xref: /external/libldac/src/quant_ldac.c

/*
 * Copyright (C) 2003 - 2016 Sony Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ldac.h"

/***************************************************************************************************
    Subfunction: Get Scale Factor Index
***************************************************************************************************/
__inline static int get_scale_factor_id_ldac(
SCALAR val)
{
    int id;
    IEEE754_FI fi;

    fi.f = val;
    id = ((fi.i & 0x7fffffff) >> 23) - 111;

    if (id < 0) {
        id = 0;
    }
    if (id > LDAC_NIDSF-1) {
        id = LDAC_NIDSF-1;
    }

    return id;
}

/***************************************************************************************************
    Normalize Spectrum
***************************************************************************************************/
static SCALAR sa_val_ldac[LDAC_MAXNSPS] = {
    -0.75, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
};

DECLFUNC void norm_spectrum_ldac(
AC *p_ac)
{
    int iqu, isp;
    int lsp, hsp;
    int nqus = p_ac->p_ab->nqus;
    int idsf;
    int *p_idsf = p_ac->a_idsf;
    SCALAR maxspec, tmp;
    SCALAR *p_spec = p_ac->p_acsub->a_spec;

    for (iqu = 0; iqu < nqus; iqu++) {
        lsp = ga_isp_ldac[iqu];
        hsp = ga_isp_ldac[iqu+1];

        maxspec = fabs(p_spec[lsp]);
        for (isp = lsp+1; isp < hsp; isp++) {
            tmp = fabs(p_spec[isp]);
            if (maxspec < tmp) {
                maxspec = tmp;
            }
        }
        idsf = get_scale_factor_id_ldac(maxspec);

        if (idsf > 0) {
            tmp = ga_isf_ldac[idsf];
            for (isp = lsp; isp < hsp; isp++) {
                p_spec[isp] *= tmp;
            }
        }
        else {
            for (isp = lsp; isp < hsp; isp++) {
                p_spec[isp] = sa_val_ldac[isp-lsp];
            }
        }

        p_idsf[iqu] = idsf;
    }

    return;
}

/***************************************************************************************************
    Subfunction: Quantize Spectrum Core
***************************************************************************************************/
__inline static void quant_spectrum_core_ldac(
AC *p_ac,
int iqu)
{
    int i;
    int isp = ga_isp_ldac[iqu];
    int nsps = ga_nsps_ldac[iqu];
    int *p_qspec = p_ac->a_qspec+isp;
    SCALAR qf = ga_qf_ldac[p_ac->a_idwl1[iqu]];
    SCALAR *p_nspec = p_ac->p_acsub->a_spec+isp;

    IEEE754_FI fi;
    const float fc = (float)((1 << 23) + (1 << 22));

    for (i = 0; i < nsps; i++) {
        fi.f = p_nspec[i] * qf + fc;
        p_qspec[i] = (short)fi.i;
    }

    return;
}

/***************************************************************************************************
    Quantize Spectrum
***************************************************************************************************/
DECLFUNC void quant_spectrum_ldac(
AC *p_ac)
{
    int iqu;
    int nqus = p_ac->p_ab->nqus;

    for (iqu = 0; iqu < nqus; iqu++) {
        quant_spectrum_core_ldac(p_ac, iqu);
    }

    return;
}

/***************************************************************************************************
    Subfunction: Quantize Residual Spectrum Core
***************************************************************************************************/
__inline static void quant_residual_core_ldac(
AC *p_ac,
int iqu)
{
    int i;
    int isp = ga_isp_ldac[iqu];
    int nsps = ga_nsps_ldac[iqu];
    int *p_qspec = p_ac->a_qspec+isp;
    int *p_rspec = p_ac->a_rspec+isp;
    SCALAR ldqspec;
    SCALAR iqf = ga_iqf_ldac[LDAC_MAXIDWL1];
    SCALAR rqsf = ga_qf_ldac[p_ac->a_idwl2[iqu]] * ga_irsf_ldac[LDAC_MAXIDWL1]
            * _scalar(0.996093750);
    SCALAR *p_nspec = p_ac->p_acsub->a_spec+isp;

    IEEE754_FI fi;
    const float fc = (float)((1 << 23) + (1 << 22));

    for (i = 0; i < nsps; i++) {
        ldqspec = p_qspec[i] * iqf;
        fi.f = (p_nspec[i] - ldqspec) * rqsf + fc;
        p_rspec[i] = (short)fi.i;
    }

    return;
}

/***************************************************************************************************
    Quantize Residual Spectrum
***************************************************************************************************/
DECLFUNC void quant_residual_ldac(
AC *p_ac)
{
    int iqu;
    int nqus = p_ac->p_ab->nqus;
    int *p_idwl2 = p_ac->a_idwl2;

    for (iqu = 0; iqu < nqus; iqu++) {
        if (p_idwl2[iqu] > 0) {
            quant_residual_core_ldac(p_ac, iqu);
        }
    }

    return;
}