FFmpeg
leaddec.c
Go to the documentation of this file.
1 /*
2  * LEAD MCMP decoder
3  *
4  * Copyright (c) 2023 Peter Ross
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "avcodec.h"
24 #include "blockdsp.h"
25 #include "codec_internal.h"
26 #include "copy_block.h"
27 #include "decode.h"
28 #include "get_bits.h"
29 #include "idctdsp.h"
30 #include "jpegquanttables.h"
31 #include "jpegtables.h"
32 #include "leaddata.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/mem_internal.h"
35 #include "libavutil/thread.h"
36 
37 #define LUMA_DC_BITS 9
38 #define CHROMA_DC_BITS 11
39 #define LUMA_AC_BITS 10
40 #define CHROMA_AC_BITS 10
41 
42 static VLCElem luma_dc_vlc[1 << LUMA_DC_BITS];
43 static VLCElem chroma_dc_vlc[1 << CHROMA_DC_BITS];
44 static VLCElem luma_ac_vlc[1160];
45 static VLCElem chroma_ac_vlc[1160];
46 
47 static av_cold void lead_init_static_data(void)
48 {
49  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(luma_dc_vlc, LUMA_DC_BITS, FF_ARRAY_ELEMS(luma_dc_len),
50  luma_dc_len, 1,
51  NULL, 0, 0,
52  0, 0);
53  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(chroma_dc_vlc, CHROMA_DC_BITS, FF_ARRAY_ELEMS(chroma_dc_len),
54  chroma_dc_len, 1,
55  NULL, 0, 0,
56  0, 0);
57  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(luma_ac_vlc, LUMA_AC_BITS, FF_ARRAY_ELEMS(luma_ac_len),
58  luma_ac_len, 1,
59  ff_mjpeg_val_ac_luminance, 1, 1,
60  0, 0);
61  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(chroma_ac_vlc, CHROMA_AC_BITS, FF_ARRAY_ELEMS(chroma_ac_len),
62  chroma_ac_len, 1,
63  ff_mjpeg_val_ac_chrominance, 1, 1,
64  0, 0);
65 }
66 
67 typedef struct LeadContext {
68  uint8_t *bitstream_buf;
69  unsigned int bitstream_buf_size;
70  BlockDSPContext bdsp;
71  IDCTDSPContext idsp;
72  uint8_t permutated_scantable[64];
73 } LeadContext;
74 
75 static av_cold int lead_decode_init(AVCodecContext * avctx)
76 {
77  static AVOnce init_static_once = AV_ONCE_INIT;
78  LeadContext *s = avctx->priv_data;
79 
80  if (avctx->extradata_size < 20)
81  return AVERROR_INVALIDDATA;
82 
83  ff_blockdsp_init(&s->bdsp);
84  ff_idctdsp_init(&s->idsp, avctx);
85  ff_permute_scantable(s->permutated_scantable, ff_zigzag_direct, s->idsp.idct_permutation);
86 
87  ff_thread_once(&init_static_once, lead_init_static_data);
88 
89  return 0;
90 }
91 
92 static void calc_dequant(uint16_t * dequant, const uint8_t * quant_tbl, int q)
93 {
94  for (int i = 0; i < 64; i++)
95  dequant[i] = av_clip(q * quant_tbl[ff_zigzag_direct[i]] / 50, 2, 32767);
96 }
97 
98 static int decode_block(LeadContext * s, GetBitContext * gb,
99  const VLCElem * dc_table, int dc_bits, const VLCElem * ac_table, int ac_bits,
100  int16_t * dc_pred, const uint16_t * dequant,
101  uint8_t * dst, int stride)
102 {
103  DECLARE_ALIGNED(32, int16_t, block)[64];
104  int size;
105 
106  s->bdsp.clear_block(block);
107 
108  if (get_bits_left(gb) <= 0)
109  return AVERROR_INVALIDDATA;
110 
111  size = get_vlc2(gb, dc_table, dc_bits, 1);
112  if (size < 0)
113  return AVERROR_INVALIDDATA;
114 
115  if (size)
116  *dc_pred += get_xbits(gb, size);
117 
118  block[0] = (1 << 10) + *dc_pred * dequant[0];
119 
120  for (int i = 1; i < 64; i++) {
121  int symbol = get_vlc2(gb, ac_table, ac_bits, 2);
122  if (symbol < 0)
123  return AVERROR_INVALIDDATA;
124 
125  if (!symbol)
126  break;
127 
128  i += symbol >> 4;
129  if (i >= 64)
130  return AVERROR_INVALIDDATA;
131 
132  size = symbol & 0xF;
133  if (size)
134  block[s->permutated_scantable[i]] = get_xbits(gb, size) * dequant[i];
135  }
136 
137  s->idsp.idct_put(dst, stride, block);
138  return 0;
139 }
140 
141 static int lead_decode_frame(AVCodecContext *avctx, AVFrame * frame,
142  int * got_frame, AVPacket * avpkt)
143 {
144  LeadContext *s = avctx->priv_data;
145  const uint8_t * buf = avpkt->data;
146  int ret, format, zero = 0, yuv20p_half = 0, fields = 1, q, size;
147  GetBitContext gb;
148  int16_t dc_pred[3] = {0, 0, 0};
149  uint16_t dequant[2][64];
150 
151  if (avpkt->size < 8)
152  return AVERROR_INVALIDDATA;
153 
154  format = AV_RL16(buf + 4);
155  switch(format) {
156  case 0x0:
157  zero = 1;
158  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
159  break;
160  case 0x6:
161  case 0x8000:
162  yuv20p_half = 1;
163  // fall-through
164  case 0x1000:
165  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
166  break;
167  case 0x1006:
168  fields = 2;
169  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
170  break;
171  case 0x2000:
172  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
173  break;
174  case 0x2006:
175  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
176  fields = 2;
177  break;
178  default:
179  avpriv_request_sample(avctx, "unsupported format 0x%x", format);
180  return AVERROR_PATCHWELCOME;
181  }
182 
183  q = AV_RL16(buf + 6);
184  calc_dequant(dequant[0], ff_mjpeg_std_luminance_quant_tbl, q);
185  calc_dequant(dequant[1], ff_mjpeg_std_chrominance_quant_tbl, q);
186 
187  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
188  return ret;
189 
190  av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size, avpkt->size - 8);
191  if (!s->bitstream_buf)
192  return AVERROR(ENOMEM);
193 
194  size = 0;
195  for (int i = 8; i < avpkt->size; i++) {
196  int src = buf[i] ^ 0x80;
197  s->bitstream_buf[size++] = src;
198  if (src == 0xFF && i + 1 < avpkt->size && (buf[i + 1] ^ 0x80) == 0x00)
199  i++;
200  }
201 
202  ret = init_get_bits8(&gb, s->bitstream_buf, size);
203  if (ret < 0)
204  return ret;
205 
206  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P && zero) {
207  for (int mb_y = 0; mb_y < avctx->height / 8; mb_y++)
208  for (int mb_x = 0; mb_x < avctx->width / 16; mb_x++)
209  for (int b = 0; b < 4; b++) {
210  int luma_block = 2;
211  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
212  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
213  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
214  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
215  int plane = b < luma_block ? 0 : b - 1;
216  int x, y, yclip;
217 
218  if (b < luma_block) {
219  y = 8*mb_y + 8*(b >> 1);
220  x = 16*mb_x + 8*(b & 1);
221  yclip = 0;
222  } else {
223  y = 4*mb_y;
224  x = 8*mb_x;
225  yclip = y + 8 >= avctx->height / 2;
226  }
227 
228  if (yclip) {
229  uint8_t tmp[64];
230  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
231  dc_pred + plane, dequant[!(b < 4)], tmp, 8);
232  for (int yy = 0; yy < 8 && y + yy < avctx->height / 2; yy++)
233  memcpy(frame->data[plane] + (y+yy)*frame->linesize[plane] + x, tmp + yy, 8);
234  } else {
235  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
236  dc_pred + plane, dequant[!(b < 4)],
237  frame->data[plane] + y*frame->linesize[plane] + x,
238  frame->linesize[plane]);
239  }
240  if (ret < 0)
241  return ret;
242  }
243  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
244  for (int f = 0; f < fields; f++)
245  for (int mb_y = 0; mb_y < (avctx->height + 15) / 16 / fields; mb_y++)
246  for (int mb_x = 0; mb_x < (avctx->width + 15) / 16; mb_x++)
247  for (int b = 0; b < (yuv20p_half ? 4 : 6); b++) {
248  int luma_block = yuv20p_half ? 2 : 4;
249  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
250  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
251  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
252  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
253  int plane = b < luma_block ? 0 : b - (yuv20p_half ? 1 : 3);
254  int x, y;
255 
256  if (b < luma_block) {
257  y = 16*mb_y + 8*(b >> 1);
258  x = 16*mb_x + 8*(b & 1);
259  } else {
260  y = 8*mb_y;
261  x = 8*mb_x;
262  }
263 
264  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
265  dc_pred + plane, dequant[!(b < 4)],
266  frame->data[plane] + (f + y*fields)*frame->linesize[plane] + x,
267  (yuv20p_half && b < 2 ? 2 : 1) * fields * frame->linesize[plane]);
268  if (ret < 0)
269  return ret;
270 
271  if (yuv20p_half && b < 2)
272  copy_block8(frame->data[plane] + (y + 1)*frame->linesize[plane] + x,
273  frame->data[plane] + y*frame->linesize[plane] + x,
274  2*frame->linesize[plane], 2*frame->linesize[plane], 8);
275  }
276  } else {
277  for (int f = 0; f < fields; f++)
278  for (int j = 0; j < (avctx->height + 7) / fields / 8; j++)
279  for (int i = 0; i < (avctx->width + 7) / 8; i++)
280  for (int plane = 0; plane < 3; plane++) {
281  const VLCElem * dc_vlc = !plane ? luma_dc_vlc : chroma_dc_vlc;
282  int dc_bits = !plane ? LUMA_DC_BITS : CHROMA_DC_BITS;
283  const VLCElem * ac_vlc = !plane ? luma_ac_vlc : chroma_ac_vlc;
284  int ac_bits = !plane ? LUMA_AC_BITS : CHROMA_AC_BITS;
285 
286  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
287  dc_pred + plane, dequant[!!plane],
288  frame->data[plane] + (f + 8*j*fields)*frame->linesize[plane] + 8*i,
289  fields * frame->linesize[plane]);
290  if (ret < 0)
291  return ret;
292  }
293  }
294 
295  *got_frame = 1;
296 
297  return avpkt->size;
298 }
299 
300 static av_cold int lead_decode_end(AVCodecContext * avctx)
301 {
302  LeadContext *s = avctx->priv_data;
303 
304  av_freep(&s->bitstream_buf);
305 
306  return 0;
307 }
308 
309 const FFCodec ff_lead_decoder = {
310  .p.name = "lead",
311  CODEC_LONG_NAME("LEAD MCMP"),
312  .p.type = AVMEDIA_TYPE_VIDEO,
313  .p.id = AV_CODEC_ID_LEAD,
314  .priv_data_size = sizeof(LeadContext),
315  .init = lead_decode_init,
316  .close = lead_decode_end,
317  FF_CODEC_DECODE_CB(lead_decode_frame),
318  .p.capabilities = AV_CODEC_CAP_DR1,
319  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
320 };
LeadContext::bdsp
BlockDSPContext bdsp
Definition: leaddec.c:70
jpegtables.h
av_clip
#define av_clip
Definition: common.h:100
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
mem_internal.h
chroma_dc_vlc
static VLCElem chroma_dc_vlc[1<< CHROMA_DC_BITS]
Definition: leaddec.c:43
thread.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
CHROMA_AC_BITS
#define CHROMA_AC_BITS
Definition: leaddec.c:40
AVPacket::data
uint8_t * data
Definition: packet.h:539
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:127
copy_block8
static void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:47
LeadContext::idsp
IDCTDSPContext idsp
Definition: leaddec.c:71
BlockDSPContext
Definition: blockdsp.h:32
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
GetBitContext
Definition: get_bits.h:108
dequant
static int dequant(AVSContext *h, int16_t *level_buf, uint8_t *run_buf, int16_t *dst, int mul, int shift, int coeff_num)
Definition: cavsdec.c:521
lead_decode_end
static av_cold int lead_decode_end(AVCodecContext *avctx)
Definition: leaddec.c:300
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
chroma_dc_len
static const uint8_t chroma_dc_len[]
Definition: leaddata.h:30
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
s
#define s(width, name)
Definition: cbs_vp9.c:198
luma_ac_len
static const uint8_t luma_ac_len[]
Definition: leaddata.h:34
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
LeadContext::bitstream_buf_size
unsigned int bitstream_buf_size
Definition: leaddec.c:69
decode.h
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
LeadContext::bitstream_buf
uint8_t * bitstream_buf
Definition: leaddec.c:68
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:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
dc_vlc
static VLCElem dc_vlc[1104]
Definition: clearvideo.c:79
AV_CODEC_ID_LEAD
@ AV_CODEC_ID_LEAD
Definition: codec_id.h:328
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
leaddata.h
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:652
jpegquanttables.h
lead_decode_init
static av_cold int lead_decode_init(AVCodecContext *avctx)
Definition: leaddec.c:75
AVOnce
#define AVOnce
Definition: thread.h:202
CHROMA_DC_BITS
#define CHROMA_DC_BITS
Definition: leaddec.c:38
LUMA_DC_BITS
#define LUMA_DC_BITS
Definition: leaddec.c:37
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
AVPacket::size
int size
Definition: packet.h:540
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
luma_dc_len
static const uint8_t luma_dc_len[]
Definition: leaddata.h:26
LeadContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: leaddec.c:72
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:32
decode_block
static int decode_block(LeadContext *s, GetBitContext *gb, const VLCElem *dc_table, int dc_bits, const VLCElem *ac_table, int ac_bits, int16_t *dc_pred, const uint16_t *dequant, uint8_t *dst, int stride)
Definition: leaddec.c:98
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:292
zero
static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:121
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_lead_decoder
const FFCodec ff_lead_decoder
Definition: leaddec.c:309
copy_block.h
luma_ac_vlc
static VLCElem luma_ac_vlc[1160]
Definition: leaddec.c:44
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:52
ff_mjpeg_std_chrominance_quant_tbl
const uint8_t ff_mjpeg_std_chrominance_quant_tbl[64]
Definition: jpegquanttables.c:45
lead_decode_frame
static int lead_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: leaddec.c:141
lead_init_static_data
static av_cold void lead_init_static_data(void)
Definition: leaddec.c:47
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:632
luma_dc_vlc
static VLCElem luma_dc_vlc[1<< LUMA_DC_BITS]
Definition: leaddec.c:42
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:671
calc_dequant
static void calc_dequant(uint16_t *dequant, const uint8_t *quant_tbl, int q)
Definition: leaddec.c:92
idctdsp.h
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
close
static void close(AVCodecParserContext *s)
Definition: ffv1_parser.c:73
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
IDCTDSPContext
Definition: idctdsp.h:43
ff_mjpeg_std_luminance_quant_tbl
const uint8_t ff_mjpeg_std_luminance_quant_tbl[64]
Definition: jpegquanttables.c:35
AVCodecContext
main external API structure.
Definition: avcodec.h:451
chroma_ac_vlc
static VLCElem chroma_ac_vlc[1160]
Definition: leaddec.c:45
ac_vlc
static VLCElem ac_vlc[554]
Definition: clearvideo.c:79
chroma_ac_len
static const uint8_t chroma_ac_len[]
Definition: leaddata.h:48
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
VLC_INIT_STATIC_TABLE_FROM_LENGTHS
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
Definition: vlc.h:280
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:632
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
LUMA_AC_BITS
#define LUMA_AC_BITS
Definition: leaddec.c:39
LeadContext
Definition: leaddec.c:67
src
#define src
Definition: vp8dsp.c:248
Generated on Tue Feb 11 2025 19:21:52 for FFmpeg by   doxygen 1.8.17