FFmpeg  4.3
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 (s->size < encoded_buf_size * (int64_t)(100 - s->avctx->discard_damaged_percentage) / 100)
327  return AVERROR_INVALIDDATA;
328 
329  /* if this is the first frame, check for deviant Sega FILM data */
330  if (s->sega_film_skip_bytes == -1) {
331  if (!encoded_buf_size) {
332  avpriv_request_sample(s->avctx, "encoded_buf_size 0");
333  return AVERROR_PATCHWELCOME;
334  }
335  if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {
336  /* If the encoded frame size differs from the frame size as indicated
337  * by the container file, this data likely comes from a Sega FILM/CPK file.
338  * If the frame header is followed by the bytes FE 00 00 06 00 00 then
339  * this is probably one of the two known files that have 6 extra bytes
340  * after the frame header. Else, assume 2 extra bytes. The container
341  * size also cannot be a multiple of the encoded size. */
342  if (s->size >= 16 &&
343  (s->data[10] == 0xFE) &&
344  (s->data[11] == 0x00) &&
345  (s->data[12] == 0x00) &&
346  (s->data[13] == 0x06) &&
347  (s->data[14] == 0x00) &&
348  (s->data[15] == 0x00))
349  s->sega_film_skip_bytes = 6;
350  else
351  s->sega_film_skip_bytes = 2;
352  } else
353  s->sega_film_skip_bytes = 0;
354  }
355 
356  if (s->size < 10 + s->sega_film_skip_bytes + num_strips * 12)
357  return AVERROR_INVALIDDATA;
358 
359  if (num_strips) {
360  const uint8_t *data = s->data + 10 + s->sega_film_skip_bytes;
361  int strip_size = AV_RB24 (data + 1);
362  if (strip_size < 12 || strip_size > encoded_buf_size)
363  return AVERROR_INVALIDDATA;
364  }
365 
366  return 0;
367 }
368 
370 {
371  const uint8_t *eod = (s->data + s->size);
372  int i, result, strip_size, frame_flags, num_strips;
373  int y0 = 0;
374 
375  frame_flags = s->data[0];
376  num_strips = AV_RB16 (&s->data[8]);
377 
378  s->data += 10 + s->sega_film_skip_bytes;
379 
380  num_strips = FFMIN(num_strips, MAX_STRIPS);
381 
382  s->frame->key_frame = 0;
383 
384  for (i=0; i < num_strips; i++) {
385  if ((s->data + 12) > eod)
386  return AVERROR_INVALIDDATA;
387 
388  s->strips[i].id = s->data[0];
389 /* zero y1 means "relative to the previous stripe" */
390  if (!(s->strips[i].y1 = AV_RB16 (&s->data[4])))
391  s->strips[i].y2 = (s->strips[i].y1 = y0) + AV_RB16 (&s->data[8]);
392  else
393  s->strips[i].y2 = AV_RB16 (&s->data[8]);
394  s->strips[i].x1 = AV_RB16 (&s->data[6]);
395  s->strips[i].x2 = AV_RB16 (&s->data[10]);
396 
397  if (s->strips[i].id == 0x10)
398  s->frame->key_frame = 1;
399 
400  strip_size = AV_RB24 (&s->data[1]) - 12;
401  if (strip_size < 0)
402  return AVERROR_INVALIDDATA;
403  s->data += 12;
404  strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;
405 
406  if ((i > 0) && !(frame_flags & 0x01)) {
407  memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,
408  sizeof(s->strips[i].v4_codebook));
409  memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,
410  sizeof(s->strips[i].v1_codebook));
411  }
412 
413  result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);
414 
415  if (result != 0)
416  return result;
417 
418  s->data += strip_size;
419  y0 = s->strips[i].y2;
420  }
421  return 0;
422 }
423 
425 {
426  CinepakContext *s = avctx->priv_data;
427 
428  s->avctx = avctx;
429  s->width = (avctx->width + 3) & ~3;
430  s->height = (avctx->height + 3) & ~3;
431 
432  s->sega_film_skip_bytes = -1; /* uninitialized state */
433 
434  // check for paletted data
435  if (avctx->bits_per_coded_sample != 8) {
436  s->palette_video = 0;
437  avctx->pix_fmt = AV_PIX_FMT_RGB24;
438  } else {
439  s->palette_video = 1;
440  avctx->pix_fmt = AV_PIX_FMT_PAL8;
441  }
442 
443  s->frame = av_frame_alloc();
444  if (!s->frame)
445  return AVERROR(ENOMEM);
446 
447  return 0;
448 }
449 
451  void *data, int *got_frame,
452  AVPacket *avpkt)
453 {
454  const uint8_t *buf = avpkt->data;
455  int ret = 0, buf_size = avpkt->size;
456  CinepakContext *s = avctx->priv_data;
457  int num_strips;
458 
459  s->data = buf;
460  s->size = buf_size;
461 
462  if (s->size < 10)
463  return AVERROR_INVALIDDATA;
464 
465  num_strips = AV_RB16 (&s->data[8]);
466 
467  //Empty frame, do not waste time
468  if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
469  return buf_size;
470 
471  if ((ret = cinepak_predecode_check(s)) < 0) {
472  av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
473  return ret;
474  }
475 
476  if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
477  return ret;
478 
479  if (s->palette_video) {
480  int size;
482  if (pal && size == AVPALETTE_SIZE) {
483  s->frame->palette_has_changed = 1;
484  memcpy(s->pal, pal, AVPALETTE_SIZE);
485  } else if (pal) {
486  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
487  }
488  }
489 
490  if ((ret = cinepak_decode(s)) < 0) {
491  av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");
492  }
493 
494  if (s->palette_video)
495  memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);
496 
497  if ((ret = av_frame_ref(data, s->frame)) < 0)
498  return ret;
499 
500  *got_frame = 1;
501 
502  /* report that the buffer was completely consumed */
503  return buf_size;
504 }
505 
507 {
508  CinepakContext *s = avctx->priv_data;
509 
510  av_frame_free(&s->frame);
511 
512  return 0;
513 }
514 
516  .name = "cinepak",
517  .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
518  .type = AVMEDIA_TYPE_VIDEO,
519  .id = AV_CODEC_ID_CINEPAK,
520  .priv_data_size = sizeof(CinepakContext),
522  .close = cinepak_decode_end,
524  .capabilities = AV_CODEC_CAP_DR1,
525 };
AVCodec
AVCodec.
Definition: codec.h:190
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
cvid_strip::y1
uint16_t y1
Definition: cinepak.c:52
ff_cinepak_decoder
AVCodec ff_cinepak_decoder
Definition: cinepak.c:515
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
CinepakContext::height
int height
Definition: cinepak.c:66
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
b
#define b
Definition: input.c:41
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:46
data
const char data[16]
Definition: mxf.c:91
AV_RB16
#define AV_RB16
Definition: intreadwrite.h:53
cvid_strip::y2
uint16_t y2
Definition: cinepak.c:53
CinepakContext::avctx
AVCodecContext * avctx
Definition: cinepak.c:60
cvid_codebook
uint8_t cvid_codebook[12]
Definition: cinepak.c:46
x
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
Definition: fate.txt:150
AV_RB24
#define AV_RB24
Definition: intreadwrite.h:64
cinepak_decode_frame
static int cinepak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cinepak.c:450
cinepak_predecode_check
static int cinepak_predecode_check(CinepakContext *s)
Definition: cinepak.c:318
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:115
CinepakContext::sega_film_skip_bytes
int sega_film_skip_bytes
Definition: cinepak.c:71
cinepak_decode_strip
static int cinepak_decode_strip(CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size)
Definition: cinepak.c:266
MAX_STRIPS
#define MAX_STRIPS
Definition: cinepak.c:48
cvid_strip::v1_codebook
cvid_codebook v1_codebook[256]
Definition: cinepak.c:55
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AV_CODEC_ID_CINEPAK
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:92
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
cvid_strip::v4_codebook
cvid_codebook v4_codebook[256]
Definition: cinepak.c:54
cvid_strip::x2
uint16_t x2
Definition: cinepak.c:53
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
cinepak_decode_codebook
static void cinepak_decode_codebook(cvid_codebook *codebook, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:76
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
cvid_strip::x1
uint16_t x1
Definition: cinepak.c:52
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:186
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:444
cvid_strip::id
uint16_t id
Definition: cinepak.c:51
size
int size
Definition: twinvq_data.h:11134
cinepak_decode_init
static av_cold int cinepak_decode_init(AVCodecContext *avctx)
Definition: cinepak.c:424
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
cvid_strip
Definition: cinepak.c:50
r
#define r
Definition: input.c:40
flag
#define flag(name)
Definition: cbs_av1.c:556
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
CinepakContext::width
int width
Definition: cinepak.c:66
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
common.h
CinepakContext::pal
uint32_t pal[256]
Definition: cinepak.c:73
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
cinepak_decode_vectors
static int cinepak_decode_vectors(CinepakContext *s, cvid_strip *strip, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:132
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:1960
ret
ret
Definition: filter_design.txt:187
CinepakContext
Definition: cinepak.c:58
CinepakContext::size
int size
Definition: cinepak.c:64
AVCodecContext
main external API structure.
Definition: avcodec.h:526
cinepak_decode_end
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
Definition: cinepak.c:506
CinepakContext::palette_video
int palette_video
Definition: cinepak.c:68
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
CinepakContext::strips
cvid_strip strips[MAX_STRIPS]
Definition: cinepak.c:69
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
cinepak_decode
static int cinepak_decode(CinepakContext *s)
Definition: cinepak.c:369
CinepakContext::frame
AVFrame * frame
Definition: cinepak.c:61
CinepakContext::data
const unsigned char * data
Definition: cinepak.c:63