GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/get_bits.h Lines: 178 212 84.0 %
Date: 2019-11-22 03:34:36 Branches: 49 72 68.1 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
3
 * Copyright (c) 2016 Alexandra Hájková
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * bitstream reader API header.
25
 */
26
27
#ifndef AVCODEC_GET_BITS_H
28
#define AVCODEC_GET_BITS_H
29
30
#include <stdint.h>
31
32
#include "libavutil/common.h"
33
#include "libavutil/intreadwrite.h"
34
#include "libavutil/log.h"
35
#include "libavutil/avassert.h"
36
#include "avcodec.h"
37
#include "mathops.h"
38
#include "vlc.h"
39
40
/*
41
 * Safe bitstream reading:
42
 * optionally, the get_bits API can check to ensure that we
43
 * don't read past input buffer boundaries. This is protected
44
 * with CONFIG_SAFE_BITSTREAM_READER at the global level, and
45
 * then below that with UNCHECKED_BITSTREAM_READER at the per-
46
 * decoder level. This means that decoders that check internally
47
 * can "#define UNCHECKED_BITSTREAM_READER 1" to disable
48
 * overread checks.
49
 * Boundary checking causes a minor performance penalty so for
50
 * applications that won't want/need this, it can be disabled
51
 * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".
52
 */
53
#ifndef UNCHECKED_BITSTREAM_READER
54
#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
55
#endif
56
57
#ifndef CACHED_BITSTREAM_READER
58
#define CACHED_BITSTREAM_READER 0
59
#endif
60
61
typedef struct GetBitContext {
62
    const uint8_t *buffer, *buffer_end;
63
#if CACHED_BITSTREAM_READER
64
    uint64_t cache;
65
    unsigned bits_left;
66
#endif
67
    int index;
68
    int size_in_bits;
69
    int size_in_bits_plus8;
70
} GetBitContext;
71
72
static inline unsigned int get_bits(GetBitContext *s, int n);
73
static inline void skip_bits(GetBitContext *s, int n);
74
static inline unsigned int show_bits(GetBitContext *s, int n);
75
76
/* Bitstream reader API docs:
77
 * name
78
 *   arbitrary name which is used as prefix for the internal variables
79
 *
80
 * gb
81
 *   getbitcontext
82
 *
83
 * OPEN_READER(name, gb)
84
 *   load gb into local variables
85
 *
86
 * CLOSE_READER(name, gb)
87
 *   store local vars in gb
88
 *
89
 * UPDATE_CACHE(name, gb)
90
 *   Refill the internal cache from the bitstream.
91
 *   After this call at least MIN_CACHE_BITS will be available.
92
 *
93
 * GET_CACHE(name, gb)
94
 *   Will output the contents of the internal cache,
95
 *   next bit is MSB of 32 or 64 bits (FIXME 64 bits).
96
 *
97
 * SHOW_UBITS(name, gb, num)
98
 *   Will return the next num bits.
99
 *
100
 * SHOW_SBITS(name, gb, num)
101
 *   Will return the next num bits and do sign extension.
102
 *
103
 * SKIP_BITS(name, gb, num)
104
 *   Will skip over the next num bits.
105
 *   Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
106
 *
107
 * SKIP_CACHE(name, gb, num)
108
 *   Will remove the next num bits from the cache (note SKIP_COUNTER
109
 *   MUST be called before UPDATE_CACHE / CLOSE_READER).
110
 *
111
 * SKIP_COUNTER(name, gb, num)
112
 *   Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
113
 *
114
 * LAST_SKIP_BITS(name, gb, num)
115
 *   Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
116
 *
117
 * BITS_LEFT(name, gb)
118
 *   Return the number of bits left
119
 *
120
 * For examples see get_bits, show_bits, skip_bits, get_vlc.
121
 */
122
123
#if CACHED_BITSTREAM_READER
124
#   define MIN_CACHE_BITS 64
125
#elif defined LONG_BITSTREAM_READER
126
#   define MIN_CACHE_BITS 32
127
#else
128
#   define MIN_CACHE_BITS 25
129
#endif
130
131
#if !CACHED_BITSTREAM_READER
132
133
#define OPEN_READER_NOSIZE(name, gb)            \
134
    unsigned int name ## _index = (gb)->index;  \
135
    unsigned int av_unused name ## _cache
136
137
#if UNCHECKED_BITSTREAM_READER
138
#define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)
139
140
#define BITS_AVAILABLE(name, gb) 1
141
#else
142
#define OPEN_READER(name, gb)                   \
143
    OPEN_READER_NOSIZE(name, gb);               \
144
    unsigned int name ## _size_plus8 = (gb)->size_in_bits_plus8
145
146
#define BITS_AVAILABLE(name, gb) name ## _index < name ## _size_plus8
147
#endif
148
149
#define CLOSE_READER(name, gb) (gb)->index = name ## _index
150
151
# ifdef LONG_BITSTREAM_READER
152
153
# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
154
      AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
155
156
# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
157
      AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))
158
159
#else
160
161
# define UPDATE_CACHE_LE(name, gb) name ## _cache = \
162
      AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
163
164
# define UPDATE_CACHE_BE(name, gb) name ## _cache = \
165
      AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)
166
167
#endif
168
169
170
#ifdef BITSTREAM_READER_LE
171
172
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
173
174
# define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
175
176
#else
177
178
# define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
179
180
# define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
181
182
#endif
183
184
#if UNCHECKED_BITSTREAM_READER
185
#   define SKIP_COUNTER(name, gb, num) name ## _index += (num)
186
#else
187
#   define SKIP_COUNTER(name, gb, num) \
188
    name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
189
#endif
190
191
#define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))
192
193
#define SKIP_BITS(name, gb, num)                \
194
    do {                                        \
195
        SKIP_CACHE(name, gb, num);              \
196
        SKIP_COUNTER(name, gb, num);            \
197
    } while (0)
198
199
#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
200
201
#define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)
202
#define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)
203
204
#define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)
205
#define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)
206
207
#ifdef BITSTREAM_READER_LE
208
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
209
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
210
#else
211
#   define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
212
#   define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
213
#endif
214
215
#define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
216
217
#endif
218
219
325456845
static inline int get_bits_count(const GetBitContext *s)
220
{
221
#if CACHED_BITSTREAM_READER
222
63858
    return s->index - s->bits_left;
223
#else
224
325392987
    return s->index;
225
#endif
226
}
227
228
#if CACHED_BITSTREAM_READER
229
1348839
static inline void refill_32(GetBitContext *s, int is_le)
230
{
231
#if !UNCHECKED_BITSTREAM_READER
232
    if (s->index >> 3 >= s->buffer_end - s->buffer)
233
        return;
234
#endif
235
236
1348839
    if (is_le)
237
    s->cache       = (uint64_t)AV_RL32(s->buffer + (s->index >> 3)) << s->bits_left | s->cache;
238
    else
239
1348839
    s->cache       = s->cache | (uint64_t)AV_RB32(s->buffer + (s->index >> 3)) << (32 - s->bits_left);
240
1348839
    s->index     += 32;
241
1348839
    s->bits_left += 32;
242
1348839
}
243
244
716
static inline void refill_64(GetBitContext *s, int is_le)
245
{
246
#if !UNCHECKED_BITSTREAM_READER
247
    if (s->index >> 3 >= s->buffer_end - s->buffer)
248
        return;
249
#endif
250
251
716
    if (is_le)
252
    s->cache = AV_RL64(s->buffer + (s->index >> 3));
253
    else
254
716
    s->cache = AV_RB64(s->buffer + (s->index >> 3));
255
716
    s->index += 64;
256
716
    s->bits_left = 64;
257
716
}
258
259
static inline uint64_t get_val(GetBitContext *s, unsigned n, int is_le)
260
{
261
    uint64_t ret;
262
    av_assert2(n>0 && n<=63);
263
    if (is_le) {
264
        ret = s->cache & ((UINT64_C(1) << n) - 1);
265
        s->cache >>= n;
266
    } else {
267
        ret = s->cache >> (64 - n);
268
        s->cache <<= n;
269
    }
270
    s->bits_left -= n;
271
    return ret;
272
}
273
274
35342927
static inline unsigned show_val(const GetBitContext *s, unsigned n)
275
{
276
#ifdef BITSTREAM_READER_LE
277
    return s->cache & ((UINT64_C(1) << n) - 1);
278
#else
279
35342927
    return s->cache >> (64 - n);
280
#endif
281
}
282
#endif
283
284
/**
285
 * Skips the specified number of bits.
286
 * @param n the number of bits to skip,
287
 *          For the UNCHECKED_BITSTREAM_READER this must not cause the distance
288
 *          from the start to overflow int32_t. Staying within the bitstream + padding
289
 *          is sufficient, too.
290
 */
291
3235237
static inline void skip_bits_long(GetBitContext *s, int n)
292
{
293
#if CACHED_BITSTREAM_READER
294
    skip_bits(s, n);
295
#else
296
#if UNCHECKED_BITSTREAM_READER
297
2612835
    s->index += n;
298
#else
299
622402
    s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
300
#endif
301
#endif
302
3235237
}
303
304
#if CACHED_BITSTREAM_READER
305
35342927
static inline void skip_remaining(GetBitContext *s, unsigned n)
306
{
307
#ifdef BITSTREAM_READER_LE
308
    s->cache >>= n;
309
#else
310
35342927
    s->cache <<= n;
311
#endif
312
35342927
    s->bits_left -= n;
313
35342927
}
314
#endif
315
316
/**
317
 * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
318
 * if MSB not set it is negative
319
 * @param n length in bits
320
 */
321
26555110
static inline int get_xbits(GetBitContext *s, int n)
322
{
323
#if CACHED_BITSTREAM_READER
324
    int32_t cache = show_bits(s, 32);
325
    int sign = ~cache >> 31;
326
    skip_remaining(s, n);
327
328
    return ((((uint32_t)(sign ^ cache)) >> (32 - n)) ^ sign) - sign;
329
#else
330
    register int sign;
331
    register int32_t cache;
332
26555110
    OPEN_READER(re, s);
333
    av_assert2(n>0 && n<=25);
334
26555110
    UPDATE_CACHE(re, s);
335
26555110
    cache = GET_CACHE(re, s);
336
26555110
    sign  = ~cache >> 31;
337
26555110
    LAST_SKIP_BITS(re, s, n);
338
26555110
    CLOSE_READER(re, s);
339
26555110
    return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
340
#endif
341
}
342
343
#if !CACHED_BITSTREAM_READER
344
336
static inline int get_xbits_le(GetBitContext *s, int n)
345
{
346
    register int sign;
347
    register int32_t cache;
348
336
    OPEN_READER(re, s);
349
    av_assert2(n>0 && n<=25);
350
336
    UPDATE_CACHE_LE(re, s);
351
336
    cache = GET_CACHE(re, s);
352
336
    sign  = sign_extend(~cache, n) >> 31;
353
336
    LAST_SKIP_BITS(re, s, n);
354
336
    CLOSE_READER(re, s);
355
336
    return (zero_extend(sign ^ cache, n) ^ sign) - sign;
356
}
357
#endif
358
359
32224005
static inline int get_sbits(GetBitContext *s, int n)
360
{
361
    register int tmp;
362
#if CACHED_BITSTREAM_READER
363
    av_assert2(n>0 && n<=25);
364
    tmp = sign_extend(get_bits(s, n), n);
365
#else
366
32224005
    OPEN_READER(re, s);
367
    av_assert2(n>0 && n<=25);
368
32224005
    UPDATE_CACHE(re, s);
369
32224005
    tmp = SHOW_SBITS(re, s, n);
370
32224005
    LAST_SKIP_BITS(re, s, n);
371
32224005
    CLOSE_READER(re, s);
372
#endif
373
32224005
    return tmp;
374
}
375
376
/**
377
 * Read 1-25 bits.
378
 */
379
312860137
static inline unsigned int get_bits(GetBitContext *s, int n)
380
{
381
    register unsigned int tmp;
382
#if CACHED_BITSTREAM_READER
383
384
    av_assert2(n>0 && n<=32);
385
    if (n > s->bits_left) {
386
#ifdef BITSTREAM_READER_LE
387
        refill_32(s, 1);
388
#else
389
        refill_32(s, 0);
390
#endif
391
        if (s->bits_left < 32)
392
            s->bits_left = n;
393
    }
394
395
#ifdef BITSTREAM_READER_LE
396
    tmp = get_val(s, n, 1);
397
#else
398
    tmp = get_val(s, n, 0);
399
#endif
400
#else
401
312860137
    OPEN_READER(re, s);
402
    av_assert2(n>0 && n<=25);
403
312860137
    UPDATE_CACHE(re, s);
404
312860137
    tmp = SHOW_UBITS(re, s, n);
405
312860137
    LAST_SKIP_BITS(re, s, n);
406
312860137
    CLOSE_READER(re, s);
407
#endif
408
    av_assert2(tmp < UINT64_C(1) << n);
409
312860137
    return tmp;
410
}
411
412
/**
413
 * Read 0-25 bits.
414
 */
415
25594177
static av_always_inline int get_bitsz(GetBitContext *s, int n)
416
{
417
25594177
    return n ? get_bits(s, n) : 0;
418
}
419
420
static inline unsigned int get_bits_le(GetBitContext *s, int n)
421
{
422
#if CACHED_BITSTREAM_READER
423
    av_assert2(n>0 && n<=32);
424
    if (n > s->bits_left) {
425
        refill_32(s, 1);
426
        if (s->bits_left < 32)
427
            s->bits_left = n;
428
    }
429
430
    return get_val(s, n, 1);
431
#else
432
    register int tmp;
433
    OPEN_READER(re, s);
434
    av_assert2(n>0 && n<=25);
435
    UPDATE_CACHE_LE(re, s);
436
    tmp = SHOW_UBITS_LE(re, s, n);
437
    LAST_SKIP_BITS(re, s, n);
438
    CLOSE_READER(re, s);
439
    return tmp;
440
#endif
441
}
442
443
/**
444
 * Show 1-25 bits.
445
 */
446
145912476
static inline unsigned int show_bits(GetBitContext *s, int n)
447
{
448
    register unsigned int tmp;
449
#if CACHED_BITSTREAM_READER
450
35342927
    if (n > s->bits_left)
451
#ifdef BITSTREAM_READER_LE
452
        refill_32(s, 1);
453
#else
454
1348839
        refill_32(s, 0);
455
#endif
456
457
35342927
    tmp = show_val(s, n);
458
#else
459
110569549
    OPEN_READER_NOSIZE(re, s);
460
    av_assert2(n>0 && n<=25);
461
110569549
    UPDATE_CACHE(re, s);
462
110569549
    tmp = SHOW_UBITS(re, s, n);
463
#endif
464
145912476
    return tmp;
465
}
466
467
108743817
static inline void skip_bits(GetBitContext *s, int n)
468
{
469
#if CACHED_BITSTREAM_READER
470
    if (n < s->bits_left)
471
        skip_remaining(s, n);
472
    else {
473
        n -= s->bits_left;
474
        s->cache = 0;
475
        s->bits_left = 0;
476
477
        if (n >= 64) {
478
            unsigned skip = (n / 8) * 8;
479
480
            n -= skip;
481
            s->index += skip;
482
        }
483
#ifdef BITSTREAM_READER_LE
484
        refill_64(s, 1);
485
#else
486
        refill_64(s, 0);
487
#endif
488
        if (n)
489
            skip_remaining(s, n);
490
    }
491
#else
492
108743817
    OPEN_READER(re, s);
493
108743817
    LAST_SKIP_BITS(re, s, n);
494
108743817
    CLOSE_READER(re, s);
495
#endif
496
108743817
}
497
498
430906216
static inline unsigned int get_bits1(GetBitContext *s)
499
{
500
#if CACHED_BITSTREAM_READER
501
    if (!s->bits_left)
502
#ifdef BITSTREAM_READER_LE
503
        refill_64(s, 1);
504
#else
505
        refill_64(s, 0);
506
#endif
507
508
#ifdef BITSTREAM_READER_LE
509
    return get_val(s, 1, 1);
510
#else
511
    return get_val(s, 1, 0);
512
#endif
513
#else
514
430906216
    unsigned int index = s->index;
515
430906216
    uint8_t result     = s->buffer[index >> 3];
516
#ifdef BITSTREAM_READER_LE
517
260779309
    result >>= index & 7;
518
260779309
    result  &= 1;
519
#else
520
170126907
    result <<= index & 7;
521
170126907
    result >>= 8 - 1;
522
#endif
523
#if !UNCHECKED_BITSTREAM_READER
524
395796052
    if (s->index < s->size_in_bits_plus8)
525
#endif
526
430891004
        index++;
527
430906216
    s->index = index;
528
529
430906216
    return result;
530
#endif
531
}
532
533
534
static inline unsigned int show_bits1(GetBitContext *s)
534
{
535
534
    return show_bits(s, 1);
536
}
537
538
229240
static inline void skip_bits1(GetBitContext *s)
539
{
540
229240
    skip_bits(s, 1);
541
229240
}
542
543
/**
544
 * Read 0-32 bits.
545
 */
546
26529883
static inline unsigned int get_bits_long(GetBitContext *s, int n)
547
{
548
    av_assert2(n>=0 && n<=32);
549
26529883
    if (!n) {
550
240222
        return 0;
551
#if CACHED_BITSTREAM_READER
552
    }
553
    return get_bits(s, n);
554
#else
555
26289661
    } else if (n <= MIN_CACHE_BITS) {
556
23162145
        return get_bits(s, n);
557
    } else {
558
#ifdef BITSTREAM_READER_LE
559
2180
        unsigned ret = get_bits(s, 16);
560
2180
        return ret | (get_bits(s, n - 16) << 16);
561
#else
562
3125336
        unsigned ret = get_bits(s, 16) << (n - 16);
563
3125336
        return ret | get_bits(s, n - 16);
564
#endif
565
    }
566
#endif
567
}
568
569
/**
570
 * Read 0-64 bits.
571
 */
572
6430
static inline uint64_t get_bits64(GetBitContext *s, int n)
573
{
574
6430
    if (n <= 32) {
575
6352
        return get_bits_long(s, n);
576
    } else {
577
#ifdef BITSTREAM_READER_LE
578
23
        uint64_t ret = get_bits_long(s, 32);
579
23
        return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
580
#else
581
55
        uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
582
55
        return ret | get_bits_long(s, 32);
583
#endif
584
    }
585
}
586
587
/**
588
 * Read 0-32 bits as a signed integer.
589
 */
590
4743930
static inline int get_sbits_long(GetBitContext *s, int n)
591
{
592
    // sign_extend(x, 0) is undefined
593
4743930
    if (!n)
594
        return 0;
595
596
4743930
    return sign_extend(get_bits_long(s, n), n);
597
}
598
599
/**
600
 * Show 0-32 bits.
601
 */
602
2918918
static inline unsigned int show_bits_long(GetBitContext *s, int n)
603
{
604
2918918
    if (n <= MIN_CACHE_BITS) {
605
24644
        return show_bits(s, n);
606
    } else {
607
2894274
        GetBitContext gb = *s;
608
2894274
        return get_bits_long(&gb, n);
609
    }
610
}
611
612
23464
static inline int check_marker(void *logctx, GetBitContext *s, const char *msg)
613
{
614
23464
    int bit = get_bits1(s);
615
23464
    if (!bit)
616
        av_log(logctx, AV_LOG_INFO, "Marker bit missing at %d of %d %s\n",
617
               get_bits_count(s) - 1, s->size_in_bits, msg);
618
619
23464
    return bit;
620
}
621
622
26784651
static inline int init_get_bits_xe(GetBitContext *s, const uint8_t *buffer,
623
                                   int bit_size, int is_le)
624
{
625
    int buffer_size;
626
26784651
    int ret = 0;
627
628

26784651
    if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {
629
12
        bit_size    = 0;
630
12
        buffer      = NULL;
631
12
        ret         = AVERROR_INVALIDDATA;
632
    }
633
634
26784651
    buffer_size = (bit_size + 7) >> 3;
635
636
26784651
    s->buffer             = buffer;
637
26784651
    s->size_in_bits       = bit_size;
638
26784651
    s->size_in_bits_plus8 = bit_size + 8;
639
26784651
    s->buffer_end         = buffer + buffer_size;
640
26784651
    s->index              = 0;
641
642
#if CACHED_BITSTREAM_READER
643
716
    s->cache              = 0;
644
716
    s->bits_left          = 0;
645
716
    refill_64(s, is_le);
646
#endif
647
648
26784651
    return ret;
649
}
650
651
/**
652
 * Initialize GetBitContext.
653
 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
654
 *        larger than the actual read bits because some optimized bitstream
655
 *        readers read 32 or 64 bit at once and could read over the end
656
 * @param bit_size the size of the buffer in bits
657
 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
658
 */
659
26784651
static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
660
                                int bit_size)
661
{
662
#ifdef BITSTREAM_READER_LE
663
64128
    return init_get_bits_xe(s, buffer, bit_size, 1);
664
#else
665
26720523
    return init_get_bits_xe(s, buffer, bit_size, 0);
666
#endif
667
}
668
669
/**
670
 * Initialize GetBitContext.
671
 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
672
 *        larger than the actual read bits because some optimized bitstream
673
 *        readers read 32 or 64 bit at once and could read over the end
674
 * @param byte_size the size of the buffer in bytes
675
 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
676
 */
677
298314
static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
678
                                 int byte_size)
679
{
680

298314
    if (byte_size > INT_MAX / 8 || byte_size < 0)
681
        byte_size = -1;
682
298314
    return init_get_bits(s, buffer, byte_size * 8);
683
}
684
685
static inline int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer,
686
                                    int byte_size)
687
{
688
    if (byte_size > INT_MAX / 8 || byte_size < 0)
689
        byte_size = -1;
690
    return init_get_bits_xe(s, buffer, byte_size * 8, 1);
691
}
692
693
259956
static inline const uint8_t *align_get_bits(GetBitContext *s)
694
{
695
259956
    int n = -get_bits_count(s) & 7;
696
259956
    if (n)
697
89368
        skip_bits(s, n);
698
259956
    return s->buffer + (s->index >> 3);
699
}
700
701
/**
702
 * If the vlc code is invalid and max_depth=1, then no bits will be removed.
703
 * If the vlc code is invalid and max_depth>1, then the number of bits removed
704
 * is undefined.
705
 */
706
#define GET_VLC(code, name, gb, table, bits, max_depth)         \
707
    do {                                                        \
708
        int n, nb_bits;                                         \
709
        unsigned int index;                                     \
710
                                                                \
711
        index = SHOW_UBITS(name, gb, bits);                     \
712
        code  = table[index][0];                                \
713
        n     = table[index][1];                                \
714
                                                                \
715
        if (max_depth > 1 && n < 0) {                           \
716
            LAST_SKIP_BITS(name, gb, bits);                     \
717
            UPDATE_CACHE(name, gb);                             \
718
                                                                \
719
            nb_bits = -n;                                       \
720
                                                                \
721
            index = SHOW_UBITS(name, gb, nb_bits) + code;       \
722
            code  = table[index][0];                            \
723
            n     = table[index][1];                            \
724
            if (max_depth > 2 && n < 0) {                       \
725
                LAST_SKIP_BITS(name, gb, nb_bits);              \
726
                UPDATE_CACHE(name, gb);                         \
727
                                                                \
728
                nb_bits = -n;                                   \
729
                                                                \
730
                index = SHOW_UBITS(name, gb, nb_bits) + code;   \
731
                code  = table[index][0];                        \
732
                n     = table[index][1];                        \
733
            }                                                   \
734
        }                                                       \
735
        SKIP_BITS(name, gb, n);                                 \
736
    } while (0)
737
738
#define GET_RL_VLC(level, run, name, gb, table, bits,  \
739
                   max_depth, need_update)                      \
740
    do {                                                        \
741
        int n, nb_bits;                                         \
742
        unsigned int index;                                     \
743
                                                                \
744
        index = SHOW_UBITS(name, gb, bits);                     \
745
        level = table[index].level;                             \
746
        n     = table[index].len;                               \
747
                                                                \
748
        if (max_depth > 1 && n < 0) {                           \
749
            SKIP_BITS(name, gb, bits);                          \
750
            if (need_update) {                                  \
751
                UPDATE_CACHE(name, gb);                         \
752
            }                                                   \
753
                                                                \
754
            nb_bits = -n;                                       \
755
                                                                \
756
            index = SHOW_UBITS(name, gb, nb_bits) + level;      \
757
            level = table[index].level;                         \
758
            n     = table[index].len;                           \
759
            if (max_depth > 2 && n < 0) {                       \
760
                LAST_SKIP_BITS(name, gb, nb_bits);              \
761
                if (need_update) {                              \
762
                    UPDATE_CACHE(name, gb);                     \
763
                }                                               \
764
                nb_bits = -n;                                   \
765
                                                                \
766
                index = SHOW_UBITS(name, gb, nb_bits) + level;  \
767
                level = table[index].level;                     \
768
                n     = table[index].len;                       \
769
            }                                                   \
770
        }                                                       \
771
        run = table[index].run;                                 \
772
        SKIP_BITS(name, gb, n);                                 \
773
    } while (0)
774
775
/* Return the LUT element for the given bitstream configuration. */
776
80383
static inline int set_idx(GetBitContext *s, int code, int *n, int *nb_bits,
777
                          VLC_TYPE (*table)[2])
778
{
779
    unsigned idx;
780
781
80383
    *nb_bits = -*n;
782
80383
    idx = show_bits(s, *nb_bits) + code;
783
80383
    *n = table[idx][1];
784
785
80383
    return table[idx][0];
786
}
787
788
/**
789
 * Parse a vlc code.
790
 * @param bits is the number of bits which will be read at once, must be
791
 *             identical to nb_bits in init_vlc()
792
 * @param max_depth is the number of times bits bits must be read to completely
793
 *                  read the longest vlc code
794
 *                  = (max_vlc_length + bits - 1) / bits
795
 * @returns the code parsed or -1 if no vlc matches
796
 */
797
353779915
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
798
                                     int bits, int max_depth)
799
{
800
#if CACHED_BITSTREAM_READER
801
    int nb_bits;
802
35262544
    unsigned idx = show_bits(s, bits);
803
35262544
    int code = table[idx][0];
804
35262544
    int n    = table[idx][1];
805
806

35262544
    if (max_depth > 1 && n < 0) {
807
80383
        skip_remaining(s, bits);
808
80383
        code = set_idx(s, code, &n, &nb_bits, table);
809

80383
        if (max_depth > 2 && n < 0) {
810
            skip_remaining(s, nb_bits);
811
            code = set_idx(s, code, &n, &nb_bits, table);
812
        }
813
    }
814
35262544
    skip_remaining(s, n);
815
816
35262544
    return code;
817
#else
818
    int code;
819
820
318517371
    OPEN_READER(re, s);
821
318517371
    UPDATE_CACHE(re, s);
822
823


318517371
    GET_VLC(code, re, s, table, bits, max_depth);
824
825
318517371
    CLOSE_READER(re, s);
826
827
318517371
    return code;
828
#endif
829
}
830
831
378491
static inline int decode012(GetBitContext *gb)
832
{
833
    int n;
834
378491
    n = get_bits1(gb);
835
378491
    if (n == 0)
836
263636
        return 0;
837
    else
838
114855
        return get_bits1(gb) + 1;
839
}
840
841
180238
static inline int decode210(GetBitContext *gb)
842
{
843
180238
    if (get_bits1(gb))
844
131041
        return 0;
845
    else
846
49197
        return 2 - get_bits1(gb);
847
}
848
849
291046057
static inline int get_bits_left(GetBitContext *gb)
850
{
851
291046057
    return gb->size_in_bits - get_bits_count(gb);
852
}
853
854
117777
static inline int skip_1stop_8data_bits(GetBitContext *gb)
855
{
856
117777
    if (get_bits_left(gb) <= 0)
857
        return AVERROR_INVALIDDATA;
858
859
119334
    while (get_bits1(gb)) {
860
1557
        skip_bits(gb, 8);
861
1557
        if (get_bits_left(gb) <= 0)
862
            return AVERROR_INVALIDDATA;
863
    }
864
865
117777
    return 0;
866
}
867
868
#endif /* AVCODEC_GET_BITS_H */