Statistics
| Branch: | Revision:

ffmpeg / libavcodec / get_bits.h @ 91cc5d37

History | View | Annotate | Download (19.1 KB)

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
#endif /* AVCODEC_GET_BITS_H */