0a91d73ebecad9812dbc97ea699cc218d78e3b5c
[ffmpeg.git] / libavcodec / vmdav.c
1 /*
2  * Sierra VMD Audio & Video Decoders
3  * Copyright (C) 2004 the ffmpeg project
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 /**
23  * @file
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/
28  *
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.
34  *
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.
40  */
41
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #include "libavutil/intreadwrite.h"
47 #include "avcodec.h"
48
49 #define VMD_HEADER_SIZE 0x330
50 #define PALETTE_COUNT 256
51
52 /*
53  * Video Decoder
54  */
55
56 typedef struct VmdVideoContext {
57
58     AVCodecContext *avctx;
59     AVFrame frame;
60     AVFrame prev_frame;
61
62     const unsigned char *buf;
63     int size;
64
65     unsigned char palette[PALETTE_COUNT * 4];
66     unsigned char *unpack_buffer;
67     int unpack_buffer_size;
68
69     int x_off, y_off;
70 } VmdVideoContext;
71
72 #define QUEUE_SIZE 0x1000
73 #define QUEUE_MASK 0x0FFF
74
75 static void lz_unpack(const unsigned char *src, int src_len,
76                       unsigned char *dest, int dest_len)
77 {
78     const unsigned char *s;
79     const unsigned char *s_end;
80     unsigned char *d;
81     unsigned char *d_end;
82     unsigned char queue[QUEUE_SIZE];
83     unsigned int qpos;
84     unsigned int dataleft;
85     unsigned int chainofs;
86     unsigned int chainlen;
87     unsigned int speclen;
88     unsigned char tag;
89     unsigned int i, j;
90
91     s = src;
92     s_end = src + src_len;
93     d = dest;
94     d_end = d + dest_len;
95
96     if (s_end - s < 8)
97         return;
98     dataleft = AV_RL32(s);
99     s += 4;
100     memset(queue, 0x20, QUEUE_SIZE);
101     if (AV_RL32(s) == 0x56781234) {
102         s += 4;
103         qpos = 0x111;
104         speclen = 0xF + 3;
105     } else {
106         qpos = 0xFEE;
107         speclen = 100;  /* no speclen */
108     }
109
110     while (s_end - s > 0 && dataleft > 0) {
111         tag = *s++;
112         if ((tag == 0xFF) && (dataleft > 8)) {
113             if (d_end - d < 8 || s_end - s < 8)
114                 return;
115             for (i = 0; i < 8; i++) {
116                 queue[qpos++] = *d++ = *s++;
117                 qpos &= QUEUE_MASK;
118             }
119             dataleft -= 8;
120         } else {
121             for (i = 0; i < 8; i++) {
122                 if (dataleft == 0)
123                     break;
124                 if (tag & 0x01) {
125                     if (d_end - d < 1 || s_end - s < 1)
126                         return;
127                     queue[qpos++] = *d++ = *s++;
128                     qpos &= QUEUE_MASK;
129                     dataleft--;
130                 } else {
131                     if (s_end - s < 2)
132                         return;
133                     chainofs = *s++;
134                     chainofs |= ((*s & 0xF0) << 4);
135                     chainlen = (*s++ & 0x0F) + 3;
136                     if (chainlen == speclen) {
137                         if (s_end - s < 1)
138                             return;
139                         chainlen = *s++ + 0xF + 3;
140                     }
141                     if (d_end - d < chainlen)
142                         return;
143                     for (j = 0; j < chainlen; j++) {
144                         *d = queue[chainofs++ & QUEUE_MASK];
145                         queue[qpos++] = *d++;
146                         qpos &= QUEUE_MASK;
147                     }
148                     dataleft -= chainlen;
149                 }
150                 tag >>= 1;
151             }
152         }
153     }
154 }
155
156 static int rle_unpack(const unsigned char *src, unsigned char *dest,
157     int src_len, int dest_len)
158 {
159     const unsigned char *ps;
160     unsigned char *pd;
161     int i, l;
162     unsigned char *dest_end = dest + dest_len;
163
164     ps = src;
165     pd = dest;
166     if (src_len & 1)
167         *pd++ = *ps++;
168
169     src_len >>= 1;
170     i = 0;
171     do {
172         l = *ps++;
173         if (l & 0x80) {
174             l = (l & 0x7F) * 2;
175             if (pd + l > dest_end)
176                 return ps - src;
177             memcpy(pd, ps, l);
178             ps += l;
179             pd += l;
180         } else {
181             if (pd + i > dest_end)
182                 return ps - src;
183             for (i = 0; i < l; i++) {
184                 *pd++ = ps[0];
185                 *pd++ = ps[1];
186             }
187             ps += 2;
188         }
189         i += l;
190     } while (i < src_len);
191
192     return ps - src;
193 }
194
195 static void vmd_decode(VmdVideoContext *s)
196 {
197     int i;
198     unsigned int *palette32;
199     unsigned char r, g, b;
200
201     /* point to the start of the encoded data */
202     const unsigned char *p = s->buf + 16;
203     const unsigned char *p_end = s->buf + s->size;
204
205     const unsigned char *pb;
206     unsigned char meth;
207     unsigned char *dp;   /* pointer to current frame */
208     unsigned char *pp;   /* pointer to previous frame */
209     unsigned char len;
210     int ofs;
211
212     int frame_x, frame_y;
213     int frame_width, frame_height;
214
215     frame_x = AV_RL16(&s->buf[6]);
216     frame_y = AV_RL16(&s->buf[8]);
217     frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;
218     frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;
219     if (frame_x < 0 || frame_width < 0 ||
220         frame_x >= s->avctx->width ||
221         frame_width > s->avctx->width ||
222         frame_x + frame_width > s->avctx->width)
223         return;
224     if (frame_y < 0 || frame_height < 0 ||
225         frame_y >= s->avctx->height ||
226         frame_height > s->avctx->height ||
227         frame_y + frame_height > s->avctx->height)
228         return;
229
230     if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
231         (frame_x || frame_y)) {
232
233         s->x_off = frame_x;
234         s->y_off = frame_y;
235     }
236     frame_x -= s->x_off;
237     frame_y -= s->y_off;
238
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))) {
244
245         memcpy(s->frame.data[0], s->prev_frame.data[0],
246             s->avctx->height * s->frame.linesize[0]);
247     }
248
249     /* check if there is a new palette */
250     if (s->buf[15] & 0x02) {
251         p += 2;
252         palette32 = (unsigned int *)s->palette;
253         for (i = 0; i < PALETTE_COUNT; i++) {
254             r = *p++ * 4;
255             g = *p++ * 4;
256             b = *p++ * 4;
257             palette32[i] = (r << 16) | (g << 8) | (b);
258         }
259         s->size -= (256 * 3 + 2);
260     }
261     if (s->size >= 0) {
262         /* originally UnpackFrame in VAG's code */
263         pb = p;
264         meth = *pb++;
265         if (meth & 0x80) {
266             lz_unpack(pb, p_end - pb, s->unpack_buffer, s->unpack_buffer_size);
267             meth &= 0x7F;
268             pb = s->unpack_buffer;
269         }
270
271         dp = &s->frame.data[0][frame_y * s->frame.linesize[0] + frame_x];
272         pp = &s->prev_frame.data[0][frame_y * s->prev_frame.linesize[0] + frame_x];
273         switch (meth) {
274         case 1:
275             for (i = 0; i < frame_height; i++) {
276                 ofs = 0;
277                 do {
278                     len = *pb++;
279                     if (len & 0x80) {
280                         len = (len & 0x7F) + 1;
281                         if (ofs + len > frame_width)
282                             return;
283                         memcpy(&dp[ofs], pb, len);
284                         pb += len;
285                         ofs += len;
286                     } else {
287                         /* interframe pixel copy */
288                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
289                             return;
290                         memcpy(&dp[ofs], &pp[ofs], len + 1);
291                         ofs += len + 1;
292                     }
293                 } while (ofs < frame_width);
294                 if (ofs > frame_width) {
295                     av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
296                         ofs, frame_width);
297                     break;
298                 }
299                 dp += s->frame.linesize[0];
300                 pp += s->prev_frame.linesize[0];
301             }
302             break;
303
304         case 2:
305             for (i = 0; i < frame_height; i++) {
306                 memcpy(dp, pb, frame_width);
307                 pb += frame_width;
308                 dp += s->frame.linesize[0];
309                 pp += s->prev_frame.linesize[0];
310             }
311             break;
312
313         case 3:
314             for (i = 0; i < frame_height; i++) {
315                 ofs = 0;
316                 do {
317                     len = *pb++;
318                     if (len & 0x80) {
319                         len = (len & 0x7F) + 1;
320                         if (*pb++ == 0xFF)
321                             len = rle_unpack(pb, &dp[ofs], len, frame_width - ofs);
322                         else
323                             memcpy(&dp[ofs], pb, len);
324                         pb += len;
325                         ofs += len;
326                     } else {
327                         /* interframe pixel copy */
328                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
329                             return;
330                         memcpy(&dp[ofs], &pp[ofs], len + 1);
331                         ofs += len + 1;
332                     }
333                 } while (ofs < frame_width);
334                 if (ofs > frame_width) {
335                     av_log(s->avctx, AV_LOG_ERROR, "VMD video: offset > width (%d > %d)\n",
336                         ofs, frame_width);
337                 }
338                 dp += s->frame.linesize[0];
339                 pp += s->prev_frame.linesize[0];
340             }
341             break;
342         }
343     }
344 }
345
346 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
347 {
348     VmdVideoContext *s = avctx->priv_data;
349     int i;
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;
355
356     s->avctx = avctx;
357     avctx->pix_fmt = PIX_FMT_PAL8;
358
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, "VMD video: expected extradata size of %d\n",
362             VMD_HEADER_SIZE);
363         return -1;
364     }
365     vmd_header = (unsigned char *)avctx->extradata;
366
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)
370         return -1;
371
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);
380     }
381
382     avcodec_get_frame_defaults(&s->frame);
383     avcodec_get_frame_defaults(&s->prev_frame);
384
385     return 0;
386 }
387
388 static int vmdvideo_decode_frame(AVCodecContext *avctx,
389                                  void *data, int *data_size,
390                                  AVPacket *avpkt)
391 {
392     const uint8_t *buf = avpkt->data;
393     int buf_size = avpkt->size;
394     VmdVideoContext *s = avctx->priv_data;
395
396     s->buf = buf;
397     s->size = buf_size;
398
399     if (buf_size < 16)
400         return buf_size;
401
402     s->frame.reference = 1;
403     if (avctx->get_buffer(avctx, &s->frame)) {
404         av_log(s->avctx, AV_LOG_ERROR, "VMD Video: get_buffer() failed\n");
405         return -1;
406     }
407
408     vmd_decode(s);
409
410     /* make the palette available on the way out */
411     memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
412
413     /* shuffle frames */
414     FFSWAP(AVFrame, s->frame, s->prev_frame);
415     if (s->frame.data[0])
416         avctx->release_buffer(avctx, &s->frame);
417
418     *data_size = sizeof(AVFrame);
419     *(AVFrame*)data = s->prev_frame;
420
421     /* report that the buffer was completely consumed */
422     return buf_size;
423 }
424
425 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
426 {
427     VmdVideoContext *s = avctx->priv_data;
428
429     if (s->prev_frame.data[0])
430         avctx->release_buffer(avctx, &s->prev_frame);
431     av_free(s->unpack_buffer);
432
433     return 0;
434 }
435
436
437 /*
438  * Audio Decoder
439  */
440
441 #define BLOCK_TYPE_AUDIO    1
442 #define BLOCK_TYPE_INITIAL  2
443 #define BLOCK_TYPE_SILENCE  3
444
445 typedef struct VmdAudioContext {
446     AVCodecContext *avctx;
447     int out_bps;
448     int predictors[2];
449 } VmdAudioContext;
450
451 static const uint16_t vmdaudio_table[128] = {
452     0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
453     0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
454     0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
455     0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
456     0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
457     0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
458     0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
459     0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
460     0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
461     0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
462     0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
463     0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
464     0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
465 };
466
467 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
468 {
469     VmdAudioContext *s = avctx->priv_data;
470
471     s->avctx = avctx;
472     if (avctx->bits_per_coded_sample == 16)
473         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
474     else
475         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
476     s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
477
478     av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
479            "block align = %d, sample rate = %d\n",
480            avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
481            avctx->sample_rate);
482
483     return 0;
484 }
485
486 static void vmdaudio_decode_audio(VmdAudioContext *s, unsigned char *data,
487     const uint8_t *buf, int buf_size, int stereo)
488 {
489     int i;
490     int chan = 0;
491     int16_t *out = (int16_t*)data;
492
493     for(i = 0; i < buf_size; i++) {
494         if(buf[i] & 0x80)
495             s->predictors[chan] -= vmdaudio_table[buf[i] & 0x7F];
496         else
497             s->predictors[chan] += vmdaudio_table[buf[i]];
498         s->predictors[chan] = av_clip_int16(s->predictors[chan]);
499         out[i] = s->predictors[chan];
500         chan ^= stereo;
501     }
502 }
503
504 static int vmdaudio_loadsound(VmdAudioContext *s, unsigned char *data,
505     const uint8_t *buf, int silent_chunks, int data_size)
506 {
507     int silent_size = s->avctx->block_align * silent_chunks * s->out_bps;
508
509     if (silent_chunks) {
510         memset(data, s->out_bps == 2 ? 0x00 : 0x80, silent_size);
511         data += silent_size;
512     }
513     if (s->avctx->bits_per_coded_sample == 16)
514         vmdaudio_decode_audio(s, data, buf, data_size, s->avctx->channels == 2);
515     else {
516         /* just copy the data */
517         memcpy(data, buf, data_size);
518     }
519
520     return silent_size + data_size * s->out_bps;
521 }
522
523 static int vmdaudio_decode_frame(AVCodecContext *avctx,
524                                  void *data, int *data_size,
525                                  AVPacket *avpkt)
526 {
527     const uint8_t *buf = avpkt->data;
528     int buf_size = avpkt->size;
529     VmdAudioContext *s = avctx->priv_data;
530     int block_type, silent_chunks;
531     unsigned char *output_samples = (unsigned char *)data;
532
533     if (buf_size < 16) {
534         av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
535         *data_size = 0;
536         return buf_size;
537     }
538
539     block_type = buf[6];
540     if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
541         av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
542         return AVERROR(EINVAL);
543     }
544     buf      += 16;
545     buf_size -= 16;
546
547     silent_chunks = 0;
548     if (block_type == BLOCK_TYPE_INITIAL) {
549         uint32_t flags;
550         if (buf_size < 4)
551             return -1;
552         flags = AV_RB32(buf);
553         silent_chunks  = av_popcount(flags);
554         buf      += 4;
555         buf_size -= 4;
556     } else if (block_type == BLOCK_TYPE_SILENCE) {
557         silent_chunks = 1;
558         buf_size = 0; // should already be zero but set it just to be sure
559     }
560
561     /* ensure output buffer is large enough */
562     if (*data_size < (avctx->block_align*silent_chunks + buf_size) * s->out_bps)
563         return -1;
564
565     *data_size = vmdaudio_loadsound(s, output_samples, buf, silent_chunks, buf_size);
566
567     return avpkt->size;
568 }
569
570
571 /*
572  * Public Data Structures
573  */
574
575 AVCodec ff_vmdvideo_decoder = {
576     "vmdvideo",
577     AVMEDIA_TYPE_VIDEO,
578     CODEC_ID_VMDVIDEO,
579     sizeof(VmdVideoContext),
580     vmdvideo_decode_init,
581     NULL,
582     vmdvideo_decode_end,
583     vmdvideo_decode_frame,
584     CODEC_CAP_DR1,
585     .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
586 };
587
588 AVCodec ff_vmdaudio_decoder = {
589     "vmdaudio",
590     AVMEDIA_TYPE_AUDIO,
591     CODEC_ID_VMDAUDIO,
592     sizeof(VmdAudioContext),
593     vmdaudio_decode_init,
594     NULL,
595     NULL,
596     vmdaudio_decode_frame,
597     .long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
598 };