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/avassert.h" 35 36#include "defs.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 61typedef 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 72static inline unsigned int get_bits(GetBitContext *s, int n); 73static inline void skip_bits(GetBitContext *s, int n); 74static 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 219static 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 229static 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 244static 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 259static 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 274static 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 */ 291static 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 305static 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 */ 321static 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 344static 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 359static 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 */ 379static 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 */ 415static av_always_inline int get_bitsz(GetBitContext *s, int n) 416{ 417 return n ? get_bits(s, n) : 0; 418} 419 420static 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 */ 446static 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 467static 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 498static 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 533static inline unsigned int show_bits1(GetBitContext *s) 534{ 535 return show_bits(s, 1); 536} 537 538static inline void skip_bits1(GetBitContext *s) 539{ 540 skip_bits(s, 1); 541} 542 543/** 544 * Read 0-32 bits. 545 */ 546static 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 */ 572static 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 */ 590static 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 */ 602static 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 612static inline int init_get_bits_xe(GetBitContext *s, const uint8_t *buffer, 613 int bit_size, int is_le) 614{ 615 int buffer_size; 616 int ret = 0; 617 618 if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) { 619 bit_size = 0; 620 buffer = NULL; 621 ret = AVERROR_INVALIDDATA; 622 } 623 624 buffer_size = (bit_size + 7) >> 3; 625 626 s->buffer = buffer; 627 s->size_in_bits = bit_size; 628 s->size_in_bits_plus8 = bit_size + 8; 629 s->buffer_end = buffer + buffer_size; 630 s->index = 0; 631 632#if CACHED_BITSTREAM_READER 633 s->cache = 0; 634 s->bits_left = 0; 635 refill_64(s, is_le); 636#endif 637 638 return ret; 639} 640 641/** 642 * Initialize GetBitContext. 643 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes 644 * larger than the actual read bits because some optimized bitstream 645 * readers read 32 or 64 bit at once and could read over the end 646 * @param bit_size the size of the buffer in bits 647 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow. 648 */ 649static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer, 650 int bit_size) 651{ 652#ifdef BITSTREAM_READER_LE 653 return init_get_bits_xe(s, buffer, bit_size, 1); 654#else 655 return init_get_bits_xe(s, buffer, bit_size, 0); 656#endif 657} 658 659/** 660 * Initialize GetBitContext. 661 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes 662 * larger than the actual read bits because some optimized bitstream 663 * readers read 32 or 64 bit at once and could read over the end 664 * @param byte_size the size of the buffer in bytes 665 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow. 666 */ 667static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer, 668 int byte_size) 669{ 670 if (byte_size > INT_MAX / 8 || byte_size < 0) 671 byte_size = -1; 672 return init_get_bits(s, buffer, byte_size * 8); 673} 674 675static inline int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, 676 int byte_size) 677{ 678 if (byte_size > INT_MAX / 8 || byte_size < 0) 679 byte_size = -1; 680 return init_get_bits_xe(s, buffer, byte_size * 8, 1); 681} 682 683static inline const uint8_t *align_get_bits(GetBitContext *s) 684{ 685 int n = -get_bits_count(s) & 7; 686 if (n) 687 skip_bits(s, n); 688 return s->buffer + (s->index >> 3); 689} 690 691/** 692 * If the vlc code is invalid and max_depth=1, then no bits will be removed. 693 * If the vlc code is invalid and max_depth>1, then the number of bits removed 694 * is undefined. 695 */ 696#define GET_VLC(code, name, gb, table, bits, max_depth) \ 697 do { \ 698 int n, nb_bits; \ 699 unsigned int index; \ 700 \ 701 index = SHOW_UBITS(name, gb, bits); \ 702 code = table[index].sym; \ 703 n = table[index].len; \ 704 \ 705 if (max_depth > 1 && n < 0) { \ 706 LAST_SKIP_BITS(name, gb, bits); \ 707 UPDATE_CACHE(name, gb); \ 708 \ 709 nb_bits = -n; \ 710 \ 711 index = SHOW_UBITS(name, gb, nb_bits) + code; \ 712 code = table[index].sym; \ 713 n = table[index].len; \ 714 if (max_depth > 2 && n < 0) { \ 715 LAST_SKIP_BITS(name, gb, nb_bits); \ 716 UPDATE_CACHE(name, gb); \ 717 \ 718 nb_bits = -n; \ 719 \ 720 index = SHOW_UBITS(name, gb, nb_bits) + code; \ 721 code = table[index].sym; \ 722 n = table[index].len; \ 723 } \ 724 } \ 725 SKIP_BITS(name, gb, n); \ 726 } while (0) 727 728#define GET_RL_VLC(level, run, name, gb, table, bits, \ 729 max_depth, need_update) \ 730 do { \ 731 int n, nb_bits; \ 732 unsigned int index; \ 733 \ 734 index = SHOW_UBITS(name, gb, bits); \ 735 level = table[index].level; \ 736 n = table[index].len; \ 737 \ 738 if (max_depth > 1 && n < 0) { \ 739 SKIP_BITS(name, gb, bits); \ 740 if (need_update) { \ 741 UPDATE_CACHE(name, gb); \ 742 } \ 743 \ 744 nb_bits = -n; \ 745 \ 746 index = SHOW_UBITS(name, gb, nb_bits) + level; \ 747 level = table[index].level; \ 748 n = table[index].len; \ 749 if (max_depth > 2 && n < 0) { \ 750 LAST_SKIP_BITS(name, gb, nb_bits); \ 751 if (need_update) { \ 752 UPDATE_CACHE(name, gb); \ 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 } \ 760 } \ 761 run = table[index].run; \ 762 SKIP_BITS(name, gb, n); \ 763 } while (0) 764 765/* Return the LUT element for the given bitstream configuration. */ 766static inline int set_idx(GetBitContext *s, int code, int *n, int *nb_bits, 767 const VLCElem *table) 768{ 769 unsigned idx; 770 771 *nb_bits = -*n; 772 idx = show_bits(s, *nb_bits) + code; 773 *n = table[idx].len; 774 775 return table[idx].sym; 776} 777 778/** 779 * Parse a vlc code. 780 * @param bits is the number of bits which will be read at once, must be 781 * identical to nb_bits in init_vlc() 782 * @param max_depth is the number of times bits bits must be read to completely 783 * read the longest vlc code 784 * = (max_vlc_length + bits - 1) / bits 785 * @returns the code parsed or -1 if no vlc matches 786 */ 787static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, 788 int bits, int max_depth) 789{ 790#if CACHED_BITSTREAM_READER 791 int nb_bits; 792 unsigned idx = show_bits(s, bits); 793 int code = table[idx].sym; 794 int n = table[idx].len; 795 796 if (max_depth > 1 && n < 0) { 797 skip_remaining(s, bits); 798 code = set_idx(s, code, &n, &nb_bits, table); 799 if (max_depth > 2 && n < 0) { 800 skip_remaining(s, nb_bits); 801 code = set_idx(s, code, &n, &nb_bits, table); 802 } 803 } 804 skip_remaining(s, n); 805 806 return code; 807#else 808 int code; 809 810 OPEN_READER(re, s); 811 UPDATE_CACHE(re, s); 812 813 GET_VLC(code, re, s, table, bits, max_depth); 814 815 CLOSE_READER(re, s); 816 817 return code; 818#endif 819} 820 821static inline int decode012(GetBitContext *gb) 822{ 823 int n; 824 n = get_bits1(gb); 825 if (n == 0) 826 return 0; 827 else 828 return get_bits1(gb) + 1; 829} 830 831static inline int decode210(GetBitContext *gb) 832{ 833 if (get_bits1(gb)) 834 return 0; 835 else 836 return 2 - get_bits1(gb); 837} 838 839static inline int get_bits_left(GetBitContext *gb) 840{ 841 return gb->size_in_bits - get_bits_count(gb); 842} 843 844static inline int skip_1stop_8data_bits(GetBitContext *gb) 845{ 846 if (get_bits_left(gb) <= 0) 847 return AVERROR_INVALIDDATA; 848 849 while (get_bits1(gb)) { 850 skip_bits(gb, 8); 851 if (get_bits_left(gb) <= 0) 852 return AVERROR_INVALIDDATA; 853 } 854 855 return 0; 856} 857 858#endif /* AVCODEC_GET_BITS_H */ 859