FFmpeg
asvdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * ASUS V1/V2 decoder.
24  */
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/mem.h"
28 
29 #include "asv.h"
30 #include "avcodec.h"
31 #include "blockdsp.h"
32 #include "idctdsp.h"
33 #include "internal.h"
34 #include "mathops.h"
35 #include "mpeg12data.h"
36 
37 #define VLC_BITS 6
38 #define ASV2_LEVEL_VLC_BITS 10
39 
40 static VLC ccp_vlc;
41 static VLC level_vlc;
42 static VLC dc_ccp_vlc;
43 static VLC ac_ccp_vlc;
44 static VLC asv2_level_vlc;
45 
46 static av_cold void init_vlcs(ASV1Context *a)
47 {
48  static int done = 0;
49 
50  if (!done) {
51  done = 1;
52 
53  INIT_VLC_STATIC(&ccp_vlc, VLC_BITS, 17,
54  &ff_asv_ccp_tab[0][1], 2, 1,
55  &ff_asv_ccp_tab[0][0], 2, 1, 64);
56  INIT_VLC_STATIC(&dc_ccp_vlc, VLC_BITS, 8,
57  &ff_asv_dc_ccp_tab[0][1], 2, 1,
58  &ff_asv_dc_ccp_tab[0][0], 2, 1, 64);
59  INIT_VLC_STATIC(&ac_ccp_vlc, VLC_BITS, 16,
60  &ff_asv_ac_ccp_tab[0][1], 2, 1,
61  &ff_asv_ac_ccp_tab[0][0], 2, 1, 64);
62  INIT_VLC_STATIC(&level_vlc, VLC_BITS, 7,
63  &ff_asv_level_tab[0][1], 2, 1,
64  &ff_asv_level_tab[0][0], 2, 1, 64);
65  INIT_VLC_STATIC(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63,
66  &ff_asv2_level_tab[0][1], 2, 1,
67  &ff_asv2_level_tab[0][0], 2, 1, 1024);
68  }
69 }
70 
71 // FIXME write a reversed bitstream reader to avoid the double reverse
72 static inline int asv2_get_bits(GetBitContext *gb, int n)
73 {
74  return ff_reverse[get_bits(gb, n) << (8 - n)];
75 }
76 
77 static inline int asv1_get_level(GetBitContext *gb)
78 {
79  int code = get_vlc2(gb, level_vlc.table, VLC_BITS, 1);
80 
81  if (code == 3)
82  return get_sbits(gb, 8);
83  else
84  return code - 3;
85 }
86 
87 static inline int asv2_get_level(GetBitContext *gb)
88 {
89  int code = get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS, 1);
90 
91  if (code == 31)
92  return (int8_t) asv2_get_bits(gb, 8);
93  else
94  return code - 31;
95 }
96 
97 static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
98 {
99  int i;
100 
101  block[0] = 8 * get_bits(&a->gb, 8);
102 
103  for (i = 0; i < 11; i++) {
104  const int ccp = get_vlc2(&a->gb, ccp_vlc.table, VLC_BITS, 1);
105 
106  if (ccp) {
107  if (ccp == 16)
108  break;
109  if (ccp < 0 || i >= 10) {
110  av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
111  return AVERROR_INVALIDDATA;
112  }
113 
114  if (ccp & 8)
115  block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
116  if (ccp & 4)
117  block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
118  if (ccp & 2)
119  block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
120  if (ccp & 1)
121  block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
122  }
123  }
124 
125  return 0;
126 }
127 
128 static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
129 {
130  int i, count, ccp;
131 
132  count = asv2_get_bits(&a->gb, 4);
133 
134  block[0] = 8 * asv2_get_bits(&a->gb, 8);
135 
136  ccp = get_vlc2(&a->gb, dc_ccp_vlc.table, VLC_BITS, 1);
137  if (ccp) {
138  if (ccp & 4)
139  block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;
140  if (ccp & 2)
141  block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;
142  if (ccp & 1)
143  block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;
144  }
145 
146  for (i = 1; i < count + 1; i++) {
147  const int ccp = get_vlc2(&a->gb, ac_ccp_vlc.table, VLC_BITS, 1);
148 
149  if (ccp) {
150  if (ccp & 8)
151  block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
152  if (ccp & 4)
153  block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
154  if (ccp & 2)
155  block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
156  if (ccp & 1)
157  block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
158  }
159  }
160 
161  return 0;
162 }
163 
164 static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
165 {
166  int i, ret;
167 
168  a->bdsp.clear_blocks(block[0]);
169 
170  if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
171  for (i = 0; i < 6; i++) {
172  if ((ret = asv1_decode_block(a, block[i])) < 0)
173  return ret;
174  }
175  } else {
176  for (i = 0; i < 6; i++) {
177  if ((ret = asv2_decode_block(a, block[i])) < 0)
178  return ret;
179  }
180  }
181  return 0;
182 }
183 
184 static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
185 {
186  int16_t(*block)[64] = a->block;
187  int linesize = frame->linesize[0];
188 
189  uint8_t *dest_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
190  uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
191  uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
192 
193  a->idsp.idct_put(dest_y, linesize, block[0]);
194  a->idsp.idct_put(dest_y + 8, linesize, block[1]);
195  a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);
196  a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
197 
198  if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
199  a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
200  a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
201  }
202 }
203 
204 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
205  AVPacket *avpkt)
206 {
207  ASV1Context *const a = avctx->priv_data;
208  const uint8_t *buf = avpkt->data;
209  int buf_size = avpkt->size;
210  AVFrame *const p = data;
211  int mb_x, mb_y, ret;
212 
213  if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
214  return AVERROR_INVALIDDATA;
215 
216  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
217  return ret;
218  p->pict_type = AV_PICTURE_TYPE_I;
219  p->key_frame = 1;
220 
221  av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size,
222  buf_size);
223  if (!a->bitstream_buffer)
224  return AVERROR(ENOMEM);
225 
226  if (avctx->codec_id == AV_CODEC_ID_ASV1) {
227  a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
228  (const uint32_t *) buf, buf_size / 4);
229  } else {
230  int i;
231  for (i = 0; i < buf_size; i++)
232  a->bitstream_buffer[i] = ff_reverse[buf[i]];
233  }
234 
235  init_get_bits(&a->gb, a->bitstream_buffer, buf_size * 8);
236 
237  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
238  for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
239  if ((ret = decode_mb(a, a->block)) < 0)
240  return ret;
241 
242  idct_put(a, p, mb_x, mb_y);
243  }
244  }
245 
246  if (a->mb_width2 != a->mb_width) {
247  mb_x = a->mb_width2;
248  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
249  if ((ret = decode_mb(a, a->block)) < 0)
250  return ret;
251 
252  idct_put(a, p, mb_x, mb_y);
253  }
254  }
255 
256  if (a->mb_height2 != a->mb_height) {
257  mb_y = a->mb_height2;
258  for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
259  if ((ret = decode_mb(a, a->block)) < 0)
260  return ret;
261 
262  idct_put(a, p, mb_x, mb_y);
263  }
264  }
265 
266  *got_frame = 1;
267 
268  emms_c();
269 
270  return (get_bits_count(&a->gb) + 31) / 32 * 4;
271 }
272 
273 static av_cold int decode_init(AVCodecContext *avctx)
274 {
275  ASV1Context *const a = avctx->priv_data;
276  const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
277  int i;
278 
279  if (avctx->extradata_size < 1) {
280  av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");
281  }
282 
283  ff_asv_common_init(avctx);
284  ff_blockdsp_init(&a->bdsp, avctx);
285  ff_idctdsp_init(&a->idsp, avctx);
286  init_vlcs(a);
287  ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
288  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
289 
290  if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {
291  av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
292  if (avctx->codec_id == AV_CODEC_ID_ASV1)
293  a->inv_qscale = 6;
294  else
295  a->inv_qscale = 10;
296  }
297 
298  for (i = 0; i < 64; i++) {
299  int index = ff_asv_scantab[i];
300 
301  a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
302  a->inv_qscale;
303  }
304 
305  return 0;
306 }
307 
308 static av_cold int decode_end(AVCodecContext *avctx)
309 {
310  ASV1Context *const a = avctx->priv_data;
311 
312  av_freep(&a->bitstream_buffer);
313  a->bitstream_buffer_size = 0;
314 
315  return 0;
316 }
317 
318 #if CONFIG_ASV1_DECODER
319 AVCodec ff_asv1_decoder = {
320  .name = "asv1",
321  .long_name = NULL_IF_CONFIG_SMALL("ASUS V1"),
322  .type = AVMEDIA_TYPE_VIDEO,
323  .id = AV_CODEC_ID_ASV1,
324  .priv_data_size = sizeof(ASV1Context),
325  .init = decode_init,
326  .close = decode_end,
327  .decode = decode_frame,
328  .capabilities = AV_CODEC_CAP_DR1,
329 };
330 #endif
331 
332 #if CONFIG_ASV2_DECODER
333 AVCodec ff_asv2_decoder = {
334  .name = "asv2",
335  .long_name = NULL_IF_CONFIG_SMALL("ASUS V2"),
336  .type = AVMEDIA_TYPE_VIDEO,
337  .id = AV_CODEC_ID_ASV2,
338  .priv_data_size = sizeof(ASV1Context),
339  .init = decode_init,
340  .close = decode_end,
341  .decode = decode_frame,
342  .capabilities = AV_CODEC_CAP_DR1,
343 };
344 #endif
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: asvdec.c:204
ff_asv2_level_tab
const uint8_t ff_asv2_level_tab[63][2]
Definition: asv.c:67
AVCodec
AVCodec.
Definition: avcodec.h:3481
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
dc_ccp_vlc
static VLC dc_ccp_vlc
Definition: asvdec.c:42
ff_asv_dc_ccp_tab
const uint8_t ff_asv_dc_ccp_tab[8][2]
Definition: asv.c:55
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
ff_asv_level_tab
const uint8_t ff_asv_level_tab[7][2]
Definition: asv.c:51
blockdsp.h
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
n
int n
Definition: avisynth_c.h:760
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:75
ASV2_LEVEL_VLC_BITS
#define ASV2_LEVEL_VLC_BITS
Definition: asvdec.c:38
ff_asv1_decoder
AVCodec ff_asv1_decoder
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
count
void INT64 INT64 count
Definition: avisynth_c.h:767
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: asvdec.c:273
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
ff_reverse
const uint8_t ff_reverse[256]
Definition: reverse.c:23
data
const char data[16]
Definition: mxf.c:91
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
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
ff_asv_scantab
const uint8_t ff_asv_scantab[64]
Definition: asv.c:32
GetBitContext
Definition: get_bits.h:61
VLC_BITS
#define VLC_BITS
Definition: asvdec.c:37
asv2_get_level
static int asv2_get_level(GetBitContext *gb)
Definition: asvdec.c:87
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
ac_ccp_vlc
static VLC ac_ccp_vlc
Definition: asvdec.c:43
ff_asv2_decoder
AVCodec ff_asv2_decoder
asv2_decode_block
static int asv2_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:128
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
ASV1Context
Definition: asv.h:42
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1667
asv.h
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1575
ff_asv_ac_ccp_tab
const uint8_t ff_asv_ac_ccp_tab[16][2]
Definition: asv.c:60
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
mathops.h
asv2_level_vlc
static VLC asv2_level_vlc
Definition: asvdec.c:44
index
int index
Definition: gxfenc.c:89
ccp_vlc
static VLC ccp_vlc
Definition: asvdec.c:40
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
ff_asv_common_init
av_cold void ff_asv_common_init(AVCodecContext *avctx)
Definition: asv.c:83
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
attributes.h
decode_mb
static int decode_mb(ASV1Context *a, int16_t block[6][64])
Definition: asvdec.c:164
AV_CODEC_ID_ASV1
@ AV_CODEC_ID_ASV1
Definition: avcodec.h:249
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
AV_CODEC_ID_ASV2
@ AV_CODEC_ID_ASV2
Definition: avcodec.h:250
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
asv2_get_bits
static int asv2_get_bits(GetBitContext *gb, int n)
Definition: asvdec.c:72
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
idctdsp.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
mpeg12data.h
idct_put
static void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
Definition: asvdec.c:184
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
level_vlc
static VLC level_vlc
Definition: asvdec.c:41
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: asvdec.c:308
asv1_decode_block
static int asv1_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:97
VLC
Definition: vlc.h:26
init_vlcs
static av_cold void init_vlcs(ASV1Context *a)
Definition: asvdec.c:46
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
ff_asv_ccp_tab
const uint8_t ff_asv_ccp_tab[17][2]
Definition: asv.c:43
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
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
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
asv1_get_level
static int asv1_get_level(GetBitContext *gb)
Definition: asvdec.c:77
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
Generated on Wed Aug 24 2022 21:26:34 for FFmpeg by   doxygen 1.8.17