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