doc/filters: correct typos in tinterlace flags
[ffmpeg.git] / libavcodec / dpcm.c
1 /*
2  * Assorted DPCM codecs
3  * Copyright (c) 2003 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  * Assorted DPCM (differential pulse code modulation) audio codecs
25  * by Mike Melanson (melanson@pcisys.net)
26  * Xan DPCM decoder by Mario Brito (mbrito@student.dei.uc.pt)
27  * for more information on the specific data formats, visit:
28  *   http://www.pcisys.net/~melanson/codecs/simpleaudio.html
29  * SOL DPCMs implemented by Konstantin Shishkov
30  *
31  * Note about using the Xan DPCM decoder: Xan DPCM is used in AVI files
32  * found in the Wing Commander IV computer game. These AVI files contain
33  * WAVEFORMAT headers which report the audio format as 0x01: raw PCM.
34  * Clearly incorrect. To detect Xan DPCM, you will probably have to
35  * special-case your AVI demuxer to use Xan DPCM if the file uses 'Xxan'
36  * (Xan video) for its video codec. Alternately, such AVI files also contain
37  * the fourcc 'Axan' in the 'auds' chunk of the AVI header.
38  */
39
40 #include "libavutil/intreadwrite.h"
41 #include "avcodec.h"
42 #include "bytestream.h"
43 #include "internal.h"
44 #include "mathops.h"
45
46 typedef struct DPCMContext {
47     int16_t array[256];
48     int sample[2];                  ///< previous sample (for SOL_DPCM)
49     const int8_t *sol_table;        ///< delta table for SOL_DPCM
50 } DPCMContext;
51
52 static const int16_t interplay_delta_table[] = {
53          0,      1,      2,      3,      4,      5,      6,      7,
54          8,      9,     10,     11,     12,     13,     14,     15,
55         16,     17,     18,     19,     20,     21,     22,     23,
56         24,     25,     26,     27,     28,     29,     30,     31,
57         32,     33,     34,     35,     36,     37,     38,     39,
58         40,     41,     42,     43,     47,     51,     56,     61,
59         66,     72,     79,     86,     94,    102,    112,    122,
60        133,    145,    158,    173,    189,    206,    225,    245,
61        267,    292,    318,    348,    379,    414,    452,    493,
62        538,    587,    640,    699,    763,    832,    908,    991,
63       1081,   1180,   1288,   1405,   1534,   1673,   1826,   1993,
64       2175,   2373,   2590,   2826,   3084,   3365,   3672,   4008,
65       4373,   4772,   5208,   5683,   6202,   6767,   7385,   8059,
66       8794,   9597,  10472,  11428,  12471,  13609,  14851,  16206,
67      17685,  19298,  21060,  22981,  25078,  27367,  29864,  32589,
68     -29973, -26728, -23186, -19322, -15105, -10503,  -5481,     -1,
69          1,      1,   5481,  10503,  15105,  19322,  23186,  26728,
70      29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,
71     -17685, -16206, -14851, -13609, -12471, -11428, -10472,  -9597,
72      -8794,  -8059,  -7385,  -6767,  -6202,  -5683,  -5208,  -4772,
73      -4373,  -4008,  -3672,  -3365,  -3084,  -2826,  -2590,  -2373,
74      -2175,  -1993,  -1826,  -1673,  -1534,  -1405,  -1288,  -1180,
75      -1081,   -991,   -908,   -832,   -763,   -699,   -640,   -587,
76       -538,   -493,   -452,   -414,   -379,   -348,   -318,   -292,
77       -267,   -245,   -225,   -206,   -189,   -173,   -158,   -145,
78       -133,   -122,   -112,   -102,    -94,    -86,    -79,    -72,
79        -66,    -61,    -56,    -51,    -47,    -43,    -42,    -41,
80        -40,    -39,    -38,    -37,    -36,    -35,    -34,    -33,
81        -32,    -31,    -30,    -29,    -28,    -27,    -26,    -25,
82        -24,    -23,    -22,    -21,    -20,    -19,    -18,    -17,
83        -16,    -15,    -14,    -13,    -12,    -11,    -10,     -9,
84         -8,     -7,     -6,     -5,     -4,     -3,     -2,     -1
85
86 };
87
88 static const int8_t sol_table_old[16] = {
89       0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF, 0x15,
90     -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1,  0x0
91 };
92
93 static const int8_t sol_table_new[16] = {
94     0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
95     0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
96 };
97
98 static const int16_t sol_table_16[128] = {
99     0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
100     0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
101     0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
102     0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
103     0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
104     0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
105     0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
106     0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
107     0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
108     0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
109     0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
110     0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
111     0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
112 };
113
114
115 static av_cold int dpcm_decode_init(AVCodecContext *avctx)
116 {
117     DPCMContext *s = avctx->priv_data;
118     int i;
119
120     if (avctx->channels < 1 || avctx->channels > 2) {
121         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
122         return AVERROR(EINVAL);
123     }
124
125     s->sample[0] = s->sample[1] = 0;
126
127     switch(avctx->codec->id) {
128
129     case AV_CODEC_ID_ROQ_DPCM:
130         /* initialize square table */
131         for (i = 0; i < 128; i++) {
132             int16_t square = i * i;
133             s->array[i      ] =  square;
134             s->array[i + 128] = -square;
135         }
136         break;
137
138     case AV_CODEC_ID_SOL_DPCM:
139         switch(avctx->codec_tag){
140         case 1:
141             s->sol_table = sol_table_old;
142             s->sample[0] = s->sample[1] = 0x80;
143             break;
144         case 2:
145             s->sol_table = sol_table_new;
146             s->sample[0] = s->sample[1] = 0x80;
147             break;
148         case 3:
149             break;
150         default:
151             av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
152             return -1;
153         }
154         break;
155
156     case AV_CODEC_ID_SDX2_DPCM:
157         for (i = -128; i < 128; i++) {
158             int16_t square = i * i * 2;
159             s->array[i+128] = i < 0 ? -square: square;
160         }
161         break;
162
163     case AV_CODEC_ID_GREMLIN_DPCM: {
164         int delta = 0;
165         int code = 64;
166         int step = 45;
167
168         s->array[0] = 0;
169         for (i = 0; i < 127; i++) {
170             delta += (code >> 5);
171             code  += step;
172             step  += 2;
173
174             s->array[i*2 + 1] =  delta;
175             s->array[i*2 + 2] = -delta;
176         }
177         s->array[255] = delta + (code >> 5);
178         }
179         break;
180
181     default:
182         break;
183     }
184
185     if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
186         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
187     else
188         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
189
190     return 0;
191 }
192
193
194 static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
195                              int *got_frame_ptr, AVPacket *avpkt)
196 {
197     int buf_size = avpkt->size;
198     DPCMContext *s = avctx->priv_data;
199     AVFrame *frame = data;
200     int out = 0, ret;
201     int predictor[2];
202     int ch = 0;
203     int stereo = avctx->channels - 1;
204     int16_t *output_samples, *samples_end;
205     GetByteContext gb;
206
207     if (stereo && (buf_size & 1))
208         buf_size--;
209     bytestream2_init(&gb, avpkt->data, buf_size);
210
211     /* calculate output size */
212     switch(avctx->codec->id) {
213     case AV_CODEC_ID_ROQ_DPCM:
214         out = buf_size - 8;
215         break;
216     case AV_CODEC_ID_INTERPLAY_DPCM:
217         out = buf_size - 6 - avctx->channels;
218         break;
219     case AV_CODEC_ID_XAN_DPCM:
220         out = buf_size - 2 * avctx->channels;
221         break;
222     case AV_CODEC_ID_SOL_DPCM:
223         if (avctx->codec_tag != 3)
224             out = buf_size * 2;
225         else
226             out = buf_size;
227         break;
228     case AV_CODEC_ID_GREMLIN_DPCM:
229     case AV_CODEC_ID_SDX2_DPCM:
230         out = buf_size;
231         break;
232     }
233     if (out <= 0) {
234         av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
235         return AVERROR(EINVAL);
236     }
237     if (out % avctx->channels) {
238         av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
239     }
240
241     /* get output buffer */
242     frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
243     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
244         return ret;
245     output_samples = (int16_t *)frame->data[0];
246     samples_end = output_samples + out;
247
248     switch(avctx->codec->id) {
249
250     case AV_CODEC_ID_ROQ_DPCM:
251         bytestream2_skipu(&gb, 6);
252
253         if (stereo) {
254             predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
255             predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
256         } else {
257             predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
258         }
259
260         /* decode the samples */
261         while (output_samples < samples_end) {
262             predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
263             predictor[ch]  = av_clip_int16(predictor[ch]);
264             *output_samples++ = predictor[ch];
265
266             /* toggle channel */
267             ch ^= stereo;
268         }
269         break;
270
271     case AV_CODEC_ID_INTERPLAY_DPCM:
272         bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
273
274         for (ch = 0; ch < avctx->channels; ch++) {
275             predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
276             *output_samples++ = predictor[ch];
277         }
278
279         ch = 0;
280         while (output_samples < samples_end) {
281             predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
282             predictor[ch]  = av_clip_int16(predictor[ch]);
283             *output_samples++ = predictor[ch];
284
285             /* toggle channel */
286             ch ^= stereo;
287         }
288         break;
289
290     case AV_CODEC_ID_XAN_DPCM:
291     {
292         int shift[2] = { 4, 4 };
293
294         for (ch = 0; ch < avctx->channels; ch++)
295             predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
296
297         ch = 0;
298         while (output_samples < samples_end) {
299             int diff = bytestream2_get_byteu(&gb);
300             int n    = diff & 3;
301
302             if (n == 3)
303                 shift[ch]++;
304             else
305                 shift[ch] -= (2 * n);
306             diff = sign_extend((diff &~ 3) << 8, 16);
307
308             /* saturate the shifter to a lower limit of 0 */
309             if (shift[ch] < 0)
310                 shift[ch] = 0;
311
312             diff >>= shift[ch];
313             predictor[ch] += diff;
314
315             predictor[ch] = av_clip_int16(predictor[ch]);
316             *output_samples++ = predictor[ch];
317
318             /* toggle channel */
319             ch ^= stereo;
320         }
321         break;
322     }
323     case AV_CODEC_ID_SOL_DPCM:
324         if (avctx->codec_tag != 3) {
325             uint8_t *output_samples_u8 = frame->data[0],
326                     *samples_end_u8 = output_samples_u8 + out;
327             while (output_samples_u8 < samples_end_u8) {
328                 int n = bytestream2_get_byteu(&gb);
329
330                 s->sample[0] += s->sol_table[n >> 4];
331                 s->sample[0]  = av_clip_uint8(s->sample[0]);
332                 *output_samples_u8++ = s->sample[0];
333
334                 s->sample[stereo] += s->sol_table[n & 0x0F];
335                 s->sample[stereo]  = av_clip_uint8(s->sample[stereo]);
336                 *output_samples_u8++ = s->sample[stereo];
337             }
338         } else {
339             while (output_samples < samples_end) {
340                 int n = bytestream2_get_byteu(&gb);
341                 if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
342                 else          s->sample[ch] += sol_table_16[n & 0x7F];
343                 s->sample[ch] = av_clip_int16(s->sample[ch]);
344                 *output_samples++ = s->sample[ch];
345                 /* toggle channel */
346                 ch ^= stereo;
347             }
348         }
349         break;
350
351     case AV_CODEC_ID_SDX2_DPCM:
352         while (output_samples < samples_end) {
353             int8_t n = bytestream2_get_byteu(&gb);
354
355             if (!(n & 1))
356                 s->sample[ch] = 0;
357             s->sample[ch] += s->array[n + 128];
358             s->sample[ch]  = av_clip_int16(s->sample[ch]);
359             *output_samples++ = s->sample[ch];
360             ch ^= stereo;
361         }
362         break;
363
364     case AV_CODEC_ID_GREMLIN_DPCM: {
365         int idx = 0;
366
367         while (output_samples < samples_end) {
368             uint8_t n = bytestream2_get_byteu(&gb);
369
370             *output_samples++ = s->sample[idx] += s->array[n];
371             idx ^= 1;
372         }
373         }
374         break;
375     }
376
377     *got_frame_ptr = 1;
378
379     return avpkt->size;
380 }
381
382 #define DPCM_DECODER(id_, name_, long_name_)                \
383 AVCodec ff_ ## name_ ## _decoder = {                        \
384     .name           = #name_,                               \
385     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
386     .type           = AVMEDIA_TYPE_AUDIO,                   \
387     .id             = id_,                                  \
388     .priv_data_size = sizeof(DPCMContext),                  \
389     .init           = dpcm_decode_init,                     \
390     .decode         = dpcm_decode_frame,                    \
391     .capabilities   = AV_CODEC_CAP_DR1,                     \
392 }
393
394 DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM,   gremlin_dpcm,   "DPCM Gremlin");
395 DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
396 DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
397 DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM,      sdx2_dpcm,      "DPCM Squareroot-Delta-Exact");
398 DPCM_DECODER(AV_CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
399 DPCM_DECODER(AV_CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");