lavc: factorize ff_{thread_,re,}get_buffer error messages.
[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         return ret;
430
431     vmd_decode(s, frame);
432
433     /* make the palette available on the way out */
434     memcpy(frame->data[1], s->palette, PALETTE_COUNT * 4);
435
436     /* shuffle frames */
437     av_frame_unref(&s->prev_frame);
438     if ((ret = av_frame_ref(&s->prev_frame, frame)) < 0)
439         return ret;
440
441     *got_frame      = 1;
442
443     /* report that the buffer was completely consumed */
444     return buf_size;
445 }
446
447 static av_cold int vmdvideo_decode_end(AVCodecContext *avctx)
448 {
449     VmdVideoContext *s = avctx->priv_data;
450
451     av_frame_unref(&s->prev_frame);
452     av_free(s->unpack_buffer);
453
454     return 0;
455 }
456
457
458 /*
459  * Audio Decoder
460  */
461
462 #define BLOCK_TYPE_AUDIO    1
463 #define BLOCK_TYPE_INITIAL  2
464 #define BLOCK_TYPE_SILENCE  3
465
466 typedef struct VmdAudioContext {
467     int out_bps;
468     int chunk_size;
469 } VmdAudioContext;
470
471 static const uint16_t vmdaudio_table[128] = {
472     0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
473     0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
474     0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
475     0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
476     0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
477     0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
478     0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
479     0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
480     0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
481     0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
482     0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
483     0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
484     0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
485 };
486
487 static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
488 {
489     VmdAudioContext *s = avctx->priv_data;
490
491     if (avctx->channels < 1 || avctx->channels > 2) {
492         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
493         return AVERROR(EINVAL);
494     }
495     if (avctx->block_align < 1 || avctx->block_align % avctx->channels) {
496         av_log(avctx, AV_LOG_ERROR, "invalid block align\n");
497         return AVERROR(EINVAL);
498     }
499
500     avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
501                                                    AV_CH_LAYOUT_STEREO;
502
503     if (avctx->bits_per_coded_sample == 16)
504         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
505     else
506         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
507     s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
508
509     s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
510
511     av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
512            "block align = %d, sample rate = %d\n",
513            avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
514            avctx->sample_rate);
515
516     return 0;
517 }
518
519 static void decode_audio_s16(int16_t *out, const uint8_t *buf, int buf_size,
520                              int channels)
521 {
522     int ch;
523     const uint8_t *buf_end = buf + buf_size;
524     int predictor[2];
525     int st = channels - 1;
526
527     /* decode initial raw sample */
528     for (ch = 0; ch < channels; ch++) {
529         predictor[ch] = (int16_t)AV_RL16(buf);
530         buf += 2;
531         *out++ = predictor[ch];
532     }
533
534     /* decode DPCM samples */
535     ch = 0;
536     while (buf < buf_end) {
537         uint8_t b = *buf++;
538         if (b & 0x80)
539             predictor[ch] -= vmdaudio_table[b & 0x7F];
540         else
541             predictor[ch] += vmdaudio_table[b];
542         predictor[ch] = av_clip_int16(predictor[ch]);
543         *out++ = predictor[ch];
544         ch ^= st;
545     }
546 }
547
548 static int vmdaudio_decode_frame(AVCodecContext *avctx, void *data,
549                                  int *got_frame_ptr, AVPacket *avpkt)
550 {
551     AVFrame *frame     = data;
552     const uint8_t *buf = avpkt->data;
553     const uint8_t *buf_end;
554     int buf_size = avpkt->size;
555     VmdAudioContext *s = avctx->priv_data;
556     int block_type, silent_chunks, audio_chunks;
557     int ret;
558     uint8_t *output_samples_u8;
559     int16_t *output_samples_s16;
560
561     if (buf_size < 16) {
562         av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
563         *got_frame_ptr = 0;
564         return buf_size;
565     }
566
567     block_type = buf[6];
568     if (block_type < BLOCK_TYPE_AUDIO || block_type > BLOCK_TYPE_SILENCE) {
569         av_log(avctx, AV_LOG_ERROR, "unknown block type: %d\n", block_type);
570         return AVERROR(EINVAL);
571     }
572     buf      += 16;
573     buf_size -= 16;
574
575     /* get number of silent chunks */
576     silent_chunks = 0;
577     if (block_type == BLOCK_TYPE_INITIAL) {
578         uint32_t flags;
579         if (buf_size < 4) {
580             av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
581             return AVERROR(EINVAL);
582         }
583         flags         = AV_RB32(buf);
584         silent_chunks = av_popcount(flags);
585         buf      += 4;
586         buf_size -= 4;
587     } else if (block_type == BLOCK_TYPE_SILENCE) {
588         silent_chunks = 1;
589         buf_size = 0; // should already be zero but set it just to be sure
590     }
591
592     /* ensure output buffer is large enough */
593     audio_chunks = buf_size / s->chunk_size;
594
595     /* get output buffer */
596     frame->nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) /
597                         avctx->channels;
598     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
599         return ret;
600     output_samples_u8  =            frame->data[0];
601     output_samples_s16 = (int16_t *)frame->data[0];
602
603     /* decode silent chunks */
604     if (silent_chunks > 0) {
605         int silent_size = avctx->block_align * silent_chunks;
606         if (s->out_bps == 2) {
607             memset(output_samples_s16, 0x00, silent_size * 2);
608             output_samples_s16 += silent_size;
609         } else {
610             memset(output_samples_u8,  0x80, silent_size);
611             output_samples_u8 += silent_size;
612         }
613     }
614
615     /* decode audio chunks */
616     if (audio_chunks > 0) {
617         buf_end = buf + buf_size;
618         while (buf_end - buf >= s->chunk_size) {
619             if (s->out_bps == 2) {
620                 decode_audio_s16(output_samples_s16, buf, s->chunk_size,
621                                  avctx->channels);
622                 output_samples_s16 += avctx->block_align;
623             } else {
624                 memcpy(output_samples_u8, buf, s->chunk_size);
625                 output_samples_u8  += avctx->block_align;
626             }
627             buf += s->chunk_size;
628         }
629     }
630
631     *got_frame_ptr = 1;
632
633     return avpkt->size;
634 }
635
636
637 /*
638  * Public Data Structures
639  */
640
641 AVCodec ff_vmdvideo_decoder = {
642     .name           = "vmdvideo",
643     .type           = AVMEDIA_TYPE_VIDEO,
644     .id             = AV_CODEC_ID_VMDVIDEO,
645     .priv_data_size = sizeof(VmdVideoContext),
646     .init           = vmdvideo_decode_init,
647     .close          = vmdvideo_decode_end,
648     .decode         = vmdvideo_decode_frame,
649     .capabilities   = CODEC_CAP_DR1,
650     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
651 };
652
653 AVCodec ff_vmdaudio_decoder = {
654     .name           = "vmdaudio",
655     .type           = AVMEDIA_TYPE_AUDIO,
656     .id             = AV_CODEC_ID_VMDAUDIO,
657     .priv_data_size = sizeof(VmdAudioContext),
658     .init           = vmdaudio_decode_init,
659     .decode         = vmdaudio_decode_frame,
660     .capabilities   = CODEC_CAP_DR1,
661     .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
662 };