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