You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
734 lines
22 KiB
734 lines
22 KiB
/*
|
|
* 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: Calculate Bits for Audio Block
|
|
***************************************************************************************************/
|
|
static int encode_audio_block_a_ldac(
|
|
AB *p_ab,
|
|
int hqu)
|
|
{
|
|
AC *p_ac;
|
|
int ich, iqu;
|
|
int nchs = p_ab->blk_nchs;
|
|
int tmp, nbits = 0;
|
|
int idsp, idwl1, idwl2;
|
|
int grad_mode = p_ab->grad_mode;
|
|
int grad_qu_l = p_ab->grad_qu_l;
|
|
int grad_qu_h = p_ab->grad_qu_h;
|
|
int grad_os_l = p_ab->grad_os_l;
|
|
int grad_os_h = p_ab->grad_os_h;
|
|
int *p_grad = p_ab->a_grad;
|
|
int *p_idsf, *p_addwl, *p_idwl1, *p_idwl2;
|
|
const unsigned char *p_t;
|
|
|
|
/* Calculate Gradient Curve */
|
|
tmp = grad_qu_h - grad_qu_l;
|
|
|
|
for (iqu = 0; iqu < grad_qu_h; iqu++) {
|
|
p_grad[iqu] = -grad_os_l;
|
|
}
|
|
for (iqu = grad_qu_h; iqu < hqu; iqu++) {
|
|
p_grad[iqu] = -grad_os_h;
|
|
}
|
|
|
|
if (tmp > 0) {
|
|
p_t = gaa_resamp_grad_ldac[tmp-1];
|
|
|
|
tmp = grad_os_h - grad_os_l;
|
|
if (tmp > 0) {
|
|
tmp = tmp-1;
|
|
for (iqu = grad_qu_l; iqu < grad_qu_h; iqu++) {
|
|
p_grad[iqu] -= ((*p_t++ * tmp) >> 8) + 1;
|
|
}
|
|
}
|
|
else if (tmp < 0) {
|
|
tmp = -tmp-1;
|
|
for (iqu = grad_qu_l; iqu < grad_qu_h; iqu++) {
|
|
p_grad[iqu] += ((*p_t++ * tmp) >> 8) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Calculate Bits */
|
|
for (ich = 0; ich < nchs; ich++) {
|
|
p_ac = p_ab->ap_ac[ich];
|
|
p_idsf = p_ac->a_idsf;
|
|
p_addwl = p_ac->a_addwl;
|
|
p_idwl1 = p_ac->a_idwl1;
|
|
p_idwl2 = p_ac->a_idwl2;
|
|
|
|
if (grad_mode == LDAC_MODE_0) {
|
|
for (iqu = 0; iqu < hqu; iqu++) {
|
|
idwl1 = p_idsf[iqu] + p_grad[iqu];
|
|
if (idwl1 < LDAC_MINIDWL1) {
|
|
idwl1 = LDAC_MINIDWL1;
|
|
}
|
|
idwl2 = 0;
|
|
if (idwl1 > LDAC_MAXIDWL1) {
|
|
idwl2 = idwl1 - LDAC_MAXIDWL1;
|
|
if (idwl2 > LDAC_MAXIDWL2) {
|
|
idwl2 = LDAC_MAXIDWL2;
|
|
}
|
|
idwl1 = LDAC_MAXIDWL1;
|
|
}
|
|
p_idwl1[iqu] = idwl1;
|
|
p_idwl2[iqu] = idwl2;
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_1) {
|
|
for (iqu = 0; iqu < hqu; iqu++) {
|
|
idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (idwl1 > 0) {
|
|
idwl1 = idwl1 >> 1;
|
|
}
|
|
if (idwl1 < LDAC_MINIDWL1) {
|
|
idwl1 = LDAC_MINIDWL1;
|
|
}
|
|
idwl2 = 0;
|
|
if (idwl1 > LDAC_MAXIDWL1) {
|
|
idwl2 = idwl1 - LDAC_MAXIDWL1;
|
|
if (idwl2 > LDAC_MAXIDWL2) {
|
|
idwl2 = LDAC_MAXIDWL2;
|
|
}
|
|
idwl1 = LDAC_MAXIDWL1;
|
|
}
|
|
p_idwl1[iqu] = idwl1;
|
|
p_idwl2[iqu] = idwl2;
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_2) {
|
|
for (iqu = 0; iqu < hqu; iqu++) {
|
|
idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (idwl1 > 0) {
|
|
idwl1 = (idwl1*3) >> 3;
|
|
}
|
|
if (idwl1 < LDAC_MINIDWL1) {
|
|
idwl1 = LDAC_MINIDWL1;
|
|
}
|
|
idwl2 = 0;
|
|
if (idwl1 > LDAC_MAXIDWL1) {
|
|
idwl2 = idwl1 - LDAC_MAXIDWL1;
|
|
if (idwl2 > LDAC_MAXIDWL2) {
|
|
idwl2 = LDAC_MAXIDWL2;
|
|
}
|
|
idwl1 = LDAC_MAXIDWL1;
|
|
}
|
|
p_idwl1[iqu] = idwl1;
|
|
p_idwl2[iqu] = idwl2;
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_3) {
|
|
for (iqu = 0; iqu < hqu; iqu++) {
|
|
idwl1 = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (idwl1 > 0) {
|
|
idwl1 = idwl1 >> 2;
|
|
}
|
|
if (idwl1 < LDAC_MINIDWL1) {
|
|
idwl1 = LDAC_MINIDWL1;
|
|
}
|
|
idwl2 = 0;
|
|
if (idwl1 > LDAC_MAXIDWL1) {
|
|
idwl2 = idwl1 - LDAC_MAXIDWL1;
|
|
if (idwl2 > LDAC_MAXIDWL2) {
|
|
idwl2 = LDAC_MAXIDWL2;
|
|
}
|
|
idwl1 = LDAC_MAXIDWL1;
|
|
}
|
|
p_idwl1[iqu] = idwl1;
|
|
p_idwl2[iqu] = idwl2;
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
}
|
|
}
|
|
}
|
|
|
|
return nbits;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Calculate Bits for Audio Block
|
|
***************************************************************************************************/
|
|
static int encode_audio_block_b_ldac(
|
|
AB *p_ab,
|
|
int nadjqus)
|
|
{
|
|
AC *p_ac;
|
|
int ich, iqu;
|
|
int nchs = p_ab->blk_nchs;
|
|
int nqus = min_ldac(LDAC_MAXNADJQUS, p_ab->nqus);
|
|
int nbits = 0;
|
|
int idsp, idwl1, idwl2;
|
|
int *p_idwl1, *p_idwl2, *p_tmp;
|
|
|
|
/* Calculate Bits */
|
|
for (ich = 0; ich < nchs; ich++) {
|
|
p_ac = p_ab->ap_ac[ich];
|
|
p_idwl1 = p_ac->a_idwl1;
|
|
p_idwl2 = p_ac->a_idwl2;
|
|
p_tmp = p_ac->a_tmp;
|
|
|
|
for (iqu = 0; iqu < nqus; iqu++) {
|
|
idwl1 = p_tmp[iqu];
|
|
if (iqu < nadjqus) {
|
|
idwl1++;
|
|
}
|
|
idwl2 = 0;
|
|
if (idwl1 > LDAC_MAXIDWL1) {
|
|
idwl2 = idwl1 - LDAC_MAXIDWL1;
|
|
if (idwl2 > LDAC_MAXIDWL2) {
|
|
idwl2 = LDAC_MAXIDWL2;
|
|
}
|
|
idwl1 = LDAC_MAXIDWL1;
|
|
}
|
|
p_idwl1[iqu] = idwl1;
|
|
p_idwl2[iqu] = idwl2;
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
}
|
|
}
|
|
|
|
return nbits;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Decrease Lower Offset of Gradient Curve
|
|
***************************************************************************************************/
|
|
static int decrease_offset_low_ldac(
|
|
AB *p_ab,
|
|
int limit,
|
|
int *p_nbits_spec)
|
|
{
|
|
int ncalls = 0;
|
|
int nqus = p_ab->nqus;
|
|
int grad_os_l = p_ab->grad_os_l;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int step = limit - grad_os_l;
|
|
int a_checked[LDAC_MAXGRADOS+1];
|
|
|
|
if (*p_nbits_spec > nbits_avail) {
|
|
memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int));
|
|
|
|
while (grad_os_l < limit) {
|
|
if (step > 1) {
|
|
step = (step+1)/2;
|
|
}
|
|
|
|
if (*p_nbits_spec < nbits_avail) {
|
|
grad_os_l -= step;
|
|
if (grad_os_l < 0) {
|
|
grad_os_l += step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_l]) {
|
|
grad_os_l += step;
|
|
break;
|
|
}
|
|
}
|
|
else if (*p_nbits_spec > nbits_avail) {
|
|
grad_os_l += step;
|
|
if (grad_os_l > LDAC_MAXGRADOS) {
|
|
grad_os_l -= step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_l]) {
|
|
grad_os_l -= step;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
|
|
p_ab->grad_os_l = grad_os_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
a_checked[grad_os_l] = *p_nbits_spec;
|
|
ncalls++;
|
|
}
|
|
|
|
while ((*p_nbits_spec > nbits_avail) && (grad_os_l < limit)) {
|
|
p_ab->grad_os_l = ++grad_os_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
ncalls++;
|
|
}
|
|
}
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Decrease Higher Offset of Gradient Curve
|
|
***************************************************************************************************/
|
|
static int decrease_offset_high_ldac(
|
|
AB *p_ab,
|
|
int *p_nbits_spec)
|
|
{
|
|
int ncalls = 0;
|
|
int nqus = p_ab->nqus;
|
|
int grad_os_h = p_ab->grad_os_h;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int step = LDAC_MAXGRADOS - grad_os_h;
|
|
int a_checked[LDAC_MAXGRADOS+1];
|
|
|
|
if (*p_nbits_spec > nbits_avail) {
|
|
memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int));
|
|
|
|
while (grad_os_h < LDAC_MAXGRADOS) {
|
|
if (step > 1) {
|
|
step = (step+1)/2;
|
|
}
|
|
|
|
if (*p_nbits_spec < nbits_avail) {
|
|
grad_os_h -= step;
|
|
if (grad_os_h < 0) {
|
|
grad_os_h += step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_h]) {
|
|
grad_os_h += step;
|
|
break;
|
|
}
|
|
}
|
|
else if (*p_nbits_spec > nbits_avail) {
|
|
grad_os_h += step;
|
|
if (grad_os_h > LDAC_MAXGRADOS) {
|
|
grad_os_h -= step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_h]) {
|
|
grad_os_h -= step;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
|
|
p_ab->grad_os_h = grad_os_h;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
a_checked[grad_os_h] = *p_nbits_spec;
|
|
ncalls++;
|
|
}
|
|
|
|
while ((*p_nbits_spec > nbits_avail) && (grad_os_h < LDAC_MAXGRADOS)) {
|
|
p_ab->grad_os_h = ++grad_os_h;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
ncalls++;
|
|
}
|
|
}
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Increase Lower Offset of Gradient Curve
|
|
***************************************************************************************************/
|
|
static int increase_offset_low_ldac(
|
|
AB *p_ab,
|
|
int *p_nbits_spec)
|
|
{
|
|
int ncalls = 0;
|
|
int nqus = p_ab->nqus;
|
|
int grad_os_l = p_ab->grad_os_l;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int step = grad_os_l;
|
|
int a_checked[LDAC_MAXGRADOS+1];
|
|
|
|
memset(a_checked, 0, (LDAC_MAXGRADOS+1)*sizeof(int));
|
|
|
|
while (grad_os_l > 0) {
|
|
if (step > 1) {
|
|
step = (step+1)/2;
|
|
}
|
|
|
|
if (*p_nbits_spec < nbits_avail) {
|
|
grad_os_l -= step;
|
|
if (grad_os_l < 0) {
|
|
grad_os_l += step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_l]) {
|
|
grad_os_l += step;
|
|
break;
|
|
}
|
|
}
|
|
else if (*p_nbits_spec > nbits_avail) {
|
|
grad_os_l += step;
|
|
if (grad_os_l > LDAC_MAXGRADOS) {
|
|
grad_os_l -= step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_os_l]) {
|
|
grad_os_l -= step;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
|
|
p_ab->grad_os_l = grad_os_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
a_checked[grad_os_l] = *p_nbits_spec;
|
|
ncalls++;
|
|
}
|
|
|
|
while ((*p_nbits_spec > nbits_avail) && (grad_os_l < LDAC_MAXGRADOS)) {
|
|
p_ab->grad_os_l = ++grad_os_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
ncalls++;
|
|
}
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Increase Lower QU of Gradient Curve
|
|
***************************************************************************************************/
|
|
static int increase_qu_low_ldac(
|
|
AB *p_ab,
|
|
int *p_nbits_spec)
|
|
{
|
|
int ncalls = 0;
|
|
int nqus = p_ab->nqus;
|
|
int grad_qu_l = p_ab->grad_qu_l;
|
|
int grad_qu_h = p_ab->grad_qu_h;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int step = grad_qu_h - grad_qu_l;
|
|
int a_checked[LDAC_DEFGRADQUH+1];
|
|
|
|
memset(a_checked, 0, (LDAC_DEFGRADQUH+1)*sizeof(int));
|
|
|
|
while ((grad_qu_l > 0) && (grad_qu_l < LDAC_DEFGRADQUH)) {
|
|
if (step > 1) {
|
|
step = (step+1)/2;
|
|
}
|
|
|
|
if (*p_nbits_spec < nbits_avail) {
|
|
grad_qu_l += step;
|
|
if (grad_qu_l > LDAC_DEFGRADQUH) {
|
|
grad_qu_l -= step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_qu_l]) {
|
|
grad_qu_l -= step;
|
|
break;
|
|
}
|
|
}
|
|
else if (*p_nbits_spec > nbits_avail) {
|
|
grad_qu_l -= step;
|
|
if (grad_qu_l < 0) {
|
|
grad_qu_l += step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_qu_l]) {
|
|
grad_qu_l += step;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
|
|
p_ab->grad_qu_l = grad_qu_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
a_checked[grad_qu_l] = *p_nbits_spec;
|
|
ncalls++;
|
|
}
|
|
|
|
while ((*p_nbits_spec > nbits_avail) && (grad_qu_l <= LDAC_DEFGRADQUH)) {
|
|
p_ab->grad_qu_l = --grad_qu_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
ncalls++;
|
|
}
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Increase Lower QU of Gradient Curve
|
|
***************************************************************************************************/
|
|
static int increase_qu_low_0_ldac(
|
|
AB *p_ab,
|
|
int *p_nbits_spec)
|
|
{
|
|
int ncalls = 0;
|
|
int nqus = p_ab->nqus;
|
|
int grad_qu_l = p_ab->grad_qu_l;
|
|
int grad_qu_h = p_ab->grad_qu_h;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int step = grad_qu_h - grad_qu_l;
|
|
int a_checked[LDAC_MAXGRADQU+1];
|
|
|
|
memset(a_checked, 0, (LDAC_MAXGRADQU+1)*sizeof(int));
|
|
|
|
while ((grad_qu_l > 0) && (grad_qu_l < grad_qu_h)) {
|
|
if (step > 1) {
|
|
step = step/2;
|
|
}
|
|
|
|
if (*p_nbits_spec < nbits_avail) {
|
|
grad_qu_l += step;
|
|
if (grad_qu_l >= grad_qu_h) {
|
|
grad_qu_l -= step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_qu_l]) {
|
|
grad_qu_l -= step;
|
|
break;
|
|
}
|
|
}
|
|
else if (*p_nbits_spec > nbits_avail) {
|
|
grad_qu_l -= step;
|
|
if (grad_qu_l < 0) {
|
|
grad_qu_l += step;
|
|
break;
|
|
}
|
|
else if (a_checked[grad_qu_l]) {
|
|
grad_qu_l += step;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
|
|
p_ab->grad_qu_l = grad_qu_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
a_checked[grad_qu_l] = *p_nbits_spec;
|
|
ncalls++;
|
|
}
|
|
|
|
while ((*p_nbits_spec > nbits_avail) && (grad_qu_l > 0)) {
|
|
p_ab->grad_qu_l = --grad_qu_l;
|
|
*p_nbits_spec = encode_audio_block_a_ldac(p_ab, nqus);
|
|
ncalls++;
|
|
}
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Subfunction: Adjust Remaining Bits
|
|
***************************************************************************************************/
|
|
static int adjust_remain_bits_ldac(
|
|
AB *p_ab,
|
|
int *p_nbits_spec,
|
|
int *p_nadjqus)
|
|
{
|
|
int ich, iqu;
|
|
int ncalls = 0;
|
|
int nbits_fix, nbits_spec;
|
|
int nbits_avail = p_ab->nbits_avail;
|
|
int idsp, idwl1, idwl2, tmp;
|
|
int step = LDAC_MAXNADJQUS>>1;
|
|
int nadjqus = LDAC_MAXNADJQUS>>1;
|
|
int nchs = p_ab->blk_nchs;
|
|
int nqus = min_ldac(LDAC_MAXNADJQUS, p_ab->nqus);
|
|
int grad_mode = p_ab->grad_mode;
|
|
int *p_grad = p_ab->a_grad;
|
|
int *p_idsf, *p_addwl, *p_idwl1, *p_idwl2, *p_tmp;
|
|
AC *p_ac;
|
|
|
|
nbits_fix = 0;
|
|
for (ich = 0; ich < nchs; ich++){
|
|
p_ac = p_ab->ap_ac[ich];
|
|
p_idsf = p_ac->a_idsf;
|
|
p_addwl = p_ac->a_addwl;
|
|
p_idwl1 = p_ac->a_idwl1;
|
|
p_idwl2 = p_ac->a_idwl2;
|
|
p_tmp = p_ac->a_tmp;
|
|
|
|
if (grad_mode == LDAC_MODE_0) {
|
|
for (iqu = 0; iqu < nqus; iqu++) {
|
|
idwl1 = p_idwl1[iqu];
|
|
idwl2 = p_idwl2[iqu];
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
tmp = p_idsf[iqu] + p_grad[iqu];
|
|
if (tmp < LDAC_MINIDWL1) {
|
|
tmp = LDAC_MINIDWL1;
|
|
}
|
|
p_tmp[iqu] = tmp;
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_1) {
|
|
for (iqu = 0; iqu < nqus; iqu++) {
|
|
idwl1 = p_idwl1[iqu];
|
|
idwl2 = p_idwl2[iqu];
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (tmp > 0) {
|
|
tmp = tmp >> 1;
|
|
}
|
|
if (tmp < LDAC_MINIDWL1) {
|
|
tmp = LDAC_MINIDWL1;
|
|
}
|
|
p_tmp[iqu] = tmp;
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_2) {
|
|
for (iqu = 0; iqu < nqus; iqu++) {
|
|
idwl1 = p_idwl1[iqu];
|
|
idwl2 = p_idwl2[iqu];
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (tmp > 0) {
|
|
tmp = (tmp*3) >> 3;
|
|
}
|
|
if (tmp < LDAC_MINIDWL1) {
|
|
tmp = LDAC_MINIDWL1;
|
|
}
|
|
p_tmp[iqu] = tmp;
|
|
}
|
|
}
|
|
else if (grad_mode == LDAC_MODE_3) {
|
|
for (iqu = 0; iqu < nqus; iqu++) {
|
|
idwl1 = p_idwl1[iqu];
|
|
idwl2 = p_idwl2[iqu];
|
|
idsp = ga_idsp_ldac[iqu];
|
|
nbits_fix += gaa_ndim_wls_ldac[idsp][idwl1] + ga_wl_ldac[idwl2] * ga_nsps_ldac[iqu];
|
|
tmp = p_idsf[iqu] + p_grad[iqu] + p_addwl[iqu];
|
|
if (tmp > 0) {
|
|
tmp = tmp >> 2;
|
|
}
|
|
if (tmp < LDAC_MINIDWL1) {
|
|
tmp = LDAC_MINIDWL1;
|
|
}
|
|
p_tmp[iqu] = tmp;
|
|
}
|
|
}
|
|
}
|
|
|
|
nbits_fix = *p_nbits_spec - nbits_fix;
|
|
nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus);
|
|
ncalls++;
|
|
|
|
while (step > 1) {
|
|
step >>= 1;
|
|
|
|
if (nbits_spec < nbits_avail) {
|
|
nadjqus += step;
|
|
if (nadjqus > p_ab->nqus) {
|
|
nadjqus = p_ab->nqus;
|
|
}
|
|
}
|
|
else if (nbits_spec > nbits_avail) {
|
|
nadjqus -= step;
|
|
}
|
|
else {
|
|
if (nadjqus > p_ab->nqus) {
|
|
nadjqus = p_ab->nqus;
|
|
}
|
|
break;
|
|
}
|
|
nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus);
|
|
ncalls++;
|
|
}
|
|
|
|
if (nbits_spec > nbits_avail) {
|
|
nadjqus--;
|
|
nbits_spec = nbits_fix + encode_audio_block_b_ldac(p_ab, nadjqus);
|
|
ncalls++;
|
|
}
|
|
*p_nadjqus = nadjqus;
|
|
*p_nbits_spec = nbits_spec;
|
|
|
|
return ncalls;
|
|
}
|
|
|
|
/***************************************************************************************************
|
|
Allocate Bits
|
|
***************************************************************************************************/
|
|
#define LDAC_UPPER_NOISE_LEVEL 20
|
|
#define LDAC_LOWER_NOISE_LEVEL 5
|
|
|
|
DECLFUNC int alloc_bits_ldac(
|
|
AB *p_ab)
|
|
{
|
|
int nbits_avail, nbits_side = 0, nbits_spec = 0;
|
|
int nbits_ab = p_ab->nbits_ab;
|
|
|
|
nbits_side = encode_side_info_ldac(p_ab);
|
|
p_ab->nbits_avail = nbits_avail = nbits_ab - nbits_side;
|
|
|
|
nbits_spec = encode_audio_block_a_ldac(p_ab, p_ab->nqus);
|
|
|
|
if (nbits_spec > nbits_avail) {
|
|
if (p_ab->grad_mode == LDAC_MODE_0) {
|
|
decrease_offset_low_ldac(p_ab, LDAC_UPPER_NOISE_LEVEL, &nbits_spec);
|
|
|
|
decrease_offset_high_ldac(p_ab, &nbits_spec);
|
|
|
|
decrease_offset_low_ldac(p_ab, LDAC_MAXGRADOS, &nbits_spec);
|
|
}
|
|
else {
|
|
decrease_offset_low_ldac(p_ab, LDAC_MAXGRADOS, &nbits_spec);
|
|
}
|
|
|
|
while ((nbits_spec > nbits_avail) && (p_ab->nbands > LDAC_BAND_OFFSET)) {
|
|
p_ab->nbands--;
|
|
p_ab->nqus = ga_nqus_ldac[p_ab->nbands];
|
|
|
|
nbits_side = encode_side_info_ldac(p_ab);
|
|
p_ab->nbits_avail = nbits_avail = nbits_ab - nbits_side;
|
|
|
|
nbits_spec = encode_audio_block_a_ldac(p_ab, p_ab->nqus);
|
|
}
|
|
}
|
|
|
|
if (nbits_spec < nbits_avail) {
|
|
if (p_ab->grad_mode == LDAC_MODE_0) {
|
|
increase_offset_low_ldac(p_ab, &nbits_spec);
|
|
|
|
increase_qu_low_0_ldac(p_ab, &nbits_spec);
|
|
}
|
|
else {
|
|
increase_offset_low_ldac(p_ab, &nbits_spec);
|
|
|
|
increase_qu_low_ldac(p_ab, &nbits_spec);
|
|
}
|
|
}
|
|
|
|
p_ab->nadjqus = 0;
|
|
adjust_remain_bits_ldac(p_ab, &nbits_spec, &p_ab->nadjqus);
|
|
|
|
if (nbits_spec > nbits_avail) {
|
|
*p_ab->p_error_code = LDAC_ERR_BIT_ALLOCATION;
|
|
return LDAC_FALSE;
|
|
}
|
|
p_ab->nbits_spec = nbits_spec;
|
|
p_ab->nbits_used = nbits_spec + nbits_side;
|
|
|
|
|
|
return LDAC_TRUE;
|
|
}
|
|
|
|
|