dpcm.c 12.5 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 roq_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
            s->roq_square_array[i      ] =  square;
134 135 136 137
            s->roq_square_array[i + 128] = -square;
        }
        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
    default:
        break;
    }

160
    if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
161 162 163 164
        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;

165 166 167
    return 0;
}

168

169 170
static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
171
{
172
    int buf_size = avpkt->size;
173
    DPCMContext *s = avctx->priv_data;
174
    AVFrame *frame = data;
175
    int out = 0, ret;
176
    int predictor[2];
177
    int ch = 0;
178
    int stereo = avctx->channels - 1;
179 180
    int16_t *output_samples, *samples_end;
    GetByteContext gb;
181

182
    if (stereo && (buf_size & 1))
183
        buf_size--;
184
    bytestream2_init(&gb, avpkt->data, buf_size);
185

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

    /* get output buffer */
213
    frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
214
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
215
        return ret;
216
    output_samples = (int16_t *)frame->data[0];
217
    samples_end = output_samples + out;
218

219 220
    switch(avctx->codec->id) {

221
    case AV_CODEC_ID_ROQ_DPCM:
222
        bytestream2_skipu(&gb, 6);
223

224
        if (stereo) {
225 226
            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
227
        } else {
228
            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
229 230 231
        }

        /* decode the samples */
232 233
        while (output_samples < samples_end) {
            predictor[ch] += s->roq_square_array[bytestream2_get_byteu(&gb)];
234
            predictor[ch]  = av_clip_int16(predictor[ch]);
235
            *output_samples++ = predictor[ch];
236 237

            /* toggle channel */
238
            ch ^= stereo;
239 240 241
        }
        break;

242
    case AV_CODEC_ID_INTERPLAY_DPCM:
243
        bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
244

245
        for (ch = 0; ch < avctx->channels; ch++) {
246
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
247
            *output_samples++ = predictor[ch];
248 249
        }

250
        ch = 0;
251 252
        while (output_samples < samples_end) {
            predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
253
            predictor[ch]  = av_clip_int16(predictor[ch]);
254
            *output_samples++ = predictor[ch];
255 256

            /* toggle channel */
257
            ch ^= stereo;
258 259
        }
        break;
260

261
    case AV_CODEC_ID_XAN_DPCM:
262 263
    {
        int shift[2] = { 4, 4 };
264

265
        for (ch = 0; ch < avctx->channels; ch++)
266
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
267 268

        ch = 0;
269 270 271 272 273
        while (output_samples < samples_end) {
            int diff = bytestream2_get_byteu(&gb);
            int n    = diff & 3;

            if (n == 3)
274
                shift[ch]++;
275
            else
276 277 278
                shift[ch] -= (2 * n);
            diff = sign_extend((diff &~ 3) << 8, 16);

279
            /* saturate the shifter to a lower limit of 0 */
280 281
            if (shift[ch] < 0)
                shift[ch] = 0;
282

283 284
            diff >>= shift[ch];
            predictor[ch] += diff;
285

286
            predictor[ch] = av_clip_int16(predictor[ch]);
287
            *output_samples++ = predictor[ch];
288 289

            /* toggle channel */
290
            ch ^= stereo;
291 292
        }
        break;
293
    }
294
    case AV_CODEC_ID_SOL_DPCM:
295
        if (avctx->codec_tag != 3) {
296
            uint8_t *output_samples_u8 = frame->data[0],
297 298 299
                    *samples_end_u8 = output_samples_u8 + out;
            while (output_samples_u8 < samples_end_u8) {
                int n = bytestream2_get_byteu(&gb);
300 301 302 303 304 305 306 307

                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];
308 309
            }
        } else {
310 311
            while (output_samples < samples_end) {
                int n = bytestream2_get_byteu(&gb);
312 313
                if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
                else          s->sample[ch] += sol_table_16[n & 0x7F];
314
                s->sample[ch] = av_clip_int16(s->sample[ch]);
315
                *output_samples++ = s->sample[ch];
316
                /* toggle channel */
317
                ch ^= stereo;
318 319 320
            }
        }
        break;
321 322
    }

323
    *got_frame_ptr = 1;
324

325
    return avpkt->size;
326 327
}

328 329 330 331 332 333 334 335
#define DPCM_DECODER(id_, name_, long_name_)                \
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(DPCMContext),                  \
    .init           = dpcm_decode_init,                     \
    .decode         = dpcm_decode_frame,                    \
336
    .capabilities   = CODEC_CAP_DR1,                        \
337
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
338
}
339

340 341 342 343
DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
DPCM_DECODER(AV_CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
DPCM_DECODER(AV_CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");