GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dpcm.c Lines: 105 184 57.1 %
Date: 2020-09-25 23:16:12 Branches: 43 83 51.8 %

Line Branch Exec Source
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
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 "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 array[256];
48
    int sample[2];                  ///< previous sample (for SOL_DPCM)
49
    const int8_t *sol_table;        ///< delta table for SOL_DPCM
50
} DPCMContext;
51
52
static const int32_t derf_steps[96] = {
53
    0, 1, 2, 3, 4, 5, 6, 7,
54
    8, 9, 10, 11, 12, 13, 14, 16,
55
    17, 19, 21, 23, 25, 28, 31, 34,
56
    37, 41, 45, 50, 55, 60, 66, 73,
57
    80, 88, 97, 107, 118, 130, 143, 157,
58
    173, 190, 209, 230, 253, 279, 307, 337,
59
    371, 408, 449, 494, 544, 598, 658, 724,
60
    796, 876, 963, 1060, 1166, 1282, 1411, 1552,
61
    1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
62
    3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,
63
    7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289,
64
    16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
65
};
66
67
static const int16_t interplay_delta_table[] = {
68
         0,      1,      2,      3,      4,      5,      6,      7,
69
         8,      9,     10,     11,     12,     13,     14,     15,
70
        16,     17,     18,     19,     20,     21,     22,     23,
71
        24,     25,     26,     27,     28,     29,     30,     31,
72
        32,     33,     34,     35,     36,     37,     38,     39,
73
        40,     41,     42,     43,     47,     51,     56,     61,
74
        66,     72,     79,     86,     94,    102,    112,    122,
75
       133,    145,    158,    173,    189,    206,    225,    245,
76
       267,    292,    318,    348,    379,    414,    452,    493,
77
       538,    587,    640,    699,    763,    832,    908,    991,
78
      1081,   1180,   1288,   1405,   1534,   1673,   1826,   1993,
79
      2175,   2373,   2590,   2826,   3084,   3365,   3672,   4008,
80
      4373,   4772,   5208,   5683,   6202,   6767,   7385,   8059,
81
      8794,   9597,  10472,  11428,  12471,  13609,  14851,  16206,
82
     17685,  19298,  21060,  22981,  25078,  27367,  29864,  32589,
83
    -29973, -26728, -23186, -19322, -15105, -10503,  -5481,     -1,
84
         1,      1,   5481,  10503,  15105,  19322,  23186,  26728,
85
     29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,
86
    -17685, -16206, -14851, -13609, -12471, -11428, -10472,  -9597,
87
     -8794,  -8059,  -7385,  -6767,  -6202,  -5683,  -5208,  -4772,
88
     -4373,  -4008,  -3672,  -3365,  -3084,  -2826,  -2590,  -2373,
89
     -2175,  -1993,  -1826,  -1673,  -1534,  -1405,  -1288,  -1180,
90
     -1081,   -991,   -908,   -832,   -763,   -699,   -640,   -587,
91
      -538,   -493,   -452,   -414,   -379,   -348,   -318,   -292,
92
      -267,   -245,   -225,   -206,   -189,   -173,   -158,   -145,
93
      -133,   -122,   -112,   -102,    -94,    -86,    -79,    -72,
94
       -66,    -61,    -56,    -51,    -47,    -43,    -42,    -41,
95
       -40,    -39,    -38,    -37,    -36,    -35,    -34,    -33,
96
       -32,    -31,    -30,    -29,    -28,    -27,    -26,    -25,
97
       -24,    -23,    -22,    -21,    -20,    -19,    -18,    -17,
98
       -16,    -15,    -14,    -13,    -12,    -11,    -10,     -9,
99
        -8,     -7,     -6,     -5,     -4,     -3,     -2,     -1
100
101
};
102
103
static const int8_t sol_table_old[16] = {
104
      0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF, 0x15,
105
    -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1,  0x0
106
};
107
108
static const int8_t sol_table_new[16] = {
109
    0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
110
    0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
111
};
112
113
static const int16_t sol_table_16[128] = {
114
    0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
115
    0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
116
    0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
117
    0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
118
    0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
119
    0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
120
    0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
121
    0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
122
    0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
123
    0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
124
    0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
125
    0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
126
    0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
127
};
128
129
130
14
static av_cold int dpcm_decode_init(AVCodecContext *avctx)
131
{
132
14
    DPCMContext *s = avctx->priv_data;
133
    int i;
134
135

14
    if (avctx->channels < 1 || avctx->channels > 2) {
136
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
137
        return AVERROR(EINVAL);
138
    }
139
140
14
    s->sample[0] = s->sample[1] = 0;
141
142

14
    switch(avctx->codec->id) {
143
144
5
    case AV_CODEC_ID_ROQ_DPCM:
145
        /* initialize square table */
146
645
        for (i = 0; i < 128; i++) {
147
640
            int16_t square = i * i;
148
640
            s->array[i      ] =  square;
149
640
            s->array[i + 128] = -square;
150
        }
151
5
        break;
152
153
2
    case AV_CODEC_ID_SOL_DPCM:
154

2
        switch(avctx->codec_tag){
155
        case 1:
156
            s->sol_table = sol_table_old;
157
            s->sample[0] = s->sample[1] = 0x80;
158
            break;
159
        case 2:
160
            s->sol_table = sol_table_new;
161
            s->sample[0] = s->sample[1] = 0x80;
162
            break;
163
2
        case 3:
164
2
            break;
165
        default:
166
            av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
167
            return -1;
168
        }
169
2
        break;
170
171
    case AV_CODEC_ID_SDX2_DPCM:
172
        for (i = -128; i < 128; i++) {
173
            int16_t square = i * i * 2;
174
            s->array[i+128] = i < 0 ? -square: square;
175
        }
176
        break;
177
178
    case AV_CODEC_ID_GREMLIN_DPCM: {
179
        int delta = 0;
180
        int code = 64;
181
        int step = 45;
182
183
        s->array[0] = 0;
184
        for (i = 0; i < 127; i++) {
185
            delta += (code >> 5);
186
            code  += step;
187
            step  += 2;
188
189
            s->array[i*2 + 1] =  delta;
190
            s->array[i*2 + 2] = -delta;
191
        }
192
        s->array[255] = delta + (code >> 5);
193
        }
194
        break;
195
196
7
    default:
197
7
        break;
198
    }
199
200

14
    if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
201
        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
202
    else
203
14
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
204
205
14
    return 0;
206
}
207
208
209
649
static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
210
                             int *got_frame_ptr, AVPacket *avpkt)
211
{
212
649
    int buf_size = avpkt->size;
213
649
    DPCMContext *s = avctx->priv_data;
214
649
    AVFrame *frame = data;
215
649
    int out = 0, ret;
216
    int predictor[2];
217
649
    int ch = 0;
218
649
    int stereo = avctx->channels - 1;
219
    int16_t *output_samples, *samples_end;
220
    GetByteContext gb;
221
222

649
    if (stereo && (buf_size & 1))
223
        buf_size--;
224
649
    bytestream2_init(&gb, avpkt->data, buf_size);
225
226
    /* calculate output size */
227

649
    switch(avctx->codec->id) {
228
340
    case AV_CODEC_ID_ROQ_DPCM:
229
340
        out = buf_size - 8;
230
340
        break;
231
124
    case AV_CODEC_ID_INTERPLAY_DPCM:
232
124
        out = buf_size - 6 - avctx->channels;
233
124
        break;
234
111
    case AV_CODEC_ID_XAN_DPCM:
235
111
        out = buf_size - 2 * avctx->channels;
236
111
        break;
237
74
    case AV_CODEC_ID_SOL_DPCM:
238
74
        if (avctx->codec_tag != 3)
239
            out = buf_size * 2;
240
        else
241
74
            out = buf_size;
242
74
        break;
243
    case AV_CODEC_ID_DERF_DPCM:
244
    case AV_CODEC_ID_GREMLIN_DPCM:
245
    case AV_CODEC_ID_SDX2_DPCM:
246
        out = buf_size;
247
        break;
248
    }
249
649
    if (out <= 0) {
250
        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
251
        return AVERROR(EINVAL);
252
    }
253
649
    if (out % avctx->channels) {
254
        av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
255
    }
256
257
    /* get output buffer */
258
649
    frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
259
649
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
260
        return ret;
261
649
    output_samples = (int16_t *)frame->data[0];
262
649
    samples_end = output_samples + out;
263
264


649
    switch(avctx->codec->id) {
265
266
340
    case AV_CODEC_ID_ROQ_DPCM:
267
340
        bytestream2_skipu(&gb, 6);
268
269
340
        if (stereo) {
270
340
            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
271
340
            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
272
        } else {
273
            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
274
        }
275
276
        /* decode the samples */
277
523240
        while (output_samples < samples_end) {
278
522900
            predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
279
522900
            predictor[ch]  = av_clip_int16(predictor[ch]);
280
522900
            *output_samples++ = predictor[ch];
281
282
            /* toggle channel */
283
522900
            ch ^= stereo;
284
        }
285
340
        break;
286
287
124
    case AV_CODEC_ID_INTERPLAY_DPCM:
288
124
        bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
289
290
372
        for (ch = 0; ch < avctx->channels; ch++) {
291
248
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
292
248
            *output_samples++ = predictor[ch];
293
        }
294
295
124
        ch = 0;
296
364752
        while (output_samples < samples_end) {
297
364628
            predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
298
364628
            predictor[ch]  = av_clip_int16(predictor[ch]);
299
364628
            *output_samples++ = predictor[ch];
300
301
            /* toggle channel */
302
364628
            ch ^= stereo;
303
        }
304
124
        break;
305
306
111
    case AV_CODEC_ID_XAN_DPCM:
307
    {
308
111
        int shift[2] = { 4, 4 };
309
310
333
        for (ch = 0; ch < avctx->channels; ch++)
311
222
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
312
313
111
        ch = 0;
314
326229
        while (output_samples < samples_end) {
315
326118
            int diff = bytestream2_get_byteu(&gb);
316
326118
            int n    = diff & 3;
317
318
326118
            if (n == 3)
319
134940
                shift[ch]++;
320
            else
321
191178
                shift[ch] -= (2 * n);
322
326118
            diff = sign_extend((diff &~ 3) << 8, 16);
323
324
            /* saturate the shifter to 0..31 */
325
326118
            shift[ch] = av_clip_uintp2(shift[ch], 5);
326
327
326118
            diff >>= shift[ch];
328
326118
            predictor[ch] += diff;
329
330
326118
            predictor[ch] = av_clip_int16(predictor[ch]);
331
326118
            *output_samples++ = predictor[ch];
332
333
            /* toggle channel */
334
326118
            ch ^= stereo;
335
        }
336
111
        break;
337
    }
338
74
    case AV_CODEC_ID_SOL_DPCM:
339
74
        if (avctx->codec_tag != 3) {
340
            uint8_t *output_samples_u8 = frame->data[0],
341
                    *samples_end_u8 = output_samples_u8 + out;
342
            while (output_samples_u8 < samples_end_u8) {
343
                int n = bytestream2_get_byteu(&gb);
344
345
                s->sample[0] += s->sol_table[n >> 4];
346
                s->sample[0]  = av_clip_uint8(s->sample[0]);
347
                *output_samples_u8++ = s->sample[0];
348
349
                s->sample[stereo] += s->sol_table[n & 0x0F];
350
                s->sample[stereo]  = av_clip_uint8(s->sample[stereo]);
351
                *output_samples_u8++ = s->sample[stereo];
352
            }
353
        } else {
354
299512
            while (output_samples < samples_end) {
355
299438
                int n = bytestream2_get_byteu(&gb);
356
299438
                if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
357
150564
                else          s->sample[ch] += sol_table_16[n & 0x7F];
358
299438
                s->sample[ch] = av_clip_int16(s->sample[ch]);
359
299438
                *output_samples++ = s->sample[ch];
360
                /* toggle channel */
361
299438
                ch ^= stereo;
362
            }
363
        }
364
74
        break;
365
366
    case AV_CODEC_ID_SDX2_DPCM:
367
        while (output_samples < samples_end) {
368
            int8_t n = bytestream2_get_byteu(&gb);
369
370
            if (!(n & 1))
371
                s->sample[ch] = 0;
372
            s->sample[ch] += s->array[n + 128];
373
            s->sample[ch]  = av_clip_int16(s->sample[ch]);
374
            *output_samples++ = s->sample[ch];
375
            ch ^= stereo;
376
        }
377
        break;
378
379
    case AV_CODEC_ID_GREMLIN_DPCM: {
380
        int idx = 0;
381
382
        while (output_samples < samples_end) {
383
            uint8_t n = bytestream2_get_byteu(&gb);
384
385
            *output_samples++ = s->sample[idx] += (unsigned)s->array[n];
386
            idx ^= 1;
387
        }
388
        }
389
        break;
390
391
    case AV_CODEC_ID_DERF_DPCM: {
392
        int idx = 0;
393
394
        while (output_samples < samples_end) {
395
            uint8_t n = bytestream2_get_byteu(&gb);
396
            int index = FFMIN(n & 0x7f, 95);
397
398
            s->sample[idx] += (n & 0x80 ? -1: 1) * derf_steps[index];
399
            s->sample[idx]  = av_clip_int16(s->sample[idx]);
400
            *output_samples++ = s->sample[idx];
401
            idx ^= stereo;
402
        }
403
        }
404
        break;
405
    }
406
407
649
    *got_frame_ptr = 1;
408
409
649
    return avpkt->size;
410
}
411
412
#define DPCM_DECODER(id_, name_, long_name_)                \
413
AVCodec ff_ ## name_ ## _decoder = {                        \
414
    .name           = #name_,                               \
415
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
416
    .type           = AVMEDIA_TYPE_AUDIO,                   \
417
    .id             = id_,                                  \
418
    .priv_data_size = sizeof(DPCMContext),                  \
419
    .init           = dpcm_decode_init,                     \
420
    .decode         = dpcm_decode_frame,                    \
421
    .capabilities   = AV_CODEC_CAP_DR1,                     \
422
}
423
424
DPCM_DECODER(AV_CODEC_ID_DERF_DPCM,      derf_dpcm,      "DPCM Xilam DERF");
425
DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM,   gremlin_dpcm,   "DPCM Gremlin");
426
DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
427
DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
428
DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM,      sdx2_dpcm,      "DPCM Squareroot-Delta-Exact");
429
DPCM_DECODER(AV_CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
430
DPCM_DECODER(AV_CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");