git.sesse.net Git - ffmpeg/blob - libavcodec/get_bits.h

   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 static inline int get_bits_count(const GetBitContext *s)
 220 {
 221 #if CACHED_BITSTREAM_READER
 222     return s->index - s->bits_left;
 223 #else
 224     return s->index;
 225 #endif
 226 }
 227
 228 #if CACHED_BITSTREAM_READER
 229 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     if (is_le)
 237         s->cache = (uint64_t)AV_RL32(s->buffer + (s->index >> 3)) << s->bits_left | s->cache;
 238     else
 239         s->cache = s->cache | (uint64_t)AV_RB32(s->buffer + (s->index >> 3)) << (32 - s->bits_left);
 240     s->index     += 32;
 241     s->bits_left += 32;
 242 }
 243
 244 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     if (is_le)
 252         s->cache = AV_RL64(s->buffer + (s->index >> 3));
 253     else
 254         s->cache = AV_RB64(s->buffer + (s->index >> 3));
 255     s->index += 64;
 256     s->bits_left = 64;
 257 }
 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 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     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 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     s->index += n;
 298 #else
 299     s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
 300 #endif
 301 #endif
 302 }
 303
 304 #if CACHED_BITSTREAM_READER
 305 static inline void skip_remaining(GetBitContext *s, unsigned n)
 306 {
 307 #ifdef BITSTREAM_READER_LE
 308     s->cache >>= n;
 309 #else
 310     s->cache <<= n;
 311 #endif
 312     s->bits_left -= n;
 313 }
 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 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     OPEN_READER(re, s);
 333     av_assert2(n>0 && n<=25);
 334     UPDATE_CACHE(re, s);
 335     cache = GET_CACHE(re, s);
 336     sign  = ~cache >> 31;
 337     LAST_SKIP_BITS(re, s, n);
 338     CLOSE_READER(re, s);
 339     return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
 340 #endif
 341 }
 342
 343 #if !CACHED_BITSTREAM_READER
 344 static inline int get_xbits_le(GetBitContext *s, int n)
 345 {
 346     register int sign;
 347     register int32_t cache;
 348     OPEN_READER(re, s);
 349     av_assert2(n>0 && n<=25);
 350     UPDATE_CACHE_LE(re, s);
 351     cache = GET_CACHE(re, s);
 352     sign  = sign_extend(~cache, n) >> 31;
 353     LAST_SKIP_BITS(re, s, n);
 354     CLOSE_READER(re, s);
 355     return (zero_extend(sign ^ cache, n) ^ sign) - sign;
 356 }
 357 #endif
 358
 359 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     OPEN_READER(re, s);
 367     av_assert2(n>0 && n<=25);
 368     UPDATE_CACHE(re, s);
 369     tmp = SHOW_SBITS(re, s, n);
 370     LAST_SKIP_BITS(re, s, n);
 371     CLOSE_READER(re, s);
 372 #endif
 373     return tmp;
 374 }
 375
 376 /**
 377  * Read 1-25 bits.
 378  */
 379 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     OPEN_READER(re, s);
 402     av_assert2(n>0 && n<=25);
 403     UPDATE_CACHE(re, s);
 404     tmp = SHOW_UBITS(re, s, n);
 405     LAST_SKIP_BITS(re, s, n);
 406     CLOSE_READER(re, s);
 407 #endif
 408     av_assert2(tmp < UINT64_C(1) << n);
 409     return tmp;
 410 }
 411
 412 /**
 413  * Read 0-25 bits.
 414  */
 415 static av_always_inline int get_bitsz(GetBitContext *s, int n)
 416 {
 417     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 static inline unsigned int show_bits(GetBitContext *s, int n)
 447 {
 448     register unsigned int tmp;
 449 #if CACHED_BITSTREAM_READER
 450     if (n > s->bits_left)
 451 #ifdef BITSTREAM_READER_LE
 452         refill_32(s, 1);
 453 #else
 454         refill_32(s, 0);
 455 #endif
 456
 457     tmp = show_val(s, n);
 458 #else
 459     OPEN_READER_NOSIZE(re, s);
 460     av_assert2(n>0 && n<=25);
 461     UPDATE_CACHE(re, s);
 462     tmp = SHOW_UBITS(re, s, n);
 463 #endif
 464     return tmp;
 465 }
 466
 467 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     OPEN_READER(re, s);
 493     LAST_SKIP_BITS(re, s, n);
 494     CLOSE_READER(re, s);
 495 #endif
 496 }
 497
 498 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     unsigned int index = s->index;
 515     uint8_t result     = s->buffer[index >> 3];
 516 #ifdef BITSTREAM_READER_LE
 517     result >>= index & 7;
 518     result  &= 1;
 519 #else
 520     result <<= index & 7;
 521     result >>= 8 - 1;
 522 #endif
 523 #if !UNCHECKED_BITSTREAM_READER
 524     if (s->index < s->size_in_bits_plus8)
 525 #endif
 526         index++;
 527     s->index = index;
 528
 529     return result;
 530 #endif
 531 }
 532
 533 static inline unsigned int show_bits1(GetBitContext *s)
 534 {
 535     return show_bits(s, 1);
 536 }
 537
 538 static inline void skip_bits1(GetBitContext *s)
 539 {
 540     skip_bits(s, 1);
 541 }
 542
 543 /**
 544  * Read 0-32 bits.
 545  */
 546 static inline unsigned int get_bits_long(GetBitContext *s, int n)
 547 {
 548     av_assert2(n>=0 && n<=32);
 549     if (!n) {
 550         return 0;
 551 #if CACHED_BITSTREAM_READER
 552     }
 553     return get_bits(s, n);
 554 #else
 555     } else if (n <= MIN_CACHE_BITS) {
 556         return get_bits(s, n);
 557     } else {
 558 #ifdef BITSTREAM_READER_LE
 559         unsigned ret = get_bits(s, 16);
 560         return ret | (get_bits(s, n - 16) << 16);
 561 #else
 562         unsigned ret = get_bits(s, 16) << (n - 16);
 563         return ret | get_bits(s, n - 16);
 564 #endif
 565     }
 566 #endif
 567 }
 568
 569 /**
 570  * Read 0-64 bits.
 571  */
 572 static inline uint64_t get_bits64(GetBitContext *s, int n)
 573 {
 574     if (n <= 32) {
 575         return get_bits_long(s, n);
 576     } else {
 577 #ifdef BITSTREAM_READER_LE
 578         uint64_t ret = get_bits_long(s, 32);
 579         return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
 580 #else
 581         uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
 582         return ret | get_bits_long(s, 32);
 583 #endif
 584     }
 585 }
 586
 587 /**
 588  * Read 0-32 bits as a signed integer.
 589  */
 590 static inline int get_sbits_long(GetBitContext *s, int n)
 591 {
 592     // sign_extend(x, 0) is undefined
 593     if (!n)
 594         return 0;
 595
 596     return sign_extend(get_bits_long(s, n), n);
 597 }
 598
 599 /**
 600  * Show 0-32 bits.
 601  */
 602 static inline unsigned int show_bits_long(GetBitContext *s, int n)
 603 {
 604     if (n <= MIN_CACHE_BITS) {
 605         return show_bits(s, n);
 606     } else {
 607         GetBitContext gb = *s;
 608         return get_bits_long(&gb, n);
 609     }
 610 }
 611
 612 static inline int check_marker(void *logctx, GetBitContext *s, const char *msg)
 613 {
 614     int bit = get_bits1(s);
 615     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     return bit;
 620 }
 621
 622 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     int ret = 0;
 627
 628     if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {
 629         bit_size    = 0;
 630         buffer      = NULL;
 631         ret         = AVERROR_INVALIDDATA;
 632     }
 633
 634     buffer_size = (bit_size + 7) >> 3;
 635
 636     s->buffer             = buffer;
 637     s->size_in_bits       = bit_size;
 638     s->size_in_bits_plus8 = bit_size + 8;
 639     s->buffer_end         = buffer + buffer_size;
 640     s->index              = 0;
 641
 642 #if CACHED_BITSTREAM_READER
 643     s->cache              = 0;
 644     s->bits_left          = 0;
 645     refill_64(s, is_le);
 646 #endif
 647
 648     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 static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
 660                                 int bit_size)
 661 {
 662 #ifdef BITSTREAM_READER_LE
 663     return init_get_bits_xe(s, buffer, bit_size, 1);
 664 #else
 665     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 static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
 678                                  int byte_size)
 679 {
 680     if (byte_size > INT_MAX / 8 || byte_size < 0)
 681         byte_size = -1;
 682     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 static inline const uint8_t *align_get_bits(GetBitContext *s)
 694 {
 695     int n = -get_bits_count(s) & 7;
 696     if (n)
 697         skip_bits(s, n);
 698     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 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     *nb_bits = -*n;
 782     idx = show_bits(s, *nb_bits) + code;
 783     *n = table[idx][1];
 784
 785     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 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     unsigned idx = show_bits(s, bits);
 803     int code = table[idx][0];
 804     int n    = table[idx][1];
 805
 806     if (max_depth > 1 && n < 0) {
 807         skip_remaining(s, bits);
 808         code = set_idx(s, code, &n, &nb_bits, table);
 809         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     skip_remaining(s, n);
 815
 816     return code;
 817 #else
 818     int code;
 819
 820     OPEN_READER(re, s);
 821     UPDATE_CACHE(re, s);
 822
 823     GET_VLC(code, re, s, table, bits, max_depth);
 824
 825     CLOSE_READER(re, s);
 826
 827     return code;
 828 #endif
 829 }
 830
 831 static inline int decode012(GetBitContext *gb)
 832 {
 833     int n;
 834     n = get_bits1(gb);
 835     if (n == 0)
 836         return 0;
 837     else
 838         return get_bits1(gb) + 1;
 839 }
 840
 841 static inline int decode210(GetBitContext *gb)
 842 {
 843     if (get_bits1(gb))
 844         return 0;
 845     else
 846         return 2 - get_bits1(gb);
 847 }
 848
 849 static inline int get_bits_left(GetBitContext *gb)
 850 {
 851     return gb->size_in_bits - get_bits_count(gb);
 852 }
 853
 854 static inline int skip_1stop_8data_bits(GetBitContext *gb)
 855 {
 856     if (get_bits_left(gb) <= 0)
 857         return AVERROR_INVALIDDATA;
 858
 859     while (get_bits1(gb)) {
 860         skip_bits(gb, 8);
 861         if (get_bits_left(gb) <= 0)
 862             return AVERROR_INVALIDDATA;
 863     }
 864
 865     return 0;
 866 }
 867
 868 #endif /* AVCODEC_GET_BITS_H */