X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fvmdav.c;h=283c2136d58c487e4cd6a1ec1255b1501f2bc13b;hb=d3a6c2ab7e76f12f56932a087266b082dc1dc39b;hp=47c77513d2f5dbd0d7606b4a15d7201b02c7f757;hpb=23fe14bb20888038b91e62b16d50fe0b75043a10;p=ffmpeg

diff --git a/libavcodec/vmdav.c b/libavcodec/vmdav.c
index 47c77513d2f..283c2136d58 100644
--- a/libavcodec/vmdav.c
+++ b/libavcodec/vmdav.c
@@ -2,24 +2,25 @@
  * Sierra VMD Audio & Video Decoders
  * Copyright (C) 2004 the ffmpeg project
  *
- * This library is free software; you can redistribute it and/or
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * This library is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /**
- * @file vmdvideo.c
+ * @file
  * Sierra VMD audio & video decoders
  * by Vladimir "VAG" Gneushev (vagsoft at mail.ru)
  * for more information on the Sierra VMD format, visit:
@@ -28,7 +29,7 @@
  * The video decoder outputs PAL8 colorspace data. The decoder expects
  * a 0x330-byte VMD file header to be transmitted via extradata during
  * codec initialization. Each encoded frame that is sent to this decoder
- * is expected to be prepended with the appropriate 16-byte frame 
+ * is expected to be prepended with the appropriate 16-byte frame
  * information record from the VMD file.
  *
  * The audio decoder, like the video decoder, expects each encoded data
@@ -41,14 +42,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
-#include "common.h"
+#include "libavutil/intreadwrite.h"
 #include "avcodec.h"
-#include "dsputil.h"
-
-#define printf(...) {} //(f)printf() usage is forbidden in libavcodec, use av_log
-#define fprintf(...) {} 
 
 #define VMD_HEADER_SIZE 0x330
 #define PALETTE_COUNT 256
@@ -60,25 +56,27 @@
 typedef struct VmdVideoContext {
 
     AVCodecContext *avctx;
-    DSPContext dsp;
     AVFrame frame;
     AVFrame prev_frame;
 
-    unsigned char *buf;
+    const unsigned char *buf;
     int size;
 
     unsigned char palette[PALETTE_COUNT * 4];
     unsigned char *unpack_buffer;
+    int unpack_buffer_size;
 
+    int x_off, y_off;
 } VmdVideoContext;
 
 #define QUEUE_SIZE 0x1000
 #define QUEUE_MASK 0x0FFF
 
-static void lz_unpack(unsigned char *src, unsigned char *dest)
+static void lz_unpack(const unsigned char *src, unsigned char *dest, int dest_len)
 {
-    unsigned char *s;
+    const unsigned char *s;
     unsigned char *d;
+    unsigned char *d_end;
     unsigned char queue[QUEUE_SIZE];
     unsigned int qpos;
     unsigned int dataleft;
@@ -90,10 +88,11 @@ static void lz_unpack(unsigned char *src, unsigned char *dest)
 
     s = src;
     d = dest;
-    dataleft = LE_32(s);
+    d_end = d + dest_len;
+    dataleft = AV_RL32(s);
     s += 4;
-    memset(queue, QUEUE_SIZE, 0x20);
-    if (LE_32(s) == 0x56781234) {
+    memset(queue, 0x20, QUEUE_SIZE);
+    if (AV_RL32(s) == 0x56781234) {
         s += 4;
         qpos = 0x111;
         speclen = 0xF + 3;
@@ -105,6 +104,8 @@ static void lz_unpack(unsigned char *src, unsigned char *dest)
     while (dataleft > 0) {
         tag = *s++;
         if ((tag == 0xFF) && (dataleft > 8)) {
+            if (d + 8 > d_end)
+                return;
             for (i = 0; i < 8; i++) {
                 queue[qpos++] = *d++ = *s++;
                 qpos &= QUEUE_MASK;
@@ -115,6 +116,8 @@ static void lz_unpack(unsigned char *src, unsigned char *dest)
                 if (dataleft == 0)
                     break;
                 if (tag & 0x01) {
+                    if (d + 1 > d_end)
+                        return;
                     queue[qpos++] = *d++ = *s++;
                     qpos &= QUEUE_MASK;
                     dataleft--;
@@ -124,6 +127,8 @@ static void lz_unpack(unsigned char *src, unsigned char *dest)
                     chainlen = (*s++ & 0x0F) + 3;
                     if (chainlen == speclen)
                         chainlen = *s++ + 0xF + 3;
+                    if (d + chainlen > d_end)
+                        return;
                     for (j = 0; j < chainlen; j++) {
                         *d = queue[chainofs++ & QUEUE_MASK];
                         queue[qpos++] = *d++;
@@ -137,27 +142,33 @@ static void lz_unpack(unsigned char *src, unsigned char *dest)
     }
 }
 
-static int rle_unpack(unsigned char *src, unsigned char *dest, int len)
+static int rle_unpack(const unsigned char *src, unsigned char *dest,
+    int src_len, int dest_len)
 {
-    unsigned char *ps;
+    const unsigned char *ps;
     unsigned char *pd;
     int i, l;
+    unsigned char *dest_end = dest + dest_len;
 
     ps = src;
     pd = dest;
-    if (len & 1)
+    if (src_len & 1)
         *pd++ = *ps++;
 
-    len >>= 1;
+    src_len >>= 1;
     i = 0;
     do {
         l = *ps++;
         if (l & 0x80) {
             l = (l & 0x7F) * 2;
+            if (pd + l > dest_end)
+                return ps - src;
             memcpy(pd, ps, l);
             ps += l;
             pd += l;
         } else {
+            if (pd + i > dest_end)
+                return ps - src;
             for (i = 0; i < l; i++) {
                 *pd++ = ps[0];
                 *pd++ = ps[1];
@@ -165,9 +176,9 @@ static int rle_unpack(unsigned char *src, unsigned char *dest, int len)
             ps += 2;
         }
         i += l;
-    } while (i < len);
+    } while (i < src_len);
 
-    return (ps - src);
+    return ps - src;
 }
 
 static void vmd_decode(VmdVideoContext *s)
@@ -177,9 +188,9 @@ static void vmd_decode(VmdVideoContext *s)
     unsigned char r, g, b;
 
     /* point to the start of the encoded data */
-    unsigned char *p = s->buf + 16;
+    const unsigned char *p = s->buf + 16;
 
-    unsigned char *pb;
+    const unsigned char *pb;
     unsigned char meth;
     unsigned char *dp;   /* pointer to current frame */
     unsigned char *pp;   /* pointer to previous frame */
@@ -189,17 +200,26 @@ static void vmd_decode(VmdVideoContext *s)
     int frame_x, frame_y;
     int frame_width, frame_height;
 
-    frame_x = LE_16(&s->buf[6]);
-    frame_y = LE_16(&s->buf[8]);
-    frame_width = LE_16(&s->buf[10]) - frame_x + 1;
-    frame_height = LE_16(&s->buf[12]) - frame_y + 1;
+    frame_x = AV_RL16(&s->buf[6]);
+    frame_y = AV_RL16(&s->buf[8]);
+    frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
+    frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
+
+    if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
+        (frame_x || frame_y)) {
+
+        s->x_off = frame_x;
+        s->y_off = frame_y;
+    }
+    frame_x -= s->x_off;
+    frame_y -= s->y_off;
 
     /* if only a certain region will be updated, copy the entire previous
      * frame before the decode */
     if (frame_x || frame_y || (frame_width != s->avctx->width) ||
         (frame_height != s->avctx->height)) {
 
-        memcpy(s->frame.data[0], s->prev_frame.data[0], 
+        memcpy(s->frame.data[0], s->prev_frame.data[0],
             s->avctx->height * s->frame.linesize[0]);
     }
 
@@ -220,7 +240,7 @@ static void vmd_decode(VmdVideoContext *s)
         pb = p;
         meth = *pb++;
         if (meth & 0x80) {
-            lz_unpack(pb, s->unpack_buffer);
+            lz_unpack(pb, s->unpack_buffer, s->unpack_buffer_size);
             meth &= 0x7F;
             pb = s->unpack_buffer;
         }
@@ -235,17 +255,21 @@ static void vmd_decode(VmdVideoContext *s)
                     len = *pb++;
                     if (len & 0x80) {
                         len = (len & 0x7F) + 1;
+                        if (ofs + len > frame_width)
+                            return;
                         memcpy(&dp[ofs], pb, len);
                         pb += len;
                         ofs += len;
                     } else {
                         /* interframe pixel copy */
+                        if (ofs + len + 1 > frame_width)
+                            return;
                         memcpy(&dp[ofs], &pp[ofs], len + 1);
                         ofs += len + 1;
                     }
                 } while (ofs < frame_width);
                 if (ofs > frame_width) {
-                    printf (" VMD video: offset > width (%d > %d)\n",
+                    av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
                         ofs, frame_width);
                     break;
                 }
@@ -271,19 +295,21 @@ static void vmd_decode(VmdVideoContext *s)
                     if (len & 0x80) {
                         len = (len & 0x7F) + 1;
                         if (*pb++ == 0xFF)
-                            len = rle_unpack(pb, &dp[ofs], len);
+                            len = rle_unpack(pb, &dp[ofs], len, frame_width - ofs);
                         else
                             memcpy(&dp[ofs], pb, len);
                         pb += len;
                         ofs += len;
                     } else {
                         /* interframe pixel copy */
+                        if (ofs + len + 1 > frame_width)
+                            return;
                         memcpy(&dp[ofs], &pp[ofs], len + 1);
                         ofs += len + 1;
                     }
                 } while (ofs < frame_width);
                 if (ofs > frame_width) {
-                    printf (" VMD video: offset > width (%d > %d)\n",
+                    av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
                         ofs, frame_width);
                 }
                 dp += s->frame.linesize[0];
@@ -294,9 +320,9 @@ static void vmd_decode(VmdVideoContext *s)
     }
 }
 
-static int vmdvideo_decode_init(AVCodecContext *avctx)
+static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
 {
-    VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;
+    VmdVideoContext *s = avctx->priv_data;
     int i;
     unsigned int *palette32;
     int palette_index = 0;
@@ -306,18 +332,17 @@ static int vmdvideo_decode_init(AVCodecContext *avctx)
 
     s->avctx = avctx;
     avctx->pix_fmt = PIX_FMT_PAL8;
-    avctx->has_b_frames = 0;
-    dsputil_init(&s->dsp, avctx);
 
     /* make sure the VMD header made it */
     if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
-        printf("  VMD video: expected extradata size of %d\n", 
+        av_log(s->avctx, AV_LOG_ERROR, "VMD video: expected extradata size of %d\n",
             VMD_HEADER_SIZE);
         return -1;
     }
     vmd_header = (unsigned char *)avctx->extradata;
 
-    s->unpack_buffer = av_malloc(LE_32(&vmd_header[800]));
+    s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
+    s->unpack_buffer = av_malloc(s->unpack_buffer_size);
     if (!s->unpack_buffer)
         return -1;
 
@@ -331,16 +356,16 @@ static int vmdvideo_decode_init(AVCodecContext *avctx)
         palette32[i] = (r << 16) | (g << 8) | (b);
     }
 
-    s->frame.data[0] = s->prev_frame.data[0] = NULL;
-
     return 0;
 }
 
 static int vmdvideo_decode_frame(AVCodecContext *avctx,
                                  void *data, int *data_size,
-                                 uint8_t *buf, int buf_size)
+                                 AVPacket *avpkt)
 {
-    VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;
+    const uint8_t *buf = avpkt->data;
+    int buf_size = avpkt->size;
+    VmdVideoContext *s = avctx->priv_data;
 
     s->buf = buf;
     s->size = buf_size;
@@ -350,7 +375,7 @@ static int vmdvideo_decode_frame(AVCodecContext *avctx,
 
     s->frame.reference = 1;
     if (avctx->get_buffer(avctx, &s->frame)) {
-        printf ("  VMD Video: get_buffer() failed\n");
+        av_log(s->avctx, AV_LOG_ERROR, "VMD Video: get_buffer() failed\n");
         return -1;
     }
 
@@ -359,22 +384,21 @@ static int vmdvideo_decode_frame(AVCodecContext *avctx,
     /* make the palette available on the way out */
     memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
 
-    if (s->prev_frame.data[0])
-        avctx->release_buffer(avctx, &s->prev_frame);
-
     /* shuffle frames */
-    s->prev_frame = s->frame;
+    FFSWAP(AVFrame, s->frame, s->prev_frame);
+    if (s->frame.data[0])
+        avctx->release_buffer(avctx, &s->frame);
 
     *data_size = sizeof(AVFrame);
-    *(AVFrame*)data = s->frame;
+    *(AVFrame*)data = s->prev_frame;
 
     /* report that the buffer was completely consumed */
     return buf_size;
 }
 
-static int vmdvideo_decode_end(AVCodecContext *avctx)
+static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
 {
-    VmdVideoContext *s = (VmdVideoContext *)avctx->priv_data;
+    VmdVideoContext *s = avctx->priv_data;
 
     if (s->prev_frame.data[0])
         avctx->release_buffer(avctx, &s->prev_frame);
@@ -388,175 +412,130 @@ static int vmdvideo_decode_end(AVCodecContext *avctx)
  * Audio Decoder
  */
 
+#define BLOCK_TYPE_AUDIO    1
+#define BLOCK_TYPE_INITIAL  2
+#define BLOCK_TYPE_SILENCE  3
+
 typedef struct VmdAudioContext {
-    int channels;
-    int bits;
-    int block_align;
-    unsigned char steps8[16];
-    unsigned short steps16[16];
-    unsigned short steps128[256];
-    short predictors[2];
+    AVCodecContext *avctx;
+    int out_bps;
+    int predictors[2];
 } VmdAudioContext;
 
-static int vmdaudio_decode_init(AVCodecContext *avctx)
-{
-    VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data;
-    int i;
-
-    s->channels = avctx->channels;
-    s->bits = avctx->bits_per_sample;
-    s->block_align = avctx->block_align;
+static const uint16_t vmdaudio_table[128] = {
+    0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
+    0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
+    0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
+    0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
+    0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
+    0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
+    0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
+    0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
+    0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
+    0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
+    0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
+    0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
+    0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
+};
 
-printf ("  %d channels, %d bits/sample, block align = %d, sample rate = %d\n",
-  s->channels, s->bits, s->block_align, avctx->sample_rate);
+static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
+{
+    VmdAudioContext *s = avctx->priv_data;
 
-    /* set up the steps8 and steps16 tables */
-    for (i = 0; i < 8; i++) {
-        if (i < 4)
-            s->steps8[i] = i;
-        else
-            s->steps8[i] = s->steps8[i - 1] + i - 1;
-
-        if (i == 0)
-            s->steps16[i] = 0;
-        else if (i == 1)
-            s->steps16[i] = 4;
-        else if (i == 2)
-            s->steps16[i] = 16;
-        else
-            s->steps16[i] = 1 << (i + 4);
-    }
+    s->avctx = avctx;
+    if (avctx->bits_per_coded_sample == 16)
+        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    else
+        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
+    s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
 
-    /* set up the step128 table */
-    s->steps128[0] = 0;
-    s->steps128[1] = 8;
-    for (i = 0x02; i <= 0x20; i++)
-        s->steps128[i] = (i - 1) << 4;
-    for (i = 0x21; i <= 0x60; i++)
-        s->steps128[i] = (i + 0x1F) << 3;
-    for (i = 0x61; i <= 0x70; i++)
-        s->steps128[i] = (i - 0x51) << 6;
-    for (i = 0x71; i <= 0x78; i++)
-        s->steps128[i] = (i - 0x69) << 8;
-    for (i = 0x79; i <= 0x7D; i++)
-        s->steps128[i] = (i - 0x75) << 10;
-    s->steps128[0x7E] = 0x3000;
-    s->steps128[0x7F] = 0x4000;
-
-    /* set up the negative half of each table */
-    for (i = 0; i < 8; i++) {
-        s->steps8[i + 8] = -s->steps8[i];
-        s->steps16[i + 8] = -s->steps16[i];
-    }
-    for (i = 0; i < 128; i++)
-      s->steps128[i + 128] = -s->steps128[i];
+    av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
+           "block align = %d, sample rate = %d\n",
+           avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
+           avctx->sample_rate);
 
     return 0;
 }
 
 static void vmdaudio_decode_audio(VmdAudioContext *s, unsigned char *data,
-    uint8_t *buf, int ratio) {
+    const uint8_t *buf, int buf_size, int stereo)
+{
+    int i;
+    int chan = 0;
+    int16_t *out = (int16_t*)data;
 
+    for(i = 0; i < buf_size; i++) {
+        if(buf[i] & 0x80)
+            s->predictors[chan] -= vmdaudio_table[buf[i] & 0x7F];
+        else
+            s->predictors[chan] += vmdaudio_table[buf[i]];
+        s->predictors[chan] = av_clip_int16(s->predictors[chan]);
+        out[i] = s->predictors[chan];
+        chan ^= stereo;
+    }
 }
 
 static int vmdaudio_loadsound(VmdAudioContext *s, unsigned char *data,
-    uint8_t *buf, int silence)
+    const uint8_t *buf, int silent_chunks, int data_size)
 {
-    int bytes_decoded = 0;
-    int i;
-
-if (silence)
-  printf (" silent block!\n");
-    if (s->channels == 2) {
-
-        /* stereo handling */
-        if ((s->block_align & 0x01) == 0) {
-            if (silence)
-                memset(data, 0, s->block_align * 2);
-            else
-                vmdaudio_decode_audio(s, data, buf, 1);
-        } else {
-            if (silence)
-                memset(data, 0, s->block_align * 2);
-            else
-                vmdaudio_decode_audio(s, data, buf, 1);
-        }
-    } else {
+    int silent_size = s->avctx->block_align * silent_chunks * s->out_bps;
 
-        /* mono handling */
-        if (silence) {
-            if (s->bits == 16) {
-                memset(data, 0, s->block_align * 2);
-                bytes_decoded = s->block_align * 2;
-            } else {
-//                memset(data, 0x00, s->block_align);
-//                bytes_decoded = s->block_align;
-memset(data, 0x00, s->block_align * 2);
-bytes_decoded = s->block_align * 2;
-            }
-        } else {
-            if (s->bits == 16) {
-            } else {
-                /* copy the data but convert it to signed */
-                for (i = 0; i < s->block_align; i++)
-                    data[i * 2 + 1] = buf[i] + 0x80;
-                bytes_decoded = s->block_align * 2;
-            }
-        }
+    if (silent_chunks) {
+        memset(data, s->out_bps == 2 ? 0x00 : 0x80, silent_size);
+        data += silent_size;
+    }
+    if (s->avctx->bits_per_coded_sample == 16)
+        vmdaudio_decode_audio(s, data, buf, data_size, s->avctx->channels == 2);
+    else {
+        /* just copy the data */
+        memcpy(data, buf, data_size);
     }
 
-    return bytes_decoded;
+    return silent_size + data_size * s->out_bps;
 }
 
 static int vmdaudio_decode_frame(AVCodecContext *avctx,
                                  void *data, int *data_size,
-                                 uint8_t *buf, int buf_size)
+                                 AVPacket *avpkt)
 {
-    VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data;
-    unsigned int sound_flags;
+    const uint8_t *buf = avpkt->data;
+    int buf_size = avpkt->size;
+    VmdAudioContext *s = avctx->priv_data;
+    int block_type, silent_chunks;
     unsigned char *output_samples = (unsigned char *)data;
 
-    /* point to the start of the encoded data */
-    unsigned char *p = buf + 16;
-    unsigned char *p_end = buf + buf_size;
-
-printf ("    processing audio frame with %d bytes\n", buf_size);
-    if (buf_size < 16)
+    if (buf_size < 16) {
+        av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
+        *data_size = 0;
         return buf_size;
+    }
 
-    *data_size = 0;
-    if (buf[6] == 1) {
-        /* the chunk contains audio */
-        *data_size = vmdaudio_loadsound(s, output_samples, p, 0);
-    } else if (buf[6] == 2) {
-printf ("  hey! audio case #2\n");
-        /* the chunk contains audio and silence mixed together */
-        sound_flags = LE_32(p);
-        p += 4;
-
-        /* do something with extrabufs here? */
-
-        while (p < p_end) {
-            if (sound_flags & 0x01)
-                /* silence */
-                *data_size += vmdaudio_loadsound(s, output_samples, p, 1);
-            else {
-                /* audio */
-                *data_size += vmdaudio_loadsound(s, output_samples, p, 0);
-                p += s->block_align;
-            }
-            output_samples += (s->block_align * s->bits / 8);
-            sound_flags >>= 1;
-        }
-    } else if (buf[6] == 3) {
-printf ("  hey! audio case #3\n");
-        /* silent chunk */
-        *data_size = vmdaudio_loadsound(s, output_samples, p, 1);
+    block_type = buf[6];
+    if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
+        av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
+        return AVERROR(EINVAL);
+    }
+    buf      += 16;
+    buf_size -= 16;
+
+    silent_chunks = 0;
+    if (block_type == BLOCK_TYPE_INITIAL) {
+        uint32_t flags = AV_RB32(buf);
+        silent_chunks  = av_popcount(flags);
+        buf      += 4;
+        buf_size -= 4;
+    } else if (block_type == BLOCK_TYPE_SILENCE) {
+        silent_chunks = 1;
+        buf_size = 0; // should already be zero but set it just to be sure
     }
 
-printf ("      final sample count = %d, byte count = %d\n", (*data_size) / 2,
-  *data_size);
-    return buf_size;
+    /* ensure output buffer is large enough */
+    if (*data_size < (avctx->block_align*silent_chunks + buf_size) * s->out_bps)
+        return -1;
+
+    *data_size = vmdaudio_loadsound(s, output_samples, buf, silent_chunks, buf_size);
+
+    return avpkt->size;
 }
 
 
@@ -564,9 +543,9 @@ printf ("      final sample count = %d, byte count = %d\n", (*data_size) / 2,
  * Public Data Structures
  */
 
-AVCodec vmdvideo_decoder = {
+AVCodec ff_vmdvideo_decoder = {
     "vmdvideo",
-    CODEC_TYPE_VIDEO,
+    AVMEDIA_TYPE_VIDEO,
     CODEC_ID_VMDVIDEO,
     sizeof(VmdVideoContext),
     vmdvideo_decode_init,
@@ -574,15 +553,17 @@ AVCodec vmdvideo_decoder = {
     vmdvideo_decode_end,
     vmdvideo_decode_frame,
     CODEC_CAP_DR1,
+    .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
 };
 
-AVCodec vmdaudio_decoder = {
+AVCodec ff_vmdaudio_decoder = {
     "vmdaudio",
-    CODEC_TYPE_AUDIO,
+    AVMEDIA_TYPE_AUDIO,
     CODEC_ID_VMDAUDIO,
     sizeof(VmdAudioContext),
     vmdaudio_decode_init,
     NULL,
     NULL,
     vmdaudio_decode_frame,
+    .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
 };