xref: /aosp_15_r20/external/libxaac/encoder/iusace_enc_fac.c (revision 15dc779a375ca8b5125643b829a8aa4b70d7f451)

/******************************************************************************
 *                                                                            *
 * 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 <string.h>
#include "ixheaac_type_def.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_bitbuffer.h"

/* DRC */
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_tables.h"
#include "impd_drc_api.h"
#include "impd_drc_uni_drc_eq.h"
#include "impd_drc_uni_drc_filter_bank.h"
#include "impd_drc_gain_enc.h"
#include "impd_drc_struct_def.h"

#include "iusace_cnst.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_config.h"
#include "iusace_arith_enc.h"
#include "iusace_block_switch_const.h"
#include "iusace_block_switch_struct_def.h"
#include "iusace_fd_qc_util.h"
#include "iusace_fd_quant.h"
#include "iusace_ms.h"
#include "iusace_signal_classifier.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"
#include "ixheaace_asc_write.h"
#include "iusace_main.h"
#include "iusace_write_bitstream.h"
#include "iusace_func_prototypes.h"
#include "iusace_avq_enc.h"
#include "iusace_lpd_rom.h"

static WORD32 iusace_unary_code(WORD32 idx, WORD16 *ptr_bit_buf) {
  WORD32 num_bits;

  num_bits = 1;

  idx -= 1;
  while (idx-- > 0) {
    *ptr_bit_buf++ = 1;
    num_bits++;
  }

  *ptr_bit_buf = 0;

  return (num_bits);
}

static VOID iusace_get_nk_mode(WORD32 mode_lpc, ia_bit_buf_struct *pstr_it_bit_buff,
                               WORD32 *nk_mode, WORD32 lpc_set) {
  switch (lpc_set) {
    case 4:
      break;
    case 0:
    case 2:
      *nk_mode = 3;
      iusace_write_bits_buf(pstr_it_bit_buff, mode_lpc, 1);
      break;
    case 1:
      *nk_mode = mode_lpc;
      if (mode_lpc == 2) {
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      } else if (mode_lpc == 1) {
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
      } else if (mode_lpc == 0) {
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      }
      break;
    case 3:
      if (mode_lpc == 0) {
        *nk_mode = 0;
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      } else if (mode_lpc == 1) {
        *nk_mode = 1;
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      } else if (mode_lpc == 2) {
        *nk_mode = 2;
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      } else {
        *nk_mode = 2;
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
      }
      break;
  }
  return;
}

static VOID iusace_write_qn_data(WORD32 *qn, ia_bit_buf_struct *pstr_it_bit_buff, WORD32 nk_mode,
                                 WORD32 num_frames) {
  WORD32 k, i;
  switch (nk_mode) {
    case 1:
      for (k = 0; k < 2; k++) {
        for (i = 0; i < qn[k] - 1; i++) {
          iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
        }
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
      }
      break;
    case 0:
    case 2:
    case 3:
      for (k = 0; k < 2; k++) {
        WORD32 qn1 = qn[k] - 2;
        if (qn1 < 0 || qn1 > 3) {
          qn1 = 3;
        }
        iusace_write_bits_buf(pstr_it_bit_buff, qn1, 2);
      }
      if ((nk_mode == 2) && num_frames != 2) {
        for (k = 0; k < 2; k++) {
          if (qn[k] > 4) {
            for (i = 0; i < qn[k] - 4; i++) {
              iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
            }
            iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
          }
          if (qn[k] == 0) {
            iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
          }
        }
      } else {
        for (k = 0; k < 2; k++) {
          if (qn[k] == 5) {
            iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
          } else if (qn[k] == 6) {
            iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
            iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
          } else if (qn[k] == 0) {
            iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
            iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
            iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
          } else {
            WORD32 qn_ext = qn[k] - 4;
            if (qn_ext > 0) {
              for (i = 0; i < qn_ext; i++) {
                iusace_write_bits_buf(pstr_it_bit_buff, 1, 1);
              }
              iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);
            }
          }
        }
      }
      break;
  }
  return;
}

static VOID iusace_write_cb_indices(WORD32 *qn, WORD32 *ptr_params, WORD32 *idx,
                                    ia_bit_buf_struct *pstr_it_bit_buff, WORD32 nk_mode,
                                    WORD32 num_frames) {
  WORD32 k;
  WORD32 j = *idx;

  iusace_write_qn_data(qn, pstr_it_bit_buff, nk_mode, num_frames);

  for (k = 0; k < 2; k++) {
    if (qn[k] > 0) {
      WORD32 n, nk, i;
      if (qn[k] > 4) {
        nk = (qn[k] - 3) >> 1;
        n = qn[k] - nk * 2;
      } else {
        nk = 0;
        n = qn[k];
      }

      iusace_write_bits_buf(pstr_it_bit_buff, ptr_params[j++], (UWORD8)(4 * n));

      for (i = 0; i < 8; i++) {
        iusace_write_bits_buf(pstr_it_bit_buff, ptr_params[j++], (UWORD8)nk);
      }
    }
  }

  *idx = j;

  return;
}

static VOID iusace_write_lpc_data(ia_bit_buf_struct *pstr_it_bit_buff, WORD32 *param_lpc,
                                  WORD32 first_lpd_flag, WORD32 *mod, WORD32 num_frames) {
  WORD32 nk_mode = 0;
  WORD32 j = 0, k;
  WORD32 mode_lpc = 0;
  WORD32 qn[2] = {0};

  iusace_get_nk_mode(mode_lpc, pstr_it_bit_buff, &nk_mode, 4);

  iusace_write_bits_buf(pstr_it_bit_buff, param_lpc[j++], 8);

  for (k = 0; k < 2; k++) {
    qn[k] = param_lpc[j++];
  }

  iusace_write_cb_indices(qn, param_lpc, &j, pstr_it_bit_buff, nk_mode, num_frames);

  if (first_lpd_flag) {
    mode_lpc = param_lpc[j++];
    iusace_get_nk_mode(mode_lpc, pstr_it_bit_buff, &nk_mode, 0);

    if (mode_lpc == 0) {
      iusace_write_bits_buf(pstr_it_bit_buff, param_lpc[j++], 8);
    }

    for (k = 0; k < 2; k++) {
      qn[k] = param_lpc[j++];
    }

    iusace_write_cb_indices(qn, param_lpc, &j, pstr_it_bit_buff, nk_mode, num_frames);
  }

  mode_lpc = param_lpc[j++];

  if (num_frames == 4 && mod[0] < 3) {
    iusace_get_nk_mode(mode_lpc, pstr_it_bit_buff, &nk_mode, 2);

    if (mode_lpc == 0) {
      iusace_write_bits_buf(pstr_it_bit_buff, param_lpc[j++], 8);
    }

    for (k = 0; k < 2; k++) {
      qn[k] = param_lpc[j++];
    }

    iusace_write_cb_indices(qn, param_lpc, &j, pstr_it_bit_buff, nk_mode, num_frames);
  }
  mode_lpc = param_lpc[j++];
  if (mod[0] < 2) {
    iusace_get_nk_mode(mode_lpc, pstr_it_bit_buff, &nk_mode, 1);

    if (mode_lpc != 1) {
      if (mode_lpc == 0) {
        iusace_write_bits_buf(pstr_it_bit_buff, param_lpc[j++], 8);
      }

      for (k = 0; k < 2; k++) {
        qn[k] = param_lpc[j++];
      }

      iusace_write_cb_indices(qn, param_lpc, &j, pstr_it_bit_buff, nk_mode, num_frames);
    }
  } else if (mode_lpc != 1) {
    if (mode_lpc == 0) {
      j++;
    }
    for (k = 0; k < 2; k++) {
      qn[k] = param_lpc[j++];
    }
    j += ((qn[0] > 0) ? 9 : 0) + ((qn[1] > 0) ? 9 : 0);
  }

  mode_lpc = param_lpc[j++];
  if (num_frames != 2 && mod[2] < 2) {
    iusace_get_nk_mode(mode_lpc, pstr_it_bit_buff, &nk_mode, 3);
    if (mode_lpc == 0) {
      iusace_write_bits_buf(pstr_it_bit_buff, param_lpc[j++], 8);
    }

    for (k = 0; k < 2; k++) {
      qn[k] = param_lpc[j++];
    }
    iusace_write_cb_indices(qn, param_lpc, &j, pstr_it_bit_buff, nk_mode, num_frames);
  }
  return;
}

VOID iusace_encode_fac_params(WORD32 *mod, WORD32 *n_param_tcx, ia_usac_data_struct *usac_data,
                              WORD32 const usac_independency_flag,
                              ia_bit_buf_struct *pstr_it_bit_buff, WORD32 ch_idx) {
  WORD32 *total_nbbits = &usac_data->total_nbbits[ch_idx];
  ia_usac_td_encoder_struct *pstr_td = usac_data->td_encoder[ch_idx];
  WORD32 codec_mode = pstr_td->acelp_core_mode;
  WORD16 *bit_buf = usac_data->td_serial_out[ch_idx];
  WORD32 is_bass_post_filter = 1;
  WORD32 first_lpd_flag = (usac_data->core_mode_prev[ch_idx] == CORE_MODE_FD);
  WORD32 *param_lpc = usac_data->param_buf + (NUM_FRAMES * MAX_NUM_TCX_PRM_PER_DIV);
  WORD32 *param = usac_data->param_buf;
  WORD32 j, k, n, sfr, lpd_mode, num_bits, sq_bits, *prm;
  WORD16 first_tcx_flag = 1;
  WORD32 nbits_fac, nb_bits_lpc;
  WORD32 core_mode_last = (first_lpd_flag) ? 0 : 1;
  WORD32 fac_data_present;
  WORD32 num_frames = NUM_FRAMES;
  WORD16 *ptr_bit_buf = bit_buf;

  pstr_td->num_bits_per_supfrm = 0;
  *total_nbbits = 0;

  iusace_write_bits_buf(pstr_it_bit_buff, pstr_td->acelp_core_mode, 3);

  if (mod[0] == 3) {
    lpd_mode = 25;
  } else if ((mod[0] == 2) && (mod[2] == 2)) {
    lpd_mode = 24;
  } else {
    if (mod[0] == 2) {
      lpd_mode = 16 + mod[2] + 2 * mod[3];
    } else if (mod[2] == 2) {
      lpd_mode = 20 + mod[0] + 2 * mod[1];
    } else {
      lpd_mode = mod[0] + 2 * mod[1] + 4 * mod[2] + 8 * mod[3];
    }
  }
  iusace_write_bits_buf(pstr_it_bit_buff, lpd_mode, 5);
  pstr_td->num_bits_per_supfrm = 5;
  *total_nbbits += 5;

  iusace_write_bits_buf(pstr_it_bit_buff, is_bass_post_filter, 1);
  *total_nbbits += 1;

  iusace_write_bits_buf(pstr_it_bit_buff, core_mode_last, 1);
  *total_nbbits += 1;

  if (((mod[0] == 0) && (mod[-1] != 0)) || ((mod[0] > 0) && (mod[-1] == 0))) {
    fac_data_present = 1;
  } else {
    fac_data_present = 0;
  }

  iusace_write_bits_buf(pstr_it_bit_buff, fac_data_present, 1);
  *total_nbbits += 1;

  num_bits = (iusace_acelp_core_numbits_1024[codec_mode] / 4) - 2;

  k = 0;
  while (k < num_frames) {
    lpd_mode = mod[k];
    prm = param + (k * MAX_NUM_TCX_PRM_PER_DIV);
    j = 0;

    if (((mod[k - 1] == 0) && (mod[k] > 0)) || ((mod[k - 1] > 0) && (mod[k] == 0))) {
      nbits_fac = iusace_fd_encode_fac(&prm[j], ptr_bit_buf, (pstr_td->len_subfrm) / 2);
      j += (pstr_td->len_subfrm) / 2;
      *total_nbbits += nbits_fac;
      for (WORD32 i = 0; i < nbits_fac; i++) {
        iusace_write_bits_buf(pstr_it_bit_buff, ptr_bit_buf[i], 1);
      }
    }

    if (lpd_mode == 0) {
      iusace_write_bits_buf(pstr_it_bit_buff, prm[j++], 2);

      for (sfr = 0; sfr < (pstr_td->num_subfrm); sfr++) {
        n = 6;
        if ((sfr == 0) || (((pstr_td->len_subfrm) == 256) && (sfr == 2))) n = 9;
        iusace_write_bits_buf(pstr_it_bit_buff, prm[j], (UWORD8)n);
        j++;
        iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 1);
        j++;
        if (codec_mode == ACELP_CORE_MODE_9k6) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
        } else if (codec_mode == ACELP_CORE_MODE_11k2) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 5);
          j++;
        } else if (codec_mode == ACELP_CORE_MODE_12k8) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
        } else if (codec_mode == ACELP_CORE_MODE_14k4) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 9);
          j++;
        } else if (codec_mode == ACELP_CORE_MODE_16k) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 13);
          j++;
        } else if (codec_mode == ACELP_CORE_MODE_18k4) {
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 2);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 2);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 2);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 2);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 14);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 14);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 14);
          j++;
          iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 14);
          j++;
        }
        iusace_write_bits_buf(pstr_it_bit_buff, prm[j], 7);
        j++;
      }
      *total_nbbits += (num_bits - NBITS_LPC);
      pstr_td->num_bits_per_supfrm += (num_bits - NBITS_LPC);
      k++;
    } else {
      iusace_write_bits_buf(pstr_it_bit_buff, prm[j++], 3);
      *total_nbbits += 3;
      pstr_td->num_bits_per_supfrm += 3;
      iusace_write_bits_buf(pstr_it_bit_buff, prm[j++], 7);
      *total_nbbits += 7;
      pstr_td->num_bits_per_supfrm += 7;

      if (first_tcx_flag) {
        first_tcx_flag = 0;
        if (usac_independency_flag) {
          pstr_td->arith_reset_flag = 1;
          memset(pstr_td->c_pres, 0, 516 * sizeof(WORD32));
          memset(pstr_td->c_prev, 0, 516 * sizeof(WORD32));
        } else {
          if (pstr_td->arith_reset_flag) {
            memset(pstr_td->c_pres, 0, 516 * sizeof(WORD32));
            memset(pstr_td->c_prev, 0, 516 * sizeof(WORD32));
          }
          iusace_write_bits_buf(pstr_it_bit_buff, pstr_td->arith_reset_flag, 1);
          *total_nbbits += 1;
          pstr_td->num_bits_per_supfrm += 1;
        }
      }

      sq_bits = iusace_tcx_coding(pstr_it_bit_buff, n_param_tcx[k], pstr_td->len_frame, prm + j,
                                  pstr_td->c_pres, pstr_td->c_prev);

      *total_nbbits += sq_bits;
      pstr_td->num_bits_per_supfrm += sq_bits;

      k += (1 << (lpd_mode - 1));
    }
  }

  nb_bits_lpc = pstr_it_bit_buff->cnt_bits;

  iusace_write_lpc_data(pstr_it_bit_buff, param_lpc, first_lpd_flag, mod, num_frames);

  nb_bits_lpc = pstr_it_bit_buff->cnt_bits - nb_bits_lpc;
  *total_nbbits += nb_bits_lpc;
  pstr_td->num_bits_per_supfrm += nb_bits_lpc;

  if ((core_mode_last == 0) && (fac_data_present == 1)) {
    WORD32 short_fac_flag = (mod[-1] == -2) ? 1 : 0;
    iusace_write_bits_buf(pstr_it_bit_buff, short_fac_flag, 1);
    *total_nbbits += 1;
  }

  return;
}

WORD32 iusace_fd_encode_fac(WORD32 *prm, WORD16 *ptr_bit_buf, WORD32 fac_length) {
  WORD32 i, j, n, nb, qn, kv[8], nk, fac_bits;
  WORD32 I;

  fac_bits = 0;

  for (i = 0; i < fac_length; i += 8) {
    iusace_apply_voronoi_ext(&prm[i], &qn, &I, kv);

    nb = iusace_unary_code(qn, ptr_bit_buf);
    ptr_bit_buf += nb;

    fac_bits += nb;

    nk = 0;
    n = qn;
    if (qn > 4) {
      nk = (qn - 3) >> 1;
      n = qn - nk * 2;
    }

    if (qn != 0) {
      iusace_write_bits2buf(I, 4 * n, ptr_bit_buf);
      ptr_bit_buf += 4 * n;
    }
    if (qn > 4) {
      for (j = 0; j < 8; j++) {
        iusace_write_bits2buf(kv[j], nk, ptr_bit_buf);
        ptr_bit_buf += nk;
      }
    }
    fac_bits += 4 * qn;
  }

  return fac_bits;
}