int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int *consumed, int src_size, int dst_size, int update_ctx){

    int dst_index, i;

    int index= c->index;

    int frac= c->frac;

    int dst_incr_frac= c->dst_incr % c->src_incr;

    int dst_incr=      c->dst_incr / c->src_incr;



    av_assert1(c->filter_shift == FILTER_SHIFT);

    av_assert1(c->felem_size == sizeof(FELEM));



    if (c->filter_length == 1 && c->phase_shift == 0) {

        int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index;

        int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;

        int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr;



        dst_size= FFMIN(dst_size, new_size);



        for(dst_index=0; dst_index < dst_size; dst_index++){

            dst[dst_index] = src[index2>>32];

            index2 += incr;

        }

        index += dst_index * dst_incr;

        index += (frac + dst_index * (int64_t)dst_incr_frac) / c->src_incr;

        frac   = (frac + dst_index * (int64_t)dst_incr_frac) % c->src_incr;

        av_assert2(index >= 0);

        *consumed= index;

        index = 0;

    } else if (index >= 0) {

        int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift;

        int64_t delta_frac = (end_index - index) * c->src_incr - c->frac;

        int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;

        int n = FFMIN(dst_size, delta_n);

        int sample_index;



        if (!c->linear) {

            sample_index = index >> c->phase_shift;

            index &= c->phase_mask;

            for (dst_index = 0; dst_index < n; dst_index++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;



#ifdef COMMON_CORE

                COMMON_CORE

#else

                FELEM2 val=0;

                for (i = 0; i < c->filter_length; i++) {

                    val += src[sample_index + i] * (FELEM2)filter[i];

                }

                OUT(dst[dst_index], val);

#endif



                frac += dst_incr_frac;

                index += dst_incr;

                if (frac >= c->src_incr) {

                    frac -= c->src_incr;

                    index++;

                }

                sample_index += index >> c->phase_shift;

                index &= c->phase_mask;

            }

        } else {

            sample_index = index >> c->phase_shift;

            index &= c->phase_mask;

            for (dst_index = 0; dst_index < n; dst_index++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;

                FELEM2 val=0, v2 = 0;



#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for (i = 0; i < c->filter_length; i++) {

                    val += src[sample_index + i] * (FELEM2)filter[i];

                    v2  += src[sample_index + i] * (FELEM2)filter[i + c->filter_alloc];

                }

#endif

                val += (v2 - val) * (FELEML) frac / c->src_incr;

                OUT(dst[dst_index], val);



                frac += dst_incr_frac;

                index += dst_incr;

                if (frac >= c->src_incr) {

                    frac -= c->src_incr;

                    index++;

                }

                sample_index += index >> c->phase_shift;

                index &= c->phase_mask;

            }

        }



        *consumed = sample_index;

    } else {

        int sample_index = 0;

        for(dst_index=0; dst_index < dst_size; dst_index++){

            FELEM *filter;

            FELEM2 val=0;



            sample_index += index >> c->phase_shift;

            index &= c->phase_mask;

            filter = ((FELEM*)c->filter_bank) + c->filter_alloc*index;



            if(sample_index + c->filter_length > src_size || -sample_index >= src_size){

                break;

            }else if(sample_index < 0){

                for(i=0; i<c->filter_length; i++)

                    val += src[FFABS(sample_index + i)] * (FELEM2)filter[i];

                OUT(dst[dst_index], val);

            }else if(c->linear){

                FELEM2 v2=0;

#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for(i=0; i<c->filter_length; i++){

                    val += src[sample_index + i] * (FELEM2)filter[i];

                    v2  += src[sample_index + i] * (FELEM2)filter[i + c->filter_alloc];

                }

#endif

                val+=(v2-val)*(FELEML)frac / c->src_incr;

                OUT(dst[dst_index], val);

            }else{

#ifdef COMMON_CORE

                COMMON_CORE

#else

                for(i=0; i<c->filter_length; i++){

                    val += src[sample_index + i] * (FELEM2)filter[i];

                }

                OUT(dst[dst_index], val);

#endif

            }



            frac += dst_incr_frac;

            index += dst_incr;

            if(frac >= c->src_incr){

                frac -= c->src_incr;

                index++;

            }

        }

        *consumed= FFMAX(sample_index, 0);

        index += FFMIN(sample_index, 0) << c->phase_shift;

    }



    if(update_ctx){

        c->frac= frac;

        c->index= index;

    }



    return dst_index;

}

int RENAME(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int *consumed, int src_size, int dst_size, int update_ctx){

    int dst_index, i;

    int index= c->index;

    int frac= c->frac;

    int dst_incr_frac= c->dst_incr % c->src_incr;

    int dst_incr=      c->dst_incr / c->src_incr;



    av_assert1(c->filter_shift == FILTER_SHIFT);

    av_assert1(c->felem_size == sizeof(FELEM));



    if (c->filter_length == 1 && c->phase_shift == 0) {

        int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index;

        int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;

        int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr;



        dst_size= FFMIN(dst_size, new_size);



        for(dst_index=0; dst_index < dst_size; dst_index++){

            dst[dst_index] = src[index2>>32];

            index2 += incr;

        }

        index += dst_index * dst_incr;

        index += (frac + dst_index * (int64_t)dst_incr_frac) / c->src_incr;

        frac   = (frac + dst_index * (int64_t)dst_incr_frac) % c->src_incr;

        av_assert2(index >= 0);

        *consumed= index;

        index = 0;

    } else if (index >= 0) {

        int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift;

        int64_t delta_frac = (end_index - index) * c->src_incr - c->frac;

        int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;

        int n = FFMIN(dst_size, delta_n);

        int sample_index;



        if (!c->linear) {

            sample_index = index >> c->phase_shift;

            index &= c->phase_mask;

            for (dst_index = 0; dst_index < n; dst_index++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;



#ifdef COMMON_CORE

                COMMON_CORE

#else

                FELEM2 val=0;

                for (i = 0; i < c->filter_length; i++) {

                    val += src[sample_index + i] * (FELEM2)filter[i];

                }

                OUT(dst[dst_index], val);

#endif



                frac += dst_incr_frac;

                index += dst_incr;

                if (frac >= c->src_incr) {

                    frac -= c->src_incr;

                    index++;

                }

                sample_index += index >> c->phase_shift;

                index &= c->phase_mask;

            }

        } else {

            sample_index = index >> c->phase_shift;

            index &= c->phase_mask;

            for (dst_index = 0; dst_index < n; dst_index++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;

                FELEM2 val=0, v2 = 0;



#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for (i = 0; i < c->filter_length; i++) {

                    val += src[sample_index + i] * (FELEM2)filter[i];

                    v2  += src[sample_index + i] * (FELEM2)filter[i + c->filter_alloc];

                }

#endif

                val += (v2 - val) * (FELEML) frac / c->src_incr;

                OUT(dst[dst_index], val);



                frac += dst_incr_frac;

                index += dst_incr;

                if (frac >= c->src_incr) {

                    frac -= c->src_incr;

                    index++;

                }

                sample_index += index >> c->phase_shift;

                index &= c->phase_mask;

            }

        }



        *consumed = sample_index;

    } else {

        int sample_index = 0;

        for(dst_index=0; dst_index < dst_size; dst_index++){

            FELEM *filter;

            FELEM2 val=0;



            sample_index += index >> c->phase_shift;

            index &= c->phase_mask;

            filter = ((FELEM*)c->filter_bank) + c->filter_alloc*index;



            if(sample_index + c->filter_length > src_size || -sample_index >= src_size){

                break;

            }else if(sample_index < 0){

                for(i=0; i<c->filter_length; i++)

                    val += src[FFABS(sample_index + i)] * (FELEM2)filter[i];

                OUT(dst[dst_index], val);

            }else if(c->linear){

                FELEM2 v2=0;

#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for(i=0; i<c->filter_length; i++){

                    val += src[sample_index + i] * (FELEM2)filter[i];

                    v2  += src[sample_index + i] * (FELEM2)filter[i + c->filter_alloc];

                }

#endif

                val+=(v2-val)*(FELEML)frac / c->src_incr;

                OUT(dst[dst_index], val);

            }else{

#ifdef COMMON_CORE

                COMMON_CORE

#else

                for(i=0; i<c->filter_length; i++){

                    val += src[sample_index + i] * (FELEM2)filter[i];

                }

                OUT(dst[dst_index], val);

#endif

            }



            frac += dst_incr_frac;

            index += dst_incr;

            if(frac >= c->src_incr){

                frac -= c->src_incr;

                index++;

            }

        }

        *consumed= FFMAX(sample_index, 0);

        index += FFMIN(sample_index, 0) << c->phase_shift;

    }



    if(update_ctx){

        c->frac= frac;

        c->index= index;

    }



    return dst_index;

}

int FUNC_0(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int *consumed, int src_size, int dst_size, int update_ctx){

    int VAR_0, VAR_1;

    int VAR_2= c->VAR_2;

    int VAR_3= c->VAR_3;

    int VAR_4= c->VAR_5 % c->src_incr;

    int VAR_5=      c->VAR_5 / c->src_incr;



    av_assert1(c->filter_shift == FILTER_SHIFT);

    av_assert1(c->felem_size == sizeof(FELEM));



    if (c->filter_length == 1 && c->phase_shift == 0) {

        int64_t index2= (1LL<<32)*c->VAR_3/c->src_incr + (1LL<<32)*VAR_2;

        int64_t incr= (1LL<<32) * c->VAR_5 / c->src_incr;

        int VAR_6 = (src_size * (int64_t)c->src_incr - VAR_3 + c->VAR_5 - 1) / c->VAR_5;



        dst_size= FFMIN(dst_size, VAR_6);



        for(VAR_0=0; VAR_0 < dst_size; VAR_0++){

            dst[VAR_0] = src[index2>>32];

            index2 += incr;

        }

        VAR_2 += VAR_0 * VAR_5;

        VAR_2 += (VAR_3 + VAR_0 * (int64_t)VAR_4) / c->src_incr;

        VAR_3   = (VAR_3 + VAR_0 * (int64_t)VAR_4) % c->src_incr;

        av_assert2(VAR_2 >= 0);

        *consumed= VAR_2;

        VAR_2 = 0;

    } else if (VAR_2 >= 0) {

        int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift;

        int64_t delta_frac = (end_index - VAR_2) * c->src_incr - c->VAR_3;

        int VAR_7 = (delta_frac + c->VAR_5 - 1) / c->VAR_5;

        int VAR_8 = FFMIN(dst_size, VAR_7);

        int VAR_10;



        if (!c->linear) {

            VAR_10 = VAR_2 >> c->phase_shift;

            VAR_2 &= c->phase_mask;

            for (VAR_0 = 0; VAR_0 < VAR_8; VAR_0++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * VAR_2;



#ifdef COMMON_CORE

                COMMON_CORE

#else

                FELEM2 val=0;

                for (VAR_1 = 0; VAR_1 < c->filter_length; VAR_1++) {

                    val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1];

                }

                OUT(dst[VAR_0], val);

#endif



                VAR_3 += VAR_4;

                VAR_2 += VAR_5;

                if (VAR_3 >= c->src_incr) {

                    VAR_3 -= c->src_incr;

                    VAR_2++;

                }

                VAR_10 += VAR_2 >> c->phase_shift;

                VAR_2 &= c->phase_mask;

            }

        } else {

            VAR_10 = VAR_2 >> c->phase_shift;

            VAR_2 &= c->phase_mask;

            for (VAR_0 = 0; VAR_0 < VAR_8; VAR_0++) {

                FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * VAR_2;

                FELEM2 val=0, v2 = 0;



#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for (VAR_1 = 0; VAR_1 < c->filter_length; VAR_1++) {

                    val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1];

                    v2  += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1 + c->filter_alloc];

                }

#endif

                val += (v2 - val) * (FELEML) VAR_3 / c->src_incr;

                OUT(dst[VAR_0], val);



                VAR_3 += VAR_4;

                VAR_2 += VAR_5;

                if (VAR_3 >= c->src_incr) {

                    VAR_3 -= c->src_incr;

                    VAR_2++;

                }

                VAR_10 += VAR_2 >> c->phase_shift;

                VAR_2 &= c->phase_mask;

            }

        }



        *consumed = VAR_10;

    } else {

        int VAR_10 = 0;

        for(VAR_0=0; VAR_0 < dst_size; VAR_0++){

            FELEM *filter;

            FELEM2 val=0;



            VAR_10 += VAR_2 >> c->phase_shift;

            VAR_2 &= c->phase_mask;

            filter = ((FELEM*)c->filter_bank) + c->filter_alloc*VAR_2;



            if(VAR_10 + c->filter_length > src_size || -VAR_10 >= src_size){

                break;

            }else if(VAR_10 < 0){

                for(VAR_1=0; VAR_1<c->filter_length; VAR_1++)

                    val += src[FFABS(VAR_10 + VAR_1)] * (FELEM2)filter[VAR_1];

                OUT(dst[VAR_0], val);

            }else if(c->linear){

                FELEM2 v2=0;

#ifdef LINEAR_CORE

                LINEAR_CORE

#else

                for(VAR_1=0; VAR_1<c->filter_length; VAR_1++){

                    val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1];

                    v2  += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1 + c->filter_alloc];

                }

#endif

                val+=(v2-val)*(FELEML)VAR_3 / c->src_incr;

                OUT(dst[VAR_0], val);

            }else{

#ifdef COMMON_CORE

                COMMON_CORE

#else

                for(VAR_1=0; VAR_1<c->filter_length; VAR_1++){

                    val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1];

                }

                OUT(dst[VAR_0], val);

#endif

            }



            VAR_3 += VAR_4;

            VAR_2 += VAR_5;

            if(VAR_3 >= c->src_incr){

                VAR_3 -= c->src_incr;

                VAR_2++;

            }

        }

        *consumed= FFMAX(VAR_10, 0);

        VAR_2 += FFMIN(VAR_10, 0) << c->phase_shift;

    }



    if(update_ctx){

        c->VAR_3= VAR_3;

        c->VAR_2= VAR_2;

    }



    return VAR_0;

}

int FUNC_0(swri_resample)(ResampleContext *c, DELEM *dst, const DELEM *src, int *consumed, int src_size, int dst_size, int update_ctx){ int VAR_0, VAR_1; int VAR_2= c->VAR_2; int VAR_3= c->VAR_3; int VAR_4= c->VAR_5 % c->src_incr; int VAR_5=      c->VAR_5 / c->src_incr; av_assert1(c->filter_shift == FILTER_SHIFT); av_assert1(c->felem_size == sizeof(FELEM)); if (c->filter_length == 1 && c->phase_shift == 0) { int64_t index2= (1LL<<32)*c->VAR_3/c->src_incr + (1LL<<32)*VAR_2; int64_t incr= (1LL<<32) * c->VAR_5 / c->src_incr; int VAR_6 = (src_size * (int64_t)c->src_incr - VAR_3 + c->VAR_5 - 1) / c->VAR_5; dst_size= FFMIN(dst_size, VAR_6); for(VAR_0=0; VAR_0 < dst_size; VAR_0++){ dst[VAR_0] = src[index2>>32]; index2 += incr; } VAR_2 += VAR_0 * VAR_5; VAR_2 += (VAR_3 + VAR_0 * (int64_t)VAR_4) / c->src_incr; VAR_3   = (VAR_3 + VAR_0 * (int64_t)VAR_4) % c->src_incr; av_assert2(VAR_2 >= 0); *consumed= VAR_2; VAR_2 = 0; } else if (VAR_2 >= 0) { int64_t end_index = (1LL + src_size - c->filter_length) << c->phase_shift; int64_t delta_frac = (end_index - VAR_2) * c->src_incr - c->VAR_3; int VAR_7 = (delta_frac + c->VAR_5 - 1) / c->VAR_5; int VAR_8 = FFMIN(dst_size, VAR_7); int VAR_10; if (!c->linear) { VAR_10 = VAR_2 >> c->phase_shift; VAR_2 &= c->phase_mask; for (VAR_0 = 0; VAR_0 < VAR_8; VAR_0++) { FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * VAR_2; #ifdef COMMON_CORE
COMMON_CORE
#else
FELEM2 val=0; for (VAR_1 = 0; VAR_1 < c->filter_length; VAR_1++) { val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1]; } OUT(dst[VAR_0], val); #endif
VAR_3 += VAR_4; VAR_2 += VAR_5; if (VAR_3 >= c->src_incr) { VAR_3 -= c->src_incr; VAR_2++; } VAR_10 += VAR_2 >> c->phase_shift; VAR_2 &= c->phase_mask; } } else { VAR_10 = VAR_2 >> c->phase_shift; VAR_2 &= c->phase_mask; for (VAR_0 = 0; VAR_0 < VAR_8; VAR_0++) { FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * VAR_2; FELEM2 val=0, v2 = 0; #ifdef LINEAR_CORE
LINEAR_CORE
#else
for (VAR_1 = 0; VAR_1 < c->filter_length; VAR_1++) { val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1]; v2  += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1 + c->filter_alloc]; } #endif
val += (v2 - val) * (FELEML) VAR_3 / c->src_incr; OUT(dst[VAR_0], val); VAR_3 += VAR_4; VAR_2 += VAR_5; if (VAR_3 >= c->src_incr) { VAR_3 -= c->src_incr; VAR_2++; } VAR_10 += VAR_2 >> c->phase_shift; VAR_2 &= c->phase_mask; } } *consumed = VAR_10; } else { int VAR_10 = 0; for(VAR_0=0; VAR_0 < dst_size; VAR_0++){ FELEM *filter; FELEM2 val=0; VAR_10 += VAR_2 >> c->phase_shift; VAR_2 &= c->phase_mask; filter = ((FELEM*)c->filter_bank) + c->filter_alloc*VAR_2; if(VAR_10 + c->filter_length > src_size || -VAR_10 >= src_size){ break; }else if(VAR_10 < 0){ for(VAR_1=0; VAR_1<c->filter_length; VAR_1++) val += src[FFABS(VAR_10 + VAR_1)] * (FELEM2)filter[VAR_1]; OUT(dst[VAR_0], val); }else if(c->linear){ FELEM2 v2=0; #ifdef LINEAR_CORE
LINEAR_CORE
#else
for(VAR_1=0; VAR_1<c->filter_length; VAR_1++){ val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1]; v2  += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1 + c->filter_alloc]; } #endif
val+=(v2-val)*(FELEML)VAR_3 / c->src_incr; OUT(dst[VAR_0], val); }else{ #ifdef COMMON_CORE
COMMON_CORE
#else
for(VAR_1=0; VAR_1<c->filter_length; VAR_1++){ val += src[VAR_10 + VAR_1] * (FELEM2)filter[VAR_1]; } OUT(dst[VAR_0], val); #endif
} VAR_3 += VAR_4; VAR_2 += VAR_5; if(VAR_3 >= c->src_incr){ VAR_3 -= c->src_incr; VAR_2++; } } *consumed= FFMAX(VAR_10, 0); VAR_2 += FFMIN(VAR_10, 0) << c->phase_shift; } if(update_ctx){ c->VAR_3= VAR_3; c->VAR_2= VAR_2; } return VAR_0; }