static int adpcm_decode_frame(AVCodecContext *avctx,

                            void *data, int *data_size,

                            AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    ADPCMDecodeContext *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;

    int coeff[2][2], shift[2];//used in EA MAXIS ADPCM



    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*avctx->channels;

        for (channel = 0; channel < avctx->channels; channel++) {

            int16_t predictor;

            int step_index;

            cs = &(c->status[channel]);

            /* (pppppp) (piiiiiii) */



            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */

            predictor = AV_RB16(src);

            step_index = predictor & 0x7F;

            predictor &= 0xFF80;



            src += 2;



            if (cs->step_index == step_index) {

                int diff = (int)predictor - cs->predictor;

                if (diff < 0)

                    diff = - diff;

                if (diff > 0x7f)

                    goto update;

            } else {

            update:

                cs->step_index = step_index;

                cs->predictor = predictor;

            }



            if (cs->step_index > 88){

                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);

                cs->step_index = 88;

            }



            samples = (short*)data + channel;



            for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */

                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);

                samples += avctx->channels;

                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4  , 3);

                samples += avctx->channels;

                src ++;

            }

        }

        if (st)

            samples--;

        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)bytestream_get_le16(&src);



            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)bytestream_get_le16(&src);

        if(st){

            c->status[1].predictor= (int16_t)bytestream_get_le16(&src);

        }

        c->status[0].step_index= (int16_t)bytestream_get_le16(&src);

        if(st){

            c->status[1].step_index= (int16_t)bytestream_get_le16(&src);

        }

        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, 6);

        block_predictor[1] = 0;

        if (st)

            block_predictor[1] = av_clip(*src++, 0, 6);

        c->status[0].idelta = (int16_t)bytestream_get_le16(&src);

        if (st){

            c->status[1].idelta = (int16_t)bytestream_get_le16(&src);

        }

        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[0]];

        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[0]];

        c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[1]];

        c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[1]];



        c->status[0].sample1 = bytestream_get_le16(&src);

        if (st) c->status[1].sample1 = bytestream_get_le16(&src);

        c->status[0].sample2 = bytestream_get_le16(&src);

        if (st) c->status[1].sample2 = bytestream_get_le16(&src);



        *samples++ = c->status[0].sample2;

        if (st) *samples++ = c->status[1].sample2;

        *samples++ = c->status[0].sample1;

        if (st) *samples++ = c->status[1].sample1;

        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)bytestream_get_le16(&src);

        c->status[0].step_index = *src++;

        src++;

        *samples++ = c->status[0].predictor;

        if (st) {

            c->status[1].predictor  = (int16_t)bytestream_get_le16(&src);

            c->status[1].step_index = *src++;

            src++;

            *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)AV_RL16(src + 10);

        c->status[1].predictor  = (int16_t)AV_RL16(src + 12);

        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_ISS:

        c->status[0].predictor  = (int16_t)AV_RL16(src + 0);

        c->status[0].step_index = src[2];

        src += 4;

        if(st) {

            c->status[1].predictor  = (int16_t)AV_RL16(src + 0);

            c->status[1].step_index = src[2];

            src += 4;

        }



        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] & 0x0F, 3);

                *samples++ = adpcm_ima_expand_nibble(&c->status[0],

                    src[0] >> 4  , 3);

            }



            src++;

        }

        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:

        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,

           each coding 28 stereo samples. */

        if (buf_size < 12) {

            av_log(avctx, AV_LOG_ERROR, "frame too small\n");

            return AVERROR(EINVAL);

        }

        samples_in_chunk = AV_RL32(src);

        if (samples_in_chunk / 28 > (buf_size - 12) / 30) {

            av_log(avctx, AV_LOG_ERROR, "invalid frame\n");

            return AVERROR(EINVAL);

        }

        src += 4;

        current_left_sample   = (int16_t)bytestream_get_le16(&src);

        previous_left_sample  = (int16_t)bytestream_get_le16(&src);

        current_right_sample  = (int16_t)bytestream_get_le16(&src);

        previous_right_sample = (int16_t)bytestream_get_le16(&src);



        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;

            }

        }



        if (src - buf == buf_size - 2)

            src += 2; // Skip terminating 0x0000



        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;

        const uint8_t *src_end = buf + buf_size;



        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++) {

            int32_t offset = (big_endian ? bytestream_get_be32(&src)

                                         : bytestream_get_le32(&src))

                           + (avctx->channels-channel-1) * 4;



            if ((offset < 0) || (offset >= src_end - src - 4)) break;

            srcC  = src + offset;

            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++;

                    if (srcC > src_end - 30*2) break;

                    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;



                    if (srcC > src_end - 14) break;

                    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) {

                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 = (int32_t)((*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;



            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);

                *samples++ = adpcm_ct_expand_nibble(&c->status[1],

                    src[0] & 0x0F);

            } else {

                *samples++ = adpcm_ct_expand_nibble(&c->status[0],

                    src[0] >> 4);

                *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, 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        , 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        , 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 = ff_adpcm_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  );

            } else {

                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        src[0] & 0x0F);

                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        src[0] >> 4  );

            }

            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;

}

static int adpcm_decode_frame(AVCodecContext *avctx,

                            void *data, int *data_size,

                            AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    ADPCMDecodeContext *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; 



    

    unsigned char last_byte = 0;

    unsigned char nibble;

    int decode_top_nibble_next = 0;

    int diff_channel;



    

    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;

    int coeff[2][2], shift[2];



    if (!buf_size)

        return 0;



    

    

    

    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*avctx->channels;

        for (channel = 0; channel < avctx->channels; channel++) {

            int16_t predictor;

            int step_index;

            cs = &(c->status[channel]);

            



            

            predictor = AV_RB16(src);

            step_index = predictor & 0x7F;

            predictor &= 0xFF80;



            src += 2;



            if (cs->step_index == step_index) {

                int diff = (int)predictor - cs->predictor;

                if (diff < 0)

                    diff = - diff;

                if (diff > 0x7f)

                    goto update;

            } else {

            update:

                cs->step_index = step_index;

                cs->predictor = predictor;

            }



            if (cs->step_index > 88){

                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);

                cs->step_index = 88;

            }



            samples = (short*)data + channel;



            for(m=32; n>0 && m>0; n--, m--) { 

                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);

                samples += avctx->channels;

                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4  , 3);

                samples += avctx->channels;

                src ++;

            }

        }

        if (st)

            samples--;

        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)bytestream_get_le16(&src);



            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]); 

        }



        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)bytestream_get_le16(&src);

        if(st){

            c->status[1].predictor= (int16_t)bytestream_get_le16(&src);

        }

        c->status[0].step_index= (int16_t)bytestream_get_le16(&src);

        if(st){

            c->status[1].step_index= (int16_t)bytestream_get_le16(&src);

        }

        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, 6);

        block_predictor[1] = 0;

        if (st)

            block_predictor[1] = av_clip(*src++, 0, 6);

        c->status[0].idelta = (int16_t)bytestream_get_le16(&src);

        if (st){

            c->status[1].idelta = (int16_t)bytestream_get_le16(&src);

        }

        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[0]];

        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[0]];

        c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[1]];

        c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[1]];



        c->status[0].sample1 = bytestream_get_le16(&src);

        if (st) c->status[1].sample1 = bytestream_get_le16(&src);

        c->status[0].sample2 = bytestream_get_le16(&src);

        if (st) c->status[1].sample2 = bytestream_get_le16(&src);



        *samples++ = c->status[0].sample2;

        if (st) *samples++ = c->status[1].sample2;

        *samples++ = c->status[0].sample1;

        if (st) *samples++ = c->status[1].sample1;

        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)bytestream_get_le16(&src);

        c->status[0].step_index = *src++;

        src++;

        *samples++ = c->status[0].predictor;

        if (st) {

            c->status[1].predictor  = (int16_t)bytestream_get_le16(&src);

            c->status[1].step_index = *src++;

            src++;

            *samples++ = c->status[1].predictor;

        }

        while (src < buf + buf_size) {



            

            *samples++ = adpcm_ima_expand_nibble(&c->status[0],

                src[0] >> 4, 3);



            



            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)AV_RL16(src + 10);

        c->status[1].predictor  = (int16_t)AV_RL16(src + 12);

        c->status[0].step_index = src[14];

        c->status[1].step_index = src[15];

        

        src += 16;

        diff_channel = c->status[1].predictor;



        



        while (1) {



            





            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);



            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);



            

            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;



            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);



            

            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_ISS:

        c->status[0].predictor  = (int16_t)AV_RL16(src + 0);

        c->status[0].step_index = src[2];

        src += 4;

        if(st) {

            c->status[1].predictor  = (int16_t)AV_RL16(src + 0);

            c->status[1].step_index = src[2];

            src += 4;

        }



        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] & 0x0F, 3);

                *samples++ = adpcm_ima_expand_nibble(&c->status[0],

                    src[0] >> 4  , 3);

            }



            src++;

        }

        break;

    case CODEC_ID_ADPCM_IMA_WS:

        

        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:

        



        if (buf_size < 12) {

            av_log(avctx, AV_LOG_ERROR, "frame too small\n");

            return AVERROR(EINVAL);

        }

        samples_in_chunk = AV_RL32(src);

        if (samples_in_chunk / 28 > (buf_size - 12) / 30) {

            av_log(avctx, AV_LOG_ERROR, "invalid frame\n");

            return AVERROR(EINVAL);

        }

        src += 4;

        current_left_sample   = (int16_t)bytestream_get_le16(&src);

        previous_left_sample  = (int16_t)bytestream_get_le16(&src);

        current_right_sample  = (int16_t)bytestream_get_le16(&src);

        previous_right_sample = (int16_t)bytestream_get_le16(&src);



        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;

            }

        }



        if (src - buf == buf_size - 2)

            src += 2;  Skip terminating 0x0000



        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) { 

                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: {

        







        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;

        const uint8_t *src_end = buf + buf_size;



        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++) {

            int32_t offset = (big_endian ? bytestream_get_be32(&src)

                                         : bytestream_get_le32(&src))

                           + (avctx->channels-channel-1) * 4;



            if ((offset < 0) || (offset >= src_end - src - 4)) break;

            srcC  = src + offset;

            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) {  

                    srcC++;

                    if (srcC > src_end - 30*2) break;

                    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;



                    if (srcC > src_end - 14) break;

                    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) {

                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 = (int32_t)((*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;



            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);

                *samples++ = adpcm_ct_expand_nibble(&c->status[1],

                    src[0] & 0x0F);

            } else {

                *samples++ = adpcm_ct_expand_nibble(&c->status[0],

                    src[0] >> 4);

                *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) {

            

            *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, 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        , 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        , 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 = ff_adpcm_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  );

            } else {

                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        src[0] & 0x0F);

                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        src[0] >> 4  );

            }

            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);



        

        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;



            

            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];



                

                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++;



                    



                    samples += st;

                }

            }

        }



        



        samples -= st;

        break;

    }



    default:

        return -1;

    }

    *data_size = (uint8_t *)samples - (uint8_t *)data;

    return src - buf;

}

    case CODEC_ID_ADPCM_IMA_EA_EACS:         if (samples_in_chunk > buf_size-4-(8<<st)) {
static int FUNC_0(AVCodecContext *VAR_0,

                            void *VAR_1, int *VAR_2,

                            AVPacket *VAR_3)

{

    const uint8_t *VAR_4 = VAR_3->VAR_1;

    int VAR_5 = VAR_3->VAR_33;

    ADPCMDecodeContext *c = VAR_0->priv_data;

    ADPCMChannelStatus *cs;

    int VAR_6, VAR_7, VAR_24, VAR_9;

    int VAR_10[2];

    short *VAR_11;

    short *VAR_12;

    const uint8_t *VAR_13;

    int VAR_14; 



    

    unsigned char VAR_15 = 0;

    unsigned char VAR_16;

    int VAR_17 = 0;

    int VAR_18;



    

    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 VAR_19, VAR_20;

    int VAR_21[2][2], VAR_22[2];



    if (!VAR_5)

        return 0;



    

    

    

    if(*VAR_2/4 < VAR_5 + 8)

        return -1;



    VAR_11 = VAR_1;

    VAR_12= VAR_11 + *VAR_2/2;

    *VAR_2= 0;

    VAR_13 = VAR_4;



    VAR_14 = VAR_0->channels == 2 ? 1 : 0;



    switch(VAR_0->codec->id) {

    case CODEC_ID_ADPCM_IMA_QT:

        VAR_6 = VAR_5 - 2*VAR_0->channels;

        for (VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) {

            int16_t predictor;

            int step_index;

            cs = &(c->status[VAR_24]);

            



            

            predictor = AV_RB16(VAR_13);

            step_index = predictor & 0x7F;

            predictor &= 0xFF80;



            VAR_13 += 2;



            if (cs->step_index == step_index) {

                int diff = (int)predictor - cs->predictor;

                if (diff < 0)

                    diff = - diff;

                if (diff > 0x7f)

                    goto update;

            } else {

            update:

                cs->step_index = step_index;

                cs->predictor = predictor;

            }



            if (cs->step_index > 88){

                av_log(VAR_0, AV_LOG_ERROR, "ERROR: step_index = %VAR_9\VAR_6", cs->step_index);

                cs->step_index = 88;

            }



            VAR_11 = (short*)VAR_1 + VAR_24;



            for(VAR_7=32; VAR_6>0 && VAR_7>0; VAR_6--, VAR_7--) { 

                *VAR_11 = adpcm_ima_qt_expand_nibble(cs, VAR_13[0] & 0x0F, 3);

                VAR_11 += VAR_0->channels;

                *VAR_11 = adpcm_ima_qt_expand_nibble(cs, VAR_13[0] >> 4  , 3);

                VAR_11 += VAR_0->channels;

                VAR_13 ++;

            }

        }

        if (VAR_14)

            VAR_11--;

        break;

    case CODEC_ID_ADPCM_IMA_WAV:

        if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)

            VAR_5 = VAR_0->block_align;



        samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;



        for(VAR_9=0; VAR_9<VAR_0->channels; VAR_9++){

            cs = &(c->status[VAR_9]);

            cs->predictor = *VAR_11++ = (int16_t)bytestream_get_le16(&VAR_13);



            cs->step_index = *VAR_13++;

            if (cs->step_index > 88){

                av_log(VAR_0, AV_LOG_ERROR, "ERROR: step_index = %VAR_9\VAR_6", cs->step_index);

                cs->step_index = 88;

            }

            if (*VAR_13++) av_log(VAR_0, AV_LOG_ERROR, "unused byte should be null but is %d!!\VAR_6", VAR_13[-1]); 

        }



        while(VAR_13 < VAR_4 + VAR_5){

            for(VAR_7=0; VAR_7<4; VAR_7++){

                for(VAR_9=0; VAR_9<=VAR_14; VAR_9++)

                    *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_9], VAR_13[4*VAR_9] & 0x0F, 3);

                for(VAR_9=0; VAR_9<=VAR_14; VAR_9++)

                    *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_9], VAR_13[4*VAR_9] >> 4  , 3);

                VAR_13++;

            }

            VAR_13 += 4*VAR_14;

        }

        break;

    case CODEC_ID_ADPCM_4XM:

        cs = &(c->status[0]);

        c->status[0].predictor= (int16_t)bytestream_get_le16(&VAR_13);

        if(VAR_14){

            c->status[1].predictor= (int16_t)bytestream_get_le16(&VAR_13);

        }

        c->status[0].step_index= (int16_t)bytestream_get_le16(&VAR_13);

        if(VAR_14){

            c->status[1].step_index= (int16_t)bytestream_get_le16(&VAR_13);

        }

        if (cs->step_index < 0) cs->step_index = 0;

        if (cs->step_index > 88) cs->step_index = 88;



        VAR_7= (VAR_5 - (VAR_13 - VAR_4))>>VAR_14;

        for(VAR_9=0; VAR_9<VAR_7; VAR_9++) {

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[VAR_9] & 0x0F, 4);

            if (VAR_14)

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1], VAR_13[VAR_9+VAR_7] & 0x0F, 4);

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[VAR_9] >> 4, 4);

            if (VAR_14)

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1], VAR_13[VAR_9+VAR_7] >> 4, 4);

        }



        VAR_13 += VAR_7<<VAR_14;



        break;

    case CODEC_ID_ADPCM_MS:

        if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)

            VAR_5 = VAR_0->block_align;

        VAR_6 = VAR_5 - 7 * VAR_0->channels;

        if (VAR_6 < 0)

            return -1;

        VAR_10[0] = av_clip(*VAR_13++, 0, 6);

        VAR_10[1] = 0;

        if (VAR_14)

            VAR_10[1] = av_clip(*VAR_13++, 0, 6);

        c->status[0].idelta = (int16_t)bytestream_get_le16(&VAR_13);

        if (VAR_14){

            c->status[1].idelta = (int16_t)bytestream_get_le16(&VAR_13);

        }

        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[VAR_10[0]];

        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[VAR_10[0]];

        c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[VAR_10[1]];

        c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[VAR_10[1]];



        c->status[0].sample1 = bytestream_get_le16(&VAR_13);

        if (VAR_14) c->status[1].sample1 = bytestream_get_le16(&VAR_13);

        c->status[0].sample2 = bytestream_get_le16(&VAR_13);

        if (VAR_14) c->status[1].sample2 = bytestream_get_le16(&VAR_13);



        *VAR_11++ = c->status[0].sample2;

        if (VAR_14) *VAR_11++ = c->status[1].sample2;

        *VAR_11++ = c->status[0].sample1;

        if (VAR_14) *VAR_11++ = c->status[1].sample1;

        for(;VAR_6>0;VAR_6--) {

            *VAR_11++ = adpcm_ms_expand_nibble(&c->status[0 ], VAR_13[0] >> 4  );

            *VAR_11++ = adpcm_ms_expand_nibble(&c->status[VAR_14], VAR_13[0] & 0x0F);

            VAR_13 ++;

        }

        break;

    case CODEC_ID_ADPCM_IMA_DK4:

        if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)

            VAR_5 = VAR_0->block_align;



        c->status[0].predictor  = (int16_t)bytestream_get_le16(&VAR_13);

        c->status[0].step_index = *VAR_13++;

        VAR_13++;

        *VAR_11++ = c->status[0].predictor;

        if (VAR_14) {

            c->status[1].predictor  = (int16_t)bytestream_get_le16(&VAR_13);

            c->status[1].step_index = *VAR_13++;

            VAR_13++;

            *VAR_11++ = c->status[1].predictor;

        }

        while (VAR_13 < VAR_4 + VAR_5) {



            

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                VAR_13[0] >> 4, 3);



            



            if (VAR_14)

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],

                    VAR_13[0] & 0x0F, 3);

            else

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] & 0x0F, 3);



            VAR_13++;

        }

        break;

    case CODEC_ID_ADPCM_IMA_DK3:

        if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)

            VAR_5 = VAR_0->block_align;



        if(VAR_5 + 16 > (VAR_12 - VAR_11)*3/8)

            return -1;



        c->status[0].predictor  = (int16_t)AV_RL16(VAR_13 + 10);

        c->status[1].predictor  = (int16_t)AV_RL16(VAR_13 + 12);

        c->status[0].step_index = VAR_13[14];

        c->status[1].step_index = VAR_13[15];

        

        VAR_13 += 16;

        VAR_18 = c->status[1].predictor;



        



        while (1) {



            





            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[0], VAR_16, 3);



            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[1], VAR_16, 3);



            

            VAR_18 = (VAR_18 + c->status[1].predictor) / 2;

            *VAR_11++ = c->status[0].predictor + c->status[1].predictor;

            *VAR_11++ = c->status[0].predictor - c->status[1].predictor;



            

            DK3_GET_NEXT_NIBBLE();

            adpcm_ima_expand_nibble(&c->status[0], VAR_16, 3);



            

            VAR_18 = (VAR_18 + c->status[1].predictor) / 2;

            *VAR_11++ = c->status[0].predictor + c->status[1].predictor;

            *VAR_11++ = c->status[0].predictor - c->status[1].predictor;

        }

        break;

    case CODEC_ID_ADPCM_IMA_ISS:

        c->status[0].predictor  = (int16_t)AV_RL16(VAR_13 + 0);

        c->status[0].step_index = VAR_13[2];

        VAR_13 += 4;

        if(VAR_14) {

            c->status[1].predictor  = (int16_t)AV_RL16(VAR_13 + 0);

            c->status[1].step_index = VAR_13[2];

            VAR_13 += 4;

        }



        while (VAR_13 < VAR_4 + VAR_5) {



            if (VAR_14) {

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4  , 3);

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],

                    VAR_13[0] & 0x0F, 3);

            } else {

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] & 0x0F, 3);

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4  , 3);

            }



            VAR_13++;

        }

        break;

    case CODEC_ID_ADPCM_IMA_WS:

        

        while (VAR_13 < VAR_4 + VAR_5) {



            if (VAR_14) {

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4  , 3);

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],

                    VAR_13[0] & 0x0F, 3);

            } else {

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4  , 3);

                *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                    VAR_13[0] & 0x0F, 3);

            }



            VAR_13++;

        }

        break;

    case CODEC_ID_ADPCM_XA:

        while (VAR_5 >= 128) {

            xa_decode(VAR_11, VAR_13, &c->status[0], &c->status[1],

                VAR_0->channels);

            VAR_13 += 128;

            VAR_11 += 28 * 8;

            VAR_5 -= 128;

        }

        break;

    case CODEC_ID_ADPCM_IMA_EA_EACS:

        samples_in_chunk = bytestream_get_le32(&VAR_13) >> (1-VAR_14);



        if (samples_in_chunk > VAR_5-4-(8<<VAR_14)) {

            VAR_13 += VAR_5 - 4;

            break;

        }



        for (VAR_9=0; VAR_9<=VAR_14; VAR_9++)

            c->status[VAR_9].step_index = bytestream_get_le32(&VAR_13);

        for (VAR_9=0; VAR_9<=VAR_14; VAR_9++)

            c->status[VAR_9].predictor  = bytestream_get_le32(&VAR_13);



        for (; samples_in_chunk; samples_in_chunk--, VAR_13++) {

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],  *VAR_13>>4,   3);

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_14], *VAR_13&0x0F, 3);

        }

        break;

    case CODEC_ID_ADPCM_IMA_EA_SEAD:

        for (; VAR_13 < VAR_4+VAR_5; VAR_13++) {

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[0] >> 4, 6);

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_14],VAR_13[0]&0x0F, 6);

        }

        break;

    case CODEC_ID_ADPCM_EA:

        



        if (VAR_5 < 12) {

            av_log(VAR_0, AV_LOG_ERROR, "frame too small\VAR_6");

            return AVERROR(EINVAL);

        }

        samples_in_chunk = AV_RL32(VAR_13);

        if (samples_in_chunk / 28 > (VAR_5 - 12) / 30) {

            av_log(VAR_0, AV_LOG_ERROR, "invalid frame\VAR_6");

            return AVERROR(EINVAL);

        }

        VAR_13 += 4;

        current_left_sample   = (int16_t)bytestream_get_le16(&VAR_13);

        previous_left_sample  = (int16_t)bytestream_get_le16(&VAR_13);

        current_right_sample  = (int16_t)bytestream_get_le16(&VAR_13);

        previous_right_sample = (int16_t)bytestream_get_le16(&VAR_13);



        for (VAR_19 = 0; VAR_19 < samples_in_chunk/28;VAR_19++) {

            coeff1l = ea_adpcm_table[ *VAR_13 >> 4       ];

            coeff2l = ea_adpcm_table[(*VAR_13 >> 4  ) + 4];

            coeff1r = ea_adpcm_table[*VAR_13 & 0x0F];

            coeff2r = ea_adpcm_table[(*VAR_13 & 0x0F) + 4];

            VAR_13++;



            shift_left  = (*VAR_13 >> 4  ) + 8;

            shift_right = (*VAR_13 & 0x0F) + 8;

            VAR_13++;



            for (VAR_20 = 0; VAR_20 < 28; VAR_20++) {

                next_left_sample  = (int32_t)((*VAR_13 & 0xF0) << 24) >> shift_left;

                next_right_sample = (int32_t)((*VAR_13 & 0x0F) << 28) >> shift_right;

                VAR_13++;



                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);

                *VAR_11++ = (unsigned short)current_left_sample;

                *VAR_11++ = (unsigned short)current_right_sample;

            }

        }



        if (VAR_13 - VAR_4 == VAR_5 - 2)

            VAR_13 += 2;  Skip terminating 0x0000



        break;

    case CODEC_ID_ADPCM_EA_MAXIS_XA:

        for(VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) {

            for (VAR_9=0; VAR_9<2; VAR_9++)

                VAR_21[VAR_24][VAR_9] = ea_adpcm_table[(*VAR_13 >> 4) + 4*VAR_9];

            VAR_22[VAR_24] = (*VAR_13 & 0x0F) + 8;

            VAR_13++;

        }

        for (VAR_19 = 0; VAR_19 < (VAR_5 - VAR_0->channels) / VAR_0->channels; VAR_19++) {

            for(VAR_9 = 4; VAR_9 >= 0; VAR_9-=4) { 

                for(VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) {

                    int32_t sample = (int32_t)(((*(VAR_13+VAR_24) >> VAR_9) & 0x0F) << 0x1C) >> VAR_22[VAR_24];

                    sample = (sample +

                             c->status[VAR_24].sample1 * VAR_21[VAR_24][0] +

                             c->status[VAR_24].sample2 * VAR_21[VAR_24][1] + 0x80) >> 8;

                    c->status[VAR_24].sample2 = c->status[VAR_24].sample1;

                    c->status[VAR_24].sample1 = av_clip_int16(sample);

                    *VAR_11++ = c->status[VAR_24].sample1;

                }

            }

            VAR_13+=VAR_0->channels;

        }

        break;

    case CODEC_ID_ADPCM_EA_R1:

    case CODEC_ID_ADPCM_EA_R2:

    case CODEC_ID_ADPCM_EA_R3: {

        







        const int VAR_23 = VAR_0->codec->id == CODEC_ID_ADPCM_EA_R3;

        int32_t previous_sample, current_sample, next_sample;

        int32_t coeff1, coeff2;

        uint8_t VAR_22;

        unsigned int VAR_24;

        uint16_t *samplesC;

        const uint8_t *VAR_24;

        const uint8_t *VAR_25 = VAR_4 + VAR_5;



        samples_in_chunk = (VAR_23 ? bytestream_get_be32(&VAR_13)

                                       : bytestream_get_le32(&VAR_13)) / 28;

        if (samples_in_chunk > UINT32_MAX/(28*VAR_0->channels) ||

            28*samples_in_chunk*VAR_0->channels > VAR_12-VAR_11) {

            VAR_13 += VAR_5 - 4;

            break;

        }



        for (VAR_24=0; VAR_24<VAR_0->channels; VAR_24++) {

            int32_t offset = (VAR_23 ? bytestream_get_be32(&VAR_13)

                                         : bytestream_get_le32(&VAR_13))

                           + (VAR_0->channels-VAR_24-1) * 4;



            if ((offset < 0) || (offset >= VAR_25 - VAR_13 - 4)) break;

            VAR_24  = VAR_13 + offset;

            samplesC = VAR_11 + VAR_24;



            if (VAR_0->codec->id == CODEC_ID_ADPCM_EA_R1) {

                current_sample  = (int16_t)bytestream_get_le16(&VAR_24);

                previous_sample = (int16_t)bytestream_get_le16(&VAR_24);

            } else {

                current_sample  = c->status[VAR_24].predictor;

                previous_sample = c->status[VAR_24].prev_sample;

            }



            for (VAR_19=0; VAR_19<samples_in_chunk; VAR_19++) {

                if (*VAR_24 == 0xEE) {  

                    VAR_24++;

                    if (VAR_24 > VAR_25 - 30*2) break;

                    current_sample  = (int16_t)bytestream_get_be16(&VAR_24);

                    previous_sample = (int16_t)bytestream_get_be16(&VAR_24);



                    for (VAR_20=0; VAR_20<28; VAR_20++) {

                        *samplesC = (int16_t)bytestream_get_be16(&VAR_24);

                        samplesC += VAR_0->channels;

                    }

                } else {

                    coeff1 = ea_adpcm_table[ *VAR_24>>4     ];

                    coeff2 = ea_adpcm_table[(*VAR_24>>4) + 4];

                    VAR_22 = (*VAR_24++ & 0x0F) + 8;



                    if (VAR_24 > VAR_25 - 14) break;

                    for (VAR_20=0; VAR_20<28; VAR_20++) {

                        if (VAR_20 & 1)

                            next_sample = (int32_t)((*VAR_24++ & 0x0F) << 28) >> VAR_22;

                        else

                            next_sample = (int32_t)((*VAR_24   & 0xF0) << 24) >> VAR_22;



                        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 += VAR_0->channels;

                    }

                }

            }



            if (VAR_0->codec->id != CODEC_ID_ADPCM_EA_R1) {

                c->status[VAR_24].predictor   = current_sample;

                c->status[VAR_24].prev_sample = previous_sample;

            }

        }



        VAR_13 = VAR_13 + VAR_5 - (4 + 4*VAR_0->channels);

        VAR_11 += 28 * samples_in_chunk * VAR_0->channels;

        break;

    }

    case CODEC_ID_ADPCM_EA_XAS:

        if (VAR_12-VAR_11 < 32*4*VAR_0->channels

            || VAR_5 < (4+15)*4*VAR_0->channels) {

            VAR_13 += VAR_5;

            break;

        }

        for (VAR_24=0; VAR_24<VAR_0->channels; VAR_24++) {

            int VAR_21[2][4], VAR_22[4];

            short *s2, *s = &VAR_11[VAR_24];

            for (VAR_6=0; VAR_6<4; VAR_6++, s+=32*VAR_0->channels) {

                for (VAR_9=0; VAR_9<2; VAR_9++)

                    VAR_21[VAR_9][VAR_6] = ea_adpcm_table[(VAR_13[0]&0x0F)+4*VAR_9];

                VAR_22[VAR_6] = (VAR_13[2]&0x0F) + 8;

                for (s2=s, VAR_9=0; VAR_9<2; VAR_9++, VAR_13+=2, s2+=VAR_0->channels)

                    s2[0] = (VAR_13[0]&0xF0) + (VAR_13[1]<<8);

            }



            for (VAR_7=2; VAR_7<32; VAR_7+=2) {

                s = &VAR_11[VAR_7*VAR_0->channels + VAR_24];

                for (VAR_6=0; VAR_6<4; VAR_6++, VAR_13++, s+=32*VAR_0->channels) {

                    for (s2=s, VAR_9=0; VAR_9<8; VAR_9+=4, s2+=VAR_0->channels) {

                        int level = (int32_t)((*VAR_13 & (0xF0>>VAR_9)) << (24+VAR_9)) >> VAR_22[VAR_6];

                        int pred  = s2[-1*VAR_0->channels] * VAR_21[0][VAR_6]

                                  + s2[-2*VAR_0->channels] * VAR_21[1][VAR_6];

                        s2[0] = av_clip_int16((level + pred + 0x80) >> 8);

                    }

                }

            }

        }

        VAR_11 += 32*4*VAR_0->channels;

        break;

    case CODEC_ID_ADPCM_IMA_AMV:

    case CODEC_ID_ADPCM_IMA_SMJPEG:

        c->status[0].predictor = (int16_t)bytestream_get_le16(&VAR_13);

        c->status[0].step_index = bytestream_get_le16(&VAR_13);



        if (VAR_0->codec->id == CODEC_ID_ADPCM_IMA_AMV)

            VAR_13+=4;



        while (VAR_13 < VAR_4 + VAR_5) {

            char VAR_26, VAR_27;

            VAR_27 = *VAR_13 & 0x0F;

            VAR_26 = *VAR_13 >> 4;



            if (VAR_0->codec->id == CODEC_ID_ADPCM_IMA_AMV)

                FFSWAP(char, VAR_26, VAR_27);



            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                VAR_27, 3);

            *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],

                VAR_26, 3);

            VAR_13++;

        }

        break;

    case CODEC_ID_ADPCM_CT:

        while (VAR_13 < VAR_4 + VAR_5) {

            if (VAR_14) {

                *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4);

                *VAR_11++ = adpcm_ct_expand_nibble(&c->status[1],

                    VAR_13[0] & 0x0F);

            } else {

                *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4);

                *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],

                    VAR_13[0] & 0x0F);

            }

            VAR_13++;

        }

        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) {

            

            *VAR_11++ = 128 * (*VAR_13++ - 0x80);

            if (VAR_14)

              *VAR_11++ = 128 * (*VAR_13++ - 0x80);

            c->status[0].step_index = 1;

        }

        if (VAR_0->codec->id == CODEC_ID_ADPCM_SBPRO_4) {

            while (VAR_13 < VAR_4 + VAR_5) {

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                    VAR_13[0] >> 4, 4, 0);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],

                    VAR_13[0] & 0x0F, 4, 0);

                VAR_13++;

            }

        } else if (VAR_0->codec->id == CODEC_ID_ADPCM_SBPRO_3) {

            while (VAR_13 < VAR_4 + VAR_5 && VAR_11 + 2 < VAR_12) {

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                     VAR_13[0] >> 5        , 3, 0);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                    (VAR_13[0] >> 2) & 0x07, 3, 0);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                    VAR_13[0] & 0x03, 2, 0);

                VAR_13++;

            }

        } else {

            while (VAR_13 < VAR_4 + VAR_5 && VAR_11 + 3 < VAR_12) {

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                     VAR_13[0] >> 6        , 2, 2);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],

                    (VAR_13[0] >> 4) & 0x03, 2, 2);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],

                    (VAR_13[0] >> 2) & 0x03, 2, 2);

                *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],

                    VAR_13[0] & 0x03, 2, 2);

                VAR_13++;

            }

        }

        break;

    case CODEC_ID_ADPCM_SWF:

    {

        GetBitContext gb;

        const int *VAR_34;

        int VAR_29, VAR_30, VAR_31, VAR_32;

        int VAR_33 = VAR_5*8;



        init_get_bits(&gb, VAR_4, VAR_33);



        read bits & initial values

        VAR_31 = get_bits(&gb, 2)+2;

        av_log(NULL,AV_LOG_INFO,"VAR_31: %d\VAR_6", VAR_31);

        VAR_34 = swf_index_tables[VAR_31-2];

        VAR_29 = 1 << (VAR_31-2);

        VAR_30 = 1 << (VAR_31-1);



        while (get_bits_count(&gb) <= VAR_33 - 22*VAR_0->channels) {

            for (VAR_9 = 0; VAR_9 < VAR_0->channels; VAR_9++) {

                *VAR_11++ = c->status[VAR_9].predictor = get_sbits(&gb, 16);

                c->status[VAR_9].step_index = get_bits(&gb, 6);

            }



            for (VAR_32 = 0; get_bits_count(&gb) <= VAR_33 - VAR_31*VAR_0->channels && VAR_32 < 4095; VAR_32++) {

                int VAR_9;



                for (VAR_9 = 0; VAR_9 < VAR_0->channels; VAR_9++) {

                     similar to IMA adpcm

                    int delta = get_bits(&gb, VAR_31);

                    int step = ff_adpcm_step_table[c->status[VAR_9].step_index];

                    long vpdiff = 0;  vpdiff = (delta+0.5)*step/4

                    int k = VAR_29;



                    do {

                        if (delta & k)

                            vpdiff += step;

                        step >>= 1;

                        k >>= 1;

                    } while(k);

                    vpdiff += step;



                    if (delta & VAR_30)

                        c->status[VAR_9].predictor -= vpdiff;

                    else

                        c->status[VAR_9].predictor += vpdiff;



                    c->status[VAR_9].step_index += VAR_34[delta & (~VAR_30)];



                    c->status[VAR_9].step_index = av_clip(c->status[VAR_9].step_index, 0, 88);

                    c->status[VAR_9].predictor = av_clip_int16(c->status[VAR_9].predictor);



                    *VAR_11++ = c->status[VAR_9].predictor;

                    if (VAR_11 >= VAR_12) {

                        av_log(VAR_0, AV_LOG_ERROR, "allocated output buffer is too small\VAR_6");

                        return -1;

                    }

                }

            }

        }

        VAR_13 += VAR_5;

        break;

    }

    case CODEC_ID_ADPCM_YAMAHA:

        while (VAR_13 < VAR_4 + VAR_5) {

            if (VAR_14) {

                *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        VAR_13[0] & 0x0F);

                *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[1],

                        VAR_13[0] >> 4  );

            } else {

                *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        VAR_13[0] & 0x0F);

                *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],

                        VAR_13[0] >> 4  );

            }

            VAR_13++;

        }

        break;

    case CODEC_ID_ADPCM_THP:

    {

        int VAR_34[2][16];

        unsigned int VAR_34;

        int VAR_35[2][2];

        int VAR_36;



        if (VAR_5 < 80) {

            av_log(VAR_0, AV_LOG_ERROR, "frame too small\VAR_6");

            return -1;

        }



        VAR_13+=4;

        VAR_34 = bytestream_get_be32(&VAR_13);



        for (VAR_9 = 0; VAR_9 < 32; VAR_9++)

            VAR_34[0][VAR_9] = (int16_t)bytestream_get_be16(&VAR_13);



        

        for (VAR_9 = 0; VAR_9 < 4; VAR_9++)

            VAR_35[0][VAR_9] = (int16_t)bytestream_get_be16(&VAR_13);



        if (VAR_34 >= (VAR_12 - VAR_11) /  (VAR_14 + 1)) {

            av_log(VAR_0, AV_LOG_ERROR, "allocated output buffer is too small\VAR_6");

            return -1;

        }



        for (VAR_36 = 0; VAR_36 <= VAR_14; VAR_36++) {

            VAR_11 = (unsigned short *) VAR_1 + VAR_36;



            

            for (VAR_9 = 0; VAR_9 < VAR_34 / 14; VAR_9++) {

                int VAR_37 = (*VAR_13 >> 4) & 7;

                unsigned int VAR_38 = 28 - (*VAR_13++ & 15);

                int VAR_39 = VAR_34[VAR_36][VAR_37 * 2];

                int VAR_40 = VAR_34[VAR_36][VAR_37 * 2 + 1];



                

                for (VAR_6 = 0; VAR_6 < 14; VAR_6++) {

                    int32_t sampledat;

                    if(VAR_6&1) sampledat=  *VAR_13++    <<28;

                    else    sampledat= (*VAR_13&0xF0)<<24;



                    sampledat = ((VAR_35[VAR_36][0]*VAR_39

                                + VAR_35[VAR_36][1]*VAR_40) >> 11) + (sampledat>>VAR_38);

                    *VAR_11 = av_clip_int16(sampledat);

                    VAR_35[VAR_36][1] = VAR_35[VAR_36][0];

                    VAR_35[VAR_36][0] = *VAR_11++;



                    



                    VAR_11 += VAR_14;

                }

            }

        }



        



        VAR_11 -= VAR_14;

        break;

    }



    default:

        return -1;

    }

    *VAR_2 = (uint8_t *)VAR_11 - (uint8_t *)VAR_1;

    return VAR_13 - VAR_4;

}

static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{ const uint8_t *VAR_4 = VAR_3->VAR_1; int VAR_5 = VAR_3->VAR_33; ADPCMDecodeContext *c = VAR_0->priv_data; ADPCMChannelStatus *cs; int VAR_6, VAR_7, VAR_24, VAR_9; int VAR_10[2]; short *VAR_11; short *VAR_12; const uint8_t *VAR_13; int VAR_14; unsigned char VAR_15 = 0; unsigned char VAR_16; int VAR_17 = 0; int VAR_18; 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 VAR_19, VAR_20; int VAR_21[2][2], VAR_22[2]; if (!VAR_5)
return 0; if(*VAR_2/4 < VAR_5 + 8)
return -1; VAR_11 = VAR_1; VAR_12= VAR_11 + *VAR_2/2; *VAR_2= 0; VAR_13 = VAR_4; VAR_14 = VAR_0->channels == 2 ? 1 : 0; switch(VAR_0->codec->id) { case CODEC_ID_ADPCM_IMA_QT:
VAR_6 = VAR_5 - 2*VAR_0->channels; for (VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) { int16_t predictor; int step_index; cs = &(c->status[VAR_24]); predictor = AV_RB16(VAR_13); step_index = predictor & 0x7F; predictor &= 0xFF80; VAR_13 += 2; if (cs->step_index == step_index) { int diff = (int)predictor - cs->predictor; if (diff < 0)
diff = - diff; if (diff > 0x7f)
goto update; } else { update:
cs->step_index = step_index; cs->predictor = predictor; } if (cs->step_index > 88){ av_log(VAR_0, AV_LOG_ERROR, "ERROR: step_index = %VAR_9\VAR_6", cs->step_index); cs->step_index = 88; } VAR_11 = (short*)VAR_1 + VAR_24; for(VAR_7=32; VAR_6>0 && VAR_7>0; VAR_6--, VAR_7--) { *VAR_11 = adpcm_ima_qt_expand_nibble(cs, VAR_13[0] & 0x0F, 3); VAR_11 += VAR_0->channels; *VAR_11 = adpcm_ima_qt_expand_nibble(cs, VAR_13[0] >> 4  , 3); VAR_11 += VAR_0->channels; VAR_13 ++; } } if (VAR_14)
VAR_11--; break; case CODEC_ID_ADPCM_IMA_WAV:
if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)
VAR_5 = VAR_0->block_align; samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1; for(VAR_9=0; VAR_9<VAR_0->channels; VAR_9++){ cs = &(c->status[VAR_9]); cs->predictor = *VAR_11++ = (int16_t)bytestream_get_le16(&VAR_13); cs->step_index = *VAR_13++; if (cs->step_index > 88){ av_log(VAR_0, AV_LOG_ERROR, "ERROR: step_index = %VAR_9\VAR_6", cs->step_index); cs->step_index = 88; } if (*VAR_13++) av_log(VAR_0, AV_LOG_ERROR, "unused byte should be null but is %d!!\VAR_6", VAR_13[-1]); } while(VAR_13 < VAR_4 + VAR_5){ for(VAR_7=0; VAR_7<4; VAR_7++){ for(VAR_9=0; VAR_9<=VAR_14; VAR_9++) *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_9], VAR_13[4*VAR_9] & 0x0F, 3); for(VAR_9=0; VAR_9<=VAR_14; VAR_9++) *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_9], VAR_13[4*VAR_9] >> 4  , 3); VAR_13++; } VAR_13 += 4*VAR_14; } break; case CODEC_ID_ADPCM_4XM:
cs = &(c->status[0]); c->status[0].predictor= (int16_t)bytestream_get_le16(&VAR_13); if(VAR_14){ c->status[1].predictor= (int16_t)bytestream_get_le16(&VAR_13); } c->status[0].step_index= (int16_t)bytestream_get_le16(&VAR_13); if(VAR_14){ c->status[1].step_index= (int16_t)bytestream_get_le16(&VAR_13); } if (cs->step_index < 0) cs->step_index = 0; if (cs->step_index > 88) cs->step_index = 88; VAR_7= (VAR_5 - (VAR_13 - VAR_4))>>VAR_14; for(VAR_9=0; VAR_9<VAR_7; VAR_9++) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[VAR_9] & 0x0F, 4); if (VAR_14)
*VAR_11++ = adpcm_ima_expand_nibble(&c->status[1], VAR_13[VAR_9+VAR_7] & 0x0F, 4); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[VAR_9] >> 4, 4); if (VAR_14)
*VAR_11++ = adpcm_ima_expand_nibble(&c->status[1], VAR_13[VAR_9+VAR_7] >> 4, 4); } VAR_13 += VAR_7<<VAR_14; break; case CODEC_ID_ADPCM_MS:
if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)
VAR_5 = VAR_0->block_align; VAR_6 = VAR_5 - 7 * VAR_0->channels; if (VAR_6 < 0)
return -1; VAR_10[0] = av_clip(*VAR_13++, 0, 6); VAR_10[1] = 0; if (VAR_14)
VAR_10[1] = av_clip(*VAR_13++, 0, 6); c->status[0].idelta = (int16_t)bytestream_get_le16(&VAR_13); if (VAR_14){ c->status[1].idelta = (int16_t)bytestream_get_le16(&VAR_13); } c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[VAR_10[0]]; c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[VAR_10[0]]; c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[VAR_10[1]]; c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[VAR_10[1]]; c->status[0].sample1 = bytestream_get_le16(&VAR_13); if (VAR_14) c->status[1].sample1 = bytestream_get_le16(&VAR_13); c->status[0].sample2 = bytestream_get_le16(&VAR_13); if (VAR_14) c->status[1].sample2 = bytestream_get_le16(&VAR_13); *VAR_11++ = c->status[0].sample2; if (VAR_14) *VAR_11++ = c->status[1].sample2; *VAR_11++ = c->status[0].sample1; if (VAR_14) *VAR_11++ = c->status[1].sample1; for(;VAR_6>0;VAR_6--) { *VAR_11++ = adpcm_ms_expand_nibble(&c->status[0 ], VAR_13[0] >> 4  ); *VAR_11++ = adpcm_ms_expand_nibble(&c->status[VAR_14], VAR_13[0] & 0x0F); VAR_13 ++; } break; case CODEC_ID_ADPCM_IMA_DK4:
if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)
VAR_5 = VAR_0->block_align; c->status[0].predictor  = (int16_t)bytestream_get_le16(&VAR_13); c->status[0].step_index = *VAR_13++; VAR_13++; *VAR_11++ = c->status[0].predictor; if (VAR_14) { c->status[1].predictor  = (int16_t)bytestream_get_le16(&VAR_13); c->status[1].step_index = *VAR_13++; VAR_13++; *VAR_11++ = c->status[1].predictor; } while (VAR_13 < VAR_4 + VAR_5) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] >> 4, 3); if (VAR_14)
*VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],
VAR_13[0] & 0x0F, 3); else
*VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F, 3); VAR_13++; } break; case CODEC_ID_ADPCM_IMA_DK3:
if (VAR_0->block_align != 0 && VAR_5 > VAR_0->block_align)
VAR_5 = VAR_0->block_align; if(VAR_5 + 16 > (VAR_12 - VAR_11)*3/8)
return -1; c->status[0].predictor  = (int16_t)AV_RL16(VAR_13 + 10); c->status[1].predictor  = (int16_t)AV_RL16(VAR_13 + 12); c->status[0].step_index = VAR_13[14]; c->status[1].step_index = VAR_13[15]; VAR_13 += 16; VAR_18 = c->status[1].predictor; while (1) { DK3_GET_NEXT_NIBBLE(); adpcm_ima_expand_nibble(&c->status[0], VAR_16, 3); DK3_GET_NEXT_NIBBLE(); adpcm_ima_expand_nibble(&c->status[1], VAR_16, 3); VAR_18 = (VAR_18 + c->status[1].predictor) / 2; *VAR_11++ = c->status[0].predictor + c->status[1].predictor; *VAR_11++ = c->status[0].predictor - c->status[1].predictor; DK3_GET_NEXT_NIBBLE(); adpcm_ima_expand_nibble(&c->status[0], VAR_16, 3); VAR_18 = (VAR_18 + c->status[1].predictor) / 2; *VAR_11++ = c->status[0].predictor + c->status[1].predictor; *VAR_11++ = c->status[0].predictor - c->status[1].predictor; } break; case CODEC_ID_ADPCM_IMA_ISS:
c->status[0].predictor  = (int16_t)AV_RL16(VAR_13 + 0); c->status[0].step_index = VAR_13[2]; VAR_13 += 4; if(VAR_14) { c->status[1].predictor  = (int16_t)AV_RL16(VAR_13 + 0); c->status[1].step_index = VAR_13[2]; VAR_13 += 4; } while (VAR_13 < VAR_4 + VAR_5) { if (VAR_14) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] >> 4  , 3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],
VAR_13[0] & 0x0F, 3); } else { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F, 3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] >> 4  , 3); } VAR_13++; } break; case CODEC_ID_ADPCM_IMA_WS:
while (VAR_13 < VAR_4 + VAR_5) { if (VAR_14) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] >> 4  , 3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[1],
VAR_13[0] & 0x0F, 3); } else { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] >> 4  , 3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F, 3); } VAR_13++; } break; case CODEC_ID_ADPCM_XA:
while (VAR_5 >= 128) { xa_decode(VAR_11, VAR_13, &c->status[0], &c->status[1],
VAR_0->channels); VAR_13 += 128; VAR_11 += 28 * 8; VAR_5 -= 128; } break; case CODEC_ID_ADPCM_IMA_EA_EACS:
samples_in_chunk = bytestream_get_le32(&VAR_13) >> (1-VAR_14); if (samples_in_chunk > VAR_5-4-(8<<VAR_14)) { VAR_13 += VAR_5 - 4; break; } for (VAR_9=0; VAR_9<=VAR_14; VAR_9++) c->status[VAR_9].step_index = bytestream_get_le32(&VAR_13); for (VAR_9=0; VAR_9<=VAR_14; VAR_9++) c->status[VAR_9].predictor  = bytestream_get_le32(&VAR_13); for (; samples_in_chunk; samples_in_chunk--, VAR_13++) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],  *VAR_13>>4,   3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_14], *VAR_13&0x0F, 3); } break; case CODEC_ID_ADPCM_IMA_EA_SEAD:
for (; VAR_13 < VAR_4+VAR_5; VAR_13++) { *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0], VAR_13[0] >> 4, 6); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[VAR_14],VAR_13[0]&0x0F, 6); } break; case CODEC_ID_ADPCM_EA:
if (VAR_5 < 12) { av_log(VAR_0, AV_LOG_ERROR, "frame too small\VAR_6"); return AVERROR(EINVAL); } samples_in_chunk = AV_RL32(VAR_13); if (samples_in_chunk / 28 > (VAR_5 - 12) / 30) { av_log(VAR_0, AV_LOG_ERROR, "invalid frame\VAR_6"); return AVERROR(EINVAL); } VAR_13 += 4; current_left_sample   = (int16_t)bytestream_get_le16(&VAR_13); previous_left_sample  = (int16_t)bytestream_get_le16(&VAR_13); current_right_sample  = (int16_t)bytestream_get_le16(&VAR_13); previous_right_sample = (int16_t)bytestream_get_le16(&VAR_13); for (VAR_19 = 0; VAR_19 < samples_in_chunk/28;VAR_19++) { coeff1l = ea_adpcm_table[ *VAR_13 >> 4       ]; coeff2l = ea_adpcm_table[(*VAR_13 >> 4  ) + 4]; coeff1r = ea_adpcm_table[*VAR_13 & 0x0F]; coeff2r = ea_adpcm_table[(*VAR_13 & 0x0F) + 4]; VAR_13++; shift_left  = (*VAR_13 >> 4  ) + 8; shift_right = (*VAR_13 & 0x0F) + 8; VAR_13++; for (VAR_20 = 0; VAR_20 < 28; VAR_20++) { next_left_sample  = (int32_t)((*VAR_13 & 0xF0) << 24) >> shift_left; next_right_sample = (int32_t)((*VAR_13 & 0x0F) << 28) >> shift_right; VAR_13++; 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); *VAR_11++ = (unsigned short)current_left_sample; *VAR_11++ = (unsigned short)current_right_sample; } } if (VAR_13 - VAR_4 == VAR_5 - 2)
VAR_13 += 2;  Skip terminating 0x0000 break; case CODEC_ID_ADPCM_EA_MAXIS_XA:
for(VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) { for (VAR_9=0; VAR_9<2; VAR_9++) VAR_21[VAR_24][VAR_9] = ea_adpcm_table[(*VAR_13 >> 4) + 4*VAR_9]; VAR_22[VAR_24] = (*VAR_13 & 0x0F) + 8; VAR_13++; } for (VAR_19 = 0; VAR_19 < (VAR_5 - VAR_0->channels) / VAR_0->channels; VAR_19++) { for(VAR_9 = 4; VAR_9 >= 0; VAR_9-=4) { for(VAR_24 = 0; VAR_24 < VAR_0->channels; VAR_24++) { int32_t sample = (int32_t)(((*(VAR_13+VAR_24) >> VAR_9) & 0x0F) << 0x1C) >> VAR_22[VAR_24]; sample = (sample +
c->status[VAR_24].sample1 * VAR_21[VAR_24][0] +
c->status[VAR_24].sample2 * VAR_21[VAR_24][1] + 0x80) >> 8; c->status[VAR_24].sample2 = c->status[VAR_24].sample1; c->status[VAR_24].sample1 = av_clip_int16(sample); *VAR_11++ = c->status[VAR_24].sample1; } } VAR_13+=VAR_0->channels; } break; case CODEC_ID_ADPCM_EA_R1:
case CODEC_ID_ADPCM_EA_R2:
case CODEC_ID_ADPCM_EA_R3: { const int VAR_23 = VAR_0->codec->id == CODEC_ID_ADPCM_EA_R3; int32_t previous_sample, current_sample, next_sample; int32_t coeff1, coeff2; uint8_t VAR_22; unsigned int VAR_24; uint16_t *samplesC; const uint8_t *VAR_24; const uint8_t *VAR_25 = VAR_4 + VAR_5; samples_in_chunk = (VAR_23 ? bytestream_get_be32(&VAR_13)
: bytestream_get_le32(&VAR_13)) / 28; if (samples_in_chunk > UINT32_MAX/(28*VAR_0->channels) ||
28*samples_in_chunk*VAR_0->channels > VAR_12-VAR_11) { VAR_13 += VAR_5 - 4; break; } for (VAR_24=0; VAR_24<VAR_0->channels; VAR_24++) { int32_t offset = (VAR_23 ? bytestream_get_be32(&VAR_13)
: bytestream_get_le32(&VAR_13))
+ (VAR_0->channels-VAR_24-1) * 4; if ((offset < 0) || (offset >= VAR_25 - VAR_13 - 4)) break; VAR_24  = VAR_13 + offset; samplesC = VAR_11 + VAR_24; if (VAR_0->codec->id == CODEC_ID_ADPCM_EA_R1) { current_sample  = (int16_t)bytestream_get_le16(&VAR_24); previous_sample = (int16_t)bytestream_get_le16(&VAR_24); } else { current_sample  = c->status[VAR_24].predictor; previous_sample = c->status[VAR_24].prev_sample; } for (VAR_19=0; VAR_19<samples_in_chunk; VAR_19++) { if (*VAR_24 == 0xEE) { VAR_24++; if (VAR_24 > VAR_25 - 30*2) break; current_sample  = (int16_t)bytestream_get_be16(&VAR_24); previous_sample = (int16_t)bytestream_get_be16(&VAR_24); for (VAR_20=0; VAR_20<28; VAR_20++) { *samplesC = (int16_t)bytestream_get_be16(&VAR_24); samplesC += VAR_0->channels; } } else { coeff1 = ea_adpcm_table[ *VAR_24>>4     ]; coeff2 = ea_adpcm_table[(*VAR_24>>4) + 4]; VAR_22 = (*VAR_24++ & 0x0F) + 8; if (VAR_24 > VAR_25 - 14) break; for (VAR_20=0; VAR_20<28; VAR_20++) { if (VAR_20 & 1)
next_sample = (int32_t)((*VAR_24++ & 0x0F) << 28) >> VAR_22; else
next_sample = (int32_t)((*VAR_24   & 0xF0) << 24) >> VAR_22; 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 += VAR_0->channels; } } } if (VAR_0->codec->id != CODEC_ID_ADPCM_EA_R1) { c->status[VAR_24].predictor   = current_sample; c->status[VAR_24].prev_sample = previous_sample; } } VAR_13 = VAR_13 + VAR_5 - (4 + 4*VAR_0->channels); VAR_11 += 28 * samples_in_chunk * VAR_0->channels; break; } case CODEC_ID_ADPCM_EA_XAS:
if (VAR_12-VAR_11 < 32*4*VAR_0->channels
|| VAR_5 < (4+15)*4*VAR_0->channels) { VAR_13 += VAR_5; break; } for (VAR_24=0; VAR_24<VAR_0->channels; VAR_24++) { int VAR_21[2][4], VAR_22[4]; short *s2, *s = &VAR_11[VAR_24]; for (VAR_6=0; VAR_6<4; VAR_6++, s+=32*VAR_0->channels) { for (VAR_9=0; VAR_9<2; VAR_9++) VAR_21[VAR_9][VAR_6] = ea_adpcm_table[(VAR_13[0]&0x0F)+4*VAR_9]; VAR_22[VAR_6] = (VAR_13[2]&0x0F) + 8; for (s2=s, VAR_9=0; VAR_9<2; VAR_9++, VAR_13+=2, s2+=VAR_0->channels) s2[0] = (VAR_13[0]&0xF0) + (VAR_13[1]<<8); } for (VAR_7=2; VAR_7<32; VAR_7+=2) { s = &VAR_11[VAR_7*VAR_0->channels + VAR_24]; for (VAR_6=0; VAR_6<4; VAR_6++, VAR_13++, s+=32*VAR_0->channels) { for (s2=s, VAR_9=0; VAR_9<8; VAR_9+=4, s2+=VAR_0->channels) { int level = (int32_t)((*VAR_13 & (0xF0>>VAR_9)) << (24+VAR_9)) >> VAR_22[VAR_6]; int pred  = s2[-1*VAR_0->channels] * VAR_21[0][VAR_6]
+ s2[-2*VAR_0->channels] * VAR_21[1][VAR_6]; s2[0] = av_clip_int16((level + pred + 0x80) >> 8); } } } } VAR_11 += 32*4*VAR_0->channels; break; case CODEC_ID_ADPCM_IMA_AMV:
case CODEC_ID_ADPCM_IMA_SMJPEG:
c->status[0].predictor = (int16_t)bytestream_get_le16(&VAR_13); c->status[0].step_index = bytestream_get_le16(&VAR_13); if (VAR_0->codec->id == CODEC_ID_ADPCM_IMA_AMV)
VAR_13+=4; while (VAR_13 < VAR_4 + VAR_5) { char VAR_26, VAR_27; VAR_27 = *VAR_13 & 0x0F; VAR_26 = *VAR_13 >> 4; if (VAR_0->codec->id == CODEC_ID_ADPCM_IMA_AMV)
FFSWAP(char, VAR_26, VAR_27); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_27, 3); *VAR_11++ = adpcm_ima_expand_nibble(&c->status[0],
VAR_26, 3); VAR_13++; } break; case CODEC_ID_ADPCM_CT:
while (VAR_13 < VAR_4 + VAR_5) { if (VAR_14) { *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],
VAR_13[0] >> 4); *VAR_11++ = adpcm_ct_expand_nibble(&c->status[1],
VAR_13[0] & 0x0F); } else { *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],
VAR_13[0] >> 4); *VAR_11++ = adpcm_ct_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F); } VAR_13++; } 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) { *VAR_11++ = 128 * (*VAR_13++ - 0x80); if (VAR_14)
*VAR_11++ = 128 * (*VAR_13++ - 0x80); c->status[0].step_index = 1; } if (VAR_0->codec->id == CODEC_ID_ADPCM_SBPRO_4) { while (VAR_13 < VAR_4 + VAR_5) { *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
VAR_13[0] >> 4, 4, 0); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],
VAR_13[0] & 0x0F, 4, 0); VAR_13++; } } else if (VAR_0->codec->id == CODEC_ID_ADPCM_SBPRO_3) { while (VAR_13 < VAR_4 + VAR_5 && VAR_11 + 2 < VAR_12) { *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
VAR_13[0] >> 5        , 3, 0); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
(VAR_13[0] >> 2) & 0x07, 3, 0); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
VAR_13[0] & 0x03, 2, 0); VAR_13++; } } else { while (VAR_13 < VAR_4 + VAR_5 && VAR_11 + 3 < VAR_12) { *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
VAR_13[0] >> 6        , 2, 2); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],
(VAR_13[0] >> 4) & 0x03, 2, 2); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[0],
(VAR_13[0] >> 2) & 0x03, 2, 2); *VAR_11++ = adpcm_sbpro_expand_nibble(&c->status[VAR_14],
VAR_13[0] & 0x03, 2, 2); VAR_13++; } } break; case CODEC_ID_ADPCM_SWF:
{ GetBitContext gb; const int *VAR_34; int VAR_29, VAR_30, VAR_31, VAR_32; int VAR_33 = VAR_5*8; init_get_bits(&gb, VAR_4, VAR_33); read bits & initial values
VAR_31 = get_bits(&gb, 2)+2; av_log(NULL,AV_LOG_INFO,"VAR_31: %d\VAR_6", VAR_31); VAR_34 = swf_index_tables[VAR_31-2]; VAR_29 = 1 << (VAR_31-2); VAR_30 = 1 << (VAR_31-1); while (get_bits_count(&gb) <= VAR_33 - 22*VAR_0->channels) { for (VAR_9 = 0; VAR_9 < VAR_0->channels; VAR_9++) { *VAR_11++ = c->status[VAR_9].predictor = get_sbits(&gb, 16); c->status[VAR_9].step_index = get_bits(&gb, 6); } for (VAR_32 = 0; get_bits_count(&gb) <= VAR_33 - VAR_31*VAR_0->channels && VAR_32 < 4095; VAR_32++) { int VAR_9; for (VAR_9 = 0; VAR_9 < VAR_0->channels; VAR_9++) { similar to IMA adpcm
int delta = get_bits(&gb, VAR_31); int step = ff_adpcm_step_table[c->status[VAR_9].step_index]; long vpdiff = 0;  vpdiff = (delta+0.5)*step/4 int k = VAR_29; do { if (delta & k)
vpdiff += step; step >>= 1; k >>= 1; } while(k); vpdiff += step; if (delta & VAR_30)
c->status[VAR_9].predictor -= vpdiff; else
c->status[VAR_9].predictor += vpdiff; c->status[VAR_9].step_index += VAR_34[delta & (~VAR_30)]; c->status[VAR_9].step_index = av_clip(c->status[VAR_9].step_index, 0, 88); c->status[VAR_9].predictor = av_clip_int16(c->status[VAR_9].predictor); *VAR_11++ = c->status[VAR_9].predictor; if (VAR_11 >= VAR_12) { av_log(VAR_0, AV_LOG_ERROR, "allocated output buffer is too small\VAR_6"); return -1; } } } } VAR_13 += VAR_5; break; } case CODEC_ID_ADPCM_YAMAHA:
while (VAR_13 < VAR_4 + VAR_5) { if (VAR_14) { *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F); *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[1],
VAR_13[0] >> 4  ); } else { *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],
VAR_13[0] & 0x0F); *VAR_11++ = adpcm_yamaha_expand_nibble(&c->status[0],
VAR_13[0] >> 4  ); } VAR_13++; } break; case CODEC_ID_ADPCM_THP:
{ int VAR_34[2][16]; unsigned int VAR_34; int VAR_35[2][2]; int VAR_36; if (VAR_5 < 80) { av_log(VAR_0, AV_LOG_ERROR, "frame too small\VAR_6"); return -1; } VAR_13+=4; VAR_34 = bytestream_get_be32(&VAR_13); for (VAR_9 = 0; VAR_9 < 32; VAR_9++) VAR_34[0][VAR_9] = (int16_t)bytestream_get_be16(&VAR_13); for (VAR_9 = 0; VAR_9 < 4; VAR_9++) VAR_35[0][VAR_9] = (int16_t)bytestream_get_be16(&VAR_13); if (VAR_34 >= (VAR_12 - VAR_11) /  (VAR_14 + 1)) { av_log(VAR_0, AV_LOG_ERROR, "allocated output buffer is too small\VAR_6"); return -1; } for (VAR_36 = 0; VAR_36 <= VAR_14; VAR_36++) { VAR_11 = (unsigned short *) VAR_1 + VAR_36; for (VAR_9 = 0; VAR_9 < VAR_34 / 14; VAR_9++) { int VAR_37 = (*VAR_13 >> 4) & 7; unsigned int VAR_38 = 28 - (*VAR_13++ & 15); int VAR_39 = VAR_34[VAR_36][VAR_37 * 2]; int VAR_40 = VAR_34[VAR_36][VAR_37 * 2 + 1]; for (VAR_6 = 0; VAR_6 < 14; VAR_6++) { int32_t sampledat; if(VAR_6&1) sampledat=  *VAR_13++    <<28; else    sampledat= (*VAR_13&0xF0)<<24; sampledat = ((VAR_35[VAR_36][0]*VAR_39
+ VAR_35[VAR_36][1]*VAR_40) >> 11) + (sampledat>>VAR_38); *VAR_11 = av_clip_int16(sampledat); VAR_35[VAR_36][1] = VAR_35[VAR_36][0]; VAR_35[VAR_36][0] = *VAR_11++; VAR_11 += VAR_14; } } } VAR_11 -= VAR_14; break; } default:
return -1; } *VAR_2 = (uint8_t *)VAR_11 - (uint8_t *)VAR_1; return VAR_13 - VAR_4; }