FFmpeg
bitstream.c
Go to the documentation of this file.
1 /*
2  * Common bit i/o utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  * Copyright (c) 2010 Loren Merritt
6  *
7  * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 /**
27  * @file
28  * bitstream api.
29  */
30 
31 #include <inttypes.h>
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <string.h>
35 
36 #include "config.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/bswap.h"
39 #include "libavutil/common.h"
40 #include "libavutil/error.h"
41 #include "libavutil/internal.h"
42 #include "libavutil/intreadwrite.h"
43 #include "libavutil/log.h"
44 #include "libavutil/mem.h"
45 #include "libavutil/qsort.h"
46 #include "mathops.h"
47 #include "put_bits.h"
48 #include "vlc.h"
49 
50 const uint8_t ff_log2_run[41]={
51  0, 0, 0, 0, 1, 1, 1, 1,
52  2, 2, 2, 2, 3, 3, 3, 3,
53  4, 4, 5, 5, 6, 6, 7, 7,
54  8, 9,10,11,12,13,14,15,
55 16,17,18,19,20,21,22,23,
56 24,
57 };
58 
59 void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
60 {
61  while (*string) {
62  put_bits(pb, 8, *string);
63  string++;
64  }
65  if (terminate_string)
66  put_bits(pb, 8, 0);
67 }
68 
69 void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
70 {
71  int words = length >> 4;
72  int bits = length & 15;
73  int i;
74 
75  if (length == 0)
76  return;
77 
78  av_assert0(length <= put_bits_left(pb));
79 
80  if (CONFIG_SMALL || words < 16 || put_bits_count(pb) & 7) {
81  for (i = 0; i < words; i++)
82  put_bits(pb, 16, AV_RB16(src + 2 * i));
83  } else {
84  for (i = 0; put_bits_count(pb) & 31; i++)
85  put_bits(pb, 8, src[i]);
86  flush_put_bits(pb);
87  memcpy(put_bits_ptr(pb), src + i, 2 * words - i);
88  skip_put_bytes(pb, 2 * words - i);
89  }
90 
91  put_bits(pb, bits, AV_RB16(src + 2 * words) >> (16 - bits));
92 }
93 
94 /* VLC decoding */
95 
96 #define GET_DATA(v, table, i, wrap, size) \
97 { \
98  const uint8_t *ptr = (const uint8_t *)table + i * wrap; \
99  switch(size) { \
100  case 1: \
101  v = *(const uint8_t *)ptr; \
102  break; \
103  case 2: \
104  v = *(const uint16_t *)ptr; \
105  break; \
106  case 4: \
107  default: \
108  av_assert1(size == 4); \
109  v = *(const uint32_t *)ptr; \
110  break; \
111  } \
112 }
113 
114 
115 static int alloc_table(VLC *vlc, int size, int use_static)
116 {
117  int index = vlc->table_size;
118 
119  vlc->table_size += size;
120  if (vlc->table_size > vlc->table_allocated) {
121  if (use_static)
122  abort(); // cannot do anything, init_vlc() is used with too little memory
123  vlc->table_allocated += (1 << vlc->bits);
124  vlc->table = av_realloc_f(vlc->table, vlc->table_allocated, sizeof(VLC_TYPE) * 2);
125  if (!vlc->table) {
126  vlc->table_allocated = 0;
127  vlc->table_size = 0;
128  return AVERROR(ENOMEM);
129  }
130  memset(vlc->table + vlc->table_allocated - (1 << vlc->bits), 0, sizeof(VLC_TYPE) * 2 << vlc->bits);
131  }
132  return index;
133 }
134 
135 #define LOCALBUF_ELEMS 1500 // the maximum currently needed is 1296 by rv34
136 
137 typedef struct VLCcode {
138  uint8_t bits;
140  /** codeword, with the first bit-to-be-read in the msb
141  * (even if intended for a little-endian bitstream reader) */
142  uint32_t code;
143 } VLCcode;
144 
145 static int vlc_common_init(VLC *vlc_arg, int nb_bits, int nb_codes,
146  VLC **vlc, VLC *localvlc, VLCcode **buf,
147  int flags)
148 {
149  *vlc = vlc_arg;
150  (*vlc)->bits = nb_bits;
152  av_assert0(nb_codes <= LOCALBUF_ELEMS);
153  *localvlc = *vlc_arg;
154  *vlc = localvlc;
155  (*vlc)->table_size = 0;
156  } else {
157  (*vlc)->table = NULL;
158  (*vlc)->table_allocated = 0;
159  (*vlc)->table_size = 0;
160  }
161  if (nb_codes > LOCALBUF_ELEMS) {
162  *buf = av_malloc_array(nb_codes, sizeof(VLCcode));
163  if (!*buf)
164  return AVERROR(ENOMEM);
165  }
166 
167  return 0;
168 }
169 
170 static int compare_vlcspec(const void *a, const void *b)
171 {
172  const VLCcode *sa = a, *sb = b;
173  return (sa->code >> 1) - (sb->code >> 1);
174 }
175 /**
176  * Build VLC decoding tables suitable for use with get_vlc().
177  *
178  * @param vlc the context to be initialized
179  *
180  * @param table_nb_bits max length of vlc codes to store directly in this table
181  * (Longer codes are delegated to subtables.)
182  *
183  * @param nb_codes number of elements in codes[]
184  *
185  * @param codes descriptions of the vlc codes
186  * These must be ordered such that codes going into the same subtable are contiguous.
187  * Sorting by VLCcode.code is sufficient, though not necessary.
188  */
189 static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
190  VLCcode *codes, int flags)
191 {
192  int table_size, table_index, index, code_prefix, symbol, subtable_bits;
193  int i, j, k, n, nb, inc;
194  uint32_t code;
195  volatile VLC_TYPE (* volatile table)[2]; // the double volatile is needed to prevent an internal compiler error in gcc 4.2
196 
197  if (table_nb_bits > 30)
198  return AVERROR(EINVAL);
199  table_size = 1 << table_nb_bits;
200  table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
201  ff_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
202  if (table_index < 0)
203  return table_index;
204  table = (volatile VLC_TYPE (*)[2])&vlc->table[table_index];
205 
206  /* first pass: map codes and compute auxiliary table sizes */
207  for (i = 0; i < nb_codes; i++) {
208  n = codes[i].bits;
209  code = codes[i].code;
210  symbol = codes[i].symbol;
211  ff_dlog(NULL, "i=%d n=%d code=0x%"PRIx32"\n", i, n, code);
212  if (n <= table_nb_bits) {
213  /* no need to add another table */
214  j = code >> (32 - table_nb_bits);
215  nb = 1 << (table_nb_bits - n);
216  inc = 1;
217  if (flags & INIT_VLC_OUTPUT_LE) {
218  j = bitswap_32(code);
219  inc = 1 << n;
220  }
221  for (k = 0; k < nb; k++) {
222  int bits = table[j][1];
223  int oldsym = table[j][0];
224  ff_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
225  if ((bits || oldsym) && (bits != n || oldsym != symbol)) {
226  av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
227  return AVERROR_INVALIDDATA;
228  }
229  table[j][1] = n; //bits
230  table[j][0] = symbol;
231  j += inc;
232  }
233  } else {
234  /* fill auxiliary table recursively */
235  n -= table_nb_bits;
236  code_prefix = code >> (32 - table_nb_bits);
237  subtable_bits = n;
238  codes[i].bits = n;
239  codes[i].code = code << table_nb_bits;
240  for (k = i+1; k < nb_codes; k++) {
241  n = codes[k].bits - table_nb_bits;
242  if (n <= 0)
243  break;
244  code = codes[k].code;
245  if (code >> (32 - table_nb_bits) != code_prefix)
246  break;
247  codes[k].bits = n;
248  codes[k].code = code << table_nb_bits;
249  subtable_bits = FFMAX(subtable_bits, n);
250  }
251  subtable_bits = FFMIN(subtable_bits, table_nb_bits);
252  j = (flags & INIT_VLC_OUTPUT_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
253  table[j][1] = -subtable_bits;
254  ff_dlog(NULL, "%4x: n=%d (subtable)\n",
255  j, codes[i].bits + table_nb_bits);
256  index = build_table(vlc, subtable_bits, k-i, codes+i, flags);
257  if (index < 0)
258  return index;
259  /* note: realloc has been done, so reload tables */
260  table = (volatile VLC_TYPE (*)[2])&vlc->table[table_index];
261  table[j][0] = index; //code
262  if (table[j][0] != index) {
263  avpriv_request_sample(NULL, "strange codes");
264  return AVERROR_PATCHWELCOME;
265  }
266  i = k-1;
267  }
268  }
269 
270  for (i = 0; i < table_size; i++) {
271  if (table[i][1] == 0) //bits
272  table[i][0] = -1; //codes
273  }
274 
275  return table_index;
276 }
277 
278 static int vlc_common_end(VLC *vlc, int nb_bits, int nb_codes, VLCcode *codes,
279  int flags, VLC *vlc_arg, VLCcode localbuf[LOCALBUF_ELEMS])
280 {
281  int ret = build_table(vlc, nb_bits, nb_codes, codes, flags);
282 
284  if (vlc->table_size != vlc->table_allocated &&
286  av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", vlc->table_size, vlc->table_allocated);
287  av_assert0(ret >= 0);
288  *vlc_arg = *vlc;
289  } else {
290  if (codes != localbuf)
291  av_free(codes);
292  if (ret < 0) {
293  av_freep(&vlc->table);
294  return ret;
295  }
296  }
297  return 0;
298 }
299 
300 /* Build VLC decoding tables suitable for use with get_vlc().
301 
302  'nb_bits' sets the decoding table size (2^nb_bits) entries. The
303  bigger it is, the faster is the decoding. But it should not be too
304  big to save memory and L1 cache. '9' is a good compromise.
305 
306  'nb_codes' : number of vlcs codes
307 
308  'bits' : table which gives the size (in bits) of each vlc code.
309 
310  'codes' : table which gives the bit pattern of of each vlc code.
311 
312  'symbols' : table which gives the values to be returned from get_vlc().
313 
314  'xxx_wrap' : give the number of bytes between each entry of the
315  'bits' or 'codes' tables.
316 
317  'xxx_size' : gives the number of bytes of each entry of the 'bits'
318  or 'codes' tables. Currently 1,2 and 4 are supported.
319 
320  'wrap' and 'size' make it possible to use any memory configuration and types
321  (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
322 */
323 int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes,
324  const void *bits, int bits_wrap, int bits_size,
325  const void *codes, int codes_wrap, int codes_size,
326  const void *symbols, int symbols_wrap, int symbols_size,
327  int flags)
328 {
329  VLCcode localbuf[LOCALBUF_ELEMS], *buf = localbuf;
330  int i, j, ret;
331  VLC localvlc, *vlc;
332 
333  ret = vlc_common_init(vlc_arg, nb_bits, nb_codes, &vlc, &localvlc,
334  &buf, flags);
335  if (ret < 0)
336  return ret;
337 
338  av_assert0(symbols_size <= 2 || !symbols);
339  j = 0;
340 #define COPY(condition)\
341  for (i = 0; i < nb_codes; i++) { \
342  unsigned len; \
343  GET_DATA(len, bits, i, bits_wrap, bits_size); \
344  if (!(condition)) \
345  continue; \
346  if (len > 3*nb_bits || len > 32) { \
347  av_log(NULL, AV_LOG_ERROR, "Too long VLC (%u) in init_vlc\n", len);\
348  if (buf != localbuf) \
349  av_free(buf); \
350  return AVERROR(EINVAL); \
351  } \
352  buf[j].bits = len; \
353  GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size); \
354  if (buf[j].code >= (1LL<<buf[j].bits)) { \
355  av_log(NULL, AV_LOG_ERROR, "Invalid code %"PRIx32" for %d in " \
356  "init_vlc\n", buf[j].code, i); \
357  if (buf != localbuf) \
358  av_free(buf); \
359  return AVERROR(EINVAL); \
360  } \
361  if (flags & INIT_VLC_INPUT_LE) \
362  buf[j].code = bitswap_32(buf[j].code); \
363  else \
364  buf[j].code <<= 32 - buf[j].bits; \
365  if (symbols) \
366  GET_DATA(buf[j].symbol, symbols, i, symbols_wrap, symbols_size) \
367  else \
368  buf[j].symbol = i; \
369  j++; \
370  }
371  COPY(len > nb_bits);
372  // qsort is the slowest part of init_vlc, and could probably be improved or avoided
373  AV_QSORT(buf, j, struct VLCcode, compare_vlcspec);
374  COPY(len && len <= nb_bits);
375  nb_codes = j;
376 
377  return vlc_common_end(vlc, nb_bits, nb_codes, buf,
378  flags, vlc_arg, localbuf);
379 }
380 
381 int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes,
382  const int8_t *lens, int lens_wrap,
383  const void *symbols, int symbols_wrap, int symbols_size,
384  int offset, int flags, void *logctx)
385 {
386  VLCcode localbuf[LOCALBUF_ELEMS], *buf = localbuf;
387  VLC localvlc, *vlc;
388  uint64_t code;
389  int ret, j, len_max = FFMIN(32, 3 * nb_bits);
390 
391  ret = vlc_common_init(vlc_arg, nb_bits, nb_codes, &vlc, &localvlc,
392  &buf, flags);
393  if (ret < 0)
394  return ret;
395 
396  j = code = 0;
397  for (int i = 0; i < nb_codes; i++, lens += lens_wrap) {
398  int len = *lens;
399  if (len > 0) {
400  unsigned sym;
401 
402  buf[j].bits = len;
403  if (symbols)
404  GET_DATA(sym, symbols, i, symbols_wrap, symbols_size)
405  else
406  sym = i;
407  buf[j].symbol = sym + offset;
408  buf[j++].code = code;
409  } else if (len < 0) {
410  len = -len;
411  } else
412  continue;
413  if (len > len_max || code & ((1U << (32 - len)) - 1)) {
414  av_log(logctx, AV_LOG_ERROR, "Invalid VLC (length %u)\n", len);
415  goto fail;
416  }
417  code += 1U << (32 - len);
418  if (code > UINT32_MAX + 1ULL) {
419  av_log(logctx, AV_LOG_ERROR, "Overdetermined VLC tree\n");
420  goto fail;
421  }
422  }
423  return vlc_common_end(vlc, nb_bits, j, buf,
424  flags, vlc_arg, localbuf);
425 fail:
426  if (buf != localbuf)
427  av_free(buf);
428  return AVERROR_INVALIDDATA;
429 }
430 
431 void ff_free_vlc(VLC *vlc)
432 {
433  av_freep(&vlc->table);
434 }
build_table
static int build_table(VLC *vlc, int table_nb_bits, int nb_codes, VLCcode *codes, int flags)
Build VLC decoding tables suitable for use with get_vlc().
Definition: bitstream.c:189
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
bitswap_32
static av_always_inline uint32_t bitswap_32(uint32_t x)
Definition: mathops.h:243
INIT_VLC_OUTPUT_LE
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
index
fg index
Definition: ffmpeg_filter.c:168
b
#define b
Definition: input.c:40
table
static const uint16_t table[]
Definition: prosumer.c:206
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
COPY
#define COPY(condition)
ff_copy_bits
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:69
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
U
#define U(x)
Definition: vp56_arith.h:37
fail
#define fail()
Definition: checkasm.h:127
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:124
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
intreadwrite.h
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_put_string
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:59
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
LOCALBUF_ELEMS
#define LOCALBUF_ELEMS
Definition: bitstream.c:135
PutBitContext
Definition: put_bits.h:49
if
if(ret)
Definition: filter_design.txt:179
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: bitstream.c:50
vlc_common_end
static int vlc_common_end(VLC *vlc, int nb_bits, int nb_codes, VLCcode *codes, int flags, VLC *vlc_arg, VLCcode localbuf[LOCALBUF_ELEMS])
Definition: bitstream.c:278
src
#define src
Definition: vp8dsp.c:255
mathops.h
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
error.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
vlc_common_init
static int vlc_common_init(VLC *vlc_arg, int nb_bits, int nb_codes, VLC **vlc, VLC *localvlc, VLCcode **buf, int flags)
Definition: bitstream.c:145
VLCcode
Definition: bitstream.c:137
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
qsort.h
GET_DATA
#define GET_DATA(v, table, i, wrap, size)
Definition: bitstream.c:96
size
int size
Definition: twinvq_data.h:10344
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
code_prefix
static const unsigned code_prefix[]
Definition: qdmc.c:76
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
AV_QSORT
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
Definition: qsort.h:33
internal.h
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
common.h
VLCcode::bits
uint8_t bits
Definition: bitstream.c:138
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
VLCcode::code
uint32_t code
codeword, with the first bit-to-be-read in the msb (even if intended for a little-endian bitstream re...
Definition: bitstream.c:142
len
int len
Definition: vorbis_enc_data.h:426
VLC::bits
int bits
Definition: vlc.h:27
alloc_table
static int alloc_table(VLC *vlc, int size, int use_static)
Definition: bitstream.c:115
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
bswap.h
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:369
VLC
Definition: vlc.h:26
skip_put_bytes
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:378
VLC::table_size
int table_size
Definition: vlc.h:29
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
compare_vlcspec
static int compare_vlcspec(const void *a, const void *b)
Definition: bitstream.c:170
vlc.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:61
VLCcode::symbol
VLC_TYPE symbol
Definition: bitstream.c:139
put_bits.h
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AV_RB16
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98