FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
bitstream_template.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Alexandra Hájková
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 #ifdef BITSTREAM_TEMPLATE_LE
22 # define BS_SUFFIX_LOWER _le
23 # define BS_SUFFIX_UPPER LE
24 #else
25 # define BS_SUFFIX_LOWER _be
26 # define BS_SUFFIX_UPPER BE
27 #endif
28 
29 #define BS_JOIN(x, y, z) x ## y ## z
30 #define BS_JOIN3(x, y, z) BS_JOIN(x, y, z)
31 #define BS_FUNC(x) BS_JOIN3(bits_, x, BS_SUFFIX_LOWER)
32 
33 #define BSCTX BS_JOIN3(Bitstream, Context, BS_SUFFIX_UPPER)
34 
35 typedef struct BSCTX {
36  uint64_t bits; // stores bits read from the buffer
37  const uint8_t *buffer, *buffer_end;
38  const uint8_t *ptr; // pointer to the position inside a buffer
39  unsigned bits_valid; // number of bits left in bits field
40  unsigned size_in_bits;
41 } BSCTX;
42 
43 /**
44  * @return
45  * - 0 on successful refill
46  * - a negative number when bitstream end is hit
47  *
48  * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled.
49  */
50 static inline int BS_FUNC(priv_refill_64)(BSCTX *bc)
51 {
52 #if !UNCHECKED_BITSTREAM_READER
53  if (bc->ptr >= bc->buffer_end)
54  return -1;
55 #endif
56 
57 #ifdef BITSTREAM_TEMPLATE_LE
58  bc->bits = AV_RL64(bc->ptr);
59 #else
60  bc->bits = AV_RB64(bc->ptr);
61 #endif
62  bc->ptr += 8;
63  bc->bits_valid = 64;
64 
65  return 0;
66 }
67 
68 /**
69  * @return
70  * - 0 on successful refill
71  * - a negative number when bitstream end is hit
72  *
73  * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled.
74  */
75 static inline int BS_FUNC(priv_refill_32)(BSCTX *bc)
76 {
77 #if !UNCHECKED_BITSTREAM_READER
78  if (bc->ptr >= bc->buffer_end)
79  return -1;
80 #endif
81 
82 #ifdef BITSTREAM_TEMPLATE_LE
83  bc->bits |= (uint64_t)AV_RL32(bc->ptr) << bc->bits_valid;
84 #else
85  bc->bits |= (uint64_t)AV_RB32(bc->ptr) << (32 - bc->bits_valid);
86 #endif
87  bc->ptr += 4;
88  bc->bits_valid += 32;
89 
90  return 0;
91 }
92 
93 /**
94  * Initialize BitstreamContext.
95  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
96  * larger than the actual read bits because some optimized bitstream
97  * readers read 32 or 64 bits at once and could read over the end
98  * @param bit_size the size of the buffer in bits
99  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
100  */
101 static inline int BS_FUNC(init)(BSCTX *bc, const uint8_t *buffer,
102  unsigned int bit_size)
103 {
104  unsigned int buffer_size;
105 
106  if (bit_size > INT_MAX - 7 || !buffer) {
107  bc->buffer = NULL;
108  bc->ptr = NULL;
109  bc->bits_valid = 0;
110  return AVERROR_INVALIDDATA;
111  }
112 
113  buffer_size = (bit_size + 7) >> 3;
114 
115  bc->buffer = buffer;
116  bc->buffer_end = buffer + buffer_size;
117  bc->ptr = bc->buffer;
118  bc->size_in_bits = bit_size;
119  bc->bits_valid = 0;
120  bc->bits = 0;
121 
122  BS_FUNC(priv_refill_64)(bc);
123 
124  return 0;
125 }
126 
127 /**
128  * Initialize BitstreamContext.
129  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
130  * larger than the actual read bits because some optimized bitstream
131  * readers read 32 or 64 bits at once and could read over the end
132  * @param byte_size the size of the buffer in bytes
133  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow
134  */
135 static inline int BS_FUNC(init8)(BSCTX *bc, const uint8_t *buffer,
136  unsigned int byte_size)
137 {
138  if (byte_size > INT_MAX / 8)
139  return AVERROR_INVALIDDATA;
140  return BS_FUNC(init)(bc, buffer, byte_size * 8);
141 }
142 
143 /**
144  * Return number of bits already read.
145  */
146 static inline int BS_FUNC(tell)(const BSCTX *bc)
147 {
148  return (bc->ptr - bc->buffer) * 8 - bc->bits_valid;
149 }
150 
151 /**
152  * Return buffer size in bits.
153  */
154 static inline int BS_FUNC(size)(const BSCTX *bc)
155 {
156  return bc->size_in_bits;
157 }
158 
159 /**
160  * Return buffer size in bytes.
161  */
162 static inline int BS_FUNC(bytesize)(const BSCTX *bc, int round_up)
163 {
164  return (bc->size_in_bits + (round_up ? 7 : 0)) >> 3;
165 }
166 
167 /**
168  * Return the number of the bits left in a buffer.
169  */
170 static inline int BS_FUNC(left)(const BSCTX *bc)
171 {
172  return (bc->buffer - bc->ptr) * 8 + bc->size_in_bits + bc->bits_valid;
173 }
174 
175 static inline uint64_t BS_FUNC(priv_val_show)(BSCTX *bc, unsigned int n)
176 {
177  av_assert2(n > 0 && n <= 64);
178 
179 #ifdef BITSTREAM_TEMPLATE_LE
180  return bc->bits & (UINT64_MAX >> (64 - n));
181 #else
182  return bc->bits >> (64 - n);
183 #endif
184 }
185 
186 static inline void BS_FUNC(priv_skip_remaining)(BSCTX *bc, unsigned int n)
187 {
188 #ifdef BITSTREAM_TEMPLATE_LE
189  bc->bits >>= n;
190 #else
191  bc->bits <<= n;
192 #endif
193  bc->bits_valid -= n;
194 }
195 
196 static inline uint64_t BS_FUNC(priv_val_get)(BSCTX *bc, unsigned int n)
197 {
198  uint64_t ret;
199 
200  av_assert2(n > 0 && n < 64);
201 
202  ret = BS_FUNC(priv_val_show)(bc, n);
204 
205  return ret;
206 }
207 
208 /**
209  * Return one bit from the buffer.
210  */
211 static inline unsigned int BS_FUNC(read_bit)(BSCTX *bc)
212 {
213  if (!bc->bits_valid && BS_FUNC(priv_refill_64)(bc) < 0)
214  return 0;
215 
216  return BS_FUNC(priv_val_get)(bc, 1);
217 }
218 
219 /**
220  * Return n bits from the buffer, n has to be in the 1-32 range.
221  * May be faster than bits_read() when n is not a compile-time constant and is
222  * known to be non-zero;
223  */
224 static inline uint32_t BS_FUNC(read_nz)(BSCTX *bc, unsigned int n)
225 {
226  av_assert2(n > 0 && n <= 32);
227 
228  if (n > bc->bits_valid) {
229  if (BS_FUNC(priv_refill_32)(bc) < 0)
230  bc->bits_valid = n;
231  }
232 
233  return BS_FUNC(priv_val_get)(bc, n);
234 }
235 
236 /**
237  * Return n bits from the buffer, n has to be in the 0-32 range.
238  */
239 static inline uint32_t BS_FUNC(read)(BSCTX *bc, unsigned int n)
240 {
241  av_assert2(n <= 32);
242 
243  if (!n)
244  return 0;
245 
246  return BS_FUNC(read_nz)(bc, n);
247 }
248 
249 /**
250  * Return n bits from the buffer, n has to be in the 0-63 range.
251  */
252 static inline uint64_t BS_FUNC(read_63)(BSCTX *bc, unsigned int n)
253 {
254  uint64_t ret = 0;
255  unsigned left = 0;
256 
257  av_assert2(n <= 63);
258 
259  if (!n)
260  return 0;
261 
262  if (n > bc->bits_valid) {
263  left = bc->bits_valid;
264  n -= left;
265 
266  if (left)
267  ret = BS_FUNC(priv_val_get)(bc, left);
268 
269  if (BS_FUNC(priv_refill_64)(bc) < 0)
270  bc->bits_valid = n;
271 
272  }
273 
274 #ifdef BITSTREAM_TEMPLATE_LE
275  ret = BS_FUNC(priv_val_get)(bc, n) << left | ret;
276 #else
277  ret = BS_FUNC(priv_val_get)(bc, n) | ret << n;
278 #endif
279 
280  return ret;
281 }
282 
283 /**
284  * Return n bits from the buffer, n has to be in the 0-64 range.
285  */
286 static inline uint64_t BS_FUNC(read_64)(BSCTX *bc, unsigned int n)
287 {
288  av_assert2(n <= 64);
289 
290  if (n == 64) {
291  uint64_t ret = BS_FUNC(read_63)(bc, 63);
292 #ifdef BITSTREAM_TEMPLATE_LE
293  return ret | ((uint64_t)BS_FUNC(read_bit)(bc) << 63);
294 #else
295  return (ret << 1) | (uint64_t)BS_FUNC(read_bit)(bc);
296 #endif
297  }
298  return BS_FUNC(read_63)(bc, n);
299 }
300 
301 /**
302  * Return n bits from the buffer as a signed integer, n has to be in the 1-32
303  * range. May be faster than bits_read_signed() when n is not a compile-time
304  * constant and is known to be non-zero;
305  */
306 static inline int32_t BS_FUNC(read_signed_nz)(BSCTX *bc, unsigned int n)
307 {
308  av_assert2(n > 0 && n <= 32);
309  return sign_extend(BS_FUNC(read_nz)(bc, n), n);
310 }
311 
312 /**
313  * Return n bits from the buffer as a signed integer.
314  * n has to be in the 0-32 range.
315  */
316 static inline int32_t BS_FUNC(read_signed)(BSCTX *bc, unsigned int n)
317 {
318  av_assert2(n <= 32);
319 
320  if (!n)
321  return 0;
322 
323  return BS_FUNC(read_signed_nz)(bc, n);
324 }
325 
326 /**
327  * Return n bits from the buffer but do not change the buffer state.
328  * n has to be in the 1-32 range. May
329  */
330 static inline uint32_t BS_FUNC(peek_nz)(BSCTX *bc, unsigned int n)
331 {
332  av_assert2(n > 0 && n <= 32);
333 
334  if (n > bc->bits_valid)
335  BS_FUNC(priv_refill_32)(bc);
336 
337  return BS_FUNC(priv_val_show)(bc, n);
338 }
339 
340 /**
341  * Return n bits from the buffer but do not change the buffer state.
342  * n has to be in the 0-32 range.
343  */
344 static inline uint32_t BS_FUNC(peek)(BSCTX *bc, unsigned int n)
345 {
346  av_assert2(n <= 32);
347 
348  if (!n)
349  return 0;
350 
351  return BS_FUNC(peek_nz)(bc, n);
352 }
353 
354 /**
355  * Return n bits from the buffer as a signed integer, do not change the buffer
356  * state. n has to be in the 1-32 range. May be faster than bits_peek_signed()
357  * when n is not a compile-time constant and is known to be non-zero;
358  */
359 static inline int BS_FUNC(peek_signed_nz)(BSCTX *bc, unsigned int n)
360 {
361  av_assert2(n > 0 && n <= 32);
362  return sign_extend(BS_FUNC(peek_nz)(bc, n), n);
363 }
364 
365 /**
366  * Return n bits from the buffer as a signed integer,
367  * do not change the buffer state.
368  * n has to be in the 0-32 range.
369  */
370 static inline int BS_FUNC(peek_signed)(BSCTX *bc, unsigned int n)
371 {
372  av_assert2(n <= 32);
373 
374  if (!n)
375  return 0;
376 
377  return BS_FUNC(peek_signed_nz)(bc, n);
378 }
379 
380 /**
381  * Skip n bits in the buffer.
382  */
383 static inline void BS_FUNC(skip)(BSCTX *bc, unsigned int n)
384 {
385  if (n < bc->bits_valid)
387  else {
388  n -= bc->bits_valid;
389  bc->bits = 0;
390  bc->bits_valid = 0;
391 
392  if (n >= 64) {
393  unsigned int skip = n / 8;
394 
395  n -= skip * 8;
396  bc->ptr += skip;
397  }
398  BS_FUNC(priv_refill_64)(bc);
399  if (n)
401  }
402 }
403 
404 /**
405  * Seek to the given bit position.
406  */
407 static inline void BS_FUNC(seek)(BSCTX *bc, unsigned pos)
408 {
409  bc->ptr = bc->buffer;
410  bc->bits = 0;
411  bc->bits_valid = 0;
412 
413  BS_FUNC(skip)(bc, pos);
414 }
415 
416 /**
417  * Skip bits to a byte boundary.
418  */
419 static inline const uint8_t *BS_FUNC(align)(BSCTX *bc)
420 {
421  unsigned int n = -BS_FUNC(tell)(bc) & 7;
422  if (n)
423  BS_FUNC(skip)(bc, n);
424  return bc->buffer + (BS_FUNC(tell)(bc) >> 3);
425 }
426 
427 /**
428  * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
429  * If MSB not set it is negative.
430  * @param n length in bits
431  */
432 static inline int BS_FUNC(read_xbits)(BSCTX *bc, unsigned int n)
433 {
434  int32_t cache = BS_FUNC(peek)(bc, 32);
435  int sign = ~cache >> 31;
437 
438  return ((((uint32_t)(sign ^ cache)) >> (32 - n)) ^ sign) - sign;
439 }
440 
441 /**
442  * Return decoded truncated unary code for the values 0, 1, 2.
443  */
444 static inline int BS_FUNC(decode012)(BSCTX *bc)
445 {
446  if (!BS_FUNC(read_bit)(bc))
447  return 0;
448  else
449  return BS_FUNC(read_bit)(bc) + 1;
450 }
451 
452 /**
453  * Return decoded truncated unary code for the values 2, 1, 0.
454  */
455 static inline int BS_FUNC(decode210)(BSCTX *bc)
456 {
457  if (BS_FUNC(read_bit)(bc))
458  return 0;
459  else
460  return 2 - BS_FUNC(read_bit)(bc);
461 }
462 
463 /* Read sign bit and flip the sign of the provided value accordingly. */
464 static inline int BS_FUNC(apply_sign)(BSCTX *bc, int val)
465 {
466  int sign = BS_FUNC(read_signed)(bc, 1);
467  return (val ^ sign) - sign;
468 }
469 
470 static inline int BS_FUNC(skip_1stop_8data)(BSCTX *s)
471 {
472  if (BS_FUNC(left)(s) <= 0)
473  return AVERROR_INVALIDDATA;
474 
475  while (BS_FUNC(read_bit)(s)) {
476  BS_FUNC(skip)(s, 8);
477  if (BS_FUNC(left)(s) <= 0)
478  return AVERROR_INVALIDDATA;
479  }
480 
481  return 0;
482 }
483 
484 /**
485  * Return the LUT element for the given bitstream configuration.
486  */
487 static inline int BS_FUNC(priv_set_idx)(BSCTX *bc, int code, int *n,
488  int *nb_bits, const VLCElem *table)
489 {
490  unsigned idx;
491 
492  *nb_bits = -*n;
493  idx = BS_FUNC(peek)(bc, *nb_bits) + code;
494  *n = table[idx].len;
495 
496  return table[idx].sym;
497 }
498 
499 /**
500  * Parse a vlc code.
501  * @param bits is the number of bits which will be read at once, must be
502  * identical to nb_bits in vlc_init()
503  * @param max_depth is the number of times bits bits must be read to completely
504  * read the longest vlc code
505  * = (max_vlc_length + bits - 1) / bits
506  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
507  * If the vlc code is invalid and max_depth>1, then the number of bits removed
508  * is undefined.
509  */
510 static inline int BS_FUNC(read_vlc)(BSCTX *bc, const VLCElem *table,
511  int bits, int max_depth)
512 {
513  int nb_bits;
514  unsigned idx = BS_FUNC(peek)(bc, bits);
515  int code = table[idx].sym;
516  int n = table[idx].len;
517 
518  if (max_depth > 1 && n < 0) {
520  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
521  if (max_depth > 2 && n < 0) {
522  BS_FUNC(priv_skip_remaining)(bc, nb_bits);
523  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
524  }
525  }
527 
528  return code;
529 }
530 
531 /**
532  * Parse a vlc / vlc_multi code.
533  * @param bits is the number of bits which will be read at once, must be
534  * identical to nb_bits in vlc_init()
535  * @param max_depth is the number of times bits bits must be read to completely
536  * read the longest vlc code
537  * = (max_vlc_length + bits - 1) / bits
538  * @param dst the parsed symbol(s) will be stored here. Up to 8 bytes are written
539  * @returns number of symbols parsed
540  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
541  * If the vlc code is invalid and max_depth>1, then the number of bits removed
542  * is undefined.
543  */
544 static inline int BS_FUNC(read_vlc_multi)(BSCTX *bc, uint8_t dst[8],
545  const VLC_MULTI_ELEM *const Jtable,
546  const VLCElem *const table,
547  const int bits, const int max_depth,
548  const int symbols_size)
549 {
550  unsigned idx = BS_FUNC(peek)(bc, bits);
551  int ret, nb_bits, code, n = Jtable[idx].len;
552  if (Jtable[idx].num) {
553  AV_COPY64U(dst, Jtable[idx].val8);
554  ret = Jtable[idx].num;
555  } else {
556  code = table[idx].sym;
557  n = table[idx].len;
558  if (max_depth > 1 && n < 0) {
560  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
561  if (max_depth > 2 && n < 0) {
562  BS_FUNC(priv_skip_remaining)(bc, nb_bits);
563  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
564  }
565  }
566  if (symbols_size == 1)
567  *dst = code;
568  else
569  AV_WN16(dst, code);
570  ret = n > 0;
571  }
573 
574  return ret;
575 }
576 
577 #undef BSCTX
578 #undef BS_FUNC
579 #undef BS_JOIN3
580 #undef BS_JOIN
581 #undef BS_SUFFIX_UPPER
582 #undef BS_SUFFIX_LOWER
read_64
static uint64_t BS_FUNC() read_64(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-64 range.
Definition: bitstream_template.h:286
size
static int BS_FUNC() size(const BSCTX *bc)
Return buffer size in bits.
Definition: bitstream_template.h:154
read_nz
static uint32_t BS_FUNC() read_nz(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 1-32 range.
Definition: bitstream_template.h:224
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
BSCTX::buffer
const uint8_t * buffer
Definition: bitstream_template.h:37
decode210
static int BS_FUNC() decode210(BSCTX *bc)
Return decoded truncated unary code for the values 2, 1, 0.
Definition: bitstream_template.h:455
BSCTX::bits_valid
unsigned bits_valid
Definition: bitstream_template.h:39
VLC_MULTI_ELEM
Definition: vlc.h:56
BSCTX
#define BSCTX
Definition: bitstream_template.h:33
table
static const uint16_t table[]
Definition: prosumer.c:203
init
static int BS_FUNC() init(BSCTX *bc, const uint8_t *buffer, unsigned int bit_size)
Initialize BitstreamContext.
Definition: bitstream_template.h:101
priv_refill_64
static int BS_FUNC() priv_refill_64(BSCTX *bc)
Definition: bitstream_template.h:50
peek
static uint32_t BS_FUNC() peek(BSCTX *bc, unsigned int n)
Return n bits from the buffer but do not change the buffer state.
Definition: bitstream_template.h:344
peek_signed
static int BS_FUNC() peek_signed(BSCTX *bc, unsigned int n)
Return n bits from the buffer as a signed integer, do not change the buffer state.
Definition: bitstream_template.h:370
read_signed_nz
static int32_t BS_FUNC() read_signed_nz(BSCTX *bc, unsigned int n)
Return n bits from the buffer as a signed integer, n has to be in the 1-32 range.
Definition: bitstream_template.h:306
read_xbits
static int BS_FUNC() read_xbits(BSCTX *bc, unsigned int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: bitstream_template.h:432
left
static int BS_FUNC() left(const BSCTX *bc)
Return the number of the bits left in a buffer.
Definition: bitstream_template.h:170
peek_nz
static uint32_t BS_FUNC() peek_nz(BSCTX *bc, unsigned int n)
Return n bits from the buffer but do not change the buffer state.
Definition: bitstream_template.h:330
val
static double val(void *priv, double ch)
Definition: aeval.c:77
s
#define s(width, name)
Definition: cbs_vp9.c:198
bits
uint8_t bits
Definition: vp3data.h:128
read_vlc_multi
static int BS_FUNC() read_vlc_multi(BSCTX *bc, uint8_t dst[8], const VLC_MULTI_ELEM *const Jtable, const VLCElem *const table, const int bits, const int max_depth, const int symbols_size)
Parse a vlc / vlc_multi code.
Definition: bitstream_template.h:544
read_63
static uint64_t BS_FUNC() read_63(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-63 range.
Definition: bitstream_template.h:252
BSCTX
Definition: bitstream_template.h:35
read_bit
static unsigned int BS_FUNC() read_bit(BSCTX *bc)
Return one bit from the buffer.
Definition: bitstream_template.h:211
NULL
#define NULL
Definition: coverity.c:32
read_signed
static int32_t BS_FUNC() read_signed(BSCTX *bc, unsigned int n)
Return n bits from the buffer as a signed integer.
Definition: bitstream_template.h:316
tell
static int BS_FUNC() tell(const BSCTX *bc)
Return number of bits already read.
Definition: bitstream_template.h:146
seek
static void BS_FUNC() seek(BSCTX *bc, unsigned pos)
Seek to the given bit position.
Definition: bitstream_template.h:407
priv_val_get
static uint64_t BS_FUNC() priv_val_get(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:196
AV_COPY64U
#define AV_COPY64U(d, s)
Definition: intreadwrite.h:611
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
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
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:419
priv_val_show
static uint64_t BS_FUNC() priv_val_show(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:175
BS_FUNC
#define BS_FUNC(x)
Definition: bitstream_template.h:31
peek_signed_nz
static int BS_FUNC() peek_signed_nz(BSCTX *bc, unsigned int n)
Return n bits from the buffer as a signed integer, do not change the buffer state.
Definition: bitstream_template.h:359
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
BSCTX::bits
uint64_t bits
Definition: bitstream_template.h:36
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
BSCTX::buffer_end
const uint8_t * buffer_end
Definition: bitstream_template.h:37
BSCTX::ptr
const uint8_t * ptr
Definition: bitstream_template.h:38
skip_1stop_8data
static int BS_FUNC() skip_1stop_8data(BSCTX *s)
Definition: bitstream_template.h:470
priv_set_idx
static int BS_FUNC() priv_set_idx(BSCTX *bc, int code, int *n, int *nb_bits, const VLCElem *table)
Return the LUT element for the given bitstream configuration.
Definition: bitstream_template.h:487
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:444
apply_sign
static int BS_FUNC() apply_sign(BSCTX *bc, int val)
Definition: bitstream_template.h:464
priv_skip_remaining
static void BS_FUNC() priv_skip_remaining(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:186
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:414
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
BSCTX::size_in_bits
unsigned size_in_bits
Definition: bitstream_template.h:40
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
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:132
init8
static int BS_FUNC() init8(BSCTX *bc, const uint8_t *buffer, unsigned int byte_size)
Initialize BitstreamContext.
Definition: bitstream_template.h:135
priv_refill_32
static int BS_FUNC() priv_refill_32(BSCTX *bc)
Definition: bitstream_template.h:75
int32_t
int32_t
Definition: audioconvert.c:56
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
bytesize
static int BS_FUNC() bytesize(const BSCTX *bc, int round_up)
Return buffer size in bytes.
Definition: bitstream_template.h:162
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
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
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:239
read_vlc
static int BS_FUNC() read_vlc(BSCTX *bc, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: bitstream_template.h:510
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:368