xref: /aosp_15_r20/external/libldac/src/bitalloc_ldac.c (revision aef9bcd9217ad2365ebc8e70efaf94b64e04df14)

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