libavcodec/get_bits.h

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