git.sesse.net Git - ffmpeg/blob - libavcodec/dpcm.c

   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 static av_cold int dpcm_decode_init(AVCodecContext *avctx)
 131 {
 132     DPCMContext *s = avctx->priv_data;
 133     int i;
 134
 135     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     s->sample[0] = s->sample[1] = 0;
 141
 142     switch(avctx->codec->id) {
 143
 144     case AV_CODEC_ID_ROQ_DPCM:
 145         /* initialize square table */
 146         for (i = 0; i < 128; i++) {
 147             int16_t square = i * i;
 148             s->array[i      ] =  square;
 149             s->array[i + 128] = -square;
 150         }
 151         break;
 152
 153     case AV_CODEC_ID_SOL_DPCM:
 154         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         case 3:
 164             break;
 165         default:
 166             av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
 167             return -1;
 168         }
 169         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     default:
 197         break;
 198     }
 199
 200     if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
 201         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
 202     else
 203         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 204
 205     return 0;
 206 }
 207
 208
 209 static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
 210                              int *got_frame_ptr, AVPacket *avpkt)
 211 {
 212     int buf_size = avpkt->size;
 213     DPCMContext *s = avctx->priv_data;
 214     AVFrame *frame = data;
 215     int out = 0, ret;
 216     int predictor[2];
 217     int ch = 0;
 218     int stereo = avctx->channels - 1;
 219     int16_t *output_samples, *samples_end;
 220     GetByteContext gb;
 221
 222     if (stereo && (buf_size & 1))
 223         buf_size--;
 224     bytestream2_init(&gb, avpkt->data, buf_size);
 225
 226     /* calculate output size */
 227     switch(avctx->codec->id) {
 228     case AV_CODEC_ID_ROQ_DPCM:
 229         out = buf_size - 8;
 230         break;
 231     case AV_CODEC_ID_INTERPLAY_DPCM:
 232         out = buf_size - 6 - avctx->channels;
 233         break;
 234     case AV_CODEC_ID_XAN_DPCM:
 235         out = buf_size - 2 * avctx->channels;
 236         break;
 237     case AV_CODEC_ID_SOL_DPCM:
 238         if (avctx->codec_tag != 3)
 239             out = buf_size * 2;
 240         else
 241             out = buf_size;
 242         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     if (out <= 0) {
 250         av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
 251         return AVERROR(EINVAL);
 252     }
 253     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     frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
 259     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 260         return ret;
 261     output_samples = (int16_t *)frame->data[0];
 262     samples_end = output_samples + out;
 263
 264     switch(avctx->codec->id) {
 265
 266     case AV_CODEC_ID_ROQ_DPCM:
 267         bytestream2_skipu(&gb, 6);
 268
 269         if (stereo) {
 270             predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
 271             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         while (output_samples < samples_end) {
 278             predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
 279             predictor[ch]  = av_clip_int16(predictor[ch]);
 280             *output_samples++ = predictor[ch];
 281
 282             /* toggle channel */
 283             ch ^= stereo;
 284         }
 285         break;
 286
 287     case AV_CODEC_ID_INTERPLAY_DPCM:
 288         bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
 289
 290         for (ch = 0; ch < avctx->channels; ch++) {
 291             predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
 292             *output_samples++ = predictor[ch];
 293         }
 294
 295         ch = 0;
 296         while (output_samples < samples_end) {
 297             predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
 298             predictor[ch]  = av_clip_int16(predictor[ch]);
 299             *output_samples++ = predictor[ch];
 300
 301             /* toggle channel */
 302             ch ^= stereo;
 303         }
 304         break;
 305
 306     case AV_CODEC_ID_XAN_DPCM:
 307     {
 308         int shift[2] = { 4, 4 };
 309
 310         for (ch = 0; ch < avctx->channels; ch++)
 311             predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
 312
 313         ch = 0;
 314         while (output_samples < samples_end) {
 315             int diff = bytestream2_get_byteu(&gb);
 316             int n    = diff & 3;
 317
 318             if (n == 3)
 319                 shift[ch]++;
 320             else
 321                 shift[ch] -= (2 * n);
 322             diff = sign_extend((diff &~ 3) << 8, 16);
 323
 324             /* saturate the shifter to 0..31 */
 325             shift[ch] = av_clip_uintp2(shift[ch], 5);
 326
 327             diff >>= shift[ch];
 328             predictor[ch] += diff;
 329
 330             predictor[ch] = av_clip_int16(predictor[ch]);
 331             *output_samples++ = predictor[ch];
 332
 333             /* toggle channel */
 334             ch ^= stereo;
 335         }
 336         break;
 337     }
 338     case AV_CODEC_ID_SOL_DPCM:
 339         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             while (output_samples < samples_end) {
 355                 int n = bytestream2_get_byteu(&gb);
 356                 if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
 357                 else          s->sample[ch] += sol_table_16[n & 0x7F];
 358                 s->sample[ch] = av_clip_int16(s->sample[ch]);
 359                 *output_samples++ = s->sample[ch];
 360                 /* toggle channel */
 361                 ch ^= stereo;
 362             }
 363         }
 364         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     *got_frame_ptr = 1;
 408
 409     return avpkt->size;
 410 }
 411
 412 #define DPCM_DECODER(id_, name_, long_name_)                \
 413 const 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");