avcodec/alsdec: Check that input space for header exists in read_diff_float_data()
[ffmpeg.git] / 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 */