c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);    /* calculate new step */    if (delta >= (2*size - 3) && c->step < 3)        c->step++;    else if (delta == 0 && c->step > 0)        c->step--;    return (short) c->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;    c->predictor = av_clip_int16(c->predictor);    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;    c->step = av_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);            s_2 = s_1;            s_1 = av_clip_int16(s);            *out = s_1;            out += inc;        }        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);            s_2 = s_1;            s_1 = av_clip_int16(s);            *out = s_1;            out += inc;        }        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;    short *samples_end;    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;    //should protect all 4bit ADPCM variants    //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels    //    if(*data_size/4 < buf_size + 8)        return -1;    samples = data;    samples_end= samples + *data_size/2;    *data_size= 0;    src = buf;    st = avctx->channels == 2 ? 1 : 0;    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;        cs->predictor = av_clip_int16(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);            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;//        samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;        for(i=0; i<avctx->channels; i++){            cs = &(c->status[i]);            cs->predictor = (int16_t)(src[0] + (src[1]<<8));            src+=2;        // XXX: is this correct ??: *samples++ = cs->predictor;            cs->step_index = *src++;            if (cs->step_index > 88){                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);                cs->step_index = 88;            }            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */        }        while(src < buf + buf_size){            for(m=0; m<4; m++){                for(i=0; i<=st; i++)                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);                for(i=0; i<=st; i++)                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4  , 3);                src++;            }            src += 4*st;        }        break;    case CODEC_ID_ADPCM_4XM:        cs = &(c->status[0]);        c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;        if(st){            c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;        }        c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;        if(st){            c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;        }        if (cs->step_index < 0) cs->step_index = 0;        if (cs->step_index > 88) cs->step_index = 88;        m= (buf_size - (src - buf))>>st;        for(i=0; i<m; i++) {            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);            if (st)                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);            if (st)                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);        }        src += m<<st;        break;    case CODEC_ID_ADPCM_MS:        if (avctx->block_align != 0 && buf_size > avctx->block_align)            buf_size = avctx->block_align;        n = buf_size - 7 * avctx->channels;        if (n < 0)            return -1;        block_predictor[0] = av_clip(*src++, 0, 7);        block_predictor[1] = 0;        if (st)            block_predictor[1] = av_clip(*src++, 0, 7);        c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));        src+=2;        if (st){            c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));            src+=2;        }        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];        c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));        src+=2;        if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));        if (st) src+=2;        c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));        src+=2;        if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));        if (st) src+=2;        *samples++ = c->status[0].sample1;        if (st) *samples++ = c->status[1].sample1;        *samples++ = c->status[0].sample2;        if (st) *samples++ = c->status[1].sample2;        for(;n>0;n--) {            *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);            src ++;        }        break;    case CODEC_ID_ADPCM_IMA_DK4:        if (avctx->block_align != 0 && buf_size > avctx->block_align)            buf_size = avctx->block_align;        c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));        c->status[0].step_index = src[2];        src += 4;        *samples++ = c->status[0].predictor;        if (st) {            c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));            c->status[1].step_index = src[2];            src += 4;            *samples++ = c->status[1].predictor;        }        while (src < buf + buf_size) {            /* take care of the top nibble (always left or mono channel) */            *samples++ = adpcm_ima_expand_nibble(&c->status[0],                (src[0] >> 4) & 0x0F, 3);            /* take care of the bottom nibble, which is right sample for             * stereo, or another mono sample */            if (st)                *samples++ = adpcm_ima_expand_nibble(&c->status[1],                    src[0] & 0x0F, 3);            else                *samples++ = adpcm_ima_expand_nibble(&c->status[0],                    src[0] & 0x0F, 3);            src++;        }        break;    case CODEC_ID_ADPCM_IMA_DK3:        if (avctx->block_align != 0 && buf_size > avctx->block_align)            buf_size = avctx->block_align;        if(buf_size + 16 > (samples_end - samples)*3/8)            return -1;        c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));        c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));        c->status[0].step_index = src[14];        c->status[1].step_index = src[15];        /* sign extend the predictors */        src += 16;        diff_channel = c->status[1].predictor;        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when         * the buffer is consumed */        while (1) {            /* for this algorithm, c->status[0] is the sum channel and             * c->status[1] is the diff channel */            /* process the first predictor of the sum channel */            DK3_GET_NEXT_NIBBLE();            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);            /* process the diff channel predictor */            DK3_GET_NEXT_NIBBLE();            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);            /* process the first pair of stereo PCM samples */            diff_channel = (diff_channel + c->status[1].predictor) / 2;            *samples++ = c->status[0].predictor + c->status[1].predictor;            *samples++ = c->status[0].predictor - c->status[1].predictor;            /* process the second predictor of the sum channel */            DK3_GET_NEXT_NIBBLE();            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);            /* process the second pair of stereo PCM samples */            diff_channel = (diff_channel + c->status[1].predictor) / 2;            *samples++ = c->status[0].predictor + c->status[1].predictor;            *samples++ = c->status[0].predictor - c->status[1].predictor;