STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));                }            } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_SWF)) {#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\                const int predictor = nodes[j]->sample1;\                const int div = (sample - predictor) * 4 / STEP_TABLE;\                int nmin = av_clip(div-range, -7, 6);\                int nmax = av_clip(div+range, -6, 7);\                if(nmin<=0) nmin--; /* distinguish -0 from +0 */\                if(nmax<0) nmax--;\                for(nidx=nmin; nidx<=nmax; nidx++) {\                    const int nibble = nidx<0 ? 7-nidx : nidx;\                    int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\                    STORE_NODE(NAME, STEP_INDEX);\                }                LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));            } else { //CODEC_ID_ADPCM_YAMAHA                LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));#undef LOOP_NODES#undef STORE_NODE            }        }        u = nodes;        nodes = nodes_next;        nodes_next = u;        // prevent overflow        if(nodes[0]->ssd > (1<<28)) {            for(j=1; j<frontier && nodes[j]; j++)                nodes[j]->ssd -= nodes[0]->ssd;            nodes[0]->ssd = 0;        }        // merge old paths to save memory        if(i == froze + FREEZE_INTERVAL) {            p = &paths[nodes[0]->path];            for(k=i; k>froze; k--) {                dst[k] = p->nibble;                p = &paths[p->prev];            }            froze = i;            pathn = 0;            // other nodes might use paths that don't coincide with the frozen one.            // checking which nodes do so is too slow, so just kill them all.            // this also slightly improves quality, but I don't know why.            memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));        }    }    p = &paths[nodes[0]->path];    for(i=n-1; i>froze; i--) {        dst[i] = p->nibble;        p = &paths[p->prev];    }    c->predictor = nodes[0]->sample1;    c->sample1 = nodes[0]->sample1;    c->sample2 = nodes[0]->sample2;    c->step_index = nodes[0]->step;    c->step = nodes[0]->step;    c->idelta = nodes[0]->step;}static int adpcm_encode_frame(AVCodecContext *avctx,                            unsigned char *frame, int buf_size, void *data){    int n, i, st;    short *samples;    unsigned char *dst;    ADPCMContext *c = avctx->priv_data;    dst = frame;    samples = (short *)data;    st= avctx->channels == 2;/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */    switch(avctx->codec->id) {    case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */        break;    case CODEC_ID_ADPCM_IMA_WAV:        n = avctx->frame_size / 8;            c->status[0].prev_sample = (signed short)samples[0]; /* XXX *//*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */            bytestream_put_le16(&dst, c->status[0].prev_sample);            *dst++ = (unsigned char)c->status[0].step_index;            *dst++ = 0; /* unknown */            samples++;            if (avctx->channels == 2) {                c->status[1].prev_sample = (signed short)samples[1];/*                c->status[1].step_index = 0; */                bytestream_put_le16(&dst, c->status[1].prev_sample);                *dst++ = (unsigned char)c->status[1].step_index;                *dst++ = 0;                samples++;            }            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */            if(avctx->trellis > 0) {                uint8_t buf[2][n*8];                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8);                if(avctx->channels == 2)                    adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8);                for(i=0; i<n; i++) {                    *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4);                    *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4);                    *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4);                    *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4);                    if (avctx->channels == 2) {                        *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4);                        *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4);                        *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4);                        *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4);                    }                }            } else            for (; n>0; n--) {                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;                dst++;                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;                dst++;                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;                dst++;                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;                dst++;                /* right channel */                if (avctx->channels == 2) {                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;                    dst++;                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;                    dst++;                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;                    dst++;                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;                    dst++;                }                samples += 8 * avctx->channels;            }        break;    case CODEC_ID_ADPCM_SWF:    {        int i;        PutBitContext pb;        init_put_bits(&pb, dst, buf_size*8);        n = avctx->frame_size-1;        //Store AdpcmCodeSize        put_bits(&pb, 2, 2);                //Set 4bits flash adpcm format        //Init the encoder state        for(i=0; i<avctx->channels; i++){            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits            put_bits(&pb, 16, samples[i] & 0xFFFF);            put_bits(&pb, 6, c->status[i].step_index);            c->status[i].prev_sample = (signed short)samples[i];        }        if(avctx->trellis > 0) {            uint8_t buf[2][n];            adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n);            if (avctx->channels == 2)                adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n);            for(i=0; i<n; i++) {                put_bits(&pb, 4, buf[0][i]);                if (avctx->channels == 2)                    put_bits(&pb, 4, buf[1][i]);            }        } else {            for (i=1; i<avctx->frame_size; i++) {                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]) & 0xF);                if (avctx->channels == 2)                    put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]) & 0xF);            }        }        flush_put_bits(&pb);        dst += put_bits_count(&pb)>>3;        break;    }    case CODEC_ID_ADPCM_MS:        for(i=0; i<avctx->channels; i++){            int predictor=0;            *dst++ = predictor;            c->status[i].coeff1 = AdaptCoeff1[predictor];            c->status[i].coeff2 = AdaptCoeff2[predictor];        }        for(i=0; i<avctx->channels; i++){            if (c->status[i].idelta < 16)                c->status[i].idelta = 16;            bytestream_put_le16(&dst, c->status[i].idelta);        }        for(i=0; i<avctx->channels; i++){            c->status[i].sample1= *samples++;            bytestream_put_le16(&dst, c->status[i].sample1);        }        for(i=0; i<avctx->channels; i++){            c->status[i].sample2= *samples++;            bytestream_put_le16(&dst, c->status[i].sample2);        }        if(avctx->trellis > 0) {            int n = avctx->block_align - 7*avctx->channels;            uint8_t buf[2][n];            if(avctx->channels == 1) {                n *= 2;                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);                for(i=0; i<n; i+=2)                    *dst++ = (buf[0][i] << 4) | buf[0][i+1];            } else {                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);                for(i=0; i<n; i++)                    *dst++ = (buf[0][i] << 4) | buf[1][i];            }        } else        for(i=7*avctx->channels; i<avctx->block_align; i++) {            int nibble;            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);            *dst++ = nibble;        }        break;    case CODEC_ID_ADPCM_YAMAHA:        n = avctx->frame_size / 2;        if(avctx->trellis > 0) {            uint8_t buf[2][n*2];            n *= 2;            if(avctx->channels == 1) {                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);                for(i=0; i<n; i+=2)                    *dst++ = buf[0][i] | (buf[0][i+1] << 4);            } else {                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);                for(i=0; i<n; i++)                    *dst++ = buf[0][i] | (buf[1][i] << 4);            }        } else        for (; n>0; n--) {            for(i = 0; i < avctx->channels; i++) {                int nibble;                nibble  = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);                nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;                *dst++ = nibble;            }            samples += 2 * avctx->channels;        }        break;    default:        return -1;    }    return dst - frame;}#endif //CONFIG_ENCODERSstatic int adpcm_decode_init(AVCodecContext * avctx){    ADPCMContext *c = avctx->priv_data;    if(avctx->channels > 2U){        return -1;    }    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;    case CODEC_ID_ADPCM_IMA_WS:        if (avctx->extradata && avctx->extradata_size == 2 * 4) {            c->status[0].predictor = AV_RL32(avctx->extradata);            c->status[1].predictor = AV_RL32(avctx->extradata + 4);        }        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;    c->predictor = av_clip_int16(predictor);    c->step_index = step_index;    return (short)c->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;    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 c->sample1;}static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble){    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 update is not so trivial: predictor is multiplied on 254/256 before updating */    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);    c->predictor = av_clip_int16(c->predictor);    /* calculate new step and clamp it to range 511..32767 */    new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;    c->step = av_clip(new_step, 511, 32767);    return (short)c->predictor;}static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift){    int sign, delta, diff;    sign = nibble & (1<<(size-1));    delta = nibble & ((1<<(size-1))-1);    diff = delta << (7 + c->step + shift);    /* clamp result */