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

   1 /*
   2  * Sierra VMD Audio & Video Decoders
   3  * Copyright (C) 2004 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  * Sierra VMD audio & video decoders
  25  * by Vladimir "VAG" Gneushev (vagsoft at mail.ru)
  26  * for more information on the Sierra VMD format, visit:
  27  *   http://www.pcisys.net/~melanson/codecs/
  28  *
  29  * The video decoder outputs PAL8 colorspace data. The decoder expects
  30  * a 0x330-byte VMD file header to be transmitted via extradata during
  31  * codec initialization. Each encoded frame that is sent to this decoder
  32  * is expected to be prepended with the appropriate 16-byte frame
  33  * information record from the VMD file.
  34  *
  35  * The audio decoder, like the video decoder, expects each encoded data
  36  * chunk to be prepended with the appropriate 16-byte frame information
  37  * record from the VMD file. It does not require the 0x330-byte VMD file
  38  * header, but it does need the audio setup parameters passed in through
  39  * normal libavcodec API means.
  40  */
  41
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include "libavutil/intreadwrite.h"
  47 #include "avcodec.h"
  48
  49 #define VMD_HEADER_SIZE 0x330
  50 #define PALETTE_COUNT 256
  51
  52 /*
  53  * Video Decoder
  54  */
  55
  56 typedef struct VmdVideoContext {
  57
  58     AVCodecContext *avctx;
  59     AVFrame frame;
  60     AVFrame prev_frame;
  61
  62     const unsigned char *buf;
  63     int size;
  64
  65     unsigned char palette[PALETTE_COUNT * 4];
  66     unsigned char *unpack_buffer;
  67     int unpack_buffer_size;
  68
  69     int x_off, y_off;
  70 } VmdVideoContext;
  71
  72 #define QUEUE_SIZE 0x1000
  73 #define QUEUE_MASK 0x0FFF
  74
  75 static void lz_unpack(const unsigned char *src, int src_len,
  76                       unsigned char *dest, int dest_len)
  77 {
  78     const unsigned char *s;
  79     const unsigned char *s_end;
  80     unsigned char *d;
  81     unsigned char *d_end;
  82     unsigned char queue[QUEUE_SIZE];
  83     unsigned int qpos;
  84     unsigned int dataleft;
  85     unsigned int chainofs;
  86     unsigned int chainlen;
  87     unsigned int speclen;
  88     unsigned char tag;
  89     unsigned int i, j;
  90
  91     s = src;
  92     s_end = src + src_len;
  93     d = dest;
  94     d_end = d + dest_len;
  95
  96     if (s_end - s < 8)
  97         return;
  98     dataleft = AV_RL32(s);
  99     s += 4;
 100     memset(queue, 0x20, QUEUE_SIZE);
 101     if (AV_RL32(s) == 0x56781234) {
 102         s += 4;
 103         qpos = 0x111;
 104         speclen = 0xF + 3;
 105     } else {
 106         qpos = 0xFEE;
 107         speclen = 100;  /* no speclen */
 108     }
 109
 110     while (s_end - s > 0 && dataleft > 0) {
 111         tag = *s++;
 112         if ((tag == 0xFF) && (dataleft > 8)) {
 113             if (d_end - d < 8 || s_end - s < 8)
 114                 return;
 115             for (i = 0; i < 8; i++) {
 116                 queue[qpos++] = *d++ = *s++;
 117                 qpos &= QUEUE_MASK;
 118             }
 119             dataleft -= 8;
 120         } else {
 121             for (i = 0; i < 8; i++) {
 122                 if (dataleft == 0)
 123                     break;
 124                 if (tag & 0x01) {
 125                     if (d_end - d < 1 || s_end - s < 1)
 126                         return;
 127                     queue[qpos++] = *d++ = *s++;
 128                     qpos &= QUEUE_MASK;
 129                     dataleft--;
 130                 } else {
 131                     if (s_end - s < 2)
 132                         return;
 133                     chainofs = *s++;
 134                     chainofs |= ((*s & 0xF0) << 4);
 135                     chainlen = (*s++ & 0x0F) + 3;
 136                     if (chainlen == speclen) {
 137                         if (s_end - s < 1)
 138                             return;
 139                         chainlen = *s++ + 0xF + 3;
 140                     }
 141                     if (d_end - d < chainlen)
 142                         return;
 143                     for (j = 0; j < chainlen; j++) {
 144                         *d = queue[chainofs++ & QUEUE_MASK];
 145                         queue[qpos++] = *d++;
 146                         qpos &= QUEUE_MASK;
 147                     }
 148                     dataleft -= chainlen;
 149                 }
 150                 tag >>= 1;
 151             }
 152         }
 153     }
 154 }
 155
 156 static int rle_unpack(const unsigned char *src, int src_len, int src_count,
 157                       unsigned char *dest, int dest_len)
 158 {
 159     const unsigned char *ps;
 160     const unsigned char *ps_end;
 161     unsigned char *pd;
 162     int i, l;
 163     unsigned char *dest_end = dest + dest_len;
 164
 165     ps = src;
 166     ps_end = src + src_len;
 167     pd = dest;
 168     if (src_count & 1) {
 169         if (ps_end - ps < 1)
 170             return 0;
 171         *pd++ = *ps++;
 172     }
 173
 174     src_count >>= 1;
 175     i = 0;
 176     do {
 177         if (ps_end - ps < 1)
 178             break;
 179         l = *ps++;
 180         if (l & 0x80) {
 181             l = (l & 0x7F) * 2;
 182             if (dest_end - pd < l || ps_end - ps < l)
 183                 return ps - src;
 184             memcpy(pd, ps, l);
 185             ps += l;
 186             pd += l;
 187         } else {
 188             if (dest_end - pd < i || ps_end - ps < 2)
 189                 return ps - src;
 190             for (i = 0; i < l; i++) {
 191                 *pd++ = ps[0];
 192                 *pd++ = ps[1];
 193             }
 194             ps += 2;
 195         }
 196         i += l;
 197     } while (i < src_count);
 198
 199     return ps - src;
 200 }
 201
 202 static void vmd_decode(VmdVideoContext *s)
 203 {
 204     int i;
 205     unsigned int *palette32;
 206     unsigned char r, g, b;
 207
 208     /* point to the start of the encoded data */
 209     const unsigned char *p = s->buf + 16;
 210     const unsigned char *p_end = s->buf + s->size;
 211
 212     const unsigned char *pb;
 213     const unsigned char *pb_end;
 214     unsigned char meth;
 215     unsigned char *dp;   /* pointer to current frame */
 216     unsigned char *pp;   /* pointer to previous frame */
 217     unsigned char len;
 218     int ofs;
 219
 220     int frame_x, frame_y;
 221     int frame_width, frame_height;
 222
 223     frame_x = AV_RL16(&s->buf[6]);
 224     frame_y = AV_RL16(&s->buf[8]);
 225     frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
 226     frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
 227     if (frame_x < 0 || frame_width < 0 ||
 228         frame_x >= s->avctx->width ||
 229         frame_width > s->avctx->width ||
 230         frame_x + frame_width > s->avctx->width)
 231         return;
 232     if (frame_y < 0 || frame_height < 0 ||
 233         frame_y >= s->avctx->height ||
 234         frame_height > s->avctx->height ||
 235         frame_y + frame_height > s->avctx->height)
 236         return;
 237
 238     if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
 239         (frame_x || frame_y)) {
 240
 241         s->x_off = frame_x;
 242         s->y_off = frame_y;
 243     }
 244     frame_x -= s->x_off;
 245     frame_y -= s->y_off;
 246
 247     /* if only a certain region will be updated, copy the entire previous
 248      * frame before the decode */
 249     if (s->prev_frame.data[0] &&
 250         (frame_x || frame_y || (frame_width != s->avctx->width) ||
 251         (frame_height != s->avctx->height))) {
 252
 253         memcpy(s->frame.data[0], s->prev_frame.data[0],
 254             s->avctx->height * s->frame.linesize[0]);
 255     }
 256
 257     /* check if there is a new palette */
 258     if (s->buf[15] & 0x02) {
 259         if (p_end - p < 2 + 3 * PALETTE_COUNT)
 260             return;
 261         p += 2;
 262         palette32 = (unsigned int *)s->palette;
 263         for (i = 0; i < PALETTE_COUNT; i++) {
 264             r = *p++ * 4;
 265             g = *p++ * 4;
 266             b = *p++ * 4;
 267             palette32[i] = 0xFF << 24 | r << 16 | g << 8 | b;
 268             palette32[i] |= palette32[i] >> 6 & 0x30303;
 269         }
 270     }
 271     if (p < p_end) {
 272         /* originally UnpackFrame in VAG's code */
 273         pb = p;
 274         pb_end = p_end;
 275         meth = *pb++;
 276         if (meth & 0x80) {
 277             lz_unpack(pb, p_end - pb, s->unpack_buffer, s->unpack_buffer_size);
 278             meth &= 0x7F;
 279             pb = s->unpack_buffer;
 280             pb_end = s->unpack_buffer + s->unpack_buffer_size;
 281         }
 282
 283         dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];
 284         pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
 285         switch (meth) {
 286         case 1:
 287             for (i = 0; i < frame_height; i++) {
 288                 ofs = 0;
 289                 do {
 290                     if (pb_end - pb < 1)
 291                         return;
 292                     len = *pb++;
 293                     if (len & 0x80) {
 294                         len = (len & 0x7F) + 1;
 295                         if (ofs + len > frame_width || pb_end - pb < len)
 296                             return;
 297                         memcpy(&dp[ofs], pb, len);
 298                         pb += len;
 299                         ofs += len;
 300                     } else {
 301                         /* interframe pixel copy */
 302                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
 303                             return;
 304                         memcpy(&dp[ofs], &pp[ofs], len + 1);
 305                         ofs += len + 1;
 306                     }
 307                 } while (ofs < frame_width);
 308                 if (ofs > frame_width) {
 309                     av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
 310                         ofs, frame_width);
 311                     break;
 312                 }
 313                 dp += s->frame.linesize[0];
 314                 pp += s->prev_frame.linesize[0];
 315             }
 316             break;
 317
 318         case 2:
 319             for (i = 0; i < frame_height; i++) {
 320                 if (pb_end -pb < frame_width)
 321                     return;
 322                 memcpy(dp, pb, frame_width);
 323                 pb += frame_width;
 324                 dp += s->frame.linesize[0];
 325                 pp += s->prev_frame.linesize[0];
 326             }
 327             break;
 328
 329         case 3:
 330             for (i = 0; i < frame_height; i++) {
 331                 ofs = 0;
 332                 do {
 333                     if (pb_end - pb < 1)
 334                         return;
 335                     len = *pb++;
 336                     if (len & 0x80) {
 337                         len = (len & 0x7F) + 1;
 338                         if (pb_end - pb < 1)
 339                             return;
 340                         if (*pb++ == 0xFF)
 341                             len = rle_unpack(pb, pb_end - pb, len, &dp[ofs], frame_width - ofs);
 342                         else {
 343                         if (pb_end - pb < len)
 344                             return;
 345                             memcpy(&dp[ofs], pb, len);
 346                         }
 347                         pb += len;
 348                         ofs += len;
 349                     } else {
 350                         /* interframe pixel copy */
 351                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
 352                             return;
 353                         memcpy(&dp[ofs], &pp[ofs], len + 1);
 354                         ofs += len + 1;
 355                     }
 356                 } while (ofs < frame_width);
 357                 if (ofs > frame_width) {
 358                     av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
 359                         ofs, frame_width);
 360                 }
 361                 dp += s->frame.linesize[0];
 362                 pp += s->prev_frame.linesize[0];
 363             }
 364             break;
 365         }
 366     }
 367 }
 368
 369 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
 370 {
 371     VmdVideoContext *s = avctx->priv_data;
 372     int i;
 373     unsigned int *palette32;
 374     int palette_index = 0;
 375     unsigned char r, g, b;
 376     unsigned char *vmd_header;
 377     unsigned char *raw_palette;
 378
 379     s->avctx = avctx;
 380     avctx->pix_fmt = PIX_FMT_PAL8;
 381
 382     /* make sure the VMD header made it */
 383     if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
 384         av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
 385             VMD_HEADER_SIZE);
 386         return -1;
 387     }
 388     vmd_header = (unsigned char *)avctx->extradata;
 389
 390     s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
 391     s->unpack_buffer = av_malloc(s->unpack_buffer_size);
 392     if (!s->unpack_buffer)
 393         return -1;
 394
 395     /* load up the initial palette */
 396     raw_palette = &vmd_header[28];
 397     palette32 = (unsigned int *)s->palette;
 398     for (i = 0; i < PALETTE_COUNT; i++) {
 399         r = raw_palette[palette_index++] * 4;
 400         g = raw_palette[palette_index++] * 4;
 401         b = raw_palette[palette_index++] * 4;
 402         palette32[i] = (r << 16) | (g << 8) | (b);
 403     }
 404
 405     avcodec_get_frame_defaults(&s->frame);
 406     avcodec_get_frame_defaults(&s->prev_frame);
 407
 408     return 0;
 409 }
 410
 411 static int vmdvideo_decode_frame(AVCodecContext *avctx,
 412                                  void *data, int *data_size,
 413                                  AVPacket *avpkt)
 414 {
 415     const uint8_t *buf = avpkt->data;
 416     int buf_size = avpkt->size;
 417     VmdVideoContext *s = avctx->priv_data;
 418
 419     s->buf = buf;
 420     s->size = buf_size;
 421
 422     if (buf_size < 16)
 423         return buf_size;
 424
 425     s->frame.reference = 3;
 426     if (avctx->get_buffer(avctx, &s->frame)) {
 427         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 428         return -1;
 429     }
 430
 431     vmd_decode(s);
 432
 433     /* make the palette available on the way out */
 434     memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
 435
 436     /* shuffle frames */
 437     FFSWAP(AVFrame, s->frame, s->prev_frame);
 438     if (s->frame.data[0])
 439         avctx->release_buffer(avctx, &s->frame);
 440
 441     *data_size = sizeof(AVFrame);
 442     *(AVFrame*)data = s->prev_frame;
 443
 444     /* report that the buffer was completely consumed */
 445     return buf_size;
 446 }
 447
 448 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
 449 {
 450     VmdVideoContext *s = avctx->priv_data;
 451
 452     if (s->prev_frame.data[0])
 453         avctx->release_buffer(avctx, &s->prev_frame);
 454     av_free(s->unpack_buffer);
 455
 456     return 0;
 457 }
 458
 459
 460 /*
 461  * Audio Decoder
 462  */
 463
 464 #define BLOCK_TYPE_AUDIO    1
 465 #define BLOCK_TYPE_INITIAL  2
 466 #define BLOCK_TYPE_SILENCE  3
 467
 468 typedef struct VmdAudioContext {
 469     AVFrame frame;
 470     int out_bps;
 471     int chunk_size;
 472 } VmdAudioContext;
 473
 474 static const uint16_t vmdaudio_table[128] = {
 475     0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
 476     0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
 477     0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
 478     0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
 479     0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
 480     0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
 481     0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
 482     0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
 483     0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
 484     0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
 485     0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
 486     0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
 487     0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
 488 };
 489
 490 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
 491 {
 492     VmdAudioContext *s = avctx->priv_data;
 493
 494     if (avctx->channels < 1 || avctx->channels > 2) {
 495         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
 496         return AVERROR(EINVAL);
 497     }
 498     if (avctx->block_align < 1) {
 499         av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
 500         return AVERROR(EINVAL);
 501     }
 502
 503     if (avctx->bits_per_coded_sample == 16)
 504         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 505     else
 506         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
 507     s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
 508
 509     s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
 510
 511     avcodec_get_frame_defaults(&s->frame);
 512     avctx->coded_frame = &s->frame;
 513
 514     av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
 515            "block align = %d, sample rate = %d\n",
 516            avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
 517            avctx->sample_rate);
 518
 519     return 0;
 520 }
 521
 522 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
 523                              int channels)
 524 {
 525     int ch;
 526     const uint8_t *buf_end = buf + buf_size;
 527     int predictor[2];
 528     int st = channels - 1;
 529
 530     /* decode initial raw sample */
 531     for (ch = 0; ch < channels; ch++) {
 532         predictor[ch] = (int16_t)AV_RL16(buf);
 533         buf += 2;
 534         *out++ = predictor[ch];
 535     }
 536
 537     /* decode DPCM samples */
 538     ch = 0;
 539     while (buf < buf_end) {
 540         uint8_t b = *buf++;
 541         if (b & 0x80)
 542             predictor[ch] -= vmdaudio_table[b & 0x7F];
 543         else
 544             predictor[ch] += vmdaudio_table[b];
 545         predictor[ch] = av_clip_int16(predictor[ch]);
 546         *out++ = predictor[ch];
 547         ch ^= st;
 548     }
 549 }
 550
 551 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
 552                                  int *got_frame_ptr, AVPacket *avpkt)
 553 {
 554     const uint8_t *buf = avpkt->data;
 555     const uint8_t *buf_end;
 556     int buf_size = avpkt->size;
 557     VmdAudioContext *s = avctx->priv_data;
 558     int block_type, silent_chunks, audio_chunks;
 559     int ret;
 560     uint8_t *output_samples_u8;
 561     int16_t *output_samples_s16;
 562
 563     if (buf_size < 16) {
 564         av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
 565         *got_frame_ptr = 0;
 566         return buf_size;
 567     }
 568
 569     block_type = buf[6];
 570     if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
 571         av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
 572         return AVERROR(EINVAL);
 573     }
 574     buf      += 16;
 575     buf_size -= 16;
 576
 577     /* get number of silent chunks */
 578     silent_chunks = 0;
 579     if (block_type == BLOCK_TYPE_INITIAL) {
 580         uint32_t flags;
 581         if (buf_size < 4) {
 582             av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
 583             return AVERROR(EINVAL);
 584         }
 585         flags         = AV_RB32(buf);
 586         silent_chunks = av_popcount(flags);
 587         buf      += 4;
 588         buf_size -= 4;
 589     } else if (block_type == BLOCK_TYPE_SILENCE) {
 590         silent_chunks = 1;
 591         buf_size = 0; // should already be zero but set it just to be sure
 592     }
 593
 594     /* ensure output buffer is large enough */
 595     audio_chunks = buf_size / s->chunk_size;
 596
 597     /* get output buffer */
 598     s->frame.nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels;
 599     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 600         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 601         return ret;
 602     }
 603     output_samples_u8  = s->frame.data[0];
 604     output_samples_s16 = (int16_t *)s->frame.data[0];
 605
 606     /* decode silent chunks */
 607     if (silent_chunks > 0) {
 608         int silent_size = avctx->block_align * silent_chunks;
 609         if (s->out_bps == 2) {
 610             memset(output_samples_s16, 0x00, silent_size * 2);
 611             output_samples_s16 += silent_size;
 612         } else {
 613             memset(output_samples_u8,  0x80, silent_size);
 614             output_samples_u8 += silent_size;
 615         }
 616     }
 617
 618     /* decode audio chunks */
 619     if (audio_chunks > 0) {
 620         buf_end = buf + buf_size;
 621         while ( buf_end - buf >= s->chunk_size) {
 622             if (s->out_bps == 2) {
 623                 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
 624                                  avctx->channels);
 625                 output_samples_s16 += avctx->block_align;
 626             } else {
 627                 memcpy(output_samples_u8, buf, s->chunk_size);
 628                 output_samples_u8  += avctx->block_align;
 629             }
 630             buf += s->chunk_size;
 631         }
 632     }
 633
 634     *got_frame_ptr   = 1;
 635     *(AVFrame *)data = s->frame;
 636
 637     return avpkt->size;
 638 }
 639
 640
 641 /*
 642  * Public Data Structures
 643  */
 644
 645 AVCodec ff_vmdvideo_decoder = {
 646     .name           = "vmdvideo",
 647     .type           = AVMEDIA_TYPE_VIDEO,
 648     .id             = CODEC_ID_VMDVIDEO,
 649     .priv_data_size = sizeof(VmdVideoContext),
 650     .init           = vmdvideo_decode_init,
 651     .close          = vmdvideo_decode_end,
 652     .decode         = vmdvideo_decode_frame,
 653     .capabilities   = CODEC_CAP_DR1,
 654     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
 655 };
 656
 657 AVCodec ff_vmdaudio_decoder = {
 658     .name           = "vmdaudio",
 659     .type           = AVMEDIA_TYPE_AUDIO,
 660     .id             = CODEC_ID_VMDAUDIO,
 661     .priv_data_size = sizeof(VmdAudioContext),
 662     .init           = vmdaudio_decode_init,
 663     .decode         = vmdaudio_decode_frame,
 664     .capabilities   = CODEC_CAP_DR1,
 665     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
 666 };