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