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/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 {
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 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;
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  */
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 */
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
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:849
n
int n
Definition: avisynth_c.h:760
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:87
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:706
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:26
table
static const uint16_t table[]
Definition: prosumer.c:206
zero_extend
static av_const unsigned zero_extend(unsigned val, unsigned bits)
Definition: mathops.h:139
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
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
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
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
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
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:677
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
bits
uint8_t bits
Definition: vp3data.h:202
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:831
SHOW_UBITS_LE
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:201
int32_t
int32_t
Definition: audio_convert.c:194
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
index
int index
Definition: gxfenc.c:89
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
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:92
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
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
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:166
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
log.h
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:43
uint8_t
uint8_t
Definition: audio_convert.c:194
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:62
avcodec.h
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:693
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:790
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:854
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:622
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
decode210
static int decode210(GetBitContext *gb)
Definition: get_bits.h:841
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: get_bits.h:612
init_get_bits8_le
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:685
set_idx
static int set_idx(GetBitContext *s, int code, int *n, int *nb_bits, VLC_TYPE(*table)[2])
Definition: get_bits.h:776
vlc.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:91
re
float re
Definition: fft.c:82