git.sesse.net Git - ffmpeg/blob - libavcodec/vqavideo.c

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