Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dpcm.c @ efeb298e

History | View | Annotate | Download (11.6 KB)

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: dpcm.c
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 "avcodec.h"
41

    
42
typedef struct DPCMContext {
43
    int channels;
44
    short roq_square_array[256];
45
    long sample[2];//for SOL_DPCM
46
    const int *sol_table;//for SOL_DPCM
47
} DPCMContext;
48

    
49
#define SE_16BIT(x)  if (x & 0x8000) x -= 0x10000;
50

    
51
static const int interplay_delta_table[] = {
52
         0,      1,      2,      3,      4,      5,      6,      7,
53
         8,      9,     10,     11,     12,     13,     14,     15,
54
        16,     17,     18,     19,     20,     21,     22,     23,
55
        24,     25,     26,     27,     28,     29,     30,     31,
56
        32,     33,     34,     35,     36,     37,     38,     39,
57
        40,     41,     42,     43,     47,     51,     56,     61,
58
        66,     72,     79,     86,     94,    102,    112,    122,
59
       133,    145,    158,    173,    189,    206,    225,    245,
60
       267,    292,    318,    348,    379,    414,    452,    493,
61
       538,    587,    640,    699,    763,    832,    908,    991,
62
      1081,   1180,   1288,   1405,   1534,   1673,   1826,   1993,
63
      2175,   2373,   2590,   2826,   3084,   3365,   3672,   4008,
64
      4373,   4772,   5208,   5683,   6202,   6767,   7385,   8059,
65
      8794,   9597,  10472,  11428,  12471,  13609,  14851,  16206,
66
     17685,  19298,  21060,  22981,  25078,  27367,  29864,  32589,
67
    -29973, -26728, -23186, -19322, -15105, -10503,  -5481,     -1,
68
         1,      1,   5481,  10503,  15105,  19322,  23186,  26728,
69
     29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,
70
    -17685, -16206, -14851, -13609, -12471, -11428, -10472,  -9597,
71
     -8794,  -8059,  -7385,  -6767,  -6202,  -5683,  -5208,  -4772,
72
     -4373,  -4008,  -3672,  -3365,  -3084,  -2826,  -2590,  -2373,
73
     -2175,  -1993,  -1826,  -1673,  -1534,  -1405,  -1288,  -1180,
74
     -1081,   -991,   -908,   -832,   -763,   -699,   -640,   -587,
75
      -538,   -493,   -452,   -414,   -379,   -348,   -318,   -292,
76
      -267,   -245,   -225,   -206,   -189,   -173,   -158,   -145,
77
      -133,   -122,   -112,   -102,    -94,    -86,    -79,    -72,
78
       -66,    -61,    -56,    -51,    -47,    -43,    -42,    -41,
79
       -40,    -39,    -38,    -37,    -36,    -35,    -34,    -33,
80
       -32,    -31,    -30,    -29,    -28,    -27,    -26,    -25,
81
       -24,    -23,    -22,    -21,    -20,    -19,    -18,    -17,
82
       -16,    -15,    -14,    -13,    -12,    -11,    -10,     -9,
83
        -8,     -7,     -6,     -5,     -4,     -3,     -2,     -1
84

    
85
};
86

    
87
static const int sol_table_old[16] =
88
    { 0x0,  0x1,  0x2 , 0x3,  0x6,  0xA,  0xF, 0x15,
89
    -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0};
90

    
91
static const int sol_table_new[16] =
92
    { 0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
93
      0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15};
94

    
95
static const int sol_table_16[128] = {
96
    0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
97
    0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
98
    0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
99
    0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
100
    0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
101
    0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
102
    0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
103
    0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
104
    0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
105
    0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
106
    0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
107
    0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
108
    0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
109
};
110

    
111

    
112

    
113
static av_cold int dpcm_decode_init(AVCodecContext *avctx)
114
{
115
    DPCMContext *s = avctx->priv_data;
116
    int i;
117
    short square;
118

    
119
    s->channels = avctx->channels;
120
    s->sample[0] = s->sample[1] = 0;
121

    
122
    switch(avctx->codec->id) {
123

    
124
    case CODEC_ID_ROQ_DPCM:
125
        /* initialize square table */
126
        for (i = 0; i < 128; i++) {
127
            square = i * i;
128
            s->roq_square_array[i] = square;
129
            s->roq_square_array[i + 128] = -square;
130
        }
131
        break;
132

    
133

    
134
    case CODEC_ID_SOL_DPCM:
135
        switch(avctx->codec_tag){
136
        case 1:
137
            s->sol_table=sol_table_old;
138
            s->sample[0] = s->sample[1] = 0x80;
139
            break;
140
        case 2:
141
            s->sol_table=sol_table_new;
142
            s->sample[0] = s->sample[1] = 0x80;
143
            break;
144
        case 3:
145
            s->sol_table=sol_table_16;
146
            break;
147
        default:
148
            av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
149
            return -1;
150
        }
151
        break;
152

    
153
    default:
154
        break;
155
    }
156

    
157
    avctx->sample_fmt = SAMPLE_FMT_S16;
158
    return 0;
159
}
160

    
161
static int dpcm_decode_frame(AVCodecContext *avctx,
162
                             void *data, int *data_size,
163
                             const uint8_t *buf, int buf_size)
164
{
165
    DPCMContext *s = avctx->priv_data;
166
    int in, out = 0;
167
    int predictor[2];
168
    int channel_number = 0;
169
    short *output_samples = data;
170
    int shift[2];
171
    unsigned char byte;
172
    short diff;
173

    
174
    if (!buf_size)
175
        return 0;
176

    
177
    // almost every DPCM variant expands one byte of data into two
178
    if(*data_size/2 < buf_size)
179
        return -1;
180

    
181
    switch(avctx->codec->id) {
182

    
183
    case CODEC_ID_ROQ_DPCM:
184
        if (s->channels == 1)
185
            predictor[0] = AV_RL16(&buf[6]);
186
        else {
187
            predictor[0] = buf[7] << 8;
188
            predictor[1] = buf[6] << 8;
189
        }
190
        SE_16BIT(predictor[0]);
191
        SE_16BIT(predictor[1]);
192

    
193
        /* decode the samples */
194
        for (in = 8, out = 0; in < buf_size; in++, out++) {
195
            predictor[channel_number] += s->roq_square_array[buf[in]];
196
            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
197
            output_samples[out] = predictor[channel_number];
198

    
199
            /* toggle channel */
200
            channel_number ^= s->channels - 1;
201
        }
202
        break;
203

    
204
    case CODEC_ID_INTERPLAY_DPCM:
205
        in = 6;  /* skip over the stream mask and stream length */
206
        predictor[0] = AV_RL16(&buf[in]);
207
        in += 2;
208
        SE_16BIT(predictor[0])
209
        output_samples[out++] = predictor[0];
210
        if (s->channels == 2) {
211
            predictor[1] = AV_RL16(&buf[in]);
212
            in += 2;
213
            SE_16BIT(predictor[1])
214
            output_samples[out++] = predictor[1];
215
        }
216

    
217
        while (in < buf_size) {
218
            predictor[channel_number] += interplay_delta_table[buf[in++]];
219
            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
220
            output_samples[out++] = predictor[channel_number];
221

    
222
            /* toggle channel */
223
            channel_number ^= s->channels - 1;
224
        }
225

    
226
        break;
227

    
228
    case CODEC_ID_XAN_DPCM:
229
        in = 0;
230
        shift[0] = shift[1] = 4;
231
        predictor[0] = AV_RL16(&buf[in]);
232
        in += 2;
233
        SE_16BIT(predictor[0]);
234
        if (s->channels == 2) {
235
            predictor[1] = AV_RL16(&buf[in]);
236
            in += 2;
237
            SE_16BIT(predictor[1]);
238
        }
239

    
240
        while (in < buf_size) {
241
            byte = buf[in++];
242
            diff = (byte & 0xFC) << 8;
243
            if ((byte & 0x03) == 3)
244
                shift[channel_number]++;
245
            else
246
                shift[channel_number] -= (2 * (byte & 3));
247
            /* saturate the shifter to a lower limit of 0 */
248
            if (shift[channel_number] < 0)
249
                shift[channel_number] = 0;
250

    
251
            diff >>= shift[channel_number];
252
            predictor[channel_number] += diff;
253

    
254
            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
255
            output_samples[out++] = predictor[channel_number];
256

    
257
            /* toggle channel */
258
            channel_number ^= s->channels - 1;
259
        }
260
        break;
261
    case CODEC_ID_SOL_DPCM:
262
        in = 0;
263
        if (avctx->codec_tag != 3) {
264
            if(*data_size/4 < buf_size)
265
                return -1;
266
            while (in < buf_size) {
267
                int n1, n2;
268
                n1 = (buf[in] >> 4) & 0xF;
269
                n2 = buf[in++] & 0xF;
270
                s->sample[0] += s->sol_table[n1];
271
                if (s->sample[0] < 0) s->sample[0] = 0;
272
                if (s->sample[0] > 255) s->sample[0] = 255;
273
                output_samples[out++] = (s->sample[0] - 128) << 8;
274
                s->sample[s->channels - 1] += s->sol_table[n2];
275
                if (s->sample[s->channels - 1] < 0) s->sample[s->channels - 1] = 0;
276
                if (s->sample[s->channels - 1] > 255) s->sample[s->channels - 1] = 255;
277
                output_samples[out++] = (s->sample[s->channels - 1] - 128) << 8;
278
            }
279
        } else {
280
            while (in < buf_size) {
281
                int n;
282
                n = buf[in++];
283
                if (n & 0x80) s->sample[channel_number] -= s->sol_table[n & 0x7F];
284
                else s->sample[channel_number] += s->sol_table[n & 0x7F];
285
                s->sample[channel_number] = av_clip_int16(s->sample[channel_number]);
286
                output_samples[out++] = s->sample[channel_number];
287
                /* toggle channel */
288
                channel_number ^= s->channels - 1;
289
            }
290
        }
291
        break;
292
    }
293

    
294
    *data_size = out * sizeof(short);
295
    return buf_size;
296
}
297

    
298
#define DPCM_DECODER(id, name, long_name_)      \
299
AVCodec name ## _decoder = {                    \
300
    #name,                                      \
301
    CODEC_TYPE_AUDIO,                           \
302
    id,                                         \
303
    sizeof(DPCMContext),                        \
304
    dpcm_decode_init,                           \
305
    NULL,                                       \
306
    NULL,                                       \
307
    dpcm_decode_frame,                          \
308
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
309
};
310

    
311
DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "Interplay DPCM");
312
DPCM_DECODER(CODEC_ID_ROQ_DPCM, roq_dpcm, "id RoQ DPCM");
313
DPCM_DECODER(CODEC_ID_SOL_DPCM, sol_dpcm, "Sol DPCM");
314
DPCM_DECODER(CODEC_ID_XAN_DPCM, xan_dpcm, "Xan DPCM");