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 "codec_internal.h"
34 #include "config_components.h"
35 #include "idctdsp.h"
36 #include "internal.h"
37 #include "mpeg12data.h"
38 
39 #define CCP_VLC_BITS 5
40 #define DC_CCP_VLC_BITS 4
41 #define AC_CCP_VLC_BITS 6
42 #define ASV1_LEVEL_VLC_BITS 4
43 #define ASV2_LEVEL_VLC_BITS 10
44 
45 static VLC ccp_vlc;
46 static VLC level_vlc;
47 static VLC dc_ccp_vlc;
48 static VLC ac_ccp_vlc;
49 static VLC asv2_level_vlc;
50 
51 static av_cold void init_vlcs(void)
52 {
53  INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17,
54  &ff_asv_ccp_tab[0][1], 2, 1,
55  &ff_asv_ccp_tab[0][0], 2, 1, 32);
56  INIT_LE_VLC_STATIC(&dc_ccp_vlc, DC_CCP_VLC_BITS, 8,
57  &ff_asv_dc_ccp_tab[0][1], 2, 1,
58  &ff_asv_dc_ccp_tab[0][0], 2, 1, 16);
59  INIT_LE_VLC_STATIC(&ac_ccp_vlc, AC_CCP_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, ASV1_LEVEL_VLC_BITS, 7,
63  &ff_asv_level_tab[0][1], 2, 1,
64  &ff_asv_level_tab[0][0], 2, 1, 16);
65  INIT_LE_VLC_STATIC(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63,
66  &ff_asv2_level_tab[0][1], 4, 2,
67  &ff_asv2_level_tab[0][0], 4, 2, 1024);
68 }
69 
70 static inline int asv1_get_level(GetBitContext *gb)
71 {
72  int code = get_vlc2(gb, level_vlc.table, ASV1_LEVEL_VLC_BITS, 1);
73 
74  if (code == 3)
75  return get_sbits(gb, 8);
76  else
77  return code - 3;
78 }
79 
80 // get_vlc2() is big-endian in this file
81 static inline int asv2_get_vlc2(GetBitContext *gb, const VLCElem *table, int bits)
82 {
83  unsigned int index;
84  int code, n;
85 
86  OPEN_READER(re, gb);
87  UPDATE_CACHE_LE(re, gb);
88 
89  index = SHOW_UBITS_LE(re, gb, bits);
90  code = table[index].sym;
91  n = table[index].len;
92  LAST_SKIP_BITS(re, gb, n);
93 
94  CLOSE_READER(re, gb);
95 
96  return code;
97 }
98 
99 static inline int asv2_get_level(GetBitContext *gb)
100 {
101  int code = asv2_get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS);
102 
103  if (code == 31)
104  return (int8_t) get_bits_le(gb, 8);
105  else
106  return code - 31;
107 }
108 
109 static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
110 {
111  int i;
112 
113  block[0] = 8 * get_bits(&a->gb, 8);
114 
115  for (i = 0; i < 11; i++) {
116  const int ccp = get_vlc2(&a->gb, ccp_vlc.table, CCP_VLC_BITS, 1);
117 
118  if (ccp) {
119  if (ccp == 16)
120  break;
121  if (ccp < 0 || i >= 10) {
122  av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
123  return AVERROR_INVALIDDATA;
124  }
125 
126  if (ccp & 8)
127  block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
128  if (ccp & 4)
129  block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
130  if (ccp & 2)
131  block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
132  if (ccp & 1)
133  block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
134  }
135  }
136 
137  return 0;
138 }
139 
140 static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
141 {
142  int i, count, ccp;
143 
144  count = get_bits_le(&a->gb, 4);
145 
146  block[0] = 8 * get_bits_le(&a->gb, 8);
147 
148  ccp = asv2_get_vlc2(&a->gb, dc_ccp_vlc.table, DC_CCP_VLC_BITS);
149  if (ccp) {
150  if (ccp & 4)
151  block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;
152  if (ccp & 2)
153  block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;
154  if (ccp & 1)
155  block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;
156  }
157 
158  for (i = 1; i < count + 1; i++) {
159  const int ccp = asv2_get_vlc2(&a->gb, ac_ccp_vlc.table, AC_CCP_VLC_BITS);
160 
161  if (ccp) {
162  if (ccp & 8)
163  block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
164  if (ccp & 4)
165  block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
166  if (ccp & 2)
167  block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
168  if (ccp & 1)
169  block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
170  }
171  }
172 
173  return 0;
174 }
175 
176 static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
177 {
178  int i, ret;
179 
180  a->bdsp.clear_blocks(block[0]);
181 
182  if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
183  for (i = 0; i < 6; i++) {
184  if ((ret = asv1_decode_block(a, block[i])) < 0)
185  return ret;
186  }
187  } else {
188  for (i = 0; i < 6; i++) {
189  if ((ret = asv2_decode_block(a, block[i])) < 0)
190  return ret;
191  }
192  }
193  return 0;
194 }
195 
196 static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
197 {
198  int16_t(*block)[64] = a->block;
199  int linesize = frame->linesize[0];
200 
201  uint8_t *dest_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
202  uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
203  uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
204 
205  a->idsp.idct_put(dest_y, linesize, block[0]);
206  a->idsp.idct_put(dest_y + 8, linesize, block[1]);
207  a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);
208  a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
209 
210  if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
211  a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
212  a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
213  }
214 }
215 
216 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
217  int *got_frame, AVPacket *avpkt)
218 {
219  ASV1Context *const a = avctx->priv_data;
220  const uint8_t *buf = avpkt->data;
221  int buf_size = avpkt->size;
222  int mb_x, mb_y, ret;
223 
224  if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
225  return AVERROR_INVALIDDATA;
226 
227  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
228  return ret;
229  p->pict_type = AV_PICTURE_TYPE_I;
230  p->key_frame = 1;
231 
232  if (avctx->codec_id == AV_CODEC_ID_ASV1) {
233  av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size,
234  buf_size);
235  if (!a->bitstream_buffer)
236  return AVERROR(ENOMEM);
237 
238  a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
239  (const uint32_t *) buf, buf_size / 4);
240  ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);
241  } else {
242  ret = init_get_bits8_le(&a->gb, buf, buf_size);
243  }
244  if (ret < 0)
245  return ret;
246 
247  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
248  for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
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_width2 != a->mb_width) {
257  mb_x = a->mb_width2;
258  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
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  if (a->mb_height2 != a->mb_height) {
267  mb_y = a->mb_height2;
268  for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
269  if ((ret = decode_mb(a, a->block)) < 0)
270  return ret;
271 
272  idct_put(a, p, mb_x, mb_y);
273  }
274  }
275 
276  *got_frame = 1;
277 
278  emms_c();
279 
280  return (get_bits_count(&a->gb) + 31) / 32 * 4;
281 }
282 
283 static av_cold int decode_init(AVCodecContext *avctx)
284 {
285  static AVOnce init_static_once = AV_ONCE_INIT;
286  ASV1Context *const a = avctx->priv_data;
287  const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
288  int i;
289 
290  if (avctx->extradata_size < 1) {
291  av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");
292  }
293 
294  ff_asv_common_init(avctx);
295  ff_blockdsp_init(&a->bdsp, avctx);
296  ff_idctdsp_init(&a->idsp, avctx);
297  ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
298  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
299 
300  if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {
301  av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
302  if (avctx->codec_id == AV_CODEC_ID_ASV1)
303  a->inv_qscale = 6;
304  else
305  a->inv_qscale = 10;
306  }
307 
308  for (i = 0; i < 64; i++) {
309  int index = ff_asv_scantab[i];
310 
311  a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
312  a->inv_qscale;
313  }
314 
315  ff_thread_once(&init_static_once, init_vlcs);
316 
317  return 0;
318 }
319 
320 static av_cold int decode_end(AVCodecContext *avctx)
321 {
322  ASV1Context *const a = avctx->priv_data;
323 
324  av_freep(&a->bitstream_buffer);
325  a->bitstream_buffer_size = 0;
326 
327  return 0;
328 }
329 
330 #if CONFIG_ASV1_DECODER
331 const FFCodec ff_asv1_decoder = {
332  .p.name = "asv1",
333  .p.long_name = NULL_IF_CONFIG_SMALL("ASUS V1"),
334  .p.type = AVMEDIA_TYPE_VIDEO,
335  .p.id = AV_CODEC_ID_ASV1,
336  .priv_data_size = sizeof(ASV1Context),
337  .init = decode_init,
338  .close = decode_end,
339  FF_CODEC_DECODE_CB(decode_frame),
340  .p.capabilities = AV_CODEC_CAP_DR1,
341  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
342 };
343 #endif
344 
345 #if CONFIG_ASV2_DECODER
346 const FFCodec ff_asv2_decoder = {
347  .p.name = "asv2",
348  .p.long_name = NULL_IF_CONFIG_SMALL("ASUS V2"),
349  .p.type = AVMEDIA_TYPE_VIDEO,
350  .p.id = AV_CODEC_ID_ASV2,
351  .priv_data_size = sizeof(ASV1Context),
352  .init = decode_init,
353  FF_CODEC_DECODE_CB(decode_frame),
354  .p.capabilities = AV_CODEC_CAP_DR1,
355  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
356 };
357 #endif
AC_CCP_VLC_BITS
#define AC_CCP_VLC_BITS
Definition: asvdec.c:41
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
dc_ccp_vlc
static VLC dc_ccp_vlc
Definition: asvdec.c:47
ff_asv_dc_ccp_tab
const uint8_t ff_asv_dc_ccp_tab[8][2]
Definition: asv.c:55
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
thread.h
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:125
ASV2_LEVEL_VLC_BITS
#define ASV2_LEVEL_VLC_BITS
Definition: asvdec.c:43
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: asvdec.c:283
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
table
static const uint16_t table[]
Definition: prosumer.c:206
FFCodec
Definition: codec_internal.h:112
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:240
init
static int init
Definition: av_tx.c:47
ff_asv2_level_tab
const uint16_t ff_asv2_level_tab[63][2]
Definition: asv.c:67
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
ff_asv1_decoder
const FFCodec ff_asv1_decoder
ff_asv_scantab
const uint8_t ff_asv_scantab[64]
Definition: asv.c:32
GetBitContext
Definition: get_bits.h:61
asv2_get_level
static int asv2_get_level(GetBitContext *gb)
Definition: asvdec.c:99
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
ac_ccp_vlc
static VLC ac_ccp_vlc
Definition: asvdec.c:48
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
asv2_decode_block
static int asv2_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:140
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ASV1_LEVEL_VLC_BITS
#define ASV1_LEVEL_VLC_BITS
Definition: asvdec.c:42
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
ASV1Context
Definition: asv.h:42
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
bits
uint8_t bits
Definition: vp3data.h:141
asv.h
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
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
SHOW_UBITS_LE
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:201
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: asvdec.c:216
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:399
ff_asv_ac_ccp_tab
const uint8_t ff_asv_ac_ccp_tab[16][2]
Definition: asv.c:60
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
init_vlcs
static av_cold void init_vlcs(void)
Definition: asvdec.c:51
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
asv2_level_vlc
static VLC asv2_level_vlc
Definition: asvdec.c:49
asv2_get_vlc2
static int asv2_get_vlc2(GetBitContext *gb, const VLCElem *table, int bits)
Definition: asvdec.c:81
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
AVOnce
#define AVOnce
Definition: thread.h:176
index
int index
Definition: gxfenc.c:89
ccp_vlc
static VLC ccp_vlc
Definition: asvdec.c:45
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:249
AVPacket::size
int size
Definition: packet.h:375
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:117
codec_internal.h
VLCElem
Definition: vlc.h:27
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
ff_asv_common_init
av_cold void ff_asv_common_init(AVCodecContext *avctx)
Definition: asv.c:89
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:176
AV_CODEC_ID_ASV1
@ AV_CODEC_ID_ASV1
Definition: codec_id.h:81
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:490
AV_CODEC_ID_ASV2
@ AV_CODEC_ID_ASV2
Definition: codec_id.h:82
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:30
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:48
CCP_VLC_BITS
#define CCP_VLC_BITS
Definition: asvdec.c:39
FF_CODEC_CAP_INIT_THREADSAFE
#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: codec_internal.h:31
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
DC_CCP_VLC_BITS
#define DC_CCP_VLC_BITS
Definition: asvdec.c:40
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:196
AVCodecContext
main external API structure.
Definition: avcodec.h:389
level_vlc
static VLC level_vlc
Definition: asvdec.c:46
UPDATE_CACHE_LE
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: asvdec.c:320
asv1_decode_block
static int asv1_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:109
VLC
Definition: vlc.h:31
VLC::table
VLCElem * table
Definition: vlc.h:33
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
init_get_bits8_le
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:675
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:416
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
asv1_get_level
static int asv1_get_level(GetBitContext *gb)
Definition: asvdec.c:70
INIT_LE_VLC_STATIC
#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:128
ff_asv2_decoder
const FFCodec ff_asv2_decoder
re
float re
Definition: fft.c:79
Generated on Wed Aug 24 2022 21:41:18 for FFmpeg by   doxygen 1.8.17