comparison flacenc.c @ 12305:000218dd70aa libavcodec

cosmetics: change FlacEncodeContext variable name from ctx to s in several places for consistency.

12304:78275120749d

    }
#endif
}


static int encode_residual(FlacEncodeContext *ctx, int ch)
{
    int i, n;
    int min_order, max_order, opt_order, precision, omethod;
    int min_porder, max_porder;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
    int shift[MAX_LPC_ORDER];
    int32_t *res, *smp;

    frame = &ctx->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    smp   = sub->samples;
    n     = frame->blocksize;

        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
        encode_residual_verbatim(res, smp, n);
        return sub->obits * n;
    }

    min_order  = ctx->options.min_prediction_order;
    max_order  = ctx->options.max_prediction_order;
    min_porder = ctx->options.min_partition_order;
    max_porder = ctx->options.max_partition_order;
    precision  = ctx->options.lpc_coeff_precision;
    omethod    = ctx->options.prediction_order_method;

    /* FIXED */
    if (ctx->options.lpc_type == AV_LPC_TYPE_NONE  ||
        ctx->options.lpc_type == AV_LPC_TYPE_FIXED || n <= max_order) {
        uint32_t bits[MAX_FIXED_ORDER+1];
        if (max_order > MAX_FIXED_ORDER)
            max_order = MAX_FIXED_ORDER;
        opt_order = 0;
        bits[0]   = UINT32_MAX;

        }
        return bits[sub->order];
    }

    /* LPC */
    opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
                                  precision, coefs, shift, ctx->options.lpc_type,
                                  ctx->options.lpc_passes, omethod,
                                  MAX_LPC_SHIFT, 0);

    if (omethod == ORDER_METHOD_2LEVEL ||
        omethod == ORDER_METHOD_4LEVEL ||
        omethod == ORDER_METHOD_8LEVEL) {

    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n,
                                sub->order, sub->obits, precision);
}


static int encode_residual_v(FlacEncodeContext *ctx, int ch)
{
    int i, n;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t *res, *smp;

    frame = &ctx->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    smp   = sub->samples;
    n     = frame->blocksize;

/**
 * Perform stereo channel decorrelation.
 */
static void channel_decorrelation(FlacEncodeContext *ctx)
{
    FlacFrame *frame;
    int32_t *left, *right;
    int i, n;

    frame = &ctx->frame;
    n     = frame->blocksize;
    left  = frame->subframes[0].samples;
    right = frame->subframes[1].samples;

    if (ctx->channels != 2) {
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
        return;
    }

    frame->ch_mode = estimate_stereo_mode(left, right, n);

        put_sbits(&s->pb, sub->obits, res);
    }
}


static void output_residual(FlacEncodeContext *ctx, int ch)
{
    int i, j, p, n, parts;
    int k, porder, psize, res_cnt;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t *res;

    frame = &ctx->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    n     = frame->blocksize;

    /* rice-encoded block */
    put_bits(&ctx->pb, 2, 0);

    /* partition order */
    porder  = sub->rc.porder;
    psize   = n >> porder;
    parts   = (1 << porder);
    put_bits(&ctx->pb, 4, porder);
    res_cnt = psize - sub->order;

    /* residual */
    j = sub->order;
    for (p = 0; p < parts; p++) {
        k = sub->rc.params[p];
        put_bits(&ctx->pb, 4, k);
        if (p == 1)
            res_cnt = psize;
        for (i = 0; i < res_cnt && j < n; i++, j++)
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
    }
}


static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
{
    int i;
    FlacFrame *frame;
    FlacSubframe *sub;

    frame = &ctx->frame;
    sub   = &frame->subframes[ch];

    /* warm-up samples */
    for (i = 0; i < sub->order; i++)
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);

    /* residual */
    output_residual(ctx, ch);
}


static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
{
    int i, cbits;
    FlacFrame *frame;
    FlacSubframe *sub;

    frame = &ctx->frame;
    sub = &frame->subframes[ch];

    /* warm-up samples */
    for (i = 0; i < sub->order; i++)
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);

    /* LPC coefficients */
    cbits = ctx->options.lpc_coeff_precision;
    put_bits( &ctx->pb, 4, cbits-1);
    put_sbits(&ctx->pb, 5, sub->shift);
    for (i = 0; i < sub->order; i++)
        put_sbits(&ctx->pb, cbits, sub->coefs[i]);

    /* residual */
    output_residual(ctx, ch);
}


static void output_subframes(FlacEncodeContext *s)
{

12305:000218dd70aa

    }
#endif
}


static int encode_residual(FlacEncodeContext *s, int ch)
{
    int i, n;
    int min_order, max_order, opt_order, precision, omethod;
    int min_porder, max_porder;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
    int shift[MAX_LPC_ORDER];
    int32_t *res, *smp;

    frame = &s->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    smp   = sub->samples;
    n     = frame->blocksize;

        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
        encode_residual_verbatim(res, smp, n);
        return sub->obits * n;
    }

    min_order  = s->options.min_prediction_order;
    max_order  = s->options.max_prediction_order;
    min_porder = s->options.min_partition_order;
    max_porder = s->options.max_partition_order;
    precision  = s->options.lpc_coeff_precision;
    omethod    = s->options.prediction_order_method;

    /* FIXED */
    if (s->options.lpc_type == AV_LPC_TYPE_NONE  ||
        s->options.lpc_type == AV_LPC_TYPE_FIXED || n <= max_order) {
        uint32_t bits[MAX_FIXED_ORDER+1];
        if (max_order > MAX_FIXED_ORDER)
            max_order = MAX_FIXED_ORDER;
        opt_order = 0;
        bits[0]   = UINT32_MAX;

        }
        return bits[sub->order];
    }

    /* LPC */
    opt_order = ff_lpc_calc_coefs(&s->dsp, smp, n, min_order, max_order,
                                  precision, coefs, shift, s->options.lpc_type,
                                  s->options.lpc_passes, omethod,
                                  MAX_LPC_SHIFT, 0);

    if (omethod == ORDER_METHOD_2LEVEL ||
        omethod == ORDER_METHOD_4LEVEL ||
        omethod == ORDER_METHOD_8LEVEL) {

    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n,
                                sub->order, sub->obits, precision);
}


static int encode_residual_v(FlacEncodeContext *s, int ch)
{
    int i, n;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t *res, *smp;

    frame = &s->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    smp   = sub->samples;
    n     = frame->blocksize;

/**
 * Perform stereo channel decorrelation.
 */
static void channel_decorrelation(FlacEncodeContext *s)
{
    FlacFrame *frame;
    int32_t *left, *right;
    int i, n;

    frame = &s->frame;
    n     = frame->blocksize;
    left  = frame->subframes[0].samples;
    right = frame->subframes[1].samples;

    if (s->channels != 2) {
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
        return;
    }

    frame->ch_mode = estimate_stereo_mode(left, right, n);

        put_sbits(&s->pb, sub->obits, res);
    }
}


static void output_residual(FlacEncodeContext *s, int ch)
{
    int i, j, p, n, parts;
    int k, porder, psize, res_cnt;
    FlacFrame *frame;
    FlacSubframe *sub;
    int32_t *res;

    frame = &s->frame;
    sub   = &frame->subframes[ch];
    res   = sub->residual;
    n     = frame->blocksize;

    /* rice-encoded block */
    put_bits(&s->pb, 2, 0);

    /* partition order */
    porder  = sub->rc.porder;
    psize   = n >> porder;
    parts   = (1 << porder);
    put_bits(&s->pb, 4, porder);
    res_cnt = psize - sub->order;

    /* residual */
    j = sub->order;
    for (p = 0; p < parts; p++) {
        k = sub->rc.params[p];
        put_bits(&s->pb, 4, k);
        if (p == 1)
            res_cnt = psize;
        for (i = 0; i < res_cnt && j < n; i++, j++)
            set_sr_golomb_flac(&s->pb, res[j], k, INT32_MAX, 0);
    }
}


static void output_subframe_fixed(FlacEncodeContext *s, int ch)
{
    int i;
    FlacFrame *frame;
    FlacSubframe *sub;

    frame = &s->frame;
    sub   = &frame->subframes[ch];

    /* warm-up samples */
    for (i = 0; i < sub->order; i++)
        put_sbits(&s->pb, sub->obits, sub->residual[i]);

    /* residual */
    output_residual(s, ch);
}


static void output_subframe_lpc(FlacEncodeContext *s, int ch)
{
    int i, cbits;
    FlacFrame *frame;
    FlacSubframe *sub;

    frame = &s->frame;
    sub = &frame->subframes[ch];

    /* warm-up samples */
    for (i = 0; i < sub->order; i++)
        put_sbits(&s->pb, sub->obits, sub->residual[i]);

    /* LPC coefficients */
    cbits = s->options.lpc_coeff_precision;
    put_bits( &s->pb, 4, cbits-1);
    put_sbits(&s->pb, 5, sub->shift);
    for (i = 0; i < sub->order; i++)
        put_sbits(&s->pb, cbits, sub->coefs[i]);

    /* residual */
    output_residual(s, ch);
}


static void output_subframes(FlacEncodeContext *s)
{