2 * Sierra VMD Audio & Video Decoders
3 * Copyright (C) 2004 the ffmpeg project
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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/channel_layout.h"
47 #include "libavutil/common.h"
48 #include "libavutil/intreadwrite.h"
52 #define VMD_HEADER_SIZE 0x330
53 #define PALETTE_COUNT 256
59 typedef struct VmdVideoContext {
61 AVCodecContext *avctx;
65 const unsigned char *buf;
68 unsigned char palette[PALETTE_COUNT * 4];
69 unsigned char *unpack_buffer;
70 int unpack_buffer_size;
75 #define QUEUE_SIZE 0x1000
76 #define QUEUE_MASK 0x0FFF
78 static void lz_unpack(const unsigned char *src, int src_len,
79 unsigned char *dest, int dest_len)
81 const unsigned char *s;
85 unsigned char queue[QUEUE_SIZE];
87 unsigned int dataleft;
88 unsigned int chainofs;
89 unsigned int chainlen;
98 dataleft = AV_RL32(s);
100 memset(queue, 0x20, QUEUE_SIZE);
103 if (AV_RL32(s) == 0x56781234) {
109 speclen = 100; /* no speclen */
112 while (dataleft > 0 && s_len > 0) {
114 if ((tag == 0xFF) && (dataleft > 8)) {
115 if (d + 8 > d_end || s_len < 8)
117 for (i = 0; i < 8; i++) {
118 queue[qpos++] = *d++ = *s++;
124 for (i = 0; i < 8; i++) {
128 if (d + 1 > d_end || s_len < 1)
130 queue[qpos++] = *d++ = *s++;
138 chainofs |= ((*s & 0xF0) << 4);
139 chainlen = (*s++ & 0x0F) + 3;
141 if (chainlen == speclen) {
144 chainlen = *s++ + 0xF + 3;
147 if (d + chainlen > d_end)
149 for (j = 0; j < chainlen; j++) {
150 *d = queue[chainofs++ & QUEUE_MASK];
151 queue[qpos++] = *d++;
154 dataleft -= chainlen;
162 static int rle_unpack(const unsigned char *src, unsigned char *dest,
163 int src_count, int src_size, int dest_len)
165 const unsigned char *ps;
168 unsigned char *dest_end = dest + dest_len;
188 if (pd + l > dest_end || src_size < l)
195 if (pd + i > dest_end || src_size < 2)
197 for (i = 0; i < l; i++) {
205 } while (i < src_count);
210 static void vmd_decode(VmdVideoContext *s)
213 unsigned int *palette32;
214 unsigned char r, g, b;
216 /* point to the start of the encoded data */
217 const unsigned char *p = s->buf + 16;
219 const unsigned char *pb;
220 unsigned int pb_size;
222 unsigned char *dp; /* pointer to current frame */
223 unsigned char *pp; /* pointer to previous frame */
227 int frame_x, frame_y;
228 int frame_width, frame_height;
230 frame_x = AV_RL16(&s->buf[6]);
231 frame_y = AV_RL16(&s->buf[8]);
232 frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
233 frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
234 if (frame_x < 0 || frame_width < 0 ||
235 frame_x >= s->avctx->width ||
236 frame_width > s->avctx->width ||
237 frame_x + frame_width > s->avctx->width)
239 if (frame_y < 0 || frame_height < 0 ||
240 frame_y >= s->avctx->height ||
241 frame_height > s->avctx->height ||
242 frame_y + frame_height > s->avctx->height)
245 if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
246 (frame_x || frame_y)) {
254 /* if only a certain region will be updated, copy the entire previous
255 * frame before the decode */
256 if (s->prev_frame.data[0] &&
257 (frame_x || frame_y || (frame_width != s->avctx->width) ||
258 (frame_height != s->avctx->height))) {
260 memcpy(s->frame.data[0], s->prev_frame.data[0],
261 s->avctx->height * s->frame.linesize[0]);
264 /* check if there is a new palette */
265 if (s->buf[15] & 0x02) {
267 palette32 = (unsigned int *)s->palette;
268 for (i = 0; i < PALETTE_COUNT; i++) {
272 palette32[i] = (r << 16) | (g << 8) | (b);
274 s->size -= (256 * 3 + 2);
277 /* originally UnpackFrame in VAG's code */
279 pb_size = s->buf + s->size - pb;
282 meth = *pb++; pb_size--;
284 lz_unpack(pb, pb_size,
285 s->unpack_buffer, s->unpack_buffer_size);
287 pb = s->unpack_buffer;
288 pb_size = s->unpack_buffer_size;
291 dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];
292 pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
295 for (i = 0; i < frame_height; i++) {
303 len = (len & 0x7F) + 1;
304 if (ofs + len > frame_width || pb_size < len)
306 memcpy(&dp[ofs], pb, len);
311 /* interframe pixel copy */
312 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
314 memcpy(&dp[ofs], &pp[ofs], len + 1);
317 } while (ofs < frame_width);
318 if (ofs > frame_width) {
319 av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
323 dp += s->frame.linesize[0];
324 pp += s->prev_frame.linesize[0];
329 for (i = 0; i < frame_height; i++) {
330 if (pb_size < frame_width)
332 memcpy(dp, pb, frame_width);
334 pb_size -= frame_width;
335 dp += s->frame.linesize[0];
336 pp += s->prev_frame.linesize[0];
341 for (i = 0; i < frame_height; i++) {
349 len = (len & 0x7F) + 1;
353 len = rle_unpack(pb, &dp[ofs], len, pb_size, frame_width - ofs);
357 memcpy(&dp[ofs], pb, len);
363 /* interframe pixel copy */
364 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
366 memcpy(&dp[ofs], &pp[ofs], len + 1);
369 } while (ofs < frame_width);
370 if (ofs > frame_width) {
371 av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
374 dp += s->frame.linesize[0];
375 pp += s->prev_frame.linesize[0];
382 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
384 VmdVideoContext *s = avctx->priv_data;
386 unsigned int *palette32;
387 int palette_index = 0;
388 unsigned char r, g, b;
389 unsigned char *vmd_header;
390 unsigned char *raw_palette;
393 avctx->pix_fmt = AV_PIX_FMT_PAL8;
395 /* make sure the VMD header made it */
396 if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
397 av_log(s->avctx, AV_LOG_ERROR, "VMD video: expected extradata size of %d\n",
401 vmd_header = (unsigned char *)avctx->extradata;
403 s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
404 s->unpack_buffer = av_malloc(s->unpack_buffer_size);
405 if (!s->unpack_buffer)
408 /* load up the initial palette */
409 raw_palette = &vmd_header[28];
410 palette32 = (unsigned int *)s->palette;
411 for (i = 0; i < PALETTE_COUNT; i++) {
412 r = raw_palette[palette_index++] * 4;
413 g = raw_palette[palette_index++] * 4;
414 b = raw_palette[palette_index++] * 4;
415 palette32[i] = (r << 16) | (g << 8) | (b);
421 static int vmdvideo_decode_frame(AVCodecContext *avctx,
422 void *data, int *got_frame,
425 const uint8_t *buf = avpkt->data;
426 int buf_size = avpkt->size;
427 VmdVideoContext *s = avctx->priv_data;
435 s->frame.reference = 1;
436 if (ff_get_buffer(avctx, &s->frame)) {
437 av_log(s->avctx, AV_LOG_ERROR, "VMD Video: get_buffer() failed\n");
443 /* make the palette available on the way out */
444 memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
447 FFSWAP(AVFrame, s->frame, s->prev_frame);
448 if (s->frame.data[0])
449 avctx->release_buffer(avctx, &s->frame);
452 *(AVFrame*)data = s->prev_frame;
454 /* report that the buffer was completely consumed */
458 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
460 VmdVideoContext *s = avctx->priv_data;
462 if (s->prev_frame.data[0])
463 avctx->release_buffer(avctx, &s->prev_frame);
464 av_free(s->unpack_buffer);
474 #define BLOCK_TYPE_AUDIO 1
475 #define BLOCK_TYPE_INITIAL 2
476 #define BLOCK_TYPE_SILENCE 3
478 typedef struct VmdAudioContext {
483 static const uint16_t vmdaudio_table[128] = {
484 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
485 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
486 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
487 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
488 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
489 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
490 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
491 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
492 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
493 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
494 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
495 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
496 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
499 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
501 VmdAudioContext *s = avctx->priv_data;
503 if (avctx->channels < 1 || avctx->channels > 2) {
504 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
505 return AVERROR(EINVAL);
507 if (avctx->block_align < 1) {
508 av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
509 return AVERROR(EINVAL);
512 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
515 if (avctx->bits_per_coded_sample == 16)
516 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
518 avctx->sample_fmt = AV_SAMPLE_FMT_U8;
519 s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
521 s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
523 av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
524 "block align = %d, sample rate = %d\n",
525 avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
531 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
535 const uint8_t *buf_end = buf + buf_size;
537 int st = channels - 1;
539 /* decode initial raw sample */
540 for (ch = 0; ch < channels; ch++) {
541 predictor[ch] = (int16_t)AV_RL16(buf);
543 *out++ = predictor[ch];
546 /* decode DPCM samples */
548 while (buf < buf_end) {
551 predictor[ch] -= vmdaudio_table[b & 0x7F];
553 predictor[ch] += vmdaudio_table[b];
554 predictor[ch] = av_clip_int16(predictor[ch]);
555 *out++ = predictor[ch];
560 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
561 int *got_frame_ptr, AVPacket *avpkt)
563 AVFrame *frame = data;
564 const uint8_t *buf = avpkt->data;
565 const uint8_t *buf_end;
566 int buf_size = avpkt->size;
567 VmdAudioContext *s = avctx->priv_data;
568 int block_type, silent_chunks, audio_chunks;
570 uint8_t *output_samples_u8;
571 int16_t *output_samples_s16;
574 av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
580 if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
581 av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
582 return AVERROR(EINVAL);
587 /* get number of silent chunks */
589 if (block_type == BLOCK_TYPE_INITIAL) {
592 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
593 return AVERROR(EINVAL);
595 flags = AV_RB32(buf);
596 silent_chunks = av_popcount(flags);
599 } else if (block_type == BLOCK_TYPE_SILENCE) {
601 buf_size = 0; // should already be zero but set it just to be sure
604 /* ensure output buffer is large enough */
605 audio_chunks = buf_size / s->chunk_size;
607 /* get output buffer */
608 frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
610 if ((ret = ff_get_buffer(avctx, frame)) < 0) {
611 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
614 output_samples_u8 = frame->data[0];
615 output_samples_s16 = (int16_t *)frame->data[0];
617 /* decode silent chunks */
618 if (silent_chunks > 0) {
619 int silent_size = avctx->block_align * silent_chunks;
620 if (s->out_bps == 2) {
621 memset(output_samples_s16, 0x00, silent_size * 2);
622 output_samples_s16 += silent_size;
624 memset(output_samples_u8, 0x80, silent_size);
625 output_samples_u8 += silent_size;
629 /* decode audio chunks */
630 if (audio_chunks > 0) {
631 buf_end = buf + buf_size;
632 while (buf < buf_end) {
633 if (s->out_bps == 2) {
634 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
636 output_samples_s16 += avctx->block_align;
638 memcpy(output_samples_u8, buf, s->chunk_size);
639 output_samples_u8 += avctx->block_align;
641 buf += s->chunk_size;
652 * Public Data Structures
655 AVCodec ff_vmdvideo_decoder = {
657 .type = AVMEDIA_TYPE_VIDEO,
658 .id = AV_CODEC_ID_VMDVIDEO,
659 .priv_data_size = sizeof(VmdVideoContext),
660 .init = vmdvideo_decode_init,
661 .close = vmdvideo_decode_end,
662 .decode = vmdvideo_decode_frame,
663 .capabilities = CODEC_CAP_DR1,
664 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
667 AVCodec ff_vmdaudio_decoder = {
669 .type = AVMEDIA_TYPE_AUDIO,
670 .id = AV_CODEC_ID_VMDAUDIO,
671 .priv_data_size = sizeof(VmdAudioContext),
672 .init = vmdaudio_decode_init,
673 .decode = vmdaudio_decode_frame,
674 .capabilities = CODEC_CAP_DR1,
675 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),