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 "decode.h"
44 #include "internal.h"
45 
46 
47 typedef uint8_t cvid_codebook[12];
48 
49 #define MAX_STRIPS 32
50 
51 typedef struct cvid_strip {
52  uint16_t id;
53  uint16_t x1, y1;
54  uint16_t x2, y2;
57 } cvid_strip;
58 
59 typedef struct CinepakContext {
60 
63 
64  const unsigned char *data;
65  int size;
66 
67  int width, height;
68 
71 
73 
74  uint32_t pal[256];
76 
78  int chunk_id, int size, const uint8_t *data)
79 {
80  const uint8_t *eod = (data + size);
81  uint32_t flag, mask;
82  int i, n;
83  uint8_t *p;
84 
85  /* check if this chunk contains 4- or 6-element vectors */
86  n = (chunk_id & 0x04) ? 4 : 6;
87  flag = 0;
88  mask = 0;
89 
90  p = codebook[0];
91  for (i=0; i < 256; i++) {
92  if ((chunk_id & 0x01) && !(mask >>= 1)) {
93  if ((data + 4) > eod)
94  break;
95 
96  flag = AV_RB32 (data);
97  data += 4;
98  mask = 0x80000000;
99  }
100 
101  if (!(chunk_id & 0x01) || (flag & mask)) {
102  int k, kk;
103 
104  if ((data + n) > eod)
105  break;
106 
107  for (k = 0; k < 4; ++k) {
108  int r = *data++;
109  for (kk = 0; kk < 3; ++kk)
110  *p++ = r;
111  }
112  if (n == 6) {
113  int r, g, b, u, v;
114  u = *(int8_t *)data++;
115  v = *(int8_t *)data++;
116  p -= 12;
117  for(k=0; k<4; ++k) {
118  r = *p++ + v*2;
119  g = *p++ - (u/2) - v;
120  b = *p + u*2;
121  p -= 2;
122  *p++ = av_clip_uint8(r);
123  *p++ = av_clip_uint8(g);
124  *p++ = av_clip_uint8(b);
125  }
126  }
127  } else {
128  p += 12;
129  }
130  }
131 }
132 
134  int chunk_id, int size, const uint8_t *data)
135 {
136  const uint8_t *eod = (data + size);
137  uint32_t flag, mask;
138  uint8_t *cb0, *cb1, *cb2, *cb3;
139  int x, y;
140  char *ip0, *ip1, *ip2, *ip3;
141 
142  flag = 0;
143  mask = 0;
144 
145  for (y=strip->y1; y < strip->y2; y+=4) {
146 
147 /* take care of y dimension not being multiple of 4, such streams exist */
148  ip0 = ip1 = ip2 = ip3 = s->frame->data[0] +
149  (s->palette_video?strip->x1:strip->x1*3) + (y * s->frame->linesize[0]);
150  if(s->avctx->height - y > 1) {
151  ip1 = ip0 + s->frame->linesize[0];
152  if(s->avctx->height - y > 2) {
153  ip2 = ip1 + s->frame->linesize[0];
154  if(s->avctx->height - y > 3) {
155  ip3 = ip2 + s->frame->linesize[0];
156  }
157  }
158  }
159 /* to get the correct picture for not-multiple-of-4 cases let us fill each
160  * block from the bottom up, thus possibly overwriting the bottommost line
161  * more than once but ending with the correct data in place
162  * (instead of in-loop checking) */
163 
164  for (x=strip->x1; x < strip->x2; x+=4) {
165  if ((chunk_id & 0x01) && !(mask >>= 1)) {
166  if ((data + 4) > eod)
167  return AVERROR_INVALIDDATA;
168 
169  flag = AV_RB32 (data);
170  data += 4;
171  mask = 0x80000000;
172  }
173 
174  if (!(chunk_id & 0x01) || (flag & mask)) {
175  if (!(chunk_id & 0x02) && !(mask >>= 1)) {
176  if ((data + 4) > eod)
177  return AVERROR_INVALIDDATA;
178 
179  flag = AV_RB32 (data);
180  data += 4;
181  mask = 0x80000000;
182  }
183 
184  if ((chunk_id & 0x02) || (~flag & mask)) {
185  uint8_t *p;
186  if (data >= eod)
187  return AVERROR_INVALIDDATA;
188 
189  p = strip->v1_codebook[*data++];
190  if (s->palette_video) {
191  ip3[0] = ip3[1] = ip2[0] = ip2[1] = p[6];
192  ip3[2] = ip3[3] = ip2[2] = ip2[3] = p[9];
193  ip1[0] = ip1[1] = ip0[0] = ip0[1] = p[0];
194  ip1[2] = ip1[3] = ip0[2] = ip0[3] = p[3];
195  } else {
196  p += 6;
197  memcpy(ip3 + 0, p, 3); memcpy(ip3 + 3, p, 3);
198  memcpy(ip2 + 0, p, 3); memcpy(ip2 + 3, p, 3);
199  p += 3; /* ... + 9 */
200  memcpy(ip3 + 6, p, 3); memcpy(ip3 + 9, p, 3);
201  memcpy(ip2 + 6, p, 3); memcpy(ip2 + 9, p, 3);
202  p -= 9; /* ... + 0 */
203  memcpy(ip1 + 0, p, 3); memcpy(ip1 + 3, p, 3);
204  memcpy(ip0 + 0, p, 3); memcpy(ip0 + 3, p, 3);
205  p += 3; /* ... + 3 */
206  memcpy(ip1 + 6, p, 3); memcpy(ip1 + 9, p, 3);
207  memcpy(ip0 + 6, p, 3); memcpy(ip0 + 9, p, 3);
208  }
209 
210  } else if (flag & mask) {
211  if ((data + 4) > eod)
212  return AVERROR_INVALIDDATA;
213 
214  cb0 = strip->v4_codebook[*data++];
215  cb1 = strip->v4_codebook[*data++];
216  cb2 = strip->v4_codebook[*data++];
217  cb3 = strip->v4_codebook[*data++];
218  if (s->palette_video) {
219  uint8_t *p;
220  p = ip3;
221  *p++ = cb2[6];
222  *p++ = cb2[9];
223  *p++ = cb3[6];
224  *p = cb3[9];
225  p = ip2;
226  *p++ = cb2[0];
227  *p++ = cb2[3];
228  *p++ = cb3[0];
229  *p = cb3[3];
230  p = ip1;
231  *p++ = cb0[6];
232  *p++ = cb0[9];
233  *p++ = cb1[6];
234  *p = cb1[9];
235  p = ip0;
236  *p++ = cb0[0];
237  *p++ = cb0[3];
238  *p++ = cb1[0];
239  *p = cb1[3];
240  } else {
241  memcpy(ip3 + 0, cb2 + 6, 6);
242  memcpy(ip3 + 6, cb3 + 6, 6);
243  memcpy(ip2 + 0, cb2 + 0, 6);
244  memcpy(ip2 + 6, cb3 + 0, 6);
245  memcpy(ip1 + 0, cb0 + 6, 6);
246  memcpy(ip1 + 6, cb1 + 6, 6);
247  memcpy(ip0 + 0, cb0 + 0, 6);
248  memcpy(ip0 + 6, cb1 + 0, 6);
249  }
250 
251  }
252  }
253 
254  if (s->palette_video) {
255  ip0 += 4; ip1 += 4;
256  ip2 += 4; ip3 += 4;
257  } else {
258  ip0 += 12; ip1 += 12;
259  ip2 += 12; ip3 += 12;
260  }
261  }
262  }
263 
264  return 0;
265 }
266 
268  cvid_strip *strip, const uint8_t *data, int size)
269 {
270  const uint8_t *eod = (data + size);
271  int chunk_id, chunk_size;
272 
273  /* coordinate sanity checks */
274  if (strip->x2 > s->width ||
275  strip->y2 > s->height ||
276  strip->x1 >= strip->x2 || strip->y1 >= strip->y2)
277  return AVERROR_INVALIDDATA;
278 
279  while ((data + 4) <= eod) {
280  chunk_id = data[0];
281  chunk_size = AV_RB24 (&data[1]) - 4;
282  if(chunk_size < 0)
283  return AVERROR_INVALIDDATA;
284 
285  data += 4;
286  chunk_size = ((data + chunk_size) > eod) ? (eod - data) : chunk_size;
287 
288  switch (chunk_id) {
289 
290  case 0x20:
291  case 0x21:
292  case 0x24:
293  case 0x25:
294  cinepak_decode_codebook (strip->v4_codebook, chunk_id,
295  chunk_size, data);
296  break;
297 
298  case 0x22:
299  case 0x23:
300  case 0x26:
301  case 0x27:
302  cinepak_decode_codebook (strip->v1_codebook, chunk_id,
303  chunk_size, data);
304  break;
305 
306  case 0x30:
307  case 0x31:
308  case 0x32:
309  return cinepak_decode_vectors (s, strip, chunk_id,
310  chunk_size, data);
311  }
312 
313  data += chunk_size;
314  }
315 
316  return AVERROR_INVALIDDATA;
317 }
318 
320 {
321  int num_strips;
322  int encoded_buf_size;
323 
324  num_strips = AV_RB16 (&s->data[8]);
325  encoded_buf_size = AV_RB24(&s->data[1]);
326 
327  if (s->size < encoded_buf_size * (int64_t)(100 - s->avctx->discard_damaged_percentage) / 100)
328  return AVERROR_INVALIDDATA;
329 
330  /* if this is the first frame, check for deviant Sega FILM data */
331  if (s->sega_film_skip_bytes == -1) {
332  if (!encoded_buf_size) {
333  avpriv_request_sample(s->avctx, "encoded_buf_size 0");
334  return AVERROR_PATCHWELCOME;
335  }
336  if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {
337  /* If the encoded frame size differs from the frame size as indicated
338  * by the container file, this data likely comes from a Sega FILM/CPK file.
339  * If the frame header is followed by the bytes FE 00 00 06 00 00 then
340  * this is probably one of the two known files that have 6 extra bytes
341  * after the frame header. Else, assume 2 extra bytes. The container
342  * size also cannot be a multiple of the encoded size. */
343  if (s->size >= 16 &&
344  (s->data[10] == 0xFE) &&
345  (s->data[11] == 0x00) &&
346  (s->data[12] == 0x00) &&
347  (s->data[13] == 0x06) &&
348  (s->data[14] == 0x00) &&
349  (s->data[15] == 0x00))
350  s->sega_film_skip_bytes = 6;
351  else
352  s->sega_film_skip_bytes = 2;
353  } else
354  s->sega_film_skip_bytes = 0;
355  }
356 
357  if (s->size < 10 + s->sega_film_skip_bytes + num_strips * 12)
358  return AVERROR_INVALIDDATA;
359 
360  if (num_strips) {
361  const uint8_t *data = s->data + 10 + s->sega_film_skip_bytes;
362  int strip_size = AV_RB24 (data + 1);
363  if (strip_size < 12 || strip_size > encoded_buf_size)
364  return AVERROR_INVALIDDATA;
365  }
366 
367  return 0;
368 }
369 
371 {
372  const uint8_t *eod = (s->data + s->size);
373  int i, result, strip_size, frame_flags, num_strips;
374  int y0 = 0;
375 
376  frame_flags = s->data[0];
377  num_strips = AV_RB16 (&s->data[8]);
378 
379  s->data += 10 + s->sega_film_skip_bytes;
380 
381  num_strips = FFMIN(num_strips, MAX_STRIPS);
382 
383  s->frame->key_frame = 0;
384 
385  for (i=0; i < num_strips; i++) {
386  if ((s->data + 12) > eod)
387  return AVERROR_INVALIDDATA;
388 
389  s->strips[i].id = s->data[0];
390 /* zero y1 means "relative to the previous stripe" */
391  if (!(s->strips[i].y1 = AV_RB16 (&s->data[4])))
392  s->strips[i].y2 = (s->strips[i].y1 = y0) + AV_RB16 (&s->data[8]);
393  else
394  s->strips[i].y2 = AV_RB16 (&s->data[8]);
395  s->strips[i].x1 = AV_RB16 (&s->data[6]);
396  s->strips[i].x2 = AV_RB16 (&s->data[10]);
397 
398  if (s->strips[i].id == 0x10)
399  s->frame->key_frame = 1;
400 
401  strip_size = AV_RB24 (&s->data[1]) - 12;
402  if (strip_size < 0)
403  return AVERROR_INVALIDDATA;
404  s->data += 12;
405  strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;
406 
407  if ((i > 0) && !(frame_flags & 0x01)) {
408  memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,
409  sizeof(s->strips[i].v4_codebook));
410  memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,
411  sizeof(s->strips[i].v1_codebook));
412  }
413 
414  result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);
415 
416  if (result != 0)
417  return result;
418 
419  s->data += strip_size;
420  y0 = s->strips[i].y2;
421  }
422  return 0;
423 }
424 
426 {
427  CinepakContext *s = avctx->priv_data;
428 
429  s->avctx = avctx;
430  s->width = (avctx->width + 3) & ~3;
431  s->height = (avctx->height + 3) & ~3;
432 
433  s->sega_film_skip_bytes = -1; /* uninitialized state */
434 
435  // check for paletted data
436  if (avctx->bits_per_coded_sample != 8) {
437  s->palette_video = 0;
438  avctx->pix_fmt = AV_PIX_FMT_RGB24;
439  } else {
440  s->palette_video = 1;
441  avctx->pix_fmt = AV_PIX_FMT_PAL8;
442  }
443 
444  s->frame = av_frame_alloc();
445  if (!s->frame)
446  return AVERROR(ENOMEM);
447 
448  return 0;
449 }
450 
452  void *data, int *got_frame,
453  AVPacket *avpkt)
454 {
455  const uint8_t *buf = avpkt->data;
456  int ret = 0, buf_size = avpkt->size;
457  CinepakContext *s = avctx->priv_data;
458  int num_strips;
459 
460  s->data = buf;
461  s->size = buf_size;
462 
463  if (s->size < 10)
464  return AVERROR_INVALIDDATA;
465 
466  num_strips = AV_RB16 (&s->data[8]);
467 
468  //Empty frame, do not waste time
469  if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
470  return buf_size;
471 
472  if ((ret = cinepak_predecode_check(s)) < 0) {
473  av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
474  return ret;
475  }
476 
477  if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
478  return ret;
479 
480  if (s->palette_video) {
481  s->frame->palette_has_changed = ff_copy_palette(s->pal, avpkt, avctx);
482  }
483 
484  if ((ret = cinepak_decode(s)) < 0) {
485  av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");
486  }
487 
488  if (s->palette_video)
489  memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);
490 
491  if ((ret = av_frame_ref(data, s->frame)) < 0)
492  return ret;
493 
494  *got_frame = 1;
495 
496  /* report that the buffer was completely consumed */
497  return buf_size;
498 }
499 
501 {
502  CinepakContext *s = avctx->priv_data;
503 
504  av_frame_free(&s->frame);
505 
506  return 0;
507 }
508 
510  .name = "cinepak",
511  .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
512  .type = AVMEDIA_TYPE_VIDEO,
513  .id = AV_CODEC_ID_CINEPAK,
514  .priv_data_size = sizeof(CinepakContext),
516  .close = cinepak_decode_end,
518  .capabilities = AV_CODEC_CAP_DR1,
519  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
520 };
AVCodec
AVCodec.
Definition: codec.h:197
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
r
const char * r
Definition: vf_curves.c:116
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
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
cvid_strip::y1
uint16_t y1
Definition: cinepak.c:53
ff_cinepak_decoder
AVCodec ff_cinepak_decoder
Definition: cinepak.c:509
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
CinepakContext::height
int height
Definition: cinepak.c:67
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
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:142
cvid_strip::y2
uint16_t y2
Definition: cinepak.c:54
CinepakContext::avctx
AVCodecContext * avctx
Definition: cinepak.c:61
cvid_codebook
uint8_t cvid_codebook[12]
Definition: cinepak.c:47
cinepak_decode_frame
static int cinepak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cinepak.c:451
cinepak_predecode_check
static int cinepak_predecode_check(CinepakContext *s)
Definition: cinepak.c:319
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:117
CinepakContext::sega_film_skip_bytes
int sega_film_skip_bytes
Definition: cinepak.c:72
cinepak_decode_strip
static int cinepak_decode_strip(CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size)
Definition: cinepak.c:267
MAX_STRIPS
#define MAX_STRIPS
Definition: cinepak.c:49
decode.h
cvid_strip::v1_codebook
cvid_codebook v1_codebook[256]
Definition: cinepak.c:56
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:55
cvid_strip::x2
uint16_t x2
Definition: cinepak.c:54
cinepak_decode_codebook
static void cinepak_decode_codebook(cvid_codebook *codebook, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:77
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() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
cvid_strip::x1
uint16_t x1
Definition: cinepak.c:53
AVPacket::size
int size
Definition: packet.h:370
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:117
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:52
size
int size
Definition: twinvq_data.h:10344
AV_RB32
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:96
cinepak_decode_init
static av_cold int cinepak_decode_init(AVCodecContext *avctx)
Definition: cinepak.c:425
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
cvid_strip
Definition: cinepak.c:51
flag
#define flag(name)
Definition: cbs_av1.c:553
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
i
int i
Definition: input.c:407
CinepakContext::width
int width
Definition: cinepak.c:67
common.h
CinepakContext::pal
uint32_t pal[256]
Definition: cinepak.c:74
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
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:133
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:2000
ret
ret
Definition: filter_design.txt:187
CinepakContext
Definition: cinepak.c:59
CinepakContext::size
int size
Definition: cinepak.c:65
AVCodecContext
main external API structure.
Definition: avcodec.h:536
cinepak_decode_end
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
Definition: cinepak.c:500
av_clip_uint8
#define av_clip_uint8
Definition: common.h:128
CinepakContext::palette_video
int palette_video
Definition: cinepak.c:69
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:346
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
CinepakContext::strips
cvid_strip strips[MAX_STRIPS]
Definition: cinepak.c:70
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
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
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:2095
cinepak_decode
static int cinepak_decode(CinepakContext *s)
Definition: cinepak.c:370
AV_RB24
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:97
CinepakContext::frame
AVFrame * frame
Definition: cinepak.c:62
CinepakContext::data
const unsigned char * data
Definition: cinepak.c:64
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
AV_RB16
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:98