Mercurial > libavcodec.hg
comparison common.c @ 520:19a5e2a81e1a libavcodec
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
minor optimizations to get_vlc
author | michaelni |
---|---|
date | Tue, 09 Jul 2002 10:35:10 +0000 |
parents | 5b33d11bd1fb |
children | 3e579fbef701 |
comparison
equal
deleted
inserted
replaced
519:55b4e2248a45 | 520:19a5e2a81e1a |
---|---|
116 put_bits(pbc, 8, 0); | 116 put_bits(pbc, 8, 0); |
117 } | 117 } |
118 | 118 |
119 /* bit input functions */ | 119 /* bit input functions */ |
120 | 120 |
121 void init_get_bits(GetBitContext *s, | 121 void init_get_bits(GetBitContext *s, |
122 UINT8 *buffer, int buffer_size) | 122 UINT8 *buffer, int buffer_size) |
123 { | 123 { |
124 s->buffer= buffer; | |
125 s->size= buffer_size; | |
126 s->buffer_end= buffer + buffer_size; | |
124 #ifdef ALT_BITSTREAM_READER | 127 #ifdef ALT_BITSTREAM_READER |
125 s->index=0; | 128 s->index=0; |
126 s->buffer= buffer; | 129 #elif defined LIBMPEG2_BITSTREAM_READER |
127 #else | 130 s->buffer_ptr = buffer; |
128 s->buf = buffer; | 131 s->bit_count = 16; |
129 s->buf_ptr = buffer; | 132 s->cache = 0; |
130 s->buf_end = buffer + buffer_size; | 133 #elif defined A32_BITSTREAM_READER |
131 s->bit_cnt = 0; | 134 s->buffer_ptr = (uint32_t*)buffer; |
132 s->bit_buf = 0; | 135 s->bit_count = 32; |
133 while (s->buf_ptr < s->buf_end && | 136 s->cache0 = 0; |
134 s->bit_cnt < 32) { | 137 s->cache1 = 0; |
135 s->bit_buf |= (*s->buf_ptr++ << (24 - s->bit_cnt)); | 138 #endif |
136 s->bit_cnt += 8; | |
137 } | |
138 #endif | |
139 s->size= buffer_size; | |
140 } | |
141 | |
142 #ifndef ALT_BITSTREAM_READER | |
143 /* n must be >= 1 and <= 32 */ | |
144 /* also true: n > s->bit_cnt */ | |
145 unsigned int get_bits_long(GetBitContext *s, int n) | |
146 { | |
147 unsigned int val; | |
148 int bit_cnt; | |
149 unsigned int bit_buf; | |
150 | |
151 #ifdef STATS | |
152 st_bit_counts[st_current_index] += n; | |
153 #endif | |
154 | |
155 bit_buf = s->bit_buf; | |
156 bit_cnt = s->bit_cnt - n; | |
157 | |
158 // if (bit_cnt >= 0) { | |
159 // val = bit_buf >> (32 - n); | |
160 // bit_buf <<= n; | |
161 // } else | |
162 { | 139 { |
163 UINT8 *buf_ptr; | 140 OPEN_READER(re, s) |
164 val = bit_buf >> (32 - n); | 141 UPDATE_CACHE(re, s) |
165 buf_ptr = s->buf_ptr; | 142 // UPDATE_CACHE(re, s) |
166 buf_ptr += 4; | 143 CLOSE_READER(re, s) |
167 /* handle common case: we can read everything */ | 144 } |
168 if (buf_ptr <= s->buf_end) { | 145 #ifdef A32_BITSTREAM_READER |
169 #ifdef ARCH_X86 | 146 s->cache1 = 0; |
170 bit_buf = bswap_32(*((unsigned long*)(&buf_ptr[-4]))); | 147 #endif |
171 #else | 148 } |
172 bit_buf = (buf_ptr[-4] << 24) | | |
173 (buf_ptr[-3] << 16) | | |
174 (buf_ptr[-2] << 8) | | |
175 (buf_ptr[-1]); | |
176 #endif | |
177 val |= bit_buf >> (32 + bit_cnt); | |
178 bit_buf <<= - bit_cnt; | |
179 bit_cnt += 32; | |
180 } else { | |
181 buf_ptr -= 4; | |
182 bit_buf = 0; | |
183 if (buf_ptr < s->buf_end) | |
184 bit_buf |= *buf_ptr++ << 24; | |
185 if (buf_ptr < s->buf_end) | |
186 bit_buf |= *buf_ptr++ << 16; | |
187 if (buf_ptr < s->buf_end) | |
188 bit_buf |= *buf_ptr++ << 8; | |
189 if (buf_ptr < s->buf_end) | |
190 bit_buf |= *buf_ptr++; | |
191 | |
192 val |= bit_buf >> (32 + bit_cnt); | |
193 bit_buf <<= - bit_cnt; | |
194 bit_cnt += 8*(buf_ptr - s->buf_ptr); | |
195 if(bit_cnt<0) bit_cnt=0; | |
196 } | |
197 s->buf_ptr = buf_ptr; | |
198 } | |
199 s->bit_buf = bit_buf; | |
200 s->bit_cnt = bit_cnt; | |
201 return val; | |
202 } | |
203 #endif | |
204 | 149 |
205 void align_get_bits(GetBitContext *s) | 150 void align_get_bits(GetBitContext *s) |
206 { | 151 { |
207 #ifdef ALT_BITSTREAM_READER | 152 int n= (-get_bits_count(s)) & 7; |
208 s->index= (s->index + 7) & (~7); | 153 if(n) skip_bits(s, n); |
209 #else | |
210 int n; | |
211 n = s->bit_cnt & 7; | |
212 if (n > 0) { | |
213 get_bits(s, n); | |
214 } | |
215 #endif | |
216 } | 154 } |
217 | 155 |
218 int check_marker(GetBitContext *s, char *msg) | 156 int check_marker(GetBitContext *s, char *msg) |
219 { | 157 { |
220 int bit= get_bits1(s); | 158 int bit= get_bits1(s); |
221 if(!bit) printf("Marker bit missing %s\n", msg); | 159 if(!bit) printf("Marker bit missing %s\n", msg); |
222 | 160 |
223 return bit; | 161 return bit; |
224 } | 162 } |
225 | |
226 #ifndef ALT_BITSTREAM_READER | |
227 /* This function is identical to get_bits_long(), the */ | |
228 /* only diference is that it doesn't touch the buffer */ | |
229 /* it is usefull to see the buffer. */ | |
230 | |
231 unsigned int show_bits_long(GetBitContext *s, int n) | |
232 { | |
233 unsigned int val; | |
234 int bit_cnt; | |
235 unsigned int bit_buf; | |
236 UINT8 *buf_ptr; | |
237 | |
238 bit_buf = s->bit_buf; | |
239 bit_cnt = s->bit_cnt - n; | |
240 | |
241 val = bit_buf >> (32 - n); | |
242 buf_ptr = s->buf_ptr; | |
243 buf_ptr += 4; | |
244 | |
245 /* handle common case: we can read everything */ | |
246 if (buf_ptr <= s->buf_end) { | |
247 #ifdef ARCH_X86 | |
248 bit_buf = bswap_32(*((unsigned long*)(&buf_ptr[-4]))); | |
249 #else | |
250 bit_buf = (buf_ptr[-4] << 24) | | |
251 (buf_ptr[-3] << 16) | | |
252 (buf_ptr[-2] << 8) | | |
253 (buf_ptr[-1]); | |
254 #endif | |
255 } else { | |
256 buf_ptr -= 4; | |
257 bit_buf = 0; | |
258 if (buf_ptr < s->buf_end) | |
259 bit_buf |= *buf_ptr++ << 24; | |
260 if (buf_ptr < s->buf_end) | |
261 bit_buf |= *buf_ptr++ << 16; | |
262 if (buf_ptr < s->buf_end) | |
263 bit_buf |= *buf_ptr++ << 8; | |
264 if (buf_ptr < s->buf_end) | |
265 bit_buf |= *buf_ptr++; | |
266 } | |
267 val |= bit_buf >> (32 + bit_cnt); | |
268 bit_buf <<= - bit_cnt; | |
269 bit_cnt += 32; | |
270 | |
271 return val; | |
272 } | |
273 #endif | |
274 | 163 |
275 /* VLC decoding */ | 164 /* VLC decoding */ |
276 | 165 |
277 //#define DEBUG_VLC | 166 //#define DEBUG_VLC |
278 | 167 |
298 int index; | 187 int index; |
299 index = vlc->table_size; | 188 index = vlc->table_size; |
300 vlc->table_size += size; | 189 vlc->table_size += size; |
301 if (vlc->table_size > vlc->table_allocated) { | 190 if (vlc->table_size > vlc->table_allocated) { |
302 vlc->table_allocated += (1 << vlc->bits); | 191 vlc->table_allocated += (1 << vlc->bits); |
303 vlc->table_bits = realloc(vlc->table_bits, | 192 vlc->table = realloc(vlc->table, |
304 sizeof(INT8) * vlc->table_allocated); | 193 sizeof(VLC_TYPE) * 2 * vlc->table_allocated); |
305 vlc->table_codes = realloc(vlc->table_codes, | 194 if (!vlc->table) |
306 sizeof(INT16) * vlc->table_allocated); | |
307 if (!vlc->table_bits || | |
308 !vlc->table_codes) | |
309 return -1; | 195 return -1; |
310 } | 196 } |
311 return index; | 197 return index; |
312 } | 198 } |
313 | 199 |
314 static int build_table(VLC *vlc, int table_nb_bits, | 200 static int build_table(VLC *vlc, int table_nb_bits, |
315 int nb_codes, | 201 int nb_codes, |
316 const void *bits, int bits_wrap, int bits_size, | 202 const void *bits, int bits_wrap, int bits_size, |
317 const void *codes, int codes_wrap, int codes_size, | 203 const void *codes, int codes_wrap, int codes_size, |
318 UINT32 code_prefix, int n_prefix) | 204 UINT32 code_prefix, int n_prefix) |
319 { | 205 { |
320 int i, j, k, n, table_size, table_index, nb, n1, index; | 206 int i, j, k, n, table_size, table_index, nb, n1, index; |
321 UINT32 code; | 207 UINT32 code; |
322 INT8 *table_bits; | 208 VLC_TYPE (*table)[2]; |
323 INT16 *table_codes; | |
324 | 209 |
325 table_size = 1 << table_nb_bits; | 210 table_size = 1 << table_nb_bits; |
326 table_index = alloc_table(vlc, table_size); | 211 table_index = alloc_table(vlc, table_size); |
327 #ifdef DEBUG_VLC | 212 #ifdef DEBUG_VLC |
328 printf("new table index=%d size=%d code_prefix=%x n=%d\n", | 213 printf("new table index=%d size=%d code_prefix=%x n=%d\n", |
329 table_index, table_size, code_prefix, n_prefix); | 214 table_index, table_size, code_prefix, n_prefix); |
330 #endif | 215 #endif |
331 if (table_index < 0) | 216 if (table_index < 0) |
332 return -1; | 217 return -1; |
333 table_bits = &vlc->table_bits[table_index]; | 218 table = &vlc->table[table_index]; |
334 table_codes = &vlc->table_codes[table_index]; | |
335 | 219 |
336 for(i=0;i<table_size;i++) { | 220 for(i=0;i<table_size;i++) { |
337 table_bits[i] = 0; | 221 table[i][1] = 0; //bits |
338 table_codes[i] = -1; | 222 table[i][0] = -1; //codes |
339 } | 223 } |
340 | 224 |
341 /* first pass: map codes and compute auxillary table sizes */ | 225 /* first pass: map codes and compute auxillary table sizes */ |
342 for(i=0;i<nb_codes;i++) { | 226 for(i=0;i<nb_codes;i++) { |
343 GET_DATA(n, bits, i, bits_wrap, bits_size); | 227 GET_DATA(n, bits, i, bits_wrap, bits_size); |
358 for(k=0;k<nb;k++) { | 242 for(k=0;k<nb;k++) { |
359 #ifdef DEBUG_VLC | 243 #ifdef DEBUG_VLC |
360 printf("%4x: code=%d n=%d\n", | 244 printf("%4x: code=%d n=%d\n", |
361 j, i, n); | 245 j, i, n); |
362 #endif | 246 #endif |
363 if (table_bits[j] != 0) { | 247 if (table[j][1] /*bits*/ != 0) { |
364 fprintf(stderr, "incorrect codes\n"); | 248 fprintf(stderr, "incorrect codes\n"); |
365 exit(1); | 249 exit(1); |
366 } | 250 } |
367 table_bits[j] = n; | 251 table[j][1] = n; //bits |
368 table_codes[j] = i; | 252 table[j][0] = i; //code |
369 j++; | 253 j++; |
370 } | 254 } |
371 } else { | 255 } else { |
372 n -= table_nb_bits; | 256 n -= table_nb_bits; |
373 j = (code >> n) & ((1 << table_nb_bits) - 1); | 257 j = (code >> n) & ((1 << table_nb_bits) - 1); |
374 #ifdef DEBUG_VLC | 258 #ifdef DEBUG_VLC |
375 printf("%4x: n=%d (subtable)\n", | 259 printf("%4x: n=%d (subtable)\n", |
376 j, n); | 260 j, n); |
377 #endif | 261 #endif |
378 /* compute table size */ | 262 /* compute table size */ |
379 n1 = -table_bits[j]; | 263 n1 = -table[j][1]; //bits |
380 if (n > n1) | 264 if (n > n1) |
381 n1 = n; | 265 n1 = n; |
382 table_bits[j] = -n1; | 266 table[j][1] = -n1; //bits |
383 } | 267 } |
384 } | 268 } |
385 } | 269 } |
386 | 270 |
387 /* second pass : fill auxillary tables recursively */ | 271 /* second pass : fill auxillary tables recursively */ |
388 for(i=0;i<table_size;i++) { | 272 for(i=0;i<table_size;i++) { |
389 n = table_bits[i]; | 273 n = table[i][1]; //bits |
390 if (n < 0) { | 274 if (n < 0) { |
391 n = -n; | 275 n = -n; |
392 if (n > table_nb_bits) { | 276 if (n > table_nb_bits) { |
393 n = table_nb_bits; | 277 n = table_nb_bits; |
394 table_bits[i] = -n; | 278 table[i][1] = -n; //bits |
395 } | 279 } |
396 index = build_table(vlc, n, nb_codes, | 280 index = build_table(vlc, n, nb_codes, |
397 bits, bits_wrap, bits_size, | 281 bits, bits_wrap, bits_size, |
398 codes, codes_wrap, codes_size, | 282 codes, codes_wrap, codes_size, |
399 (code_prefix << table_nb_bits) | i, | 283 (code_prefix << table_nb_bits) | i, |
400 n_prefix + table_nb_bits); | 284 n_prefix + table_nb_bits); |
401 if (index < 0) | 285 if (index < 0) |
402 return -1; | 286 return -1; |
403 /* note: realloc has been done, so reload tables */ | 287 /* note: realloc has been done, so reload tables */ |
404 table_bits = &vlc->table_bits[table_index]; | 288 table = &vlc->table[table_index]; |
405 table_codes = &vlc->table_codes[table_index]; | 289 table[i][0] = index; //code |
406 table_codes[i] = index; | |
407 } | 290 } |
408 } | 291 } |
409 return table_index; | 292 return table_index; |
410 } | 293 } |
411 | 294 |
434 int init_vlc(VLC *vlc, int nb_bits, int nb_codes, | 317 int init_vlc(VLC *vlc, int nb_bits, int nb_codes, |
435 const void *bits, int bits_wrap, int bits_size, | 318 const void *bits, int bits_wrap, int bits_size, |
436 const void *codes, int codes_wrap, int codes_size) | 319 const void *codes, int codes_wrap, int codes_size) |
437 { | 320 { |
438 vlc->bits = nb_bits; | 321 vlc->bits = nb_bits; |
439 vlc->table_bits = NULL; | 322 vlc->table = NULL; |
440 vlc->table_codes = NULL; | |
441 vlc->table_allocated = 0; | 323 vlc->table_allocated = 0; |
442 vlc->table_size = 0; | 324 vlc->table_size = 0; |
443 #ifdef DEBUG_VLC | 325 #ifdef DEBUG_VLC |
444 printf("build table nb_codes=%d\n", nb_codes); | 326 printf("build table nb_codes=%d\n", nb_codes); |
445 #endif | 327 #endif |
446 | 328 |
447 if (build_table(vlc, nb_bits, nb_codes, | 329 if (build_table(vlc, nb_bits, nb_codes, |
448 bits, bits_wrap, bits_size, | 330 bits, bits_wrap, bits_size, |
449 codes, codes_wrap, codes_size, | 331 codes, codes_wrap, codes_size, |
450 0, 0) < 0) { | 332 0, 0) < 0) { |
451 av_free(vlc->table_bits); | 333 av_free(vlc->table); |
452 av_free(vlc->table_codes); | |
453 return -1; | 334 return -1; |
454 } | 335 } |
455 return 0; | 336 return 0; |
456 } | 337 } |
457 | 338 |
458 | 339 |
459 void free_vlc(VLC *vlc) | 340 void free_vlc(VLC *vlc) |
460 { | 341 { |
461 av_free(vlc->table_bits); | 342 av_free(vlc->table); |
462 av_free(vlc->table_codes); | |
463 } | 343 } |
464 | 344 |
465 int ff_gcd(int a, int b){ | 345 int ff_gcd(int a, int b){ |
466 if(b) return ff_gcd(b, a%b); | 346 if(b) return ff_gcd(b, a%b); |
467 else return a; | 347 else return a; |