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