FFmpeg
cinepak.c
Go to the documentation of this file.
1 /*
2  * Cinepak Video Decoder
3  * Copyright (C) 2003 The FFmpeg project
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 /**
23  * @file
24  * Cinepak video decoder
25  * @author Ewald Snel <ewald@rambo.its.tudelft.nl>
26  *
27  * @see For more information on the Cinepak algorithm, visit:
28  * http://www.csse.monash.edu.au/~timf/
29  * @see For more information on the quirky data inside Sega FILM/CPK files, visit:
30  * http://wiki.multimedia.cx/index.php?title=Sega_FILM
31  *
32  * Cinepak colorspace support (c) 2013 Rl, Aetey Global Technologies AB
33  * @author Cinepak colorspace, Rl, Aetey Global Technologies AB
34  */
35 
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 
40 #include "libavutil/common.h"
41 #include "libavutil/intreadwrite.h"
42 #include "avcodec.h"
43 #include "internal.h"
44 
45 
46 typedef uint8_t cvid_codebook[12];
47 
48 #define MAX_STRIPS 32
49 
50 typedef struct cvid_strip {
51  uint16_t id;
52  uint16_t x1, y1;
53  uint16_t x2, y2;
56 } cvid_strip;
57 
58 typedef struct CinepakContext {
59 
62 
63  const unsigned char *data;
64  int size;
65 
66  int width, height;
67 
70 
72 
73  uint32_t pal[256];
75 
76 static void cinepak_decode_codebook (cvid_codebook *codebook,
77  int chunk_id, int size, const uint8_t *data)
78 {
79  const uint8_t *eod = (data + size);
80  uint32_t flag, mask;
81  int i, n;
82  uint8_t *p;
83 
84  /* check if this chunk contains 4- or 6-element vectors */
85  n = (chunk_id & 0x04) ? 4 : 6;
86  flag = 0;
87  mask = 0;
88 
89  p = codebook[0];
90  for (i=0; i < 256; i++) {
91  if ((chunk_id & 0x01) && !(mask >>= 1)) {
92  if ((data + 4) > eod)
93  break;
94 
95  flag = AV_RB32 (data);
96  data += 4;
97  mask = 0x80000000;
98  }
99 
100  if (!(chunk_id & 0x01) || (flag & mask)) {
101  int k, kk;
102 
103  if ((data + n) > eod)
104  break;
105 
106  for (k = 0; k < 4; ++k) {
107  int r = *data++;
108  for (kk = 0; kk < 3; ++kk)
109  *p++ = r;
110  }
111  if (n == 6) {
112  int r, g, b, u, v;
113  u = *(int8_t *)data++;
114  v = *(int8_t *)data++;
115  p -= 12;
116  for(k=0; k<4; ++k) {
117  r = *p++ + v*2;
118  g = *p++ - (u/2) - v;
119  b = *p + u*2;
120  p -= 2;
121  *p++ = av_clip_uint8(r);
122  *p++ = av_clip_uint8(g);
123  *p++ = av_clip_uint8(b);
124  }
125  }
126  } else {
127  p += 12;
128  }
129  }
130 }
131 
133  int chunk_id, int size, const uint8_t *data)
134 {
135  const uint8_t *eod = (data + size);
136  uint32_t flag, mask;
137  uint8_t *cb0, *cb1, *cb2, *cb3;
138  int x, y;
139  char *ip0, *ip1, *ip2, *ip3;
140 
141  flag = 0;
142  mask = 0;
143 
144  for (y=strip->y1; y < strip->y2; y+=4) {
145 
146 /* take care of y dimension not being multiple of 4, such streams exist */
147  ip0 = ip1 = ip2 = ip3 = s->frame->data[0] +
148  (s->palette_video?strip->x1:strip->x1*3) + (y * s->frame->linesize[0]);
149  if(s->avctx->height - y > 1) {
150  ip1 = ip0 + s->frame->linesize[0];
151  if(s->avctx->height - y > 2) {
152  ip2 = ip1 + s->frame->linesize[0];
153  if(s->avctx->height - y > 3) {
154  ip3 = ip2 + s->frame->linesize[0];
155  }
156  }
157  }
158 /* to get the correct picture for not-multiple-of-4 cases let us fill each
159  * block from the bottom up, thus possibly overwriting the bottommost line
160  * more than once but ending with the correct data in place
161  * (instead of in-loop checking) */
162 
163  for (x=strip->x1; x < strip->x2; x+=4) {
164  if ((chunk_id & 0x01) && !(mask >>= 1)) {
165  if ((data + 4) > eod)
166  return AVERROR_INVALIDDATA;
167 
168  flag = AV_RB32 (data);
169  data += 4;
170  mask = 0x80000000;
171  }
172 
173  if (!(chunk_id & 0x01) || (flag & mask)) {
174  if (!(chunk_id & 0x02) && !(mask >>= 1)) {
175  if ((data + 4) > eod)
176  return AVERROR_INVALIDDATA;
177 
178  flag = AV_RB32 (data);
179  data += 4;
180  mask = 0x80000000;
181  }
182 
183  if ((chunk_id & 0x02) || (~flag & mask)) {
184  uint8_t *p;
185  if (data >= eod)
186  return AVERROR_INVALIDDATA;
187 
188  p = strip->v1_codebook[*data++];
189  if (s->palette_video) {
190  ip3[0] = ip3[1] = ip2[0] = ip2[1] = p[6];
191  ip3[2] = ip3[3] = ip2[2] = ip2[3] = p[9];
192  ip1[0] = ip1[1] = ip0[0] = ip0[1] = p[0];
193  ip1[2] = ip1[3] = ip0[2] = ip0[3] = p[3];
194  } else {
195  p += 6;
196  memcpy(ip3 + 0, p, 3); memcpy(ip3 + 3, p, 3);
197  memcpy(ip2 + 0, p, 3); memcpy(ip2 + 3, p, 3);
198  p += 3; /* ... + 9 */
199  memcpy(ip3 + 6, p, 3); memcpy(ip3 + 9, p, 3);
200  memcpy(ip2 + 6, p, 3); memcpy(ip2 + 9, p, 3);
201  p -= 9; /* ... + 0 */
202  memcpy(ip1 + 0, p, 3); memcpy(ip1 + 3, p, 3);
203  memcpy(ip0 + 0, p, 3); memcpy(ip0 + 3, p, 3);
204  p += 3; /* ... + 3 */
205  memcpy(ip1 + 6, p, 3); memcpy(ip1 + 9, p, 3);
206  memcpy(ip0 + 6, p, 3); memcpy(ip0 + 9, p, 3);
207  }
208 
209  } else if (flag & mask) {
210  if ((data + 4) > eod)
211  return AVERROR_INVALIDDATA;
212 
213  cb0 = strip->v4_codebook[*data++];
214  cb1 = strip->v4_codebook[*data++];
215  cb2 = strip->v4_codebook[*data++];
216  cb3 = strip->v4_codebook[*data++];
217  if (s->palette_video) {
218  uint8_t *p;
219  p = ip3;
220  *p++ = cb2[6];
221  *p++ = cb2[9];
222  *p++ = cb3[6];
223  *p = cb3[9];
224  p = ip2;
225  *p++ = cb2[0];
226  *p++ = cb2[3];
227  *p++ = cb3[0];
228  *p = cb3[3];
229  p = ip1;
230  *p++ = cb0[6];
231  *p++ = cb0[9];
232  *p++ = cb1[6];
233  *p = cb1[9];
234  p = ip0;
235  *p++ = cb0[0];
236  *p++ = cb0[3];
237  *p++ = cb1[0];
238  *p = cb1[3];
239  } else {
240  memcpy(ip3 + 0, cb2 + 6, 6);
241  memcpy(ip3 + 6, cb3 + 6, 6);
242  memcpy(ip2 + 0, cb2 + 0, 6);
243  memcpy(ip2 + 6, cb3 + 0, 6);
244  memcpy(ip1 + 0, cb0 + 6, 6);
245  memcpy(ip1 + 6, cb1 + 6, 6);
246  memcpy(ip0 + 0, cb0 + 0, 6);
247  memcpy(ip0 + 6, cb1 + 0, 6);
248  }
249 
250  }
251  }
252 
253  if (s->palette_video) {
254  ip0 += 4; ip1 += 4;
255  ip2 += 4; ip3 += 4;
256  } else {
257  ip0 += 12; ip1 += 12;
258  ip2 += 12; ip3 += 12;
259  }
260  }
261  }
262 
263  return 0;
264 }
265 
267  cvid_strip *strip, const uint8_t *data, int size)
268 {
269  const uint8_t *eod = (data + size);
270  int chunk_id, chunk_size;
271 
272  /* coordinate sanity checks */
273  if (strip->x2 > s->width ||
274  strip->y2 > s->height ||
275  strip->x1 >= strip->x2 || strip->y1 >= strip->y2)
276  return AVERROR_INVALIDDATA;
277 
278  while ((data + 4) <= eod) {
279  chunk_id = data[0];
280  chunk_size = AV_RB24 (&data[1]) - 4;
281  if(chunk_size < 0)
282  return AVERROR_INVALIDDATA;
283 
284  data += 4;
285  chunk_size = ((data + chunk_size) > eod) ? (eod - data) : chunk_size;
286 
287  switch (chunk_id) {
288 
289  case 0x20:
290  case 0x21:
291  case 0x24:
292  case 0x25:
293  cinepak_decode_codebook (strip->v4_codebook, chunk_id,
294  chunk_size, data);
295  break;
296 
297  case 0x22:
298  case 0x23:
299  case 0x26:
300  case 0x27:
301  cinepak_decode_codebook (strip->v1_codebook, chunk_id,
302  chunk_size, data);
303  break;
304 
305  case 0x30:
306  case 0x31:
307  case 0x32:
308  return cinepak_decode_vectors (s, strip, chunk_id,
309  chunk_size, data);
310  }
311 
312  data += chunk_size;
313  }
314 
315  return AVERROR_INVALIDDATA;
316 }
317 
319 {
320  int num_strips;
321  int encoded_buf_size;
322 
323  num_strips = AV_RB16 (&s->data[8]);
324  encoded_buf_size = AV_RB24(&s->data[1]);
325 
326  /* if this is the first frame, check for deviant Sega FILM data */
327  if (s->sega_film_skip_bytes == -1) {
328  if (!encoded_buf_size) {
329  avpriv_request_sample(s->avctx, "encoded_buf_size 0");
330  return AVERROR_PATCHWELCOME;
331  }
332  if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {
333  /* If the encoded frame size differs from the frame size as indicated
334  * by the container file, this data likely comes from a Sega FILM/CPK file.
335  * If the frame header is followed by the bytes FE 00 00 06 00 00 then
336  * this is probably one of the two known files that have 6 extra bytes
337  * after the frame header. Else, assume 2 extra bytes. The container
338  * size also cannot be a multiple of the encoded size. */
339  if (s->size >= 16 &&
340  (s->data[10] == 0xFE) &&
341  (s->data[11] == 0x00) &&
342  (s->data[12] == 0x00) &&
343  (s->data[13] == 0x06) &&
344  (s->data[14] == 0x00) &&
345  (s->data[15] == 0x00))
346  s->sega_film_skip_bytes = 6;
347  else
348  s->sega_film_skip_bytes = 2;
349  } else
350  s->sega_film_skip_bytes = 0;
351  }
352 
353  if (s->size < 10 + s->sega_film_skip_bytes + num_strips * 12)
354  return AVERROR_INVALIDDATA;
355 
356  return 0;
357 }
358 
360 {
361  const uint8_t *eod = (s->data + s->size);
362  int i, result, strip_size, frame_flags, num_strips;
363  int y0 = 0;
364 
365  frame_flags = s->data[0];
366  num_strips = AV_RB16 (&s->data[8]);
367 
368  s->data += 10 + s->sega_film_skip_bytes;
369 
370  num_strips = FFMIN(num_strips, MAX_STRIPS);
371 
372  s->frame->key_frame = 0;
373 
374  for (i=0; i < num_strips; i++) {
375  if ((s->data + 12) > eod)
376  return AVERROR_INVALIDDATA;
377 
378  s->strips[i].id = s->data[0];
379 /* zero y1 means "relative to the previous stripe" */
380  if (!(s->strips[i].y1 = AV_RB16 (&s->data[4])))
381  s->strips[i].y2 = (s->strips[i].y1 = y0) + AV_RB16 (&s->data[8]);
382  else
383  s->strips[i].y2 = AV_RB16 (&s->data[8]);
384  s->strips[i].x1 = AV_RB16 (&s->data[6]);
385  s->strips[i].x2 = AV_RB16 (&s->data[10]);
386 
387  if (s->strips[i].id == 0x10)
388  s->frame->key_frame = 1;
389 
390  strip_size = AV_RB24 (&s->data[1]) - 12;
391  if (strip_size < 0)
392  return AVERROR_INVALIDDATA;
393  s->data += 12;
394  strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;
395 
396  if ((i > 0) && !(frame_flags & 0x01)) {
397  memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,
398  sizeof(s->strips[i].v4_codebook));
399  memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,
400  sizeof(s->strips[i].v1_codebook));
401  }
402 
403  result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);
404 
405  if (result != 0)
406  return result;
407 
408  s->data += strip_size;
409  y0 = s->strips[i].y2;
410  }
411  return 0;
412 }
413 
415 {
416  CinepakContext *s = avctx->priv_data;
417 
418  s->avctx = avctx;
419  s->width = (avctx->width + 3) & ~3;
420  s->height = (avctx->height + 3) & ~3;
421 
422  s->sega_film_skip_bytes = -1; /* uninitialized state */
423 
424  // check for paletted data
425  if (avctx->bits_per_coded_sample != 8) {
426  s->palette_video = 0;
427  avctx->pix_fmt = AV_PIX_FMT_RGB24;
428  } else {
429  s->palette_video = 1;
430  avctx->pix_fmt = AV_PIX_FMT_PAL8;
431  }
432 
433  s->frame = av_frame_alloc();
434  if (!s->frame)
435  return AVERROR(ENOMEM);
436 
437  return 0;
438 }
439 
441  void *data, int *got_frame,
442  AVPacket *avpkt)
443 {
444  const uint8_t *buf = avpkt->data;
445  int ret = 0, buf_size = avpkt->size;
446  CinepakContext *s = avctx->priv_data;
447  int num_strips;
448 
449  s->data = buf;
450  s->size = buf_size;
451 
452  if (s->size < 10)
453  return AVERROR_INVALIDDATA;
454 
455  num_strips = AV_RB16 (&s->data[8]);
456 
457  //Empty frame, do not waste time
458  if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
459  return buf_size;
460 
461  if ((ret = cinepak_predecode_check(s)) < 0) {
462  av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
463  return ret;
464  }
465 
466  if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
467  return ret;
468 
469  if (s->palette_video) {
470  int size;
471  const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
472  if (pal && size == AVPALETTE_SIZE) {
473  s->frame->palette_has_changed = 1;
474  memcpy(s->pal, pal, AVPALETTE_SIZE);
475  } else if (pal) {
476  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
477  }
478  }
479 
480  if ((ret = cinepak_decode(s)) < 0) {
481  av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");
482  }
483 
484  if (s->palette_video)
485  memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);
486 
487  if ((ret = av_frame_ref(data, s->frame)) < 0)
488  return ret;
489 
490  *got_frame = 1;
491 
492  /* report that the buffer was completely consumed */
493  return buf_size;
494 }
495 
497 {
498  CinepakContext *s = avctx->priv_data;
499 
500  av_frame_free(&s->frame);
501 
502  return 0;
503 }
504 
506  .name = "cinepak",
507  .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
508  .type = AVMEDIA_TYPE_VIDEO,
509  .id = AV_CODEC_ID_CINEPAK,
510  .priv_data_size = sizeof(CinepakContext),
512  .close = cinepak_decode_end,
514  .capabilities = AV_CODEC_CAP_DR1,
515 };
#define NULL
Definition: coverity.c:32
cvid_strip strips[MAX_STRIPS]
Definition: cinepak.c:69
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint16_t x1
Definition: cinepak.c:52
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
cvid_codebook v4_codebook[256]
Definition: cinepak.c:54
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int cinepak_decode(CinepakContext *s)
Definition: cinepak.c:359
int size
Definition: avcodec.h:1469
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1766
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
AVCodec.
Definition: avcodec.h:3468
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:1966
AVCodec ff_cinepak_decoder
Definition: cinepak.c:505
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static int cinepak_decode_strip(CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size)
Definition: cinepak.c:266
static int cinepak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cinepak.c:440
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
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:443
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
#define height
uint8_t * data
Definition: avcodec.h:1468
ptrdiff_t size
Definition: opengl_enc.c:101
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2776
#define av_log(a,...)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1181
uint8_t cvid_codebook[12]
Definition: cinepak.c:46
static const uint16_t mask[17]
Definition: lzw.c:38
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
uint16_t y2
Definition: cinepak.c:53
const char * name
Name of the codec implementation.
Definition: avcodec.h:3475
static int cinepak_predecode_check(CinepakContext *s)
Definition: cinepak.c:318
uint16_t x2
Definition: cinepak.c:53
AVFrame * frame
Definition: cinepak.c:61
const unsigned char * data
Definition: cinepak.c:63
int sega_film_skip_bytes
Definition: cinepak.c:71
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1729
#define MAX_STRIPS
Definition: cinepak.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:684
uint16_t y1
Definition: cinepak.c:52
static int cinepak_decode_vectors(CinepakContext *s, cvid_strip *strip, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:132
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
Libavcodec external API header.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
main external API structure.
Definition: avcodec.h:1556
static av_cold int cinepak_decode_init(AVCodecContext *avctx)
Definition: cinepak.c:414
void * buf
Definition: avisynth_c.h:690
static void cinepak_decode_codebook(cvid_codebook *codebook, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:76
AVCodecContext * avctx
Definition: cinepak.c:60
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:425
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
uint16_t id
Definition: cinepak.c:51
int palette_video
Definition: cinepak.c:68
common internal api header.
common internal and external API header
#define flag(name)
Definition: cbs_av1.c:598
uint32_t pal[256]
Definition: cinepak.c:73
cvid_codebook v1_codebook[256]
Definition: cinepak.c:55
void * priv_data
Definition: avcodec.h:1583
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:346
and forward the result(frame or status change) to the corresponding input.If nothing is possible
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
This structure stores compressed data.
Definition: avcodec.h:1445
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:972
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
Definition: cinepak.c:496