/* * ADPCM codecs * Copyright (c) 2001-2003 The ffmpeg Project * * This library 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 of the License, or (at your option) any later version. * * This library 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 this library; 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"/** * @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) * * 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#define CLAMP_TO_SHORT(value) \if (value > 32767) \    value = 32767; \else if (value < -32768) \    value = -32768; \/* 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 */    /* SWF only */    int nb_bits;    int nb_samples;} ADPCMContext;static int adpcm_decode_init(AVCodecContext * avctx){    ADPCMContext *c = avctx->priv_data;    c->channel = 0;    c->status[0].predictor = c->status[1].predictor = 0;    c->status[0].step_index = c->status[1].step_index = 0;    c->status[0].step = c->status[1].step = 0;    switch(avctx->codec->id) {    case CODEC_ID_ADPCM_CT:	c->status[0].step = c->status[1].step = 511;	break;    default:        break;    }    return 0;}static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift){    int step_index;    int predictor;    int sign, delta, diff, step;    step = step_table[c->step_index];    step_index = c->step_index + index_table[(unsigned)nibble];    if (step_index < 0) step_index = 0;    else if (step_index > 88) step_index = 88;    sign = nibble & 8;    delta = nibble & 7;    /* perform direct multiplication instead of series of jumps proposed by     * the reference ADPCM implementation since modern CPUs can do the mults     * quickly enough */    diff = ((2 * delta + 1) * step) >> shift;    predictor = c->predictor;    if (sign) predictor -= diff;    else predictor += diff;    CLAMP_TO_SHORT(predictor);    c->predictor = predictor;    c->step_index = step_index;    return (short)predictor;}static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble){    int predictor;    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;    CLAMP_TO_SHORT(predictor);    c->sample2 = c->sample1;    c->sample1 = predictor;    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;    if (c->idelta < 16) c->idelta = 16;    return (short)predictor;}static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble){    int predictor;    int sign, delta, diff;    int new_step;    sign = nibble & 8;    delta = nibble & 7;    /* perform direct multiplication instead of series of jumps proposed by     * the reference ADPCM implementation since modern CPUs can do the mults     * quickly enough */    diff = ((2 * delta + 1) * c->step) >> 3;    predictor = c->predictor;    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */    if(sign)	predictor = ((predictor * 254) >> 8) - diff;    else    	predictor = ((predictor * 254) >> 8) + diff;    /* calculate new step and clamp it to range 511..32767 */    new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;    c->step = new_step;    if(c->step < 511)	c->step = 511;    if(c->step > 32767)	c->step = 32767;    CLAMP_TO_SHORT(predictor);    c->predictor = predictor;    return (short)predictor;}static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble){    if(!c->step) {        c->predictor = 0;        c->step = 127;    }    c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;    CLAMP_TO_SHORT(c->predictor);    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;    c->step = clip(c->step, 127, 24567);    return c->predictor;}static void xa_decode(short *out, const unsigned char *in,     ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc){    int i, j;    int shift,filter,f0,f1;    int s_1,s_2;    int d,s,t;    for(i=0;i<4;i++) {        shift  = 12 - (in[4+i*2] & 15);        filter = in[4+i*2] >> 4;        f0 = xa_adpcm_table[filter][0];        f1 = xa_adpcm_table[filter][1];        s_1 = left->sample1;        s_2 = left->sample2;        for(j=0;j<28;j++) {            d = in[16+i+j*4];            t = (signed char)(d<<4)>>4;            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);            CLAMP_TO_SHORT(s);            *out = s;            out += inc;            s_2 = s_1;            s_1 = s;        }        if (inc==2) { /* stereo */            left->sample1 = s_1;            left->sample2 = s_2;            s_1 = right->sample1;            s_2 = right->sample2;            out = out + 1 - 28*2;        }        shift  = 12 - (in[5+i*2] & 15);        filter = in[5+i*2] >> 4;        f0 = xa_adpcm_table[filter][0];        f1 = xa_adpcm_table[filter][1];        for(j=0;j<28;j++) {            d = in[16+i+j*4];            t = (signed char)d >> 4;            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);            CLAMP_TO_SHORT(s);            *out = s;            out += inc;            s_2 = s_1;            s_1 = s;        }        if (inc==2) { /* stereo */            right->sample1 = s_1;            right->sample2 = s_2;            out -= 1;        } else {            left->sample1 = s_1;            left->sample2 = s_2;        }    }}/* DK3 ADPCM support macro */#define DK3_GET_NEXT_NIBBLE() \    if (decode_top_nibble_next) \    { \        nibble = (last_byte >> 4) & 0x0F; \        decode_top_nibble_next = 0; \    } \    else \    { \        last_byte = *src++; \        if (src >= buf + buf_size) break; \        nibble = last_byte & 0x0F; \        decode_top_nibble_next = 1; \    }static int adpcm_decode_frame(AVCodecContext *avctx,			    void *data, int *data_size,			    uint8_t *buf, int buf_size){    ADPCMContext *c = avctx->priv_data;    ADPCMChannelStatus *cs;    int n, m, channel, i;    int block_predictor[2];    short *samples;    uint8_t *src;    int st; /* stereo */    /* DK3 ADPCM accounting variables */    unsigned char last_byte = 0;    unsigned char nibble;    int decode_top_nibble_next = 0;    int diff_channel;    /* EA ADPCM state variables */    uint32_t samples_in_chunk;    int32_t previous_left_sample, previous_right_sample;    int32_t current_left_sample, current_right_sample;    int32_t next_left_sample, next_right_sample;    int32_t coeff1l, coeff2l, coeff1r, coeff2r;    uint8_t shift_left, shift_right;    int count1, count2;    if (!buf_size)        return 0;    samples = data;    src = buf;    st = avctx->channels == 2;    switch(avctx->codec->id) {    case CODEC_ID_ADPCM_IMA_QT:        n = (buf_size - 2);/* >> 2*avctx->channels;*/        channel = c->channel;        cs = &(c->status[channel]);        /* (pppppp) (piiiiiii) */        /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */        cs->predictor = (*src++) << 8;        cs->predictor |= (*src & 0x80);        cs->predictor &= 0xFF80;        /* sign extension */        if(cs->predictor & 0x8000)            cs->predictor -= 0x10000;        CLAMP_TO_SHORT(cs->predictor);        cs->step_index = (*src++) & 0x7F;        if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);        if (cs->step_index > 88) cs->step_index = 88;        cs->step = step_table[cs->step_index];        if (st && channel)            samples++;        for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */            *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);            samples += avctx->channels;            *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);            samples += avctx->channels;            src ++;        }        if(st) { /* handle stereo interlacing */            c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */            if(channel == 1) { /* wait for the other packet before outputing anything */                return src - buf;            }        }        break;    case CODEC_ID_ADPCM_IMA_WAV:        if (avctx->block_align != 0 && buf_size > avctx->block_align)            buf_size = avctx->block_align;