dpcm.c 12.4 KB
Newer Older
1 2
/*
 * Assorted DPCM codecs
3
 * Copyright (c) 2003 The ffmpeg Project
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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 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
    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 209

    /* get output buffer */
210
    frame->nb_samples = out / avctx->channels;
211
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
212 213
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
214
    }
215
    output_samples = (int16_t *)frame->data[0];
216
    samples_end = output_samples + out;
217

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

322
    *got_frame_ptr = 1;
323

324
    return avpkt->size;
325 326
}

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

339 340 341 342
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");