Libav
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 #include "internal.h"
75 
76 #define PALETTE_COUNT 256
77 #define VQA_HEADER_SIZE 0x2A
78 
79 /* allocate the maximum vector space, regardless of the file version:
80  * (0xFF00 codebook vectors + 0x100 solid pixel vectors) * (4x4 pixels/block) */
81 #define MAX_CODEBOOK_VECTORS 0xFF00
82 #define SOLID_PIXEL_VECTORS 0x100
83 #define MAX_VECTORS (MAX_CODEBOOK_VECTORS + SOLID_PIXEL_VECTORS)
84 #define MAX_CODEBOOK_SIZE (MAX_VECTORS * 4 * 4)
85 
86 #define CBF0_TAG MKBETAG('C', 'B', 'F', '0')
87 #define CBFZ_TAG MKBETAG('C', 'B', 'F', 'Z')
88 #define CBP0_TAG MKBETAG('C', 'B', 'P', '0')
89 #define CBPZ_TAG MKBETAG('C', 'B', 'P', 'Z')
90 #define CPL0_TAG MKBETAG('C', 'P', 'L', '0')
91 #define CPLZ_TAG MKBETAG('C', 'P', 'L', 'Z')
92 #define VPTZ_TAG MKBETAG('V', 'P', 'T', 'Z')
93 
94 typedef struct VqaContext {
95 
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, ret;
125 
126  s->avctx = avctx;
127  avctx->pix_fmt = AV_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 AVERROR(EINVAL);
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  avpriv_report_missing_feature(avctx, "VQA Version %d", s->vqa_version);
143  return AVERROR_PATCHWELCOME;
144  default:
145  avpriv_request_sample(avctx, "VQA Version %i", s->vqa_version);
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 ((ret = ff_set_dimensions(avctx, s->width, s->height)) < 0) {
151  s->width= s->height= 0;
152  return ret;
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 AVERROR_INVALIDDATA;
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 */
174  if (!s->codebook)
175  goto fail;
177  if (!s->next_codebook_buffer)
178  goto fail;
179 
180  /* allocate decode buffer */
181  s->decode_buffer_size = (s->width / s->vector_width) *
182  (s->height / s->vector_height) * 2;
184  if (!s->decode_buffer)
185  goto fail;
186 
187  /* initialize the solid-color vectors */
188  if (s->vector_height == 4) {
189  codebook_index = 0xFF00 * 16;
190  for (i = 0; i < 256; i++)
191  for (j = 0; j < 16; j++)
192  s->codebook[codebook_index++] = i;
193  } else {
194  codebook_index = 0xF00 * 8;
195  for (i = 0; i < 256; i++)
196  for (j = 0; j < 8; j++)
197  s->codebook[codebook_index++] = i;
198  }
200 
201  return 0;
202 fail:
203  av_freep(&s->codebook);
205  av_freep(&s->decode_buffer);
206  return AVERROR(ENOMEM);
207 }
208 
209 #define CHECK_COUNT() \
210  if (dest_index + count > dest_size) { \
211  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
212  av_log(NULL, AV_LOG_ERROR, " VQA video: current dest_index = %d, count = %d, dest_size = %d\n", \
213  dest_index, count, dest_size); \
214  return AVERROR_INVALIDDATA; \
215  }
216 
217 #define CHECK_COPY(idx) \
218  if (idx < 0 || idx + count > dest_size) { \
219  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
220  av_log(NULL, AV_LOG_ERROR, " VQA video: current src_pos = %d, count = %d, dest_size = %d\n", \
221  src_pos, count, dest_size); \
222  return AVERROR_INVALIDDATA; \
223  }
224 
225 
226 static int decode_format80(GetByteContext *gb, int src_size,
227  unsigned char *dest, int dest_size, int check_size) {
228 
229  int dest_index = 0;
230  int count, opcode, start;
231  int src_pos;
232  unsigned char color;
233  int i;
234 
235  start = bytestream2_tell(gb);
236  while (bytestream2_tell(gb) - start < src_size) {
237  opcode = bytestream2_get_byte(gb);
238  av_dlog(NULL, " opcode %02X: ", opcode);
239 
240  /* 0x80 means that frame is finished */
241  if (opcode == 0x80)
242  return 0;
243 
244  if (dest_index >= dest_size) {
245  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: dest_index (%d) exceeded dest_size (%d)\n",
246  dest_index, dest_size);
247  return AVERROR_INVALIDDATA;
248  }
249 
250  if (opcode == 0xFF) {
251 
252  count = bytestream2_get_le16(gb);
253  src_pos = bytestream2_get_le16(gb);
254  av_dlog(NULL, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
255  CHECK_COUNT();
256  CHECK_COPY(src_pos);
257  for (i = 0; i < count; i++)
258  dest[dest_index + i] = dest[src_pos + i];
259  dest_index += count;
260 
261  } else if (opcode == 0xFE) {
262 
263  count = bytestream2_get_le16(gb);
264  color = bytestream2_get_byte(gb);
265  av_dlog(NULL, "(2) set %X bytes to %02X\n", count, color);
266  CHECK_COUNT();
267  memset(&dest[dest_index], color, count);
268  dest_index += count;
269 
270  } else if ((opcode & 0xC0) == 0xC0) {
271 
272  count = (opcode & 0x3F) + 3;
273  src_pos = bytestream2_get_le16(gb);
274  av_dlog(NULL, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
275  CHECK_COUNT();
276  CHECK_COPY(src_pos);
277  for (i = 0; i < count; i++)
278  dest[dest_index + i] = dest[src_pos + i];
279  dest_index += count;
280 
281  } else if (opcode > 0x80) {
282 
283  count = opcode & 0x3F;
284  av_dlog(NULL, "(4) copy %X bytes from source to dest\n", count);
285  CHECK_COUNT();
286  bytestream2_get_buffer(gb, &dest[dest_index], count);
287  dest_index += count;
288 
289  } else {
290 
291  count = ((opcode & 0x70) >> 4) + 3;
292  src_pos = bytestream2_get_byte(gb) | ((opcode & 0x0F) << 8);
293  av_dlog(NULL, "(5) copy %X bytes from relpos %X\n", count, src_pos);
294  CHECK_COUNT();
295  CHECK_COPY(dest_index - src_pos);
296  for (i = 0; i < count; i++)
297  dest[dest_index + i] = dest[dest_index - src_pos + i];
298  dest_index += count;
299  }
300  }
301 
302  /* validate that the entire destination buffer was filled; this is
303  * important for decoding frame maps since each vector needs to have a
304  * codebook entry; it is not important for compressed codebooks because
305  * not every entry needs to be filled */
306  if (check_size)
307  if (dest_index < dest_size)
308  av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: decode finished with dest_index (%d) < dest_size (%d)\n",
309  dest_index, dest_size);
310 
311  return 0; // let's display what we decoded anyway
312 }
313 
314 static int vqa_decode_chunk(VqaContext *s, AVFrame *frame)
315 {
316  unsigned int chunk_type;
317  unsigned int chunk_size;
318  int byte_skip;
319  unsigned int index = 0;
320  int i;
321  unsigned char r, g, b;
322  int index_shift;
323  int res;
324 
325  int cbf0_chunk = -1;
326  int cbfz_chunk = -1;
327  int cbp0_chunk = -1;
328  int cbpz_chunk = -1;
329  int cpl0_chunk = -1;
330  int cplz_chunk = -1;
331  int vptz_chunk = -1;
332 
333  int x, y;
334  int lines = 0;
335  int pixel_ptr;
336  int vector_index = 0;
337  int lobyte = 0;
338  int hibyte = 0;
339  int lobytes = 0;
340  int hibytes = s->decode_buffer_size / 2;
341 
342  /* first, traverse through the frame and find the subchunks */
343  while (bytestream2_get_bytes_left(&s->gb) >= 8) {
344 
345  chunk_type = bytestream2_get_be32u(&s->gb);
346  index = bytestream2_tell(&s->gb);
347  chunk_size = bytestream2_get_be32u(&s->gb);
348 
349  switch (chunk_type) {
350 
351  case CBF0_TAG:
352  cbf0_chunk = index;
353  break;
354 
355  case CBFZ_TAG:
356  cbfz_chunk = index;
357  break;
358 
359  case CBP0_TAG:
360  cbp0_chunk = index;
361  break;
362 
363  case CBPZ_TAG:
364  cbpz_chunk = index;
365  break;
366 
367  case CPL0_TAG:
368  cpl0_chunk = index;
369  break;
370 
371  case CPLZ_TAG:
372  cplz_chunk = index;
373  break;
374 
375  case VPTZ_TAG:
376  vptz_chunk = index;
377  break;
378 
379  default:
380  av_log(s->avctx, AV_LOG_ERROR, " VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",
381  (chunk_type >> 24) & 0xFF,
382  (chunk_type >> 16) & 0xFF,
383  (chunk_type >> 8) & 0xFF,
384  (chunk_type >> 0) & 0xFF,
385  chunk_type);
386  break;
387  }
388 
389  byte_skip = chunk_size & 0x01;
390  bytestream2_skip(&s->gb, chunk_size + byte_skip);
391  }
392 
393  /* next, deal with the palette */
394  if ((cpl0_chunk != -1) && (cplz_chunk != -1)) {
395 
396  /* a chunk should not have both chunk types */
397  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CPL0 and CPLZ chunks\n");
398  return AVERROR_INVALIDDATA;
399  }
400 
401  /* decompress the palette chunk */
402  if (cplz_chunk != -1) {
403 
404 /* yet to be handled */
405 
406  }
407 
408  /* convert the RGB palette into the machine's endian format */
409  if (cpl0_chunk != -1) {
410 
411  bytestream2_seek(&s->gb, cpl0_chunk, SEEK_SET);
412  chunk_size = bytestream2_get_be32(&s->gb);
413  /* sanity check the palette size */
414  if (chunk_size / 3 > 256 || chunk_size > bytestream2_get_bytes_left(&s->gb)) {
415  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found a palette chunk with %d colors\n",
416  chunk_size / 3);
417  return AVERROR_INVALIDDATA;
418  }
419  for (i = 0; i < chunk_size / 3; i++) {
420  /* scale by 4 to transform 6-bit palette -> 8-bit */
421  r = bytestream2_get_byteu(&s->gb) * 4;
422  g = bytestream2_get_byteu(&s->gb) * 4;
423  b = bytestream2_get_byteu(&s->gb) * 4;
424  s->palette[i] = (r << 16) | (g << 8) | (b);
425  }
426  }
427 
428  /* next, look for a full codebook */
429  if ((cbf0_chunk != -1) && (cbfz_chunk != -1)) {
430 
431  /* a chunk should not have both chunk types */
432  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBF0 and CBFZ chunks\n");
433  return AVERROR_INVALIDDATA;
434  }
435 
436  /* decompress the full codebook chunk */
437  if (cbfz_chunk != -1) {
438 
439  bytestream2_seek(&s->gb, cbfz_chunk, SEEK_SET);
440  chunk_size = bytestream2_get_be32(&s->gb);
441  if ((res = decode_format80(&s->gb, chunk_size, s->codebook,
442  s->codebook_size, 0)) < 0)
443  return res;
444  }
445 
446  /* copy a full codebook */
447  if (cbf0_chunk != -1) {
448 
449  bytestream2_seek(&s->gb, cbf0_chunk, SEEK_SET);
450  chunk_size = bytestream2_get_be32(&s->gb);
451  /* sanity check the full codebook size */
452  if (chunk_size > MAX_CODEBOOK_SIZE) {
453  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",
454  chunk_size);
455  return AVERROR_INVALIDDATA;
456  }
457 
458  bytestream2_get_buffer(&s->gb, s->codebook, chunk_size);
459  }
460 
461  /* decode the frame */
462  if (vptz_chunk == -1) {
463 
464  /* something is wrong if there is no VPTZ chunk */
465  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: no VPTZ chunk found\n");
466  return AVERROR_INVALIDDATA;
467  }
468 
469  bytestream2_seek(&s->gb, vptz_chunk, SEEK_SET);
470  chunk_size = bytestream2_get_be32(&s->gb);
471  if ((res = decode_format80(&s->gb, chunk_size,
472  s->decode_buffer, s->decode_buffer_size, 1)) < 0)
473  return res;
474 
475  /* render the final PAL8 frame */
476  if (s->vector_height == 4)
477  index_shift = 4;
478  else
479  index_shift = 3;
480  for (y = 0; y < s->height; y += s->vector_height) {
481  for (x = 0; x < s->width; x += 4, lobytes++, hibytes++) {
482  pixel_ptr = y * frame->linesize[0] + x;
483 
484  /* get the vector index, the method for which varies according to
485  * VQA file version */
486  switch (s->vqa_version) {
487 
488  case 1:
489  lobyte = s->decode_buffer[lobytes * 2];
490  hibyte = s->decode_buffer[(lobytes * 2) + 1];
491  vector_index = ((hibyte << 8) | lobyte) >> 3;
492  vector_index <<= index_shift;
493  lines = s->vector_height;
494  /* uniform color fill - a quick hack */
495  if (hibyte == 0xFF) {
496  while (lines--) {
497  frame->data[0][pixel_ptr + 0] = 255 - lobyte;
498  frame->data[0][pixel_ptr + 1] = 255 - lobyte;
499  frame->data[0][pixel_ptr + 2] = 255 - lobyte;
500  frame->data[0][pixel_ptr + 3] = 255 - lobyte;
501  pixel_ptr += frame->linesize[0];
502  }
503  lines=0;
504  }
505  break;
506 
507  case 2:
508  lobyte = s->decode_buffer[lobytes];
509  hibyte = s->decode_buffer[hibytes];
510  vector_index = (hibyte << 8) | lobyte;
511  vector_index <<= index_shift;
512  lines = s->vector_height;
513  break;
514 
515  case 3:
516 /* not implemented yet */
517  lines = 0;
518  break;
519  }
520 
521  while (lines--) {
522  frame->data[0][pixel_ptr + 0] = s->codebook[vector_index++];
523  frame->data[0][pixel_ptr + 1] = s->codebook[vector_index++];
524  frame->data[0][pixel_ptr + 2] = s->codebook[vector_index++];
525  frame->data[0][pixel_ptr + 3] = s->codebook[vector_index++];
526  pixel_ptr += frame->linesize[0];
527  }
528  }
529  }
530 
531  /* handle partial codebook */
532  if ((cbp0_chunk != -1) && (cbpz_chunk != -1)) {
533  /* a chunk should not have both chunk types */
534  av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBP0 and CBPZ chunks\n");
535  return AVERROR_INVALIDDATA;
536  }
537 
538  if (cbp0_chunk != -1) {
539 
540  bytestream2_seek(&s->gb, cbp0_chunk, SEEK_SET);
541  chunk_size = bytestream2_get_be32(&s->gb);
542 
543  if (chunk_size > MAX_CODEBOOK_SIZE - s->next_codebook_buffer_index) {
544  av_log(s->avctx, AV_LOG_ERROR, "cbp0 chunk too large (%u bytes)\n",
545  chunk_size);
546  return AVERROR_INVALIDDATA;
547  }
548 
549  /* accumulate partial codebook */
551  chunk_size);
552  s->next_codebook_buffer_index += chunk_size;
553 
554  s->partial_countdown--;
555  if (s->partial_countdown == 0) {
556 
557  /* time to replace codebook */
558  memcpy(s->codebook, s->next_codebook_buffer,
560 
561  /* reset accounting */
564  }
565  }
566 
567  if (cbpz_chunk != -1) {
568 
569  bytestream2_seek(&s->gb, cbpz_chunk, SEEK_SET);
570  chunk_size = bytestream2_get_be32(&s->gb);
571 
572  if (chunk_size > MAX_CODEBOOK_SIZE - s->next_codebook_buffer_index) {
573  av_log(s->avctx, AV_LOG_ERROR, "cbpz chunk too large (%u bytes)\n",
574  chunk_size);
575  return AVERROR_INVALIDDATA;
576  }
577 
578  /* accumulate partial codebook */
580  chunk_size);
581  s->next_codebook_buffer_index += chunk_size;
582 
583  s->partial_countdown--;
584  if (s->partial_countdown == 0) {
585  GetByteContext gb;
586 
588  /* decompress codebook */
589  if ((res = decode_format80(&gb, s->next_codebook_buffer_index,
590  s->codebook, s->codebook_size, 0)) < 0)
591  return res;
592 
593  /* reset accounting */
596  }
597  }
598 
599  return 0;
600 }
601 
603  void *data, int *got_frame,
604  AVPacket *avpkt)
605 {
606  VqaContext *s = avctx->priv_data;
607  AVFrame *frame = data;
608  int res;
609 
610  if ((res = ff_get_buffer(avctx, frame, 0)) < 0) {
611  av_log(s->avctx, AV_LOG_ERROR, " VQA Video: get_buffer() failed\n");
612  return res;
613  }
614 
615  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
616  if ((res = vqa_decode_chunk(s, frame)) < 0)
617  return res;
618 
619  /* make the palette available on the way out */
620  memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
621  frame->palette_has_changed = 1;
622 
623  *got_frame = 1;
624 
625  /* report that the buffer was completely consumed */
626  return avpkt->size;
627 }
628 
630 {
631  VqaContext *s = avctx->priv_data;
632 
633  av_freep(&s->codebook);
635  av_freep(&s->decode_buffer);
636 
637  return 0;
638 }
639 
641  .name = "vqavideo",
642  .long_name = NULL_IF_CONFIG_SMALL("Westwood Studios VQA (Vector Quantized Animation) video"),
643  .type = AVMEDIA_TYPE_VIDEO,
644  .id = AV_CODEC_ID_WS_VQA,
645  .priv_data_size = sizeof(VqaContext),
649  .capabilities = CODEC_CAP_DR1,
650 };
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define CPLZ_TAG
Definition: vqavideo.c:91
static int vqa_decode_chunk(VqaContext *s, AVFrame *frame)
Definition: vqavideo.c:314
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
#define VQA_HEADER_SIZE
Definition: vqavideo.c:77
static int check_size(TiffEncoderContext *s, uint64_t need)
Check free space in buffer.
Definition: tiffenc.c:77
misc image utilities
#define CBP0_TAG
Definition: vqavideo.c:88
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:133
int size
Definition: avcodec.h:974
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1270
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:132
#define AV_RL16
Definition: intreadwrite.h:42
int next_codebook_buffer_index
Definition: vqavideo.c:110
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
AVCodec.
Definition: avcodec.h:2812
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define av_cold
Definition: attributes.h:66
#define CHECK_COUNT()
Definition: vqavideo.c:209
int vector_width
Definition: vqavideo.c:103
8 bit with PIX_FMT_RGB32 palette
Definition: pixfmt.h:76
unsigned char * decode_buffer
Definition: vqavideo.c:112
int vqa_version
Definition: vqavideo.c:105
#define b
Definition: input.c:52
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1164
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
int width
Definition: vqavideo.c:101
uint8_t * data
Definition: avcodec.h:973
#define CPL0_TAG
Definition: vqavideo.c:90
#define r
Definition: input.c:51
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int vector_height
Definition: vqavideo.c:104
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:161
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:145
g
Definition: yuv2rgb.c:535
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:260
static int decode_format80(GetByteContext *gb, int src_size, unsigned char *dest, int dest_size, int check_size)
Definition: vqavideo.c:226
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:151
#define CBF0_TAG
Definition: vqavideo.c:86
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2819
unsigned char * codebook
Definition: vqavideo.c:107
#define CBPZ_TAG
Definition: vqavideo.c:89
#define CBFZ_TAG
Definition: vqavideo.c:87
#define PALETTE_COUNT
Definition: vqavideo.c:76
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:185
NULL
Definition: eval.c:55
uint32_t palette[PALETTE_COUNT]
Definition: vqavideo.c:99
Libavcodec external API header.
GetByteContext gb
Definition: vqavideo.c:97
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
int partial_count
Definition: vqavideo.c:117
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:621
int extradata_size
Definition: avcodec.h:1165
int index
Definition: gxfenc.c:72
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:330
int codebook_size
Definition: vqavideo.c:108
#define MAX_CODEBOOK_SIZE
Definition: vqavideo.c:84
int height
Definition: vqavideo.c:102
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
AVCodec ff_vqa_decoder
Definition: vqavideo.c:640
int decode_buffer_size
Definition: vqavideo.c:113
#define CHECK_COPY(idx)
Definition: vqavideo.c:217
common internal api header.
static av_cold int vqa_decode_end(AVCodecContext *avctx)
Definition: vqavideo.c:629
static int vqa_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vqavideo.c:602
int partial_countdown
Definition: vqavideo.c:116
static const uint8_t color[]
Definition: log.c:55
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
void * priv_data
Definition: avcodec.h:1092
static av_cold int vqa_decode_init(AVCodecContext *avctx)
Definition: vqavideo.c:121
unsigned char * next_codebook_buffer
Definition: vqavideo.c:109
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:205
#define VPTZ_TAG
Definition: vqavideo.c:92
AVCodecContext * avctx
Definition: vqavideo.c:96
This structure stores compressed data.
Definition: avcodec.h:950