2 * Sierra VMD Audio & Video Decoders
3 * Copyright (C) 2004 the ffmpeg project
5 * This file is part of FFmpeg.
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.
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.
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
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/
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.
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.
46 #include "libavutil/intreadwrite.h"
49 #define VMD_HEADER_SIZE 0x330
50 #define PALETTE_COUNT 256
56 typedef struct VmdVideoContext {
58 AVCodecContext *avctx;
62 const unsigned char *buf;
65 unsigned char palette[PALETTE_COUNT * 4];
66 unsigned char *unpack_buffer;
67 int unpack_buffer_size;
72 #define QUEUE_SIZE 0x1000
73 #define QUEUE_MASK 0x0FFF
75 static void lz_unpack(const unsigned char *src, int src_len,
76 unsigned char *dest, int dest_len)
78 const unsigned char *s;
79 const unsigned char *s_end;
82 unsigned char queue[QUEUE_SIZE];
84 unsigned int dataleft;
85 unsigned int chainofs;
86 unsigned int chainlen;
92 s_end = src + src_len;
98 dataleft = AV_RL32(s);
100 memset(queue, 0x20, QUEUE_SIZE);
101 if (AV_RL32(s) == 0x56781234) {
107 speclen = 100; /* no speclen */
110 while (s_end - s > 0 && dataleft > 0) {
112 if ((tag == 0xFF) && (dataleft > 8)) {
113 if (d_end - d < 8 || s_end - s < 8)
115 for (i = 0; i < 8; i++) {
116 queue[qpos++] = *d++ = *s++;
121 for (i = 0; i < 8; i++) {
125 if (d_end - d < 1 || s_end - s < 1)
127 queue[qpos++] = *d++ = *s++;
134 chainofs |= ((*s & 0xF0) << 4);
135 chainlen = (*s++ & 0x0F) + 3;
136 if (chainlen == speclen) {
139 chainlen = *s++ + 0xF + 3;
141 if (d_end - d < chainlen)
143 for (j = 0; j < chainlen; j++) {
144 *d = queue[chainofs++ & QUEUE_MASK];
145 queue[qpos++] = *d++;
148 dataleft -= chainlen;
156 static int rle_unpack(const unsigned char *src, int src_len, int src_count,
157 unsigned char *dest, int dest_len)
159 const unsigned char *ps;
160 const unsigned char *ps_end;
163 unsigned char *dest_end = dest + dest_len;
166 ps_end = src + src_len;
182 if (dest_end - pd < l || ps_end - ps < l)
188 if (dest_end - pd < i || ps_end - ps < 2)
190 for (i = 0; i < l; i++) {
197 } while (i < src_count);
202 static void vmd_decode(VmdVideoContext *s)
205 unsigned int *palette32;
206 unsigned char r, g, b;
208 /* point to the start of the encoded data */
209 const unsigned char *p = s->buf + 16;
210 const unsigned char *p_end = s->buf + s->size;
212 const unsigned char *pb;
213 const unsigned char *pb_end;
215 unsigned char *dp; /* pointer to current frame */
216 unsigned char *pp; /* pointer to previous frame */
220 int frame_x, frame_y;
221 int frame_width, frame_height;
223 frame_x = AV_RL16(&s->buf[6]);
224 frame_y = AV_RL16(&s->buf[8]);
225 frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
226 frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
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)
232 if (frame_y < 0 || frame_height < 0 ||
233 frame_y >= s->avctx->height ||
234 frame_height > s->avctx->height ||
235 frame_y + frame_height > s->avctx->height)
238 if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
239 (frame_x || frame_y)) {
247 /* if only a certain region will be updated, copy the entire previous
248 * frame before the decode */
249 if (s->prev_frame.data[0] &&
250 (frame_x || frame_y || (frame_width != s->avctx->width) ||
251 (frame_height != s->avctx->height))) {
253 memcpy(s->frame.data[0], s->prev_frame.data[0],
254 s->avctx->height * s->frame.linesize[0]);
257 /* check if there is a new palette */
258 if (s->buf[15] & 0x02) {
259 if (p_end - p < 2 + 3 * PALETTE_COUNT)
262 palette32 = (unsigned int *)s->palette;
263 for (i = 0; i < PALETTE_COUNT; i++) {
267 palette32[i] = 0xFF << 24 | r << 16 | g << 8 | b;
268 palette32[i] |= palette32[i] >> 6 & 0x30303;
272 /* originally UnpackFrame in VAG's code */
277 lz_unpack(pb, p_end - pb, s->unpack_buffer, s->unpack_buffer_size);
279 pb = s->unpack_buffer;
280 pb_end = s->unpack_buffer + s->unpack_buffer_size;
283 dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];
284 pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
287 for (i = 0; i < frame_height; i++) {
294 len = (len & 0x7F) + 1;
295 if (ofs + len > frame_width || pb_end - pb < len)
297 memcpy(&dp[ofs], pb, len);
301 /* interframe pixel copy */
302 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
304 memcpy(&dp[ofs], &pp[ofs], len + 1);
307 } while (ofs < frame_width);
308 if (ofs > frame_width) {
309 av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
313 dp += s->frame.linesize[0];
314 pp += s->prev_frame.linesize[0];
319 for (i = 0; i < frame_height; i++) {
320 if (pb_end -pb < frame_width)
322 memcpy(dp, pb, frame_width);
324 dp += s->frame.linesize[0];
325 pp += s->prev_frame.linesize[0];
330 for (i = 0; i < frame_height; i++) {
337 len = (len & 0x7F) + 1;
341 len = rle_unpack(pb, pb_end - pb, len, &dp[ofs], frame_width - ofs);
343 if (pb_end - pb < len)
345 memcpy(&dp[ofs], pb, len);
350 /* interframe pixel copy */
351 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
353 memcpy(&dp[ofs], &pp[ofs], len + 1);
356 } while (ofs < frame_width);
357 if (ofs > frame_width) {
358 av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
361 dp += s->frame.linesize[0];
362 pp += s->prev_frame.linesize[0];
369 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
371 VmdVideoContext *s = avctx->priv_data;
373 unsigned int *palette32;
374 int palette_index = 0;
375 unsigned char r, g, b;
376 unsigned char *vmd_header;
377 unsigned char *raw_palette;
380 avctx->pix_fmt = PIX_FMT_PAL8;
382 /* make sure the VMD header made it */
383 if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
384 av_log(s->avctx, AV_LOG_ERROR, "VMD video: expected extradata size of %d\n",
388 vmd_header = (unsigned char *)avctx->extradata;
390 s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
391 s->unpack_buffer = av_malloc(s->unpack_buffer_size);
392 if (!s->unpack_buffer)
395 /* load up the initial palette */
396 raw_palette = &vmd_header[28];
397 palette32 = (unsigned int *)s->palette;
398 for (i = 0; i < PALETTE_COUNT; i++) {
399 r = raw_palette[palette_index++] * 4;
400 g = raw_palette[palette_index++] * 4;
401 b = raw_palette[palette_index++] * 4;
402 palette32[i] = (r << 16) | (g << 8) | (b);
405 avcodec_get_frame_defaults(&s->frame);
406 avcodec_get_frame_defaults(&s->prev_frame);
411 static int vmdvideo_decode_frame(AVCodecContext *avctx,
412 void *data, int *data_size,
415 const uint8_t *buf = avpkt->data;
416 int buf_size = avpkt->size;
417 VmdVideoContext *s = avctx->priv_data;
425 s->frame.reference = 3;
426 if (avctx->get_buffer(avctx, &s->frame)) {
427 av_log(s->avctx, AV_LOG_ERROR, "VMD Video: get_buffer() failed\n");
433 /* make the palette available on the way out */
434 memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
437 FFSWAP(AVFrame, s->frame, s->prev_frame);
438 if (s->frame.data[0])
439 avctx->release_buffer(avctx, &s->frame);
441 *data_size = sizeof(AVFrame);
442 *(AVFrame*)data = s->prev_frame;
444 /* report that the buffer was completely consumed */
448 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
450 VmdVideoContext *s = avctx->priv_data;
452 if (s->prev_frame.data[0])
453 avctx->release_buffer(avctx, &s->prev_frame);
454 av_free(s->unpack_buffer);
464 #define BLOCK_TYPE_AUDIO 1
465 #define BLOCK_TYPE_INITIAL 2
466 #define BLOCK_TYPE_SILENCE 3
468 typedef struct VmdAudioContext {
474 static const uint16_t vmdaudio_table[128] = {
475 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
476 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
477 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
478 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
479 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
480 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
481 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
482 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
483 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
484 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
485 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
486 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
487 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
490 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
492 VmdAudioContext *s = avctx->priv_data;
494 if (avctx->channels < 1 || avctx->channels > 2) {
495 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
496 return AVERROR(EINVAL);
498 if (avctx->block_align < 1) {
499 av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
500 return AVERROR(EINVAL);
503 if (avctx->bits_per_coded_sample == 16)
504 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
506 avctx->sample_fmt = AV_SAMPLE_FMT_U8;
507 s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
509 s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
511 avcodec_get_frame_defaults(&s->frame);
512 avctx->coded_frame = &s->frame;
514 av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
515 "block align = %d, sample rate = %d\n",
516 avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
522 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
526 const uint8_t *buf_end = buf + buf_size;
528 int st = channels - 1;
530 /* decode initial raw sample */
531 for (ch = 0; ch < channels; ch++) {
532 predictor[ch] = (int16_t)AV_RL16(buf);
534 *out++ = predictor[ch];
537 /* decode DPCM samples */
539 while (buf < buf_end) {
542 predictor[ch] -= vmdaudio_table[b & 0x7F];
544 predictor[ch] += vmdaudio_table[b];
545 predictor[ch] = av_clip_int16(predictor[ch]);
546 *out++ = predictor[ch];
551 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
552 int *got_frame_ptr, AVPacket *avpkt)
554 const uint8_t *buf = avpkt->data;
555 const uint8_t *buf_end;
556 int buf_size = avpkt->size;
557 VmdAudioContext *s = avctx->priv_data;
558 int block_type, silent_chunks, audio_chunks;
560 uint8_t *output_samples_u8;
561 int16_t *output_samples_s16;
564 av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
570 if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
571 av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
572 return AVERROR(EINVAL);
577 /* get number of silent chunks */
579 if (block_type == BLOCK_TYPE_INITIAL) {
582 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
583 return AVERROR(EINVAL);
585 flags = AV_RB32(buf);
586 silent_chunks = av_popcount(flags);
589 } else if (block_type == BLOCK_TYPE_SILENCE) {
591 buf_size = 0; // should already be zero but set it just to be sure
594 /* ensure output buffer is large enough */
595 audio_chunks = buf_size / s->chunk_size;
597 /* get output buffer */
598 s->frame.nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels;
599 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
600 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
603 output_samples_u8 = s->frame.data[0];
604 output_samples_s16 = (int16_t *)s->frame.data[0];
606 /* decode silent chunks */
607 if (silent_chunks > 0) {
608 int silent_size = avctx->block_align * silent_chunks;
609 if (s->out_bps == 2) {
610 memset(output_samples_s16, 0x00, silent_size * 2);
611 output_samples_s16 += silent_size;
613 memset(output_samples_u8, 0x80, silent_size);
614 output_samples_u8 += silent_size;
618 /* decode audio chunks */
619 if (audio_chunks > 0) {
620 buf_end = buf + buf_size;
621 while ( buf_end - buf >= s->chunk_size) {
622 if (s->out_bps == 2) {
623 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
625 output_samples_s16 += avctx->block_align;
627 memcpy(output_samples_u8, buf, s->chunk_size);
628 output_samples_u8 += avctx->block_align;
630 buf += s->chunk_size;
635 *(AVFrame *)data = s->frame;
642 * Public Data Structures
645 AVCodec ff_vmdvideo_decoder = {
647 .type = AVMEDIA_TYPE_VIDEO,
648 .id = CODEC_ID_VMDVIDEO,
649 .priv_data_size = sizeof(VmdVideoContext),
650 .init = vmdvideo_decode_init,
651 .close = vmdvideo_decode_end,
652 .decode = vmdvideo_decode_frame,
653 .capabilities = CODEC_CAP_DR1,
654 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
657 AVCodec ff_vmdaudio_decoder = {
659 .type = AVMEDIA_TYPE_AUDIO,
660 .id = CODEC_ID_VMDAUDIO,
661 .priv_data_size = sizeof(VmdAudioContext),
662 .init = vmdaudio_decode_init,
663 .decode = vmdaudio_decode_frame,
664 .capabilities = CODEC_CAP_DR1,
665 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),