• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/get_bits.h

Go to the documentation of this file.
00001 /*
00002  * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
00003  *
00004  * This file is part of FFmpeg.
00005  *
00006  * FFmpeg is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * FFmpeg is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with FFmpeg; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00026 #ifndef AVCODEC_GET_BITS_H
00027 #define AVCODEC_GET_BITS_H
00028 
00029 #include <stdint.h>
00030 #include <stdlib.h>
00031 #include <assert.h>
00032 #include "libavutil/bswap.h"
00033 #include "libavutil/common.h"
00034 #include "libavutil/intreadwrite.h"
00035 #include "libavutil/log.h"
00036 #include "mathops.h"
00037 
00038 #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER)
00039 #   define ALT_BITSTREAM_READER
00040 #endif
00041 
00042 #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER)
00043 #   if ARCH_ARM && !HAVE_FAST_UNALIGNED
00044 #       define A32_BITSTREAM_READER
00045 #   else
00046 #       define ALT_BITSTREAM_READER
00047 //#define LIBMPEG2_BITSTREAM_READER
00048 //#define A32_BITSTREAM_READER
00049 #   endif
00050 #endif
00051 
00052 /* bit input */
00053 /* buffer, buffer_end and size_in_bits must be present and used by every reader */
00054 typedef struct GetBitContext {
00055     const uint8_t *buffer, *buffer_end;
00056 #ifdef ALT_BITSTREAM_READER
00057     int index;
00058 #elif defined LIBMPEG2_BITSTREAM_READER
00059     uint8_t *buffer_ptr;
00060     uint32_t cache;
00061     int bit_count;
00062 #elif defined A32_BITSTREAM_READER
00063     uint32_t *buffer_ptr;
00064     uint32_t cache0;
00065     uint32_t cache1;
00066     int bit_count;
00067 #endif
00068     int size_in_bits;
00069 } GetBitContext;
00070 
00071 #define VLC_TYPE int16_t
00072 
00073 typedef struct VLC {
00074     int bits;
00075     VLC_TYPE (*table)[2]; 
00076     int table_size, table_allocated;
00077 } VLC;
00078 
00079 typedef struct RL_VLC_ELEM {
00080     int16_t level;
00081     int8_t len;
00082     uint8_t run;
00083 } RL_VLC_ELEM;
00084 
00085 /* Bitstream reader API docs:
00086 name
00087     arbitrary name which is used as prefix for the internal variables
00088 
00089 gb
00090     getbitcontext
00091 
00092 OPEN_READER(name, gb)
00093     loads gb into local variables
00094 
00095 CLOSE_READER(name, gb)
00096     stores local vars in gb
00097 
00098 UPDATE_CACHE(name, gb)
00099     refills the internal cache from the bitstream
00100     after this call at least MIN_CACHE_BITS will be available,
00101 
00102 GET_CACHE(name, gb)
00103     will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
00104 
00105 SHOW_UBITS(name, gb, num)
00106     will return the next num bits
00107 
00108 SHOW_SBITS(name, gb, num)
00109     will return the next num bits and do sign extension
00110 
00111 SKIP_BITS(name, gb, num)
00112     will skip over the next num bits
00113     note, this is equivalent to SKIP_CACHE; SKIP_COUNTER
00114 
00115 SKIP_CACHE(name, gb, num)
00116     will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
00117 
00118 SKIP_COUNTER(name, gb, num)
00119     will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
00120 
00121 LAST_SKIP_CACHE(name, gb, num)
00122     will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
00123 
00124 LAST_SKIP_BITS(name, gb, num)
00125     is equivalent to LAST_SKIP_CACHE; SKIP_COUNTER
00126 
00127 for examples see get_bits, show_bits, skip_bits, get_vlc
00128 */
00129 
00130 #ifdef ALT_BITSTREAM_READER
00131 #   define MIN_CACHE_BITS 25
00132 
00133 #   define OPEN_READER(name, gb)\
00134         unsigned int name##_index= (gb)->index;\
00135         int name##_cache= 0;\
00136 
00137 #   define CLOSE_READER(name, gb)\
00138         (gb)->index= name##_index;\
00139 
00140 # ifdef ALT_BITSTREAM_READER_LE
00141 #   define UPDATE_CACHE(name, gb)\
00142         name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\
00143 
00144 #   define SKIP_CACHE(name, gb, num)\
00145         name##_cache >>= (num);
00146 # else
00147 #   define UPDATE_CACHE(name, gb)\
00148         name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
00149 
00150 #   define SKIP_CACHE(name, gb, num)\
00151         name##_cache <<= (num);
00152 # endif
00153 
00154 // FIXME name?
00155 #   define SKIP_COUNTER(name, gb, num)\
00156         name##_index += (num);\
00157 
00158 #   define SKIP_BITS(name, gb, num)\
00159         {\
00160             SKIP_CACHE(name, gb, num)\
00161             SKIP_COUNTER(name, gb, num)\
00162         }\
00163 
00164 #   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
00165 #   define LAST_SKIP_CACHE(name, gb, num) ;
00166 
00167 # ifdef ALT_BITSTREAM_READER_LE
00168 #   define SHOW_UBITS(name, gb, num)\
00169         zero_extend(name##_cache, num)
00170 
00171 #   define SHOW_SBITS(name, gb, num)\
00172         sign_extend(name##_cache, num)
00173 # else
00174 #   define SHOW_UBITS(name, gb, num)\
00175         NEG_USR32(name##_cache, num)
00176 
00177 #   define SHOW_SBITS(name, gb, num)\
00178         NEG_SSR32(name##_cache, num)
00179 # endif
00180 
00181 #   define GET_CACHE(name, gb)\
00182         ((uint32_t)name##_cache)
00183 
00184 static inline int get_bits_count(const GetBitContext *s){
00185     return s->index;
00186 }
00187 
00188 static inline void skip_bits_long(GetBitContext *s, int n){
00189     s->index += n;
00190 }
00191 
00192 #elif defined LIBMPEG2_BITSTREAM_READER
00193 //libmpeg2 like reader
00194 
00195 #   define MIN_CACHE_BITS 17
00196 
00197 #   define OPEN_READER(name, gb)\
00198         int name##_bit_count=(gb)->bit_count;\
00199         int name##_cache= (gb)->cache;\
00200         uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
00201 
00202 #   define CLOSE_READER(name, gb)\
00203         (gb)->bit_count= name##_bit_count;\
00204         (gb)->cache= name##_cache;\
00205         (gb)->buffer_ptr= name##_buffer_ptr;\
00206 
00207 #   define UPDATE_CACHE(name, gb)\
00208     if(name##_bit_count >= 0){\
00209         name##_cache+= AV_RB16(name##_buffer_ptr) << name##_bit_count; \
00210         name##_buffer_ptr+=2;\
00211         name##_bit_count-= 16;\
00212     }\
00213 
00214 #   define SKIP_CACHE(name, gb, num)\
00215         name##_cache <<= (num);\
00216 
00217 #   define SKIP_COUNTER(name, gb, num)\
00218         name##_bit_count += (num);\
00219 
00220 #   define SKIP_BITS(name, gb, num)\
00221         {\
00222             SKIP_CACHE(name, gb, num)\
00223             SKIP_COUNTER(name, gb, num)\
00224         }\
00225 
00226 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
00227 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
00228 
00229 #   define SHOW_UBITS(name, gb, num)\
00230         NEG_USR32(name##_cache, num)
00231 
00232 #   define SHOW_SBITS(name, gb, num)\
00233         NEG_SSR32(name##_cache, num)
00234 
00235 #   define GET_CACHE(name, gb)\
00236         ((uint32_t)name##_cache)
00237 
00238 static inline int get_bits_count(const GetBitContext *s){
00239     return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
00240 }
00241 
00242 static inline void skip_bits_long(GetBitContext *s, int n){
00243     OPEN_READER(re, s)
00244     re_bit_count += n;
00245     re_buffer_ptr += 2*(re_bit_count>>4);
00246     re_bit_count &= 15;
00247     re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count);
00248     UPDATE_CACHE(re, s)
00249     CLOSE_READER(re, s)
00250 }
00251 
00252 #elif defined A32_BITSTREAM_READER
00253 
00254 #   define MIN_CACHE_BITS 32
00255 
00256 #   define OPEN_READER(name, gb)\
00257         int name##_bit_count=(gb)->bit_count;\
00258         uint32_t name##_cache0= (gb)->cache0;\
00259         uint32_t name##_cache1= (gb)->cache1;\
00260         uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
00261 
00262 #   define CLOSE_READER(name, gb)\
00263         (gb)->bit_count= name##_bit_count;\
00264         (gb)->cache0= name##_cache0;\
00265         (gb)->cache1= name##_cache1;\
00266         (gb)->buffer_ptr= name##_buffer_ptr;\
00267 
00268 #   define UPDATE_CACHE(name, gb)\
00269     if(name##_bit_count > 0){\
00270         const uint32_t next= be2me_32( *name##_buffer_ptr );\
00271         name##_cache0 |= NEG_USR32(next,name##_bit_count);\
00272         name##_cache1 |= next<<name##_bit_count;\
00273         name##_buffer_ptr++;\
00274         name##_bit_count-= 32;\
00275     }\
00276 
00277 #if ARCH_X86
00278 #   define SKIP_CACHE(name, gb, num)\
00279         __asm__(\
00280             "shldl %2, %1, %0          \n\t"\
00281             "shll %2, %1               \n\t"\
00282             : "+r" (name##_cache0), "+r" (name##_cache1)\
00283             : "Ic" ((uint8_t)(num))\
00284            );
00285 #else
00286 #   define SKIP_CACHE(name, gb, num)\
00287         name##_cache0 <<= (num);\
00288         name##_cache0 |= NEG_USR32(name##_cache1,num);\
00289         name##_cache1 <<= (num);
00290 #endif
00291 
00292 #   define SKIP_COUNTER(name, gb, num)\
00293         name##_bit_count += (num);\
00294 
00295 #   define SKIP_BITS(name, gb, num)\
00296         {\
00297             SKIP_CACHE(name, gb, num)\
00298             SKIP_COUNTER(name, gb, num)\
00299         }\
00300 
00301 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
00302 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
00303 
00304 #   define SHOW_UBITS(name, gb, num)\
00305         NEG_USR32(name##_cache0, num)
00306 
00307 #   define SHOW_SBITS(name, gb, num)\
00308         NEG_SSR32(name##_cache0, num)
00309 
00310 #   define GET_CACHE(name, gb)\
00311         (name##_cache0)
00312 
00313 static inline int get_bits_count(const GetBitContext *s){
00314     return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
00315 }
00316 
00317 static inline void skip_bits_long(GetBitContext *s, int n){
00318     OPEN_READER(re, s)
00319     re_bit_count += n;
00320     re_buffer_ptr += re_bit_count>>5;
00321     re_bit_count &= 31;
00322     re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count;
00323     re_cache1 = 0;
00324     UPDATE_CACHE(re, s)
00325     CLOSE_READER(re, s)
00326 }
00327 
00328 #endif
00329 
00336 static inline int get_xbits(GetBitContext *s, int n){
00337     register int sign;
00338     register int32_t cache;
00339     OPEN_READER(re, s)
00340     UPDATE_CACHE(re, s)
00341     cache = GET_CACHE(re,s);
00342     sign=(~cache)>>31;
00343     LAST_SKIP_BITS(re, s, n)
00344     CLOSE_READER(re, s)
00345     return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
00346 }
00347 
00348 static inline int get_sbits(GetBitContext *s, int n){
00349     register int tmp;
00350     OPEN_READER(re, s)
00351     UPDATE_CACHE(re, s)
00352     tmp= SHOW_SBITS(re, s, n);
00353     LAST_SKIP_BITS(re, s, n)
00354     CLOSE_READER(re, s)
00355     return tmp;
00356 }
00357 
00362 static inline unsigned int get_bits(GetBitContext *s, int n){
00363     register int tmp;
00364     OPEN_READER(re, s)
00365     UPDATE_CACHE(re, s)
00366     tmp= SHOW_UBITS(re, s, n);
00367     LAST_SKIP_BITS(re, s, n)
00368     CLOSE_READER(re, s)
00369     return tmp;
00370 }
00371 
00376 static inline unsigned int show_bits(GetBitContext *s, int n){
00377     register int tmp;
00378     OPEN_READER(re, s)
00379     UPDATE_CACHE(re, s)
00380     tmp= SHOW_UBITS(re, s, n);
00381 //    CLOSE_READER(re, s)
00382     return tmp;
00383 }
00384 
00385 static inline void skip_bits(GetBitContext *s, int n){
00386  //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
00387     OPEN_READER(re, s)
00388     UPDATE_CACHE(re, s)
00389     LAST_SKIP_BITS(re, s, n)
00390     CLOSE_READER(re, s)
00391 }
00392 
00393 static inline unsigned int get_bits1(GetBitContext *s){
00394 #ifdef ALT_BITSTREAM_READER
00395     unsigned int index= s->index;
00396     uint8_t result= s->buffer[ index>>3 ];
00397 #ifdef ALT_BITSTREAM_READER_LE
00398     result>>= (index&0x07);
00399     result&= 1;
00400 #else
00401     result<<= (index&0x07);
00402     result>>= 8 - 1;
00403 #endif
00404     index++;
00405     s->index= index;
00406 
00407     return result;
00408 #else
00409     return get_bits(s, 1);
00410 #endif
00411 }
00412 
00413 static inline unsigned int show_bits1(GetBitContext *s){
00414     return show_bits(s, 1);
00415 }
00416 
00417 static inline void skip_bits1(GetBitContext *s){
00418     skip_bits(s, 1);
00419 }
00420 
00424 static inline unsigned int get_bits_long(GetBitContext *s, int n){
00425     if(n<=MIN_CACHE_BITS) return get_bits(s, n);
00426     else{
00427 #ifdef ALT_BITSTREAM_READER_LE
00428         int ret= get_bits(s, 16);
00429         return ret | (get_bits(s, n-16) << 16);
00430 #else
00431         int ret= get_bits(s, 16) << (n-16);
00432         return ret | get_bits(s, n-16);
00433 #endif
00434     }
00435 }
00436 
00440 static inline int get_sbits_long(GetBitContext *s, int n) {
00441     return sign_extend(get_bits_long(s, n), n);
00442 }
00443 
00447 static inline unsigned int show_bits_long(GetBitContext *s, int n){
00448     if(n<=MIN_CACHE_BITS) return show_bits(s, n);
00449     else{
00450         GetBitContext gb= *s;
00451         return get_bits_long(&gb, n);
00452     }
00453 }
00454 
00455 static inline int check_marker(GetBitContext *s, const char *msg)
00456 {
00457     int bit= get_bits1(s);
00458     if(!bit)
00459         av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);
00460 
00461     return bit;
00462 }
00463 
00473 static inline void init_get_bits(GetBitContext *s,
00474                    const uint8_t *buffer, int bit_size)
00475 {
00476     int buffer_size= (bit_size+7)>>3;
00477     if(buffer_size < 0 || bit_size < 0) {
00478         buffer_size = bit_size = 0;
00479         buffer = NULL;
00480     }
00481 
00482     s->buffer= buffer;
00483     s->size_in_bits= bit_size;
00484     s->buffer_end= buffer + buffer_size;
00485 #ifdef ALT_BITSTREAM_READER
00486     s->index=0;
00487 #elif defined LIBMPEG2_BITSTREAM_READER
00488     s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1));
00489     s->bit_count = 16 + 8*((intptr_t)buffer&1);
00490     skip_bits_long(s, 0);
00491 #elif defined A32_BITSTREAM_READER
00492     s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3));
00493     s->bit_count = 32 + 8*((intptr_t)buffer&3);
00494     skip_bits_long(s, 0);
00495 #endif
00496 }
00497 
00498 static inline void align_get_bits(GetBitContext *s)
00499 {
00500     int n= (-get_bits_count(s)) & 7;
00501     if(n) skip_bits(s, n);
00502 }
00503 
00504 #define init_vlc(vlc, nb_bits, nb_codes,\
00505                  bits, bits_wrap, bits_size,\
00506                  codes, codes_wrap, codes_size,\
00507                  flags)\
00508         init_vlc_sparse(vlc, nb_bits, nb_codes,\
00509                  bits, bits_wrap, bits_size,\
00510                  codes, codes_wrap, codes_size,\
00511                  NULL, 0, 0, flags)
00512 
00513 int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
00514              const void *bits, int bits_wrap, int bits_size,
00515              const void *codes, int codes_wrap, int codes_size,
00516              const void *symbols, int symbols_wrap, int symbols_size,
00517              int flags);
00518 #define INIT_VLC_LE         2
00519 #define INIT_VLC_USE_NEW_STATIC 4
00520 void free_vlc(VLC *vlc);
00521 
00522 #define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size)\
00523 {\
00524     static VLC_TYPE table[static_size][2];\
00525     (vlc)->table= table;\
00526     (vlc)->table_allocated= static_size;\
00527     init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);\
00528 }
00529 
00530 
00537 #define GET_VLC(code, name, gb, table, bits, max_depth)\
00538 {\
00539     int n, nb_bits;\
00540     unsigned int index;\
00541 \
00542     index= SHOW_UBITS(name, gb, bits);\
00543     code = table[index][0];\
00544     n    = table[index][1];\
00545 \
00546     if(max_depth > 1 && n < 0){\
00547         LAST_SKIP_BITS(name, gb, bits)\
00548         UPDATE_CACHE(name, gb)\
00549 \
00550         nb_bits = -n;\
00551 \
00552         index= SHOW_UBITS(name, gb, nb_bits) + code;\
00553         code = table[index][0];\
00554         n    = table[index][1];\
00555         if(max_depth > 2 && n < 0){\
00556             LAST_SKIP_BITS(name, gb, nb_bits)\
00557             UPDATE_CACHE(name, gb)\
00558 \
00559             nb_bits = -n;\
00560 \
00561             index= SHOW_UBITS(name, gb, nb_bits) + code;\
00562             code = table[index][0];\
00563             n    = table[index][1];\
00564         }\
00565     }\
00566     SKIP_BITS(name, gb, n)\
00567 }
00568 
00569 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\
00570 {\
00571     int n, nb_bits;\
00572     unsigned int index;\
00573 \
00574     index= SHOW_UBITS(name, gb, bits);\
00575     level = table[index].level;\
00576     n     = table[index].len;\
00577 \
00578     if(max_depth > 1 && n < 0){\
00579         SKIP_BITS(name, gb, bits)\
00580         if(need_update){\
00581             UPDATE_CACHE(name, gb)\
00582         }\
00583 \
00584         nb_bits = -n;\
00585 \
00586         index= SHOW_UBITS(name, gb, nb_bits) + level;\
00587         level = table[index].level;\
00588         n     = table[index].len;\
00589     }\
00590     run= table[index].run;\
00591     SKIP_BITS(name, gb, n)\
00592 }
00593 
00594 
00603 static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
00604                                   int bits, int max_depth)
00605 {
00606     int code;
00607 
00608     OPEN_READER(re, s)
00609     UPDATE_CACHE(re, s)
00610 
00611     GET_VLC(code, re, s, table, bits, max_depth)
00612 
00613     CLOSE_READER(re, s)
00614     return code;
00615 }
00616 
00617 //#define TRACE
00618 
00619 #ifdef TRACE
00620 static inline void print_bin(int bits, int n){
00621     int i;
00622 
00623     for(i=n-1; i>=0; i--){
00624         av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
00625     }
00626     for(i=n; i<24; i++)
00627         av_log(NULL, AV_LOG_DEBUG, " ");
00628 }
00629 
00630 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
00631     int r= get_bits(s, n);
00632 
00633     print_bin(r, n);
00634     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);
00635     return r;
00636 }
00637 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){
00638     int show= show_bits(s, 24);
00639     int pos= get_bits_count(s);
00640     int r= get_vlc2(s, table, bits, max_depth);
00641     int len= get_bits_count(s) - pos;
00642     int bits2= show>>(24-len);
00643 
00644     print_bin(bits2, len);
00645 
00646     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
00647     return r;
00648 }
00649 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
00650     int show= show_bits(s, n);
00651     int r= get_xbits(s, n);
00652 
00653     print_bin(show, n);
00654     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);
00655     return r;
00656 }
00657 
00658 #define get_bits(s, n)  get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00659 #define get_bits1(s)    get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00660 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00661 #define get_vlc(s, vlc)            get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00662 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00663 
00664 #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
00665 
00666 #else //TRACE
00667 #define tprintf(p, ...) {}
00668 #endif
00669 
00670 static inline int decode012(GetBitContext *gb){
00671     int n;
00672     n = get_bits1(gb);
00673     if (n == 0)
00674         return 0;
00675     else
00676         return get_bits1(gb) + 1;
00677 }
00678 
00679 static inline int decode210(GetBitContext *gb){
00680     if (get_bits1(gb))
00681         return 0;
00682     else
00683         return 2 - get_bits1(gb);
00684 }
00685 
00686 static inline int get_bits_left(GetBitContext *gb)
00687 {
00688     return gb->size_in_bits - get_bits_count(gb);
00689 }
00690 
00691 #endif /* AVCODEC_GET_BITS_H */

Generated on Fri Sep 16 2011 17:17:36 for FFmpeg by  doxygen 1.7.1