/src/ffmpeg/libavcodec/dpcm.c

Source
/*
 * Assorted DPCM codecs
 * Copyright (c) 2003 The FFmpeg project
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * Assorted DPCM (differential pulse code modulation) audio codecs
 * by Mike Melanson (melanson@pcisys.net)
 * Xan DPCM decoder by Mario Brito (mbrito@student.dei.uc.pt)
 * for more information on the specific data formats, visit:
 *   http://www.pcisys.net/~melanson/codecs/simpleaudio.html
 * SOL DPCMs implemented by Konstantin Shishkov
 *
 * 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.
 */

#include "avcodec.h"
#include "bytestream.h"
#include "codec_internal.h"
#include "decode.h"
#include "mathops.h"

#include "libavutil/attributes.h"

typedef struct DPCMContext {
    int16_t array[256];
    int sample[2];                  ///< previous sample (for SOL_DPCM and WADY_DPCM)
    int scale;                      ///< scale for WADY_DPCM
    const int8_t *sol_table;        ///< delta table for SOL_DPCM
} DPCMContext;

static const int32_t derf_steps[96] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 9, 10, 11, 12, 13, 14, 16,
    17, 19, 21, 23, 25, 28, 31, 34,
    37, 41, 45, 50, 55, 60, 66, 73,
    80, 88, 97, 107, 118, 130, 143, 157,
    173, 190, 209, 230, 253, 279, 307, 337,
    371, 408, 449, 494, 544, 598, 658, 724,
    796, 876, 963, 1060, 1166, 1282, 1411, 1552,
    1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
    3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,
    7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289,
    16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
};

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

};

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

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

static const int16_t sol_table_16[128] = {
    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
};

static const int16_t wady_table[128] = {
    0,   2,   4,   6,   8,   10,  12,  15,
    18,  21,  24,  28,  32,  36,  40,  44,
    49,  54,  59,  64,  70,  76,  82,  88,
    95,  102, 109, 116, 124, 132, 140, 148,
    160, 170, 180, 190, 200, 210, 220, 230,
    240, 255, 270, 285, 300, 320, 340, 360,
    380, 400, 425, 450, 475, 500, 525, 550,
    580, 610, 650, 700, 750, 800, 900, 1000,
    -0,  -2,  -4,  -6,  -8,  -10, -12, -15,
    -18, -21, -24, -28, -32, -36, -40, -44,
    -49, -54, -59, -64, -70, -76, -82, -88,
    -95, -102,-109,-116,-124,-132,-140,-148,
    -160,-170,-180,-190,-200,-210,-220,-230,
    -240,-255,-270,-285,-300,-320,-340,-360,
    -380,-400,-425,-450,-475,-500,-525,-550,
    -580,-610,-650,-700,-750,-800,-900,-1000,
};

static av_cold int dpcm_decode_init(AVCodecContext *avctx)
{
    DPCMContext *s = avctx->priv_data;
    int i;

    if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2) {
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
        return AVERROR(EINVAL);
    }

    s->sample[0] = s->sample[1] = 0;

    switch (avctx->codec->id) {

    case AV_CODEC_ID_ROQ_DPCM:
        /* initialize square table */
        for (i = 0; i < 128; i++) {
            int16_t square = i * i;
            s->array[i      ] =  square;
            s->array[i + 128] = -square;
        }
        break;

    case AV_CODEC_ID_SOL_DPCM:
        switch(avctx->codec_tag){
        case 1:
            s->sol_table = sol_table_old;
            s->sample[0] = s->sample[1] = 0x80;
            break;
        case 2:
            s->sol_table = sol_table_new;
            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;

    case AV_CODEC_ID_SDX2_DPCM:
        for (i = -128; i < 128; i++) {
            int16_t square = i * i * 2;
            s->array[i+128] = i < 0 ? -square: square;
        }
        break;

    case AV_CODEC_ID_CBD2_DPCM:
        for (i = -128; i < 128; i++) {
            int16_t cube = (i * i * i) / 64;
            s->array[i+128] = cube;
        }
        break;

    case AV_CODEC_ID_GREMLIN_DPCM: {
        int delta = 0;
        int code = 64;
        int step = 45;

        s->array[0] = 0;
        for (i = 0; i < 127; i++) {
            delta += (code >> 5);
            code  += step;
            step  += 2;

            s->array[i*2 + 1] =  delta;
            s->array[i*2 + 2] = -delta;
        }
        s->array[255] = delta + (code >> 5);
        }
        break;

    case AV_CODEC_ID_WADY_DPCM:
        s->scale = (avctx->extradata && avctx->extradata_size > 0) ? avctx->extradata[0] : 1;
        break;

    default:
        break;
    }

    if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
    else
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;

    return 0;
}


static int dpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                             int *got_frame_ptr, AVPacket *avpkt)
{
    int buf_size = avpkt->size;
    DPCMContext *s = avctx->priv_data;
    int out = 0, ret;
    int predictor[2];
    int ch = 0;
    int stereo = avctx->ch_layout.nb_channels - 1;
    int16_t *output_samples, *samples_end;
    GetByteContext gb;

    if (stereo && (buf_size & 1))
        buf_size--;
    bytestream2_init(&gb, avpkt->data, buf_size);

    /* calculate output size */
    switch(avctx->codec->id) {
    case AV_CODEC_ID_ROQ_DPCM:
        out = buf_size - 8;
        break;
    case AV_CODEC_ID_INTERPLAY_DPCM:
        out = buf_size - 6 - avctx->ch_layout.nb_channels;
        break;
    case AV_CODEC_ID_XAN_DPCM:
        out = buf_size - 2 * avctx->ch_layout.nb_channels;
        break;
    case AV_CODEC_ID_SOL_DPCM:
        if (avctx->codec_tag != 3)
            out = buf_size * 2;
        else
            out = buf_size;
        break;
    case AV_CODEC_ID_WADY_DPCM:
    case AV_CODEC_ID_DERF_DPCM:
    case AV_CODEC_ID_GREMLIN_DPCM:
    case AV_CODEC_ID_CBD2_DPCM:
    case AV_CODEC_ID_SDX2_DPCM:
        out = buf_size;
        break;
    }
    if (out <= 0) {
        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
        return AVERROR(EINVAL);
    }
    if (out % avctx->ch_layout.nb_channels) {
        av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
    }

    /* get output buffer */
    frame->nb_samples = (out + avctx->ch_layout.nb_channels - 1) / avctx->ch_layout.nb_channels;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;
    output_samples = (int16_t *)frame->data[0];
    samples_end = output_samples + out;

    switch(avctx->codec->id) {

    case AV_CODEC_ID_ROQ_DPCM:
        bytestream2_skipu(&gb, 6);

        if (stereo) {
            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
        } else {
            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
        }

        /* decode the samples */
        while (output_samples < samples_end) {
            predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
            predictor[ch]  = av_clip_int16(predictor[ch]);
            *output_samples++ = predictor[ch];

            /* toggle channel */
            ch ^= stereo;
        }
        break;

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

        for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
            *output_samples++ = predictor[ch];
        }

        ch = 0;
        while (output_samples < samples_end) {
            predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
            predictor[ch]  = av_clip_int16(predictor[ch]);
            *output_samples++ = predictor[ch];

            /* toggle channel */
            ch ^= stereo;
        }
        break;

    case AV_CODEC_ID_XAN_DPCM:
    {
        int shift[2] = { 4, 4 };

        for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);

        ch = 0;
        while (output_samples < samples_end) {
            int diff = bytestream2_get_byteu(&gb);
            int n    = diff & 3;

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

            /* saturate the shifter to 0..31 */
            shift[ch] = av_clip_uintp2(shift[ch], 5);

            diff >>= shift[ch];
            predictor[ch] += diff;

            predictor[ch] = av_clip_int16(predictor[ch]);
            *output_samples++ = predictor[ch];

            /* toggle channel */
            ch ^= stereo;
        }
        break;
    }
    case AV_CODEC_ID_SOL_DPCM:
        if (avctx->codec_tag != 3) {
            uint8_t *output_samples_u8 = frame->data[0],
                    *samples_end_u8 = output_samples_u8 + out;
            while (output_samples_u8 < samples_end_u8) {
                int n = bytestream2_get_byteu(&gb);

                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];
            }
        } else {
            while (output_samples < samples_end) {
                int n = bytestream2_get_byteu(&gb);
                if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
                else          s->sample[ch] += sol_table_16[n & 0x7F];
                s->sample[ch] = av_clip_int16(s->sample[ch]);
                *output_samples++ = s->sample[ch];
                /* toggle channel */
                ch ^= stereo;
            }
        }
        break;

    case AV_CODEC_ID_CBD2_DPCM:
    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->array[n + 128];
            s->sample[ch]  = av_clip_int16(s->sample[ch]);
            *output_samples++ = s->sample[ch];
            ch ^= stereo;
        }
        break;

    case AV_CODEC_ID_GREMLIN_DPCM: {
        int idx = 0;

        while (output_samples < samples_end) {
            uint8_t n = bytestream2_get_byteu(&gb);

            *output_samples++ = s->sample[idx] += (unsigned)s->array[n];
            idx ^= 1;
        }
        }
        break;

    case AV_CODEC_ID_DERF_DPCM: {
        int idx = 0;

        while (output_samples < samples_end) {
            uint8_t n = bytestream2_get_byteu(&gb);
            int index = FFMIN(n & 0x7f, 95);

            s->sample[idx] += (n & 0x80 ? -1: 1) * derf_steps[index];
            s->sample[idx]  = av_clip_int16(s->sample[idx]);
            *output_samples++ = s->sample[idx];
            idx ^= stereo;
        }
        }
        break;

    case AV_CODEC_ID_WADY_DPCM: {
        int idx = 0;

        while (output_samples < samples_end) {
            const uint8_t n = bytestream2_get_byteu(&gb);

            if (n & 0x80)
                s->sample[idx] = sign_extend((n & 0x7f) << 9, 16);
            else
                s->sample[idx] += s->scale * (unsigned)wady_table[n & 0x7f];
            *output_samples++ = av_clip_int16(s->sample[idx]);
            idx ^= stereo;
        }
        }
        break;
    }

    *got_frame_ptr = 1;

    return avpkt->size;
}

static av_cold void dpcm_flush(AVCodecContext *avctx)
{
    DPCMContext *s = avctx->priv_data;

    s->sample[0] = s->sample[1] = 0;
}

#define DPCM_DECODER(id_, name_, long_name_)                \
const FFCodec ff_ ## name_ ## _decoder = {                  \
    .p.name         = #name_,                               \
    CODEC_LONG_NAME(long_name_),                            \
    .p.type         = AVMEDIA_TYPE_AUDIO,                   \
    .p.id           = id_,                                  \
    .p.capabilities = AV_CODEC_CAP_DR1,                     \
    .priv_data_size = sizeof(DPCMContext),                  \
    .init           = dpcm_decode_init,                     \
    .flush          = dpcm_flush,                           \
    FF_CODEC_DECODE_CB(dpcm_decode_frame),                  \
}

DPCM_DECODER(AV_CODEC_ID_CBD2_DPCM,      cbd2_dpcm,      "DPCM Cuberoot-Delta-Exact");
DPCM_DECODER(AV_CODEC_ID_DERF_DPCM,      derf_dpcm,      "DPCM Xilam DERF");
DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM,   gremlin_dpcm,   "DPCM Gremlin");
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_SDX2_DPCM,      sdx2_dpcm,      "DPCM Squareroot-Delta-Exact");
DPCM_DECODER(AV_CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
DPCM_DECODER(AV_CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");
DPCM_DECODER(AV_CODEC_ID_WADY_DPCM,      wady_dpcm,      "DPCM Marble WADY");

Coverage Report

Created: 2025-11-16 07:20

Line	Count	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 "avcodec.h"
41		#include "bytestream.h"
42		#include "codec_internal.h"
43		#include "decode.h"
44		#include "mathops.h"
45
46		#include "libavutil/attributes.h"
47
48		typedef struct DPCMContext {
49		int16_t array[256];
50		int sample[2]; ///< previous sample (for SOL_DPCM and WADY_DPCM)
51		int scale; ///< scale for WADY_DPCM
52		const int8_t *sol_table; ///< delta table for SOL_DPCM
53		} DPCMContext;
54
55		static const int32_t derf_steps[96] = {
56		0, 1, 2, 3, 4, 5, 6, 7,
57		8, 9, 10, 11, 12, 13, 14, 16,
58		17, 19, 21, 23, 25, 28, 31, 34,
59		37, 41, 45, 50, 55, 60, 66, 73,
60		80, 88, 97, 107, 118, 130, 143, 157,
61		173, 190, 209, 230, 253, 279, 307, 337,
62		371, 408, 449, 494, 544, 598, 658, 724,
63		796, 876, 963, 1060, 1166, 1282, 1411, 1552,
64		1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
65		3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,
66		7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289,
67		16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
68		};
69
70		static const int16_t interplay_delta_table[] = {
71		0, 1, 2, 3, 4, 5, 6, 7,
72		8, 9, 10, 11, 12, 13, 14, 15,
73		16, 17, 18, 19, 20, 21, 22, 23,
74		24, 25, 26, 27, 28, 29, 30, 31,
75		32, 33, 34, 35, 36, 37, 38, 39,
76		40, 41, 42, 43, 47, 51, 56, 61,
77		66, 72, 79, 86, 94, 102, 112, 122,
78		133, 145, 158, 173, 189, 206, 225, 245,
79		267, 292, 318, 348, 379, 414, 452, 493,
80		538, 587, 640, 699, 763, 832, 908, 991,
81		1081, 1180, 1288, 1405, 1534, 1673, 1826, 1993,
82		2175, 2373, 2590, 2826, 3084, 3365, 3672, 4008,
83		4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059,
84		8794, 9597, 10472, 11428, 12471, 13609, 14851, 16206,
85		17685, 19298, 21060, 22981, 25078, 27367, 29864, 32589,
86		-29973, -26728, -23186, -19322, -15105, -10503, -5481, -1,
87		1, 1, 5481, 10503, 15105, 19322, 23186, 26728,
88		29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,
89		-17685, -16206, -14851, -13609, -12471, -11428, -10472, -9597,
90		-8794, -8059, -7385, -6767, -6202, -5683, -5208, -4772,
91		-4373, -4008, -3672, -3365, -3084, -2826, -2590, -2373,
92		-2175, -1993, -1826, -1673, -1534, -1405, -1288, -1180,
93		-1081, -991, -908, -832, -763, -699, -640, -587,
94		-538, -493, -452, -414, -379, -348, -318, -292,
95		-267, -245, -225, -206, -189, -173, -158, -145,
96		-133, -122, -112, -102, -94, -86, -79, -72,
97		-66, -61, -56, -51, -47, -43, -42, -41,
98		-40, -39, -38, -37, -36, -35, -34, -33,
99		-32, -31, -30, -29, -28, -27, -26, -25,
100		-24, -23, -22, -21, -20, -19, -18, -17,
101		-16, -15, -14, -13, -12, -11, -10, -9,
102		-8, -7, -6, -5, -4, -3, -2, -1
103
104		};
105
106		static const int8_t sol_table_old[16] = {
107		0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,
108		-0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0
109		};
110
111		static const int8_t sol_table_new[16] = {
112		0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,
113		0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
114		};
115
116		static const int16_t sol_table_16[128] = {
117		0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
118		0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
119		0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
120		0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
121		0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
122		0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
123		0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
124		0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
125		0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
126		0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
127		0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
128		0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
129		0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
130		};
131
132		static const int16_t wady_table[128] = {
133		0, 2, 4, 6, 8, 10, 12, 15,
134		18, 21, 24, 28, 32, 36, 40, 44,
135		49, 54, 59, 64, 70, 76, 82, 88,
136		95, 102, 109, 116, 124, 132, 140, 148,
137		160, 170, 180, 190, 200, 210, 220, 230,
138		240, 255, 270, 285, 300, 320, 340, 360,
139		380, 400, 425, 450, 475, 500, 525, 550,
140		580, 610, 650, 700, 750, 800, 900, 1000,
141		-0, -2, -4, -6, -8, -10, -12, -15,
142		-18, -21, -24, -28, -32, -36, -40, -44,
143		-49, -54, -59, -64, -70, -76, -82, -88,
144		-95, -102,-109,-116,-124,-132,-140,-148,
145		-160,-170,-180,-190,-200,-210,-220,-230,
146		-240,-255,-270,-285,-300,-320,-340,-360,
147		-380,-400,-425,-450,-475,-500,-525,-550,
148		-580,-610,-650,-700,-750,-800,-900,-1000,
149		};
150
151		static av_cold int dpcm_decode_init(AVCodecContext *avctx)
152	4.65k	{
153	4.65k	DPCMContext *s = avctx->priv_data;
154	4.65k	int i;
155
156	4.65k	if (avctx->ch_layout.nb_channels < 1 \|\| avctx->ch_layout.nb_channels > 2) {
157	441	av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
158	441	return AVERROR(EINVAL);
159	441	}
160
161	4.21k	s->sample[0] = s->sample[1] = 0;
162
163	4.21k	switch (avctx->codec->id) {
164
165	501	case AV_CODEC_ID_ROQ_DPCM:
166		/* initialize square table */
167	64.6k	for (i = 0; i < 128; i++) {
168	64.1k	int16_t square = i * i;
169	64.1k	s->array[i ] = square;
170	64.1k	s->array[i + 128] = -square;
171	64.1k	}
172	501	break;
173
174	421	case AV_CODEC_ID_SOL_DPCM:
175	421	switch(avctx->codec_tag){
176	138	case 1:
177	138	s->sol_table = sol_table_old;
178	138	s->sample[0] = s->sample[1] = 0x80;
179	138	break;
180	95	case 2:
181	95	s->sol_table = sol_table_new;
182	95	s->sample[0] = s->sample[1] = 0x80;
183	95	break;
184	185	case 3:
185	185	break;
186	3	default:
187	3	av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
188	3	return -1;
189	421	}
190	418	break;
191
192	475	case AV_CODEC_ID_SDX2_DPCM:
193	122k	for (i = -128; i < 128; i++) {
194	121k	int16_t square = i * i * 2;
195	121k	s->array[i+128] = i < 0 ? -square: square;
196	121k	}
197	475	break;
198
199	462	case AV_CODEC_ID_CBD2_DPCM:
200	118k	for (i = -128; i < 128; i++) {
201	118k	int16_t cube = (i * i * i) / 64;
202	118k	s->array[i+128] = cube;
203	118k	}
204	462	break;
205
206	464	case AV_CODEC_ID_GREMLIN_DPCM: {
207	464	int delta = 0;
208	464	int code = 64;
209	464	int step = 45;
210
211	464	s->array[0] = 0;
212	59.3k	for (i = 0; i < 127; i++) {
213	58.9k	delta += (code >> 5);
214	58.9k	code += step;
215	58.9k	step += 2;
216
217	58.9k	s->array[i*2 + 1] = delta;
218	58.9k	s->array[i*2 + 2] = -delta;
219	58.9k	}
220	464	s->array[255] = delta + (code >> 5);
221	464	}
222	464	break;
223
224	483	case AV_CODEC_ID_WADY_DPCM:
225	483	s->scale = (avctx->extradata && avctx->extradata_size > 0) ? avctx->extradata[0] : 1;
226	483	break;
227
228	1.40k	default:
229	1.40k	break;
230	4.21k	}
231
232	4.20k	if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
233	233	avctx->sample_fmt = AV_SAMPLE_FMT_U8;
234	3.97k	else
235	3.97k	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
236
237	4.20k	return 0;
238	4.21k	}
239
240
241		static int dpcm_decode_frame(AVCodecContext avctx, AVFrame frame,
242		int got_frame_ptr, AVPacket avpkt)
243	2.14M	{
244	2.14M	int buf_size = avpkt->size;
245	2.14M	DPCMContext *s = avctx->priv_data;
246	2.14M	int out = 0, ret;
247	2.14M	int predictor[2];
248	2.14M	int ch = 0;
249	2.14M	int stereo = avctx->ch_layout.nb_channels - 1;
250	2.14M	int16_t output_samples, samples_end;
251	2.14M	GetByteContext gb;
252
253	2.14M	if (stereo && (buf_size & 1))
254	718k	buf_size--;
255	2.14M	bytestream2_init(&gb, avpkt->data, buf_size);
256
257		/* calculate output size */
258	2.14M	switch(avctx->codec->id) {
259	216k	case AV_CODEC_ID_ROQ_DPCM:
260	216k	out = buf_size - 8;
261	216k	break;
262	246k	case AV_CODEC_ID_INTERPLAY_DPCM:
263	246k	out = buf_size - 6 - avctx->ch_layout.nb_channels;
264	246k	break;
265	242k	case AV_CODEC_ID_XAN_DPCM:
266	242k	out = buf_size - 2 * avctx->ch_layout.nb_channels;
267	242k	break;
268	199k	case AV_CODEC_ID_SOL_DPCM:
269	199k	if (avctx->codec_tag != 3)
270	68.4k	out = buf_size * 2;
271	131k	else
272	131k	out = buf_size;
273	199k	break;
274	244k	case AV_CODEC_ID_WADY_DPCM:
275	505k	case AV_CODEC_ID_DERF_DPCM:
276	762k	case AV_CODEC_ID_GREMLIN_DPCM:
277	981k	case AV_CODEC_ID_CBD2_DPCM:
278	1.24M	case AV_CODEC_ID_SDX2_DPCM:
279	1.24M	out = buf_size;
280	1.24M	break;
281	2.14M	}
282	2.14M	if (out <= 0) {
283	911k	av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
284	911k	return AVERROR(EINVAL);
285	911k	}
286	1.23M	if (out % avctx->ch_layout.nb_channels) {
287	0	av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
288	0	}
289
290		/* get output buffer */
291	1.23M	frame->nb_samples = (out + avctx->ch_layout.nb_channels - 1) / avctx->ch_layout.nb_channels;
292	1.23M	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
293	0	return ret;
294	1.23M	output_samples = (int16_t *)frame->data[0];
295	1.23M	samples_end = output_samples + out;
296
297	1.23M	switch(avctx->codec->id) {
298
299	79.1k	case AV_CODEC_ID_ROQ_DPCM:
300	79.1k	bytestream2_skipu(&gb, 6);
301
302	79.1k	if (stereo) {
303	2.60k	predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
304	2.60k	predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
305	76.5k	} else {
306	76.5k	predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
307	76.5k	}
308
309		/* decode the samples */
310	17.0M	while (output_samples < samples_end) {
311	16.9M	predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
312	16.9M	predictor[ch] = av_clip_int16(predictor[ch]);
313	16.9M	*output_samples++ = predictor[ch];
314
315		/* toggle channel */
316	16.9M	ch ^= stereo;
317	16.9M	}
318	79.1k	break;
319
320	135k	case AV_CODEC_ID_INTERPLAY_DPCM:
321	135k	bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */
322
323	273k	for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
324	137k	predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
325	137k	*output_samples++ = predictor[ch];
326	137k	}
327
328	135k	ch = 0;
329	15.4M	while (output_samples < samples_end) {
330	15.3M	predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
331	15.3M	predictor[ch] = av_clip_int16(predictor[ch]);
332	15.3M	*output_samples++ = predictor[ch];
333
334		/* toggle channel */
335	15.3M	ch ^= stereo;
336	15.3M	}
337	135k	break;
338
339	129k	case AV_CODEC_ID_XAN_DPCM:
340	129k	{
341	129k	int shift[2] = { 4, 4 };
342
343	261k	for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
344	131k	predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
345
346	129k	ch = 0;
347	16.6M	while (output_samples < samples_end) {
348	16.4M	int diff = bytestream2_get_byteu(&gb);
349	16.4M	int n = diff & 3;
350
351	16.4M	if (n == 3)
352	5.76M	shift[ch]++;
353	10.7M	else
354	10.7M	shift[ch] -= (2 * n);
355	16.4M	diff = sign_extend((diff &~ 3) << 8, 16);
356
357		/* saturate the shifter to 0..31 */
358	16.4M	shift[ch] = av_clip_uintp2(shift[ch], 5);
359
360	16.4M	diff >>= shift[ch];
361	16.4M	predictor[ch] += diff;
362
363	16.4M	predictor[ch] = av_clip_int16(predictor[ch]);
364	16.4M	*output_samples++ = predictor[ch];
365
366		/* toggle channel */
367	16.4M	ch ^= stereo;
368	16.4M	}
369	129k	break;
370	0	}
371	119k	case AV_CODEC_ID_SOL_DPCM:
372	119k	if (avctx->codec_tag != 3) {
373	4.55k	uint8_t *output_samples_u8 = frame->data[0],
374	4.55k	*samples_end_u8 = output_samples_u8 + out;
375	9.76M	while (output_samples_u8 < samples_end_u8) {
376	9.75M	int n = bytestream2_get_byteu(&gb);
377
378	9.75M	s->sample[0] += s->sol_table[n >> 4];
379	9.75M	s->sample[0] = av_clip_uint8(s->sample[0]);
380	9.75M	*output_samples_u8++ = s->sample[0];
381
382	9.75M	s->sample[stereo] += s->sol_table[n & 0x0F];
383	9.75M	s->sample[stereo] = av_clip_uint8(s->sample[stereo]);
384	9.75M	*output_samples_u8++ = s->sample[stereo];
385	9.75M	}
386	115k	} else {
387	1.90M	while (output_samples < samples_end) {
388	1.79M	int n = bytestream2_get_byteu(&gb);
389	1.79M	if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
390	1.37M	else s->sample[ch] += sol_table_16[n & 0x7F];
391	1.79M	s->sample[ch] = av_clip_int16(s->sample[ch]);
392	1.79M	*output_samples++ = s->sample[ch];
393		/* toggle channel */
394	1.79M	ch ^= stereo;
395	1.79M	}
396	115k	}
397	119k	break;
398
399	139k	case AV_CODEC_ID_CBD2_DPCM:
400	293k	case AV_CODEC_ID_SDX2_DPCM:
401	30.5M	while (output_samples < samples_end) {
402	30.2M	int8_t n = bytestream2_get_byteu(&gb);
403
404	30.2M	if (!(n & 1))
405	15.8M	s->sample[ch] = 0;
406	30.2M	s->sample[ch] += s->array[n + 128];
407	30.2M	s->sample[ch] = av_clip_int16(s->sample[ch]);
408	30.2M	*output_samples++ = s->sample[ch];
409	30.2M	ch ^= stereo;
410	30.2M	}
411	293k	break;
412
413	164k	case AV_CODEC_ID_GREMLIN_DPCM: {
414	164k	int idx = 0;
415
416	14.8M	while (output_samples < samples_end) {
417	14.6M	uint8_t n = bytestream2_get_byteu(&gb);
418
419	14.6M	*output_samples++ = s->sample[idx] += (unsigned)s->array[n];
420	14.6M	idx ^= 1;
421	14.6M	}
422	164k	}
423	164k	break;
424
425	158k	case AV_CODEC_ID_DERF_DPCM: {
426	158k	int idx = 0;
427
428	13.5M	while (output_samples < samples_end) {
429	13.3M	uint8_t n = bytestream2_get_byteu(&gb);
430	13.3M	int index = FFMIN(n & 0x7f, 95);
431
432	13.3M	s->sample[idx] += (n & 0x80 ? -1: 1) * derf_steps[index];
433	13.3M	s->sample[idx] = av_clip_int16(s->sample[idx]);
434	13.3M	*output_samples++ = s->sample[idx];
435	13.3M	idx ^= stereo;
436	13.3M	}
437	158k	}
438	158k	break;
439
440	154k	case AV_CODEC_ID_WADY_DPCM: {
441	154k	int idx = 0;
442
443	15.1M	while (output_samples < samples_end) {
444	15.0M	const uint8_t n = bytestream2_get_byteu(&gb);
445
446	15.0M	if (n & 0x80)
447	3.55M	s->sample[idx] = sign_extend((n & 0x7f) << 9, 16);
448	11.4M	else
449	11.4M	s->sample[idx] += s->scale * (unsigned)wady_table[n & 0x7f];
450	15.0M	*output_samples++ = av_clip_int16(s->sample[idx]);
451	15.0M	idx ^= stereo;
452	15.0M	}
453	154k	}
454	154k	break;
455	1.23M	}
456
457	1.23M	*got_frame_ptr = 1;
458
459	1.23M	return avpkt->size;
460	1.23M	}
461
462		static av_cold void dpcm_flush(AVCodecContext *avctx)
463	514k	{
464	514k	DPCMContext *s = avctx->priv_data;
465
466	514k	s->sample[0] = s->sample[1] = 0;
467	514k	}
468
469		#define DPCM_DECODER(id_, name_, long_name_) \
470		const FFCodec ff_ ## name_ ## _decoder = { \
471		.p.name = #name_, \
472		CODEC_LONG_NAME(long_name_), \
473		.p.type = AVMEDIA_TYPE_AUDIO, \
474		.p.id = id_, \
475		.p.capabilities = AV_CODEC_CAP_DR1, \
476		.priv_data_size = sizeof(DPCMContext), \
477		.init = dpcm_decode_init, \
478		.flush = dpcm_flush, \
479		FF_CODEC_DECODE_CB(dpcm_decode_frame), \
480		}
481
482		DPCM_DECODER(AV_CODEC_ID_CBD2_DPCM, cbd2_dpcm, "DPCM Cuberoot-Delta-Exact");
483		DPCM_DECODER(AV_CODEC_ID_DERF_DPCM, derf_dpcm, "DPCM Xilam DERF");
484		DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM, gremlin_dpcm, "DPCM Gremlin");
485		DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
486		DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
487		DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM, sdx2_dpcm, "DPCM Squareroot-Delta-Exact");
488		DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
489		DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");
490		DPCM_DECODER(AV_CODEC_ID_WADY_DPCM, wady_dpcm, "DPCM Marble WADY");