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);
179 if (dest_end - pd < i || bytestream2_get_bytes_left(&gb) < 2)
180 return bytestream2_tell(&gb);
181 for (i = 0; i < l; i++) {
182 *pd++ = bytestream2_get_byteu(&gb);
183 *pd++ = bytestream2_get_byteu(&gb);
185 bytestream2_skip(&gb, 2);
188 } while (i < src_count);
190 return bytestream2_tell(&gb);
193 static void vmd_decode(VmdVideoContext *s, AVFrame *frame)
196 unsigned int *palette32;
197 unsigned char r, g, b;
202 unsigned char *dp; /* pointer to current frame */
203 unsigned char *pp; /* pointer to previous frame */
207 int frame_x, frame_y;
208 int frame_width, frame_height;
210 frame_x = AV_RL16(&s->buf[6]);
211 frame_y = AV_RL16(&s->buf[8]);
212 frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
213 frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
214 if (frame_x < 0 || frame_width < 0 ||
215 frame_x >= s->avctx->width ||
216 frame_width > s->avctx->width ||
217 frame_x + frame_width > s->avctx->width)
219 if (frame_y < 0 || frame_height < 0 ||
220 frame_y >= s->avctx->height ||
221 frame_height > s->avctx->height ||
222 frame_y + frame_height > s->avctx->height)
225 if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
226 (frame_x || frame_y)) {
234 /* if only a certain region will be updated, copy the entire previous
235 * frame before the decode */
236 if (s->prev_frame.data[0] &&
237 (frame_x || frame_y || (frame_width != s->avctx->width) ||
238 (frame_height != s->avctx->height))) {
240 memcpy(frame->data[0], s->prev_frame.data[0],
241 s->avctx->height * frame->linesize[0]);
244 /* check if there is a new palette */
245 bytestream2_init(&gb, s->buf + 16, s->size - 16);
246 if (s->buf[15] & 0x02) {
247 bytestream2_skip(&gb, 2);
248 palette32 = (unsigned int *)s->palette;
249 if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {
250 for (i = 0; i < PALETTE_COUNT; i++) {
251 r = bytestream2_get_byteu(&gb) * 4;
252 g = bytestream2_get_byteu(&gb) * 4;
253 b = bytestream2_get_byteu(&gb) * 4;
254 palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);
255 palette32[i] |= palette32[i] >> 6 & 0x30303;
260 /* originally UnpackFrame in VAG's code */
261 bytestream2_init(&gb, gb.buffer, s->buf + s->size - gb.buffer);
262 if (bytestream2_get_bytes_left(&gb) < 1)
264 meth = bytestream2_get_byteu(&gb);
266 lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),
267 s->unpack_buffer, s->unpack_buffer_size);
269 bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);
272 dp = &frame->data[0][frame_y * frame->linesize[0] + frame_x];
273 pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
276 for (i = 0; i < frame_height; i++) {
279 len = bytestream2_get_byte(&gb);
281 len = (len & 0x7F) + 1;
282 if (ofs + len > frame_width || bytestream2_get_bytes_left(&gb) < len)
284 bytestream2_get_bufferu(&gb, &dp[ofs], len);
287 /* interframe pixel copy */
288 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
290 memcpy(&dp[ofs], &pp[ofs], len + 1);
293 } while (ofs < frame_width);
294 if (ofs > frame_width) {
295 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
299 dp += frame->linesize[0];
300 pp += s->prev_frame.linesize[0];
305 for (i = 0; i < frame_height; i++) {
306 bytestream2_get_buffer(&gb, dp, frame_width);
307 dp += frame->linesize[0];
308 pp += s->prev_frame.linesize[0];
313 for (i = 0; i < frame_height; i++) {
316 len = bytestream2_get_byte(&gb);
318 len = (len & 0x7F) + 1;
319 if (bytestream2_get_byte(&gb) == 0xFF)
320 len = rle_unpack(gb.buffer, &dp[ofs],
321 len, bytestream2_get_bytes_left(&gb),
324 bytestream2_get_buffer(&gb, &dp[ofs], len);
325 bytestream2_skip(&gb, len);
327 /* interframe pixel copy */
328 if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
330 memcpy(&dp[ofs], &pp[ofs], len + 1);
333 } while (ofs < frame_width);
334 if (ofs > frame_width) {
335 av_log(s->avctx, AV_LOG_ERROR, "offset > width (%d > %d)\n",
338 dp += frame->linesize[0];
339 pp += s->prev_frame.linesize[0];
346 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
348 VmdVideoContext *s = avctx->priv_data;
350 unsigned int *palette32;
351 int palette_index = 0;
352 unsigned char r, g, b;
353 unsigned char *vmd_header;
354 unsigned char *raw_palette;
357 avctx->pix_fmt = AV_PIX_FMT_PAL8;
359 /* make sure the VMD header made it */
360 if (s->avctx->extradata_size != VMD_HEADER_SIZE) {
361 av_log(s->avctx, AV_LOG_ERROR, "expected extradata size of %d\n",
365 vmd_header = (unsigned char *)avctx->extradata;
367 s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
368 s->unpack_buffer = av_malloc(s->unpack_buffer_size);
369 if (!s->unpack_buffer)
372 /* load up the initial palette */
373 raw_palette = &vmd_header[28];
374 palette32 = (unsigned int *)s->palette;
375 for (i = 0; i < PALETTE_COUNT; i++) {
376 r = raw_palette[palette_index++] * 4;
377 g = raw_palette[palette_index++] * 4;
378 b = raw_palette[palette_index++] * 4;
379 palette32[i] = (r << 16) | (g << 8) | (b);
382 avcodec_get_frame_defaults(&s->prev_frame);
387 static int vmdvideo_decode_frame(AVCodecContext *avctx,
388 void *data, int *got_frame,
391 const uint8_t *buf = avpkt->data;
392 int buf_size = avpkt->size;
393 VmdVideoContext *s = avctx->priv_data;
394 AVFrame *frame = data;
403 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
406 vmd_decode(s, frame);
408 /* make the palette available on the way out */
409 memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
412 av_frame_unref(&s->prev_frame);
413 if ((ret = av_frame_ref(&s->prev_frame, frame)) < 0)
418 /* report that the buffer was completely consumed */
422 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
424 VmdVideoContext *s = avctx->priv_data;
426 av_frame_unref(&s->prev_frame);
427 av_free(s->unpack_buffer);
437 #define BLOCK_TYPE_AUDIO 1
438 #define BLOCK_TYPE_INITIAL 2
439 #define BLOCK_TYPE_SILENCE 3
441 typedef struct VmdAudioContext {
446 static const uint16_t vmdaudio_table[128] = {
447 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
448 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
449 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
450 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
451 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
452 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
453 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
454 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
455 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
456 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
457 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
458 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
459 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
462 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
464 VmdAudioContext *s = avctx->priv_data;
466 if (avctx->channels < 1 || avctx->channels > 2) {
467 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
468 return AVERROR(EINVAL);
470 if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
471 av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
472 return AVERROR(EINVAL);
475 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
478 if (avctx->bits_per_coded_sample == 16)
479 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
481 avctx->sample_fmt = AV_SAMPLE_FMT_U8;
482 s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
484 s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
486 av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
487 "block align = %d, sample rate = %d\n",
488 avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
494 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
498 const uint8_t *buf_end = buf + buf_size;
500 int st = channels - 1;
502 /* decode initial raw sample */
503 for (ch = 0; ch < channels; ch++) {
504 predictor[ch] = (int16_t)AV_RL16(buf);
506 *out++ = predictor[ch];
509 /* decode DPCM samples */
511 while (buf < buf_end) {
514 predictor[ch] -= vmdaudio_table[b & 0x7F];
516 predictor[ch] += vmdaudio_table[b];
517 predictor[ch] = av_clip_int16(predictor[ch]);
518 *out++ = predictor[ch];
523 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
524 int *got_frame_ptr, AVPacket *avpkt)
526 AVFrame *frame = data;
527 const uint8_t *buf = avpkt->data;
528 const uint8_t *buf_end;
529 int buf_size = avpkt->size;
530 VmdAudioContext *s = avctx->priv_data;
531 int block_type, silent_chunks, audio_chunks;
533 uint8_t *output_samples_u8;
534 int16_t *output_samples_s16;
537 av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
543 if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
544 av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
545 return AVERROR(EINVAL);
550 /* get number of silent chunks */
552 if (block_type == BLOCK_TYPE_INITIAL) {
555 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
556 return AVERROR(EINVAL);
558 flags = AV_RB32(buf);
559 silent_chunks = av_popcount(flags);
562 } else if (block_type == BLOCK_TYPE_SILENCE) {
564 buf_size = 0; // should already be zero but set it just to be sure
567 /* ensure output buffer is large enough */
568 audio_chunks = buf_size / s->chunk_size;
570 /* get output buffer */
571 frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
573 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
575 output_samples_u8 = frame->data[0];
576 output_samples_s16 = (int16_t *)frame->data[0];
578 /* decode silent chunks */
579 if (silent_chunks > 0) {
580 int silent_size = avctx->block_align * silent_chunks;
581 if (s->out_bps == 2) {
582 memset(output_samples_s16, 0x00, silent_size * 2);
583 output_samples_s16 += silent_size;
585 memset(output_samples_u8, 0x80, silent_size);
586 output_samples_u8 += silent_size;
590 /* decode audio chunks */
591 if (audio_chunks > 0) {
592 buf_end = buf + buf_size;
593 while (buf_end - buf >= s->chunk_size) {
594 if (s->out_bps == 2) {
595 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
597 output_samples_s16 += avctx->block_align;
599 memcpy(output_samples_u8, buf, s->chunk_size);
600 output_samples_u8 += avctx->block_align;
602 buf += s->chunk_size;
613 * Public Data Structures
616 AVCodec ff_vmdvideo_decoder = {
618 .type = AVMEDIA_TYPE_VIDEO,
619 .id = AV_CODEC_ID_VMDVIDEO,
620 .priv_data_size = sizeof(VmdVideoContext),
621 .init = vmdvideo_decode_init,
622 .close = vmdvideo_decode_end,
623 .decode = vmdvideo_decode_frame,
624 .capabilities = CODEC_CAP_DR1,
625 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
628 AVCodec ff_vmdaudio_decoder = {
630 .type = AVMEDIA_TYPE_AUDIO,
631 .id = AV_CODEC_ID_VMDAUDIO,
632 .priv_data_size = sizeof(VmdAudioContext),
633 .init = vmdaudio_decode_init,
634 .decode = vmdaudio_decode_frame,
635 .capabilities = CODEC_CAP_DR1,
636 .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),