/*
* Copyright (C) 2003 - 2017 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"
/***************************************************************************************************
Calculate Bits for Band Info
***************************************************************************************************/
static int encode_band_info_ldac(
__attribute__((unused)) AB *p_ab)
{
int nbits;
nbits = LDAC_NBANDBITS + LDAC_FLAGBITS;
return nbits;
}
/***************************************************************************************************
Calculate Bits for Gradient Data
***************************************************************************************************/
static int encode_gradient_ldac(
AB *p_ab)
{
int nbits;
if (p_ab->grad_mode == LDAC_MODE_0) {
nbits = LDAC_GRADMODEBITS + LDAC_GRADQU0BITS*2 + LDAC_GRADOSBITS*2 + LDAC_NADJQUBITS;
}
else {
nbits = LDAC_GRADMODEBITS + LDAC_GRADQU1BITS + LDAC_GRADOSBITS + LDAC_NADJQUBITS;
}
return nbits;
}
/***************************************************************************************************
Subfunction: Get Index of Minimum Value
***************************************************************************************************/
__inline static int get_minimum_id_ldac(
int *p_nbits,
int n)
{
int i;
int id, nbits;
id = 0;
nbits = p_nbits[0];
for (i = 1; i < n; i++) {
if (nbits > p_nbits[i]) {
id = i;
nbits = p_nbits[i];
}
}
return id;
}
typedef struct {
int bitlen;
int offset;
int weight;
} SFCINF;
/***************************************************************************************************
Subfunction: Calculate Bits for Scale Factor Data - Mode 0
***************************************************************************************************/
static const unsigned char sa_bitlen_maxdif_0_ldac[LDAC_NIDSF] = {
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
};
static int encode_scale_factor_0_ldac(
AC *p_ac,
SFCINF *p_sfcinf)
{
HCENC *p_hcsf;
int iqu, iwt;
int nqus = p_ac->p_ab->nqus;
int nbits = LDAC_MAXBITNUM;
int bitlen, vmin, vmax, val0, val1;
int *p_idsf = p_ac->a_idsf;
int *p_idsf_dif = p_ac->a_tmp;
const unsigned char *p_tbl;
for (iwt = 0; iwt < LDAC_NSFCWTBL; iwt++) {
p_tbl = gaa_sfcwgt_ldac[iwt];
vmin = vmax = val0 = p_idsf[0] + p_tbl[0];
for (iqu = 1; iqu < nqus; iqu++) {
val1 = p_idsf[iqu] + p_tbl[iqu];
if (vmin > val1) {
vmin = val1;
}
if (vmax < val1) {
vmax = val1;
}
p_idsf_dif[iqu] = val1 - val0;
val0 = val1;
}
val1 = bitlen = sa_bitlen_maxdif_0_ldac[(vmax-vmin)>>1];
p_hcsf = ga_hcenc_sf0_ldac + (bitlen-LDAC_MINSFCBLEN_0);
for (iqu = 1; iqu < nqus; iqu++) {
val0 = p_idsf_dif[iqu] & p_hcsf->mask;
val1 += hc_len_ldac(p_hcsf->p_tbl+val0);
}
if (nbits > val1) {
p_sfcinf->bitlen = bitlen;
p_sfcinf->offset = vmin;
p_sfcinf->weight = iwt;
nbits = val1;
}
}
nbits += LDAC_SFCBLENBITS + LDAC_IDSFBITS + LDAC_SFCWTBLBITS;
return nbits;
}
/***************************************************************************************************
Subfunction: Calculate Bits for Scale Factor Data - Mode 1
***************************************************************************************************/
static const unsigned char sa_bitlen_maxdif_1_ldac[LDAC_NIDSF] = {
2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
};
static int encode_scale_factor_1_ldac(
AC *p_ac,
SFCINF *p_sfcinf)
{
int iqu, iwt;
int nqus = p_ac->p_ab->nqus;
int nbits = LDAC_MAXBITNUM;
int bitlen, vmin, vmax, val;
int *p_idsf = p_ac->a_idsf;
const unsigned char *p_tbl;
for (iwt = 0; iwt < LDAC_NSFCWTBL; iwt++) {
p_tbl = gaa_sfcwgt_ldac[iwt];
vmin = vmax = p_idsf[0] + p_tbl[0];
for (iqu = 1; iqu < nqus; iqu++) {
val = p_idsf[iqu] + p_tbl[iqu];
if (vmin > val) {
vmin = val;
}
if (vmax < val) {
vmax = val;
}
}
bitlen = sa_bitlen_maxdif_1_ldac[(vmax-vmin)>>1];
if (bitlen > 4) {
val = LDAC_SFCBLENBITS;
}
else {
val = LDAC_SFCBLENBITS + LDAC_IDSFBITS + LDAC_SFCWTBLBITS;
}
val += bitlen * nqus;
if (nbits > val) {
p_sfcinf->bitlen = bitlen;
p_sfcinf->offset = vmin;
p_sfcinf->weight = iwt;
nbits = val;
}
}
return nbits;
}
/***************************************************************************************************
Subfunction: Calculate Bits for Scale Factor Data - Mode 2
***************************************************************************************************/
static const unsigned char sa_bitlen_absmax_2_ldac[LDAC_NIDSF>>1] = {
2, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
};
static int encode_scale_factor_2_ldac(
AC *p_ac,
SFCINF *p_sfcinf)
{
HCENC *p_hcsf;
int iqu;
int nqus = p_ac->p_ab->nqus;
int nbits, bitlen, vmax, val;
int *p_idsf_dif = p_ac->a_tmp;
p_idsf_dif[0] = p_ac->a_idsf[0] - p_ac->p_ab->ap_ac[0]->a_idsf[0];
vmax = abs(p_idsf_dif[0]);
for (iqu = 1; iqu < nqus; iqu++) {
p_idsf_dif[iqu] = p_ac->a_idsf[iqu] - p_ac->p_ab->ap_ac[0]->a_idsf[iqu];
val = abs(p_idsf_dif[iqu]);
if (vmax < val) {
vmax = val;
}
}
nbits = LDAC_SFCBLENBITS;
bitlen = sa_bitlen_absmax_2_ldac[vmax>>1];
p_hcsf = ga_hcenc_sf1_ldac + (bitlen-LDAC_MINSFCBLEN_2);
for (iqu = 0; iqu < nqus; iqu++) {
val = p_idsf_dif[iqu] & p_hcsf->mask;
nbits += hc_len_ldac(p_hcsf->p_tbl+val);
}
p_sfcinf->bitlen = bitlen;
p_sfcinf->offset = 0;
p_sfcinf->weight = 0;
return nbits;
}
/***************************************************************************************************
Calculate Bits for Scale Factor Data
***************************************************************************************************/
static int encode_scale_factor_ldac(
AC *p_ac)
{
SFCINF a_sfcinf[LDAC_NSFCMODE];
SFCINF *p_sfcinf;
int nbits, sfc_mode;
int a_nbits[LDAC_NSFCMODE];
if (p_ac->ich == 0) {
a_nbits[LDAC_MODE_0] = encode_scale_factor_0_ldac(p_ac, a_sfcinf+LDAC_MODE_0);
a_nbits[LDAC_MODE_1] = encode_scale_factor_1_ldac(p_ac, a_sfcinf+LDAC_MODE_1);
}
else {
a_nbits[LDAC_MODE_0] = encode_scale_factor_0_ldac(p_ac, a_sfcinf+LDAC_MODE_0);
a_nbits[LDAC_MODE_1] = encode_scale_factor_2_ldac(p_ac, a_sfcinf+LDAC_MODE_1);
}
p_ac->sfc_mode = sfc_mode = get_minimum_id_ldac(a_nbits, LDAC_MODE_1+1);
p_sfcinf = a_sfcinf + sfc_mode;
p_ac->sfc_bitlen = p_sfcinf->bitlen;
p_ac->sfc_offset = p_sfcinf->offset;
p_ac->sfc_weight = p_sfcinf->weight;
nbits = a_nbits[sfc_mode] + LDAC_SFCMODEBITS;
return nbits;
}
/***************************************************************************************************
Calculate Bits for Side Information (Band Info, Gradient Data & Scale Factor Data)
***************************************************************************************************/
DECLFUNC int encode_side_info_ldac(
AB *p_ab)
{
AC *p_ac;
int ich;
int nchs = p_ab->blk_nchs;
int nbits, nbits_band, nbits_grad, nbits_scfc = 0;
p_ab->nbits_band = nbits_band = encode_band_info_ldac(p_ab);
p_ab->nbits_grad = nbits_grad = encode_gradient_ldac(p_ab);
for (ich = 0; ich < nchs; ich++) {
p_ac = p_ab->ap_ac[ich];
nbits_scfc += encode_scale_factor_ldac(p_ac);
calc_add_word_length_ldac(p_ac);
}
p_ab->nbits_scfc = nbits_scfc;
nbits = nbits_band + nbits_grad + nbits_scfc;
return nbits;
}
/***************************************************************************************************
Calculate Additional Word Length Data
***************************************************************************************************/
DECLFUNC void calc_add_word_length_ldac(
AC *p_ac)
{
int iqu;
int nqus = p_ac->p_ab->nqus;
int dif;
int *p_idsf = p_ac->a_idsf;
int *p_addwl = p_ac->a_addwl;
clear_data_ldac(p_addwl, LDAC_MAXNQUS*sizeof(int));
if (p_ac->p_ab->grad_mode != LDAC_MODE_0) {
for (iqu = 1; iqu < nqus; iqu++) {
dif = p_idsf[iqu] - p_idsf[iqu-1];
if (dif > 0) {
if (dif > 5) {
p_addwl[iqu] += 5;
}
else if (dif > 4) {
p_addwl[iqu] += 4;
}
else if (dif > 3) {
p_addwl[iqu] += 3;
}
else if (dif > 2) {
p_addwl[iqu] += 2;
}
else if (dif > 1) {
p_addwl[iqu] += 1;
}
}
else {
if (dif < -5) {
p_addwl[iqu-1] += 5;
}
else if (dif < -4) {
p_addwl[iqu-1] += 4;
}
else if (dif < -3) {
p_addwl[iqu-1] += 3;
}
else if (dif < -2) {
p_addwl[iqu-1] += 2;
}
else if (dif < -1) {
p_addwl[iqu-1] += 1;
}
}
}
}
return;
}