LCOV - code coverage report
Current view: top level - libavcodec - get_bits.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 135 149 90.6 %
Date: 2018-05-20 11:54:08 Functions: 25 26 96.2 %

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

Generated by: LCOV version 1.13