dpcm.c 13.2 KB
Newer Older
1 2
/*
 * Assorted DPCM codecs
3
 * Copyright (c) 2003 The FFmpeg project
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 25
 * Assorted DPCM (differential pulse code modulation) audio codecs
 * by Mike Melanson (melanson@pcisys.net)
26
 * Xan DPCM decoder by Mario Brito (mbrito@student.dei.uc.pt)
27 28
 * for more information on the specific data formats, visit:
 *   http://www.pcisys.net/~melanson/codecs/simpleaudio.html
29
 * SOL DPCMs implemented by Konstantin Shishkov
30 31 32 33 34 35 36 37
 *
 * Note about using the Xan DPCM decoder: Xan DPCM is used in AVI files
 * found in the Wing Commander IV computer game. These AVI files contain
 * WAVEFORMAT headers which report the audio format as 0x01: raw PCM.
 * Clearly incorrect. To detect Xan DPCM, you will probably have to
 * special-case your AVI demuxer to use Xan DPCM if the file uses 'Xxan'
 * (Xan video) for its video codec. Alternately, such AVI files also contain
 * 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 square_array[256];
48
    int sample[2];                  ///< previous sample (for SOL_DPCM)
49
    const int8_t *sol_table;        ///< delta table for SOL_DPCM
50 51
} DPCMContext;

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

};

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

93
static const int8_t sol_table_new[16] = {
94 95 96
    0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
    0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
};
97

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


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

120
    if (avctx->channels < 1 || avctx->channels > 2) {
121
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
122 123
        return AVERROR(EINVAL);
    }
124

125
    s->sample[0] = s->sample[1] = 0;
126 127 128

    switch(avctx->codec->id) {

129
    case AV_CODEC_ID_ROQ_DPCM:
130 131
        /* initialize square table */
        for (i = 0; i < 128; i++) {
132
            int16_t square = i * i;
133 134
            s->square_array[i      ] =  square;
            s->square_array[i + 128] = -square;
135 136 137
        }
        break;

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

156 157 158 159 160 161 162
    case AV_CODEC_ID_SDX2_DPCM:
        for (i = -128; i < 128; i++) {
            int16_t square = i * i * 2;
            s->square_array[i+128] = i < 0 ? -square: square;
        }
        break;

163 164 165 166
    default:
        break;
    }

167
    if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
168 169 170 171
        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;

172 173 174
    return 0;
}

175

176 177
static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
178
{
179
    int buf_size = avpkt->size;
180
    DPCMContext *s = avctx->priv_data;
181
    AVFrame *frame = data;
182
    int out = 0, ret;
183
    int predictor[2];
184
    int ch = 0;
185
    int stereo = avctx->channels - 1;
186 187
    int16_t *output_samples, *samples_end;
    GetByteContext gb;
188

189
    if (stereo && (buf_size & 1))
190
        buf_size--;
191
    bytestream2_init(&gb, avpkt->data, buf_size);
192

193 194
    /* calculate output size */
    switch(avctx->codec->id) {
195
    case AV_CODEC_ID_ROQ_DPCM:
196 197
        out = buf_size - 8;
        break;
198
    case AV_CODEC_ID_INTERPLAY_DPCM:
199
        out = buf_size - 6 - avctx->channels;
200
        break;
201
    case AV_CODEC_ID_XAN_DPCM:
202
        out = buf_size - 2 * avctx->channels;
203
        break;
204
    case AV_CODEC_ID_SOL_DPCM:
205 206 207 208 209
        if (avctx->codec_tag != 3)
            out = buf_size * 2;
        else
            out = buf_size;
        break;
210 211 212
    case AV_CODEC_ID_SDX2_DPCM:
        out = buf_size;
        break;
213
    }
214
    if (out <= 0) {
215 216 217
        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
        return AVERROR(EINVAL);
    }
218
    if (out % avctx->channels) {
219 220
        av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
    }
221 222

    /* get output buffer */
223
    frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
224
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
225
        return ret;
226
    output_samples = (int16_t *)frame->data[0];
227
    samples_end = output_samples + out;
228

229 230
    switch(avctx->codec->id) {

231
    case AV_CODEC_ID_ROQ_DPCM:
232
        bytestream2_skipu(&gb, 6);
233

234
        if (stereo) {
235 236
            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
237
        } else {
238
            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
239 240 241
        }

        /* decode the samples */
242
        while (output_samples < samples_end) {
243
            predictor[ch] += s->square_array[bytestream2_get_byteu(&gb)];
244
            predictor[ch]  = av_clip_int16(predictor[ch]);
245
            *output_samples++ = predictor[ch];
246 247

            /* toggle channel */
248
            ch ^= stereo;
249 250 251
        }
        break;

252
    case AV_CODEC_ID_INTERPLAY_DPCM:
253
        bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
254

255
        for (ch = 0; ch < avctx->channels; ch++) {
256
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
257
            *output_samples++ = predictor[ch];
258 259
        }

260
        ch = 0;
261 262
        while (output_samples < samples_end) {
            predictor[ch] += interplay_delta_table[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_XAN_DPCM:
272 273
    {
        int shift[2] = { 4, 4 };
274

275
        for (ch = 0; ch < avctx->channels; ch++)
276
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
277 278

        ch = 0;
279 280 281 282 283
        while (output_samples < samples_end) {
            int diff = bytestream2_get_byteu(&gb);
            int n    = diff & 3;

            if (n == 3)
284
                shift[ch]++;
285
            else
286 287 288
                shift[ch] -= (2 * n);
            diff = sign_extend((diff &~ 3) << 8, 16);

289
            /* saturate the shifter to a lower limit of 0 */
290 291
            if (shift[ch] < 0)
                shift[ch] = 0;
292

293 294
            diff >>= shift[ch];
            predictor[ch] += diff;
295

296
            predictor[ch] = av_clip_int16(predictor[ch]);
297
            *output_samples++ = predictor[ch];
298 299

            /* toggle channel */
300
            ch ^= stereo;
301 302
        }
        break;
303
    }
304
    case AV_CODEC_ID_SOL_DPCM:
305
        if (avctx->codec_tag != 3) {
306
            uint8_t *output_samples_u8 = frame->data[0],
307 308 309
                    *samples_end_u8 = output_samples_u8 + out;
            while (output_samples_u8 < samples_end_u8) {
                int n = bytestream2_get_byteu(&gb);
310 311 312 313 314 315 316 317

                s->sample[0] += s->sol_table[n >> 4];
                s->sample[0]  = av_clip_uint8(s->sample[0]);
                *output_samples_u8++ = s->sample[0];

                s->sample[stereo] += s->sol_table[n & 0x0F];
                s->sample[stereo]  = av_clip_uint8(s->sample[stereo]);
                *output_samples_u8++ = s->sample[stereo];
318 319
            }
        } else {
320 321
            while (output_samples < samples_end) {
                int n = bytestream2_get_byteu(&gb);
322 323
                if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
                else          s->sample[ch] += sol_table_16[n & 0x7F];
324
                s->sample[ch] = av_clip_int16(s->sample[ch]);
325
                *output_samples++ = s->sample[ch];
326
                /* toggle channel */
327
                ch ^= stereo;
328 329 330
            }
        }
        break;
331 332 333 334 335 336 337 338 339 340 341 342 343

    case AV_CODEC_ID_SDX2_DPCM:
        while (output_samples < samples_end) {
            int8_t n = bytestream2_get_byteu(&gb);

            if (!(n & 1))
                s->sample[ch] = 0;
            s->sample[ch] += s->square_array[n + 128];
            s->sample[ch]  = av_clip_int16(s->sample[ch]);
            *output_samples++ = s->sample[ch];
            ch ^= stereo;
        }
        break;
344 345
    }

346
    *got_frame_ptr = 1;
347

348
    return avpkt->size;
349 350
}

351 352 353
#define DPCM_DECODER(id_, name_, long_name_)                \
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
354
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
355 356 357 358 359
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(DPCMContext),                  \
    .init           = dpcm_decode_init,                     \
    .decode         = dpcm_decode_frame,                    \
360
    .capabilities   = AV_CODEC_CAP_DR1,                     \
361
}
362

363 364
DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
365
DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM,      sdx2_dpcm,      "DPCM Squareroot-Delta-Exact");
366 367
DPCM_DECODER(AV_CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
DPCM_DECODER(AV_CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");