FFmpeg
pafvideo.c
Go to the documentation of this file.
1 /*
2  * Packed Animation File video decoder
3  * Copyright (c) 2012 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/imgutils.h"
23 
24 #include "avcodec.h"
25 #include "bytestream.h"
26 #include "copy_block.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29 
30 
31 static const uint8_t block_sequences[16][8] = {
32  { 0, 0, 0, 0, 0, 0, 0, 0 },
33  { 2, 0, 0, 0, 0, 0, 0, 0 },
34  { 5, 7, 0, 0, 0, 0, 0, 0 },
35  { 5, 0, 0, 0, 0, 0, 0, 0 },
36  { 6, 0, 0, 0, 0, 0, 0, 0 },
37  { 5, 7, 5, 7, 0, 0, 0, 0 },
38  { 5, 7, 5, 0, 0, 0, 0, 0 },
39  { 5, 7, 6, 0, 0, 0, 0, 0 },
40  { 5, 5, 0, 0, 0, 0, 0, 0 },
41  { 3, 0, 0, 0, 0, 0, 0, 0 },
42  { 6, 6, 0, 0, 0, 0, 0, 0 },
43  { 2, 4, 0, 0, 0, 0, 0, 0 },
44  { 2, 4, 5, 7, 0, 0, 0, 0 },
45  { 2, 4, 5, 0, 0, 0, 0, 0 },
46  { 2, 4, 6, 0, 0, 0, 0, 0 },
47  { 2, 4, 5, 7, 5, 7, 0, 0 },
48 };
49 
50 typedef struct PAFVideoDecContext {
53 
54  int width;
55  int height;
56 
58  uint8_t *frame[4];
59  int dirty[4];
62 
63  uint8_t *opcodes;
65 
67 {
68  PAFVideoDecContext *c = avctx->priv_data;
69  int i;
70 
71  av_frame_free(&c->pic);
72 
73  for (i = 0; i < 4; i++)
74  av_freep(&c->frame[i]);
75 
76  return 0;
77 }
78 
80 {
81  PAFVideoDecContext *c = avctx->priv_data;
82  int i;
83  int ret;
84 
85  c->width = avctx->width;
86  c->height = avctx->height;
87 
88  if (avctx->height & 3 || avctx->width & 3) {
89  av_log(avctx, AV_LOG_ERROR,
90  "width %d and height %d must be multiplie of 4.\n",
91  avctx->width, avctx->height);
92  return AVERROR_INVALIDDATA;
93  }
94 
95  avctx->pix_fmt = AV_PIX_FMT_PAL8;
96  ret = av_image_check_size2(avctx->width, FFALIGN(avctx->height, 256), avctx->max_pixels, avctx->pix_fmt, 0, avctx);
97  if (ret < 0)
98  return ret;
99 
100  c->pic = av_frame_alloc();
101  if (!c->pic)
102  return AVERROR(ENOMEM);
103 
104  c->frame_size = avctx->width * FFALIGN(avctx->height, 256);
105  c->video_size = avctx->width * avctx->height;
106  for (i = 0; i < 4; i++) {
107  c->frame[i] = av_mallocz(c->frame_size);
108  if (!c->frame[i])
109  return AVERROR(ENOMEM);
110  }
111 
112  return 0;
113 }
114 
115 static void read4x4block(PAFVideoDecContext *c, uint8_t *dst, int width)
116 {
117  int i;
118 
119  for (i = 0; i < 4; i++) {
120  bytestream2_get_buffer(&c->gb, dst, 4);
121  dst += width;
122  }
123 }
124 
125 static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color)
126 {
127  int i;
128 
129  for (i = 0; i < 4; i++) {
130  if (mask & (1 << 7 - i))
131  dst[i] = color;
132  if (mask & (1 << 3 - i))
133  dst[width + i] = color;
134  }
135 }
136 
137 static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src)
138 {
139  int i;
140 
141  for (i = 0; i < 4; i++) {
142  if (mask & (1 << 7 - i))
143  dst[i] = src[i];
144  if (mask & (1 << 3 - i))
145  dst[width + i] = src[width + i];
146  }
147 }
148 
150  const uint8_t **p,
151  const uint8_t **pend)
152 {
153  int val = bytestream2_get_be16(&c->gb);
154  int page = val >> 14;
155  int x = (val & 0x7F);
156  int y = ((val >> 7) & 0x7F);
157 
158  *p = c->frame[page] + x * 2 + y * 2 * c->width;
159  *pend = c->frame[page] + c->frame_size;
160 }
161 
162 static int decode_0(PAFVideoDecContext *c, const uint8_t *pkt, uint8_t code)
163 {
164  uint32_t opcode_size, offset;
165  uint8_t *dst, *dend, mask = 0, color = 0;
166  const uint8_t *src, *send, *opcodes;
167  int i, j, op = 0;
168 
169  i = bytestream2_get_byte(&c->gb);
170  if (i) {
171  if (code & 0x10) {
172  int align;
173 
174  align = bytestream2_tell(&c->gb) & 3;
175  if (align)
176  bytestream2_skip(&c->gb, 4 - align);
177  }
178  do {
179  int page, val, x, y;
180  val = bytestream2_get_be16(&c->gb);
181  page = val >> 14;
182  x = (val & 0x7F) * 2;
183  y = ((val >> 7) & 0x7F) * 2;
184  dst = c->frame[page] + x + y * c->width;
185  dend = c->frame[page] + c->frame_size;
186  offset = (x & 0x7F) * 2;
187  j = bytestream2_get_le16(&c->gb) + offset;
188  if (bytestream2_get_bytes_left(&c->gb) < (j - offset) * 16)
189  return AVERROR_INVALIDDATA;
190  c->dirty[page] = 1;
191  do {
192  offset++;
193  if (dst + 3 * c->width + 4 > dend)
194  return AVERROR_INVALIDDATA;
195  read4x4block(c, dst, c->width);
196  if ((offset & 0x3F) == 0)
197  dst += c->width * 3;
198  dst += 4;
199  } while (offset < j);
200  } while (--i);
201  }
202 
203  dst = c->frame[c->current_frame];
204  dend = c->frame[c->current_frame] + c->frame_size;
205  do {
206  set_src_position(c, &src, &send);
207  if ((src + 3 * c->width + 4 > send) ||
208  (dst + 3 * c->width + 4 > dend) ||
209  bytestream2_get_bytes_left(&c->gb) < 4)
210  return AVERROR_INVALIDDATA;
211  copy_block4(dst, src, c->width, c->width, 4);
212  i++;
213  if ((i & 0x3F) == 0)
214  dst += c->width * 3;
215  dst += 4;
216  } while (i < c->video_size / 16);
217 
218  opcode_size = bytestream2_get_le16(&c->gb);
219  bytestream2_skip(&c->gb, 2);
220 
221  if (bytestream2_get_bytes_left(&c->gb) < opcode_size)
222  return AVERROR_INVALIDDATA;
223 
224  opcodes = pkt + bytestream2_tell(&c->gb);
225  bytestream2_skipu(&c->gb, opcode_size);
226 
227  dst = c->frame[c->current_frame];
228 
229  for (i = 0; i < c->height; i += 4, dst += c->width * 3)
230  for (j = 0; j < c->width; j += 4, dst += 4) {
231  int opcode, k = 0;
232  if (op > opcode_size)
233  return AVERROR_INVALIDDATA;
234  if (j & 4) {
235  opcode = opcodes[op] & 15;
236  op++;
237  } else {
238  opcode = opcodes[op] >> 4;
239  }
240 
241  while (block_sequences[opcode][k]) {
242  offset = c->width * 2;
243  code = block_sequences[opcode][k++];
244 
245  switch (code) {
246  case 2:
247  offset = 0;
248  case 3:
249  color = bytestream2_get_byte(&c->gb);
250  case 4:
251  mask = bytestream2_get_byte(&c->gb);
252  copy_color_mask(dst + offset, c->width, mask, color);
253  break;
254  case 5:
255  offset = 0;
256  case 6:
257  set_src_position(c, &src, &send);
258  case 7:
259  if (src + offset + c->width + 4 > send)
260  return AVERROR_INVALIDDATA;
261  mask = bytestream2_get_byte(&c->gb);
262  copy_src_mask(dst + offset, c->width, mask, src + offset);
263  break;
264  }
265  }
266  }
267 
268  return 0;
269 }
270 
271 static int paf_video_decode(AVCodecContext *avctx, AVFrame *rframe,
272  int *got_frame, AVPacket *pkt)
273 {
274  PAFVideoDecContext *c = avctx->priv_data;
275  uint8_t code, *dst, *end;
276  int i, frame, ret;
277 
278  if (pkt->size < 2)
279  return AVERROR_INVALIDDATA;
280 
281  bytestream2_init(&c->gb, pkt->data, pkt->size);
282 
283  code = bytestream2_get_byte(&c->gb);
284  if ((code & 0xF) > 4 || (code & 0xF) == 3) {
285  avpriv_request_sample(avctx, "unknown/invalid code");
286  return AVERROR_INVALIDDATA;
287  }
288 
289  if ((code & 0xF) == 0 &&
290  c->video_size / 32 - (int64_t)bytestream2_get_bytes_left(&c->gb) > c->video_size / 32 * (int64_t)avctx->discard_damaged_percentage / 100)
291  return AVERROR_INVALIDDATA;
292 
293  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
294  return ret;
295 
296  if (code & 0x20) { // frame is keyframe
297  memset(c->pic->data[1], 0, AVPALETTE_SIZE);
298  c->current_frame = 0;
299  c->pic->key_frame = 1;
300  c->pic->pict_type = AV_PICTURE_TYPE_I;
301  } else {
302  c->pic->key_frame = 0;
303  c->pic->pict_type = AV_PICTURE_TYPE_P;
304  }
305 
306  if (code & 0x40) { // palette update
307  uint32_t *out = (uint32_t *)c->pic->data[1];
308  int index, count;
309 
310  index = bytestream2_get_byte(&c->gb);
311  count = bytestream2_get_byte(&c->gb) + 1;
312 
313  if (index + count > 256)
314  return AVERROR_INVALIDDATA;
315  if (bytestream2_get_bytes_left(&c->gb) < 3 * count)
316  return AVERROR_INVALIDDATA;
317 
318  out += index;
319  for (i = 0; i < count; i++) {
320  unsigned r, g, b;
321 
322  r = bytestream2_get_byteu(&c->gb);
323  r = r << 2 | r >> 4;
324  g = bytestream2_get_byteu(&c->gb);
325  g = g << 2 | g >> 4;
326  b = bytestream2_get_byteu(&c->gb);
327  b = b << 2 | b >> 4;
328  *out++ = (0xFFU << 24) | (r << 16) | (g << 8) | b;
329  }
330  c->pic->palette_has_changed = 1;
331  }
332 
333  c->dirty[c->current_frame] = 1;
334  if (code & 0x20)
335  for (i = 0; i < 4; i++) {
336  if (c->dirty[i])
337  memset(c->frame[i], 0, c->frame_size);
338  c->dirty[i] = 0;
339  }
340 
341  switch (code & 0x0F) {
342  case 0:
343  /* Block-based motion compensation using 4x4 blocks with either
344  * horizontal or vertical vectors; might incorporate VQ as well. */
345  if ((ret = decode_0(c, pkt->data, code)) < 0)
346  return ret;
347  break;
348  case 1:
349  /* Uncompressed data. This mode specifies that (width * height) bytes
350  * should be copied directly from the encoded buffer into the output. */
351  dst = c->frame[c->current_frame];
352  // possibly chunk length data
353  bytestream2_skip(&c->gb, 2);
354  if (bytestream2_get_bytes_left(&c->gb) < c->video_size)
355  return AVERROR_INVALIDDATA;
356  bytestream2_get_bufferu(&c->gb, dst, c->video_size);
357  break;
358  case 2:
359  /* Copy reference frame: Consume the next byte in the stream as the
360  * reference frame (which should be 0, 1, 2, or 3, and should not be
361  * the same as the current frame number). */
362  frame = bytestream2_get_byte(&c->gb);
363  if (frame > 3)
364  return AVERROR_INVALIDDATA;
365  if (frame != c->current_frame)
366  memcpy(c->frame[c->current_frame], c->frame[frame], c->frame_size);
367  break;
368  case 4:
369  /* Run length encoding.*/
370  dst = c->frame[c->current_frame];
371  end = dst + c->video_size;
372 
373  bytestream2_skip(&c->gb, 2);
374 
375  while (dst < end) {
376  int8_t code;
377  int count;
378 
379  if (bytestream2_get_bytes_left(&c->gb) < 2)
380  return AVERROR_INVALIDDATA;
381 
382  code = bytestream2_get_byteu(&c->gb);
383  count = FFABS(code) + 1;
384 
385  if (dst + count > end)
386  return AVERROR_INVALIDDATA;
387  if (code < 0)
388  memset(dst, bytestream2_get_byteu(&c->gb), count);
389  else
390  bytestream2_get_buffer(&c->gb, dst, count);
391  dst += count;
392  }
393  break;
394  default:
395  av_assert0(0);
396  }
397 
398  av_image_copy_plane(c->pic->data[0], c->pic->linesize[0],
399  c->frame[c->current_frame], c->width,
400  c->width, c->height);
401 
402  c->current_frame = (c->current_frame + 1) & 3;
403  if ((ret = av_frame_ref(rframe, c->pic)) < 0)
404  return ret;
405 
406  *got_frame = 1;
407 
408  return pkt->size;
409 }
410 
412  .p.name = "paf_video",
413  CODEC_LONG_NAME("Amazing Studio Packed Animation File Video"),
414  .p.type = AVMEDIA_TYPE_VIDEO,
415  .p.id = AV_CODEC_ID_PAF_VIDEO,
416  .priv_data_size = sizeof(PAFVideoDecContext),
417  .init = paf_video_init,
418  .close = paf_video_close,
420  .p.capabilities = AV_CODEC_CAP_DR1,
421  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
422 };
paf_video_decode
static int paf_video_decode(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *pkt)
Definition: pafvideo.c:271
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
PAFVideoDecContext::opcodes
uint8_t * opcodes
Definition: pafvideo.c:63
r
const char * r
Definition: vf_curves.c:126
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
out
FILE * out
Definition: movenc.c:54
color
Definition: vf_paletteuse.c:601
GetByteContext
Definition: bytestream.h:33
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
PAFVideoDecContext::gb
GetByteContext gb
Definition: pafvideo.c:52
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
PAFVideoDecContext::frame_size
int frame_size
Definition: pafvideo.c:60
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:41
PAFVideoDecContext::frame
uint8_t * frame[4]
Definition: pafvideo.c:58
FFCodec
Definition: codec_internal.h:119
PAFVideoDecContext::width
int width
Definition: pafvideo.c:54
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
val
static double val(void *priv, double ch)
Definition: aeval.c:77
copy_src_mask
static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src)
Definition: pafvideo.c:137
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
PAFVideoDecContext::current_frame
int current_frame
Definition: pafvideo.c:57
PAFVideoDecContext
Definition: pafvideo.c:50
pkt
AVPacket * pkt
Definition: movenc.c:59
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
mask
static const uint16_t mask[17]
Definition: lzw.c:38
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
g
const char * g
Definition: vf_curves.c:127
op
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:76
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
decode.h
paf_video_init
static av_cold int paf_video_init(AVCodecContext *avctx)
Definition: pafvideo.c:79
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1911
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
copy_color_mask
static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color)
Definition: pafvideo.c:125
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
block_sequences
static const uint8_t block_sequences[16][8]
Definition: pafvideo.c:31
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
read4x4block
static void read4x4block(PAFVideoDecContext *c, uint8_t *dst, int width)
Definition: pafvideo.c:115
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
PAFVideoDecContext::video_size
int video_size
Definition: pafvideo.c:61
PAFVideoDecContext::pic
AVFrame * pic
Definition: pafvideo.c:51
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
AVPacket::size
int size
Definition: packet.h:375
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:353
codec_internal.h
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
PAFVideoDecContext::dirty
int dirty[4]
Definition: pafvideo.c:59
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
copy_block4
static void copy_block4(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:37
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
copy_block.h
AV_CODEC_ID_PAF_VIDEO
@ AV_CODEC_ID_PAF_VIDEO
Definition: codec_id.h:231
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1568
ret
ret
Definition: filter_design.txt:187
set_src_position
static void set_src_position(PAFVideoDecContext *c, const uint8_t **p, const uint8_t **pend)
Definition: pafvideo.c:149
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
ff_paf_video_decoder
const FFCodec ff_paf_video_decoder
Definition: pafvideo.c:411
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1991
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
PAFVideoDecContext::height
int height
Definition: pafvideo.c:55
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:571
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
paf_video_close
static av_cold int paf_video_close(AVCodecContext *avctx)
Definition: pafvideo.c:66
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
decode_0
static int decode_0(PAFVideoDecContext *c, const uint8_t *pkt, uint8_t code)
Definition: pafvideo.c:162