vmdaudio: decode directly to the user-provided AVFrame
[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 Libav.
6  *
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.
11  *
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.
16  *
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
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 frame;
63     AVFrame prev_frame;
64
65     const unsigned char *buf;
66     int size;
67
68     unsigned char palette[PALETTE_COUNT * 4];
69     unsigned char *unpack_buffer;
70     int unpack_buffer_size;
71
72     int x_off, y_off;
73 } VmdVideoContext;
74
75 #define QUEUE_SIZE 0x1000
76 #define QUEUE_MASK 0x0FFF
77
78 static void lz_unpack(const unsigned char *src, int src_len,
79                       unsigned char *dest, int dest_len)
80 {
81     const unsigned char *s;
82     unsigned int s_len;
83     unsigned char *d;
84     unsigned char *d_end;
85     unsigned char queue[QUEUE_SIZE];
86     unsigned int qpos;
87     unsigned int dataleft;
88     unsigned int chainofs;
89     unsigned int chainlen;
90     unsigned int speclen;
91     unsigned char tag;
92     unsigned int i, j;
93
94     s = src;
95     s_len = src_len;
96     d = dest;
97     d_end = d + dest_len;
98     dataleft = AV_RL32(s);
99     s += 4; s_len -= 4;
100     memset(queue, 0x20, QUEUE_SIZE);
101     if (s_len < 4)
102         return;
103     if (AV_RL32(s) == 0x56781234) {
104         s += 4; s_len -= 4;
105         qpos = 0x111;
106         speclen = 0xF + 3;
107     } else {
108         qpos = 0xFEE;
109         speclen = 100;  /* no speclen */
110     }
111
112     while (dataleft > 0 && s_len > 0) {
113         tag = *s++; s_len--;
114         if ((tag == 0xFF) && (dataleft > 8)) {
115             if (d + 8 > d_end || s_len < 8)
116                 return;
117             for (i = 0; i < 8; i++) {
118                 queue[qpos++] = *d++ = *s++;
119                 qpos &= QUEUE_MASK;
120             }
121             s_len -= 8;
122             dataleft -= 8;
123         } else {
124             for (i = 0; i < 8; i++) {
125                 if (dataleft == 0)
126                     break;
127                 if (tag & 0x01) {
128                     if (d + 1 > d_end || s_len < 1)
129                         return;
130                     queue[qpos++] = *d++ = *s++;
131                     qpos &= QUEUE_MASK;
132                     dataleft--;
133                     s_len--;
134                 } else {
135                     if (s_len < 2)
136                         return;
137                     chainofs = *s++;
138                     chainofs |= ((*s & 0xF0) << 4);
139                     chainlen = (*s++ & 0x0F) + 3;
140                     s_len -= 2;
141                     if (chainlen == speclen) {
142                         if (s_len < 1)
143                             return;
144                         chainlen = *s++ + 0xF + 3;
145                         s_len--;
146                     }
147                     if (d + chainlen > d_end)
148                         return;
149                     for (j = 0; j < chainlen; j++) {
150                         *d = queue[chainofs++ & QUEUE_MASK];
151                         queue[qpos++] = *d++;
152                         qpos &= QUEUE_MASK;
153                     }
154                     dataleft -= chainlen;
155                 }
156                 tag >>= 1;
157             }
158         }
159     }
160 }
161
162 static int rle_unpack(const unsigned char *src, unsigned char *dest,
163     int src_count, int src_size, int dest_len)
164 {
165     const unsigned char *ps;
166     unsigned char *pd;
167     int i, l;
168     unsigned char *dest_end = dest + dest_len;
169
170     ps = src;
171     pd = dest;
172     if (src_count & 1) {
173         if (src_size < 1)
174             return 0;
175         *pd++ = *ps++;
176         src_size--;
177     }
178
179     src_count >>= 1;
180     i = 0;
181     do {
182         if (src_size < 1)
183             break;
184         l = *ps++;
185         src_size--;
186         if (l & 0x80) {
187             l = (l & 0x7F) * 2;
188             if (pd + l > dest_end || src_size < l)
189                 return ps - src;
190             memcpy(pd, ps, l);
191             ps += l;
192             src_size -= l;
193             pd += l;
194         } else {
195             if (pd + i > dest_end || src_size < 2)
196                 return ps - src;
197             for (i = 0; i < l; i++) {
198                 *pd++ = ps[0];
199                 *pd++ = ps[1];
200             }
201             ps += 2;
202             src_size -= 2;
203         }
204         i += l;
205     } while (i < src_count);
206
207     return ps - src;
208 }
209
210 static void vmd_decode(VmdVideoContext *s)
211 {
212     int i;
213     unsigned int *palette32;
214     unsigned char r, g, b;
215
216     /* point to the start of the encoded data */
217     const unsigned char *p = s->buf + 16;
218
219     const unsigned char *pb;
220     unsigned int pb_size;
221     unsigned char meth;
222     unsigned char *dp;   /* pointer to current frame */
223     unsigned char *pp;   /* pointer to previous frame */
224     unsigned char len;
225     int ofs;
226
227     int frame_x, frame_y;
228     int frame_width, frame_height;
229
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)
238         return;
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)
243         return;
244
245     if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&
246         (frame_x || frame_y)) {
247
248         s->x_off = frame_x;
249         s->y_off = frame_y;
250     }
251     frame_x -= s->x_off;
252     frame_y -= s->y_off;
253
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))) {
259
260         memcpy(s->frame.data[0], s->prev_frame.data[0],
261             s->avctx->height * s->frame.linesize[0]);
262     }
263
264     /* check if there is a new palette */
265     if (s->buf[15] & 0x02) {
266         p += 2;
267         palette32 = (unsigned int *)s->palette;
268         for (i = 0; i < PALETTE_COUNT; i++) {
269             r = *p++ * 4;
270             g = *p++ * 4;
271             b = *p++ * 4;
272             palette32[i] = (r << 16) | (g << 8) | (b);
273         }
274         s->size -= (256 * 3 + 2);
275     }
276     if (s->size > 0) {
277         /* originally UnpackFrame in VAG's code */
278         pb = p;
279         pb_size = s->buf + s->size - pb;
280         if (pb_size < 1)
281             return;
282         meth = *pb++; pb_size--;
283         if (meth & 0x80) {
284             lz_unpack(pb, pb_size,
285                       s->unpack_buffer, s->unpack_buffer_size);
286             meth &= 0x7F;
287             pb = s->unpack_buffer;
288             pb_size = s->unpack_buffer_size;
289         }
290
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];
293         switch (meth) {
294         case 1:
295             for (i = 0; i < frame_height; i++) {
296                 ofs = 0;
297                 do {
298                     if (pb_size < 1)
299                         return;
300                     len = *pb++;
301                     pb_size--;
302                     if (len & 0x80) {
303                         len = (len & 0x7F) + 1;
304                         if (ofs + len > frame_width || pb_size < len)
305                             return;
306                         memcpy(&dp[ofs], pb, len);
307                         pb += len;
308                         pb_size -= len;
309                         ofs += len;
310                     } else {
311                         /* interframe pixel copy */
312                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
313                             return;
314                         memcpy(&dp[ofs], &pp[ofs], len + 1);
315                         ofs += len + 1;
316                     }
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",
320                         ofs, frame_width);
321                     break;
322                 }
323                 dp += s->frame.linesize[0];
324                 pp += s->prev_frame.linesize[0];
325             }
326             break;
327
328         case 2:
329             for (i = 0; i < frame_height; i++) {
330                 if (pb_size < frame_width)
331                     return;
332                 memcpy(dp, pb, frame_width);
333                 pb += frame_width;
334                 pb_size -= frame_width;
335                 dp += s->frame.linesize[0];
336                 pp += s->prev_frame.linesize[0];
337             }
338             break;
339
340         case 3:
341             for (i = 0; i < frame_height; i++) {
342                 ofs = 0;
343                 do {
344                     if (pb_size < 1)
345                         return;
346                     len = *pb++;
347                     pb_size--;
348                     if (len & 0x80) {
349                         len = (len & 0x7F) + 1;
350                         if (pb_size < 1)
351                             return;
352                         if (*pb++ == 0xFF)
353                             len = rle_unpack(pb, &dp[ofs], len, pb_size, frame_width - ofs);
354                         else {
355                             if (pb_size < len)
356                                 return;
357                             memcpy(&dp[ofs], pb, len);
358                         }
359                         pb += len;
360                         pb_size -= 1 + len;
361                         ofs += len;
362                     } else {
363                         /* interframe pixel copy */
364                         if (ofs + len + 1 > frame_width || !s->prev_frame.data[0])
365                             return;
366                         memcpy(&dp[ofs], &pp[ofs], len + 1);
367                         ofs += len + 1;
368                     }
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",
372                         ofs, frame_width);
373                 }
374                 dp += s->frame.linesize[0];
375                 pp += s->prev_frame.linesize[0];
376             }
377             break;
378         }
379     }
380 }
381
382 static av_cold int vmdvideo_decode_init(AVCodecContext *avctx)
383 {
384     VmdVideoContext *s = avctx->priv_data;
385     int i;
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;
391
392     s->avctx = avctx;
393     avctx->pix_fmt = AV_PIX_FMT_PAL8;
394
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",
398             VMD_HEADER_SIZE);
399         return -1;
400     }
401     vmd_header = (unsigned char *)avctx->extradata;
402
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)
406         return -1;
407
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);
416     }
417
418     return 0;
419 }
420
421 static int vmdvideo_decode_frame(AVCodecContext *avctx,
422                                  void *data, int *got_frame,
423                                  AVPacket *avpkt)
424 {
425     const uint8_t *buf = avpkt->data;
426     int buf_size = avpkt->size;
427     VmdVideoContext *s = avctx->priv_data;
428
429     s->buf = buf;
430     s->size = buf_size;
431
432     if (buf_size < 16)
433         return buf_size;
434
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");
438         return -1;
439     }
440
441     vmd_decode(s);
442
443     /* make the palette available on the way out */
444     memcpy(s->frame.data[1], s->palette, PALETTE_COUNT * 4);
445
446     /* shuffle frames */
447     FFSWAP(AVFrame, s->frame, s->prev_frame);
448     if (s->frame.data[0])
449         avctx->release_buffer(avctx, &s->frame);
450
451     *got_frame      = 1;
452     *(AVFrame*)data = s->prev_frame;
453
454     /* report that the buffer was completely consumed */
455     return buf_size;
456 }
457
458 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
459 {
460     VmdVideoContext *s = avctx->priv_data;
461
462     if (s->prev_frame.data[0])
463         avctx->release_buffer(avctx, &s->prev_frame);
464     av_free(s->unpack_buffer);
465
466     return 0;
467 }
468
469
470 /*
471  * Audio Decoder
472  */
473
474 #define BLOCK_TYPE_AUDIO    1
475 #define BLOCK_TYPE_INITIAL  2
476 #define BLOCK_TYPE_SILENCE  3
477
478 typedef struct VmdAudioContext {
479     int out_bps;
480     int chunk_size;
481 } VmdAudioContext;
482
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
497 };
498
499 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
500 {
501     VmdAudioContext *s = avctx->priv_data;
502
503     if (avctx->channels < 1 || avctx->channels > 2) {
504         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
505         return AVERROR(EINVAL);
506     }
507     if (avctx->block_align < 1) {
508         av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
509         return AVERROR(EINVAL);
510     }
511
512     avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
513                                                    AV_CH_LAYOUT_STEREO;
514
515     if (avctx->bits_per_coded_sample == 16)
516         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
517     else
518         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
519     s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
520
521     s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
522
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,
526            avctx->sample_rate);
527
528     return 0;
529 }
530
531 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
532                              int channels)
533 {
534     int ch;
535     const uint8_t *buf_end = buf + buf_size;
536     int predictor[2];
537     int st = channels - 1;
538
539     /* decode initial raw sample */
540     for (ch = 0; ch < channels; ch++) {
541         predictor[ch] = (int16_t)AV_RL16(buf);
542         buf += 2;
543         *out++ = predictor[ch];
544     }
545
546     /* decode DPCM samples */
547     ch = 0;
548     while (buf < buf_end) {
549         uint8_t b = *buf++;
550         if (b & 0x80)
551             predictor[ch] -= vmdaudio_table[b & 0x7F];
552         else
553             predictor[ch] += vmdaudio_table[b];
554         predictor[ch] = av_clip_int16(predictor[ch]);
555         *out++ = predictor[ch];
556         ch ^= st;
557     }
558 }
559
560 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
561                                  int *got_frame_ptr, AVPacket *avpkt)
562 {
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;
569     int ret;
570     uint8_t *output_samples_u8;
571     int16_t *output_samples_s16;
572
573     if (buf_size < 16) {
574         av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
575         *got_frame_ptr = 0;
576         return buf_size;
577     }
578
579     block_type = buf[6];
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);
583     }
584     buf      += 16;
585     buf_size -= 16;
586
587     /* get number of silent chunks */
588     silent_chunks = 0;
589     if (block_type == BLOCK_TYPE_INITIAL) {
590         uint32_t flags;
591         if (buf_size < 4) {
592             av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
593             return AVERROR(EINVAL);
594         }
595         flags         = AV_RB32(buf);
596         silent_chunks = av_popcount(flags);
597         buf      += 4;
598         buf_size -= 4;
599     } else if (block_type == BLOCK_TYPE_SILENCE) {
600         silent_chunks = 1;
601         buf_size = 0; // should already be zero but set it just to be sure
602     }
603
604     /* ensure output buffer is large enough */
605     audio_chunks = buf_size / s->chunk_size;
606
607     /* get output buffer */
608     frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
609                         avctx->channels;
610     if ((ret = ff_get_buffer(avctx, frame)) < 0) {
611         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
612         return ret;
613     }
614     output_samples_u8  =            frame->data[0];
615     output_samples_s16 = (int16_t *)frame->data[0];
616
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;
623         } else {
624             memset(output_samples_u8,  0x80, silent_size);
625             output_samples_u8 += silent_size;
626         }
627     }
628
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,
635                                  avctx->channels);
636                 output_samples_s16 += avctx->block_align;
637             } else {
638                 memcpy(output_samples_u8, buf, s->chunk_size);
639                 output_samples_u8  += avctx->block_align;
640             }
641             buf += s->chunk_size;
642         }
643     }
644
645     *got_frame_ptr = 1;
646
647     return avpkt->size;
648 }
649
650
651 /*
652  * Public Data Structures
653  */
654
655 AVCodec ff_vmdvideo_decoder = {
656     .name           = "vmdvideo",
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"),
665 };
666
667 AVCodec ff_vmdaudio_decoder = {
668     .name           = "vmdaudio",
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"),
676 };