/*
|
* 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;
|
}
|
