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 0x8000:
161  yuv20p_half = 1;
162  // fall-through
163  case 0x1000:
164  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
165  break;
166  case 0x2000:
167  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
168  break;
169  case 0x2006:
170  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
171  fields = 2;
172  break;
173  default:
174  avpriv_request_sample(avctx, "unsupported format 0x%x", format);
175  return AVERROR_PATCHWELCOME;
176  }
177 
178  q = AV_RL16(buf + 6);
179  calc_dequant(dequant[0], ff_mjpeg_std_luminance_quant_tbl, q);
180  calc_dequant(dequant[1], ff_mjpeg_std_chrominance_quant_tbl, q);
181 
182  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
183  return ret;
184 
185  frame->flags |= AV_FRAME_FLAG_KEY;
186  frame->pict_type = AV_PICTURE_TYPE_I;
187 
188  av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size, avpkt->size - 8);
189  if (!s->bitstream_buf)
190  return AVERROR(ENOMEM);
191 
192  size = 0;
193  for (int i = 8; i < avpkt->size; i++) {
194  int src = buf[i] ^ 0x80;
195  s->bitstream_buf[size++] = src;
196  if (src == 0xFF && i + 1 < avpkt->size && (buf[i + 1] ^ 0x80) == 0x00)
197  i++;
198  }
199 
200  init_get_bits8(&gb, s->bitstream_buf, size);
201 
202  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P && zero) {
203  for (int mb_y = 0; mb_y < avctx->height / 8; mb_y++)
204  for (int mb_x = 0; mb_x < avctx->width / 16; mb_x++)
205  for (int b = 0; b < 4; b++) {
206  int luma_block = 2;
207  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
208  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
209  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
210  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
211  int plane = b < luma_block ? 0 : b - 1;
212  int x, y, yclip;
213 
214  if (b < luma_block) {
215  y = 8*mb_y + 8*(b >> 1);
216  x = 16*mb_x + 8*(b & 1);
217  yclip = 0;
218  } else {
219  y = 4*mb_y;
220  x = 8*mb_x;
221  yclip = y + 8 >= avctx->height / 2;
222  }
223 
224  if (yclip) {
225  uint8_t tmp[64];
226  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
227  dc_pred + plane, dequant[!(b < 4)], tmp, 8);
228  for (int yy = 0; yy < 8 && y + yy < avctx->height / 2; yy++)
229  memcpy(frame->data[plane] + (y+yy)*frame->linesize[plane] + x, tmp + yy, 8);
230  } else {
231  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
232  dc_pred + plane, dequant[!(b < 4)],
233  frame->data[plane] + y*frame->linesize[plane] + x,
234  frame->linesize[plane]);
235  }
236  if (ret < 0)
237  return ret;
238  }
239  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
240  for (int mb_y = 0; mb_y < (avctx->height + 15) / 16; mb_y++)
241  for (int mb_x = 0; mb_x < (avctx->width + 15) / 16; mb_x++)
242  for (int b = 0; b < (yuv20p_half ? 4 : 6); b++) {
243  int luma_block = yuv20p_half ? 2 : 4;
244  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
245  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
246  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
247  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
248  int plane = b < luma_block ? 0 : b - (yuv20p_half ? 1 : 3);
249  int x, y;
250 
251  if (b < luma_block) {
252  y = 16*mb_y + 8*(b >> 1);
253  x = 16*mb_x + 8*(b & 1);
254  } else {
255  y = 8*mb_y;
256  x = 8*mb_x;
257  }
258 
259  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
260  dc_pred + plane, dequant[!(b < 4)],
261  frame->data[plane] + y*frame->linesize[plane] + x,
262  (yuv20p_half && b < 2 ? 2 : 1) * frame->linesize[plane]);
263  if (ret < 0)
264  return ret;
265 
266  if (yuv20p_half && b < 2)
267  copy_block8(frame->data[plane] + (y + 1)*frame->linesize[plane] + x,
268  frame->data[plane] + y*frame->linesize[plane] + x,
269  2*frame->linesize[plane], 2*frame->linesize[plane], 8);
270  }
271  } else {
272  for (int f = 0; f < fields; f++)
273  for (int j = 0; j < (avctx->height + 7) / fields / 8; j++)
274  for (int i = 0; i < (avctx->width + 7) / 8; i++)
275  for (int plane = 0; plane < 3; plane++) {
276  const VLCElem * dc_vlc = !plane ? luma_dc_vlc : chroma_dc_vlc;
277  int dc_bits = !plane ? LUMA_DC_BITS : CHROMA_DC_BITS;
278  const VLCElem * ac_vlc = !plane ? luma_ac_vlc : chroma_ac_vlc;
279  int ac_bits = !plane ? LUMA_AC_BITS : CHROMA_AC_BITS;
280 
281  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
282  dc_pred + plane, dequant[!!plane],
283  frame->data[plane] + (f + 8*j*fields)*frame->linesize[plane] + 8*i,
284  fields * frame->linesize[plane]);
285  if (ret < 0)
286  return ret;
287  }
288  }
289 
290  *got_frame = 1;
291 
292  return avpkt->size;
293 }
294 
295 static av_cold int lead_decode_end(AVCodecContext * avctx)
296 {
297  LeadContext *s = avctx->priv_data;
298 
299  av_freep(&s->bitstream_buf);
300 
301  return 0;
302 }
303 
304 const FFCodec ff_lead_decoder = {
305  .p.name = "lead",
306  CODEC_LONG_NAME("LEAD MCMP"),
307  .p.type = AVMEDIA_TYPE_VIDEO,
308  .p.id = AV_CODEC_ID_LEAD,
309  .priv_data_size = sizeof(LeadContext),
310  .init = lead_decode_init,
311  .close = lead_decode_end,
312  FF_CODEC_DECODE_CB(lead_decode_frame),
313  .p.capabilities = AV_CODEC_CAP_DR1,
314  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
315 };
LeadContext::bdsp
BlockDSPContext bdsp
Definition: leaddec.c:70
jpegtables.h
av_clip
#define av_clip
Definition: common.h:99
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:42
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:374
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:524
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:126
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:130
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:295
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
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
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:271
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:324
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
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
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:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1556
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
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
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:304
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:618
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:657
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:537
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
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
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:445
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
zero
#define zero
Definition: regdef.h:64
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:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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
Generated on Sat Apr 27 2024 19:21:46 for FFmpeg by   doxygen 1.8.17