FFmpeg
get_bits.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (c) 2016 Alexandra Hájková
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * bitstream reader API header.
25  */
26 
27 #ifndef AVCODEC_GET_BITS_H
28 #define AVCODEC_GET_BITS_H
29 
30 #include <stdint.h>
31 
32 #include "libavutil/common.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/avassert.h"
35 
36 #include "defs.h"
37 #include "mathops.h"
38 #include "vlc.h"
39 
40 /*
41  * Safe bitstream reading:
42  * optionally, the get_bits API can check to ensure that we
43  * don't read past input buffer boundaries. This is protected
44  * with CONFIG_SAFE_BITSTREAM_READER at the global level, and
45  * then below that with UNCHECKED_BITSTREAM_READER at the per-
46  * decoder level. This means that decoders that check internally
47  * can "#define UNCHECKED_BITSTREAM_READER 1" to disable
48  * overread checks.
49  * Boundary checking causes a minor performance penalty so for
50  * applications that won't want/need this, it can be disabled
51  * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".
52  */
53 #ifndef UNCHECKED_BITSTREAM_READER
54 #define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
55 #endif
56 
57 #ifndef CACHED_BITSTREAM_READER
58 #define CACHED_BITSTREAM_READER 0
59 #endif
60 
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;
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  */
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
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 init_get_bits_xe(GetBitContext *s, const uint8_t *buffer,
613  int bit_size, int is_le)
614 {
615  int buffer_size;
616  int ret = 0;
617 
618  if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {
619  bit_size = 0;
620  buffer = NULL;
622  }
623 
624  buffer_size = (bit_size + 7) >> 3;
625 
626  s->buffer = buffer;
627  s->size_in_bits = bit_size;
628  s->size_in_bits_plus8 = bit_size + 8;
629  s->buffer_end = buffer + buffer_size;
630  s->index = 0;
631 
632 #if CACHED_BITSTREAM_READER
633  s->cache = 0;
634  s->bits_left = 0;
635  refill_64(s, is_le);
636 #endif
637 
638  return ret;
639 }
640 
641 /**
642  * Initialize GetBitContext.
643  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
644  * larger than the actual read bits because some optimized bitstream
645  * readers read 32 or 64 bit at once and could read over the end
646  * @param bit_size the size of the buffer in bits
647  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
648  */
649 static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
650  int bit_size)
651 {
652 #ifdef BITSTREAM_READER_LE
653  return init_get_bits_xe(s, buffer, bit_size, 1);
654 #else
655  return init_get_bits_xe(s, buffer, bit_size, 0);
656 #endif
657 }
658 
659 /**
660  * Initialize GetBitContext.
661  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
662  * larger than the actual read bits because some optimized bitstream
663  * readers read 32 or 64 bit at once and could read over the end
664  * @param byte_size the size of the buffer in bytes
665  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
666  */
667 static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
668  int byte_size)
669 {
670  if (byte_size > INT_MAX / 8 || byte_size < 0)
671  byte_size = -1;
672  return init_get_bits(s, buffer, byte_size * 8);
673 }
674 
675 static inline int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer,
676  int byte_size)
677 {
678  if (byte_size > INT_MAX / 8 || byte_size < 0)
679  byte_size = -1;
680  return init_get_bits_xe(s, buffer, byte_size * 8, 1);
681 }
682 
683 static inline const uint8_t *align_get_bits(GetBitContext *s)
684 {
685  int n = -get_bits_count(s) & 7;
686  if (n)
687  skip_bits(s, n);
688  return s->buffer + (s->index >> 3);
689 }
690 
691 /**
692  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
693  * If the vlc code is invalid and max_depth>1, then the number of bits removed
694  * is undefined.
695  */
696 #define GET_VLC(code, name, gb, table, bits, max_depth) \
697  do { \
698  int n, nb_bits; \
699  unsigned int index; \
700  \
701  index = SHOW_UBITS(name, gb, bits); \
702  code = table[index].sym; \
703  n = table[index].len; \
704  \
705  if (max_depth > 1 && n < 0) { \
706  LAST_SKIP_BITS(name, gb, bits); \
707  UPDATE_CACHE(name, gb); \
708  \
709  nb_bits = -n; \
710  \
711  index = SHOW_UBITS(name, gb, nb_bits) + code; \
712  code = table[index].sym; \
713  n = table[index].len; \
714  if (max_depth > 2 && n < 0) { \
715  LAST_SKIP_BITS(name, gb, nb_bits); \
716  UPDATE_CACHE(name, gb); \
717  \
718  nb_bits = -n; \
719  \
720  index = SHOW_UBITS(name, gb, nb_bits) + code; \
721  code = table[index].sym; \
722  n = table[index].len; \
723  } \
724  } \
725  SKIP_BITS(name, gb, n); \
726  } while (0)
727 
728 #define GET_RL_VLC(level, run, name, gb, table, bits, \
729  max_depth, need_update) \
730  do { \
731  int n, nb_bits; \
732  unsigned int index; \
733  \
734  index = SHOW_UBITS(name, gb, bits); \
735  level = table[index].level; \
736  n = table[index].len; \
737  \
738  if (max_depth > 1 && n < 0) { \
739  SKIP_BITS(name, gb, bits); \
740  if (need_update) { \
741  UPDATE_CACHE(name, gb); \
742  } \
743  \
744  nb_bits = -n; \
745  \
746  index = SHOW_UBITS(name, gb, nb_bits) + level; \
747  level = table[index].level; \
748  n = table[index].len; \
749  if (max_depth > 2 && n < 0) { \
750  LAST_SKIP_BITS(name, gb, nb_bits); \
751  if (need_update) { \
752  UPDATE_CACHE(name, gb); \
753  } \
754  nb_bits = -n; \
755  \
756  index = SHOW_UBITS(name, gb, nb_bits) + level; \
757  level = table[index].level; \
758  n = table[index].len; \
759  } \
760  } \
761  run = table[index].run; \
762  SKIP_BITS(name, gb, n); \
763  } while (0)
764 
765 /* Return the LUT element for the given bitstream configuration. */
766 static inline int set_idx(GetBitContext *s, int code, int *n, int *nb_bits,
767  const VLCElem *table)
768 {
769  unsigned idx;
770 
771  *nb_bits = -*n;
772  idx = show_bits(s, *nb_bits) + code;
773  *n = table[idx].len;
774 
775  return table[idx].sym;
776 }
777 
778 /**
779  * Parse a vlc code.
780  * @param bits is the number of bits which will be read at once, must be
781  * identical to nb_bits in init_vlc()
782  * @param max_depth is the number of times bits bits must be read to completely
783  * read the longest vlc code
784  * = (max_vlc_length + bits - 1) / bits
785  * @returns the code parsed or -1 if no vlc matches
786  */
788  int bits, int max_depth)
789 {
790 #if CACHED_BITSTREAM_READER
791  int nb_bits;
792  unsigned idx = show_bits(s, bits);
793  int code = table[idx].sym;
794  int n = table[idx].len;
795 
796  if (max_depth > 1 && n < 0) {
797  skip_remaining(s, bits);
798  code = set_idx(s, code, &n, &nb_bits, table);
799  if (max_depth > 2 && n < 0) {
800  skip_remaining(s, nb_bits);
801  code = set_idx(s, code, &n, &nb_bits, table);
802  }
803  }
804  skip_remaining(s, n);
805 
806  return code;
807 #else
808  int code;
809 
810  OPEN_READER(re, s);
811  UPDATE_CACHE(re, s);
812 
813  GET_VLC(code, re, s, table, bits, max_depth);
814 
815  CLOSE_READER(re, s);
816 
817  return code;
818 #endif
819 }
820 
821 static inline int decode012(GetBitContext *gb)
822 {
823  int n;
824  n = get_bits1(gb);
825  if (n == 0)
826  return 0;
827  else
828  return get_bits1(gb) + 1;
829 }
830 
831 static inline int decode210(GetBitContext *gb)
832 {
833  if (get_bits1(gb))
834  return 0;
835  else
836  return 2 - get_bits1(gb);
837 }
838 
839 static inline int get_bits_left(GetBitContext *gb)
840 {
841  return gb->size_in_bits - get_bits_count(gb);
842 }
843 
844 static inline int skip_1stop_8data_bits(GetBitContext *gb)
845 {
846  if (get_bits_left(gb) <= 0)
847  return AVERROR_INVALIDDATA;
848 
849  while (get_bits1(gb)) {
850  skip_bits(gb, 8);
851  if (get_bits_left(gb) <= 0)
852  return AVERROR_INVALIDDATA;
853  }
854 
855  return 0;
856 }
857 
858 #endif /* AVCODEC_GET_BITS_H */
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
av_clip
#define av_clip
Definition: common.h:95
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
show_bits1
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:533
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
GET_VLC
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
Definition: get_bits.h:696
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
table
static const uint16_t table[]
Definition: prosumer.c:205
zero_extend
static av_const unsigned zero_extend(unsigned val, unsigned bits)
Definition: mathops.h:142
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
OPEN_READER_NOSIZE
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:133
GetBitContext::size_in_bits_plus8
int size_in_bits_plus8
Definition: get_bits.h:69
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
GetBitContext
Definition: get_bits.h:61
avassert.h
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
bits
uint8_t bits
Definition: vp3data.h:128
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:821
SHOW_UBITS_LE
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:201
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
mathops.h
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
index
int index
Definition: gxfenc.c:89
VLCElem
Definition: vlc.h:27
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
GetBitContext::index
int index
Definition: get_bits.h:67
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:321
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:169
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
common.h
MIN_CACHE_BITS
#define MIN_CACHE_BITS
Definition: get_bits.h:128
av_always_inline
#define av_always_inline
Definition: attributes.h:49
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:62
get_xbits_le
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:344
ret
ret
Definition: filter_design.txt:187
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:683
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:844
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
UPDATE_CACHE_LE
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
init_get_bits_xe
static int init_get_bits_xe(GetBitContext *s, const uint8_t *buffer, int bit_size, int is_le)
Definition: get_bits.h:612
set_idx
static int set_idx(GetBitContext *s, int code, int *n, int *nb_bits, const VLCElem *table)
Definition: get_bits.h:766
defs.h
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
decode210
static int decode210(GetBitContext *gb)
Definition: get_bits.h:831
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
init_get_bits8_le
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:675
vlc.h
int32_t
int32_t
Definition: audioconvert.c:56
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
re
float re
Definition: fft.c:79