vqavideo.c
Go to the documentation of this file.
1 /*
2  * Westwood Studios VQA 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 
66 #include <stdio.h>
67 #include <stdlib.h>
68 #include <string.h>
69 
70 #include "libavutil/intreadwrite.h"
71 #include "libavutil/imgutils.h"
72 #include "avcodec.h"
73 #include "bytestream.h"
74 
75 #define PALETTE_COUNT 256
76 #define VQA_HEADER_SIZE 0x2A
77 
78 /* allocate the maximum vector space, regardless of the file version:
79  * (0xFF00 codebook vectors + 0x100 solid pixel vectors) * (4x4 pixels/block) */
80 #define MAX_CODEBOOK_VECTORS 0xFF00
81 #define SOLID_PIXEL_VECTORS 0x100
82 #define MAX_VECTORS (MAX_CODEBOOK_VECTORS + SOLID_PIXEL_VECTORS)
83 #define MAX_CODEBOOK_SIZE (MAX_VECTORS * 4 * 4)
84 
85 #define CBF0_TAG MKBETAG('C', 'B', 'F', '0')
86 #define CBFZ_TAG MKBETAG('C', 'B', 'F', 'Z')
87 #define CBP0_TAG MKBETAG('C', 'B', 'P', '0')
88 #define CBPZ_TAG MKBETAG('C', 'B', 'P', 'Z')
89 #define CPL0_TAG MKBETAG('C', 'P', 'L', '0')
90 #define CPLZ_TAG MKBETAG('C', 'P', 'L', 'Z')
91 #define VPTZ_TAG MKBETAG('V', 'P', 'T', 'Z')
92 
93 typedef struct VqaContext {
94 
98 
100 
101  int width; /* width of a frame */
102  int height; /* height of a frame */
103  int vector_width; /* width of individual vector */
104  int vector_height; /* height of individual vector */
105  int vqa_version; /* this should be either 1, 2 or 3 */
106 
107  unsigned char *codebook; /* the current codebook */
109  unsigned char *next_codebook_buffer; /* accumulator for next codebook */
111 
112  unsigned char *decode_buffer;
114 
115  /* number of frames to go before replacing codebook */
118 
119 } VqaContext;
120 
122 {
123  VqaContext *s = avctx->priv_data;
124  int i, j, codebook_index;
125 
126  s->avctx = avctx;
127  avctx->pix_fmt = PIX_FMT_PAL8;
128 
129  /* make sure the extradata made it */
130  if (s->avctx->extradata_size != VQA_HEADER_SIZE) {
131  av_log(s->avctx, AV_LOG_ERROR, " VQA video: expected extradata size of %d\n", VQA_HEADER_SIZE);
132  return -1;
133  }
134 
135  /* load up the VQA parameters from the header */
136  s->vqa_version = s->avctx->extradata[0];
137  switch (s->vqa_version) {
138  case 1:
139  case 2:
140  break;
141  case 3:
142  av_log_missing_feature(avctx, "VQA Version 3", 0);
143  return AVERROR_PATCHWELCOME;
144  default:
145  av_log_missing_feature(avctx, "VQA Version", 1);
146  return AVERROR_PATCHWELCOME;
147  }
148  s->width = AV_RL16(&s->avctx->extradata[6]);
149  s->height = AV_RL16(&s->avctx->extradata[8]);
150  if(av_image_check_size(s->width, s->height, 0, avctx)){
151  s->width= s->height= 0;
152  return -1;
153  }
154  s->vector_width = s->avctx->extradata[10];
155  s->vector_height = s->avctx->extradata[11];
157 
158  /* the vector dimensions have to meet very stringent requirements */
159  if ((s->vector_width != 4) ||
160  ((s->vector_height != 2) && (s->vector_height != 4))) {
161  /* return without further initialization */
162  return -1;
163  }
164 
165  if (s->width & (s->vector_width - 1) ||
166  s->height & (s->vector_height - 1)) {
167  av_log(avctx, AV_LOG_ERROR, "Image size not multiple of block size\n");
168  return AVERROR_INVALIDDATA;
169  }
170 
171  /* allocate codebooks */
175 
176  /* initialize the solid-color vectors */
177  if (s->vector_height == 4) {
178  codebook_index = 0xFF00 * 16;
179  for (i = 0; i < 256; i++)
180  for (j = 0; j < 16; j++)
181  s->codebook[codebook_index++] = i;
182  } else {
183  codebook_index = 0xF00 * 8;
184  for (i = 0; i < 256; i++)
185  for (j = 0; j < 8; j++)
186  s->codebook[codebook_index++] = i;
187  }
189 
190  /* allocate decode buffer */
191  s->decode_buffer_size = (s->width / s->vector_width) *
192  (s->height / s->vector_height) * 2;
194 
195  s->frame.data[0] = NULL;
196 
197  return 0;
198 }
199 
200 #define CHECK_COUNT() \
201  if (dest_index + count > dest_size) { \
202  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
203  av_log(NULL, AV_LOG_ERROR, " VQA video: current dest_index = %d, count = %d, dest_size = %d\n", \
204  dest_index, count, dest_size); \
205  return AVERROR_INVALIDDATA; \
206  }
207 
208 #define CHECK_COPY(idx) \
209  if (idx < 0 || idx + count > dest_size) { \
210  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
211  av_log(NULL, AV_LOG_ERROR, " VQA video: current src_pos = %d, count = %d, dest_size = %d\n", \
212  src_pos, count, dest_size); \
213  return AVERROR_INVALIDDATA; \
214  }
215 
216 
217 static int decode_format80(GetByteContext *gb, int src_size,
218  unsigned char *dest, int dest_size, int check_size) {
219 
220  int dest_index = 0;
221  int count, opcode, start;
222  int src_pos;
223  unsigned char color;
224  int i;
225 
226  start = bytestream2_tell(gb);
227  while (bytestream2_tell(gb) - start < src_size) {
228  opcode = bytestream2_get_byte(gb);
229  av_dlog(NULL, " opcode %02X: ", opcode);
230 
231  /* 0x80 means that frame is finished */
232  if (opcode == 0x80)
233  return 0;
234 
235  if (dest_index >= dest_size) {
236  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: dest_index (%d) exceeded dest_size (%d)\n",
237  dest_index, dest_size);
238  return AVERROR_INVALIDDATA;
239  }
240 
241  if (opcode == 0xFF) {
242 
243  count = bytestream2_get_le16(gb);
244  src_pos = bytestream2_get_le16(gb);
245  av_dlog(NULL, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
246  CHECK_COUNT();
247  CHECK_COPY(src_pos);
248  for (i = 0; i < count; i++)
249  dest[dest_index + i] = dest[src_pos + i];
250  dest_index += count;
251 
252  } else if (opcode == 0xFE) {
253 
254  count = bytestream2_get_le16(gb);
255  color = bytestream2_get_byte(gb);
256  av_dlog(NULL, "(2) set %X bytes to %02X\n", count, color);
257  CHECK_COUNT();
258  memset(&dest[dest_index], color, count);
259  dest_index += count;
260 
261  } else if ((opcode & 0xC0) == 0xC0) {
262 
263  count = (opcode & 0x3F) + 3;
264  src_pos = bytestream2_get_le16(gb);
265  av_dlog(NULL, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
266  CHECK_COUNT();
267  CHECK_COPY(src_pos);
268  for (i = 0; i < count; i++)
269  dest[dest_index + i] = dest[src_pos + i];
270  dest_index += count;
271 
272  } else if (opcode > 0x80) {
273 
274  count = opcode & 0x3F;
275  av_dlog(NULL, "(4) copy %X bytes from source to dest\n", count);
276  CHECK_COUNT();
277  bytestream2_get_buffer(gb, &dest[dest_index], count);
278  dest_index += count;
279 
280  } else {
281 
282  count = ((opcode & 0x70) >> 4) + 3;
283  src_pos = bytestream2_get_byte(gb) | ((opcode & 0x0F) << 8);
284  av_dlog(NULL, "(5) copy %X bytes from relpos %X\n", count, src_pos);
285  CHECK_COUNT();
286  CHECK_COPY(dest_index - src_pos);
287  for (i = 0; i < count; i++)
288  dest[dest_index + i] = dest[dest_index - src_pos + i];
289  dest_index += count;
290  }
291  }
292 
293  /* validate that the entire destination buffer was filled; this is
294  * important for decoding frame maps since each vector needs to have a
295  * codebook entry; it is not important for compressed codebooks because
296  * not every entry needs to be filled */
297  if (check_size)
298  if (dest_index < dest_size)
299  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: decode finished with dest_index (%d) < dest_size (%d)\n",
300  dest_index, dest_size);
301 
302  return 0; // let's display what we decoded anyway
303 }
304 
306 {
307  unsigned int chunk_type;
308  unsigned int chunk_size;
309  int byte_skip;
310  unsigned int index = 0;
311  int i;
312  unsigned char r, g, b;
313  int index_shift;
314  int res;
315 
316  int cbf0_chunk = -1;
317  int cbfz_chunk = -1;
318  int cbp0_chunk = -1;
319  int cbpz_chunk = -1;
320  int cpl0_chunk = -1;
321  int cplz_chunk = -1;
322  int vptz_chunk = -1;
323 
324  int x, y;
325  int lines = 0;
326  int pixel_ptr;
327  int vector_index = 0;
328  int lobyte = 0;
329  int hibyte = 0;
330  int lobytes = 0;
331  int hibytes = s->decode_buffer_size / 2;
332 
333  /* first, traverse through the frame and find the subchunks */
334  while (bytestream2_get_bytes_left(&s->gb) >= 8) {
335 
336  chunk_type = bytestream2_get_be32u(&s->gb);
337  index = bytestream2_tell(&s->gb);
338  chunk_size = bytestream2_get_be32u(&s->gb);
339 
340  switch (chunk_type) {
341 
342  case CBF0_TAG:
343  cbf0_chunk = index;
344  break;
345 
346  case CBFZ_TAG:
347  cbfz_chunk = index;
348  break;
349 
350  case CBP0_TAG:
351  cbp0_chunk = index;
352  break;
353 
354  case CBPZ_TAG:
355  cbpz_chunk = index;
356  break;
357 
358  case CPL0_TAG:
359  cpl0_chunk = index;
360  break;
361 
362  case CPLZ_TAG:
363  cplz_chunk = index;
364  break;
365 
366  case VPTZ_TAG:
367  vptz_chunk = index;
368  break;
369 
370  default:
371  av_log(s->avctx, AV_LOG_ERROR, " VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",
372  (chunk_type >> 24) & 0xFF,
373  (chunk_type >> 16) & 0xFF,
374  (chunk_type >> 8) & 0xFF,
375  (chunk_type >> 0) & 0xFF,
376  chunk_type);
377  break;
378  }
379 
380  byte_skip = chunk_size & 0x01;
381  bytestream2_skip(&s->gb, chunk_size + byte_skip);
382  }
383 
384  /* next, deal with the palette */
385  if ((cpl0_chunk != -1) && (cplz_chunk != -1)) {
386 
387  /* a chunk should not have both chunk types */
388  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CPL0 and CPLZ chunks\n");
389  return AVERROR_INVALIDDATA;
390  }
391 
392  /* decompress the palette chunk */
393  if (cplz_chunk != -1) {
394 
395 /* yet to be handled */
396 
397  }
398 
399  /* convert the RGB palette into the machine's endian format */
400  if (cpl0_chunk != -1) {
401 
402  bytestream2_seek(&s->gb, cpl0_chunk, SEEK_SET);
403  chunk_size = bytestream2_get_be32(&s->gb);
404  /* sanity check the palette size */
405  if (chunk_size / 3 > 256 || chunk_size > bytestream2_get_bytes_left(&s->gb)) {
406  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found a palette chunk with %d colors\n",
407  chunk_size / 3);
408  return AVERROR_INVALIDDATA;
409  }
410  for (i = 0; i < chunk_size / 3; i++) {
411  /* scale by 4 to transform 6-bit palette -> 8-bit */
412  r = bytestream2_get_byteu(&s->gb) * 4;
413  g = bytestream2_get_byteu(&s->gb) * 4;
414  b = bytestream2_get_byteu(&s->gb) * 4;
415  s->palette[i] = (r << 16) | (g << 8) | (b);
416  }
417  }
418 
419  /* next, look for a full codebook */
420  if ((cbf0_chunk != -1) && (cbfz_chunk != -1)) {
421 
422  /* a chunk should not have both chunk types */
423  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBF0 and CBFZ chunks\n");
424  return AVERROR_INVALIDDATA;
425  }
426 
427  /* decompress the full codebook chunk */
428  if (cbfz_chunk != -1) {
429 
430  bytestream2_seek(&s->gb, cbfz_chunk, SEEK_SET);
431  chunk_size = bytestream2_get_be32(&s->gb);
432  if ((res = decode_format80(&s->gb, chunk_size, s->codebook,
433  s->codebook_size, 0)) < 0)
434  return res;
435  }
436 
437  /* copy a full codebook */
438  if (cbf0_chunk != -1) {
439 
440  bytestream2_seek(&s->gb, cbf0_chunk, SEEK_SET);
441  chunk_size = bytestream2_get_be32(&s->gb);
442  /* sanity check the full codebook size */
443  if (chunk_size > MAX_CODEBOOK_SIZE) {
444  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",
445  chunk_size);
446  return AVERROR_INVALIDDATA;
447  }
448 
449  bytestream2_get_buffer(&s->gb, s->codebook, chunk_size);
450  }
451 
452  /* decode the frame */
453  if (vptz_chunk == -1) {
454 
455  /* something is wrong if there is no VPTZ chunk */
456  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: no VPTZ chunk found\n");
457  return AVERROR_INVALIDDATA;
458  }
459 
460  bytestream2_seek(&s->gb, vptz_chunk, SEEK_SET);
461  chunk_size = bytestream2_get_be32(&s->gb);
462  if ((res = decode_format80(&s->gb, chunk_size,
463  s->decode_buffer, s->decode_buffer_size, 1)) < 0)
464  return res;
465 
466  /* render the final PAL8 frame */
467  if (s->vector_height == 4)
468  index_shift = 4;
469  else
470  index_shift = 3;
471  for (y = 0; y < s->frame.linesize[0] * s->height;
472  y += s->frame.linesize[0] * s->vector_height) {
473 
474  for (x = y; x < y + s->width; x += 4, lobytes++, hibytes++) {
475  pixel_ptr = x;
476 
477  /* get the vector index, the method for which varies according to
478  * VQA file version */
479  switch (s->vqa_version) {
480 
481  case 1:
482  lobyte = s->decode_buffer[lobytes * 2];
483  hibyte = s->decode_buffer[(lobytes * 2) + 1];
484  vector_index = ((hibyte << 8) | lobyte) >> 3;
485  vector_index <<= index_shift;
486  lines = s->vector_height;
487  /* uniform color fill - a quick hack */
488  if (hibyte == 0xFF) {
489  while (lines--) {
490  s->frame.data[0][pixel_ptr + 0] = 255 - lobyte;
491  s->frame.data[0][pixel_ptr + 1] = 255 - lobyte;
492  s->frame.data[0][pixel_ptr + 2] = 255 - lobyte;
493  s->frame.data[0][pixel_ptr + 3] = 255 - lobyte;
494  pixel_ptr += s->frame.linesize[0];
495  }
496  lines=0;
497  }
498  break;
499 
500  case 2:
501  lobyte = s->decode_buffer[lobytes];
502  hibyte = s->decode_buffer[hibytes];
503  vector_index = (hibyte << 8) | lobyte;
504  vector_index <<= index_shift;
505  lines = s->vector_height;
506  break;
507 
508  case 3:
509 /* not implemented yet */
510  lines = 0;
511  break;
512  }
513 
514  while (lines--) {
515  s->frame.data[0][pixel_ptr + 0] = s->codebook[vector_index++];
516  s->frame.data[0][pixel_ptr + 1] = s->codebook[vector_index++];
517  s->frame.data[0][pixel_ptr + 2] = s->codebook[vector_index++];
518  s->frame.data[0][pixel_ptr + 3] = s->codebook[vector_index++];
519  pixel_ptr += s->frame.linesize[0];
520  }
521  }
522  }
523 
524  /* handle partial codebook */
525  if ((cbp0_chunk != -1) && (cbpz_chunk != -1)) {
526  /* a chunk should not have both chunk types */
527  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBP0 and CBPZ chunks\n");
528  return AVERROR_INVALIDDATA;
529  }
530 
531  if (cbp0_chunk != -1) {
532 
533  bytestream2_seek(&s->gb, cbp0_chunk, SEEK_SET);
534  chunk_size = bytestream2_get_be32(&s->gb);
535 
536  if (chunk_size > MAX_CODEBOOK_SIZE - s->next_codebook_buffer_index) {
537  av_log(s->avctx, AV_LOG_ERROR, "cbp0 chunk too large (%u bytes)\n",
538  chunk_size);
539  return AVERROR_INVALIDDATA;
540  }
541 
542  /* accumulate partial codebook */
544  chunk_size);
545  s->next_codebook_buffer_index += chunk_size;
546 
547  s->partial_countdown--;
548  if (s->partial_countdown == 0) {
549 
550  /* time to replace codebook */
551  memcpy(s->codebook, s->next_codebook_buffer,
553 
554  /* reset accounting */
557  }
558  }
559 
560  if (cbpz_chunk != -1) {
561 
562  bytestream2_seek(&s->gb, cbpz_chunk, SEEK_SET);
563  chunk_size = bytestream2_get_be32(&s->gb);
564 
565  if (chunk_size > MAX_CODEBOOK_SIZE - s->next_codebook_buffer_index) {
566  av_log(s->avctx, AV_LOG_ERROR, "cbpz chunk too large (%u bytes)\n",
567  chunk_size);
568  return AVERROR_INVALIDDATA;
569  }
570 
571  /* accumulate partial codebook */
573  chunk_size);
574  s->next_codebook_buffer_index += chunk_size;
575 
576  s->partial_countdown--;
577  if (s->partial_countdown == 0) {
578  GetByteContext gb;
579 
581  /* decompress codebook */
582  if ((res = decode_format80(&gb, s->next_codebook_buffer_index,
583  s->codebook, s->codebook_size, 0)) < 0)
584  return res;
585 
586  /* reset accounting */
589  }
590  }
591 
592  return 0;
593 }
594 
596  void *data, int *data_size,
597  AVPacket *avpkt)
598 {
599  VqaContext *s = avctx->priv_data;
600  int res;
601 
602  if (s->frame.data[0])
603  avctx->release_buffer(avctx, &s->frame);
604 
605  if (avctx->get_buffer(avctx, &s->frame)) {
606  av_log(s->avctx, AV_LOG_ERROR, " VQA Video: get_buffer() failed\n");
607  return -1;
608  }
609 
610  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
611  if ((res = vqa_decode_chunk(s)) < 0)
612  return res;
613 
614  /* make the palette available on the way out */
615  memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
616  s->frame.palette_has_changed = 1;
617 
618  *data_size = sizeof(AVFrame);
619  *(AVFrame*)data = s->frame;
620 
621  /* report that the buffer was completely consumed */
622  return avpkt->size;
623 }
624 
626 {
627  VqaContext *s = avctx->priv_data;
628 
629  av_free(s->codebook);
632 
633  if (s->frame.data[0])
634  avctx->release_buffer(avctx, &s->frame);
635 
636  return 0;
637 }
638 
640  .name = "vqavideo",
641  .type = AVMEDIA_TYPE_VIDEO,
642  .id = CODEC_ID_WS_VQA,
643  .priv_data_size = sizeof(VqaContext),
647  .capabilities = CODEC_CAP_DR1,
648  .long_name = NULL_IF_CONFIG_SMALL("Westwood Studios VQA (Vector Quantized Animation) video"),
649 };