src/bitalloc_sub_ldac.c

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