Mercurial > libavcodec.hg
annotate get_bits.h @ 10398:11b685acd280 libavcodec
Print a warning message when avcodec_default_free_buffers finds unreleased
buffers, this hopefully should help detect codecs that do not release all
buffers e.g. in the decode_end function.
author | reimar |
---|---|
date | Tue, 13 Oct 2009 20:48:51 +0000 |
parents | fd9dfd5aa5e9 |
children | bdf4a9ca162a |
rev | line source |
---|---|
9428 | 1 /* |
2 * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at> | |
3 * | |
4 * This file is part of FFmpeg. | |
5 * | |
6 * FFmpeg is free software; you can redistribute it and/or | |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2.1 of the License, or (at your option) any later version. | |
10 * | |
11 * FFmpeg is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 * Lesser General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU Lesser General Public | |
17 * License along with FFmpeg; if not, write to the Free Software | |
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
19 */ | |
20 | |
21 /** | |
22 * @file libavcodec/get_bits.h | |
23 * bitstream reader API header. | |
24 */ | |
25 | |
26 #ifndef AVCODEC_GET_BITS_H | |
27 #define AVCODEC_GET_BITS_H | |
28 | |
29 #include <stdint.h> | |
30 #include <stdlib.h> | |
31 #include <assert.h> | |
32 #include "libavutil/bswap.h" | |
33 #include "libavutil/common.h" | |
34 #include "libavutil/intreadwrite.h" | |
35 #include "libavutil/log.h" | |
36 #include "mathops.h" | |
37 | |
38 #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER) | |
39 # define ALT_BITSTREAM_READER | |
40 #endif | |
41 | |
42 #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER) | |
43 # if ARCH_ARM | |
44 # define A32_BITSTREAM_READER | |
45 # else | |
46 # define ALT_BITSTREAM_READER | |
47 //#define LIBMPEG2_BITSTREAM_READER | |
48 //#define A32_BITSTREAM_READER | |
49 # endif | |
50 #endif | |
51 | |
52 extern const uint8_t ff_reverse[256]; | |
53 | |
54 #if ARCH_X86 | |
55 // avoid +32 for shift optimization (gcc should do that ...) | |
56 static inline int32_t NEG_SSR32( int32_t a, int8_t s){ | |
57 __asm__ ("sarl %1, %0\n\t" | |
58 : "+r" (a) | |
59 : "ic" ((uint8_t)(-s)) | |
60 ); | |
61 return a; | |
62 } | |
63 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){ | |
64 __asm__ ("shrl %1, %0\n\t" | |
65 : "+r" (a) | |
66 : "ic" ((uint8_t)(-s)) | |
67 ); | |
68 return a; | |
69 } | |
70 #else | |
71 # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s))) | |
72 # define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s))) | |
73 #endif | |
74 | |
75 /* bit input */ | |
76 /* buffer, buffer_end and size_in_bits must be present and used by every reader */ | |
77 typedef struct GetBitContext { | |
78 const uint8_t *buffer, *buffer_end; | |
79 #ifdef ALT_BITSTREAM_READER | |
80 int index; | |
81 #elif defined LIBMPEG2_BITSTREAM_READER | |
82 uint8_t *buffer_ptr; | |
83 uint32_t cache; | |
84 int bit_count; | |
85 #elif defined A32_BITSTREAM_READER | |
86 uint32_t *buffer_ptr; | |
87 uint32_t cache0; | |
88 uint32_t cache1; | |
89 int bit_count; | |
90 #endif | |
91 int size_in_bits; | |
92 } GetBitContext; | |
93 | |
94 #define VLC_TYPE int16_t | |
95 | |
96 typedef struct VLC { | |
97 int bits; | |
98 VLC_TYPE (*table)[2]; ///< code, bits | |
99 int table_size, table_allocated; | |
100 } VLC; | |
101 | |
102 typedef struct RL_VLC_ELEM { | |
103 int16_t level; | |
104 int8_t len; | |
105 uint8_t run; | |
106 } RL_VLC_ELEM; | |
107 | |
108 /* Bitstream reader API docs: | |
109 name | |
110 arbitrary name which is used as prefix for the internal variables | |
111 | |
112 gb | |
113 getbitcontext | |
114 | |
115 OPEN_READER(name, gb) | |
116 loads gb into local variables | |
117 | |
118 CLOSE_READER(name, gb) | |
119 stores local vars in gb | |
120 | |
121 UPDATE_CACHE(name, gb) | |
122 refills the internal cache from the bitstream | |
123 after this call at least MIN_CACHE_BITS will be available, | |
124 | |
125 GET_CACHE(name, gb) | |
126 will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit) | |
127 | |
128 SHOW_UBITS(name, gb, num) | |
129 will return the next num bits | |
130 | |
131 SHOW_SBITS(name, gb, num) | |
132 will return the next num bits and do sign extension | |
133 | |
134 SKIP_BITS(name, gb, num) | |
135 will skip over the next num bits | |
136 note, this is equivalent to SKIP_CACHE; SKIP_COUNTER | |
137 | |
138 SKIP_CACHE(name, gb, num) | |
139 will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER) | |
140 | |
141 SKIP_COUNTER(name, gb, num) | |
142 will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS) | |
143 | |
144 LAST_SKIP_CACHE(name, gb, num) | |
145 will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing | |
146 | |
147 LAST_SKIP_BITS(name, gb, num) | |
10163 | 148 is equivalent to LAST_SKIP_CACHE; SKIP_COUNTER |
9428 | 149 |
150 for examples see get_bits, show_bits, skip_bits, get_vlc | |
151 */ | |
152 | |
153 #ifdef ALT_BITSTREAM_READER | |
154 # define MIN_CACHE_BITS 25 | |
155 | |
156 # define OPEN_READER(name, gb)\ | |
157 int name##_index= (gb)->index;\ | |
158 int name##_cache= 0;\ | |
159 | |
160 # define CLOSE_READER(name, gb)\ | |
161 (gb)->index= name##_index;\ | |
162 | |
163 # ifdef ALT_BITSTREAM_READER_LE | |
164 # define UPDATE_CACHE(name, gb)\ | |
165 name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\ | |
166 | |
167 # define SKIP_CACHE(name, gb, num)\ | |
168 name##_cache >>= (num); | |
169 # else | |
170 # define UPDATE_CACHE(name, gb)\ | |
171 name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\ | |
172 | |
173 # define SKIP_CACHE(name, gb, num)\ | |
174 name##_cache <<= (num); | |
175 # endif | |
176 | |
177 // FIXME name? | |
178 # define SKIP_COUNTER(name, gb, num)\ | |
179 name##_index += (num);\ | |
180 | |
181 # define SKIP_BITS(name, gb, num)\ | |
182 {\ | |
183 SKIP_CACHE(name, gb, num)\ | |
184 SKIP_COUNTER(name, gb, num)\ | |
185 }\ | |
186 | |
187 # define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num) | |
188 # define LAST_SKIP_CACHE(name, gb, num) ; | |
189 | |
190 # ifdef ALT_BITSTREAM_READER_LE | |
191 # define SHOW_UBITS(name, gb, num)\ | |
192 ((name##_cache) & (NEG_USR32(0xffffffff,num))) | |
193 | |
194 # define SHOW_SBITS(name, gb, num)\ | |
195 NEG_SSR32((name##_cache)<<(32-(num)), num) | |
196 # else | |
197 # define SHOW_UBITS(name, gb, num)\ | |
198 NEG_USR32(name##_cache, num) | |
199 | |
200 # define SHOW_SBITS(name, gb, num)\ | |
201 NEG_SSR32(name##_cache, num) | |
202 # endif | |
203 | |
204 # define GET_CACHE(name, gb)\ | |
205 ((uint32_t)name##_cache) | |
206 | |
207 static inline int get_bits_count(GetBitContext *s){ | |
208 return s->index; | |
209 } | |
210 | |
211 static inline void skip_bits_long(GetBitContext *s, int n){ | |
212 s->index += n; | |
213 } | |
214 | |
215 #elif defined LIBMPEG2_BITSTREAM_READER | |
216 //libmpeg2 like reader | |
217 | |
218 # define MIN_CACHE_BITS 17 | |
219 | |
220 # define OPEN_READER(name, gb)\ | |
221 int name##_bit_count=(gb)->bit_count;\ | |
222 int name##_cache= (gb)->cache;\ | |
223 uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\ | |
224 | |
225 # define CLOSE_READER(name, gb)\ | |
226 (gb)->bit_count= name##_bit_count;\ | |
227 (gb)->cache= name##_cache;\ | |
228 (gb)->buffer_ptr= name##_buffer_ptr;\ | |
229 | |
230 # define UPDATE_CACHE(name, gb)\ | |
231 if(name##_bit_count >= 0){\ | |
232 name##_cache+= AV_RB16(name##_buffer_ptr) << name##_bit_count; \ | |
233 name##_buffer_ptr+=2;\ | |
234 name##_bit_count-= 16;\ | |
235 }\ | |
236 | |
237 # define SKIP_CACHE(name, gb, num)\ | |
238 name##_cache <<= (num);\ | |
239 | |
240 # define SKIP_COUNTER(name, gb, num)\ | |
241 name##_bit_count += (num);\ | |
242 | |
243 # define SKIP_BITS(name, gb, num)\ | |
244 {\ | |
245 SKIP_CACHE(name, gb, num)\ | |
246 SKIP_COUNTER(name, gb, num)\ | |
247 }\ | |
248 | |
249 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) | |
250 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) | |
251 | |
252 # define SHOW_UBITS(name, gb, num)\ | |
253 NEG_USR32(name##_cache, num) | |
254 | |
255 # define SHOW_SBITS(name, gb, num)\ | |
256 NEG_SSR32(name##_cache, num) | |
257 | |
258 # define GET_CACHE(name, gb)\ | |
259 ((uint32_t)name##_cache) | |
260 | |
261 static inline int get_bits_count(GetBitContext *s){ | |
262 return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count; | |
263 } | |
264 | |
265 static inline void skip_bits_long(GetBitContext *s, int n){ | |
266 OPEN_READER(re, s) | |
267 re_bit_count += n; | |
268 re_buffer_ptr += 2*(re_bit_count>>4); | |
269 re_bit_count &= 15; | |
270 re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count); | |
271 UPDATE_CACHE(re, s) | |
272 CLOSE_READER(re, s) | |
273 } | |
274 | |
275 #elif defined A32_BITSTREAM_READER | |
276 | |
277 # define MIN_CACHE_BITS 32 | |
278 | |
279 # define OPEN_READER(name, gb)\ | |
280 int name##_bit_count=(gb)->bit_count;\ | |
281 uint32_t name##_cache0= (gb)->cache0;\ | |
282 uint32_t name##_cache1= (gb)->cache1;\ | |
283 uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\ | |
284 | |
285 # define CLOSE_READER(name, gb)\ | |
286 (gb)->bit_count= name##_bit_count;\ | |
287 (gb)->cache0= name##_cache0;\ | |
288 (gb)->cache1= name##_cache1;\ | |
289 (gb)->buffer_ptr= name##_buffer_ptr;\ | |
290 | |
291 # define UPDATE_CACHE(name, gb)\ | |
292 if(name##_bit_count > 0){\ | |
293 const uint32_t next= be2me_32( *name##_buffer_ptr );\ | |
294 name##_cache0 |= NEG_USR32(next,name##_bit_count);\ | |
295 name##_cache1 |= next<<name##_bit_count;\ | |
296 name##_buffer_ptr++;\ | |
297 name##_bit_count-= 32;\ | |
298 }\ | |
299 | |
300 #if ARCH_X86 | |
301 # define SKIP_CACHE(name, gb, num)\ | |
302 __asm__(\ | |
303 "shldl %2, %1, %0 \n\t"\ | |
304 "shll %2, %1 \n\t"\ | |
305 : "+r" (name##_cache0), "+r" (name##_cache1)\ | |
306 : "Ic" ((uint8_t)(num))\ | |
307 ); | |
308 #else | |
309 # define SKIP_CACHE(name, gb, num)\ | |
310 name##_cache0 <<= (num);\ | |
311 name##_cache0 |= NEG_USR32(name##_cache1,num);\ | |
312 name##_cache1 <<= (num); | |
313 #endif | |
314 | |
315 # define SKIP_COUNTER(name, gb, num)\ | |
316 name##_bit_count += (num);\ | |
317 | |
318 # define SKIP_BITS(name, gb, num)\ | |
319 {\ | |
320 SKIP_CACHE(name, gb, num)\ | |
321 SKIP_COUNTER(name, gb, num)\ | |
322 }\ | |
323 | |
324 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) | |
325 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) | |
326 | |
327 # define SHOW_UBITS(name, gb, num)\ | |
328 NEG_USR32(name##_cache0, num) | |
329 | |
330 # define SHOW_SBITS(name, gb, num)\ | |
331 NEG_SSR32(name##_cache0, num) | |
332 | |
333 # define GET_CACHE(name, gb)\ | |
334 (name##_cache0) | |
335 | |
336 static inline int get_bits_count(GetBitContext *s){ | |
337 return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count; | |
338 } | |
339 | |
340 static inline void skip_bits_long(GetBitContext *s, int n){ | |
341 OPEN_READER(re, s) | |
342 re_bit_count += n; | |
343 re_buffer_ptr += re_bit_count>>5; | |
344 re_bit_count &= 31; | |
345 re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count; | |
346 re_cache1 = 0; | |
347 UPDATE_CACHE(re, s) | |
348 CLOSE_READER(re, s) | |
349 } | |
350 | |
351 #endif | |
352 | |
353 /** | |
354 * read mpeg1 dc style vlc (sign bit + mantisse with no MSB). | |
355 * if MSB not set it is negative | |
356 * @param n length in bits | |
357 * @author BERO | |
358 */ | |
359 static inline int get_xbits(GetBitContext *s, int n){ | |
360 register int sign; | |
361 register int32_t cache; | |
362 OPEN_READER(re, s) | |
363 UPDATE_CACHE(re, s) | |
364 cache = GET_CACHE(re,s); | |
365 sign=(~cache)>>31; | |
366 LAST_SKIP_BITS(re, s, n) | |
367 CLOSE_READER(re, s) | |
368 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign; | |
369 } | |
370 | |
371 static inline int get_sbits(GetBitContext *s, int n){ | |
372 register int tmp; | |
373 OPEN_READER(re, s) | |
374 UPDATE_CACHE(re, s) | |
375 tmp= SHOW_SBITS(re, s, n); | |
376 LAST_SKIP_BITS(re, s, n) | |
377 CLOSE_READER(re, s) | |
378 return tmp; | |
379 } | |
380 | |
381 /** | |
382 * reads 1-17 bits. | |
383 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't | |
384 */ | |
385 static inline unsigned int get_bits(GetBitContext *s, int n){ | |
386 register int tmp; | |
387 OPEN_READER(re, s) | |
388 UPDATE_CACHE(re, s) | |
389 tmp= SHOW_UBITS(re, s, n); | |
390 LAST_SKIP_BITS(re, s, n) | |
391 CLOSE_READER(re, s) | |
392 return tmp; | |
393 } | |
394 | |
395 /** | |
396 * shows 1-17 bits. | |
397 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't | |
398 */ | |
399 static inline unsigned int show_bits(GetBitContext *s, int n){ | |
400 register int tmp; | |
401 OPEN_READER(re, s) | |
402 UPDATE_CACHE(re, s) | |
403 tmp= SHOW_UBITS(re, s, n); | |
404 // CLOSE_READER(re, s) | |
405 return tmp; | |
406 } | |
407 | |
408 static inline void skip_bits(GetBitContext *s, int n){ | |
409 //Note gcc seems to optimize this to s->index+=n for the ALT_READER :)) | |
410 OPEN_READER(re, s) | |
411 UPDATE_CACHE(re, s) | |
412 LAST_SKIP_BITS(re, s, n) | |
413 CLOSE_READER(re, s) | |
414 } | |
415 | |
416 static inline unsigned int get_bits1(GetBitContext *s){ | |
417 #ifdef ALT_BITSTREAM_READER | |
418 int index= s->index; | |
419 uint8_t result= s->buffer[ index>>3 ]; | |
420 #ifdef ALT_BITSTREAM_READER_LE | |
421 result>>= (index&0x07); | |
422 result&= 1; | |
423 #else | |
424 result<<= (index&0x07); | |
425 result>>= 8 - 1; | |
426 #endif | |
427 index++; | |
428 s->index= index; | |
429 | |
430 return result; | |
431 #else | |
432 return get_bits(s, 1); | |
433 #endif | |
434 } | |
435 | |
436 static inline unsigned int show_bits1(GetBitContext *s){ | |
437 return show_bits(s, 1); | |
438 } | |
439 | |
440 static inline void skip_bits1(GetBitContext *s){ | |
441 skip_bits(s, 1); | |
442 } | |
443 | |
444 /** | |
445 * reads 0-32 bits. | |
446 */ | |
447 static inline unsigned int get_bits_long(GetBitContext *s, int n){ | |
448 if(n<=17) return get_bits(s, n); | |
449 else{ | |
450 #ifdef ALT_BITSTREAM_READER_LE | |
451 int ret= get_bits(s, 16); | |
452 return ret | (get_bits(s, n-16) << 16); | |
453 #else | |
454 int ret= get_bits(s, 16) << (n-16); | |
455 return ret | get_bits(s, n-16); | |
456 #endif | |
457 } | |
458 } | |
459 | |
460 /** | |
461 * reads 0-32 bits as a signed integer. | |
462 */ | |
463 static inline int get_sbits_long(GetBitContext *s, int n) { | |
464 return sign_extend(get_bits_long(s, n), n); | |
465 } | |
466 | |
467 /** | |
468 * shows 0-32 bits. | |
469 */ | |
470 static inline unsigned int show_bits_long(GetBitContext *s, int n){ | |
471 if(n<=17) return show_bits(s, n); | |
472 else{ | |
473 GetBitContext gb= *s; | |
474 return get_bits_long(&gb, n); | |
475 } | |
476 } | |
477 | |
478 static inline int check_marker(GetBitContext *s, const char *msg) | |
479 { | |
480 int bit= get_bits1(s); | |
481 if(!bit) | |
482 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg); | |
483 | |
484 return bit; | |
485 } | |
486 | |
487 /** | |
488 * init GetBitContext. | |
489 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits | |
490 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end | |
491 * @param bit_size the size of the buffer in bits | |
10148
732dfbf67524
Try to clarify that anyone using get_bits must check for buffer overrun
reimar
parents:
9428
diff
changeset
|
492 * |
732dfbf67524
Try to clarify that anyone using get_bits must check for buffer overrun
reimar
parents:
9428
diff
changeset
|
493 * While GetBitContext stores the buffer size, for performance reasons you are |
732dfbf67524
Try to clarify that anyone using get_bits must check for buffer overrun
reimar
parents:
9428
diff
changeset
|
494 * responsible for checking for the buffer end yourself (take advantage of the padding)! |
9428 | 495 */ |
496 static inline void init_get_bits(GetBitContext *s, | |
497 const uint8_t *buffer, int bit_size) | |
498 { | |
499 int buffer_size= (bit_size+7)>>3; | |
500 if(buffer_size < 0 || bit_size < 0) { | |
501 buffer_size = bit_size = 0; | |
502 buffer = NULL; | |
503 } | |
504 | |
505 s->buffer= buffer; | |
506 s->size_in_bits= bit_size; | |
507 s->buffer_end= buffer + buffer_size; | |
508 #ifdef ALT_BITSTREAM_READER | |
509 s->index=0; | |
510 #elif defined LIBMPEG2_BITSTREAM_READER | |
511 s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1)); | |
512 s->bit_count = 16 + 8*((intptr_t)buffer&1); | |
513 skip_bits_long(s, 0); | |
514 #elif defined A32_BITSTREAM_READER | |
515 s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3)); | |
516 s->bit_count = 32 + 8*((intptr_t)buffer&3); | |
517 skip_bits_long(s, 0); | |
518 #endif | |
519 } | |
520 | |
521 static inline void align_get_bits(GetBitContext *s) | |
522 { | |
523 int n= (-get_bits_count(s)) & 7; | |
524 if(n) skip_bits(s, n); | |
525 } | |
526 | |
527 #define init_vlc(vlc, nb_bits, nb_codes,\ | |
528 bits, bits_wrap, bits_size,\ | |
529 codes, codes_wrap, codes_size,\ | |
530 flags)\ | |
531 init_vlc_sparse(vlc, nb_bits, nb_codes,\ | |
532 bits, bits_wrap, bits_size,\ | |
533 codes, codes_wrap, codes_size,\ | |
534 NULL, 0, 0, flags) | |
535 | |
536 int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, | |
537 const void *bits, int bits_wrap, int bits_size, | |
538 const void *codes, int codes_wrap, int codes_size, | |
539 const void *symbols, int symbols_wrap, int symbols_size, | |
540 int flags); | |
541 #define INIT_VLC_LE 2 | |
542 #define INIT_VLC_USE_NEW_STATIC 4 | |
543 void free_vlc(VLC *vlc); | |
544 | |
545 #define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size)\ | |
546 {\ | |
547 static VLC_TYPE table[static_size][2];\ | |
548 (vlc)->table= table;\ | |
549 (vlc)->table_allocated= static_size;\ | |
550 init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);\ | |
551 } | |
552 | |
553 | |
554 /** | |
555 * | |
556 * if the vlc code is invalid and max_depth=1 than no bits will be removed | |
557 * if the vlc code is invalid and max_depth>1 than the number of bits removed | |
558 * is undefined | |
559 */ | |
560 #define GET_VLC(code, name, gb, table, bits, max_depth)\ | |
561 {\ | |
562 int n, index, nb_bits;\ | |
563 \ | |
564 index= SHOW_UBITS(name, gb, bits);\ | |
565 code = table[index][0];\ | |
566 n = table[index][1];\ | |
567 \ | |
568 if(max_depth > 1 && n < 0){\ | |
569 LAST_SKIP_BITS(name, gb, bits)\ | |
570 UPDATE_CACHE(name, gb)\ | |
571 \ | |
572 nb_bits = -n;\ | |
573 \ | |
574 index= SHOW_UBITS(name, gb, nb_bits) + code;\ | |
575 code = table[index][0];\ | |
576 n = table[index][1];\ | |
577 if(max_depth > 2 && n < 0){\ | |
578 LAST_SKIP_BITS(name, gb, nb_bits)\ | |
579 UPDATE_CACHE(name, gb)\ | |
580 \ | |
581 nb_bits = -n;\ | |
582 \ | |
583 index= SHOW_UBITS(name, gb, nb_bits) + code;\ | |
584 code = table[index][0];\ | |
585 n = table[index][1];\ | |
586 }\ | |
587 }\ | |
588 SKIP_BITS(name, gb, n)\ | |
589 } | |
590 | |
591 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\ | |
592 {\ | |
593 int n, index, nb_bits;\ | |
594 \ | |
595 index= SHOW_UBITS(name, gb, bits);\ | |
596 level = table[index].level;\ | |
597 n = table[index].len;\ | |
598 \ | |
599 if(max_depth > 1 && n < 0){\ | |
600 SKIP_BITS(name, gb, bits)\ | |
601 if(need_update){\ | |
602 UPDATE_CACHE(name, gb)\ | |
603 }\ | |
604 \ | |
605 nb_bits = -n;\ | |
606 \ | |
607 index= SHOW_UBITS(name, gb, nb_bits) + level;\ | |
608 level = table[index].level;\ | |
609 n = table[index].len;\ | |
610 }\ | |
611 run= table[index].run;\ | |
612 SKIP_BITS(name, gb, n)\ | |
613 } | |
614 | |
615 | |
616 /** | |
617 * parses a vlc code, faster then get_vlc() | |
618 * @param bits is the number of bits which will be read at once, must be | |
619 * identical to nb_bits in init_vlc() | |
620 * @param max_depth is the number of times bits bits must be read to completely | |
621 * read the longest vlc code | |
622 * = (max_vlc_length + bits - 1) / bits | |
623 */ | |
624 static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2], | |
625 int bits, int max_depth) | |
626 { | |
627 int code; | |
628 | |
629 OPEN_READER(re, s) | |
630 UPDATE_CACHE(re, s) | |
631 | |
632 GET_VLC(code, re, s, table, bits, max_depth) | |
633 | |
634 CLOSE_READER(re, s) | |
635 return code; | |
636 } | |
637 | |
638 //#define TRACE | |
639 | |
640 #ifdef TRACE | |
641 static inline void print_bin(int bits, int n){ | |
642 int i; | |
643 | |
644 for(i=n-1; i>=0; i--){ | |
645 av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1); | |
646 } | |
647 for(i=n; i<24; i++) | |
648 av_log(NULL, AV_LOG_DEBUG, " "); | |
649 } | |
650 | |
651 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ | |
652 int r= get_bits(s, n); | |
653 | |
654 print_bin(r, n); | |
655 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line); | |
656 return r; | |
657 } | |
658 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){ | |
659 int show= show_bits(s, 24); | |
660 int pos= get_bits_count(s); | |
661 int r= get_vlc2(s, table, bits, max_depth); | |
662 int len= get_bits_count(s) - pos; | |
663 int bits2= show>>(24-len); | |
664 | |
665 print_bin(bits2, len); | |
666 | |
667 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line); | |
668 return r; | |
669 } | |
670 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ | |
671 int show= show_bits(s, n); | |
672 int r= get_xbits(s, n); | |
673 | |
674 print_bin(show, n); | |
675 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line); | |
676 return r; | |
677 } | |
678 | |
679 #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
680 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
681 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
682 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
683 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
684 | |
685 #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__) | |
686 | |
687 #else //TRACE | |
688 #define tprintf(p, ...) {} | |
689 #endif | |
690 | |
691 static inline int decode012(GetBitContext *gb){ | |
692 int n; | |
693 n = get_bits1(gb); | |
694 if (n == 0) | |
695 return 0; | |
696 else | |
697 return get_bits1(gb) + 1; | |
698 } | |
699 | |
700 static inline int decode210(GetBitContext *gb){ | |
701 if (get_bits1(gb)) | |
702 return 0; | |
703 else | |
704 return 2 - get_bits1(gb); | |
705 } | |
706 | |
707 #endif /* AVCODEC_GET_BITS_H */ |