FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
get_bits.h
Go to the documentation of this file.
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/avassert.h"
34 
35 #include "defs.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 #ifndef CACHED_BITSTREAM_READER
57 #define CACHED_BITSTREAM_READER 0
58 #endif
59 
60 #if CACHED_BITSTREAM_READER
61 
62 // we always want the LE implementation, to provide get_bits_le()
63 #define BITSTREAM_LE
64 
65 #ifndef BITSTREAM_READER_LE
66 # define BITSTREAM_BE
67 # define BITSTREAM_DEFAULT_BE
68 #endif
69 
70 #include "bitstream.h"
71 
72 #undef BITSTREAM_LE
73 #undef BITSTREAM_BE
74 #undef BITSTREAM_DEFAULT_BE
75 
77 
78 #define get_bits_count bits_tell
79 #define get_bits_bytesize bits_bytesize
80 #define get_bits_left bits_left
81 #define skip_bits_long bits_skip
82 #define skip_bits bits_skip
83 #define get_bits bits_read_nz
84 #define get_bitsz bits_read
85 #define get_bits_long bits_read
86 #define get_bits1 bits_read_bit
87 #define get_bits64 bits_read_64
88 #define get_xbits bits_read_xbits
89 #define get_sbits bits_read_signed_nz
90 #define get_sbits_long bits_read_signed
91 #define show_bits bits_peek
92 #define show_bits_long bits_peek
93 #define init_get_bits bits_init
94 #define init_get_bits8 bits_init8
95 #define align_get_bits bits_align
96 #define get_vlc2 bits_read_vlc
97 #define get_vlc_multi bits_read_vlc_multi
98 
99 #define init_get_bits8_le(s, buffer, byte_size) bits_init8_le((BitstreamContextLE*)s, buffer, byte_size)
100 #define get_bits_le(s, n) bits_read_le((BitstreamContextLE*)s, n)
101 
102 #define show_bits1(s) bits_peek(s, 1)
103 #define skip_bits1(s) bits_skip(s, 1)
104 
105 #define skip_1stop_8data_bits bits_skip_1stop_8data
106 
107 #else // CACHED_BITSTREAM_READER
108 
109 typedef struct GetBitContext {
110  const uint8_t *buffer;
111  int index;
114 } GetBitContext;
115 
116 static inline unsigned int get_bits(GetBitContext *s, int n);
117 static inline void skip_bits(GetBitContext *s, int n);
118 static inline unsigned int show_bits(GetBitContext *s, int n);
119 
120 /* Bitstream reader API docs:
121  * name
122  * arbitrary name which is used as prefix for the internal variables
123  *
124  * gb
125  * getbitcontext
126  *
127  * OPEN_READER(name, gb)
128  * load gb into local variables
129  *
130  * CLOSE_READER(name, gb)
131  * store local vars in gb
132  *
133  * UPDATE_CACHE(name, gb)
134  * Refill the internal cache from the bitstream.
135  * After this call at least MIN_CACHE_BITS will be available.
136  *
137  * GET_CACHE(name, gb)
138  * Will output the contents of the internal cache,
139  * next bit is MSB of 32 or 64 bits (FIXME 64 bits).
140  *
141  * SHOW_UBITS(name, gb, num)
142  * Will return the next num bits.
143  *
144  * SHOW_SBITS(name, gb, num)
145  * Will return the next num bits and do sign extension.
146  *
147  * SKIP_BITS(name, gb, num)
148  * Will skip over the next num bits.
149  * Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
150  *
151  * SKIP_CACHE(name, gb, num)
152  * Will remove the next num bits from the cache (note SKIP_COUNTER
153  * MUST be called before UPDATE_CACHE / CLOSE_READER).
154  *
155  * SKIP_COUNTER(name, gb, num)
156  * Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
157  *
158  * LAST_SKIP_BITS(name, gb, num)
159  * Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
160  *
161  * BITS_LEFT(name, gb)
162  * Return the number of bits left
163  *
164  * For examples see get_bits, show_bits, skip_bits, get_vlc.
165  */
166 
167 #define MIN_CACHE_BITS 25
168 
169 #define OPEN_READER_NOSIZE(name, gb) \
170  unsigned int name ## _index = (gb)->index; \
171  unsigned int av_unused name ## _cache
172 
173 #if UNCHECKED_BITSTREAM_READER
174 #define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)
175 
176 #define BITS_AVAILABLE(name, gb) 1
177 #else
178 #define OPEN_READER(name, gb) \
179  OPEN_READER_NOSIZE(name, gb); \
180  unsigned int name ## _size_plus8 = (gb)->size_in_bits_plus8
181 
182 #define BITS_AVAILABLE(name, gb) name ## _index < name ## _size_plus8
183 #endif
184 
185 #define CLOSE_READER(name, gb) (gb)->index = name ## _index
186 
187 #define UPDATE_CACHE_BE_EXT(name, gb, bits, dst_bits) name ## _cache = \
188  AV_RB ## bits((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7) >> (bits - dst_bits)
189 
190 #define UPDATE_CACHE_LE_EXT(name, gb, bits, dst_bits) name ## _cache = \
191  (uint ## dst_bits ## _t)(AV_RL ## bits((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7))
192 
193 /* Using these two macros ensures that 32 bits are available. */
194 # define UPDATE_CACHE_LE_32(name, gb) UPDATE_CACHE_LE_EXT(name, (gb), 64, 32)
195 # define UPDATE_CACHE_BE_32(name, gb) UPDATE_CACHE_BE_EXT(name, (gb), 64, 32)
196 
197 # define UPDATE_CACHE_LE(name, gb) UPDATE_CACHE_LE_EXT(name, (gb), 32, 32)
198 # define UPDATE_CACHE_BE(name, gb) UPDATE_CACHE_BE_EXT(name, (gb), 32, 32)
199 
200 #ifdef BITSTREAM_READER_LE
201 
202 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
203 # define UPDATE_CACHE_32(name, gb) UPDATE_CACHE_LE_32(name, (gb))
204 
205 # define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
206 
207 #else
208 
209 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
210 # define UPDATE_CACHE_32(name, gb) UPDATE_CACHE_BE_32(name, (gb))
211 
212 # define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
213 
214 #endif
215 
216 #if UNCHECKED_BITSTREAM_READER
217 # define SKIP_COUNTER(name, gb, num) name ## _index += (num)
218 #else
219 # define SKIP_COUNTER(name, gb, num) \
220  name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
221 #endif
222 
223 #define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))
224 
225 #define SKIP_BITS(name, gb, num) \
226  do { \
227  SKIP_CACHE(name, gb, num); \
228  SKIP_COUNTER(name, gb, num); \
229  } while (0)
230 
231 #define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
232 
233 #define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)
234 #define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)
235 
236 #define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)
237 #define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)
238 
239 #ifdef BITSTREAM_READER_LE
240 # define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
241 # define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
242 #else
243 # define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
244 # define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
245 #endif
246 
247 #define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
248 
249 
250 static inline int get_bits_count(const GetBitContext *s)
251 {
252  return s->index;
253 }
254 
255 /**
256  * Get the size of the GetBitContext's buffer in bytes.
257  *
258  * @param s the GetBitContext
259  * @param round_up If set, the number of bits will be rounded up to full bytes;
260  * this does not matter if the number of bits is known to be
261  * a multiple of eight, e.g. if the GetBitContext has been
262  * initialized with init_get_bits8.
263  */
264 static inline int get_bits_bytesize(const GetBitContext *s, int round_up)
265 {
266  return (s->size_in_bits + (round_up ? 7 : 0)) >> 3;
267 }
268 
269 /**
270  * Skips the specified number of bits.
271  * @param n the number of bits to skip,
272  * For the UNCHECKED_BITSTREAM_READER this must not cause the distance
273  * from the start to overflow int32_t. Staying within the bitstream + padding
274  * is sufficient, too.
275  */
276 static inline void skip_bits_long(GetBitContext *s, int n)
277 {
278 #if UNCHECKED_BITSTREAM_READER
279  s->index += n;
280 #else
281  s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
282 #endif
283 }
284 
285 /**
286  * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
287  * if MSB not set it is negative
288  * @param n length in bits
289  */
290 static inline int get_xbits(GetBitContext *s, int n)
291 {
292  register int sign;
293  register int32_t cache;
294  OPEN_READER(re, s);
295  av_assert2(n>0 && n<=25);
296  UPDATE_CACHE(re, s);
297  cache = GET_CACHE(re, s);
298  sign = ~cache >> 31;
299  LAST_SKIP_BITS(re, s, n);
300  CLOSE_READER(re, s);
301  return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
302 }
303 
304 static inline int get_xbits_le(GetBitContext *s, int n)
305 {
306  register int sign;
307  register int32_t cache;
308  OPEN_READER(re, s);
309  av_assert2(n>0 && n<=25);
310  UPDATE_CACHE_LE(re, s);
311  cache = GET_CACHE(re, s);
312  sign = sign_extend(~cache, n) >> 31;
313  LAST_SKIP_BITS(re, s, n);
314  CLOSE_READER(re, s);
315  return (zero_extend(sign ^ cache, n) ^ sign) - sign;
316 }
317 
318 static inline int get_sbits(GetBitContext *s, int n)
319 {
320  register int tmp;
321  OPEN_READER(re, s);
322  av_assert2(n>0 && n<=25);
323  UPDATE_CACHE(re, s);
324  tmp = SHOW_SBITS(re, s, n);
325  LAST_SKIP_BITS(re, s, n);
326  CLOSE_READER(re, s);
327  return tmp;
328 }
329 
330 /**
331  * Read 1-25 bits.
332  */
333 static inline unsigned int get_bits(GetBitContext *s, int n)
334 {
335  register unsigned int tmp;
336  OPEN_READER(re, s);
337  av_assert2(n>0 && n<=25);
338  UPDATE_CACHE(re, s);
339  tmp = SHOW_UBITS(re, s, n);
340  LAST_SKIP_BITS(re, s, n);
341  CLOSE_READER(re, s);
342  av_assert2(tmp < UINT64_C(1) << n);
343  return tmp;
344 }
345 
346 /**
347  * Read 0-25 bits.
348  */
350 {
351  return n ? get_bits(s, n) : 0;
352 }
353 
354 static inline unsigned int get_bits_le(GetBitContext *s, int n)
355 {
356  register int tmp;
357  OPEN_READER(re, s);
358  av_assert2(n>0 && n<=25);
359  UPDATE_CACHE_LE(re, s);
360  tmp = SHOW_UBITS_LE(re, s, n);
361  LAST_SKIP_BITS(re, s, n);
362  CLOSE_READER(re, s);
363  return tmp;
364 }
365 
366 /**
367  * Show 1-25 bits.
368  */
369 static inline unsigned int show_bits(GetBitContext *s, int n)
370 {
371  register unsigned int tmp;
372  OPEN_READER_NOSIZE(re, s);
373  av_assert2(n>0 && n<=25);
374  UPDATE_CACHE(re, s);
375  tmp = SHOW_UBITS(re, s, n);
376  return tmp;
377 }
378 
379 static inline void skip_bits(GetBitContext *s, int n)
380 {
381  OPEN_READER(re, s);
382  LAST_SKIP_BITS(re, s, n);
383  CLOSE_READER(re, s);
384 }
385 
386 static inline unsigned int get_bits1(GetBitContext *s)
387 {
388  unsigned int index = s->index;
389  uint8_t result = s->buffer[index >> 3];
390 #ifdef BITSTREAM_READER_LE
391  result >>= index & 7;
392  result &= 1;
393 #else
394  result <<= index & 7;
395  result >>= 8 - 1;
396 #endif
397 #if !UNCHECKED_BITSTREAM_READER
398  if (s->index < s->size_in_bits_plus8)
399 #endif
400  index++;
401  s->index = index;
402 
403  return result;
404 }
405 
406 static inline unsigned int show_bits1(GetBitContext *s)
407 {
408  return show_bits(s, 1);
409 }
410 
411 static inline void skip_bits1(GetBitContext *s)
412 {
413  skip_bits(s, 1);
414 }
415 
416 /**
417  * Read 0-32 bits.
418  */
419 static inline unsigned int get_bits_long(GetBitContext *s, int n)
420 {
421  av_assert2(n>=0 && n<=32);
422  if (!n) {
423  return 0;
424  } else if ((!HAVE_FAST_64BIT || av_builtin_constant_p(n <= MIN_CACHE_BITS))
425  && n <= MIN_CACHE_BITS) {
426  return get_bits(s, n);
427  } else {
428 #if HAVE_FAST_64BIT
429  unsigned tmp;
430  OPEN_READER(re, s);
431  UPDATE_CACHE_32(re, s);
432  tmp = SHOW_UBITS(re, s, n);
433  LAST_SKIP_BITS(re, s, n);
434  CLOSE_READER(re, s);
435  return tmp;
436 #else
437 #ifdef BITSTREAM_READER_LE
438  unsigned ret = get_bits(s, 16);
439  return ret | (get_bits(s, n - 16) << 16);
440 #else
441  unsigned ret = get_bits(s, 16) << (n - 16);
442  return ret | get_bits(s, n - 16);
443 #endif
444 #endif
445  }
446 }
447 
448 /**
449  * Read 0-64 bits.
450  */
451 static inline uint64_t get_bits64(GetBitContext *s, int n)
452 {
453  if (n <= 32) {
454  return get_bits_long(s, n);
455  } else {
456 #ifdef BITSTREAM_READER_LE
457  uint64_t ret = get_bits_long(s, 32);
458  return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
459 #else
460  uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
461  return ret | get_bits_long(s, 32);
462 #endif
463  }
464 }
465 
466 /**
467  * Read 0-32 bits as a signed integer.
468  */
469 static inline int get_sbits_long(GetBitContext *s, int n)
470 {
471  // sign_extend(x, 0) is undefined
472  if (!n)
473  return 0;
474 
475  return sign_extend(get_bits_long(s, n), n);
476 }
477 
478 /**
479  * Read 0-64 bits as a signed integer.
480  */
481 static inline int64_t get_sbits64(GetBitContext *s, int n)
482 {
483  // sign_extend(x, 0) is undefined
484  if (!n)
485  return 0;
486 
487  return sign_extend64(get_bits64(s, n), n);
488 }
489 
490 /**
491  * Show 0-32 bits.
492  */
493 static inline unsigned int show_bits_long(GetBitContext *s, int n)
494 {
495  if (n <= MIN_CACHE_BITS) {
496  return show_bits(s, n);
497  } else {
498  GetBitContext gb = *s;
499  return get_bits_long(&gb, n);
500  }
501 }
502 
503 
504 /**
505  * Initialize GetBitContext.
506  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
507  * larger than the actual read bits because some optimized bitstream
508  * readers read 32 or 64 bit at once and could read over the end
509  * @param bit_size the size of the buffer in bits
510  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
511  */
512 static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
513  int bit_size)
514 {
515  int ret = 0;
516 
517  if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {
518  bit_size = 0;
519  buffer = NULL;
521  }
522 
523  s->buffer = buffer;
524  s->size_in_bits = bit_size;
525  s->size_in_bits_plus8 = bit_size + 8;
526  s->index = 0;
527 
528  return ret;
529 }
530 
531 /**
532  * Initialize GetBitContext.
533  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
534  * larger than the actual read bits because some optimized bitstream
535  * readers read 32 or 64 bit at once and could read over the end
536  * @param byte_size the size of the buffer in bytes
537  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
538  */
539 static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
540  int byte_size)
541 {
542  if (byte_size > INT_MAX / 8 || byte_size < 0)
543  byte_size = -1;
544  return init_get_bits(s, buffer, byte_size * 8);
545 }
546 
547 static inline int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer,
548  int byte_size)
549 {
550  if (byte_size > INT_MAX / 8 || byte_size < 0)
551  byte_size = -1;
552  return init_get_bits(s, buffer, byte_size * 8);
553 }
554 
555 static inline const uint8_t *align_get_bits(GetBitContext *s)
556 {
557  int n = -get_bits_count(s) & 7;
558  if (n)
559  skip_bits(s, n);
560  return s->buffer + (s->index >> 3);
561 }
562 
563 /**
564  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
565  * If the vlc code is invalid and max_depth>1, then the number of bits removed
566  * is undefined.
567  */
568 #define GET_VLC(code, name, gb, table, bits, max_depth) \
569  do { \
570  int n, nb_bits; \
571  unsigned int index; \
572  \
573  index = SHOW_UBITS(name, gb, bits); \
574  code = table[index].sym; \
575  n = table[index].len; \
576  \
577  if (max_depth > 1 && n < 0) { \
578  LAST_SKIP_BITS(name, gb, bits); \
579  UPDATE_CACHE(name, gb); \
580  \
581  nb_bits = -n; \
582  \
583  index = SHOW_UBITS(name, gb, nb_bits) + code; \
584  code = table[index].sym; \
585  n = table[index].len; \
586  if (max_depth > 2 && n < 0) { \
587  LAST_SKIP_BITS(name, gb, nb_bits); \
588  UPDATE_CACHE(name, gb); \
589  \
590  nb_bits = -n; \
591  \
592  index = SHOW_UBITS(name, gb, nb_bits) + code; \
593  code = table[index].sym; \
594  n = table[index].len; \
595  } \
596  } \
597  SKIP_BITS(name, gb, n); \
598  } while (0)
599 
600 #define GET_RL_VLC(level, run, name, gb, table, bits, \
601  max_depth, need_update) \
602  do { \
603  int n, nb_bits; \
604  unsigned int index; \
605  \
606  index = SHOW_UBITS(name, gb, bits); \
607  level = table[index].level; \
608  n = table[index].len8; \
609  \
610  if (max_depth > 1 && n < 0) { \
611  SKIP_BITS(name, gb, bits); \
612  if (need_update) { \
613  UPDATE_CACHE(name, gb); \
614  } \
615  \
616  nb_bits = -n; \
617  \
618  index = SHOW_UBITS(name, gb, nb_bits) + level; \
619  level = table[index].level; \
620  n = table[index].len8; \
621  if (max_depth > 2 && n < 0) { \
622  LAST_SKIP_BITS(name, gb, nb_bits); \
623  if (need_update) { \
624  UPDATE_CACHE(name, gb); \
625  } \
626  nb_bits = -n; \
627  \
628  index = SHOW_UBITS(name, gb, nb_bits) + level; \
629  level = table[index].level; \
630  n = table[index].len8; \
631  } \
632  } \
633  run = table[index].run; \
634  SKIP_BITS(name, gb, n); \
635  } while (0)
636 
637 /**
638  * Parse a vlc code.
639  * @param bits is the number of bits which will be read at once, must be
640  * identical to nb_bits in vlc_init()
641  * @param max_depth is the number of times bits bits must be read to completely
642  * read the longest vlc code
643  * = (max_vlc_length + bits - 1) / bits
644  * @returns the code parsed or -1 if no vlc matches
645  */
647  int bits, int max_depth)
648 {
649  int code;
650 
651  OPEN_READER(re, s);
652  UPDATE_CACHE(re, s);
653 
654  GET_VLC(code, re, s, table, bits, max_depth);
655 
656  CLOSE_READER(re, s);
657 
658  return code;
659 }
660 
661 static inline int get_vlc_multi(GetBitContext *s, uint8_t *dst,
662  const VLC_MULTI_ELEM *const Jtable,
663  const VLCElem *const table,
664  const int bits, const int max_depth,
665  const int symbols_size)
666 {
667  dst[0] = get_vlc2(s, table, bits, max_depth);
668  return 1;
669 }
670 
671 static inline int decode012(GetBitContext *gb)
672 {
673  int n;
674  n = get_bits1(gb);
675  if (n == 0)
676  return 0;
677  else
678  return get_bits1(gb) + 1;
679 }
680 
681 static inline int decode210(GetBitContext *gb)
682 {
683  if (get_bits1(gb))
684  return 0;
685  else
686  return 2 - get_bits1(gb);
687 }
688 
689 static inline int get_bits_left(GetBitContext *gb)
690 {
691  return gb->size_in_bits - get_bits_count(gb);
692 }
693 
694 static inline int skip_1stop_8data_bits(GetBitContext *gb)
695 {
696  if (get_bits_left(gb) <= 0)
697  return AVERROR_INVALIDDATA;
698 
699  while (get_bits1(gb)) {
700  skip_bits(gb, 8);
701  if (get_bits_left(gb) <= 0)
702  return AVERROR_INVALIDDATA;
703  }
704 
705  return 0;
706 }
707 
708 #endif // CACHED_BITSTREAM_READER
709 
710 #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:276
av_clip
#define av_clip
Definition: common.h:100
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:493
show_bits1
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:406
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:689
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:568
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:419
int64_t
long long int64_t
Definition: coverity.c:34
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:250
VLC_MULTI_ELEM
Definition: vlc.h:56
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:112
table
static const uint16_t table[]
Definition: prosumer.c:203
zero_extend
static av_const unsigned zero_extend(unsigned val, unsigned bits)
Definition: mathops.h:150
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:209
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:512
OPEN_READER_NOSIZE
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:169
GetBitContext::size_in_bits_plus8
int size_in_bits_plus8
Definition: get_bits.h:113
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:247
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:379
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:333
GetBitContext
Definition: get_bits.h:109
get_vlc_multi
static int get_vlc_multi(GetBitContext *s, uint8_t *dst, const VLC_MULTI_ELEM *const Jtable, const VLCElem *const table, const int bits, const int max_depth, const int symbols_size)
Definition: get_bits.h:661
BitstreamContext
#define BitstreamContext
Definition: bitstream.h:110
avassert.h
get_sbits64
static int64_t get_sbits64(GetBitContext *s, int n)
Read 0-64 bits as a signed integer.
Definition: get_bits.h:481
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:539
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:185
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:244
bits
uint8_t bits
Definition: vp3data.h:128
sign_extend64
static av_const int64_t sign_extend64(int64_t val, unsigned bits)
Definition: mathops.h:141
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:354
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:318
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:671
SHOW_UBITS_LE
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:233
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:110
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:386
mathops.h
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:231
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:646
index
int index
Definition: gxfenc.c:90
get_bits_bytesize
static int get_bits_bytesize(const GetBitContext *s, int round_up)
Get the size of the GetBitContext's buffer in bytes.
Definition: get_bits.h:264
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
VLCElem
Definition: vlc.h:32
GetBitContext::index
int index
Definition: get_bits.h:111
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:174
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:290
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:411
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:451
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:177
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
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:369
av_builtin_constant_p
#define av_builtin_constant_p
Definition: attributes.h:160
common.h
MIN_CACHE_BITS
#define MIN_CACHE_BITS
Definition: get_bits.h:167
av_always_inline
#define av_always_inline
Definition: attributes.h:49
bitstream.h
get_xbits_le
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:304
ret
ret
Definition: filter_design.txt:187
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:555
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:694
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:243
UPDATE_CACHE_LE
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:197
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
defs.h
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:132
decode210
static int decode210(GetBitContext *gb)
Definition: get_bits.h:681
UPDATE_CACHE_32
#define UPDATE_CACHE_32(name, gb)
Definition: get_bits.h:210
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:349
init_get_bits8_le
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:547
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:469