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,                            const 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;    const 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 = *samples++ = (int16_t)(src[0] + (src[1]<<8));            src+=2;            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;        }        break;    case CODEC_ID_ADPCM_IMA_WS:        /* no per-block initialization; just start decoding the data */        while (src < buf + buf_size) {            if (st) {                *samples++ = adpcm_ima_expand_nibble(&c->status[0],                    (src[0] >> 4) & 0x0F, 3);                *samples++ = adpcm_ima_expand_nibble(&c->status[1],                    src[0] & 0x0F, 3);            } else {                *samples++ = adpcm_ima_expand_nibble(&c->status[0],                    (src[0] >> 4) & 0x0F, 3);                *samples++ = adpcm_ima_expand_nibble(&c->status[0],                    src[0] & 0x0F, 3);            }            src++;        }        break;    case CODEC_ID_ADPCM_XA:        while (buf_size >= 128) {            xa_decode(samples, src, &c->status[0], &c->status[1],                avctx->channels);            src += 128;            samples += 28 * 8;            buf_size -= 128;        }        break;    case CODEC_ID_ADPCM_IMA_EA_EACS:        samples_in_chunk = bytestream_get_le32(&src) >> (1-st);        if (samples_in_chunk > buf_size-4-(8<<st)) {            src += buf_size - 4;            break;        }        for (i=0; i<=st; i++)            c->status[i].step_index = bytestream_get_le32(&src);        for (i=0; i<=st; i++)            c->status[i].predictor  = bytestream_get_le32(&src);        for (; samples_in_chunk; samples_in_chunk--, src++) {            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  *src>>4,   3);            *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3);        }        break;    case CODEC_ID_ADPCM_IMA_EA_SEAD:        for (; src < buf+buf_size; src++) {            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6);            *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6);        }        break;    case CODEC_ID_ADPCM_EA:        samples_in_chunk = AV_RL32(src);        if (samples_in_chunk >= ((buf_size - 12) * 2)) {            src += buf_size;            break;        }        src += 4;        current_left_sample = (int16_t)AV_RL16(src);        src += 2;        previous_left_sample = (int16_t)AV_RL16(src);        src += 2;        current_right_sample = (int16_t)AV_RL16(src);        src += 2;        previous_right_sample = (int16_t)AV_RL16(src);        src += 2;        for (count1 = 0; count1 < samples_in_chunk/28;count1++) {            coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];            coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];            coeff1r = ea_adpcm_table[*src & 0x0F];            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];            src++;            shift_left = ((*src >> 4) & 0x0F) + 8;            shift_right = (*src & 0x0F) + 8;            src++;            for (count2 = 0; count2 < 28; count2++) {                next_left_sample = (((*src & 0xF0) << 24) >> shift_left);                next_right_sample = (((*src & 0x0F) << 28) >> shift_right);                src++;                next_left_sample = (next_left_sample +                    (current_left_sample * coeff1l) +                    (previous_left_sample * coeff2l) + 0x80) >> 8;                next_right_sample = (next_right_sample +                    (current_right_sample * coeff1r) +                    (previous_right_sample * coeff2r) + 0x80) >> 8;                previous_left_sample = current_left_sample;                current_left_sample = av_clip_int16(next_left_sample);                previous_right_sample = current_right_sample;                current_right_sample = av_clip_int16(next_right_sample);                *samples++ = (unsigned short)current_left_sample;                *samples++ = (unsigned short)current_right_sample;            }        }        break;