cosmetics: Align codec declarations
[libav.git] / libavcodec / vqavideo.c
CommitLineData
6955a882
MM
1/*
2 * Westwood Studios VQA Video Decoder
3 * Copyright (C) 2003 the ffmpeg project
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
6955a882
MM
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
6955a882 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
6955a882
MM
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
6955a882
MM
20 */
21
22/**
ba87f080 23 * @file
ad4cd0c2
DB
24 * VQA Video Decoder
25 * @author Mike Melanson (melanson@pcisys.net)
26 * @see http://wiki.multimedia.cx/index.php?title=VQA
6955a882 27 *
cafa66af
MM
28 * The VQA video decoder outputs PAL8 or RGB555 colorspace data, depending
29 * on the type of data in the file.
6955a882
MM
30 *
31 * This decoder needs the 42-byte VQHD header from the beginning
32 * of the VQA file passed through the extradata field. The VQHD header
33 * is laid out as:
34 *
35 * bytes 0-3 chunk fourcc: 'VQHD'
36 * bytes 4-7 chunk size in big-endian format, should be 0x0000002A
cafa66af 37 * bytes 8-49 VQHD chunk data
6955a882 38 *
cafa66af 39 * Bytes 8-49 are what this decoder expects to see.
6955a882
MM
40 *
41 * Briefly, VQA is a vector quantized animation format that operates in a
cafa66af 42 * VGA palettized colorspace. It operates on pixel vectors (blocks)
6955a882
MM
43 * of either 4x2 or 4x4 in size. Compressed VQA chunks can contain vector
44 * codebooks, palette information, and code maps for rendering vectors onto
45 * frames. Any of these components can also be compressed with a run-length
46 * encoding (RLE) algorithm commonly referred to as "format80".
47 *
48 * VQA takes a novel approach to rate control. Each group of n frames
49 * (usually, n = 8) relies on a different vector codebook. Rather than
50 * transporting an entire codebook every 8th frame, the new codebook is
51 * broken up into 8 pieces and sent along with the compressed video chunks
52 * for each of the 8 frames preceding the 8 frames which require the
53 * codebook. A full codebook is also sent on the very first frame of a
54 * file. This is an interesting technique, although it makes random file
55 * seeking difficult despite the fact that the frames are all intracoded.
56 *
f4433de9 57 * V1,2 VQA uses 12-bit codebook indexes. If the 12-bit indexes were
6955a882
MM
58 * packed into bytes and then RLE compressed, bytewise, the results would
59 * be poor. That is why the coding method divides each index into 2 parts,
cafa66af 60 * the top 4 bits and the bottom 8 bits, then RL encodes the 4-bit pieces
6955a882
MM
61 * together and the 8-bit pieces together. If most of the vectors are
62 * clustered into one group of 256 vectors, most of the 4-bit index pieces
63 * should be the same.
64 */
65
66#include <stdio.h>
67#include <stdlib.h>
68#include <string.h>
6955a882 69
6a5d31ac 70#include "libavutil/intreadwrite.h"
737eb597 71#include "libavutil/imgutils.h"
6955a882 72#include "avcodec.h"
5a3a906b 73#include "bytestream.h"
6955a882
MM
74
75#define PALETTE_COUNT 256
76#define VQA_HEADER_SIZE 0x2A
6955a882 77
cafa66af
MM
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)
6955a882 84
3a278992
MM
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')
6955a882 92
6955a882
MM
93typedef struct VqaContext {
94
95 AVCodecContext *avctx;
6955a882 96 AVFrame frame;
5a3a906b 97 GetByteContext gb;
6955a882 98
3129f3bd 99 uint32_t palette[PALETTE_COUNT];
6955a882
MM
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 */
cafa66af 108 int codebook_size;
6955a882
MM
109 unsigned char *next_codebook_buffer; /* accumulator for next codebook */
110 int next_codebook_buffer_index;
111
112 unsigned char *decode_buffer;
113 int decode_buffer_size;
114
115 /* number of frames to go before replacing codebook */
116 int partial_countdown;
117 int partial_count;
118
119} VqaContext;
120
98a6fff9 121static av_cold int vqa_decode_init(AVCodecContext *avctx)
6955a882 122{
e4141433 123 VqaContext *s = avctx->priv_data;
cea96420 124 int i, j, codebook_index;
6955a882
MM
125
126 s->avctx = avctx;
127 avctx->pix_fmt = PIX_FMT_PAL8;
6955a882
MM
128
129 /* make sure the extradata made it */
130 if (s->avctx->extradata_size != VQA_HEADER_SIZE) {
9b879566 131 av_log(s->avctx, AV_LOG_ERROR, " VQA video: expected extradata size of %d\n", VQA_HEADER_SIZE);
6955a882
MM
132 return -1;
133 }
134
135 /* load up the VQA parameters from the header */
5a3a906b
PM
136 s->vqa_version = s->avctx->extradata[0];
137 s->width = AV_RL16(&s->avctx->extradata[6]);
138 s->height = AV_RL16(&s->avctx->extradata[8]);
e16f217c 139 if(av_image_check_size(s->width, s->height, 0, avctx)){
0ecca7a4
MN
140 s->width= s->height= 0;
141 return -1;
142 }
5a3a906b
PM
143 s->vector_width = s->avctx->extradata[10];
144 s->vector_height = s->avctx->extradata[11];
145 s->partial_count = s->partial_countdown = s->avctx->extradata[13];
6955a882
MM
146
147 /* the vector dimensions have to meet very stringent requirements */
148 if ((s->vector_width != 4) ||
149 ((s->vector_height != 2) && (s->vector_height != 4))) {
150 /* return without further initialization */
151 return -1;
152 }
153
154 /* allocate codebooks */
cafa66af
MM
155 s->codebook_size = MAX_CODEBOOK_SIZE;
156 s->codebook = av_malloc(s->codebook_size);
341404f7
PM
157 if (!s->codebook)
158 goto fail;
cafa66af 159 s->next_codebook_buffer = av_malloc(s->codebook_size);
341404f7
PM
160 if (!s->next_codebook_buffer)
161 goto fail;
162
163 /* allocate decode buffer */
164 s->decode_buffer_size = (s->width / s->vector_width) *
165 (s->height / s->vector_height) * 2;
166 s->decode_buffer = av_malloc(s->decode_buffer_size);
167 if (!s->decode_buffer)
168 goto fail;
cafa66af
MM
169
170 /* initialize the solid-color vectors */
171 if (s->vector_height == 4) {
172 codebook_index = 0xFF00 * 16;
173 for (i = 0; i < 256; i++)
174 for (j = 0; j < 16; j++)
175 s->codebook[codebook_index++] = i;
6955a882 176 } else {
cafa66af
MM
177 codebook_index = 0xF00 * 8;
178 for (i = 0; i < 256; i++)
179 for (j = 0; j < 8; j++)
180 s->codebook[codebook_index++] = i;
6955a882
MM
181 }
182 s->next_codebook_buffer_index = 0;
183
6955a882
MM
184 s->frame.data[0] = NULL;
185
186 return 0;
341404f7
PM
187fail:
188 av_freep(&s->codebook);
189 av_freep(&s->next_codebook_buffer);
190 av_freep(&s->decode_buffer);
191 return AVERROR(ENOMEM);
6955a882
MM
192}
193
194#define CHECK_COUNT() \
195 if (dest_index + count > dest_size) { \
9b879566
MB
196 av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
197 av_log(NULL, AV_LOG_ERROR, " VQA video: current dest_index = %d, count = %d, dest_size = %d\n", \
6955a882 198 dest_index, count, dest_size); \
5a3a906b 199 return AVERROR_INVALIDDATA; \
6955a882
MM
200 }
201
5a3a906b
PM
202#define CHECK_COPY(idx) \
203 if (idx < 0 || idx + count > dest_size) { \
204 av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: next op would overflow dest_index\n"); \
205 av_log(NULL, AV_LOG_ERROR, " VQA video: current src_pos = %d, count = %d, dest_size = %d\n", \
206 src_pos, count, dest_size); \
207 return AVERROR_INVALIDDATA; \
208 }
209
210
211static int decode_format80(GetByteContext *gb, int src_size,
cafa66af 212 unsigned char *dest, int dest_size, int check_size) {
6955a882 213
6955a882 214 int dest_index = 0;
5a3a906b 215 int count, opcode, start;
6955a882
MM
216 int src_pos;
217 unsigned char color;
218 int i;
219
5a3a906b
PM
220 start = bytestream2_tell(gb);
221 while (bytestream2_tell(gb) - start < src_size) {
222 opcode = bytestream2_get_byte(gb);
223 av_dlog(NULL, " opcode %02X: ", opcode);
6955a882
MM
224
225 /* 0x80 means that frame is finished */
5a3a906b
PM
226 if (opcode == 0x80)
227 return 0;
6955a882
MM
228
229 if (dest_index >= dest_size) {
9b879566 230 av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: dest_index (%d) exceeded dest_size (%d)\n",
6955a882 231 dest_index, dest_size);
5a3a906b 232 return AVERROR_INVALIDDATA;
6955a882
MM
233 }
234
5a3a906b 235 if (opcode == 0xFF) {
6955a882 236
5a3a906b
PM
237 count = bytestream2_get_le16(gb);
238 src_pos = bytestream2_get_le16(gb);
df96f22d 239 av_dlog(NULL, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
6955a882 240 CHECK_COUNT();
5a3a906b 241 CHECK_COPY(src_pos);
6955a882
MM
242 for (i = 0; i < count; i++)
243 dest[dest_index + i] = dest[src_pos + i];
244 dest_index += count;
245
5a3a906b 246 } else if (opcode == 0xFE) {
6955a882 247
5a3a906b
PM
248 count = bytestream2_get_le16(gb);
249 color = bytestream2_get_byte(gb);
df96f22d 250 av_dlog(NULL, "(2) set %X bytes to %02X\n", count, color);
6955a882
MM
251 CHECK_COUNT();
252 memset(&dest[dest_index], color, count);
253 dest_index += count;
254
5a3a906b 255 } else if ((opcode & 0xC0) == 0xC0) {
6955a882 256
5a3a906b
PM
257 count = (opcode & 0x3F) + 3;
258 src_pos = bytestream2_get_le16(gb);
df96f22d 259 av_dlog(NULL, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
6955a882 260 CHECK_COUNT();
5a3a906b 261 CHECK_COPY(src_pos);
6955a882
MM
262 for (i = 0; i < count; i++)
263 dest[dest_index + i] = dest[src_pos + i];
264 dest_index += count;
265
5a3a906b 266 } else if (opcode > 0x80) {
6955a882 267
5a3a906b 268 count = opcode & 0x3F;
df96f22d 269 av_dlog(NULL, "(4) copy %X bytes from source to dest\n", count);
6955a882 270 CHECK_COUNT();
5a3a906b 271 bytestream2_get_buffer(gb, &dest[dest_index], count);
6955a882
MM
272 dest_index += count;
273
274 } else {
275
5a3a906b
PM
276 count = ((opcode & 0x70) >> 4) + 3;
277 src_pos = bytestream2_get_byte(gb) | ((opcode & 0x0F) << 8);
df96f22d 278 av_dlog(NULL, "(5) copy %X bytes from relpos %X\n", count, src_pos);
6955a882 279 CHECK_COUNT();
5a3a906b 280 CHECK_COPY(dest_index - src_pos);
6955a882
MM
281 for (i = 0; i < count; i++)
282 dest[dest_index + i] = dest[dest_index - src_pos + i];
283 dest_index += count;
284 }
285 }
286
cafa66af
MM
287 /* validate that the entire destination buffer was filled; this is
288 * important for decoding frame maps since each vector needs to have a
289 * codebook entry; it is not important for compressed codebooks because
290 * not every entry needs to be filled */
291 if (check_size)
292 if (dest_index < dest_size)
9b879566 293 av_log(NULL, AV_LOG_ERROR, " VQA video: decode_format80 problem: decode finished with dest_index (%d) < dest_size (%d)\n",
cafa66af 294 dest_index, dest_size);
5a3a906b
PM
295
296 return 0; // let's display what we decoded anyway
6955a882
MM
297}
298
5a3a906b 299static int vqa_decode_chunk(VqaContext *s)
6955a882 300{
6955a882
MM
301 unsigned int chunk_type;
302 unsigned int chunk_size;
303 int byte_skip;
304 unsigned int index = 0;
305 int i;
306 unsigned char r, g, b;
b3a5d003 307 int index_shift;
5a3a906b 308 int res;
6955a882
MM
309
310 int cbf0_chunk = -1;
311 int cbfz_chunk = -1;
312 int cbp0_chunk = -1;
313 int cbpz_chunk = -1;
314 int cpl0_chunk = -1;
315 int cplz_chunk = -1;
316 int vptz_chunk = -1;
317
318 int x, y;
319 int lines = 0;
320 int pixel_ptr;
321 int vector_index = 0;
322 int lobyte = 0;
323 int hibyte = 0;
324 int lobytes = 0;
325 int hibytes = s->decode_buffer_size / 2;
326
6955a882 327 /* first, traverse through the frame and find the subchunks */
5a3a906b 328 while (bytestream2_get_bytes_left(&s->gb) >= 8) {
6955a882 329
5a3a906b
PM
330 chunk_type = bytestream2_get_be32u(&s->gb);
331 index = bytestream2_tell(&s->gb);
332 chunk_size = bytestream2_get_be32u(&s->gb);
6955a882
MM
333
334 switch (chunk_type) {
335
336 case CBF0_TAG:
337 cbf0_chunk = index;
338 break;
339
340 case CBFZ_TAG:
341 cbfz_chunk = index;
342 break;
343
344 case CBP0_TAG:
345 cbp0_chunk = index;
346 break;
347
348 case CBPZ_TAG:
349 cbpz_chunk = index;
350 break;
351
352 case CPL0_TAG:
353 cpl0_chunk = index;
354 break;
355
356 case CPLZ_TAG:
357 cplz_chunk = index;
358 break;
359
360 case VPTZ_TAG:
361 vptz_chunk = index;
362 break;
363
364 default:
9b879566 365 av_log(s->avctx, AV_LOG_ERROR, " VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",
6955a882
MM
366 (chunk_type >> 24) & 0xFF,
367 (chunk_type >> 16) & 0xFF,
368 (chunk_type >> 8) & 0xFF,
369 (chunk_type >> 0) & 0xFF,
370 chunk_type);
371 break;
372 }
373
374 byte_skip = chunk_size & 0x01;
5a3a906b 375 bytestream2_skip(&s->gb, chunk_size + byte_skip);
6955a882
MM
376 }
377
378 /* next, deal with the palette */
379 if ((cpl0_chunk != -1) && (cplz_chunk != -1)) {
380
381 /* a chunk should not have both chunk types */
9b879566 382 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CPL0 and CPLZ chunks\n");
5a3a906b 383 return AVERROR_INVALIDDATA;
6955a882
MM
384 }
385
386 /* decompress the palette chunk */
387 if (cplz_chunk != -1) {
388
389/* yet to be handled */
390
391 }
392
393 /* convert the RGB palette into the machine's endian format */
394 if (cpl0_chunk != -1) {
395
5a3a906b
PM
396 bytestream2_seek(&s->gb, cpl0_chunk, SEEK_SET);
397 chunk_size = bytestream2_get_be32(&s->gb);
6955a882 398 /* sanity check the palette size */
75d79752 399 if (chunk_size / 3 > 256 || chunk_size > bytestream2_get_bytes_left(&s->gb)) {
9b879566 400 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found a palette chunk with %d colors\n",
6955a882 401 chunk_size / 3);
5a3a906b 402 return AVERROR_INVALIDDATA;
6955a882 403 }
6955a882
MM
404 for (i = 0; i < chunk_size / 3; i++) {
405 /* scale by 4 to transform 6-bit palette -> 8-bit */
5a3a906b
PM
406 r = bytestream2_get_byteu(&s->gb) * 4;
407 g = bytestream2_get_byteu(&s->gb) * 4;
408 b = bytestream2_get_byteu(&s->gb) * 4;
2a2bbcb0 409 s->palette[i] = (r << 16) | (g << 8) | (b);
6955a882
MM
410 }
411 }
412
413 /* next, look for a full codebook */
414 if ((cbf0_chunk != -1) && (cbfz_chunk != -1)) {
415
416 /* a chunk should not have both chunk types */
9b879566 417 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBF0 and CBFZ chunks\n");
5a3a906b 418 return AVERROR_INVALIDDATA;
6955a882
MM
419 }
420
cafa66af 421 /* decompress the full codebook chunk */
6955a882
MM
422 if (cbfz_chunk != -1) {
423
5a3a906b
PM
424 bytestream2_seek(&s->gb, cbfz_chunk, SEEK_SET);
425 chunk_size = bytestream2_get_be32(&s->gb);
426 if ((res = decode_format80(&s->gb, chunk_size, s->codebook,
427 s->codebook_size, 0)) < 0)
428 return res;
6955a882
MM
429 }
430
431 /* copy a full codebook */
432 if (cbf0_chunk != -1) {
433
5a3a906b
PM
434 bytestream2_seek(&s->gb, cbf0_chunk, SEEK_SET);
435 chunk_size = bytestream2_get_be32(&s->gb);
6955a882 436 /* sanity check the full codebook size */
cafa66af 437 if (chunk_size > MAX_CODEBOOK_SIZE) {
9b879566 438 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",
cafa66af 439 chunk_size);
5a3a906b 440 return AVERROR_INVALIDDATA;
6955a882 441 }
6955a882 442
5a3a906b 443 bytestream2_get_buffer(&s->gb, s->codebook, chunk_size);
6955a882
MM
444 }
445
446 /* decode the frame */
447 if (vptz_chunk == -1) {
448
449 /* something is wrong if there is no VPTZ chunk */
9b879566 450 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: no VPTZ chunk found\n");
5a3a906b 451 return AVERROR_INVALIDDATA;
6955a882
MM
452 }
453
5a3a906b
PM
454 bytestream2_seek(&s->gb, vptz_chunk, SEEK_SET);
455 chunk_size = bytestream2_get_be32(&s->gb);
456 if ((res = decode_format80(&s->gb, chunk_size,
457 s->decode_buffer, s->decode_buffer_size, 1)) < 0)
458 return res;
6955a882
MM
459
460 /* render the final PAL8 frame */
b3a5d003
MM
461 if (s->vector_height == 4)
462 index_shift = 4;
463 else
464 index_shift = 3;
115329f1 465 for (y = 0; y < s->frame.linesize[0] * s->height;
6955a882
MM
466 y += s->frame.linesize[0] * s->vector_height) {
467
468 for (x = y; x < y + s->width; x += 4, lobytes++, hibytes++) {
469 pixel_ptr = x;
470
471 /* get the vector index, the method for which varies according to
472 * VQA file version */
473 switch (s->vqa_version) {
474
475 case 1:
7667896a
KS
476 lobyte = s->decode_buffer[lobytes * 2];
477 hibyte = s->decode_buffer[(lobytes * 2) + 1];
478 vector_index = ((hibyte << 8) | lobyte) >> 3;
479 vector_index <<= index_shift;
480 lines = s->vector_height;
481 /* uniform color fill - a quick hack */
482 if (hibyte == 0xFF) {
483 while (lines--) {
484 s->frame.data[0][pixel_ptr + 0] = 255 - lobyte;
485 s->frame.data[0][pixel_ptr + 1] = 255 - lobyte;
486 s->frame.data[0][pixel_ptr + 2] = 255 - lobyte;
487 s->frame.data[0][pixel_ptr + 3] = 255 - lobyte;
488 pixel_ptr += s->frame.linesize[0];
489 }
490 lines=0;
491 }
6955a882
MM
492 break;
493
494 case 2:
495 lobyte = s->decode_buffer[lobytes];
496 hibyte = s->decode_buffer[hibytes];
6955a882 497 vector_index = (hibyte << 8) | lobyte;
b3a5d003 498 vector_index <<= index_shift;
cafa66af 499 lines = s->vector_height;
6955a882
MM
500 break;
501
502 case 3:
503/* not implemented yet */
504 lines = 0;
505 break;
506 }
507
508 while (lines--) {
509 s->frame.data[0][pixel_ptr + 0] = s->codebook[vector_index++];
510 s->frame.data[0][pixel_ptr + 1] = s->codebook[vector_index++];
511 s->frame.data[0][pixel_ptr + 2] = s->codebook[vector_index++];
512 s->frame.data[0][pixel_ptr + 3] = s->codebook[vector_index++];
513 pixel_ptr += s->frame.linesize[0];
514 }
515 }
516 }
517
518 /* handle partial codebook */
519 if ((cbp0_chunk != -1) && (cbpz_chunk != -1)) {
520 /* a chunk should not have both chunk types */
9b879566 521 av_log(s->avctx, AV_LOG_ERROR, " VQA video: problem: found both CBP0 and CBPZ chunks\n");
5a3a906b 522 return AVERROR_INVALIDDATA;
6955a882
MM
523 }
524
525 if (cbp0_chunk != -1) {
526
5a3a906b
PM
527 bytestream2_seek(&s->gb, cbp0_chunk, SEEK_SET);
528 chunk_size = bytestream2_get_be32(&s->gb);
6955a882
MM
529
530 /* accumulate partial codebook */
5a3a906b
PM
531 bytestream2_get_buffer(&s->gb, &s->next_codebook_buffer[s->next_codebook_buffer_index],
532 chunk_size);
6955a882
MM
533 s->next_codebook_buffer_index += chunk_size;
534
535 s->partial_countdown--;
536 if (s->partial_countdown == 0) {
537
538 /* time to replace codebook */
115329f1 539 memcpy(s->codebook, s->next_codebook_buffer,
6955a882
MM
540 s->next_codebook_buffer_index);
541
542 /* reset accounting */
543 s->next_codebook_buffer_index = 0;
544 s->partial_countdown = s->partial_count;
545 }
546 }
547
548 if (cbpz_chunk != -1) {
549
5a3a906b
PM
550 bytestream2_seek(&s->gb, cbpz_chunk, SEEK_SET);
551 chunk_size = bytestream2_get_be32(&s->gb);
6955a882 552
cafa66af 553 /* accumulate partial codebook */
5a3a906b
PM
554 bytestream2_get_buffer(&s->gb, &s->next_codebook_buffer[s->next_codebook_buffer_index],
555 chunk_size);
cafa66af
MM
556 s->next_codebook_buffer_index += chunk_size;
557
558 s->partial_countdown--;
559 if (s->partial_countdown == 0) {
5a3a906b 560 GetByteContext gb;
cafa66af 561
5a3a906b 562 bytestream2_init(&gb, s->next_codebook_buffer, s->next_codebook_buffer_index);
cafa66af 563 /* decompress codebook */
5a3a906b
PM
564 if ((res = decode_format80(&gb, s->next_codebook_buffer_index,
565 s->codebook, s->codebook_size, 0)) < 0)
566 return res;
cafa66af
MM
567
568 /* reset accounting */
569 s->next_codebook_buffer_index = 0;
570 s->partial_countdown = s->partial_count;
571 }
6955a882 572 }
5a3a906b
PM
573
574 return 0;
6955a882
MM
575}
576
577static int vqa_decode_frame(AVCodecContext *avctx,
578 void *data, int *data_size,
7a00bbad 579 AVPacket *avpkt)
6955a882 580{
e4141433 581 VqaContext *s = avctx->priv_data;
5a3a906b 582 int res;
6955a882
MM
583
584 if (s->frame.data[0])
585 avctx->release_buffer(avctx, &s->frame);
586
587 if (avctx->get_buffer(avctx, &s->frame)) {
9b879566 588 av_log(s->avctx, AV_LOG_ERROR, " VQA Video: get_buffer() failed\n");
6955a882
MM
589 return -1;
590 }
591
5a3a906b
PM
592 bytestream2_init(&s->gb, avpkt->data, avpkt->size);
593 if ((res = vqa_decode_chunk(s)) < 0)
594 return res;
6955a882
MM
595
596 /* make the palette available on the way out */
597 memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
2a2bbcb0 598 s->frame.palette_has_changed = 1;
6955a882
MM
599
600 *data_size = sizeof(AVFrame);
601 *(AVFrame*)data = s->frame;
602
603 /* report that the buffer was completely consumed */
5a3a906b 604 return avpkt->size;
6955a882
MM
605}
606
98a6fff9 607static av_cold int vqa_decode_end(AVCodecContext *avctx)
6955a882 608{
e4141433 609 VqaContext *s = avctx->priv_data;
6955a882 610
341404f7
PM
611 av_freep(&s->codebook);
612 av_freep(&s->next_codebook_buffer);
613 av_freep(&s->decode_buffer);
6955a882
MM
614
615 if (s->frame.data[0])
616 avctx->release_buffer(avctx, &s->frame);
617
618 return 0;
619}
620
d36beb3f 621AVCodec ff_vqa_decoder = {
ec6402b7
AK
622 .name = "vqavideo",
623 .type = AVMEDIA_TYPE_VIDEO,
624 .id = CODEC_ID_WS_VQA,
625 .priv_data_size = sizeof(VqaContext),
626 .init = vqa_decode_init,
627 .close = vqa_decode_end,
628 .decode = vqa_decode_frame,
629 .capabilities = CODEC_CAP_DR1,
00c3b67b 630 .long_name = NULL_IF_CONFIG_SMALL("Westwood Studios VQA (Vector Quantized Animation) video"),
6955a882 631};