get_bits.h 21.5 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 67 68 69 70 71 72 73 74 75
} GetBitContext;

#define VLC_TYPE int16_t

typedef struct VLC {
    int bits;
    VLC_TYPE (*table)[2]; ///< code, bits
    int table_size, table_allocated;
} VLC;

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

/* Bitstream reader API docs:
76 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
 * 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.
 *
116 117 118
 * BITS_LEFT(name, gb)
 *   Return the number of bits left
 *
119 120
 * For examples see get_bits, show_bits, skip_bits, get_vlc.
 */
121

122 123 124
#ifdef LONG_BITSTREAM_READER
#   define MIN_CACHE_BITS 32
#else
125
#   define MIN_CACHE_BITS 25
126
#endif
127

128
#define OPEN_READER_NOSIZE(name, gb)            \
129
    unsigned int name ## _index = (gb)->index;  \
130
    unsigned int av_unused name ## _cache
131

132 133 134
#if UNCHECKED_BITSTREAM_READER
#define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)

135
#define BITS_AVAILABLE(name, gb) 1
136 137
#else
#define OPEN_READER(name, gb)                   \
138 139
    OPEN_READER_NOSIZE(name, gb);               \
    unsigned int name ## _size_plus8 = (gb)->size_in_bits_plus8
140

141
#define BITS_AVAILABLE(name, gb) name ## _index < name ## _size_plus8
142 143
#endif

144
#define CLOSE_READER(name, gb) (gb)->index = name ## _index
145

146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
# 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


165
#ifdef BITSTREAM_READER_LE
166

167
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
168

169
# define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
170 171 172

#else

173
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
174

175
# define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
176

177
#endif
178

179
#if UNCHECKED_BITSTREAM_READER
180
#   define SKIP_COUNTER(name, gb, num) name ## _index += (num)
181 182
#else
#   define SKIP_COUNTER(name, gb, num) \
183
    name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
184
#endif
185

186 187
#define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))

188 189
#define SKIP_BITS(name, gb, num)                \
    do {                                        \
190 191 192
        SKIP_CACHE(name, gb, num);              \
        SKIP_COUNTER(name, gb, num);            \
    } while (0)
193

194
#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
195

196 197 198 199 200 201
#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)

202
#ifdef BITSTREAM_READER_LE
203 204
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
205
#else
206 207
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
208
#endif
209

210
#define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
211

212 213
static inline int get_bits_count(const GetBitContext *s)
{
214 215
    return s->index;
}
216

217 218
static inline void skip_bits_long(GetBitContext *s, int n)
{
219
#if UNCHECKED_BITSTREAM_READER
220
    s->index += n;
221 222 223
#else
    s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
#endif
224 225
}

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

245 246
static inline int get_sbits(GetBitContext *s, int n)
{
247
    register int tmp;
248
    OPEN_READER(re, s);
249
    av_assert2(n>0 && n<=25);
250
    UPDATE_CACHE(re, s);
251
    tmp = SHOW_SBITS(re, s, n);
252 253
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
254 255 256 257
    return tmp;
}

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

272 273 274 275 276 277 278 279 280 281 282 283
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;
}

284
/**
285
 * Show 1-25 bits.
286
 */
287 288
static inline unsigned int show_bits(GetBitContext *s, int n)
{
289
    register int tmp;
290
    OPEN_READER_NOSIZE(re, s);
291
    av_assert2(n>0 && n<=25);
292
    UPDATE_CACHE(re, s);
293
    tmp = SHOW_UBITS(re, s, n);
294 295 296
    return tmp;
}

297 298
static inline void skip_bits(GetBitContext *s, int n)
{
299 300 301
    OPEN_READER(re, s);
    LAST_SKIP_BITS(re, s, n);
    CLOSE_READER(re, s);
302 303
}

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

    return result;
}

324 325
static inline unsigned int show_bits1(GetBitContext *s)
{
326 327 328
    return show_bits(s, 1);
}

329 330
static inline void skip_bits1(GetBitContext *s)
{
331 332 333
    skip_bits(s, 1);
}

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

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

372
/**
373
 * Read 0-32 bits as a signed integer.
374
 */
375 376
static inline int get_sbits_long(GetBitContext *s, int n)
{
377 378 379
    return sign_extend(get_bits_long(s, n), n);
}

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

static inline int check_marker(GetBitContext *s, const char *msg)
{
395 396
    int bit = get_bits1(s);
    if (!bit)
397 398 399 400 401
        av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);

    return bit;
}

402
/**
403 404 405 406
 * 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
407
 * @param bit_size the size of the buffer in bits
408
 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
409
 */
410 411
static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
                                int bit_size)
412
{
413 414 415
    int buffer_size;
    int ret = 0;

416
    if (bit_size >= INT_MAX - 7 || bit_size < 0 || !buffer) {
417
        bit_size    = 0;
418 419
        buffer      = NULL;
        ret         = AVERROR_INVALIDDATA;
420
    }
421

422 423
    buffer_size = (bit_size + 7) >> 3;

424 425
    s->buffer             = buffer;
    s->size_in_bits       = bit_size;
426
    s->size_in_bits_plus8 = bit_size + 8;
427 428 429
    s->buffer_end         = buffer + buffer_size;
    s->index              = 0;

430
    return ret;
431 432
}

433 434 435 436 437 438 439 440 441 442 443
/**
 * 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)
{
444
    if (byte_size > INT_MAX / 8 || byte_size < 0)
445
        byte_size = -1;
446
    return init_get_bits(s, buffer, byte_size * 8);
447 448
}

449
static inline const uint8_t *align_get_bits(GetBitContext *s)
450
{
451
    int n = -get_bits_count(s) & 7;
452 453
    if (n)
        skip_bits(s, n);
454
    return s->buffer + (s->index >> 3);
455 456
}

457 458 459 460
#define init_vlc(vlc, nb_bits, nb_codes,                \
                 bits, bits_wrap, bits_size,            \
                 codes, codes_wrap, codes_size,         \
                 flags)                                 \
461 462 463 464
    ff_init_vlc_sparse(vlc, nb_bits, nb_codes,          \
                       bits, bits_wrap, bits_size,      \
                       codes, codes_wrap, codes_size,   \
                       NULL, 0, 0, flags)
465

466
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
467 468 469 470
                       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);
471
void ff_free_vlc(VLC *vlc);
472

473 474
#define INIT_VLC_LE             2
#define INIT_VLC_USE_NEW_STATIC 4
475

476 477 478 479 480 481 482
#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)
483

484
/**
485 486 487
 * 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.
488
 */
489 490
#define GET_VLC(code, name, gb, table, bits, max_depth)         \
    do {                                                        \
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 516 517 518 519 520
        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)

521
#define GET_RL_VLC_INTERNAL(level, run, name, gb, table, bits,  \
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
                   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);                                 \
545
    } while (0)
546 547

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

560 561
    OPEN_READER(re, s);
    UPDATE_CACHE(re, s);
562

563
    GET_VLC(code, re, s, table, bits, max_depth);
564

565
    CLOSE_READER(re, s);
566

567 568 569
    return code;
}

570 571
static inline int decode012(GetBitContext *gb)
{
572 573 574 575 576 577 578 579
    int n;
    n = get_bits1(gb);
    if (n == 0)
        return 0;
    else
        return get_bits1(gb) + 1;
}

580 581
static inline int decode210(GetBitContext *gb)
{
582 583 584 585 586 587 588 589 590 591 592
    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);
}

593 594 595 596 597 598 599 600 601 602 603 604 605 606
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;
}

607 608 609
//#define TRACE

#ifdef TRACE
610 611
static inline void print_bin(int bits, int n)
{
612
    int i;
613

614 615
    for (i = n - 1; i >= 0; i--)
        av_log(NULL, AV_LOG_DEBUG, "%d", (bits >> i) & 1);
616
    for (i = n; i < 24; i++)
617
        av_log(NULL, AV_LOG_DEBUG, " ");
618 619
}

620
static inline int get_bits_trace(GetBitContext *s, int n, const char *file,
621 622
                                 const char *func, int line)
{
623
    int r = get_bits(s, n);
624

625
    print_bin(r, n);
626
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n",
627 628
           r, n, r, get_bits_count(s) - n, file, func, line);

629 630
    return r;
}
631

632
static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],
633
                                int bits, int max_depth, const char *file,
634 635
                                const char *func, int line)
{
636 637 638 639
    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;
640
    int bits2 = show >> (24 - len);
641

642
    print_bin(bits2, len);
643

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

647 648
    return r;
}
649

650 651 652 653 654 655 656 657 658
#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); \
                                                                \
659
        len = name ## _index - pos + 1;                         \
660 661 662 663
        show = show >> (24 - len);                              \
                                                                \
        print_bin(show, len);                                   \
                                                                \
664 665
        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__);\
666 667 668
    } while (0)                                                 \


669
static inline int get_xbits_trace(GetBitContext *s, int n, const char *file,
670 671
                                  const char *func, int line)
{
672 673
    int show = show_bits(s, n);
    int r    = get_xbits(s, n);
674

675
    print_bin(show, n);
676
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n",
677 678
           show, n, r, get_bits_count(s) - n, file, func, line);

679 680 681
    return r;
}

682 683
#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__)
684
#define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
685 686 687

#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__)
688

689
#define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
690 691

#else //TRACE
692
#define tprintf(p, ...) { }
693
#define GET_RL_VLC GET_RL_VLC_INTERNAL
694 695
#endif

696
#endif /* AVCODEC_GET_BITS_H */