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  );            *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, 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  , 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  , 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       ];            coeff2l = ea_adpcm_table[(*src >> 4  ) + 4];            coeff1r = ea_adpcm_table[*src & 0x0F];            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];            src++;            shift_left  = (*src >> 4  ) + 8;            shift_right = (*src & 0x0F) + 8;            src++;            for (count2 = 0; count2 < 28; count2++) {                next_left_sample  = (int32_t)((*src & 0xF0) << 24) >> shift_left;                next_right_sample = (int32_t)((*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;    case CODEC_ID_ADPCM_EA_MAXIS_XA:        for(channel = 0; channel < avctx->channels; channel++) {            for (i=0; i<2; i++)                coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];            shift[channel] = (*src & 0x0F) + 8;            src++;        }        for (count1 = 0; count1 < (buf_size - avctx->channels) / avctx->channels; count1++) {            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */                for(channel = 0; channel < avctx->channels; channel++) {                    int32_t sample = (int32_t)(((*(src+channel) >> i) & 0x0F) << 0x1C) >> shift[channel];                    sample = (sample +                             c->status[channel].sample1 * coeff[channel][0] +                             c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;                    c->status[channel].sample2 = c->status[channel].sample1;                    c->status[channel].sample1 = av_clip_int16(sample);                    *samples++ = c->status[channel].sample1;                }            }            src+=avctx->channels;        }        break;    case CODEC_ID_ADPCM_EA_R1:    case CODEC_ID_ADPCM_EA_R2:    case CODEC_ID_ADPCM_EA_R3: {        /* channel numbering           2chan: 0=fl, 1=fr           4chan: 0=fl, 1=rl, 2=fr, 3=rr           6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */        const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;        int32_t previous_sample, current_sample, next_sample;        int32_t coeff1, coeff2;        uint8_t shift;        unsigned int channel;        uint16_t *samplesC;        const uint8_t *srcC;        samples_in_chunk = (big_endian ? bytestream_get_be32(&src)                                       : bytestream_get_le32(&src)) / 28;        if (samples_in_chunk > UINT32_MAX/(28*avctx->channels) ||            28*samples_in_chunk*avctx->channels > samples_end-samples) {            src += buf_size - 4;            break;        }        for (channel=0; channel<avctx->channels; channel++) {            srcC = src + (big_endian ? bytestream_get_be32(&src)                                     : bytestream_get_le32(&src))                       + (avctx->channels-channel-1) * 4;            samplesC = samples + channel;            if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {                current_sample  = (int16_t)bytestream_get_le16(&srcC);                previous_sample = (int16_t)bytestream_get_le16(&srcC);            } else {                current_sample  = c->status[channel].predictor;                previous_sample = c->status[channel].prev_sample;            }            for (count1=0; count1<samples_in_chunk; count1++) {                if (*srcC == 0xEE) {  /* only seen in R2 and R3 */                    srcC++;                    current_sample  = (int16_t)bytestream_get_be16(&srcC);                    previous_sample = (int16_t)bytestream_get_be16(&srcC);                    for (count2=0; count2<28; count2++) {                        *samplesC = (int16_t)bytestream_get_be16(&srcC);                        samplesC += avctx->channels;                    }                } else {                    coeff1 = ea_adpcm_table[ *srcC>>4     ];                    coeff2 = ea_adpcm_table[(*srcC>>4) + 4];                    shift = (*srcC++ & 0x0F) + 8;                    for (count2=0; count2<28; count2++) {                        if (count2 & 1)                            next_sample = (int32_t)((*srcC++ & 0x0F) << 28) >> shift;                        else                            next_sample = (int32_t)((*srcC   & 0xF0) << 24) >> shift;                        next_sample += (current_sample  * coeff1) +                                       (previous_sample * coeff2);                        next_sample = av_clip_int16(next_sample >> 8);                        previous_sample = current_sample;                        current_sample  = next_sample;                        *samplesC = current_sample;                        samplesC += avctx->channels;                    }                }            }            if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {