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

Generated by: LCOV version 1.13