/* * ADPCM codecs * Copyright (c) 2001-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 */#include "avcodec.h"#include "bitstream.h"#include "bytestream.h"/** * @file adpcm.c * ADPCM codecs. * First version by Francois Revol (revol@free.fr) * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood) *   by Mike Melanson (melanson@pcisys.net) * CD-ROM XA ADPCM codec by BERO * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com) * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl) * * Features and limitations: * * Reference documents: * http://www.pcisys.net/~melanson/codecs/simpleaudio.html * http://www.geocities.com/SiliconValley/8682/aud3.txt * http://openquicktime.sourceforge.net/plugins.htm * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html * http://www.cs.ucla.edu/~leec/mediabench/applications.html * SoX source code http://home.sprynet.com/~cbagwell/sox.html * * CD-ROM XA: * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html * readstr http://www.geocities.co.jp/Playtown/2004/ */#define BLKSIZE 1024/* step_table[] and index_table[] are from the ADPCM reference source *//* This is the index table: */static const int index_table[16] = {    -1, -1, -1, -1, 2, 4, 6, 8,    -1, -1, -1, -1, 2, 4, 6, 8,};/** * This is the step table. Note that many programs use slight deviations from * this table, but such deviations are negligible: */static const int step_table[89] = {    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};/* These are for MS-ADPCM *//* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */static const int AdaptationTable[] = {        230, 230, 230, 230, 307, 409, 512, 614,        768, 614, 512, 409, 307, 230, 230, 230};static const int AdaptCoeff1[] = {        256, 512, 0, 192, 240, 460, 392};static const int AdaptCoeff2[] = {        0, -256, 0, 64, 0, -208, -232};/* These are for CD-ROM XA ADPCM */static const int xa_adpcm_table[5][2] = {   {   0,   0 },   {  60,   0 },   { 115, -52 },   {  98, -55 },   { 122, -60 }};static const int ea_adpcm_table[] = {    0, 240, 460, 392, 0, 0, -208, -220, 0, 1,    3, 4, 7, 8, 10, 11, 0, -1, -3, -4};static const int ct_adpcm_table[8] = {    0x00E6, 0x00E6, 0x00E6, 0x00E6,    0x0133, 0x0199, 0x0200, 0x0266};// padded to zero where table size is less then 16static const int swf_index_tables[4][16] = {    /*2*/ { -1, 2 },    /*3*/ { -1, -1, 2, 4 },    /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },    /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }};static const int yamaha_indexscale[] = {    230, 230, 230, 230, 307, 409, 512, 614,    230, 230, 230, 230, 307, 409, 512, 614};static const int yamaha_difflookup[] = {    1, 3, 5, 7, 9, 11, 13, 15,    -1, -3, -5, -7, -9, -11, -13, -15};/* end of tables */typedef struct ADPCMChannelStatus {    int predictor;    short int step_index;    int step;    /* for encoding */    int prev_sample;    /* MS version */    short sample1;    short sample2;    int coeff1;    int coeff2;    int idelta;} ADPCMChannelStatus;typedef struct ADPCMContext {    int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */    ADPCMChannelStatus status[2];    short sample_buffer[32]; /* hold left samples while waiting for right samples */} ADPCMContext;/* XXX: implement encoding */#ifdef CONFIG_ENCODERSstatic int adpcm_encode_init(AVCodecContext *avctx){    if (avctx->channels > 2)        return -1; /* only stereo or mono =) */    switch(avctx->codec->id) {    case CODEC_ID_ADPCM_IMA_QT:        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");        avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */        return -1;        break;    case CODEC_ID_ADPCM_IMA_WAV:        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */                                                             /* and we have 4 bytes per channel overhead */        avctx->block_align = BLKSIZE;        /* seems frame_size isn't taken into account... have to buffer the samples :-( */        break;    case CODEC_ID_ADPCM_MS:        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */                                                             /* and we have 7 bytes per channel overhead */        avctx->block_align = BLKSIZE;        break;    case CODEC_ID_ADPCM_YAMAHA:        avctx->frame_size = BLKSIZE * avctx->channels;        avctx->block_align = BLKSIZE;        break;    case CODEC_ID_ADPCM_SWF:        if (avctx->sample_rate != 11025 &&            avctx->sample_rate != 22050 &&            avctx->sample_rate != 44100) {            av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");            return -1;        }        avctx->frame_size = 512 * (avctx->sample_rate / 11025);        break;    default:        return -1;        break;    }    avctx->coded_frame= avcodec_alloc_frame();    avctx->coded_frame->key_frame= 1;    return 0;}static int adpcm_encode_close(AVCodecContext *avctx){    av_freep(&avctx->coded_frame);    return 0;}static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample){    int delta = sample - c->prev_sample;    int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8;    c->prev_sample += ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8);    c->prev_sample = av_clip_int16(c->prev_sample);    c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88);    return nibble;}static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample){    int predictor, nibble, bias;    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;    nibble= sample - predictor;    if(nibble>=0) bias= c->idelta/2;    else          bias=-c->idelta/2;    nibble= (nibble + bias) / c->idelta;    nibble= av_clip(nibble, -8, 7)&0x0F;    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;    c->sample2 = c->sample1;    c->sample1 = av_clip_int16(predictor);    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;    if (c->idelta < 16) c->idelta = 16;    return nibble;}static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample){    int nibble, delta;    if(!c->step) {        c->predictor = 0;        c->step = 127;    }    delta = sample - c->predictor;    nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;    c->predictor += ((c->step * yamaha_difflookup[nibble]) / 8);    c->predictor = av_clip_int16(c->predictor);    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;    c->step = av_clip(c->step, 127, 24567);    return nibble;}typedef struct TrellisPath {    int nibble;    int prev;} TrellisPath;typedef struct TrellisNode {    uint32_t ssd;    int path;    int sample1;    int sample2;    int step;} TrellisNode;static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,                                   uint8_t *dst, ADPCMChannelStatus *c, int n){#define FREEZE_INTERVAL 128    //FIXME 6% faster if frontier is a compile-time constant    const int frontier = 1 << avctx->trellis;    const int stride = avctx->channels;    const int version = avctx->codec->id;    const int max_paths = frontier*FREEZE_INTERVAL;    TrellisPath paths[max_paths], *p;    TrellisNode node_buf[2][frontier];    TrellisNode *nodep_buf[2][frontier];    TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd    TrellisNode **nodes_next = nodep_buf[1];    int pathn = 0, froze = -1, i, j, k;    assert(!(max_paths&(max_paths-1)));    memset(nodep_buf, 0, sizeof(nodep_buf));    nodes[0] = &node_buf[1][0];    nodes[0]->ssd = 0;    nodes[0]->path = 0;    nodes[0]->step = c->step_index;    nodes[0]->sample1 = c->sample1;    nodes[0]->sample2 = c->sample2;    if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_SWF))        nodes[0]->sample1 = c->prev_sample;    if(version == CODEC_ID_ADPCM_MS)        nodes[0]->step = c->idelta;    if(version == CODEC_ID_ADPCM_YAMAHA) {        if(c->step == 0) {            nodes[0]->step = 127;            nodes[0]->sample1 = 0;        } else {            nodes[0]->step = c->step;            nodes[0]->sample1 = c->predictor;        }    }    for(i=0; i<n; i++) {        TrellisNode *t = node_buf[i&1];        TrellisNode **u;        int sample = samples[i*stride];        memset(nodes_next, 0, frontier*sizeof(TrellisNode*));        for(j=0; j<frontier && nodes[j]; j++) {            // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too            const int range = (j < frontier/2) ? 1 : 0;            const int step = nodes[j]->step;            int nidx;            if(version == CODEC_ID_ADPCM_MS) {                const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 256;                const int div = (sample - predictor) / step;                const int nmin = av_clip(div-range, -8, 6);                const int nmax = av_clip(div+range, -7, 7);                for(nidx=nmin; nidx<=nmax; nidx++) {                    const int nibble = nidx & 0xf;                    int dec_sample = predictor + nidx * step;#define STORE_NODE(NAME, STEP_INDEX)\                    int d;\                    uint32_t ssd;\                    dec_sample = av_clip_int16(dec_sample);\                    d = sample - dec_sample;\                    ssd = nodes[j]->ssd + d*d;\                    if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\                        continue;\                    /* Collapse any two states with the same previous sample value. \                     * One could also distinguish states by step and by 2nd to last                     * sample, but the effects of that are negligible. */\                    for(k=0; k<frontier && nodes_next[k]; k++) {\                        if(dec_sample == nodes_next[k]->sample1) {\                            assert(ssd >= nodes_next[k]->ssd);\                            goto next_##NAME;\                        }\                    }\                    for(k=0; k<frontier; k++) {\                        if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\                            TrellisNode *u = nodes_next[frontier-1];\                            if(!u) {\                                assert(pathn < max_paths);\                                u = t++;\                                u->path = pathn++;\                            }\                            u->ssd = ssd;\                            u->step = STEP_INDEX;\                            u->sample2 = nodes[j]->sample1;\                            u->sample1 = dec_sample;\                            paths[u->path].nibble = nibble;\                            paths[u->path].prev = nodes[j]->path;\                            memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\                            nodes_next[k] = u;\                            break;\                        }\                    }\                    next_##NAME:;