X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fvmdav.c;h=47a16d86550e821f2074ba0e1b67b5654dc33996;hb=b6a6e90a7c79f9530637a1efb62e0af4049822c1;hp=a5c7f450c2661c4417b13620297b9fcaa6106702;hpb=fafa0b75eebff24a721e5d1ccd0b724556e4152a;p=ffmpeg diff --git a/libavcodec/vmdav.c b/libavcodec/vmdav.c index a5c7f450c26..47a16d86550 100644 --- a/libavcodec/vmdav.c +++ b/libavcodec/vmdav.c @@ -2,35 +2,38 @@ * 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: + * http://www.pcisys.net/~melanson/codecs/ * * 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 - * chunk to be prepended with the approriate 16-byte frame information + * chunk to be prepended with the appropriate 16-byte frame information * record from the VMD file. It does not require the 0x330-byte VMD file * header, but it does need the audio setup parameters passed in through * normal libavcodec API means. @@ -39,21 +42,13 @@ #include #include #include -#include -#include "common.h" +#include "libavutil/intreadwrite.h" #include "avcodec.h" -#include "dsputil.h" #define VMD_HEADER_SIZE 0x330 #define PALETTE_COUNT 256 -#define LE_16(x) ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0]) -#define LE_32(x) ((((uint8_t*)(x))[3] << 24) | \ - (((uint8_t*)(x))[2] << 16) | \ - (((uint8_t*)(x))[1] << 8) | \ - ((uint8_t*)(x))[0]) - /* * Video Decoder */ @@ -61,25 +56,29 @@ 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, int src_len, + unsigned char *dest, int dest_len) { - unsigned char *s; + const unsigned char *s; + unsigned int s_len; unsigned char *d; + unsigned char *d_end; unsigned char queue[QUEUE_SIZE]; unsigned int qpos; unsigned int dataleft; @@ -90,12 +89,16 @@ static void lz_unpack(unsigned char *src, unsigned char *dest) unsigned int i, j; s = src; + s_len = src_len; d = dest; - dataleft = LE_32(s); - s += 4; - memset(queue, QUEUE_SIZE, 0x20); - if (LE_32(s) == 0x56781234) { - s += 4; + d_end = d + dest_len; + dataleft = AV_RL32(s); + s += 4; s_len -= 4; + memset(queue, 0x20, QUEUE_SIZE); + if (s_len < 4) + return; + if (AV_RL32(s) == 0x56781234) { + s += 4; s_len -= 4; qpos = 0x111; speclen = 0xF + 3; } else { @@ -103,28 +106,43 @@ static void lz_unpack(unsigned char *src, unsigned char *dest) speclen = 100; /* no speclen */ } - while (dataleft > 0) { - tag = *s++; + while (dataleft > 0 && s_len > 0) { + tag = *s++; s_len--; if ((tag == 0xFF) && (dataleft > 8)) { + if (d + 8 > d_end || s_len < 8) + return; for (i = 0; i < 8; i++) { queue[qpos++] = *d++ = *s++; qpos &= QUEUE_MASK; } + s_len -= 8; dataleft -= 8; } else { for (i = 0; i < 8; i++) { if (dataleft == 0) break; if (tag & 0x01) { + if (d + 1 > d_end || s_len < 1) + return; queue[qpos++] = *d++ = *s++; qpos &= QUEUE_MASK; dataleft--; + s_len--; } else { + if (s_len < 2) + return; chainofs = *s++; chainofs |= ((*s & 0xF0) << 4); chainlen = (*s++ & 0x0F) + 3; - if (chainlen == speclen) + s_len -= 2; + if (chainlen == speclen) { + if (s_len < 1) + return; chainlen = *s++ + 0xF + 3; + s_len--; + } + if (d + chainlen > d_end) + return; for (j = 0; j < chainlen; j++) { *d = queue[chainofs++ & QUEUE_MASK]; queue[qpos++] = *d++; @@ -138,37 +156,52 @@ 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_count, int src_size, 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_count & 1) { + if (src_size < 1) + return 0; *pd++ = *ps++; + src_size--; + } - len >>= 1; + src_count >>= 1; i = 0; do { + if (src_size < 1) + break; l = *ps++; + src_size--; if (l & 0x80) { l = (l & 0x7F) * 2; + if (pd + l > dest_end || src_size < l) + return ps - src; memcpy(pd, ps, l); ps += l; + src_size -= l; pd += l; } else { + if (pd + i > dest_end || src_size < 2) + return ps - src; for (i = 0; i < l; i++) { *pd++ = ps[0]; *pd++ = ps[1]; } ps += 2; + src_size -= 2; } i += l; - } while (i < len); + } while (i < src_count); - return (ps - src); + return ps - src; } static void vmd_decode(VmdVideoContext *s) @@ -178,9 +211,10 @@ 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 int pb_size; unsigned char meth; unsigned char *dp; /* pointer to current frame */ unsigned char *pp; /* pointer to previous frame */ @@ -190,17 +224,37 @@ 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_x < 0 || frame_width < 0 || + frame_x >= s->avctx->width || + frame_width > s->avctx->width || + frame_x + frame_width > s->avctx->width) + return; + if (frame_y < 0 || frame_height < 0 || + frame_y >= s->avctx->height || + frame_height > s->avctx->height || + frame_y + frame_height > s->avctx->height) + return; + + 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)) { + if (s->prev_frame.data[0] && + (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]); } @@ -216,14 +270,19 @@ static void vmd_decode(VmdVideoContext *s) } s->size -= (256 * 3 + 2); } - if (s->size >= 0) { + if (s->size > 0) { /* originally UnpackFrame in VAG's code */ pb = p; - meth = *pb++; + pb_size = s->buf + s->size - pb; + if (pb_size < 1) + return; + meth = *pb++; pb_size--; if (meth & 0x80) { - lz_unpack(pb, s->unpack_buffer); + lz_unpack(pb, pb_size, + s->unpack_buffer, s->unpack_buffer_size); meth &= 0x7F; pb = s->unpack_buffer; + pb_size = s->unpack_buffer_size; } dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x]; @@ -233,20 +292,28 @@ static void vmd_decode(VmdVideoContext *s) for (i = 0; i < frame_height; i++) { ofs = 0; do { + if (pb_size < 1) + return; len = *pb++; + pb_size--; if (len & 0x80) { len = (len & 0x7F) + 1; + if (ofs + len > frame_width || pb_size < len) + return; memcpy(&dp[ofs], pb, len); pb += len; + pb_size -= len; ofs += len; } else { /* interframe pixel copy */ + if (ofs + len + 1 > frame_width || !s->prev_frame.data[0]) + 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; } @@ -257,8 +324,11 @@ static void vmd_decode(VmdVideoContext *s) case 2: for (i = 0; i < frame_height; i++) { + if (pb_size < frame_width) + return; memcpy(dp, pb, frame_width); pb += frame_width; + pb_size -= frame_width; dp += s->frame.linesize[0]; pp += s->prev_frame.linesize[0]; } @@ -268,23 +338,34 @@ static void vmd_decode(VmdVideoContext *s) for (i = 0; i < frame_height; i++) { ofs = 0; do { + if (pb_size < 1) + return; len = *pb++; + pb_size--; if (len & 0x80) { len = (len & 0x7F) + 1; + if (pb_size < 1) + return; if (*pb++ == 0xFF) - len = rle_unpack(pb, dp, len); - else + len = rle_unpack(pb, &dp[ofs], len, pb_size, frame_width - ofs); + else { + if (pb_size < len) + return; memcpy(&dp[ofs], pb, len); + } pb += len; + pb_size -= 1 + len; ofs += len; } else { /* interframe pixel copy */ + if (ofs + len + 1 > frame_width || !s->prev_frame.data[0]) + 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]; @@ -295,9 +376,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; @@ -307,18 +388,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; @@ -332,23 +412,26 @@ 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; + if (buf_size < 16) + return buf_size; + 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; } @@ -357,22 +440,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); @@ -386,137 +468,180 @@ 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]; + AVFrame frame; + int out_bps; + int chunk_size; } VmdAudioContext; -static int vmdaudio_decode_init(AVCodecContext *avctx) +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 +}; + +static av_cold int vmdaudio_decode_init(AVCodecContext *avctx) { - VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data; - int i; + VmdAudioContext *s = avctx->priv_data; - s->channels = avctx->channels; - s->bits = avctx->bits_per_sample; - s->block_align = avctx->block_align; + if (avctx->channels < 1 || avctx->channels > 2) { + av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n"); + return AVERROR(EINVAL); + } + if (avctx->block_align < 1) { + av_log(avctx, AV_LOG_ERROR, "invalid block align\n"); + return AVERROR(EINVAL); + } -printf (" %d channels, %d bits/sample, block align = %d\n", - s->channels, s->bits, s->block_align); + 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 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->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2); - /* 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]; + avcodec_get_frame_defaults(&s->frame); + avctx->coded_frame = &s->frame; + + 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) { +static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size, + int channels) +{ + int ch; + const uint8_t *buf_end = buf + buf_size; + int predictor[2]; + int st = channels - 1; + + /* decode initial raw sample */ + for (ch = 0; ch < channels; ch++) { + predictor[ch] = (int16_t)AV_RL16(buf); + buf += 2; + *out++ = predictor[ch]; + } + /* decode DPCM samples */ + ch = 0; + while (buf < buf_end) { + uint8_t b = *buf++; + if (b & 0x80) + predictor[ch] -= vmdaudio_table[b & 0x7F]; + else + predictor[ch] += vmdaudio_table[b]; + predictor[ch] = av_clip_int16(predictor[ch]); + *out++ = predictor[ch]; + ch ^= st; + } } -static void vmdaudio_loadsound(VmdAudioContext *s, unsigned char *data, - uint8_t *buf, int silence) +static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) { - if (s->channels == 2) { - 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); + const uint8_t *buf = avpkt->data; + const uint8_t *buf_end; + int buf_size = avpkt->size; + VmdAudioContext *s = avctx->priv_data; + int block_type, silent_chunks, audio_chunks; + int ret; + uint8_t *output_samples_u8; + int16_t *output_samples_s16; + + if (buf_size < 16) { + av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n"); + *got_frame_ptr = 0; + return buf_size; + } + + 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; + + /* get number of silent chunks */ + silent_chunks = 0; + if (block_type == BLOCK_TYPE_INITIAL) { + uint32_t flags; + if (buf_size < 4) { + av_log(avctx, AV_LOG_ERROR, "packet is too small\n"); + return AVERROR(EINVAL); } - } else { + 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 } -} -static int vmdaudio_decode_frame(AVCodecContext *avctx, - void *data, int *data_size, - uint8_t *buf, int buf_size) -{ - VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data; - unsigned int sound_flags; - unsigned char *output_samples = (unsigned char *)data; + /* ensure output buffer is large enough */ + audio_chunks = buf_size / s->chunk_size; - /* point to the start of the encoded data */ - unsigned char *p = buf + 16; - unsigned char *p_end = buf + buf_size; - - if (buf[6] == 1) { - /* the chunk contains audio */ - vmdaudio_loadsound(s, output_samples, p, 0); - } else if (buf[6] == 2) { - /* 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) - /* audio */ - vmdaudio_loadsound(s, output_samples, p, 1); - else - /* silence */ - vmdaudio_loadsound(s, output_samples, p, 0); - p += s->block_align; - output_samples += (s->block_align * s->bits / 8); - sound_flags >>= 1; + /* get output buffer */ + s->frame.nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels; + if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) { + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return ret; + } + output_samples_u8 = s->frame.data[0]; + output_samples_s16 = (int16_t *)s->frame.data[0]; + + /* decode silent chunks */ + if (silent_chunks > 0) { + int silent_size = avctx->block_align * silent_chunks; + if (s->out_bps == 2) { + memset(output_samples_s16, 0x00, silent_size * 2); + output_samples_s16 += silent_size; + } else { + memset(output_samples_u8, 0x80, silent_size); + output_samples_u8 += silent_size; } - } else if (buf[6] == 3) { - /* silent chunk */ - vmdaudio_loadsound(s, output_samples, p, 1); } + /* decode audio chunks */ + if (audio_chunks > 0) { + buf_end = buf + buf_size; + while (buf < buf_end) { + if (s->out_bps == 2) { + decode_audio_s16(output_samples_s16, buf, s->chunk_size, + avctx->channels); + output_samples_s16 += avctx->block_align; + } else { + memcpy(output_samples_u8, buf, s->chunk_size); + output_samples_u8 += avctx->block_align; + } + buf += s->chunk_size; + } + } -// *datasize = ; - return buf_size; + *got_frame_ptr = 1; + *(AVFrame *)data = s->frame; + + return avpkt->size; } @@ -524,25 +649,25 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx, * Public Data Structures */ -AVCodec vmdvideo_decoder = { - "vmdvideo", - CODEC_TYPE_VIDEO, - CODEC_ID_VMDVIDEO, - sizeof(VmdVideoContext), - vmdvideo_decode_init, - NULL, - vmdvideo_decode_end, - vmdvideo_decode_frame, - CODEC_CAP_DR1, +AVCodec ff_vmdvideo_decoder = { + .name = "vmdvideo", + .type = AVMEDIA_TYPE_VIDEO, + .id = CODEC_ID_VMDVIDEO, + .priv_data_size = sizeof(VmdVideoContext), + .init = vmdvideo_decode_init, + .close = vmdvideo_decode_end, + .decode = vmdvideo_decode_frame, + .capabilities = CODEC_CAP_DR1, + .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"), }; -AVCodec vmdaudio_decoder = { - "vmdaudio", - CODEC_TYPE_AUDIO, - CODEC_ID_VMDAUDIO, - sizeof(VmdAudioContext), - vmdaudio_decode_init, - NULL, - NULL, - vmdaudio_decode_frame, +AVCodec ff_vmdaudio_decoder = { + .name = "vmdaudio", + .type = AVMEDIA_TYPE_AUDIO, + .id = CODEC_ID_VMDAUDIO, + .priv_data_size = sizeof(VmdAudioContext), + .init = vmdaudio_decode_init, + .decode = vmdaudio_decode_frame, + .capabilities = CODEC_CAP_DR1, + .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"), };