static int resample(ResampleContext *c, void *dst, const void *src,

                    int *consumed, int src_size, int dst_size, int update_ctx,

                    int nearest_neighbour)

{

    int dst_index;

    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;

    int compensation_distance = c->compensation_distance;



    if (!dst != !src)

        return AVERROR(EINVAL);



    if (nearest_neighbour) {

        int64_t index2 = ((int64_t)index) << 32;

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

        dst_size       = FFMIN(dst_size,

                               (src_size-1-index) * (int64_t)c->src_incr /

                               c->dst_incr);



        if (dst) {

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

                c->resample_nearest(dst, dst_index, src, index2 >> 32);

                index2 += incr;

            }

        } else {

            dst_index = dst_size;

        }

        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;

    } else {

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

            int sample_index = index >> c->phase_shift;



            if (sample_index + c->filter_length > src_size ||

                -sample_index >= src_size)

                break;



            if (dst)

                c->resample_one(c, dst, dst_index, src, src_size, index, frac);



            frac  += dst_incr_frac;

            index += dst_incr;

            if (frac >= c->src_incr) {

                frac -= c->src_incr;

                index++;

            }

            if (dst_index + 1 == compensation_distance) {

                compensation_distance = 0;

                dst_incr_frac = c->ideal_dst_incr % c->src_incr;

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

            }

        }

    }

    if (consumed)

        *consumed = FFMAX(index, 0) >> c->phase_shift;



    if (update_ctx) {

        if (index >= 0)

            index &= c->phase_mask;



        if (compensation_distance) {

            compensation_distance -= dst_index;

            if (compensation_distance <= 0)

                return AVERROR_BUG;

        }

        c->frac     = frac;

        c->index    = index;

        c->dst_incr = dst_incr_frac + c->src_incr*dst_incr;

        c->compensation_distance = compensation_distance;

    }



    return dst_index;

}

static int resample(ResampleContext *c, void *dst, const void *src,

                    int *consumed, int src_size, int dst_size, int update_ctx,

                    int nearest_neighbour)

{

    int dst_index;

    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;

    int compensation_distance = c->compensation_distance;



    if (!dst != !src)

        return AVERROR(EINVAL);



    if (nearest_neighbour) {

        int64_t index2 = ((int64_t)index) << 32;

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

        dst_size       = FFMIN(dst_size,

                               (src_size-1-index) * (int64_t)c->src_incr /

                               c->dst_incr);



        if (dst) {

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

                c->resample_nearest(dst, dst_index, src, index2 >> 32);

                index2 += incr;

            }

        } else {

            dst_index = dst_size;

        }

        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;

    } else {

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

            int sample_index = index >> c->phase_shift;



            if (sample_index + c->filter_length > src_size ||

                -sample_index >= src_size)

                break;



            if (dst)

                c->resample_one(c, dst, dst_index, src, src_size, index, frac);



            frac  += dst_incr_frac;

            index += dst_incr;

            if (frac >= c->src_incr) {

                frac -= c->src_incr;

                index++;

            }

            if (dst_index + 1 == compensation_distance) {

                compensation_distance = 0;

                dst_incr_frac = c->ideal_dst_incr % c->src_incr;

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

            }

        }

    }

    if (consumed)

        *consumed = FFMAX(index, 0) >> c->phase_shift;



    if (update_ctx) {

        if (index >= 0)

            index &= c->phase_mask;



        if (compensation_distance) {

            compensation_distance -= dst_index;

            if (compensation_distance <= 0)

                return AVERROR_BUG;

        }

        c->frac     = frac;

        c->index    = index;

        c->dst_incr = dst_incr_frac + c->src_incr*dst_incr;

        c->compensation_distance = compensation_distance;

    }



    return dst_index;

}

static int FUNC_0(ResampleContext *VAR_0, void *VAR_1, const void *VAR_2,

                    int *VAR_3, int VAR_4, int VAR_5, int VAR_6,

                    int VAR_7)

{

    int VAR_8;

    int VAR_9         = VAR_0->VAR_9;

    int VAR_10          = VAR_0->VAR_10;

    int VAR_11 = VAR_0->VAR_12 % VAR_0->src_incr;

    int VAR_12      = VAR_0->VAR_12 / VAR_0->src_incr;

    int VAR_13 = VAR_0->VAR_13;



    if (!VAR_1 != !VAR_2)

        return AVERROR(EINVAL);



    if (VAR_7) {

        int64_t index2 = ((int64_t)VAR_9) << 32;

        int64_t incr   = (1LL << 32) * VAR_0->VAR_12 / VAR_0->src_incr;

        VAR_5       = FFMIN(VAR_5,

                               (VAR_4-1-VAR_9) * (int64_t)VAR_0->src_incr /

                               VAR_0->VAR_12);



        if (VAR_1) {

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

                VAR_0->resample_nearest(VAR_1, VAR_8, VAR_2, index2 >> 32);

                index2 += incr;

            }

        } else {

            VAR_8 = VAR_5;

        }

        VAR_9 += VAR_8 * VAR_12;

        VAR_9 += (VAR_10 + VAR_8 * (int64_t)VAR_11) / VAR_0->src_incr;

        VAR_10   = (VAR_10 + VAR_8 * (int64_t)VAR_11) % VAR_0->src_incr;

    } else {

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

            int VAR_14 = VAR_9 >> VAR_0->phase_shift;



            if (VAR_14 + VAR_0->filter_length > VAR_4 ||

                -VAR_14 >= VAR_4)

                break;



            if (VAR_1)

                VAR_0->resample_one(VAR_0, VAR_1, VAR_8, VAR_2, VAR_4, VAR_9, VAR_10);



            VAR_10  += VAR_11;

            VAR_9 += VAR_12;

            if (VAR_10 >= VAR_0->src_incr) {

                VAR_10 -= VAR_0->src_incr;

                VAR_9++;

            }

            if (VAR_8 + 1 == VAR_13) {

                VAR_13 = 0;

                VAR_11 = VAR_0->ideal_dst_incr % VAR_0->src_incr;

                VAR_12      = VAR_0->ideal_dst_incr / VAR_0->src_incr;

            }

        }

    }

    if (VAR_3)

        *VAR_3 = FFMAX(VAR_9, 0) >> VAR_0->phase_shift;



    if (VAR_6) {

        if (VAR_9 >= 0)

            VAR_9 &= VAR_0->phase_mask;



        if (VAR_13) {

            VAR_13 -= VAR_8;

            if (VAR_13 <= 0)

                return AVERROR_BUG;

        }

        VAR_0->VAR_10     = VAR_10;

        VAR_0->VAR_9    = VAR_9;

        VAR_0->VAR_12 = VAR_11 + VAR_0->src_incr*VAR_12;

        VAR_0->VAR_13 = VAR_13;

    }



    return VAR_8;

}

static int FUNC_0(ResampleContext *VAR_0, void *VAR_1, const void *VAR_2,
int *VAR_3, int VAR_4, int VAR_5, int VAR_6,
int VAR_7)
{ int VAR_8; int VAR_9         = VAR_0->VAR_9; int VAR_10          = VAR_0->VAR_10; int VAR_11 = VAR_0->VAR_12 % VAR_0->src_incr; int VAR_12      = VAR_0->VAR_12 / VAR_0->src_incr; int VAR_13 = VAR_0->VAR_13; if (!VAR_1 != !VAR_2)
return AVERROR(EINVAL); if (VAR_7) { int64_t index2 = ((int64_t)VAR_9) << 32; int64_t incr   = (1LL << 32) * VAR_0->VAR_12 / VAR_0->src_incr; VAR_5       = FFMIN(VAR_5,
(VAR_4-1-VAR_9) * (int64_t)VAR_0->src_incr /
VAR_0->VAR_12); if (VAR_1) { for(VAR_8 = 0; VAR_8 < VAR_5; VAR_8++) { VAR_0->resample_nearest(VAR_1, VAR_8, VAR_2, index2 >> 32); index2 += incr; } } else { VAR_8 = VAR_5; } VAR_9 += VAR_8 * VAR_12; VAR_9 += (VAR_10 + VAR_8 * (int64_t)VAR_11) / VAR_0->src_incr; VAR_10   = (VAR_10 + VAR_8 * (int64_t)VAR_11) % VAR_0->src_incr; } else { for (VAR_8 = 0; VAR_8 < VAR_5; VAR_8++) { int VAR_14 = VAR_9 >> VAR_0->phase_shift; if (VAR_14 + VAR_0->filter_length > VAR_4 ||
-VAR_14 >= VAR_4)
break; if (VAR_1)
VAR_0->resample_one(VAR_0, VAR_1, VAR_8, VAR_2, VAR_4, VAR_9, VAR_10); VAR_10  += VAR_11; VAR_9 += VAR_12; if (VAR_10 >= VAR_0->src_incr) { VAR_10 -= VAR_0->src_incr; VAR_9++; } if (VAR_8 + 1 == VAR_13) { VAR_13 = 0; VAR_11 = VAR_0->ideal_dst_incr % VAR_0->src_incr; VAR_12      = VAR_0->ideal_dst_incr / VAR_0->src_incr; } } } if (VAR_3)
*VAR_3 = FFMAX(VAR_9, 0) >> VAR_0->phase_shift; if (VAR_6) { if (VAR_9 >= 0)
VAR_9 &= VAR_0->phase_mask; if (VAR_13) { VAR_13 -= VAR_8; if (VAR_13 <= 0)
return AVERROR_BUG; } VAR_0->VAR_10     = VAR_10; VAR_0->VAR_9    = VAR_9; VAR_0->VAR_12 = VAR_11 + VAR_0->src_incr*VAR_12; VAR_0->VAR_13 = VAR_13; } return VAR_8; }