dpcm.c 12.6 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 "mathops.h"
44 45

typedef struct DPCMContext {
46
    AVFrame frame;
47
    int channels;
48
    int16_t roq_square_array[256];
49
    int sample[2];                  ///< previous sample (for SOL_DPCM)
50
    const int8_t *sol_table;        ///< delta table for SOL_DPCM
51 52
} DPCMContext;

53
static const int16_t interplay_delta_table[] = {
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 88
         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

};

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

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

99
static const int16_t sol_table_16[128] = {
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
    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
};


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

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

    s->channels = avctx->channels;
127
    s->sample[0] = s->sample[1] = 0;
128 129 130 131 132 133

    switch(avctx->codec->id) {

    case CODEC_ID_ROQ_DPCM:
        /* initialize square table */
        for (i = 0; i < 128; i++) {
134
            int16_t square = i * i;
135
            s->roq_square_array[i      ] =  square;
136 137 138 139
            s->roq_square_array[i + 128] = -square;
        }
        break;

140 141 142
    case CODEC_ID_SOL_DPCM:
        switch(avctx->codec_tag){
        case 1:
143
            s->sol_table = sol_table_old;
144 145 146
            s->sample[0] = s->sample[1] = 0x80;
            break;
        case 2:
147
            s->sol_table = sol_table_new;
148 149 150 151 152 153 154 155 156
            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;
157

158 159 160 161
    default:
        break;
    }

162 163 164 165 166
    if (avctx->codec->id == CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;

167 168 169
    avcodec_get_frame_defaults(&s->frame);
    avctx->coded_frame = &s->frame;

170 171 172
    return 0;
}

173

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

186
    if (stereo && (buf_size & 1))
187
        buf_size--;
188
    bytestream2_init(&gb, avpkt->data, buf_size);
189

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

    /* get output buffer */
217
    s->frame.nb_samples = (out + s->channels - 1) / s->channels;
218 219 220
    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
221
    }
222
    output_samples = (int16_t *)s->frame.data[0];
223
    samples_end = output_samples + out;
224

225 226 227
    switch(avctx->codec->id) {

    case CODEC_ID_ROQ_DPCM:
228
        bytestream2_skipu(&gb, 6);
229

230
        if (stereo) {
231 232
            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
233
        } else {
234
            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
235 236 237
        }

        /* decode the samples */
238 239
        while (output_samples < samples_end) {
            predictor[ch] += s->roq_square_array[bytestream2_get_byteu(&gb)];
240
            predictor[ch]  = av_clip_int16(predictor[ch]);
241
            *output_samples++ = predictor[ch];
242 243

            /* toggle channel */
244
            ch ^= stereo;
245 246 247 248
        }
        break;

    case CODEC_ID_INTERPLAY_DPCM:
249
        bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
250 251

        for (ch = 0; ch < s->channels; ch++) {
252
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
253
            *output_samples++ = predictor[ch];
254 255
        }

256
        ch = 0;
257 258
        while (output_samples < samples_end) {
            predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
259
            predictor[ch]  = av_clip_int16(predictor[ch]);
260
            *output_samples++ = predictor[ch];
261 262

            /* toggle channel */
263
            ch ^= stereo;
264 265
        }
        break;
266 267

    case CODEC_ID_XAN_DPCM:
268 269
    {
        int shift[2] = { 4, 4 };
270

271
        for (ch = 0; ch < s->channels; ch++)
272
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
273 274

        ch = 0;
275 276 277 278 279
        while (output_samples < samples_end) {
            int diff = bytestream2_get_byteu(&gb);
            int n    = diff & 3;

            if (n == 3)
280
                shift[ch]++;
281
            else
282 283 284
                shift[ch] -= (2 * n);
            diff = sign_extend((diff &~ 3) << 8, 16);

285
            /* saturate the shifter to a lower limit of 0 */
286 287
            if (shift[ch] < 0)
                shift[ch] = 0;
288

289 290
            diff >>= shift[ch];
            predictor[ch] += diff;
291

292
            predictor[ch] = av_clip_int16(predictor[ch]);
293
            *output_samples++ = predictor[ch];
294 295

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

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

329 330 331
    *got_frame_ptr   = 1;
    *(AVFrame *)data = s->frame;

332
    return avpkt->size;
333 334
}

335 336 337 338 339 340 341 342
#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,                    \
343
    .capabilities   = CODEC_CAP_DR1,                        \
344
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
345
}
346

347
DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
348 349 350
DPCM_DECODER(CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
DPCM_DECODER(CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
DPCM_DECODER(CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");