X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fvmdav.c;h=47a16d86550e821f2074ba0e1b67b5654dc33996;hb=b6a6e90a7c79f9530637a1efb62e0af4049822c1;hp=359b23717ed21d401462600a3763029dc7022ba8;hpb=b78e7197a81e193827cf2408fe25bc1f14843a72;p=ffmpeg diff --git a/libavcodec/vmdav.c b/libavcodec/vmdav.c index 359b23717ed..47a16d86550 100644 --- a/libavcodec/vmdav.c +++ b/libavcodec/vmdav.c @@ -2,26 +2,25 @@ * Sierra VMD Audio & Video Decoders * Copyright (C) 2004 the ffmpeg project * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * 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.1 of the License, or (at your option) any later version. * - * FFmpeg 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 FFmpeg; if not, write to the Free Software + * 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: @@ -43,11 +42,9 @@ #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 @@ -59,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, int dest_len) +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]; @@ -90,13 +89,16 @@ static void lz_unpack(unsigned char *src, unsigned char *dest, int dest_len) unsigned int i, j; s = src; + s_len = src_len; d = dest; d_end = d + dest_len; - dataleft = LE_32(s); - s += 4; + dataleft = AV_RL32(s); + s += 4; s_len -= 4; memset(queue, 0x20, QUEUE_SIZE); - if (LE_32(s) == 0x56781234) { - s += 4; + if (s_len < 4) + return; + if (AV_RL32(s) == 0x56781234) { + s += 4; s_len -= 4; qpos = 0x111; speclen = 0xF + 3; } else { @@ -104,32 +106,41 @@ static void lz_unpack(unsigned char *src, unsigned char *dest, int dest_len) 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) + 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) + 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++) { @@ -145,43 +156,52 @@ static void lz_unpack(unsigned char *src, unsigned char *dest, int dest_len) } } -static int rle_unpack(unsigned char *src, unsigned char *dest, - int src_len, int dest_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 (src_len & 1) + if (src_count & 1) { + if (src_size < 1) + return 0; *pd++ = *ps++; + src_size--; + } - src_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) - return (ps - src); + 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) - return (ps - src); + 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 < src_len); + } while (i < src_count); - return (ps - src); + return ps - src; } static void vmd_decode(VmdVideoContext *s) @@ -191,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 */ @@ -202,17 +223,36 @@ static void vmd_decode(VmdVideoContext *s) int frame_x, frame_y; int frame_width, frame_height; - int dp_size; - 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], s->avctx->height * s->frame.linesize[0]); @@ -230,35 +270,43 @@ 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, s->unpack_buffer_size); + 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]; - dp_size = s->frame.linesize[0] * s->avctx->height; pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x]; switch (meth) { case 1: 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) + 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) + if (ofs + len + 1 > frame_width || !s->prev_frame.data[0]) return; memcpy(&dp[ofs], &pp[ofs], len + 1); ofs += len + 1; @@ -276,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]; } @@ -287,18 +338,27 @@ 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[ofs], len, frame_width - ofs); - 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) + if (ofs + len + 1 > frame_width || !s->prev_frame.data[0]) return; memcpy(&dp[ofs], &pp[ofs], len + 1); ofs += len + 1; @@ -316,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; @@ -328,8 +388,6 @@ 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) { @@ -339,7 +397,7 @@ static int vmdvideo_decode_init(AVCodecContext *avctx) } vmd_header = (unsigned char *)avctx->extradata; - s->unpack_buffer_size = 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; @@ -354,16 +412,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; @@ -382,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); @@ -411,15 +468,17 @@ 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 { - AVCodecContext *avctx; - int channels; - int bits; - int block_align; - int predictors[2]; + AVFrame frame; + int out_bps; + int chunk_size; } VmdAudioContext; -static uint16_t vmdaudio_table[128] = { +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, @@ -435,123 +494,154 @@ static uint16_t vmdaudio_table[128] = { 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000 }; -static int vmdaudio_decode_init(AVCodecContext *avctx) +static av_cold int vmdaudio_decode_init(AVCodecContext *avctx) { - VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data; + VmdAudioContext *s = avctx->priv_data; - s->avctx = avctx; - 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); + } + + 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); + + s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2); - av_log(s->avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, block align = %d, sample rate = %d\n", - s->channels, s->bits, s->block_align, avctx->sample_rate); + 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 stereo) +static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size, + int channels) { - int i; - int chan = 0; - int16_t *out = (int16_t*)data; + 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]; + } - for(i = 0; i < s->block_align; i++) { - if(buf[i] & 0x80) - s->predictors[chan] -= vmdaudio_table[buf[i] & 0x7F]; + /* decode DPCM samples */ + ch = 0; + while (buf < buf_end) { + uint8_t b = *buf++; + if (b & 0x80) + predictor[ch] -= vmdaudio_table[b & 0x7F]; else - s->predictors[chan] += vmdaudio_table[buf[i]]; - s->predictors[chan] = clip(s->predictors[chan], -32768, 32767); - out[i] = s->predictors[chan]; - chan ^= stereo; + predictor[ch] += vmdaudio_table[b]; + predictor[ch] = av_clip_int16(predictor[ch]); + *out++ = predictor[ch]; + ch ^= st; } } -static int 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) { - int bytes_decoded = 0; - int i; - -// if (silence) -// av_log(s->avctx, AV_LOG_INFO, "silent block!\n"); - if (s->channels == 2) { + 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; + } - /* stereo handling */ - if (silence) { - memset(data, 0, s->block_align * 2); - } else { - if (s->bits == 16) - vmdaudio_decode_audio(s, data, buf, 1); - else - /* copy the data but convert it to signed */ - for (i = 0; i < s->block_align; i++) - data[i * 2 + 1] = buf[i] + 0x80; + 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 { - bytes_decoded = s->block_align * 2; + 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 + } + + /* ensure output buffer is large enough */ + audio_chunks = buf_size / s->chunk_size; - /* mono handling */ - if (silence) { - memset(data, 0, s->block_align * 2); + /* 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 { - if (s->bits == 16) { - vmdaudio_decode_audio(s, data, buf, 0); - } else { - /* copy the data but convert it to signed */ - for (i = 0; i < s->block_align; i++) - data[i * 2 + 1] = buf[i] + 0x80; - } + memset(output_samples_u8, 0x80, silent_size); + output_samples_u8 += silent_size; } } - return s->block_align * 2; -} - -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; - - /* point to the start of the encoded data */ - unsigned char *p = buf + 16; - unsigned char *p_end = buf + buf_size; - - if (buf_size < 16) - return buf_size; - - if (buf[6] == 1) { - /* the chunk contains audio */ - *data_size = 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) - /* 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; + /* 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; } - output_samples += (s->block_align * s->bits / 8); - sound_flags >>= 1; + buf += s->chunk_size; } - } else if (buf[6] == 3) { - /* silent chunk */ - *data_size = vmdaudio_loadsound(s, output_samples, p, 1); } - return buf_size; + *got_frame_ptr = 1; + *(AVFrame *)data = s->frame; + + return avpkt->size; } @@ -559,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"), };