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/channel_layout.h"
47 #include "libavutil/common.h"
48 #include "libavutil/intreadwrite.h"
51 #include "bytestream.h"
53 #define VMD_HEADER_SIZE 0x330
54 #define PALETTE_COUNT 256
60 typedef struct VmdVideoContext {
62 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)
83 unsigned char queue[QUEUE_SIZE];
85 unsigned int dataleft;
86 unsigned int chainofs;
87 unsigned int chainlen;
93 bytestream2_init(&gb, src, src_len);
96 dataleft = bytestream2_get_le32(&gb);
97 memset(queue, 0x20, QUEUE_SIZE);
98 if (bytestream2_get_bytes_left(&gb) < 4)
100 if (bytestream2_peek_le32(&gb) == 0x56781234) {
101 bytestream2_skipu(&gb, 4);
106 speclen = 100; /* no speclen */
109 while (dataleft > 0 && bytestream2_get_bytes_left(&gb) > 0) {
110 tag = bytestream2_get_byteu(&gb);
111 if ((tag == 0xFF) && (dataleft > 8)) {
112 if (d_end - d < 8 || bytestream2_get_bytes_left(&gb) < 8)
114 for (i = 0; i < 8; i++) {
115 queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
120 for (i = 0; i < 8; i++) {
124 if (d_end - d < 1 || bytestream2_get_bytes_left(&gb) < 1)
126 queue[qpos++] = *d++ = bytestream2_get_byteu(&gb);
130 chainofs = bytestream2_get_byte(&gb);
131 chainofs |= ((bytestream2_peek_byte(&gb) & 0xF0) << 4);
132 chainlen = (bytestream2_get_byte(&gb) & 0x0F) + 3;
133 if (chainlen == speclen) {
134 chainlen = bytestream2_get_byte(&gb) + 0xF + 3;
136 if (d_end - d < chainlen)
138 for (j = 0; j < chainlen; j++) {
139 *d = queue[chainofs++ & QUEUE_MASK];
140 queue[qpos++] = *d++;
143 dataleft -= chainlen;
150 static int rle_unpack(const unsigned char *src, unsigned char *dest,
151 int src_count, int src_size, int dest_len)
155 unsigned char *dest_end = dest + dest_len;
158 bytestream2_init(&gb, src, src_size);
161 if (bytestream2_get_bytes_left(&gb) < 1)
163 *pd++ = bytestream2_get_byteu(&gb);
169 if (bytestream2_get_bytes_left(&gb) < 1)
171 l = bytestream2_get_byteu(&gb);
174 if (dest_end - pd < l || bytestream2_get_bytes_left(&gb) < l)
175 return bytestream2_tell(&gb);
176 bytestream2_get_bufferu(&gb, pd, l);
180 if (dest_end - pd < 2*l || bytestream2_get_bytes_left(&gb) < 2)
181 return bytestream2_tell(&gb);
182 ps[0] = bytestream2_get_byteu(&gb);
183 ps[1] = bytestream2_get_byteu(&gb);
184 for (j = 0; j < l; j++) {
190 } while (i < src_count);
192 return bytestream2_tell(&gb);
195 static int vmd_decode(VmdVideoContext *s, AVFrame *frame)
198 unsigned int *palette32;
199 unsigned char r, g, b;
204 unsigned char *dp; /* pointer to current frame */
205 unsigned char *pp; /* pointer to previous frame */
209 int frame_x, frame_y;
210 int frame_width, frame_height;
212 frame_x = AV_RL16(&s->buf[6]);
213 frame_y = AV_RL16(&s->buf[8]);
214 frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
215 frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
217 if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
218 (frame_x || frame_y)) {
226 if (frame_x < 0 || frame_width < 0 ||
227 frame_x >= s->avctx->width ||
228 frame_width > s->avctx->width ||
229 frame_x + frame_width > s->avctx->width) {
230 return AVERROR_INVALIDDATA;
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) {
236 return AVERROR_INVALIDDATA;
239 /* if only a certain region will be updated, copy the entire previous
240 * frame before the decode */
241 if (s->prev_frame.data[0] &&
242 (frame_x || frame_y || (frame_width != s->avctx->width) ||
243 (frame_height != s->avctx->height))) {
245 memcpy(frame->data[0], s->prev_frame.data[0],
246 s->avctx->height * frame->linesize[0]);
249 /* check if there is a new palette */
250 bytestream2_init(&gb, s->buf + 16, s->size - 16);
251 if (s->buf[15] & 0x02) {
252 bytestream2_skip(&gb, 2);
253 palette32 = (unsigned int *)s->palette;
254 if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {
255 for (i = 0; i < PALETTE_COUNT; i++) {
256 r = bytestream2_get_byteu(&gb) * 4;
257 g = bytestream2_get_byteu(&gb) * 4;
258 b = bytestream2_get_byteu(&gb) * 4;
259 palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);
260 palette32[i] |= palette32[i] >> 6 & 0x30303;
265 /* originally UnpackFrame in VAG's code */
266 bytestream2_init(&gb, gb.buffer, s->buf + s->size - gb.buffer);
267 if (bytestream2_get_bytes_left(&gb) < 1)
268 return AVERROR_INVALIDDATA;
269 meth = bytestream2_get_byteu(&gb);
271 lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),
272 s->unpack_buffer, s->unpack_buffer_size);
274 bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);
277 dp = &frame->data[0][frame_y * frame->linesize[0] + frame_x];
278 pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
281 for (i = 0; i < frame_height; i++) {
284 len = bytestream2_get_byte(&gb);
286 len = (len & 0x7F) + 1;
287 if (ofs + len > frame_width || bytestream2_get_bytes_left(&gb) < len)
288 return AVERROR_INVALIDDATA;
289 bytestream2_get_bufferu(&gb, &dp[ofs], len);
292 /* interframe pixel copy */
293 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
294 return AVERROR_INVALIDDATA;
295 memcpy(&dp[ofs], &pp[ofs], len + 1);
298 } while (ofs < frame_width);
299 if (ofs > frame_width) {
300 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
304 dp += frame->linesize[0];
305 pp += s->prev_frame.linesize[0];
310 for (i = 0; i < frame_height; i++) {
311 bytestream2_get_buffer(&gb, dp, frame_width);
312 dp += frame->linesize[0];
313 pp += s->prev_frame.linesize[0];
318 for (i = 0; i < frame_height; i++) {
321 len = bytestream2_get_byte(&gb);
323 len = (len & 0x7F) + 1;
324 if (bytestream2_get_byte(&gb) == 0xFF)
325 len = rle_unpack(gb.buffer, &dp[ofs],
326 len, bytestream2_get_bytes_left(&gb),
329 bytestream2_get_buffer(&gb, &dp[ofs], len);
330 bytestream2_skip(&gb, len);
332 /* interframe pixel copy */
333 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
334 return AVERROR_INVALIDDATA;
335 memcpy(&dp[ofs], &pp[ofs], len + 1);
338 } while (ofs < frame_width);
339 if (ofs > frame_width) {
340 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
343 dp += frame->linesize[0];
344 pp += s->prev_frame.linesize[0];
353 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
355 VmdVideoContext *s = avctx->priv_data;
357 unsigned int *palette32;
358 int palette_index = 0;
359 unsigned char r, g, b;
360 unsigned char *vmd_header;
361 unsigned char *raw_palette;
364 avctx->pix_fmt = AV_PIX_FMT_PAL8;
366 /* make sure the VMD header made it */
367 if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
368 av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
370 return AVERROR_INVALIDDATA;
372 vmd_header = (unsigned char *)avctx->extradata;
374 s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
375 s->unpack_buffer = av_malloc(s->unpack_buffer_size);
376 if (!s->unpack_buffer)
377 return AVERROR(ENOMEM);
379 /* load up the initial palette */
380 raw_palette = &vmd_header[28];
381 palette32 = (unsigned int *)s->palette;
382 for (i = 0; i < PALETTE_COUNT; i++) {
383 r = raw_palette[palette_index++] * 4;
384 g = raw_palette[palette_index++] * 4;
385 b = raw_palette[palette_index++] * 4;
386 palette32[i] = (r << 16) | (g << 8) | (b);
389 avcodec_get_frame_defaults(&s->prev_frame);
394 static int vmdvideo_decode_frame(AVCodecContext *avctx,
395 void *data, int *got_frame,
398 const uint8_t *buf = avpkt->data;
399 int buf_size = avpkt->size;
400 VmdVideoContext *s = avctx->priv_data;
401 AVFrame *frame = data;
410 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
413 if (vmd_decode(s, frame) < 0)
414 av_log(avctx, AV_LOG_WARNING, "decode error\n");
416 /* make the palette available on the way out */
417 memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
420 av_frame_unref(&s->prev_frame);
421 if ((ret = av_frame_ref(&s->prev_frame, frame)) < 0)
426 /* report that the buffer was completely consumed */
430 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
432 VmdVideoContext *s = avctx->priv_data;
434 av_frame_unref(&s->prev_frame);
435 av_free(s->unpack_buffer);
445 #define BLOCK_TYPE_AUDIO 1
446 #define BLOCK_TYPE_INITIAL 2
447 #define BLOCK_TYPE_SILENCE 3
449 typedef struct VmdAudioContext {
454 static const uint16_t vmdaudio_table[128] = {
455 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
456 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
457 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
458 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
459 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
460 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
461 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
462 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
463 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
464 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
465 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
466 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
467 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
470 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
472 VmdAudioContext *s = avctx->priv_data;
474 if (avctx->channels < 1 || avctx->channels > 2) {
475 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
476 return AVERROR(EINVAL);
478 if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
479 av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
480 return AVERROR(EINVAL);
483 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
486 if (avctx->bits_per_coded_sample == 16)
487 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
489 avctx->sample_fmt = AV_SAMPLE_FMT_U8;
490 s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
492 s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
494 av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
495 "block align = %d, sample rate = %d\n",
496 avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
502 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
506 const uint8_t *buf_end = buf + buf_size;
508 int st = channels - 1;
510 /* decode initial raw sample */
511 for (ch = 0; ch < channels; ch++) {
512 predictor[ch] = (int16_t)AV_RL16(buf);
514 *out++ = predictor[ch];
517 /* decode DPCM samples */
519 while (buf < buf_end) {
522 predictor[ch] -= vmdaudio_table[b & 0x7F];
524 predictor[ch] += vmdaudio_table[b];
525 predictor[ch] = av_clip_int16(predictor[ch]);
526 *out++ = predictor[ch];
531 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
532 int *got_frame_ptr, AVPacket *avpkt)
534 AVFrame *frame = data;
535 const uint8_t *buf = avpkt->data;
536 const uint8_t *buf_end;
537 int buf_size = avpkt->size;
538 VmdAudioContext *s = avctx->priv_data;
539 int block_type, silent_chunks, audio_chunks;
541 uint8_t *output_samples_u8;
542 int16_t *output_samples_s16;
545 av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
551 if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
552 av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
553 return AVERROR(EINVAL);
558 /* get number of silent chunks */
560 if (block_type == BLOCK_TYPE_INITIAL) {
563 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
564 return AVERROR(EINVAL);
566 flags = AV_RB32(buf);
567 silent_chunks = av_popcount(flags);
570 } else if (block_type == BLOCK_TYPE_SILENCE) {
572 buf_size = 0; // should already be zero but set it just to be sure
575 /* ensure output buffer is large enough */
576 audio_chunks = buf_size / s->chunk_size;
578 /* get output buffer */
579 frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
581 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
583 output_samples_u8 = frame->data[0];
584 output_samples_s16 = (int16_t *)frame->data[0];
586 /* decode silent chunks */
587 if (silent_chunks > 0) {
588 int silent_size = avctx->block_align * silent_chunks;
589 if (s->out_bps == 2) {
590 memset(output_samples_s16, 0x00, silent_size * 2);
591 output_samples_s16 += silent_size;
593 memset(output_samples_u8, 0x80, silent_size);
594 output_samples_u8 += silent_size;
598 /* decode audio chunks */
599 if (audio_chunks > 0) {
600 buf_end = buf + buf_size;
601 while (buf_end - buf >= s->chunk_size) {
602 if (s->out_bps == 2) {
603 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
605 output_samples_s16 += avctx->block_align;
607 memcpy(output_samples_u8, buf, s->chunk_size);
608 output_samples_u8 += avctx->block_align;
610 buf += s->chunk_size;
621 * Public Data Structures
624 AVCodec ff_vmdvideo_decoder = {
626 .type = AVMEDIA_TYPE_VIDEO,
627 .id = AV_CODEC_ID_VMDVIDEO,
628 .priv_data_size = sizeof(VmdVideoContext),
629 .init = vmdvideo_decode_init,
630 .close = vmdvideo_decode_end,
631 .decode = vmdvideo_decode_frame,
632 .capabilities = CODEC_CAP_DR1,
633 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
636 AVCodec ff_vmdaudio_decoder = {
638 .type = AVMEDIA_TYPE_AUDIO,
639 .id = AV_CODEC_ID_VMDAUDIO,
640 .priv_data_size = sizeof(VmdAudioContext),
641 .init = vmdaudio_decode_init,
642 .decode = vmdaudio_decode_frame,
643 .capabilities = CODEC_CAP_DR1,
644 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),