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