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 #include "libavutil/mem.h"
24 
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "copy_block.h"
28 #include "codec_internal.h"
29 #include "decode.h"
30 
31 
32 static const uint8_t block_sequences[16][8] = {
33  { 0, 0, 0, 0, 0, 0, 0, 0 },
34  { 2, 0, 0, 0, 0, 0, 0, 0 },
35  { 5, 7, 0, 0, 0, 0, 0, 0 },
36  { 5, 0, 0, 0, 0, 0, 0, 0 },
37  { 6, 0, 0, 0, 0, 0, 0, 0 },
38  { 5, 7, 5, 7, 0, 0, 0, 0 },
39  { 5, 7, 5, 0, 0, 0, 0, 0 },
40  { 5, 7, 6, 0, 0, 0, 0, 0 },
41  { 5, 5, 0, 0, 0, 0, 0, 0 },
42  { 3, 0, 0, 0, 0, 0, 0, 0 },
43  { 6, 6, 0, 0, 0, 0, 0, 0 },
44  { 2, 4, 0, 0, 0, 0, 0, 0 },
45  { 2, 4, 5, 7, 0, 0, 0, 0 },
46  { 2, 4, 5, 0, 0, 0, 0, 0 },
47  { 2, 4, 6, 0, 0, 0, 0, 0 },
48  { 2, 4, 5, 7, 5, 7, 0, 0 },
49 };
50 
51 typedef struct PAFVideoDecContext {
54 
55  int width;
56  int height;
57 
59  uint8_t *frame[4];
60  int dirty[4];
63 
64  uint8_t *opcodes;
66 
68 {
69  PAFVideoDecContext *c = avctx->priv_data;
70  int i;
71 
72  av_frame_free(&c->pic);
73 
74  for (i = 0; i < 4; i++)
75  av_freep(&c->frame[i]);
76 
77  return 0;
78 }
79 
81 {
82  PAFVideoDecContext *c = avctx->priv_data;
83  int i;
84  int ret;
85 
86  c->width = avctx->width;
87  c->height = avctx->height;
88 
89  if (avctx->height & 3 || avctx->width & 3) {
90  av_log(avctx, AV_LOG_ERROR,
91  "width %d and height %d must be multiplie of 4.\n",
92  avctx->width, avctx->height);
93  return AVERROR_INVALIDDATA;
94  }
95 
96  avctx->pix_fmt = AV_PIX_FMT_PAL8;
97  ret = av_image_check_size2(avctx->width, FFALIGN(avctx->height, 256), avctx->max_pixels, avctx->pix_fmt, 0, avctx);
98  if (ret < 0)
99  return ret;
100 
101  c->pic = av_frame_alloc();
102  if (!c->pic)
103  return AVERROR(ENOMEM);
104 
105  c->frame_size = avctx->width * FFALIGN(avctx->height, 256);
106  c->video_size = avctx->width * avctx->height;
107  for (i = 0; i < 4; i++) {
108  c->frame[i] = av_mallocz(c->frame_size);
109  if (!c->frame[i])
110  return AVERROR(ENOMEM);
111  }
112 
113  return 0;
114 }
115 
116 static void read4x4block(PAFVideoDecContext *c, uint8_t *dst, int width)
117 {
118  int i;
119 
120  for (i = 0; i < 4; i++) {
121  bytestream2_get_buffer(&c->gb, dst, 4);
122  dst += width;
123  }
124 }
125 
126 static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color)
127 {
128  int i;
129 
130  for (i = 0; i < 4; i++) {
131  if (mask & (1 << 7 - i))
132  dst[i] = color;
133  if (mask & (1 << 3 - i))
134  dst[width + i] = color;
135  }
136 }
137 
138 static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src)
139 {
140  int i;
141 
142  for (i = 0; i < 4; i++) {
143  if (mask & (1 << 7 - i))
144  dst[i] = src[i];
145  if (mask & (1 << 3 - i))
146  dst[width + i] = src[width + i];
147  }
148 }
149 
151  const uint8_t **p,
152  const uint8_t **pend)
153 {
154  int val = bytestream2_get_be16(&c->gb);
155  int page = val >> 14;
156  int x = (val & 0x7F);
157  int y = ((val >> 7) & 0x7F);
158 
159  *p = c->frame[page] + x * 2 + y * 2 * c->width;
160  *pend = c->frame[page] + c->frame_size;
161 }
162 
163 static int decode_0(PAFVideoDecContext *c, const uint8_t *pkt, uint8_t code)
164 {
165  uint32_t opcode_size, offset;
166  uint8_t *dst, *dend, mask = 0, color = 0;
167  const uint8_t *src, *send, *opcodes;
168  int i, j, op = 0;
169 
170  i = bytestream2_get_byte(&c->gb);
171  if (i) {
172  if (code & 0x10) {
173  int align;
174 
175  align = bytestream2_tell(&c->gb) & 3;
176  if (align)
177  bytestream2_skip(&c->gb, 4 - align);
178  }
179  do {
180  int page, val, x, y;
181  val = bytestream2_get_be16(&c->gb);
182  page = val >> 14;
183  x = (val & 0x7F) * 2;
184  y = ((val >> 7) & 0x7F) * 2;
185  dst = c->frame[page] + x + y * c->width;
186  dend = c->frame[page] + c->frame_size;
187  offset = (x & 0x7F) * 2;
188  j = bytestream2_get_le16(&c->gb) + offset;
189  if (bytestream2_get_bytes_left(&c->gb) < (j - offset) * 16)
190  return AVERROR_INVALIDDATA;
191  c->dirty[page] = 1;
192  do {
193  offset++;
194  if (dst + 3 * c->width + 4 > dend)
195  return AVERROR_INVALIDDATA;
196  read4x4block(c, dst, c->width);
197  if ((offset & 0x3F) == 0)
198  dst += c->width * 3;
199  dst += 4;
200  } while (offset < j);
201  } while (--i);
202  }
203 
204  dst = c->frame[c->current_frame];
205  dend = c->frame[c->current_frame] + c->frame_size;
206  do {
207  set_src_position(c, &src, &send);
208  if ((src + 3 * c->width + 4 > send) ||
209  (dst + 3 * c->width + 4 > dend) ||
210  bytestream2_get_bytes_left(&c->gb) < 4)
211  return AVERROR_INVALIDDATA;
212  copy_block4(dst, src, c->width, c->width, 4);
213  i++;
214  if ((i & 0x3F) == 0)
215  dst += c->width * 3;
216  dst += 4;
217  } while (i < c->video_size / 16);
218 
219  opcode_size = bytestream2_get_le16(&c->gb);
220  bytestream2_skip(&c->gb, 2);
221 
222  if (bytestream2_get_bytes_left(&c->gb) < opcode_size)
223  return AVERROR_INVALIDDATA;
224 
225  opcodes = pkt + bytestream2_tell(&c->gb);
226  bytestream2_skipu(&c->gb, opcode_size);
227 
228  dst = c->frame[c->current_frame];
229 
230  for (i = 0; i < c->height; i += 4, dst += c->width * 3)
231  for (j = 0; j < c->width; j += 4, dst += 4) {
232  int opcode, k = 0;
233  if (op > opcode_size)
234  return AVERROR_INVALIDDATA;
235  if (j & 4) {
236  opcode = opcodes[op] & 15;
237  op++;
238  } else {
239  opcode = opcodes[op] >> 4;
240  }
241 
242  while (block_sequences[opcode][k]) {
243  offset = c->width * 2;
244  code = block_sequences[opcode][k++];
245 
246  switch (code) {
247  case 2:
248  offset = 0;
249  case 3:
250  color = bytestream2_get_byte(&c->gb);
251  case 4:
252  mask = bytestream2_get_byte(&c->gb);
253  copy_color_mask(dst + offset, c->width, mask, color);
254  break;
255  case 5:
256  offset = 0;
257  case 6:
258  set_src_position(c, &src, &send);
259  case 7:
260  if (src + offset + c->width + 4 > send)
261  return AVERROR_INVALIDDATA;
262  mask = bytestream2_get_byte(&c->gb);
263  copy_src_mask(dst + offset, c->width, mask, src + offset);
264  break;
265  }
266  }
267  }
268 
269  return 0;
270 }
271 
272 static int paf_video_decode(AVCodecContext *avctx, AVFrame *rframe,
273  int *got_frame, AVPacket *pkt)
274 {
275  PAFVideoDecContext *c = avctx->priv_data;
276  uint8_t code, *dst, *end;
277  int i, frame, ret;
278 
279  if (pkt->size < 2)
280  return AVERROR_INVALIDDATA;
281 
282  bytestream2_init(&c->gb, pkt->data, pkt->size);
283 
284  code = bytestream2_get_byte(&c->gb);
285  if ((code & 0xF) > 4 || (code & 0xF) == 3) {
286  avpriv_request_sample(avctx, "unknown/invalid code");
287  return AVERROR_INVALIDDATA;
288  }
289 
290  if ((code & 0xF) == 0 &&
291  c->video_size / 32 - (int64_t)bytestream2_get_bytes_left(&c->gb) > c->video_size / 32 * (int64_t)avctx->discard_damaged_percentage / 100)
292  return AVERROR_INVALIDDATA;
293 
294  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
295  return ret;
296 
297  if (code & 0x20) { // frame is keyframe
298  memset(c->pic->data[1], 0, AVPALETTE_SIZE);
299  c->current_frame = 0;
300  c->pic->flags |= AV_FRAME_FLAG_KEY;
301  c->pic->pict_type = AV_PICTURE_TYPE_I;
302  } else {
303  c->pic->flags &= ~AV_FRAME_FLAG_KEY;
304  c->pic->pict_type = AV_PICTURE_TYPE_P;
305  }
306 
307  if (code & 0x40) { // palette update
308  uint32_t *out = (uint32_t *)c->pic->data[1];
309  int index, count;
310 
311  index = bytestream2_get_byte(&c->gb);
312  count = bytestream2_get_byte(&c->gb) + 1;
313 
314  if (index + count > 256)
315  return AVERROR_INVALIDDATA;
316  if (bytestream2_get_bytes_left(&c->gb) < 3 * count)
317  return AVERROR_INVALIDDATA;
318 
319  out += index;
320  for (i = 0; i < count; i++) {
321  unsigned r, g, b;
322 
323  r = bytestream2_get_byteu(&c->gb);
324  r = r << 2 | r >> 4;
325  g = bytestream2_get_byteu(&c->gb);
326  g = g << 2 | g >> 4;
327  b = bytestream2_get_byteu(&c->gb);
328  b = b << 2 | b >> 4;
329  *out++ = (0xFFU << 24) | (r << 16) | (g << 8) | b;
330  }
331 #if FF_API_PALETTE_HAS_CHANGED
333  c->pic->palette_has_changed = 1;
335 #endif
336  }
337 
338  c->dirty[c->current_frame] = 1;
339  if (code & 0x20)
340  for (i = 0; i < 4; i++) {
341  if (c->dirty[i])
342  memset(c->frame[i], 0, c->frame_size);
343  c->dirty[i] = 0;
344  }
345 
346  switch (code & 0x0F) {
347  case 0:
348  /* Block-based motion compensation using 4x4 blocks with either
349  * horizontal or vertical vectors; might incorporate VQ as well. */
350  if ((ret = decode_0(c, pkt->data, code)) < 0)
351  return ret;
352  break;
353  case 1:
354  /* Uncompressed data. This mode specifies that (width * height) bytes
355  * should be copied directly from the encoded buffer into the output. */
356  dst = c->frame[c->current_frame];
357  // possibly chunk length data
358  bytestream2_skip(&c->gb, 2);
359  if (bytestream2_get_bytes_left(&c->gb) < c->video_size)
360  return AVERROR_INVALIDDATA;
361  bytestream2_get_bufferu(&c->gb, dst, c->video_size);
362  break;
363  case 2:
364  /* Copy reference frame: Consume the next byte in the stream as the
365  * reference frame (which should be 0, 1, 2, or 3, and should not be
366  * the same as the current frame number). */
367  frame = bytestream2_get_byte(&c->gb);
368  if (frame > 3)
369  return AVERROR_INVALIDDATA;
370  if (frame != c->current_frame)
371  memcpy(c->frame[c->current_frame], c->frame[frame], c->frame_size);
372  break;
373  case 4:
374  /* Run length encoding.*/
375  dst = c->frame[c->current_frame];
376  end = dst + c->video_size;
377 
378  bytestream2_skip(&c->gb, 2);
379 
380  while (dst < end) {
381  int8_t code;
382  int count;
383 
384  if (bytestream2_get_bytes_left(&c->gb) < 2)
385  return AVERROR_INVALIDDATA;
386 
387  code = bytestream2_get_byteu(&c->gb);
388  count = FFABS(code) + 1;
389 
390  if (dst + count > end)
391  return AVERROR_INVALIDDATA;
392  if (code < 0)
393  memset(dst, bytestream2_get_byteu(&c->gb), count);
394  else
395  bytestream2_get_buffer(&c->gb, dst, count);
396  dst += count;
397  }
398  break;
399  default:
400  av_assert0(0);
401  }
402 
403  av_image_copy_plane(c->pic->data[0], c->pic->linesize[0],
404  c->frame[c->current_frame], c->width,
405  c->width, c->height);
406 
407  c->current_frame = (c->current_frame + 1) & 3;
408  if ((ret = av_frame_ref(rframe, c->pic)) < 0)
409  return ret;
410 
411  *got_frame = 1;
412 
413  return pkt->size;
414 }
415 
417  .p.name = "paf_video",
418  CODEC_LONG_NAME("Amazing Studio Packed Animation File Video"),
419  .p.type = AVMEDIA_TYPE_VIDEO,
420  .p.id = AV_CODEC_ID_PAF_VIDEO,
421  .priv_data_size = sizeof(PAFVideoDecContext),
422  .init = paf_video_init,
423  .close = paf_video_close,
425  .p.capabilities = AV_CODEC_CAP_DR1,
426  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
427 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
paf_video_decode
static int paf_video_decode(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *pkt)
Definition: pafvideo.c:272
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:64
r
const char * r
Definition: vf_curves.c:127
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:55
color
Definition: vf_paletteuse.c:512
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:53
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
PAFVideoDecContext::frame_size
int frame_size
Definition: pafvideo.c:61
AVPacket::data
uint8_t * data
Definition: packet.h:520
b
#define b
Definition: input.c:41
PAFVideoDecContext::frame
uint8_t * frame[4]
Definition: pafvideo.c:59
FFCodec
Definition: codec_internal.h:126
PAFVideoDecContext::width
int width
Definition: pafvideo.c:55
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:130
val
static double val(void *priv, double ch)
Definition: aeval.c:78
copy_src_mask
static void copy_src_mask(uint8_t *dst, int width, uint8_t mask, const uint8_t *src)
Definition: pafvideo.c:138
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:148
PAFVideoDecContext::current_frame
int current_frame
Definition: pafvideo.c:58
PAFVideoDecContext
Definition: pafvideo.c:51
pkt
AVPacket * pkt
Definition: movenc.c:60
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
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
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:286
g
const char * g
Definition: vf_curves.c:128
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
decode.h
paf_video_init
static av_cold int paf_video_init(AVCodecContext *avctx)
Definition: pafvideo.c:80
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1935
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
copy_color_mask
static void copy_color_mask(uint8_t *dst, int width, uint8_t mask, uint8_t color)
Definition: pafvideo.c:126
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
block_sequences
static const uint8_t block_sequences[16][8]
Definition: pafvideo.c:32
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
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:116
index
int index
Definition: gxfenc.c:90
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:62
PAFVideoDecContext::pic
AVFrame * pic
Definition: pafvideo.c:52
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
AVPacket::size
int size
Definition: packet.h:521
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:384
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:60
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
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:256
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
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:1684
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:150
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:416
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1970
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
PAFVideoDecContext::height
int height
Definition: pafvideo.c:56
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:497
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
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:67
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:163