support skiping some bitstream encoding
[ffmpeg.git] / libavcodec / bitstream.h
1 /**
2  * @file bitstream.h
3  * bitstream api header.
4  */
5
6 #ifndef BITSTREAM_H
7 #define BITSTREAM_H
8
9 //#define ALT_BITSTREAM_WRITER
10 //#define ALIGNED_BITSTREAM_WRITER
11
12 #define ALT_BITSTREAM_READER
13 //#define LIBMPEG2_BITSTREAM_READER
14 //#define A32_BITSTREAM_READER
15 #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO
16  
17 #if defined(ARCH_X86) || defined(ARCH_X86_64)
18 // avoid +32 for shift optimization (gcc should do that ...)
19 static inline  int32_t NEG_SSR32( int32_t a, int8_t s){
20     asm ("sarl %1, %0\n\t"
21          : "+r" (a)
22          : "ic" ((uint8_t)(-s))
23     );
24     return a;
25 }
26 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
27     asm ("shrl %1, %0\n\t"
28          : "+r" (a)
29          : "ic" ((uint8_t)(-s))
30     );
31     return a;
32 }
33 #else
34 #    define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
35 #    define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
36 #endif
37
38 /* bit output */
39
40 /* buf and buf_end must be present and used by every alternative writer. */
41 typedef struct PutBitContext {
42 #ifdef ALT_BITSTREAM_WRITER
43     uint8_t *buf, *buf_end;
44     int index;
45 #else
46     uint32_t bit_buf;
47     int bit_left;
48     uint8_t *buf, *buf_ptr, *buf_end;
49 #endif
50 } PutBitContext;
51
52 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
53 {
54     s->buf = buffer;
55     s->buf_end = s->buf + buffer_size;
56 #ifdef ALT_BITSTREAM_WRITER
57     s->index=0;
58     ((uint32_t*)(s->buf))[0]=0;
59 //    memset(buffer, 0, buffer_size);
60 #else
61     s->buf_ptr = s->buf;
62     s->bit_left=32;
63     s->bit_buf=0;
64 #endif
65 }
66
67 /* return the number of bits output */
68 static inline int put_bits_count(PutBitContext *s)
69 {
70 #ifdef ALT_BITSTREAM_WRITER
71     return s->index;
72 #else
73     return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
74 #endif
75 }
76
77 /* pad the end of the output stream with zeros */
78 static inline void flush_put_bits(PutBitContext *s)
79 {
80 #ifdef ALT_BITSTREAM_WRITER
81     align_put_bits(s);
82 #else
83     s->bit_buf<<= s->bit_left;
84     while (s->bit_left < 32) {
85         /* XXX: should test end of buffer */
86         *s->buf_ptr++=s->bit_buf >> 24;
87         s->bit_buf<<=8;
88         s->bit_left+=8;
89     }
90     s->bit_left=32;
91     s->bit_buf=0;
92 #endif
93 }
94
95 void align_put_bits(PutBitContext *s);
96 void put_string(PutBitContext * pbc, char *s, int put_zero);
97
98 /* bit input */
99 /* buffer, buffer_end and size_in_bits must be present and used by every reader */
100 typedef struct GetBitContext {
101     const uint8_t *buffer, *buffer_end;
102 #ifdef ALT_BITSTREAM_READER
103     int index;
104 #elif defined LIBMPEG2_BITSTREAM_READER
105     uint8_t *buffer_ptr;
106     uint32_t cache;
107     int bit_count;
108 #elif defined A32_BITSTREAM_READER
109     uint32_t *buffer_ptr;
110     uint32_t cache0;
111     uint32_t cache1;
112     int bit_count;
113 #endif
114     int size_in_bits;
115 } GetBitContext;
116
117 #define VLC_TYPE int16_t
118
119 typedef struct VLC {
120     int bits;
121     VLC_TYPE (*table)[2]; ///< code, bits
122     int table_size, table_allocated;
123 } VLC;
124
125 typedef struct RL_VLC_ELEM {
126     int16_t level;
127     int8_t len;
128     uint8_t run;
129 } RL_VLC_ELEM;
130
131 #ifdef ARCH_SPARC
132 #define UNALIGNED_STORES_ARE_BAD
133 #endif
134
135 /* used to avoid missaligned exceptions on some archs (alpha, ...) */
136 #if defined(ARCH_X86) || defined(ARCH_X86_64)
137 #    define unaligned32(a) (*(const uint32_t*)(a))
138 #else
139 #    ifdef __GNUC__
140 static inline uint32_t unaligned32(const void *v) {
141     struct Unaligned {
142         uint32_t i;
143     } __attribute__((packed));
144
145     return ((const struct Unaligned *) v)->i;
146 }
147 #    elif defined(__DECC)
148 static inline uint32_t unaligned32(const void *v) {
149     return *(const __unaligned uint32_t *) v;
150 }
151 #    else
152 static inline uint32_t unaligned32(const void *v) {
153     return *(const uint32_t *) v;
154 }
155 #    endif
156 #endif //!ARCH_X86
157
158 #ifndef ALT_BITSTREAM_WRITER
159 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
160 {
161     unsigned int bit_buf;
162     int bit_left;
163
164 #ifdef STATS
165     st_out_bit_counts[st_current_index] += n;
166 #endif
167     //    printf("put_bits=%d %x\n", n, value);
168     assert(n == 32 || value < (1U << n));
169     
170     bit_buf = s->bit_buf;
171     bit_left = s->bit_left;
172
173     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
174     /* XXX: optimize */
175     if (n < bit_left) {
176         bit_buf = (bit_buf<<n) | value;
177         bit_left-=n;
178     } else {
179         bit_buf<<=bit_left;
180         bit_buf |= value >> (n - bit_left);
181 #ifdef UNALIGNED_STORES_ARE_BAD
182         if (3 & (intptr_t) s->buf_ptr) {
183             s->buf_ptr[0] = bit_buf >> 24;
184             s->buf_ptr[1] = bit_buf >> 16;
185             s->buf_ptr[2] = bit_buf >>  8;
186             s->buf_ptr[3] = bit_buf      ;
187         } else
188 #endif
189         *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
190         //printf("bitbuf = %08x\n", bit_buf);
191         s->buf_ptr+=4;
192         bit_left+=32 - n;
193         bit_buf = value;
194     }
195
196     s->bit_buf = bit_buf;
197     s->bit_left = bit_left;
198 }
199 #endif
200
201
202 #ifdef ALT_BITSTREAM_WRITER
203 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
204 {
205 #    ifdef ALIGNED_BITSTREAM_WRITER
206 #        if defined(ARCH_X86) || defined(ARCH_X86_64)
207     asm volatile(
208         "movl %0, %%ecx                 \n\t"
209         "xorl %%eax, %%eax              \n\t"
210         "shrdl %%cl, %1, %%eax          \n\t"
211         "shrl %%cl, %1                  \n\t"
212         "movl %0, %%ecx                 \n\t"
213         "shrl $3, %%ecx                 \n\t"
214         "andl $0xFFFFFFFC, %%ecx        \n\t"
215         "bswapl %1                      \n\t"
216         "orl %1, (%2, %%ecx)            \n\t"
217         "bswapl %%eax                   \n\t"
218         "addl %3, %0                    \n\t"
219         "movl %%eax, 4(%2, %%ecx)       \n\t"
220         : "=&r" (s->index), "=&r" (value)
221         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
222         : "%eax", "%ecx"
223     );
224 #        else
225     int index= s->index;
226     uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
227     
228     value<<= 32-n; 
229     
230     ptr[0] |= be2me_32(value>>(index&31));
231     ptr[1]  = be2me_32(value<<(32-(index&31)));
232 //if(n>24) printf("%d %d\n", n, value);
233     index+= n;
234     s->index= index;
235 #        endif
236 #    else //ALIGNED_BITSTREAM_WRITER
237 #        if defined(ARCH_X86) || defined(ARCH_X86_64)
238     asm volatile(
239         "movl $7, %%ecx                 \n\t"
240         "andl %0, %%ecx                 \n\t"
241         "addl %3, %%ecx                 \n\t"
242         "negl %%ecx                     \n\t"
243         "shll %%cl, %1                  \n\t"
244         "bswapl %1                      \n\t"
245         "movl %0, %%ecx                 \n\t"
246         "shrl $3, %%ecx                 \n\t"
247         "orl %1, (%%ecx, %2)            \n\t"
248         "addl %3, %0                    \n\t"
249         "movl $0, 4(%%ecx, %2)          \n\t"
250         : "=&r" (s->index), "=&r" (value)
251         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
252         : "%ecx"
253     );
254 #        else
255     int index= s->index;
256     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
257     
258     ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
259     ptr[1] = 0;
260 //if(n>24) printf("%d %d\n", n, value);
261     index+= n;
262     s->index= index;
263 #        endif
264 #    endif //!ALIGNED_BITSTREAM_WRITER
265 }
266 #endif
267
268
269 static inline uint8_t* pbBufPtr(PutBitContext *s)
270 {
271 #ifdef ALT_BITSTREAM_WRITER
272         return s->buf + (s->index>>3);
273 #else
274         return s->buf_ptr;
275 #endif
276 }
277
278 /**
279  *
280  * PutBitContext must be flushed & aligned to a byte boundary before calling this.
281  */
282 static inline void skip_put_bytes(PutBitContext *s, int n){
283         assert((put_bits_count(s)&7)==0);
284 #ifdef ALT_BITSTREAM_WRITER
285         FIXME may need some cleaning of the buffer
286         s->index += n<<3;
287 #else
288         assert(s->bit_left==32);
289         s->buf_ptr += n;
290 #endif    
291 }
292
293 /**
294  * skips the given number of bits.
295  * must only be used if the actual values in the bitstream dont matter
296  */
297 static inline void skip_put_bits(PutBitContext *s, int n){
298 #ifdef ALT_BITSTREAM_WRITER
299     s->index += n;
300 #else
301     s->bit_left -= n;
302     s->buf_ptr-= s->bit_left>>5;
303     s->bit_left &= 31;
304 #endif        
305 }
306
307 /**
308  * Changes the end of the buffer.
309  */
310 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){
311     s->buf_end= s->buf + size;
312 }
313
314 /* Bitstream reader API docs:
315 name
316     abritary name which is used as prefix for the internal variables
317
318 gb
319     getbitcontext
320
321 OPEN_READER(name, gb)
322     loads gb into local variables
323
324 CLOSE_READER(name, gb)
325     stores local vars in gb
326
327 UPDATE_CACHE(name, gb)
328     refills the internal cache from the bitstream
329     after this call at least MIN_CACHE_BITS will be available,
330
331 GET_CACHE(name, gb)
332     will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
333
334 SHOW_UBITS(name, gb, num)
335     will return the nest num bits
336
337 SHOW_SBITS(name, gb, num)
338     will return the nest num bits and do sign extension
339
340 SKIP_BITS(name, gb, num)
341     will skip over the next num bits
342     note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER
343
344 SKIP_CACHE(name, gb, num)
345     will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
346
347 SKIP_COUNTER(name, gb, num)
348     will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
349
350 LAST_SKIP_CACHE(name, gb, num)
351     will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
352
353 LAST_SKIP_BITS(name, gb, num)
354     is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER
355
356 for examples see get_bits, show_bits, skip_bits, get_vlc
357 */
358
359 static inline int unaligned32_be(const void *v)
360 {
361 #ifdef CONFIG_ALIGN
362         const uint8_t *p=v;
363         return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);
364 #else
365         return be2me_32( unaligned32(v)); //original
366 #endif
367 }
368
369 #ifdef ALT_BITSTREAM_READER
370 #   define MIN_CACHE_BITS 25
371
372 #   define OPEN_READER(name, gb)\
373         int name##_index= (gb)->index;\
374         int name##_cache= 0;\
375
376 #   define CLOSE_READER(name, gb)\
377         (gb)->index= name##_index;\
378
379 #   define UPDATE_CACHE(name, gb)\
380         name##_cache= unaligned32_be( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
381
382 #   define SKIP_CACHE(name, gb, num)\
383         name##_cache <<= (num);\
384
385 // FIXME name?
386 #   define SKIP_COUNTER(name, gb, num)\
387         name##_index += (num);\
388
389 #   define SKIP_BITS(name, gb, num)\
390         {\
391             SKIP_CACHE(name, gb, num)\
392             SKIP_COUNTER(name, gb, num)\
393         }\
394
395 #   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
396 #   define LAST_SKIP_CACHE(name, gb, num) ;
397
398 #   define SHOW_UBITS(name, gb, num)\
399         NEG_USR32(name##_cache, num)
400
401 #   define SHOW_SBITS(name, gb, num)\
402         NEG_SSR32(name##_cache, num)
403
404 #   define GET_CACHE(name, gb)\
405         ((uint32_t)name##_cache)
406
407 static inline int get_bits_count(GetBitContext *s){
408     return s->index;
409 }
410 #elif defined LIBMPEG2_BITSTREAM_READER
411 //libmpeg2 like reader
412
413 #   define MIN_CACHE_BITS 17
414
415 #   define OPEN_READER(name, gb)\
416         int name##_bit_count=(gb)->bit_count;\
417         int name##_cache= (gb)->cache;\
418         uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
419
420 #   define CLOSE_READER(name, gb)\
421         (gb)->bit_count= name##_bit_count;\
422         (gb)->cache= name##_cache;\
423         (gb)->buffer_ptr= name##_buffer_ptr;\
424
425 #ifdef LIBMPEG2_BITSTREAM_READER_HACK
426
427 #   define UPDATE_CACHE(name, gb)\
428     if(name##_bit_count >= 0){\
429         name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\
430         ((uint16_t*)name##_buffer_ptr)++;\
431         name##_bit_count-= 16;\
432     }\
433
434 #else
435
436 #   define UPDATE_CACHE(name, gb)\
437     if(name##_bit_count >= 0){\
438         name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\
439         name##_buffer_ptr+=2;\
440         name##_bit_count-= 16;\
441     }\
442
443 #endif
444
445 #   define SKIP_CACHE(name, gb, num)\
446         name##_cache <<= (num);\
447
448 #   define SKIP_COUNTER(name, gb, num)\
449         name##_bit_count += (num);\
450
451 #   define SKIP_BITS(name, gb, num)\
452         {\
453             SKIP_CACHE(name, gb, num)\
454             SKIP_COUNTER(name, gb, num)\
455         }\
456
457 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
458 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
459
460 #   define SHOW_UBITS(name, gb, num)\
461         NEG_USR32(name##_cache, num)
462
463 #   define SHOW_SBITS(name, gb, num)\
464         NEG_SSR32(name##_cache, num)
465
466 #   define GET_CACHE(name, gb)\
467         ((uint32_t)name##_cache)
468
469 static inline int get_bits_count(GetBitContext *s){
470     return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
471 }
472
473 #elif defined A32_BITSTREAM_READER
474
475 #   define MIN_CACHE_BITS 32
476
477 #   define OPEN_READER(name, gb)\
478         int name##_bit_count=(gb)->bit_count;\
479         uint32_t name##_cache0= (gb)->cache0;\
480         uint32_t name##_cache1= (gb)->cache1;\
481         uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
482
483 #   define CLOSE_READER(name, gb)\
484         (gb)->bit_count= name##_bit_count;\
485         (gb)->cache0= name##_cache0;\
486         (gb)->cache1= name##_cache1;\
487         (gb)->buffer_ptr= name##_buffer_ptr;\
488
489 #   define UPDATE_CACHE(name, gb)\
490     if(name##_bit_count > 0){\
491         const uint32_t next= be2me_32( *name##_buffer_ptr );\
492         name##_cache0 |= NEG_USR32(next,name##_bit_count);\
493         name##_cache1 |= next<<name##_bit_count;\
494         name##_buffer_ptr++;\
495         name##_bit_count-= 32;\
496     }\
497
498 #if defined(ARCH_X86) || defined(ARCH_X86_64)
499 #   define SKIP_CACHE(name, gb, num)\
500         asm(\
501             "shldl %2, %1, %0           \n\t"\
502             "shll %2, %1                \n\t"\
503             : "+r" (name##_cache0), "+r" (name##_cache1)\
504             : "Ic" ((uint8_t)num)\
505            );
506 #else
507 #   define SKIP_CACHE(name, gb, num)\
508         name##_cache0 <<= (num);\
509         name##_cache0 |= NEG_USR32(name##_cache1,num);\
510         name##_cache1 <<= (num);
511 #endif
512
513 #   define SKIP_COUNTER(name, gb, num)\
514         name##_bit_count += (num);\
515
516 #   define SKIP_BITS(name, gb, num)\
517         {\
518             SKIP_CACHE(name, gb, num)\
519             SKIP_COUNTER(name, gb, num)\
520         }\
521
522 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
523 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
524
525 #   define SHOW_UBITS(name, gb, num)\
526         NEG_USR32(name##_cache0, num)
527
528 #   define SHOW_SBITS(name, gb, num)\
529         NEG_SSR32(name##_cache0, num)
530
531 #   define GET_CACHE(name, gb)\
532         (name##_cache0)
533
534 static inline int get_bits_count(GetBitContext *s){
535     return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
536 }
537
538 #endif
539
540 /**
541  * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
542  * if MSB not set it is negative 
543  * @param n length in bits
544  * @author BERO  
545  */
546 static inline int get_xbits(GetBitContext *s, int n){
547     register int tmp;
548     register int32_t cache;
549     OPEN_READER(re, s)
550     UPDATE_CACHE(re, s)
551     cache = GET_CACHE(re,s);
552     if ((int32_t)cache<0) { //MSB=1
553         tmp = NEG_USR32(cache,n);
554     } else {
555     //   tmp = (-1<<n) | NEG_USR32(cache,n) + 1; mpeg12.c algo
556     //   tmp = - (NEG_USR32(cache,n) ^ ((1 << n) - 1)); h263.c algo
557         tmp = - NEG_USR32(~cache,n);
558     }
559     LAST_SKIP_BITS(re, s, n)
560     CLOSE_READER(re, s)
561     return tmp;
562 }
563
564 static inline int get_sbits(GetBitContext *s, int n){
565     register int tmp;
566     OPEN_READER(re, s)
567     UPDATE_CACHE(re, s)
568     tmp= SHOW_SBITS(re, s, n);
569     LAST_SKIP_BITS(re, s, n)
570     CLOSE_READER(re, s)
571     return tmp;
572 }
573
574 /**
575  * reads 0-17 bits.
576  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant
577  */
578 static inline unsigned int get_bits(GetBitContext *s, int n){
579     register int tmp;
580     OPEN_READER(re, s)
581     UPDATE_CACHE(re, s)
582     tmp= SHOW_UBITS(re, s, n);
583     LAST_SKIP_BITS(re, s, n)
584     CLOSE_READER(re, s)
585     return tmp;
586 }
587
588 unsigned int get_bits_long(GetBitContext *s, int n);
589
590 /**
591  * shows 0-17 bits.
592  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant
593  */
594 static inline unsigned int show_bits(GetBitContext *s, int n){
595     register int tmp;
596     OPEN_READER(re, s)
597     UPDATE_CACHE(re, s)
598     tmp= SHOW_UBITS(re, s, n);
599 //    CLOSE_READER(re, s)
600     return tmp;
601 }
602
603 unsigned int show_bits_long(GetBitContext *s, int n);
604
605 static inline void skip_bits(GetBitContext *s, int n){
606  //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
607     OPEN_READER(re, s)
608     UPDATE_CACHE(re, s)
609     LAST_SKIP_BITS(re, s, n)
610     CLOSE_READER(re, s)
611 }
612
613 static inline unsigned int get_bits1(GetBitContext *s){
614 #ifdef ALT_BITSTREAM_READER
615     int index= s->index;
616     uint8_t result= s->buffer[ index>>3 ];
617     result<<= (index&0x07);
618     result>>= 8 - 1;
619     index++;
620     s->index= index;
621
622     return result;
623 #else
624     return get_bits(s, 1);
625 #endif
626 }
627
628 static inline unsigned int show_bits1(GetBitContext *s){
629     return show_bits(s, 1);
630 }
631
632 static inline void skip_bits1(GetBitContext *s){
633     skip_bits(s, 1);
634 }
635
636 /**
637  * init GetBitContext.
638  * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits
639  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
640  * @param bit_size the size of the buffer in bits
641  */
642 static inline void init_get_bits(GetBitContext *s,
643                    const uint8_t *buffer, int bit_size)
644 {
645     const int buffer_size= (bit_size+7)>>3;
646
647     s->buffer= buffer;
648     s->size_in_bits= bit_size;
649     s->buffer_end= buffer + buffer_size;
650 #ifdef ALT_BITSTREAM_READER
651     s->index=0;
652 #elif defined LIBMPEG2_BITSTREAM_READER
653 #ifdef LIBMPEG2_BITSTREAM_READER_HACK
654   if ((int)buffer&1) {
655      /* word alignment */
656     s->cache = (*buffer++)<<24;
657     s->buffer_ptr = buffer;
658     s->bit_count = 16-8;
659   } else
660 #endif
661   {
662     s->buffer_ptr = buffer;
663     s->bit_count = 16;
664     s->cache = 0;
665   }
666 #elif defined A32_BITSTREAM_READER
667     s->buffer_ptr = (uint32_t*)buffer;
668     s->bit_count = 32;
669     s->cache0 = 0;
670     s->cache1 = 0;
671 #endif
672     {
673         OPEN_READER(re, s)
674         UPDATE_CACHE(re, s)
675         UPDATE_CACHE(re, s)
676         CLOSE_READER(re, s)
677     }
678 #ifdef A32_BITSTREAM_READER
679     s->cache1 = 0;
680 #endif
681 }
682
683 int check_marker(GetBitContext *s, const char *msg);
684 void align_get_bits(GetBitContext *s);
685 int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
686              const void *bits, int bits_wrap, int bits_size,
687              const void *codes, int codes_wrap, int codes_size,
688              int use_static);
689 void free_vlc(VLC *vlc);
690
691 /**
692  *
693  * if the vlc code is invalid and max_depth=1 than no bits will be removed
694  * if the vlc code is invalid and max_depth>1 than the number of bits removed
695  * is undefined
696  */
697 #define GET_VLC(code, name, gb, table, bits, max_depth)\
698 {\
699     int n, index, nb_bits;\
700 \
701     index= SHOW_UBITS(name, gb, bits);\
702     code = table[index][0];\
703     n    = table[index][1];\
704 \
705     if(max_depth > 1 && n < 0){\
706         LAST_SKIP_BITS(name, gb, bits)\
707         UPDATE_CACHE(name, gb)\
708 \
709         nb_bits = -n;\
710 \
711         index= SHOW_UBITS(name, gb, nb_bits) + code;\
712         code = table[index][0];\
713         n    = table[index][1];\
714         if(max_depth > 2 && n < 0){\
715             LAST_SKIP_BITS(name, gb, nb_bits)\
716             UPDATE_CACHE(name, gb)\
717 \
718             nb_bits = -n;\
719 \
720             index= SHOW_UBITS(name, gb, nb_bits) + code;\
721             code = table[index][0];\
722             n    = table[index][1];\
723         }\
724     }\
725     SKIP_BITS(name, gb, n)\
726 }
727
728 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\
729 {\
730     int n, index, nb_bits;\
731 \
732     index= SHOW_UBITS(name, gb, bits);\
733     level = table[index].level;\
734     n     = table[index].len;\
735 \
736     if(max_depth > 1 && n < 0){\
737         LAST_SKIP_BITS(name, gb, bits)\
738         UPDATE_CACHE(name, gb)\
739 \
740         nb_bits = -n;\
741 \
742         index= SHOW_UBITS(name, gb, nb_bits) + level;\
743         level = table[index].level;\
744         n     = table[index].len;\
745     }\
746     run= table[index].run;\
747     SKIP_BITS(name, gb, n)\
748 }
749
750 // deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly
751 static inline int get_vlc(GetBitContext *s, VLC *vlc)
752 {
753     int code;
754     VLC_TYPE (*table)[2]= vlc->table;
755     
756     OPEN_READER(re, s)
757     UPDATE_CACHE(re, s)
758
759     GET_VLC(code, re, s, table, vlc->bits, 3)    
760
761     CLOSE_READER(re, s)
762     return code;
763 }
764
765 /**
766  * parses a vlc code, faster then get_vlc()
767  * @param bits is the number of bits which will be read at once, must be 
768  *             identical to nb_bits in init_vlc()
769  * @param max_depth is the number of times bits bits must be readed to completly
770  *                  read the longest vlc code 
771  *                  = (max_vlc_length + bits - 1) / bits
772  */
773 static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
774                                   int bits, int max_depth)
775 {
776     int code;
777     
778     OPEN_READER(re, s)
779     UPDATE_CACHE(re, s)
780
781     GET_VLC(code, re, s, table, bits, max_depth)
782
783     CLOSE_READER(re, s)
784     return code;
785 }
786
787 //#define TRACE
788
789 #ifdef TRACE
790 #include "avcodec.h"
791 static inline void print_bin(int bits, int n){
792     int i;
793     
794     for(i=n-1; i>=0; i--){
795         av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
796     }
797     for(i=n; i<24; i++)
798         av_log(NULL, AV_LOG_DEBUG, " ");
799 }
800
801 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
802     int r= get_bits(s, n);
803     
804     print_bin(r, n);
805     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);
806     return r;
807 }
808 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){
809     int show= show_bits(s, 24);
810     int pos= get_bits_count(s);
811     int r= get_vlc2(s, table, bits, max_depth);
812     int len= get_bits_count(s) - pos;
813     int bits2= show>>(24-len);
814     
815     print_bin(bits2, len);
816     
817     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
818     return r;
819 }
820 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
821     int show= show_bits(s, n);
822     int r= get_xbits(s, n);
823     
824     print_bin(show, n);
825     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);
826     return r;
827 }
828
829 #define get_bits(s, n)  get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
830 #define get_bits1(s)    get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
831 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
832 #define get_vlc(s, vlc)            get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
833 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
834
835 #define tprintf(...) av_log(NULL, AV_LOG_DEBUG, __VA_ARGS__)
836
837 #else //TRACE
838 #define tprintf(...) {}
839 #endif
840
841 static inline int decode012(GetBitContext *gb){
842     int n;
843     n = get_bits1(gb);
844     if (n == 0)
845         return 0;
846     else
847         return get_bits1(gb) + 1;
848 }
849
850 #endif /* BITSTREAM_H */