wrapper/libxaac-mirror
1
0
Fork 0
mirror of https://github.com/ittiam-systems/libxaac.git synced 2026-04-02 20:30:47 +07:00
Code Issues Projects Releases Packages Wiki Activity Actions
libxaac-mirror/encoder/ixheaace_dynamic_bits.c
Nikhil Bhavikatti 797de4d1e9
USAC along with DRC support for libxaac encoder (#37)
2023-07-14 13:04:15 +05:30

598 lines
20 KiB
C
Raw Permalink Blame History

/******************************************************************************
* *
* Copyright (C) 2023 The Android Open Source Project
*
* 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.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "ixheaac_type_def.h"
#include "ixheaac_constants.h"
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_tables.h"
#include "impd_drc_api.h"
#include "ixheaace_api.h"
#include "ixheaace_aac_constants.h"
#include "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"
#include "ixheaace_psy_const.h"
#include "ixheaace_tns.h"
#include "ixheaace_tns_params.h"
#include "ixheaace_rom.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_bitbuffer.h"
#include "ixheaace_bits_count.h"
#include "ixheaace_dynamic_bits.h"
#include "ixheaace_common_utils.h"
static WORD32 ia_enhaacplus_enc_calc_side_info_bits(WORD32 sfb_cnt, WORD32 block_type) {
WORD32 seg_len_bits = (block_type == SHORT_WINDOW ? 3 : 5);
WORD32 escape_val = (block_type == SHORT_WINDOW ? 7 : 31);
WORD32 side_info_bits, tmp;
side_info_bits = CODE_BCK_BITS;
tmp = sfb_cnt;
while (tmp >= 0) {
side_info_bits += seg_len_bits;
tmp -= escape_val;
}
return (side_info_bits);
}
static VOID ia_enhaacplus_enc_build_bit_look_up(
const WORD16 *ptr_quant_spec, const WORD32 max_sfb, const WORD32 *ptr_sfb_offset,
const UWORD16 *sfb_max,
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
ixheaace_section_info *pstr_section_info, ixheaace_huffman_tables *pstr_huffman_tbl,
WORD32 aot) {
WORD8 i;
for (i = 0; i < max_sfb; i++) {
WORD32 sfb_width, max_val;
pstr_section_info[i].sfb_cnt = 1;
pstr_section_info[i].sfb_start = i;
switch (aot) {
case AOT_AAC_LC:
case AOT_SBR:
case AOT_PS:
pstr_section_info[i].section_bits = INVALID_BITCOUNT_LC;
break;
case AOT_AAC_LD:
case AOT_AAC_ELD:
pstr_section_info[i].section_bits = INVALID_BITCOUNT_LD;
break;
}
pstr_section_info[i].code_book = -1;
sfb_width = ptr_sfb_offset[i + 1] - ptr_sfb_offset[i];
max_val = sfb_max[i];
ia_enhaacplus_enc_bitcount(ptr_quant_spec + ptr_sfb_offset[i], sfb_width, max_val,
bit_look_up[i], pstr_huffman_tbl, aot);
}
}
static WORD32 ia_enhaacplus_enc_find_best_book(const WORD32 *ptr_bit_cnt, WORD8 *ptr_codebook,
WORD32 aot) {
WORD32 min_bits = 0, temp1, temp2;
WORD8 temp_book = CODE_BCK_ESC_NDX;
WORD8 j;
switch (aot) {
case AOT_AAC_LC:
case AOT_SBR:
case AOT_PS:
min_bits = INVALID_BITCOUNT_LC;
break;
case AOT_AAC_LD:
case AOT_AAC_ELD:
min_bits = INVALID_BITCOUNT_LD;
break;
}
for (j = 0; j <= CODE_BCK_ESC_NDX; j += 2) {
temp1 = *ptr_bit_cnt++;
temp2 = *ptr_bit_cnt++;
if (temp1 < min_bits) {
min_bits = temp1;
temp_book = j;
}
if (temp2 < min_bits) {
min_bits = temp2;
temp_book = j + 1;
}
}
*ptr_codebook = temp_book;
return min_bits;
}
static WORD32 ia_enhaacplus_enc_find_min_merge_bits(const WORD32 *ptr_bit_cnt1,
const WORD32 *ptr_bit_cnt2, WORD32 aot) {
WORD32 min_bits = 0, j, temp1, temp2, temp3, temp4;
switch (aot) {
case AOT_AAC_LC:
case AOT_SBR:
case AOT_PS:
min_bits = INVALID_BITCOUNT_LC;
break;
case AOT_AAC_LD:
case AOT_AAC_ELD:
min_bits = INVALID_BITCOUNT_LD;
break;
}
for (j = CODE_BCK_ESC_NDX; j >= 0; j -= 2) {
temp1 = *ptr_bit_cnt1++;
temp2 = *ptr_bit_cnt2++;
temp3 = *ptr_bit_cnt1++;
temp1 = temp1 + temp2;
min_bits = MIN(temp1, min_bits);
temp4 = *ptr_bit_cnt2++;
temp1 = temp3 + temp4;
min_bits = MIN(temp1, min_bits);
}
return min_bits;
}
static VOID ia_enhaacplus_enc_merge_bit_look_up(WORD32 *ptr_bit_cnt1, const WORD32 *ptr_bit_cnt2,
WORD32 aot) {
WORD32 j, temp1, temp2, temp3, temp4;
WORD32 invalid_bitcnt = 0;
switch (aot) {
case AOT_AAC_LC:
case AOT_SBR:
case AOT_PS:
invalid_bitcnt = INVALID_BITCOUNT_LC;
break;
case AOT_AAC_LD:
case AOT_AAC_ELD:
invalid_bitcnt = INVALID_BITCOUNT_LD;
break;
}
for (j = 0; j <= CODE_BCK_ESC_NDX; j += 2) {
temp1 = ptr_bit_cnt1[j];
temp2 = ptr_bit_cnt2[j];
temp3 = ptr_bit_cnt1[j + 1];
ptr_bit_cnt1[j] = MIN(temp1 + temp2, invalid_bitcnt);
temp4 = ptr_bit_cnt2[j + 1];
ptr_bit_cnt1[j + 1] = MIN(temp3 + temp4, invalid_bitcnt);
}
}
static WORD32 ia_enhaacplus_enc_find_max_merge(
const WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],
const ixheaace_section_info *section, const WORD32 max_sfb, WORD32 *max_ndx) {
WORD32 i, max_merge_gain = 0;
for (i = 0; i + section[i].sfb_cnt < max_sfb; i += section[i].sfb_cnt) {
if (merge_gain_look_up[i] > max_merge_gain) {
max_merge_gain = merge_gain_look_up[i];
*max_ndx = i;
}
}
return (max_merge_gain);
}
static WORD32 ia_enhaacplus_enc_calc_merge_gain(
const ixheaace_section_info *pstr_section_info,
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
const WORD32 *pstr_side_info_tab, const WORD32 idx1, const WORD32 idx2, WORD32 aot) {
WORD32 split_bits;
WORD32 merge_bits;
WORD32 merge_gain;
split_bits = pstr_section_info[idx1].section_bits + pstr_section_info[idx2].section_bits;
merge_bits =
pstr_side_info_tab[pstr_section_info[idx1].sfb_cnt + pstr_section_info[idx2].sfb_cnt] +
ia_enhaacplus_enc_find_min_merge_bits(bit_look_up[idx1], bit_look_up[idx2], aot);
merge_gain = split_bits - merge_bits;
return merge_gain;
}
static VOID ia_enhaacplus_enc_gm_stage0(
ixheaace_section_info *pstr_section,
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
const WORD32 max_sfb, WORD32 aot) {
WORD32 i = 0;
WORD32 invalid_bitcnt = 0;
switch (aot) {
case AOT_AAC_LC:
case AOT_SBR:
case AOT_PS:
invalid_bitcnt = INVALID_BITCOUNT_LC;
break;
case AOT_AAC_LD:
case AOT_AAC_ELD:
invalid_bitcnt = INVALID_BITCOUNT_LD;
break;
}
while (i < max_sfb) {
if (pstr_section[i].section_bits == invalid_bitcnt) {
pstr_section[i].section_bits = (WORD16)ia_enhaacplus_enc_find_best_book(
bit_look_up[i], &(pstr_section[i].code_book), aot);
}
i++;
}
}
static VOID ia_enhaacplus_enc_gm_stage1(
ixheaace_section_info *pstr_section_info,
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
const WORD32 max_sfb, const WORD32 *ptr_side_info_tab, WORD32 aot) {
WORD32 merge_start = 0, merge_end;
do {
for (merge_end = merge_start + 1; merge_end < max_sfb; merge_end++) {
if (pstr_section_info[merge_start].code_book != pstr_section_info[merge_end].code_book) {
break;
}
pstr_section_info[merge_start].sfb_cnt++;
pstr_section_info[merge_start].section_bits += pstr_section_info[merge_end].section_bits;
ia_enhaacplus_enc_merge_bit_look_up(bit_look_up[merge_start], bit_look_up[merge_end], aot);
}
pstr_section_info[merge_start].section_bits +=
(WORD16)ptr_side_info_tab[pstr_section_info[merge_start].sfb_cnt];
pstr_section_info[merge_end - 1].sfb_start = pstr_section_info[merge_start].sfb_start;
merge_start = merge_end;
} while (merge_start < max_sfb);
}
static VOID ia_enhaacplus_enc_gm_stage2(
ixheaace_section_info *pstr_section_info,
WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
const WORD32 max_sfb, const WORD32 *ptr_side_info_tab, WORD32 aot) {
WORD32 i;
for (i = 0; i + pstr_section_info[i].sfb_cnt < max_sfb; i += pstr_section_info[i].sfb_cnt) {
merge_gain_look_up[i] =
ia_enhaacplus_enc_calc_merge_gain(pstr_section_info, bit_look_up, ptr_side_info_tab, i,
i + pstr_section_info[i].sfb_cnt, aot);
}
while (TRUE) {
WORD32 max_merge_gain = 0, max_idx = 0, max_idx_next = 0, max_idx_last = 0;
max_merge_gain = ia_enhaacplus_enc_find_max_merge(merge_gain_look_up, pstr_section_info,
max_sfb, &max_idx);
if (max_merge_gain <= 0) {
break;
}
max_idx_next = max_idx + pstr_section_info[max_idx].sfb_cnt;
pstr_section_info[max_idx].sfb_cnt += pstr_section_info[max_idx_next].sfb_cnt;
pstr_section_info[max_idx].section_bits +=
pstr_section_info[max_idx_next].section_bits - (WORD16)max_merge_gain;
ia_enhaacplus_enc_merge_bit_look_up(bit_look_up[max_idx], bit_look_up[max_idx_next], aot);
if (max_idx != 0) {
max_idx_last = pstr_section_info[max_idx - 1].sfb_start;
merge_gain_look_up[max_idx_last] = ia_enhaacplus_enc_calc_merge_gain(
pstr_section_info, bit_look_up, ptr_side_info_tab, max_idx_last, max_idx, aot);
}
max_idx_next = max_idx + pstr_section_info[max_idx].sfb_cnt;
pstr_section_info[max_idx_next - 1].sfb_start = pstr_section_info[max_idx].sfb_start;
if (max_idx_next < max_sfb) {
merge_gain_look_up[max_idx] = ia_enhaacplus_enc_calc_merge_gain(
pstr_section_info, bit_look_up, ptr_side_info_tab, max_idx, max_idx_next, aot);
}
}
}
static IA_ERRORCODE ia_enhaacplus_enc_noiseless_counter(
ixheaace_section_data *pstr_section_data,
WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],
WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],
const WORD16 *ptr_quant_spec, const UWORD16 *ptr_max_val_in_sfb, const WORD32 *ptr_sfb_offset,
const WORD32 block_type, WORD32 *ptr_side_info_tab_long, WORD32 *ptr_side_info_tab_short,
ixheaace_huffman_tables *pstr_huffman_tbl, WORD32 aot) {
WORD32 grp_idx;
WORD32 *ptr_side_info_tab = 0;
ixheaace_section_info *pstr_section_info;
WORD32 i;
for (i = 0; i < MAXIMUM_SCALE_FACTOR_BAND_LONG; i++) {
memset(bit_look_up[i], 0, (CODE_BCK_ESC_NDX + 1) * sizeof(bit_look_up[0][0]));
}
/* counting previous operations */
switch (block_type) {
case LONG_WINDOW:
case START_WINDOW:
case STOP_WINDOW:
ptr_side_info_tab = ptr_side_info_tab_long;
break;
case SHORT_WINDOW:
ptr_side_info_tab = ptr_side_info_tab_short;
break;
default:
return IA_EXHEAACE_EXE_FATAL_INVALID_BLOCK_TYPE;
}
pstr_section_data->num_of_sections = 0;
pstr_section_data->huffman_bits = 0;
pstr_section_data->side_info_bits = 0;
if (pstr_section_data->max_sfb_per_grp == 0) {
return IA_NO_ERROR;
}
for (grp_idx = 0; grp_idx < pstr_section_data->sfb_cnt;
grp_idx += pstr_section_data->sfb_per_group) {
pstr_section_info = pstr_section_data->section + pstr_section_data->num_of_sections;
ia_enhaacplus_enc_build_bit_look_up(ptr_quant_spec, pstr_section_data->max_sfb_per_grp,
ptr_sfb_offset + grp_idx, ptr_max_val_in_sfb + grp_idx,
bit_look_up, pstr_section_info, pstr_huffman_tbl, aot);
ia_enhaacplus_enc_gm_stage0(pstr_section_info, bit_look_up,
pstr_section_data->max_sfb_per_grp, aot);
ia_enhaacplus_enc_gm_stage1(pstr_section_info, bit_look_up,
pstr_section_data->max_sfb_per_grp, ptr_side_info_tab, aot);
ia_enhaacplus_enc_gm_stage2(pstr_section_info, merge_gain_look_up, bit_look_up,
pstr_section_data->max_sfb_per_grp, ptr_side_info_tab, aot);
for (i = 0; i < pstr_section_data->max_sfb_per_grp; i += pstr_section_info[i].sfb_cnt) {
ia_enhaacplus_enc_find_best_book(bit_look_up[i], &(pstr_section_info[i].code_book), aot);
pstr_section_info[i].sfb_start += (WORD8)grp_idx;
pstr_section_data->huffman_bits +=
pstr_section_info[i].section_bits - ptr_side_info_tab[pstr_section_info[i].sfb_cnt];
pstr_section_data->side_info_bits += ptr_side_info_tab[pstr_section_info[i].sfb_cnt];
pstr_section_data->section[pstr_section_data->num_of_sections++] = pstr_section_info[i];
}
}
return IA_NO_ERROR;
}
static WORD32 ia_enhaacplus_enc_bit_count_scalefactor_delta(
WORD32 delta, ixheaace_huffman_tables *pstr_huffman_tbl) {
return pstr_huffman_tbl->huff_ltabscf[delta + CODE_BCK_SCF_LAV];
}
static IA_ERRORCODE ia_enhaacplus_enc_scf_count(const WORD16 *ptr_scale_fac,
const UWORD16 *ptr_max_val_in_sfb,
ixheaace_section_data *pstr_section_data,
ixheaace_huffman_tables *pstr_huffman_tbl) {
WORD32 sect_idx1 = 0;
WORD32 sfb_idx1 = 0;
WORD32 scf_idx = 0;
WORD32 sect_idx2 = 0;
WORD32 sfb_idx2 = 0;
WORD32 last_val_scf = 0;
WORD32 delta_scf = 0;
WORD32 found = 0;
WORD32 scf_skip_counter = 0;
pstr_section_data->scale_fac_bits = 0;
if (ptr_scale_fac == 0) {
return IA_EXHEAACE_EXE_FATAL_INVALID_SCALE_FACTOR_GAIN;
}
last_val_scf = 0;
pstr_section_data->first_scf = 0;
for (sect_idx1 = 0; sect_idx1 < pstr_section_data->num_of_sections; sect_idx1++) {
if (pstr_section_data->section[sect_idx1].code_book != CODE_BCK_ZERO_NO) {
pstr_section_data->first_scf = pstr_section_data->section[sect_idx1].sfb_start;
last_val_scf = ptr_scale_fac[pstr_section_data->first_scf];
break;
}
}
for (sect_idx1 = 0; sect_idx1 < pstr_section_data->num_of_sections; sect_idx1++) {
if ((pstr_section_data->section[sect_idx1].code_book != CODE_BCK_ZERO_NO) &&
(pstr_section_data->section[sect_idx1].code_book != CODE_BCK_PNS_NO)) {
for (sfb_idx1 = pstr_section_data->section[sect_idx1].sfb_start;
sfb_idx1 < pstr_section_data->section[sect_idx1].sfb_start +
pstr_section_data->section[sect_idx1].sfb_cnt;
sfb_idx1++) {
if (ptr_max_val_in_sfb[sfb_idx1] == 0) {
found = 0;
if (scf_skip_counter == 0) {
if (sfb_idx1 == (pstr_section_data->section[sect_idx1].sfb_start +
pstr_section_data->section[sect_idx1].sfb_cnt - 1)) {
found = 0;
} else {
for (scf_idx = (sfb_idx1 + 1);
scf_idx < pstr_section_data->section[sect_idx1].sfb_start +
pstr_section_data->section[sect_idx1].sfb_cnt;
scf_idx++) {
if (ptr_max_val_in_sfb[scf_idx] != 0) {
found = 1;
if ((abs32(ptr_scale_fac[scf_idx] - last_val_scf)) < CODE_BCK_SCF_LAV) {
delta_scf = 0;
} else {
delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);
last_val_scf = ptr_scale_fac[sfb_idx1];
scf_skip_counter = 0;
}
break;
}
/* count scalefactor skip */
scf_skip_counter = scf_skip_counter + 1;
}
}
/* search for the next ptr_max_val_in_sfb[] != 0 in all other sections */
for (sect_idx2 = (sect_idx1 + 1);
(sect_idx2 < pstr_section_data->num_of_sections) && (found == 0); sect_idx2++) {
if ((pstr_section_data->section[sect_idx2].code_book != CODE_BCK_ZERO_NO) &&
(pstr_section_data->section[sect_idx2].code_book != CODE_BCK_PNS_NO)) {
for (sfb_idx2 = pstr_section_data->section[sect_idx2].sfb_start;
sfb_idx2 < pstr_section_data->section[sect_idx2].sfb_start +
pstr_section_data->section[sect_idx2].sfb_cnt;
sfb_idx2++) {
if (ptr_max_val_in_sfb[sfb_idx2] != 0) {
found = 1;
if ((abs32(ptr_scale_fac[sfb_idx2] - last_val_scf)) < CODE_BCK_SCF_LAV) {
delta_scf = 0;
} else {
delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);
last_val_scf = ptr_scale_fac[sfb_idx1];
scf_skip_counter = 0;
}
break;
}
scf_skip_counter = scf_skip_counter + 1;
}
}
}
if (found == 0) {
delta_scf = 0;
scf_skip_counter = 0;
}
} else {
delta_scf = 0;
scf_skip_counter = scf_skip_counter - 1;
}
} else {
delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);
last_val_scf = ptr_scale_fac[sfb_idx1];
}
pstr_section_data->scale_fac_bits +=
ia_enhaacplus_enc_bit_count_scalefactor_delta(delta_scf, pstr_huffman_tbl);
}
}
}
return IA_NO_ERROR;
}
IA_ERRORCODE ia_enhaacplus_enc_dyn_bitcount(
const WORD16 *ptr_quant_spec, const UWORD16 *ptr_max_val_in_sfb, const WORD16 *ptr_scale_fac,
const WORD32 block_type, const WORD32 sfb_cnt, const WORD32 max_sfb_per_grp,
const WORD32 sfb_per_grp, const WORD32 *ptr_sfb_offset,
ixheaace_section_data *pstr_section_data, WORD32 *ptr_side_info_tab_long,
WORD32 *ptr_side_info_tab_short, ixheaace_huffman_tables *ptr_huffman_tbl,
WORD32 *ptr_scratch_buf, WORD32 aot, WORD32 *bit_cnt) {
IA_ERRORCODE err_code;
WORD32(*ptr_bit_look_up)
[CODE_BCK_ESC_NDX + 1] = (WORD32(*)[CODE_BCK_ESC_NDX + 1]) ptr_scratch_buf;
WORD32 *ptr_merge_gain_look_up =
ptr_scratch_buf + MAXIMUM_SCALE_FACTOR_BAND_LONG * (CODE_BCK_ESC_NDX + 1);
*bit_cnt = 0;
pstr_section_data->block_type = block_type;
pstr_section_data->sfb_cnt = sfb_cnt;
pstr_section_data->sfb_per_group = sfb_per_grp;
pstr_section_data->total_groups_cnt = sfb_cnt / sfb_per_grp;
pstr_section_data->max_sfb_per_grp = max_sfb_per_grp;
err_code = ia_enhaacplus_enc_noiseless_counter(
pstr_section_data, ptr_merge_gain_look_up, ptr_bit_look_up, ptr_quant_spec,
ptr_max_val_in_sfb, ptr_sfb_offset, block_type, ptr_side_info_tab_long,
ptr_side_info_tab_short, ptr_huffman_tbl, aot);
if (err_code != IA_NO_ERROR) {
return err_code;
}
err_code = ia_enhaacplus_enc_scf_count(ptr_scale_fac, ptr_max_val_in_sfb, pstr_section_data,
ptr_huffman_tbl);
if (err_code != IA_NO_ERROR) {
return err_code;
}
*bit_cnt = (pstr_section_data->huffman_bits + pstr_section_data->side_info_bits +
pstr_section_data->scale_fac_bits);
return IA_NO_ERROR;
}
VOID ia_enhaacplus_enc_bitcount_init(WORD32 *side_info_tab_long, WORD32 *side_info_tab_short) {
WORD32 i;
/* side_info_tab_long[] */
for (i = 0; i <= MAXIMUM_SCALE_FACTOR_BAND_LONG; i++) {
side_info_tab_long[i] = ia_enhaacplus_enc_calc_side_info_bits(i, LONG_WINDOW);
}
/* side_info_tab_short[] */
for (i = 0; i <= MAXIMUM_SCALE_FACTOR_BAND_SHORT; i++) {
side_info_tab_short[i] = ia_enhaacplus_enc_calc_side_info_bits(i, SHORT_WINDOW);
}
}
Reference in a new issue View git blame Copy permalink