vbrquantize.c

音频编码

    return checkScalefactor(cod_info, vbrsfmin);
}



/******************************************************************
 *
 *  long block scalefacs
 *
 ******************************************************************/

static int
long_block_constrain(const algo_t * that, int vbrsf[SFBMAX], const int vbrsfmin[SFBMAX], int vbrmax)
{
    gr_info *cod_info = that->cod_info;
    lame_internal_flags *gfc = that->gfc;
    const int *max_rangep;
    int const maxminsfb = that->mingain_l;
    int     sfb;
    int     maxover0, maxover1, maxover0p, maxover1p, mover, delta = 0;
    int     v, v0, v1, v0p, v1p, vm0p = 1, vm1p = 1;
    int     psymax = cod_info->psymax;

    max_rangep = gfc->mode_gr == 2 ? max_range_long : max_range_long_lsf_pretab;

    maxover0 = 0;
    maxover1 = 0;
    maxover0p = 0;      /* pretab */
    maxover1p = 0;      /* pretab */

    for (sfb = 0; sfb < psymax; ++sfb) {
        assert( vbrsf[sfb] >= vbrsfmin[sfb] );
        v = vbrmax - vbrsf[sfb];
        if (delta < v) {
            delta = v;
        }
        v0 = v - 2 * max_range_long[sfb];
        v1 = v - 4 * max_range_long[sfb];
        v0p = v - 2 * (max_rangep[sfb] + pretab[sfb]);
        v1p = v - 4 * (max_rangep[sfb] + pretab[sfb]);
        if (maxover0 < v0) {
            maxover0 = v0;
        }
        if (maxover1 < v1) {
            maxover1 = v1;
        }
        if (maxover0p < v0p) {
            maxover0p = v0p;
        }
        if (maxover1p < v1p) {
            maxover1p = v1p;
        }
    }
    if (vm0p == 1) {
        int     gain = vbrmax - maxover0p;
        if (gain < maxminsfb) {
            gain = maxminsfb;
        }
        for (sfb = 0; sfb < psymax; ++sfb) {
            int     a = (gain - vbrsfmin[sfb]) - 2 * pretab[sfb];
            if (a <= 0) {
                vm0p = 0;
                vm1p = 0;
                break;
            }
        }
    }
    if (vm1p == 1) {
        int     gain = vbrmax - maxover1p;
        if (gain < maxminsfb) {
            gain = maxminsfb;
        }
        for (sfb = 0; sfb < psymax; ++sfb) {
            int     b = (gain - vbrsfmin[sfb]) - 4 * pretab[sfb];
            if (b <= 0) {
                vm1p = 0;
                break;
            }
        }
    }
    if (vm0p == 0) {
        maxover0p = maxover0;
    }
    if (vm1p == 0) {
        maxover1p = maxover1;
    }
    if (gfc->noise_shaping != 2) {
        maxover1 = maxover0;
        maxover1p = maxover0p;
    }
    mover = Min(maxover0, maxover0p);
    mover = Min(mover, maxover1);
    mover = Min(mover, maxover1p);

    if (delta > mover) {
        delta = mover;
    }
    vbrmax -= delta;
    if (vbrmax < maxminsfb) {
        vbrmax = maxminsfb;
    }
    maxover0 -= mover;
    maxover0p -= mover;
    maxover1 -= mover;
    maxover1p -= mover;

    if (maxover0 == 0) {
        cod_info->scalefac_scale = 0;
        cod_info->preflag = 0;
        max_rangep = max_range_long;
    }
    else if (maxover0p == 0) {
        cod_info->scalefac_scale = 0;
        cod_info->preflag = 1;
    }
    else if (maxover1 == 0) {
        cod_info->scalefac_scale = 1;
        cod_info->preflag = 0;
        max_rangep = max_range_long;
    }
    else if (maxover1p == 0) {
        cod_info->scalefac_scale = 1;
        cod_info->preflag = 1;
    }
    else {
        assert(0);      /* this should not happen */
    }
    cod_info->global_gain = vbrmax;
    if (cod_info->global_gain < 0) {
        cod_info->global_gain = 0;
    }
    else if (cod_info->global_gain > 255) {
        cod_info->global_gain = 255;
    }
    for (sfb = 0; sfb < SFBMAX; ++sfb) {
        vbrsf[sfb] -= vbrmax;
    }
    set_scalefacs(cod_info, vbrsfmin, vbrsf, max_rangep);
    assert(checkScalefactor(cod_info, vbrsfmin));
    return checkScalefactor(cod_info, vbrsfmin);
}



static int
bitcount(const algo_t * that)
{
    if (that->gfc->mode_gr == 2) {
        return scale_bitcount(that->cod_info);
    }
    else {
        return scale_bitcount_lsf(that->gfc, that->cod_info);
    }
}



static int
quantizeAndCountBits(const algo_t * that)
{
    that->quantize(that);
    that->cod_info->part2_3_length = noquant_count_bits(that->gfc, that->cod_info, 0);
    return that->cod_info->part2_3_length;
}



static int
tryScalefacColor(const algo_t * that, int vbrsf[SFBMAX],
                 const int vbrsf2[SFBMAX], const int vbrsfmin[SFBMAX], int I, int M, int target)
{
    FLOAT   xrpow_max = that->cod_info->xrpow_max;
    int     i, nbits;
    int     gain, vbrmax = 0;

    for (i = 0; i < SFBMAX; ++i) {
        gain = target + (vbrsf2[i] - target) * I / M;
        if (gain < vbrsfmin[i]) {
            gain = vbrsfmin[i];
        }
        if (gain > 255) {
            gain = 255;
        }
        if (vbrmax < gain) {
            vbrmax = gain;
        }
        vbrsf[i] = gain;
    }
    if (!that->alloc(that, vbrsf, vbrsfmin, vbrmax)) {
        return LARGE_BITS;
    }
    bitcount(that);
    nbits = quantizeAndCountBits(that);
    that->cod_info->xrpow_max = xrpow_max;
    return nbits;
}



static void
searchScalefacColorMax(const algo_t * that, int sfwork[SFBMAX],
                       const int sfcalc[SFBMAX], const int vbrsfmin[SFBMAX], int bits)
{
    int const psymax = that->cod_info->psymax;
    int     nbits, last, i, ok = -1, l = 0, r, vbrmin = 255, vbrmax = 0, M, target;
    for (i = 0; i < psymax; ++i) {
        if (vbrmin > sfcalc[i]) {
            vbrmin = sfcalc[i];
        }
        if (vbrmax < sfcalc[i]) {
            vbrmax = sfcalc[i];
        }
    }
    M = vbrmax - vbrmin;

    if (M == 0) {
        return;
    }
    target = vbrmax;
    for (l = 0, r = M, last = i = M / 2; l <= r; i = (l + r) / 2) {
        nbits = tryScalefacColor(that, sfwork, sfcalc, vbrsfmin, i, M, target);
        if (nbits < bits) {
            ok = i;
            l = i + 1;
        }
        else {
            r = i - 1;
        }
        last = i;
    }
    if (last != ok) {
        if (ok == -1) {
            ok = 0;
        }
        nbits = tryScalefacColor(that, sfwork, sfcalc, vbrsfmin, ok, M, target);
    }
}


#if 0
static void
searchScalefacColorMin(const algo_t * that, int sfwork[SFBMAX],
                       const int sfcalc[SFBMAX], const int vbrsfmin[SFBMAX], int bits)
{
    int const psymax = that->cod_info->psymax;
    int     nbits, last, i, ok = -1, l = 0, r, vbrmin = 255, vbrmax = 0, M, target;
    for (i = 0; i < psymax; ++i) {
        if (vbrmin > sfcalc[i]) {
            vbrmin = sfcalc[i];
        }
        if (vbrmax < sfcalc[i]) {
            vbrmax = sfcalc[i];
        }
    }
    M = vbrmax - vbrmin;

    if (M == 0) {
        return;
    }
    target = vbrmin;
    for (l = 0, r = M, last = i = M / 2; l <= r; i = (l + r) / 2) {
        nbits = tryScalefacColor(that, sfwork, sfcalc, vbrsfmin, i, M, target);
        if (nbits > bits) {
            ok = i;
            r = i - 1;
        }
        else {
            l = i + 1;
        }
        last = i;
    }
    if (last != ok) {
        if (ok == -1) {
            ok = 0;
        }
        nbits = tryScalefacColor(that, sfwork, sfcalc, vbrsfmin, ok, M, target);
    }
}
#endif


static int
tryGlobalStepsize(const algo_t * that, const int sfwork[SFBMAX],
                  const int vbrsfmin[SFBMAX], int delta)
{
    FLOAT   xrpow_max = that->cod_info->xrpow_max;
    int     sftemp[SFBMAX], i, nbits;
    int     gain, vbrmax = 0;
    for (i = 0; i < SFBMAX; ++i) {
        gain = sfwork[i] + delta;
        if (gain < vbrsfmin[i]) {
            gain = vbrsfmin[i];
        }
        if (gain > 255) {
            gain = 255;
        }
        if (vbrmax < gain) {
            vbrmax = gain;
        }
        sftemp[i] = gain;
    }
    if (!that->alloc(that, sftemp, vbrsfmin, vbrmax)) {
        return LARGE_BITS;
    }
    bitcount(that);
    nbits = quantizeAndCountBits(that);
    that->cod_info->xrpow_max = xrpow_max;
    return nbits;
}



static void
searchGlobalStepsizeMax(const algo_t * that, const int sfwork[SFBMAX],
                        const int vbrsfmin[SFBMAX], int target)
{
    gr_info *cod_info = that->cod_info;
    const int gain = cod_info->global_gain;
    int     curr = gain;
    int     gain_ok = 1024;
    int     nbits = LARGE_BITS;
    int     l = gain, r = 512;

    assert(gain >= 0);
    while (l <= r) {
        curr = (l + r) >> 1;
        nbits = tryGlobalStepsize(that, sfwork, vbrsfmin, curr - gain);
        if (cod_info->part2_length >= LARGE_BITS || nbits >= LARGE_BITS) {
            l = curr + 1;
            continue;
        }
        if (nbits + cod_info->part2_length < target) {
            r = curr - 1;
            gain_ok = curr;
        }
        else {
            l = curr + 1;
            if (gain_ok == 1024) {
                gain_ok = curr;
            }
        }
    }
    if (gain_ok != curr) {
        curr = gain_ok;
        nbits = tryGlobalStepsize(that, sfwork, vbrsfmin, curr - gain);
    }
}

#if 0
static void
searchGlobalStepsizeMin(const algo_t * that, const int sfwork[SFBMAX],
                        const int vbrsfmin[SFBMAX], int target)
{
    gr_info *cod_info = that->cod_info;
    const int gain = cod_info->global_gain;
    int     curr = gain;
    int     gain_ok = 1024;
    int     nbits = LARGE_BITS;
    int     l = 0, r = gain;

    assert(gain >= 0);
    while (l <= r) {
        curr = (l + r) >> 1;
        nbits = tryGlobalStepsize(that, sfwork, vbrsfmin, curr - gain);
        if (cod_info->part2_length >= LARGE_BITS || nbits >= LARGE_BITS) {
            l = curr + 1;
            continue;
        }
        if (nbits + cod_info->part2_length < target) {
            l = curr + 1;
            if (gain_ok == 1024) {
                gain_ok = curr;
            }
        }
        else {
            r = curr - 1;
            gain_ok = curr;
        }
    }
    if (gain_ok != curr) {
        curr = gain_ok;
        nbits = tryGlobalStepsize(that, sfwork, vbrsfmin, curr - gain);
    }
}
#endif


/************************************************************************
 *
 *  VBR_noise_shaping()
 *
 *  may result in a need of too many bits, then do it CBR like
 *
 *  Robert Hegemann 2000-10-25
 *
 ***********************************************************************/

int
VBR_noise_shaping(lame_internal_flags * gfc, const FLOAT xr34orig[576],
                  const FLOAT l3_xmin[576], int maxbits, int gr, int ch)
{
    int     sfwork[SFBMAX];
    int     sfcalc[SFBMAX];
    int     vbrsfmin[SFBMAX];
    algo_t  that;
    int     vbrmax;
    gr_info *cod_info = &gfc->l3_side.tt[gr][ch];

    that.xr34orig = xr34orig;
    if (gfc->quantization) {
        that.find = find_scalefac_x34;
        that.quantize = quantize_x34;
    }
    else {
        that.find = find_scalefac_ISO;
        that.quantize = quantize_ISO;
    }
    if (cod_info->block_type == SHORT_TYPE) {
        that.alloc = short_block_constrain;
    }
    else {
        that.alloc = long_block_constrain;
    }
    that.gfc = gfc;
    that.cod_info = &gfc->l3_side.tt[gr][ch];

    memset(cod_info->l3_enc, 0, 576 * sizeof(int));

    vbrmax = block_sf(&that, l3_xmin, sfcalc, vbrsfmin);
    memcpy(sfwork, sfcalc, SFBMAX * sizeof(int));
    that.alloc(&that, sfwork, vbrsfmin, vbrmax);
    if (0 != bitcount(&that)) {
        /*  this should not happen due to the way the scalefactors are selected
         */
        cod_info->part2_3_length = LARGE_BITS;
        return -1;
    }
    quantizeAndCountBits(&that);
    if (cod_info->part2_3_length > maxbits - cod_info->part2_length) {
        searchScalefacColorMax(&that, sfwork, sfcalc, vbrsfmin, maxbits);
    }
    if (cod_info->part2_3_length > maxbits - cod_info->part2_length) {
        searchGlobalStepsizeMax(&that, sfwork, vbrsfmin, maxbits);
    }
    if (gfc->use_best_huffman == 2) {
        best_huffman_divide(gfc, cod_info);
    }
    assert(cod_info->global_gain < 256u);

    if (cod_info->part2_3_length + cod_info->part2_length >= LARGE_BITS) {
        cod_info->part2_3_length = LARGE_BITS;
        return -2;      /* Houston, we have a problem */
    }
    return 0;
}