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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 
37 #include "libavutil/intreadwrite.h"
38 #include "avcodec.h"
39 
40 
41 typedef struct {
42  uint8_t y0, y1, y2, y3;
43  uint8_t u, v;
45 
46 #define MAX_STRIPS 32
47 
48 typedef struct {
49  uint16_t id;
50  uint16_t x1, y1;
51  uint16_t x2, y2;
52  cvid_codebook v4_codebook[256];
53  cvid_codebook v1_codebook[256];
54 } cvid_strip;
55 
56 typedef struct CinepakContext {
57 
60 
61  const unsigned char *data;
62  int size;
63 
64  int width, height;
65 
68 
70 
71  uint32_t pal[256];
73 
74 static void cinepak_decode_codebook (cvid_codebook *codebook,
75  int chunk_id, int size, const uint8_t *data)
76 {
77  const uint8_t *eod = (data + size);
78  uint32_t flag, mask;
79  int i, n;
80 
81  /* check if this chunk contains 4- or 6-element vectors */
82  n = (chunk_id & 0x04) ? 4 : 6;
83  flag = 0;
84  mask = 0;
85 
86  for (i=0; i < 256; i++) {
87  if ((chunk_id & 0x01) && !(mask >>= 1)) {
88  if ((data + 4) > eod)
89  break;
90 
91  flag = AV_RB32 (data);
92  data += 4;
93  mask = 0x80000000;
94  }
95 
96  if (!(chunk_id & 0x01) || (flag & mask)) {
97  if ((data + n) > eod)
98  break;
99 
100  if (n == 6) {
101  codebook[i].y0 = *data++;
102  codebook[i].y1 = *data++;
103  codebook[i].y2 = *data++;
104  codebook[i].y3 = *data++;
105  codebook[i].u = 128 + *data++;
106  codebook[i].v = 128 + *data++;
107  } else {
108  /* this codebook type indicates either greyscale or
109  * palettized video; if palettized, U & V components will
110  * not be used so it is safe to set them to 128 for the
111  * benefit of greyscale rendering in YUV420P */
112  codebook[i].y0 = *data++;
113  codebook[i].y1 = *data++;
114  codebook[i].y2 = *data++;
115  codebook[i].y3 = *data++;
116  codebook[i].u = 128;
117  codebook[i].v = 128;
118  }
119  }
120  }
121 }
122 
124  int chunk_id, int size, const uint8_t *data)
125 {
126  const uint8_t *eod = (data + size);
127  uint32_t flag, mask;
128  cvid_codebook *codebook;
129  unsigned int x, y;
130  uint32_t iy[4];
131  uint32_t iu[2];
132  uint32_t iv[2];
133 
134  flag = 0;
135  mask = 0;
136 
137  for (y=strip->y1; y < strip->y2; y+=4) {
138 
139  iy[0] = strip->x1 + (y * s->frame.linesize[0]);
140  iy[1] = iy[0] + s->frame.linesize[0];
141  iy[2] = iy[1] + s->frame.linesize[0];
142  iy[3] = iy[2] + s->frame.linesize[0];
143  iu[0] = (strip->x1/2) + ((y/2) * s->frame.linesize[1]);
144  iu[1] = iu[0] + s->frame.linesize[1];
145  iv[0] = (strip->x1/2) + ((y/2) * s->frame.linesize[2]);
146  iv[1] = iv[0] + s->frame.linesize[2];
147 
148  for (x=strip->x1; x < strip->x2; x+=4) {
149  if ((chunk_id & 0x01) && !(mask >>= 1)) {
150  if ((data + 4) > eod)
151  return AVERROR_INVALIDDATA;
152 
153  flag = AV_RB32 (data);
154  data += 4;
155  mask = 0x80000000;
156  }
157 
158  if (!(chunk_id & 0x01) || (flag & mask)) {
159  if (!(chunk_id & 0x02) && !(mask >>= 1)) {
160  if ((data + 4) > eod)
161  return AVERROR_INVALIDDATA;
162 
163  flag = AV_RB32 (data);
164  data += 4;
165  mask = 0x80000000;
166  }
167 
168  if ((chunk_id & 0x02) || (~flag & mask)) {
169  if (data >= eod)
170  return AVERROR_INVALIDDATA;
171 
172  codebook = &strip->v1_codebook[*data++];
173  s->frame.data[0][iy[0] + 0] = codebook->y0;
174  s->frame.data[0][iy[0] + 1] = codebook->y0;
175  s->frame.data[0][iy[1] + 0] = codebook->y0;
176  s->frame.data[0][iy[1] + 1] = codebook->y0;
177  if (!s->palette_video) {
178  s->frame.data[1][iu[0]] = codebook->u;
179  s->frame.data[2][iv[0]] = codebook->v;
180  }
181 
182  s->frame.data[0][iy[0] + 2] = codebook->y1;
183  s->frame.data[0][iy[0] + 3] = codebook->y1;
184  s->frame.data[0][iy[1] + 2] = codebook->y1;
185  s->frame.data[0][iy[1] + 3] = codebook->y1;
186  if (!s->palette_video) {
187  s->frame.data[1][iu[0] + 1] = codebook->u;
188  s->frame.data[2][iv[0] + 1] = codebook->v;
189  }
190 
191  s->frame.data[0][iy[2] + 0] = codebook->y2;
192  s->frame.data[0][iy[2] + 1] = codebook->y2;
193  s->frame.data[0][iy[3] + 0] = codebook->y2;
194  s->frame.data[0][iy[3] + 1] = codebook->y2;
195  if (!s->palette_video) {
196  s->frame.data[1][iu[1]] = codebook->u;
197  s->frame.data[2][iv[1]] = codebook->v;
198  }
199 
200  s->frame.data[0][iy[2] + 2] = codebook->y3;
201  s->frame.data[0][iy[2] + 3] = codebook->y3;
202  s->frame.data[0][iy[3] + 2] = codebook->y3;
203  s->frame.data[0][iy[3] + 3] = codebook->y3;
204  if (!s->palette_video) {
205  s->frame.data[1][iu[1] + 1] = codebook->u;
206  s->frame.data[2][iv[1] + 1] = codebook->v;
207  }
208 
209  } else if (flag & mask) {
210  if ((data + 4) > eod)
211  return AVERROR_INVALIDDATA;
212 
213  codebook = &strip->v4_codebook[*data++];
214  s->frame.data[0][iy[0] + 0] = codebook->y0;
215  s->frame.data[0][iy[0] + 1] = codebook->y1;
216  s->frame.data[0][iy[1] + 0] = codebook->y2;
217  s->frame.data[0][iy[1] + 1] = codebook->y3;
218  if (!s->palette_video) {
219  s->frame.data[1][iu[0]] = codebook->u;
220  s->frame.data[2][iv[0]] = codebook->v;
221  }
222 
223  codebook = &strip->v4_codebook[*data++];
224  s->frame.data[0][iy[0] + 2] = codebook->y0;
225  s->frame.data[0][iy[0] + 3] = codebook->y1;
226  s->frame.data[0][iy[1] + 2] = codebook->y2;
227  s->frame.data[0][iy[1] + 3] = codebook->y3;
228  if (!s->palette_video) {
229  s->frame.data[1][iu[0] + 1] = codebook->u;
230  s->frame.data[2][iv[0] + 1] = codebook->v;
231  }
232 
233  codebook = &strip->v4_codebook[*data++];
234  s->frame.data[0][iy[2] + 0] = codebook->y0;
235  s->frame.data[0][iy[2] + 1] = codebook->y1;
236  s->frame.data[0][iy[3] + 0] = codebook->y2;
237  s->frame.data[0][iy[3] + 1] = codebook->y3;
238  if (!s->palette_video) {
239  s->frame.data[1][iu[1]] = codebook->u;
240  s->frame.data[2][iv[1]] = codebook->v;
241  }
242 
243  codebook = &strip->v4_codebook[*data++];
244  s->frame.data[0][iy[2] + 2] = codebook->y0;
245  s->frame.data[0][iy[2] + 3] = codebook->y1;
246  s->frame.data[0][iy[3] + 2] = codebook->y2;
247  s->frame.data[0][iy[3] + 3] = codebook->y3;
248  if (!s->palette_video) {
249  s->frame.data[1][iu[1] + 1] = codebook->u;
250  s->frame.data[2][iv[1] + 1] = codebook->v;
251  }
252 
253  }
254  }
255 
256  iy[0] += 4; iy[1] += 4;
257  iy[2] += 4; iy[3] += 4;
258  iu[0] += 2; iu[1] += 2;
259  iv[0] += 2; iv[1] += 2;
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  const uint8_t *eod = (s->data + s->size);
321  int i, result, strip_size, frame_flags, num_strips;
322  int y0 = 0;
323  int encoded_buf_size;
324 
325  if (s->size < 10)
326  return AVERROR_INVALIDDATA;
327 
328  frame_flags = s->data[0];
329  num_strips = AV_RB16 (&s->data[8]);
330  encoded_buf_size = AV_RB24(&s->data[1]);
331 
332  /* if this is the first frame, check for deviant Sega FILM data */
333  if (s->sega_film_skip_bytes == -1) {
334  if (!encoded_buf_size) {
335  av_log_ask_for_sample(s->avctx, "encoded_buf_size is 0");
336  return AVERROR_INVALIDDATA;
337  }
338  if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {
339  /* If the encoded frame size differs from the frame size as indicated
340  * by the container file, this data likely comes from a Sega FILM/CPK file.
341  * If the frame header is followed by the bytes FE 00 00 06 00 00 then
342  * this is probably one of the two known files that have 6 extra bytes
343  * after the frame header. Else, assume 2 extra bytes. The container
344  * size also cannot be a multiple of the encoded size. */
345  if (s->size >= 16 &&
346  (s->data[10] == 0xFE) &&
347  (s->data[11] == 0x00) &&
348  (s->data[12] == 0x00) &&
349  (s->data[13] == 0x06) &&
350  (s->data[14] == 0x00) &&
351  (s->data[15] == 0x00))
352  s->sega_film_skip_bytes = 6;
353  else
354  s->sega_film_skip_bytes = 2;
355  } else
356  s->sega_film_skip_bytes = 0;
357  }
358 
359  s->data += 10 + s->sega_film_skip_bytes;
360 
361  num_strips = FFMIN(num_strips, MAX_STRIPS);
362 
363  for (i=0; i < num_strips; i++) {
364  if ((s->data + 12) > eod)
365  return AVERROR_INVALIDDATA;
366 
367  s->strips[i].id = s->data[0];
368  s->strips[i].y1 = y0;
369  s->strips[i].x1 = 0;
370  s->strips[i].y2 = y0 + AV_RB16 (&s->data[8]);
371  s->strips[i].x2 = s->avctx->width;
372 
373  strip_size = AV_RB24 (&s->data[1]) - 12;
374  if (strip_size < 0)
375  return AVERROR_INVALIDDATA;
376  s->data += 12;
377  strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;
378 
379  if ((i > 0) && !(frame_flags & 0x01)) {
380  memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,
381  sizeof(s->strips[i].v4_codebook));
382  memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,
383  sizeof(s->strips[i].v1_codebook));
384  }
385 
386  result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);
387 
388  if (result != 0)
389  return result;
390 
391  s->data += strip_size;
392  y0 = s->strips[i].y2;
393  }
394  return 0;
395 }
396 
398 {
399  CinepakContext *s = avctx->priv_data;
400 
401  s->avctx = avctx;
402  s->width = (avctx->width + 3) & ~3;
403  s->height = (avctx->height + 3) & ~3;
404  s->sega_film_skip_bytes = -1; /* uninitialized state */
405 
406  // check for paletted data
407  if (avctx->bits_per_coded_sample != 8) {
408  s->palette_video = 0;
409  avctx->pix_fmt = PIX_FMT_YUV420P;
410  } else {
411  s->palette_video = 1;
412  avctx->pix_fmt = PIX_FMT_PAL8;
413  }
414 
415  s->frame.data[0] = NULL;
416 
417  return 0;
418 }
419 
421  void *data, int *data_size,
422  AVPacket *avpkt)
423 {
424  const uint8_t *buf = avpkt->data;
425  int ret = 0, buf_size = avpkt->size;
426  CinepakContext *s = avctx->priv_data;
427 
428  s->data = buf;
429  s->size = buf_size;
430 
431  s->frame.reference = 1;
434  if ((ret = avctx->reget_buffer(avctx, &s->frame))) {
435  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
436  return ret;
437  }
438 
439  if (s->palette_video) {
440  const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
441  if (pal) {
442  s->frame.palette_has_changed = 1;
443  memcpy(s->pal, pal, AVPALETTE_SIZE);
444  }
445  }
446 
447  cinepak_decode(s);
448 
449  if (s->palette_video)
450  memcpy (s->frame.data[1], s->pal, AVPALETTE_SIZE);
451 
452  *data_size = sizeof(AVFrame);
453  *(AVFrame*)data = s->frame;
454 
455  /* report that the buffer was completely consumed */
456  return buf_size;
457 }
458 
460 {
461  CinepakContext *s = avctx->priv_data;
462 
463  if (s->frame.data[0])
464  avctx->release_buffer(avctx, &s->frame);
465 
466  return 0;
467 }
468 
470  .name = "cinepak",
471  .type = AVMEDIA_TYPE_VIDEO,
472  .id = CODEC_ID_CINEPAK,
473  .priv_data_size = sizeof(CinepakContext),
477  .capabilities = CODEC_CAP_DR1,
478  .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
479 };
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
Definition: avcodec.h:1426
cvid_strip strips[MAX_STRIPS]
Definition: cinepak.c:67
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
uint16_t x1
Definition: cinepak.c:50
AV_WL32 AV_WL24 AV_WL16 AV_WB32 AV_WB24 AV_RB16
Definition: bytestream.h:89
int size
#define FF_BUFFER_HINTS_VALID
Definition: avcodec.h:880
Audio Video Frame.
Definition: avcodec.h:985
cvid_codebook v4_codebook[256]
Definition: cinepak.c:52
AV_WL32 AV_WL24 AV_WL16 AV_RB32
Definition: bytestream.h:89
int buffer_hints
codec suggestion on buffer type if != 0
Definition: avcodec.h:1195
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:1737
static int cinepak_decode(CinepakContext *s)
Definition: cinepak.c:318
int size
Definition: avcodec.h:909
AVFrame frame
Definition: cinepak.c:59
AVCodec.
Definition: avcodec.h:3189
int(* reget_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of a frame to get cr buffer for it.
Definition: avcodec.h:2336
AVCodec ff_cinepak_decoder
Definition: cinepak.c:469
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
static int cinepak_decode_strip(CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size)
Definition: cinepak.c:266
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:64
#define av_cold
Definition: attributes.h:71
const char data[16]
Definition: mxf.c:60
uint8_t * data
Definition: avcodec.h:908
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1974
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
static const uint16_t mask[17]
Definition: lzw.c:36
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1074
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
uint16_t y2
Definition: cinepak.c:51
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
uint16_t x2
Definition: cinepak.c:51
const unsigned char * data
Definition: cinepak.c:61
int sega_film_skip_bytes
Definition: cinepak.c:69
uint8_t y2
Definition: cinepak.c:42
#define FFMIN(a, b)
Definition: common.h:55
int width
picture width / height.
Definition: avcodec.h:1408
struct AVFrame AVFrame
Audio Video Frame.
#define MAX_STRIPS
Definition: cinepak.c:46
uint8_t v
Definition: cinepak.c:43
uint16_t y1
Definition: cinepak.c:50
static int cinepak_decode_vectors(CinepakContext *s, cvid_strip *strip, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:123
#define FF_BUFFER_HINTS_REUSABLE
Definition: avcodec.h:883
uint8_t u
Definition: cinepak.c:43
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:185
NULL
Definition: eval.c:50
external API header
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
void av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
main external API structure.
Definition: avcodec.h:1329
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
static av_cold int cinepak_decode_init(AVCodecContext *avctx)
Definition: cinepak.c:397
#define FF_BUFFER_HINTS_PRESERVE
Definition: avcodec.h:882
static void cinepak_decode_codebook(cvid_codebook *codebook, int chunk_id, int size, const uint8_t *data)
Definition: cinepak.c:74
AVCodecContext * avctx
Definition: cinepak.c:58
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: avcodec.h:1188
uint8_t y3
Definition: cinepak.c:42
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
AV_WL32 AV_WL24 AV_WL16 AV_WB32 AV_RB24
Definition: bytestream.h:89
uint16_t id
Definition: cinepak.c:49
int palette_video
Definition: cinepak.c:66
uint8_t y0
Definition: cinepak.c:42
#define AVPALETTE_SIZE
Definition: avcodec.h:3372
8 bit with PIX_FMT_RGB32 palette
Definition: pixfmt.h:75
uint32_t pal[256]
Definition: cinepak.c:71
cvid_codebook v1_codebook[256]
Definition: cinepak.c:53
void * priv_data
Definition: avcodec.h:1531
static int cinepak_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: cinepak.c:420
uint8_t y1
Definition: cinepak.c:42
struct CinepakContext CinepakContext
static av_cold int cinepak_decode_end(AVCodecContext *avctx)
Definition: cinepak.c:459