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) & 0x0F     ];                    coeff2 = ea_adpcm_table[((*srcC>>4) & 0x0F) + 4];                    shift = (*srcC++ & 0x0F) + 8;                    for (count2=0; count2<28; count2++) {                        if (count2 & 1)                            next_sample = ((*srcC++ & 0x0F) << 28) >> shift;                        else                            next_sample = ((*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) {                c->status[channel].predictor   = current_sample;                c->status[channel].prev_sample = previous_sample;            }        }        src = src + buf_size - (4 + 4*avctx->channels);        samples += 28 * samples_in_chunk * avctx->channels;        break;    }    case CODEC_ID_ADPCM_EA_XAS:        if (samples_end-samples < 32*4*avctx->channels            || buf_size < (4+15)*4*avctx->channels) {            src += buf_size;            break;        }        for (channel=0; channel<avctx->channels; channel++) {            int coeff[2][4], shift[4];            short *s2, *s = &samples[channel];            for (n=0; n<4; n++, s+=32*avctx->channels) {                for (i=0; i<2; i++)                    coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i];                shift[n] = (src[2]&0x0F) + 8;                for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels)                    s2[0] = (src[0]&0xF0) + (src[1]<<8);            }            for (m=2; m<32; m+=2) {                s = &samples[m*avctx->channels + channel];                for (n=0; n<4; n++, src++, s+=32*avctx->channels) {                    for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {                        int level = ((*src & (0xF0>>i)) << (24+i)) >> shift[n];                        int pred  = s2[-1*avctx->channels] * coeff[0][n]                                  + s2[-2*avctx->channels] * coeff[1][n];                        s2[0] = av_clip_int16((level + pred + 0x80) >> 8);                    }                }            }        }        samples += 32*4*avctx->channels;        break;    case CODEC_ID_ADPCM_IMA_AMV:    case CODEC_ID_ADPCM_IMA_SMJPEG:        c->status[0].predictor = (int16_t)bytestream_get_le16(&src);        c->status[0].step_index = bytestream_get_le16(&src);        if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)            src+=4;        while (src < buf + buf_size) {            char hi, lo;            lo = *src & 0x0F;            hi = (*src >> 4) & 0x0F;            if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)                FFSWAP(char, hi, lo);            *samples++ = adpcm_ima_expand_nibble(&c->status[0],                lo, 3);            *samples++ = adpcm_ima_expand_nibble(&c->status[0],                hi, 3);            src++;        }        break;    case CODEC_ID_ADPCM_CT:        while (src < buf + buf_size) {            if (st) {                *samples++ = adpcm_ct_expand_nibble(&c->status[0],                    (src[0] >> 4) & 0x0F);                *samples++ = adpcm_ct_expand_nibble(&c->status[1],                    src[0] & 0x0F);            } else {                *samples++ = adpcm_ct_expand_nibble(&c->status[0],                    (src[0] >> 4) & 0x0F);                *samples++ = adpcm_ct_expand_nibble(&c->status[0],                    src[0] & 0x0F);            }            src++;        }        break;    case CODEC_ID_ADPCM_SBPRO_4:    case CODEC_ID_ADPCM_SBPRO_3:    case CODEC_ID_ADPCM_SBPRO_2:        if (!c->status[0].step_index) {            /* the first byte is a raw sample */            *samples++ = 128 * (*src++ - 0x80);            if (st)              *samples++ = 128 * (*src++ - 0x80);            c->status[0].step_index = 1;        }        if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {            while (src < buf + buf_size) {                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    (src[0] >> 4) & 0x0F, 4, 0);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],                    src[0] & 0x0F, 4, 0);                src++;            }        } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {            while (src < buf + buf_size && samples + 2 < samples_end) {                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    (src[0] >> 5) & 0x07, 3, 0);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    (src[0] >> 2) & 0x07, 3, 0);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    src[0] & 0x03, 2, 0);                src++;            }        } else {            while (src < buf + buf_size && samples + 3 < samples_end) {                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    (src[0] >> 6) & 0x03, 2, 2);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],                    (src[0] >> 4) & 0x03, 2, 2);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],                    (src[0] >> 2) & 0x03, 2, 2);                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],                    src[0] & 0x03, 2, 2);                src++;            }        }        break;    case CODEC_ID_ADPCM_SWF:    {        GetBitContext gb;        const int *table;        int k0, signmask, nb_bits, count;        int size = buf_size*8;        init_get_bits(&gb, buf, size);        //read bits & initial values        nb_bits = get_bits(&gb, 2)+2;        //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);        table = swf_index_tables[nb_bits-2];        k0 = 1 << (nb_bits-2);        signmask = 1 << (nb_bits-1);        while (get_bits_count(&gb) <= size - 22*avctx->channels) {            for (i = 0; i < avctx->channels; i++) {                *samples++ = c->status[i].predictor = get_sbits(&gb, 16);                c->status[i].step_index = get_bits(&gb, 6);            }            for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {                int i;                for (i = 0; i < avctx->channels; i++) {                    // similar to IMA adpcm                    int delta = get_bits(&gb, nb_bits);                    int step = step_table[c->status[i].step_index];                    long vpdiff = 0; // vpdiff = (delta+0.5)*step/4                    int k = k0;                    do {                        if (delta & k)                            vpdiff += step;                        step >>= 1;                        k >>= 1;                    } while(k);                    vpdiff += step;                    if (delta & signmask)                        c->status[i].predictor -= vpdiff;                    else                        c->status[i].predictor += vpdiff;                    c->status[i].step_index += table[delta & (~signmask)];                    c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);                    c->status[i].predictor = av_clip_int16(c->status[i].predictor);                    *samples++ = c->status[i].predictor;                    if (samples >= samples_end) {                        av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");                        return -1;                    }                }            }        }        src += buf_size;        break;    }    case CODEC_ID_ADPCM_YAMAHA:        while (src < buf + buf_size) {            if (st) {                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],                        src[0] & 0x0F);                *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],                        (src[0] >> 4) & 0x0F);            } else {                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],                        src[0] & 0x0F);                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],                        (src[0] >> 4) & 0x0F);            }            src++;        }        break;    case CODEC_ID_ADPCM_THP:    {        int table[2][16];        unsigned int samplecnt;        int prev[2][2];        int ch;        if (buf_size < 80) {            av_log(avctx, AV_LOG_ERROR, "frame too small\n");            return -1;        }        src+=4;        samplecnt = bytestream_get_be32(&src);        for (i = 0; i < 32; i++)            table[0][i] = (int16_t)bytestream_get_be16(&src);        /* Initialize the previous sample.  */        for (i = 0; i < 4; i++)            prev[0][i] = (int16_t)bytestream_get_be16(&src);        if (samplecnt >= (samples_end - samples) /  (st + 1)) {            av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");            return -1;        }        for (ch = 0; ch <= st; ch++) {            samples = (unsigned short *) data + ch;            /* Read in every sample for this channel.  */            for (i = 0; i < samplecnt / 14; i++) {                int index = (*src >> 4) & 7;                unsigned int exp = 28 - (*src++ & 15);                int factor1 = table[ch][index * 2];                int factor2 = table[ch][index * 2 + 1];                /* Decode 14 samples.  */                for (n = 0; n < 14; n++) {                    int32_t sampledat;                    if(n&1) sampledat=  *src++    <<28;                    else    sampledat= (*src&0xF0)<<24;                    sampledat = ((prev[ch][0]*factor1                                + prev[ch][1]*factor2) >> 11) + (sampledat>>exp);                    *samples = av_clip_int16(sampledat);                    prev[ch][1] = prev[ch][0];                    prev[ch][0] = *samples++;                    /* In case of stereo, skip one sample, this sample                       is for the other channel.  */                    samples += st;                }            }        }        /* In the previous loop, in case stereo is used, samples is           increased exactly one time too often.  */        samples -= st;        break;    }    default:        return -1;    }    *data_size = (uint8_t *)samples - (uint8_t *)data;    return src - buf;}#ifdef CONFIG_ENCODERS#define ADPCM_ENCODER(id,name)                  \AVCodec name ## _encoder = {                    \    #name,                                      \    CODEC_TYPE_AUDIO,                           \    id,                                         \    sizeof(ADPCMContext),                       \    adpcm_encode_init,                          \    adpcm_encode_frame,                         \    adpcm_encode_close,                         \    NULL,                                       \};#else#define ADPCM_ENCODER(id,name)#endif#ifdef CONFIG_DECODERS#define ADPCM_DECODER(id,name)                  \AVCodec name ## _decoder = {                    \    #name,                                      \    CODEC_TYPE_AUDIO,                           \    id,                                         \    sizeof(ADPCMContext),                       \    adpcm_decode_init,                          \    NULL,                                       \    NULL,                                       \    adpcm_decode_frame,                         \};#else#define ADPCM_DECODER(id,name)#endif#define ADPCM_CODEC(id, name)                   \ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm);ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct);ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea);ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1);ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2);ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3);ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);ADPCM_CODEC  (CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);ADPCM_CODEC  (CODEC_ID_ADPCM_MS, adpcm_ms);ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4);ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3);ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2);ADPCM_CODEC  (CODEC_ID_ADPCM_SWF, adpcm_swf);ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp);ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa);ADPCM_CODEC  (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha);