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