FFmpeg
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 the number of the bits left in a buffer.
161  */
162 static inline int BS_FUNC(left)(const BSCTX *bc)
163 {
164  return (bc->buffer - bc->ptr) * 8 + bc->size_in_bits + bc->bits_valid;
165 }
166 
167 static inline uint64_t BS_FUNC(priv_val_show)(BSCTX *bc, unsigned int n)
168 {
169  av_assert2(n > 0 && n <= 64);
170 
171 #ifdef BITSTREAM_TEMPLATE_LE
172  return bc->bits & (UINT64_MAX >> (64 - n));
173 #else
174  return bc->bits >> (64 - n);
175 #endif
176 }
177 
178 static inline void BS_FUNC(priv_skip_remaining)(BSCTX *bc, unsigned int n)
179 {
180 #ifdef BITSTREAM_TEMPLATE_LE
181  bc->bits >>= n;
182 #else
183  bc->bits <<= n;
184 #endif
185  bc->bits_valid -= n;
186 }
187 
188 static inline uint64_t BS_FUNC(priv_val_get)(BSCTX *bc, unsigned int n)
189 {
190  uint64_t ret;
191 
192  av_assert2(n > 0 && n < 64);
193 
194  ret = BS_FUNC(priv_val_show)(bc, n);
196 
197  return ret;
198 }
199 
200 /**
201  * Return one bit from the buffer.
202  */
203 static inline unsigned int BS_FUNC(read_bit)(BSCTX *bc)
204 {
205  if (!bc->bits_valid && BS_FUNC(priv_refill_64)(bc) < 0)
206  return 0;
207 
208  return BS_FUNC(priv_val_get)(bc, 1);
209 }
210 
211 /**
212  * Return n bits from the buffer, n has to be in the 1-32 range.
213  * May be faster than bits_read() when n is not a compile-time constant and is
214  * known to be non-zero;
215  */
216 static inline uint32_t BS_FUNC(read_nz)(BSCTX *bc, unsigned int n)
217 {
218  av_assert2(n > 0 && n <= 32);
219 
220  if (n > bc->bits_valid) {
221  if (BS_FUNC(priv_refill_32)(bc) < 0)
222  bc->bits_valid = n;
223  }
224 
225  return BS_FUNC(priv_val_get)(bc, n);
226 }
227 
228 /**
229  * Return n bits from the buffer, n has to be in the 0-32 range.
230  */
231 static inline uint32_t BS_FUNC(read)(BSCTX *bc, unsigned int n)
232 {
233  av_assert2(n <= 32);
234 
235  if (!n)
236  return 0;
237 
238  return BS_FUNC(read_nz)(bc, n);
239 }
240 
241 /**
242  * Return n bits from the buffer, n has to be in the 0-63 range.
243  */
244 static inline uint64_t BS_FUNC(read_63)(BSCTX *bc, unsigned int n)
245 {
246  uint64_t ret = 0;
247  unsigned left = 0;
248 
249  av_assert2(n <= 63);
250 
251  if (!n)
252  return 0;
253 
254  if (n > bc->bits_valid) {
255  left = bc->bits_valid;
256  n -= left;
257 
258  if (left)
259  ret = BS_FUNC(priv_val_get)(bc, left);
260 
261  if (BS_FUNC(priv_refill_64)(bc) < 0)
262  bc->bits_valid = n;
263 
264  }
265 
266 #ifdef BITSTREAM_TEMPLATE_LE
267  ret = BS_FUNC(priv_val_get)(bc, n) << left | ret;
268 #else
269  ret = BS_FUNC(priv_val_get)(bc, n) | ret << n;
270 #endif
271 
272  return ret;
273 }
274 
275 /**
276  * Return n bits from the buffer, n has to be in the 0-64 range.
277  */
278 static inline uint64_t BS_FUNC(read_64)(BSCTX *bc, unsigned int n)
279 {
280  av_assert2(n <= 64);
281 
282  if (n == 64) {
283  uint64_t ret = BS_FUNC(read_63)(bc, 63);
284 #ifdef BITSTREAM_TEMPLATE_LE
285  return ret | ((uint64_t)BS_FUNC(read_bit)(bc) << 63);
286 #else
287  return (ret << 1) | (uint64_t)BS_FUNC(read_bit)(bc);
288 #endif
289  }
290  return BS_FUNC(read_63)(bc, n);
291 }
292 
293 /**
294  * Return n bits from the buffer as a signed integer, n has to be in the 1-32
295  * range. May be faster than bits_read_signed() when n is not a compile-time
296  * constant and is known to be non-zero;
297  */
298 static inline int32_t BS_FUNC(read_signed_nz)(BSCTX *bc, unsigned int n)
299 {
300  av_assert2(n > 0 && n <= 32);
301  return sign_extend(BS_FUNC(read_nz)(bc, n), n);
302 }
303 
304 /**
305  * Return n bits from the buffer as a signed integer.
306  * n has to be in the 0-32 range.
307  */
308 static inline int32_t BS_FUNC(read_signed)(BSCTX *bc, unsigned int n)
309 {
310  av_assert2(n <= 32);
311 
312  if (!n)
313  return 0;
314 
315  return BS_FUNC(read_signed_nz)(bc, n);
316 }
317 
318 /**
319  * Return n bits from the buffer but do not change the buffer state.
320  * n has to be in the 1-32 range. May
321  */
322 static inline uint32_t BS_FUNC(peek_nz)(BSCTX *bc, unsigned int n)
323 {
324  av_assert2(n > 0 && n <= 32);
325 
326  if (n > bc->bits_valid)
327  BS_FUNC(priv_refill_32)(bc);
328 
329  return BS_FUNC(priv_val_show)(bc, n);
330 }
331 
332 /**
333  * Return n bits from the buffer but do not change the buffer state.
334  * n has to be in the 0-32 range.
335  */
336 static inline uint32_t BS_FUNC(peek)(BSCTX *bc, unsigned int n)
337 {
338  av_assert2(n <= 32);
339 
340  if (!n)
341  return 0;
342 
343  return BS_FUNC(peek_nz)(bc, n);
344 }
345 
346 /**
347  * Return n bits from the buffer as a signed integer, do not change the buffer
348  * state. n has to be in the 1-32 range. May be faster than bits_peek_signed()
349  * when n is not a compile-time constant and is known to be non-zero;
350  */
351 static inline int BS_FUNC(peek_signed_nz)(BSCTX *bc, unsigned int n)
352 {
353  av_assert2(n > 0 && n <= 32);
354  return sign_extend(BS_FUNC(peek_nz)(bc, n), n);
355 }
356 
357 /**
358  * Return n bits from the buffer as a signed integer,
359  * do not change the buffer state.
360  * n has to be in the 0-32 range.
361  */
362 static inline int BS_FUNC(peek_signed)(BSCTX *bc, unsigned int n)
363 {
364  av_assert2(n <= 32);
365 
366  if (!n)
367  return 0;
368 
369  return BS_FUNC(peek_signed_nz)(bc, n);
370 }
371 
372 /**
373  * Skip n bits in the buffer.
374  */
375 static inline void BS_FUNC(skip)(BSCTX *bc, unsigned int n)
376 {
377  if (n < bc->bits_valid)
379  else {
380  n -= bc->bits_valid;
381  bc->bits = 0;
382  bc->bits_valid = 0;
383 
384  if (n >= 64) {
385  unsigned int skip = n / 8;
386 
387  n -= skip * 8;
388  bc->ptr += skip;
389  }
390  BS_FUNC(priv_refill_64)(bc);
391  if (n)
393  }
394 }
395 
396 /**
397  * Seek to the given bit position.
398  */
399 static inline void BS_FUNC(seek)(BSCTX *bc, unsigned pos)
400 {
401  bc->ptr = bc->buffer;
402  bc->bits = 0;
403  bc->bits_valid = 0;
404 
405  BS_FUNC(skip)(bc, pos);
406 }
407 
408 /**
409  * Skip bits to a byte boundary.
410  */
411 static inline const uint8_t *BS_FUNC(align)(BSCTX *bc)
412 {
413  unsigned int n = -BS_FUNC(tell)(bc) & 7;
414  if (n)
415  BS_FUNC(skip)(bc, n);
416  return bc->buffer + (BS_FUNC(tell)(bc) >> 3);
417 }
418 
419 /**
420  * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
421  * If MSB not set it is negative.
422  * @param n length in bits
423  */
424 static inline int BS_FUNC(read_xbits)(BSCTX *bc, unsigned int n)
425 {
426  int32_t cache = BS_FUNC(peek)(bc, 32);
427  int sign = ~cache >> 31;
429 
430  return ((((uint32_t)(sign ^ cache)) >> (32 - n)) ^ sign) - sign;
431 }
432 
433 /**
434  * Return decoded truncated unary code for the values 0, 1, 2.
435  */
436 static inline int BS_FUNC(decode012)(BSCTX *bc)
437 {
438  if (!BS_FUNC(read_bit)(bc))
439  return 0;
440  else
441  return BS_FUNC(read_bit)(bc) + 1;
442 }
443 
444 /**
445  * Return decoded truncated unary code for the values 2, 1, 0.
446  */
447 static inline int BS_FUNC(decode210)(BSCTX *bc)
448 {
449  if (BS_FUNC(read_bit)(bc))
450  return 0;
451  else
452  return 2 - BS_FUNC(read_bit)(bc);
453 }
454 
455 /* Read sign bit and flip the sign of the provided value accordingly. */
456 static inline int BS_FUNC(apply_sign)(BSCTX *bc, int val)
457 {
458  int sign = BS_FUNC(read_signed)(bc, 1);
459  return (val ^ sign) - sign;
460 }
461 
462 static inline int BS_FUNC(skip_1stop_8data)(BSCTX *s)
463 {
464  if (BS_FUNC(left)(s) <= 0)
465  return AVERROR_INVALIDDATA;
466 
467  while (BS_FUNC(read_bit)(s)) {
468  BS_FUNC(skip)(s, 8);
469  if (BS_FUNC(left)(s) <= 0)
470  return AVERROR_INVALIDDATA;
471  }
472 
473  return 0;
474 }
475 
476 /**
477  * Return the LUT element for the given bitstream configuration.
478  */
479 static inline int BS_FUNC(priv_set_idx)(BSCTX *bc, int code, int *n,
480  int *nb_bits, const VLCElem *table)
481 {
482  unsigned idx;
483 
484  *nb_bits = -*n;
485  idx = BS_FUNC(peek)(bc, *nb_bits) + code;
486  *n = table[idx].len;
487 
488  return table[idx].sym;
489 }
490 
491 /**
492  * Parse a vlc code.
493  * @param bits is the number of bits which will be read at once, must be
494  * identical to nb_bits in vlc_init()
495  * @param max_depth is the number of times bits bits must be read to completely
496  * read the longest vlc code
497  * = (max_vlc_length + bits - 1) / bits
498  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
499  * If the vlc code is invalid and max_depth>1, then the number of bits removed
500  * is undefined.
501  */
502 static inline int BS_FUNC(read_vlc)(BSCTX *bc, const VLCElem *table,
503  int bits, int max_depth)
504 {
505  int nb_bits;
506  unsigned idx = BS_FUNC(peek)(bc, bits);
507  int code = table[idx].sym;
508  int n = table[idx].len;
509 
510  if (max_depth > 1 && n < 0) {
512  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
513  if (max_depth > 2 && n < 0) {
514  BS_FUNC(priv_skip_remaining)(bc, nb_bits);
515  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
516  }
517  }
519 
520  return code;
521 }
522 
523 /**
524  * Parse a vlc / vlc_multi code.
525  * @param bits is the number of bits which will be read at once, must be
526  * identical to nb_bits in vlc_init()
527  * @param max_depth is the number of times bits bits must be read to completely
528  * read the longest vlc code
529  * = (max_vlc_length + bits - 1) / bits
530  * @param dst the parsed symbol(s) will be stored here. Up to 8 bytes are written
531  * @returns number of symbols parsed
532  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
533  * If the vlc code is invalid and max_depth>1, then the number of bits removed
534  * is undefined.
535  */
536 static inline int BS_FUNC(read_vlc_multi)(BSCTX *bc, uint8_t dst[8],
537  const VLC_MULTI_ELEM *const Jtable,
538  const VLCElem *const table,
539  const int bits, const int max_depth,
540  const int symbols_size)
541 {
542  unsigned idx = BS_FUNC(peek)(bc, bits);
543  int ret, nb_bits, code, n = Jtable[idx].len;
544  if (Jtable[idx].num) {
545  AV_COPY64U(dst, Jtable[idx].val8);
546  ret = Jtable[idx].num;
547  } else {
548  code = table[idx].sym;
549  n = table[idx].len;
550  if (max_depth > 1 && n < 0) {
552  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
553  if (max_depth > 2 && n < 0) {
554  BS_FUNC(priv_skip_remaining)(bc, nb_bits);
555  code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
556  }
557  }
558  if (symbols_size == 1)
559  *dst = code;
560  else
561  AV_WN16(dst, code);
562  ret = n > 0;
563  }
565 
566  return ret;
567 }
568 
569 #undef BSCTX
570 #undef BS_FUNC
571 #undef BS_JOIN3
572 #undef BS_JOIN
573 #undef BS_SUFFIX_UPPER
574 #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:278
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:216
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:447
BSCTX::bits_valid
unsigned bits_valid
Definition: bitstream_template.h:39
VLC_MULTI_ELEM
Definition: vlc.h:42
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:336
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:362
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:298
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:424
left
static int BS_FUNC() left(const BSCTX *bc)
Return the number of the bits left in a buffer.
Definition: bitstream_template.h:162
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:322
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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:536
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:244
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:203
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:308
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:399
priv_val_get
static uint64_t BS_FUNC() priv_val_get(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:188
AV_COPY64U
#define AV_COPY64U(d, s)
Definition: intreadwrite.h:574
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:411
priv_val_show
static uint64_t BS_FUNC() priv_val_show(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:167
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:351
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
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:462
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:479
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:436
apply_sign
static int BS_FUNC() apply_sign(BSCTX *bc, int val)
Definition: bitstream_template.h:456
priv_skip_remaining
static void BS_FUNC() priv_skip_remaining(BSCTX *bc, unsigned int n)
Definition: bitstream_template.h:178
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:133
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
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
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:231
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:502
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:370