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 #include "libavutil/thread.h"
29 
30 #include "asv.h"
31 #include "avcodec.h"
32 #include "blockdsp.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35 #include "mpeg12data.h"
36 
37 #define CCP_VLC_BITS 5
38 #define DC_CCP_VLC_BITS 4
39 #define AC_CCP_VLC_BITS 6
40 #define ASV1_LEVEL_VLC_BITS 4
41 #define ASV2_LEVEL_VLC_BITS 10
42 
43 static VLC ccp_vlc;
44 static VLC level_vlc;
45 static VLC dc_ccp_vlc;
46 static VLC ac_ccp_vlc;
48 
49 static av_cold void init_vlcs(void)
50 {
51  INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17,
52  &ff_asv_ccp_tab[0][1], 2, 1,
53  &ff_asv_ccp_tab[0][0], 2, 1, 32);
54  INIT_LE_VLC_STATIC(&dc_ccp_vlc, DC_CCP_VLC_BITS, 8,
55  &ff_asv_dc_ccp_tab[0][1], 2, 1,
56  &ff_asv_dc_ccp_tab[0][0], 2, 1, 16);
57  INIT_LE_VLC_STATIC(&ac_ccp_vlc, AC_CCP_VLC_BITS, 16,
58  &ff_asv_ac_ccp_tab[0][1], 2, 1,
59  &ff_asv_ac_ccp_tab[0][0], 2, 1, 64);
60  INIT_VLC_STATIC(&level_vlc, ASV1_LEVEL_VLC_BITS, 7,
61  &ff_asv_level_tab[0][1], 2, 1,
62  &ff_asv_level_tab[0][0], 2, 1, 16);
63  INIT_LE_VLC_STATIC(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63,
64  &ff_asv2_level_tab[0][1], 4, 2,
65  &ff_asv2_level_tab[0][0], 4, 2, 1024);
66 }
67 
68 static inline int asv1_get_level(GetBitContext *gb)
69 {
70  int code = get_vlc2(gb, level_vlc.table, ASV1_LEVEL_VLC_BITS, 1);
71 
72  if (code == 3)
73  return get_sbits(gb, 8);
74  else
75  return code - 3;
76 }
77 
78 // get_vlc2() is big-endian in this file
79 static inline int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE (*table)[2], int bits)
80 {
81  unsigned int index;
82  int code, n;
83 
84  OPEN_READER(re, gb);
85  UPDATE_CACHE_LE(re, gb);
86 
87  index = SHOW_UBITS_LE(re, gb, bits);
88  code = table[index][0];
89  n = table[index][1];
90  LAST_SKIP_BITS(re, gb, n);
91 
92  CLOSE_READER(re, gb);
93 
94  return code;
95 }
96 
97 static inline int asv2_get_level(GetBitContext *gb)
98 {
99  int code = asv2_get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS);
100 
101  if (code == 31)
102  return (int8_t) get_bits_le(gb, 8);
103  else
104  return code - 31;
105 }
106 
107 static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
108 {
109  int i;
110 
111  block[0] = 8 * get_bits(&a->gb, 8);
112 
113  for (i = 0; i < 11; i++) {
114  const int ccp = get_vlc2(&a->gb, ccp_vlc.table, CCP_VLC_BITS, 1);
115 
116  if (ccp) {
117  if (ccp == 16)
118  break;
119  if (ccp < 0 || i >= 10) {
120  av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
121  return AVERROR_INVALIDDATA;
122  }
123 
124  if (ccp & 8)
125  block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
126  if (ccp & 4)
127  block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
128  if (ccp & 2)
129  block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
130  if (ccp & 1)
131  block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
132  }
133  }
134 
135  return 0;
136 }
137 
138 static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
139 {
140  int i, count, ccp;
141 
142  count = get_bits_le(&a->gb, 4);
143 
144  block[0] = 8 * get_bits_le(&a->gb, 8);
145 
146  ccp = asv2_get_vlc2(&a->gb, dc_ccp_vlc.table, DC_CCP_VLC_BITS);
147  if (ccp) {
148  if (ccp & 4)
149  block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;
150  if (ccp & 2)
151  block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;
152  if (ccp & 1)
153  block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;
154  }
155 
156  for (i = 1; i < count + 1; i++) {
157  const int ccp = asv2_get_vlc2(&a->gb, ac_ccp_vlc.table, AC_CCP_VLC_BITS);
158 
159  if (ccp) {
160  if (ccp & 8)
161  block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
162  if (ccp & 4)
163  block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
164  if (ccp & 2)
165  block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
166  if (ccp & 1)
167  block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
168  }
169  }
170 
171  return 0;
172 }
173 
174 static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
175 {
176  int i, ret;
177 
178  a->bdsp.clear_blocks(block[0]);
179 
180  if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
181  for (i = 0; i < 6; i++) {
182  if ((ret = asv1_decode_block(a, block[i])) < 0)
183  return ret;
184  }
185  } else {
186  for (i = 0; i < 6; i++) {
187  if ((ret = asv2_decode_block(a, block[i])) < 0)
188  return ret;
189  }
190  }
191  return 0;
192 }
193 
194 static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
195 {
196  int16_t(*block)[64] = a->block;
197  int linesize = frame->linesize[0];
198 
199  uint8_t *dest_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
200  uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
201  uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
202 
203  a->idsp.idct_put(dest_y, linesize, block[0]);
204  a->idsp.idct_put(dest_y + 8, linesize, block[1]);
205  a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);
206  a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
207 
208  if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
209  a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
210  a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
211  }
212 }
213 
214 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
215  AVPacket *avpkt)
216 {
217  ASV1Context *const a = avctx->priv_data;
218  const uint8_t *buf = avpkt->data;
219  int buf_size = avpkt->size;
220  AVFrame *const p = data;
221  int mb_x, mb_y, ret;
222 
223  if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
224  return AVERROR_INVALIDDATA;
225 
226  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
227  return ret;
229  p->key_frame = 1;
230 
231  if (avctx->codec_id == AV_CODEC_ID_ASV1) {
233  buf_size);
234  if (!a->bitstream_buffer)
235  return AVERROR(ENOMEM);
236 
237  a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
238  (const uint32_t *) buf, buf_size / 4);
239  ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);
240  } else {
241  ret = init_get_bits8_le(&a->gb, buf, buf_size);
242  }
243  if (ret < 0)
244  return ret;
245 
246  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
247  for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
248  if ((ret = decode_mb(a, a->block)) < 0)
249  return ret;
250 
251  idct_put(a, p, mb_x, mb_y);
252  }
253  }
254 
255  if (a->mb_width2 != a->mb_width) {
256  mb_x = a->mb_width2;
257  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
258  if ((ret = decode_mb(a, a->block)) < 0)
259  return ret;
260 
261  idct_put(a, p, mb_x, mb_y);
262  }
263  }
264 
265  if (a->mb_height2 != a->mb_height) {
266  mb_y = a->mb_height2;
267  for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
268  if ((ret = decode_mb(a, a->block)) < 0)
269  return ret;
270 
271  idct_put(a, p, mb_x, mb_y);
272  }
273  }
274 
275  *got_frame = 1;
276 
277  emms_c();
278 
279  return (get_bits_count(&a->gb) + 31) / 32 * 4;
280 }
281 
283 {
284  static AVOnce init_static_once = AV_ONCE_INIT;
285  ASV1Context *const a = avctx->priv_data;
286  const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
287  int i;
288 
289  if (avctx->extradata_size < 1) {
290  av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");
291  }
292 
293  ff_asv_common_init(avctx);
294  ff_blockdsp_init(&a->bdsp, avctx);
295  ff_idctdsp_init(&a->idsp, avctx);
297  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
298 
299  if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {
300  av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
301  if (avctx->codec_id == AV_CODEC_ID_ASV1)
302  a->inv_qscale = 6;
303  else
304  a->inv_qscale = 10;
305  }
306 
307  for (i = 0; i < 64; i++) {
308  int index = ff_asv_scantab[i];
309 
310  a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
311  a->inv_qscale;
312  }
313 
314  ff_thread_once(&init_static_once, init_vlcs);
315 
316  return 0;
317 }
318 
320 {
321  ASV1Context *const a = avctx->priv_data;
322 
324  a->bitstream_buffer_size = 0;
325 
326  return 0;
327 }
328 
329 #if CONFIG_ASV1_DECODER
331  .name = "asv1",
332  .long_name = NULL_IF_CONFIG_SMALL("ASUS V1"),
333  .type = AVMEDIA_TYPE_VIDEO,
334  .id = AV_CODEC_ID_ASV1,
335  .priv_data_size = sizeof(ASV1Context),
336  .init = decode_init,
337  .close = decode_end,
338  .decode = decode_frame,
339  .capabilities = AV_CODEC_CAP_DR1,
340  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
341 };
342 #endif
343 
344 #if CONFIG_ASV2_DECODER
346  .name = "asv2",
347  .long_name = NULL_IF_CONFIG_SMALL("ASUS V2"),
348  .type = AVMEDIA_TYPE_VIDEO,
349  .id = AV_CODEC_ID_ASV2,
350  .priv_data_size = sizeof(ASV1Context),
351  .init = decode_init,
352  .decode = decode_frame,
353  .capabilities = AV_CODEC_CAP_DR1,
354  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
355 };
356 #endif
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: asvdec.c:214
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
const uint8_t ff_asv_ac_ccp_tab[16][2]
Definition: asv.c:60
#define AC_CCP_VLC_BITS
Definition: asvdec.c:39
static int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE(*table)[2], int bits)
Definition: asvdec.c:79
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Memory handling functions.
int16_t block[6][64]
Definition: asv.h:57
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
int size
Definition: packet.h:364
AVCodecContext * avctx
Definition: asv.h:43
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
IDCTDSPContext idsp
Definition: asv.h:47
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:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
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:72
uint8_t permutated[64]
Definition: idctdsp.h:33
static int asv2_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:138
unsigned int bitstream_buffer_size
Definition: asv.h:61
AVCodec.
Definition: codec.h:190
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
Macro definitions for various function/variable attributes.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
The exact code depends on how similar the blocks are and how related they are to the block
static av_cold int decode_init(AVCodecContext *avctx)
Definition: asvdec.c:282
uint8_t
#define av_cold
Definition: attributes.h:88
uint8_t * bitstream_buffer
Definition: asv.h:60
static VLC asv2_level_vlc
Definition: asvdec.c:47
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:123
const uint8_t ff_asv_ccp_tab[17][2]
Definition: asv.c:43
static int asv2_get_level(GetBitContext *gb)
Definition: asvdec.c:97
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
const uint8_t ff_asv_dc_ccp_tab[8][2]
Definition: asv.c:55
int mb_height2
Definition: asv.h:56
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define AVOnce
Definition: thread.h:172
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:201
#define av_log(a,...)
#define ASV1_LEVEL_VLC_BITS
Definition: asvdec.c:40
static const uint16_t table[]
Definition: prosumer.c:206
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
BswapDSPContext bbdsp
Definition: asv.h:45
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:37
av_cold void ff_asv_common_init(AVCodecContext *avctx)
Definition: asv.c:89
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:141
#define ASV2_LEVEL_VLC_BITS
Definition: asvdec.c:41
uint16_t intra_matrix[64]
Definition: asv.h:58
GLsizei count
Definition: opengl_enc.c:108
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
ASUS V1/V2 encoder/decoder common data.
static av_cold void init_vlcs(void)
Definition: asvdec.c:49
Definition: vlc.h:26
#define DC_CCP_VLC_BITS
Definition: asvdec.c:38
ScanTable scantable
Definition: asv.h:51
GetBitContext gb
Definition: asv.h:50
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
static VLC level_vlc
Definition: asvdec.c:44
static int decode_mb(ASV1Context *a, int16_t block[6][64])
Definition: asvdec.c:174
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
static VLC ccp_vlc
Definition: asvdec.c:43
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
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
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
int mb_width
Definition: asv.h:53
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
#define AV_ONCE_INIT
Definition: thread.h:173
Libavcodec external API header.
static VLC ac_ccp_vlc
Definition: asvdec.c:46
enum AVCodecID codec_id
Definition: avcodec.h:541
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:531
static VLC dc_ccp_vlc
Definition: asvdec.c:45
MPEG-1/2 tables.
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1884
int extradata_size
Definition: avcodec.h:633
#define CCP_VLC_BITS
Definition: asvdec.c:37
int index
Definition: gxfenc.c:89
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
const uint16_t ff_asv2_level_tab[63][2]
Definition: asv.c:67
int mb_width2
Definition: asv.h:55
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
static void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
Definition: asvdec.c:194
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
int inv_qscale
Definition: asv.h:52
common internal api header.
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:685
void * priv_data
Definition: avcodec.h:558
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
static int asv1_get_level(GetBitContext *gb)
Definition: asvdec.c:68
#define av_freep(p)
#define VLC_TYPE
Definition: vlc.h:24
static int asv1_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:107
const uint8_t ff_asv_scantab[64]
Definition: asv.c:32
static av_cold int decode_end(AVCodecContext *avctx)
Definition: asvdec.c:319
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
const uint8_t ff_asv_level_tab[7][2]
Definition: asv.c:51
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVCodec ff_asv2_decoder
int mb_height
Definition: asv.h:54
AVCodec ff_asv1_decoder
int i
Definition: input.c:407
BlockDSPContext bdsp
Definition: asv.h:44