get_bits.h 21.4 KB
Newer Older
1 2 3
/*
 * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
 *
4 5 6
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * 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 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

21
/**
22
 * @file
23
 * bitstream reader API header.
24 25
 */

26 27
#ifndef AVCODEC_GET_BITS_H
#define AVCODEC_GET_BITS_H
28

29
#include <stdint.h>
30

31 32 33
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/log.h"
34
#include "libavutil/avassert.h"
35
#include "mathops.h"
36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
/*
 * Safe bitstream reading:
 * optionally, the get_bits API can check to ensure that we
 * don't read past input buffer boundaries. This is protected
 * with CONFIG_SAFE_BITSTREAM_READER at the global level, and
 * then below that with UNCHECKED_BITSTREAM_READER at the per-
 * decoder level. This means that decoders that check internally
 * can "#define UNCHECKED_BITSTREAM_READER 1" to disable
 * overread checks.
 * Boundary checking causes a minor performance penalty so for
 * applications that won't want/need this, it can be disabled
 * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".
 */
#ifndef UNCHECKED_BITSTREAM_READER
#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
#endif

54 55 56 57
typedef struct GetBitContext {
    const uint8_t *buffer, *buffer_end;
    int index;
    int size_in_bits;
58
    int size_in_bits_plus8;
59 60 61 62 63 64 65 66
} GetBitContext;

#define VLC_TYPE int16_t

typedef struct VLC {
    int bits;
    VLC_TYPE (*table)[2]; ///< code, bits
    int table_size, table_allocated;
67
    void * volatile init_state;
68 69 70 71 72 73 74 75 76
} VLC;

typedef struct RL_VLC_ELEM {
    int16_t level;
    int8_t len;
    uint8_t run;
} RL_VLC_ELEM;

/* Bitstream reader API docs:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
 * name
 *   arbitrary name which is used as prefix for the internal variables
 *
 * gb
 *   getbitcontext
 *
 * OPEN_READER(name, gb)
 *   load gb into local variables
 *
 * CLOSE_READER(name, gb)
 *   store local vars in gb
 *
 * UPDATE_CACHE(name, gb)
 *   Refill the internal cache from the bitstream.
 *   After this call at least MIN_CACHE_BITS will be available.
 *
 * GET_CACHE(name, gb)
 *   Will output the contents of the internal cache,
 *   next bit is MSB of 32 or 64 bit (FIXME 64bit).
 *
 * SHOW_UBITS(name, gb, num)
 *   Will return the next num bits.
 *
 * SHOW_SBITS(name, gb, num)
 *   Will return the next num bits and do sign extension.
 *
 * SKIP_BITS(name, gb, num)
 *   Will skip over the next num bits.
 *   Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
 *
 * SKIP_CACHE(name, gb, num)
 *   Will remove the next num bits from the cache (note SKIP_COUNTER
 *   MUST be called before UPDATE_CACHE / CLOSE_READER).
 *
 * SKIP_COUNTER(name, gb, num)
 *   Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
 *
 * LAST_SKIP_BITS(name, gb, num)
 *   Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
 *
 * For examples see get_bits, show_bits, skip_bits, get_vlc.
 */
119

120 121 122
#ifdef LONG_BITSTREAM_READER
#   define MIN_CACHE_BITS 32
#else
123
#   define MIN_CACHE_BITS 25
124
#endif
125

126
#if UNCHECKED_BITSTREAM_READER
127
#define OPEN_READER(name, gb)                   \
128
    unsigned int name ## _index = (gb)->index;  \
129
    unsigned int av_unused name ## _cache
130

131 132 133
#define HAVE_BITS_REMAINING(name, gb) 1
#else
#define OPEN_READER(name, gb)                   \
134 135 136
    unsigned int name ## _index = (gb)->index;  \
    unsigned int av_unused name ## _cache = 0;  \
    unsigned int av_unused name ## _size_plus8 = (gb)->size_in_bits_plus8
137

138
#define HAVE_BITS_REMAINING(name, gb) name ## _index < name ## _size_plus8
139 140
#endif

141
#define CLOSE_READER(name, gb) (gb)->index = name ## _index
142

143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
# ifdef LONG_BITSTREAM_READER

# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
      AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)

# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
      AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))

#else

# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
      AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)

# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
      AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)

#endif


162
#ifdef BITSTREAM_READER_LE
163

164
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
165

166
# define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
167 168 169

#else

170
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
171

172
# define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
173

174
#endif
175

176
#if UNCHECKED_BITSTREAM_READER
177
#   define SKIP_COUNTER(name, gb, num) name ## _index += (num)
178 179
#else
#   define SKIP_COUNTER(name, gb, num) \
180
    name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
181
#endif
182

183 184
#define SKIP_BITS(name, gb, num)                \
    do {                                        \
185 186 187
        SKIP_CACHE(name, gb, num);              \
        SKIP_COUNTER(name, gb, num);            \
    } while (0)
188

189
#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
190

191 192 193 194 195 196
#define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)
#define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)

#define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)
#define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)

197
#ifdef BITSTREAM_READER_LE
198 199
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
200
#else
201 202
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
203
#endif
204

205
#define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
206

207 208
static inline int get_bits_count(const GetBitContext *s)
{
209 210
    return s->index;
}
211

212 213
static inline void skip_bits_long(GetBitContext *s, int n)
{
214
#if UNCHECKED_BITSTREAM_READER
215
    s->index += n;
216 217 218
#else
    s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
#endif
219 220
}

221
/**
222
 * read mpeg1 dc style vlc (sign bit + mantissa with no MSB).
223
 * if MSB not set it is negative
224 225
 * @param n length in bits
 */
226 227
static inline int get_xbits(GetBitContext *s, int n)
{
228
    register int sign;
229
    register int32_t cache;
230
    OPEN_READER(re, s);
231
    av_assert2(n>0 && n<=25);
232
    UPDATE_CACHE(re, s);
233
    cache = GET_CACHE(re, s);
234
    sign  = ~cache >> 31;
235 236
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
237
    return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
238 239
}

240 241
static inline int get_sbits(GetBitContext *s, int n)
{
242
    register int tmp;
243
    OPEN_READER(re, s);
244
    av_assert2(n>0 && n<=25);
245
    UPDATE_CACHE(re, s);
246
    tmp = SHOW_SBITS(re, s, n);
247 248
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
249 250 251 252
    return tmp;
}

/**
253
 * Read 1-25 bits.
254
 */
255 256
static inline unsigned int get_bits(GetBitContext *s, int n)
{
257
    register int tmp;
258
    OPEN_READER(re, s);
259
    av_assert2(n>0 && n<=25);
260
    UPDATE_CACHE(re, s);
261
    tmp = SHOW_UBITS(re, s, n);
262 263
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
264 265 266
    return tmp;
}

267 268 269 270 271 272 273 274 275 276 277 278
static inline unsigned int get_bits_le(GetBitContext *s, int n)
{
    register int tmp;
    OPEN_READER(re, s);
    av_assert2(n>0 && n<=25);
    UPDATE_CACHE_LE(re, s);
    tmp = SHOW_UBITS_LE(re, s, n);
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
    return tmp;
}

279
/**
280
 * Show 1-25 bits.
281
 */
282 283
static inline unsigned int show_bits(GetBitContext *s, int n)
{
284
    register int tmp;
285
    OPEN_READER(re, s);
286
    av_assert2(n>0 && n<=25);
287
    UPDATE_CACHE(re, s);
288
    tmp = SHOW_UBITS(re, s, n);
289 290 291
    return tmp;
}

292 293
static inline void skip_bits(GetBitContext *s, int n)
{
294 295 296
    OPEN_READER(re, s);
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
297 298
}

299 300
static inline unsigned int get_bits1(GetBitContext *s)
{
301
    unsigned int index = s->index;
302
    uint8_t result     = s->buffer[index >> 3];
303
#ifdef BITSTREAM_READER_LE
304
    result >>= index & 7;
305
    result  &= 1;
306
#else
307 308
    result <<= index & 7;
    result >>= 8 - 1;
309
#endif
310 311 312 313
#if !UNCHECKED_BITSTREAM_READER
    if (s->index < s->size_in_bits_plus8)
#endif
        index++;
314
    s->index = index;
315 316 317 318

    return result;
}

319 320
static inline unsigned int show_bits1(GetBitContext *s)
{
321 322 323
    return show_bits(s, 1);
}

324 325
static inline void skip_bits1(GetBitContext *s)
{
326 327 328
    skip_bits(s, 1);
}

329
/**
330
 * Read 0-32 bits.
331
 */
332 333
static inline unsigned int get_bits_long(GetBitContext *s, int n)
{
334 335
    if (!n) {
        return 0;
336
    } else if (n <= MIN_CACHE_BITS) {
337
        return get_bits(s, n);
338
    } else {
339
#ifdef BITSTREAM_READER_LE
340
        unsigned ret = get_bits(s, 16);
341
        return ret | (get_bits(s, n - 16) << 16);
342
#else
343
        unsigned ret = get_bits(s, 16) << (n - 16);
344
        return ret | get_bits(s, n - 16);
345
#endif
346 347 348
    }
}

349 350 351
/**
 * Read 0-64 bits.
 */
352
static inline uint64_t get_bits64(GetBitContext *s, int n)
353
{
354
    if (n <= 32) {
355
        return get_bits_long(s, n);
356
    } else {
357 358
#ifdef BITSTREAM_READER_LE
        uint64_t ret = get_bits_long(s, 32);
359
        return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
360
#else
361
        uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
362
        return ret | get_bits_long(s, 32);
363 364 365 366
#endif
    }
}

367
/**
368
 * Read 0-32 bits as a signed integer.
369
 */
370 371
static inline int get_sbits_long(GetBitContext *s, int n)
{
372 373 374
    return sign_extend(get_bits_long(s, n), n);
}

375
/**
376
 * Show 0-32 bits.
377
 */
378 379
static inline unsigned int show_bits_long(GetBitContext *s, int n)
{
380
    if (n <= MIN_CACHE_BITS) {
381
        return show_bits(s, n);
382
    } else {
383
        GetBitContext gb = *s;
384
        return get_bits_long(&gb, n);
385 386 387 388 389
    }
}

static inline int check_marker(GetBitContext *s, const char *msg)
{
390 391
    int bit = get_bits1(s);
    if (!bit)
392 393 394 395 396
        av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);

    return bit;
}

397
/**
398 399 400 401
 * Initialize GetBitContext.
 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes
 *        larger than the actual read bits because some optimized bitstream
 *        readers read 32 or 64 bit at once and could read over the end
402
 * @param bit_size the size of the buffer in bits
403
 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
404
 */
405 406
static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
                                int bit_size)
407
{
408 409 410
    int buffer_size;
    int ret = 0;

411
    if (bit_size >= INT_MAX - 7 || bit_size < 0 || !buffer) {
412
        buffer_size = bit_size = 0;
413 414
        buffer      = NULL;
        ret         = AVERROR_INVALIDDATA;
415
    }
416

417 418
    buffer_size = (bit_size + 7) >> 3;

419 420
    s->buffer             = buffer;
    s->size_in_bits       = bit_size;
421
    s->size_in_bits_plus8 = bit_size + 8;
422 423 424
    s->buffer_end         = buffer + buffer_size;
    s->index              = 0;

425
    return ret;
426 427
}

428 429 430 431 432 433 434 435 436 437 438
/**
 * Initialize GetBitContext.
 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes
 *        larger than the actual read bits because some optimized bitstream
 *        readers read 32 or 64 bit at once and could read over the end
 * @param byte_size the size of the buffer in bytes
 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
 */
static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
                                 int byte_size)
{
439
    if (byte_size > INT_MAX / 8 || byte_size < 0)
440
        byte_size = -1;
441
    return init_get_bits(s, buffer, byte_size * 8);
442 443
}

444
static inline const uint8_t *align_get_bits(GetBitContext *s)
445
{
446
    int n = -get_bits_count(s) & 7;
447 448
    if (n)
        skip_bits(s, n);
449
    return s->buffer + (s->index >> 3);
450 451
}

452 453 454 455
#define init_vlc(vlc, nb_bits, nb_codes,                \
                 bits, bits_wrap, bits_size,            \
                 codes, codes_wrap, codes_size,         \
                 flags)                                 \
456 457 458 459
    ff_init_vlc_sparse(vlc, nb_bits, nb_codes,          \
                       bits, bits_wrap, bits_size,      \
                       codes, codes_wrap, codes_size,   \
                       NULL, 0, 0, flags)
460

461
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
462 463 464 465
                       const void *bits, int bits_wrap, int bits_size,
                       const void *codes, int codes_wrap, int codes_size,
                       const void *symbols, int symbols_wrap, int symbols_size,
                       int flags);
466
void ff_free_vlc(VLC *vlc);
467

468 469
#define INIT_VLC_LE             2
#define INIT_VLC_USE_NEW_STATIC 4
470

471 472 473 474 475 476 477
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)       \
    do {                                                                   \
        static VLC_TYPE table[static_size][2];                             \
        (vlc)->table           = table;                                    \
        (vlc)->table_allocated = static_size;                              \
        init_vlc(vlc, bits, a, b, c, d, e, f, g, INIT_VLC_USE_NEW_STATIC); \
    } while (0)
478

479
/**
480 481 482
 * If the vlc code is invalid and max_depth=1, then no bits will be removed.
 * If the vlc code is invalid and max_depth>1, then the number of bits removed
 * is undefined.
483
 */
484 485
#define GET_VLC(code, name, gb, table, bits, max_depth)         \
    do {                                                        \
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
        int n, nb_bits;                                         \
        unsigned int index;                                     \
                                                                \
        index = SHOW_UBITS(name, gb, bits);                     \
        code  = table[index][0];                                \
        n     = table[index][1];                                \
                                                                \
        if (max_depth > 1 && n < 0) {                           \
            LAST_SKIP_BITS(name, gb, bits);                     \
            UPDATE_CACHE(name, gb);                             \
                                                                \
            nb_bits = -n;                                       \
                                                                \
            index = SHOW_UBITS(name, gb, nb_bits) + code;       \
            code  = table[index][0];                            \
            n     = table[index][1];                            \
            if (max_depth > 2 && n < 0) {                       \
                LAST_SKIP_BITS(name, gb, nb_bits);              \
                UPDATE_CACHE(name, gb);                         \
                                                                \
                nb_bits = -n;                                   \
                                                                \
                index = SHOW_UBITS(name, gb, nb_bits) + code;   \
                code  = table[index][0];                        \
                n     = table[index][1];                        \
            }                                                   \
        }                                                       \
        SKIP_BITS(name, gb, n);                                 \
    } while (0)

516
#define GET_RL_VLC_INTERNAL(level, run, name, gb, table, bits,  \
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
                   max_depth, need_update)                      \
    do {                                                        \
        int n, nb_bits;                                         \
        unsigned int index;                                     \
                                                                \
        index = SHOW_UBITS(name, gb, bits);                     \
        level = table[index].level;                             \
        n     = table[index].len;                               \
                                                                \
        if (max_depth > 1 && n < 0) {                           \
            SKIP_BITS(name, gb, bits);                          \
            if (need_update) {                                  \
                UPDATE_CACHE(name, gb);                         \
            }                                                   \
                                                                \
            nb_bits = -n;                                       \
                                                                \
            index = SHOW_UBITS(name, gb, nb_bits) + level;      \
            level = table[index].level;                         \
            n     = table[index].len;                           \
        }                                                       \
        run = table[index].run;                                 \
        SKIP_BITS(name, gb, n);                                 \
540
    } while (0)
541 542

/**
543
 * Parse a vlc code.
544
 * @param bits is the number of bits which will be read at once, must be
545
 *             identical to nb_bits in init_vlc()
Diego Biurrun's avatar
Diego Biurrun committed
546
 * @param max_depth is the number of times bits bits must be read to completely
547
 *                  read the longest vlc code
548 549
 *                  = (max_vlc_length + bits - 1) / bits
 */
550
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
551
                                     int bits, int max_depth)
552 553
{
    int code;
554

555 556
    OPEN_READER(re, s);
    UPDATE_CACHE(re, s);
557

558
    GET_VLC(code, re, s, table, bits, max_depth);
559

560
    CLOSE_READER(re, s);
561

562 563 564
    return code;
}

565 566
static inline int decode012(GetBitContext *gb)
{
567 568 569 570 571 572 573 574
    int n;
    n = get_bits1(gb);
    if (n == 0)
        return 0;
    else
        return get_bits1(gb) + 1;
}

575 576
static inline int decode210(GetBitContext *gb)
{
577 578 579 580 581 582 583 584 585 586 587
    if (get_bits1(gb))
        return 0;
    else
        return 2 - get_bits1(gb);
}

static inline int get_bits_left(GetBitContext *gb)
{
    return gb->size_in_bits - get_bits_count(gb);
}

588 589 590 591 592 593 594 595 596 597 598 599 600 601
static inline int skip_1stop_8data_bits(GetBitContext *gb)
{
    if (get_bits_left(gb) <= 0)
        return AVERROR_INVALIDDATA;

    while (get_bits1(gb)) {
        skip_bits(gb, 8);
        if (get_bits_left(gb) <= 0)
            return AVERROR_INVALIDDATA;
    }

    return 0;
}

602 603 604
//#define TRACE

#ifdef TRACE
605 606
static inline void print_bin(int bits, int n)
{
607
    int i;
608

609 610
    for (i = n - 1; i >= 0; i--)
        av_log(NULL, AV_LOG_DEBUG, "%d", (bits >> i) & 1);
611
    for (i = n; i < 24; i++)
612
        av_log(NULL, AV_LOG_DEBUG, " ");
613 614
}

615
static inline int get_bits_trace(GetBitContext *s, int n, const char *file,
616 617
                                 const char *func, int line)
{
618
    int r = get_bits(s, n);
619

620
    print_bin(r, n);
621
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n",
622 623
           r, n, r, get_bits_count(s) - n, file, func, line);

624 625
    return r;
}
626

627
static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],
628
                                int bits, int max_depth, const char *file,
629 630
                                const char *func, int line)
{
631 632 633 634
    int show  = show_bits(s, 24);
    int pos   = get_bits_count(s);
    int r     = get_vlc2(s, table, bits, max_depth);
    int len   = get_bits_count(s) - pos;
635
    int bits2 = show >> (24 - len);
636

637
    print_bin(bits2, len);
638

639 640
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n",
           bits2, len, r, pos, file, func, line);
641

642 643
    return r;
}
644

645 646 647 648 649 650 651 652 653
#define GET_RL_VLC(level, run, name, gb, table, bits,           \
                   max_depth, need_update)                      \
    do {                                                        \
        int show  = SHOW_UBITS(name, gb, 24);                   \
        int len;                                                \
        int pos = name ## _index;                               \
                                                                \
        GET_RL_VLC_INTERNAL(level, run, name, gb, table, bits,max_depth, need_update); \
                                                                \
654
        len = name ## _index - pos + 1;                         \
655 656 657 658
        show = show >> (24 - len);                              \
                                                                \
        print_bin(show, len);                                   \
                                                                \
659 660
        av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d/%-3d rlv @%5d in %s %s:%d\n",\
               show, len, run-1, level, pos, __FILE__, __PRETTY_FUNCTION__, __LINE__);\
661 662 663
    } while (0)                                                 \


664
static inline int get_xbits_trace(GetBitContext *s, int n, const char *file,
665 666
                                  const char *func, int line)
{
667 668
    int show = show_bits(s, n);
    int r    = get_xbits(s, n);
669

670
    print_bin(show, n);
671
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n",
672 673
           show, n, r, get_bits_count(s) - n, file, func, line);

674 675 676
    return r;
}

677 678
#define get_bits(s, n)  get_bits_trace(s , n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#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 681 682

#define get_vlc(s, vlc)             get_vlc_trace(s, (vlc)->table, (vlc)->bits,   3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc2(s, tab, bits, max) get_vlc_trace(s,          tab,        bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
683

684
#define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
685 686

#else //TRACE
687
#define tprintf(p, ...) { }
688
#define GET_RL_VLC GET_RL_VLC_INTERNAL
689 690
#endif

691
#endif /* AVCODEC_GET_BITS_H */