static void alac_linear_predictor(AlacEncodeContext *s, int ch)

{

    int i;

    LPCContext lpc = s->lpc[ch];



    if(lpc.lpc_order == 31) {

        s->predictor_buf[0] = s->sample_buf[ch][0];



        for(i=1; i<s->avctx->frame_size; i++)

            s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];



        return;

    }



    // generalised linear predictor



    if(lpc.lpc_order > 0) {

        int32_t *samples  = s->sample_buf[ch];

        int32_t *residual = s->predictor_buf;



        // generate warm-up samples

        residual[0] = samples[0];

        for(i=1;i<=lpc.lpc_order;i++)

            residual[i] = samples[i] - samples[i-1];



        // perform lpc on remaining samples

        for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {

            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;



            for (j = 0; j < lpc.lpc_order; j++) {

                sum += (samples[lpc.lpc_order-j] - samples[0]) *

                        lpc.lpc_coeff[j];

            }



            sum >>= lpc.lpc_quant;

            sum += samples[0];

            residual[i] = samples[lpc.lpc_order+1] - sum;

            res_val = residual[i];



            if(res_val) {

                int index = lpc.lpc_order - 1;

                int neg = (res_val < 0);



                while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {

                    int val = samples[0] - samples[lpc.lpc_order - index];

                    int sign = (val ? FFSIGN(val) : 0);



                    if(neg)

                        sign*=-1;



                    lpc.lpc_coeff[index] -= sign;

                    val *= sign;

                    res_val -= ((val >> lpc.lpc_quant) *

                            (lpc.lpc_order - index));

                    index--;

                }

            }

            samples++;

        }

    }

}

static void alac_linear_predictor(AlacEncodeContext *s, int ch)

{

    int i;

    LPCContext lpc = s->lpc[ch];



    if(lpc.lpc_order == 31) {

        s->predictor_buf[0] = s->sample_buf[ch][0];



        for(i=1; i<s->avctx->frame_size; i++)

            s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];



        return;

    }



    



    if(lpc.lpc_order > 0) {

        int32_t *samples  = s->sample_buf[ch];

        int32_t *residual = s->predictor_buf;



        

        residual[0] = samples[0];

        for(i=1;i<=lpc.lpc_order;i++)

            residual[i] = samples[i] - samples[i-1];



        

        for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {

            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;



            for (j = 0; j < lpc.lpc_order; j++) {

                sum += (samples[lpc.lpc_order-j] - samples[0]) *

                        lpc.lpc_coeff[j];

            }



            sum >>= lpc.lpc_quant;

            sum += samples[0];

            residual[i] = samples[lpc.lpc_order+1] - sum;

            res_val = residual[i];



            if(res_val) {

                int index = lpc.lpc_order - 1;

                int neg = (res_val < 0);



                while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {

                    int val = samples[0] - samples[lpc.lpc_order - index];

                    int sign = (val ? FFSIGN(val) : 0);



                    if(neg)

                        sign*=-1;



                    lpc.lpc_coeff[index] -= sign;

                    val *= sign;

                    res_val -= ((val >> lpc.lpc_quant) *

                            (lpc.lpc_order - index));

                    index--;

                }

            }

            samples++;

        }

    }

}

            residual[i] = samples[lpc.lpc_order+1] - sum;
static void FUNC_0(AlacEncodeContext *VAR_0, int VAR_1)

{

    int VAR_2;

    LPCContext lpc = VAR_0->lpc[VAR_1];



    if(lpc.lpc_order == 31) {

        VAR_0->predictor_buf[0] = VAR_0->sample_buf[VAR_1][0];



        for(VAR_2=1; VAR_2<VAR_0->avctx->frame_size; VAR_2++)

            VAR_0->predictor_buf[VAR_2] = VAR_0->sample_buf[VAR_1][VAR_2] - VAR_0->sample_buf[VAR_1][VAR_2-1];



        return;

    }



    



    if(lpc.lpc_order > 0) {

        int32_t *samples  = VAR_0->sample_buf[VAR_1];

        int32_t *residual = VAR_0->predictor_buf;



        

        residual[0] = samples[0];

        for(VAR_2=1;VAR_2<=lpc.lpc_order;VAR_2++)

            residual[VAR_2] = samples[VAR_2] - samples[VAR_2-1];



        

        for(VAR_2 = lpc.lpc_order + 1; VAR_2 < VAR_0->avctx->frame_size; VAR_2++) {

            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;



            for (j = 0; j < lpc.lpc_order; j++) {

                sum += (samples[lpc.lpc_order-j] - samples[0]) *

                        lpc.lpc_coeff[j];

            }



            sum >>= lpc.lpc_quant;

            sum += samples[0];

            residual[VAR_2] = samples[lpc.lpc_order+1] - sum;

            res_val = residual[VAR_2];



            if(res_val) {

                int index = lpc.lpc_order - 1;

                int neg = (res_val < 0);



                while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {

                    int val = samples[0] - samples[lpc.lpc_order - index];

                    int sign = (val ? FFSIGN(val) : 0);



                    if(neg)

                        sign*=-1;



                    lpc.lpc_coeff[index] -= sign;

                    val *= sign;

                    res_val -= ((val >> lpc.lpc_quant) *

                            (lpc.lpc_order - index));

                    index--;

                }

            }

            samples++;

        }

    }

}

static void FUNC_0(AlacEncodeContext *VAR_0, int VAR_1)
{ int VAR_2; LPCContext lpc = VAR_0->lpc[VAR_1]; if(lpc.lpc_order == 31) { VAR_0->predictor_buf[0] = VAR_0->sample_buf[VAR_1][0]; for(VAR_2=1; VAR_2<VAR_0->avctx->frame_size; VAR_2++) VAR_0->predictor_buf[VAR_2] = VAR_0->sample_buf[VAR_1][VAR_2] - VAR_0->sample_buf[VAR_1][VAR_2-1]; return; } if(lpc.lpc_order > 0) { int32_t *samples  = VAR_0->sample_buf[VAR_1]; int32_t *residual = VAR_0->predictor_buf; residual[0] = samples[0]; for(VAR_2=1;VAR_2<=lpc.lpc_order;VAR_2++) residual[VAR_2] = samples[VAR_2] - samples[VAR_2-1]; for(VAR_2 = lpc.lpc_order + 1; VAR_2 < VAR_0->avctx->frame_size; VAR_2++) { int sum = 1 << (lpc.lpc_quant - 1), res_val, j; for (j = 0; j < lpc.lpc_order; j++) { sum += (samples[lpc.lpc_order-j] - samples[0]) *
lpc.lpc_coeff[j]; } sum >>= lpc.lpc_quant; sum += samples[0]; residual[VAR_2] = samples[lpc.lpc_order+1] - sum; res_val = residual[VAR_2]; if(res_val) { int index = lpc.lpc_order - 1; int neg = (res_val < 0); while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) { int val = samples[0] - samples[lpc.lpc_order - index]; int sign = (val ? FFSIGN(val) : 0); if(neg)
sign*=-1; lpc.lpc_coeff[index] -= sign; val *= sign; res_val -= ((val >> lpc.lpc_quant) *
(lpc.lpc_order - index)); index--; } } samples++; } } }