/src/libxaac/encoder/ixheaace_mps_bitstream.c

Source (jump to first uncovered line)
/******************************************************************************
 *                                                                            *
 * 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 <stdlib.h>
#include <math.h>
#include "ixheaac_type_def.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 "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_mps_common_fix.h"
#include "ixheaace_mps_defines.h"
#include "ixheaace_mps_common_define.h"
#include "ixheaace_bitbuffer.h"

#include "ixheaace_mps_nlc_enc.h"
#include "ixheaac_constants.h"
#include "ixheaace_aac_constants.h"
#include "ixheaace_common_rom.h"

#include "ixheaace_mps_struct_def.h"
#include "ixheaace_mps_sac_polyphase.h"
#include "ixheaace_mps_sac_nlc_enc.h"
#include "ixheaace_mps_sac_hybfilter.h"
#include "ixheaace_mps_bitstream.h"
#include "ixheaace_mps_spatial_bitstream.h"
#include "ixheaace_mps_param_extract.h"
#include "ixheaace_mps_tree.h"
#include "ixheaace_mps_rom.h"

static UWORD8 ixheaace_mps_212_get_bs_freq_res_stride(const WORD32 index) {
  WORD32 freq_res_stride_table_size = 0;
  const UWORD8 *ptr_freq_res_stride_table = NULL;

  ptr_freq_res_stride_table = freq_res_stride_table_212;
  freq_res_stride_table_size =
      sizeof(freq_res_stride_table_212) / sizeof(*freq_res_stride_table_212);

  return (((index >= 0) && (index < freq_res_stride_table_size))
              ? ptr_freq_res_stride_table[index]
              : 1);
}

static IA_ERRORCODE ixheaace_mps_212_get_bs_freq_res_index(const WORD32 num_bands,
                                                           WORD32 *const ptr_bs_freq_res_index,
                                                           WORD32 aot) {
  IA_ERRORCODE error = IA_NO_ERROR;
  WORD32 idx;
  const UWORD8 *p_freq_res_bin_table;
  *ptr_bs_freq_res_index = -1;

  if (aot == AOT_AAC_ELD) {
    p_freq_res_bin_table = freq_res_bin_table_ld;
  } else {
    p_freq_res_bin_table = freq_res_bin_table_usac;
  }
  for (idx = 0; idx < MAX_FREQ_RES_INDEX; idx++) {
    if (num_bands == p_freq_res_bin_table[idx]) {
      *ptr_bs_freq_res_index = idx;
      break;
    }
  }
  if (*ptr_bs_freq_res_index < 0 || *ptr_bs_freq_res_index >= MAX_FREQ_RES_INDEX) {
    return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
  }
  return error;
}

static VOID ixheaace_mps_212_get_sampling_frequency_index(
    const UWORD32 bs_sampling_frequency, WORD32 *const ptr_bs_sampling_frequency_index) {
  WORD32 idx;
  *ptr_bs_sampling_frequency_index = SAMPLING_FREQUENCY_INDEX_ESCAPE;

  for (idx = 0; idx < MAX_SAMPLING_FREQUENCY_INDEX; idx++) {
    if (bs_sampling_frequency == ia_sampl_freq_table[idx]) {
      *ptr_bs_sampling_frequency_index = idx;
      break;
    }
  }
}

static IA_ERRORCODE ixheaace_mps_212_ec_data(
    ixheaace_bit_buf_handle pstr_bit_buf, WORD8 data[MAX_NUM_PARAMS][MAX_NUM_BINS],
    WORD8 old_data[MAX_NUM_BINS], UWORD8 quant_coarse_xxx_prev[MAX_NUM_PARAMS],
    ixheaace_mps_lossless_data *const pstr_lossless_data, const WORD32 data_type,
    const WORD32 param_idx, const WORD32 num_param_sets, const WORD32 independency_flag,
    const WORD32 start_band, const WORD32 stop_band, const WORD32 default_value) {
  IA_ERRORCODE error;
  WORD32 ps, pb, str_offset, pb_stride, i;
  WORD16 data_bands;
  WORD32 a_strides[MAX_NUM_BINS + 1] = {0};
  WORD16 cmp_idx_data[2][MAX_NUM_BINS] = {{0}};
  WORD16 cmp_old_data[MAX_NUM_BINS] = {0};

  if (num_param_sets > MAX_NUM_PARAMS) {
    return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_NUM_PARAM_SETS;
  }

  if (independency_flag || (pstr_lossless_data->bs_quant_coarse_xxx[param_idx][0] !=
                            quant_coarse_xxx_prev[param_idx])) {
    pstr_lossless_data->bs_xxx_data_mode[param_idx][0] = IXHEAACE_MPS_DATA_MODE_FINECOARSE;
  } else {
    pstr_lossless_data->bs_xxx_data_mode[param_idx][0] = IXHEAACE_MPS_DATA_MODE_KEEP;
    for (i = start_band; i < stop_band; i++) {
      if (data[0][i] != old_data[i]) {
        pstr_lossless_data->bs_xxx_data_mode[param_idx][0] = IXHEAACE_MPS_DATA_MODE_FINECOARSE;
        break;
      }
    }
  }

  ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_xxx_data_mode[param_idx][0], 2);

  for (ps = 1; ps < num_param_sets; ps++) {
    if (pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps] !=
        pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps - 1]) {
      pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] = IXHEAACE_MPS_DATA_MODE_FINECOARSE;
    } else {
      pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] = IXHEAACE_MPS_DATA_MODE_KEEP;
      for (i = start_band; i < stop_band; i++) {
        if (data[ps][i] != data[ps - 1][i]) {
          pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] = IXHEAACE_MPS_DATA_MODE_FINECOARSE;
          break;
        }
      }
    }

    ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_xxx_data_mode[param_idx][ps], 2);
  }

  for (ps = 0; ps < (num_param_sets - 1); ps++) {
    if (pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] ==
        IXHEAACE_MPS_DATA_MODE_FINECOARSE) {
      if (pstr_lossless_data->bs_xxx_data_mode[param_idx][ps + 1] ==
          IXHEAACE_MPS_DATA_MODE_FINECOARSE) {
        if ((pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps + 1] ==
             pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps]) &&
            (pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][ps + 1] ==
             pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][ps])) {
          pstr_lossless_data->bs_data_pair[param_idx][ps] = 1;
          pstr_lossless_data->bs_data_pair[param_idx][ps + 1] = 1;
          ps++;
          continue;
        }
      }

      pstr_lossless_data->bs_data_pair[param_idx][ps] = 0;

      pstr_lossless_data->bs_data_pair[param_idx][ps + 1] = 0;
    } else {
      pstr_lossless_data->bs_data_pair[param_idx][ps] = 0;
      pstr_lossless_data->bs_data_pair[param_idx][ps + 1] = 0;
    }
  }

  for (ps = 0; ps < num_param_sets; ps++) {
    if (pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] == IXHEAACE_MPS_DATA_MODE_DEFAULT) {
      for (i = start_band; i < stop_band; i++) {
        old_data[i] = (WORD8)default_value;
      }
      quant_coarse_xxx_prev[param_idx] = 0;
    }

    if (pstr_lossless_data->bs_xxx_data_mode[param_idx][ps] ==
        IXHEAACE_MPS_DATA_MODE_FINECOARSE) {
      ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_data_pair[param_idx][ps], 1);
      ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps],
                          1);
      ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][ps],
                          2);

      if (pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps] !=
          quant_coarse_xxx_prev[param_idx]) {
        if (quant_coarse_xxx_prev[param_idx]) {
          for (i = start_band; i < stop_band; i++) {
            old_data[i] *= 2;
          }

          if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
            for (i = start_band; i < stop_band; i++) {
              if (old_data[i] == -14) {
                old_data[i] = -15;
              } else if (old_data[i] == 14) {
                old_data[i] = 15;
              }
            }
          }
        } else {
          for (i = start_band; i < stop_band; i++) {
            old_data[i] /= 2;
          }
        }
      }

      pb_stride = ixheaace_mps_212_get_bs_freq_res_stride(
          pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][ps]);
      data_bands = (WORD16)((stop_band - start_band - 1) / pb_stride + 1);

      a_strides[0] = start_band;
      for (pb = 1; pb <= data_bands; pb++) {
        a_strides[pb] = a_strides[pb - 1] + pb_stride;
      }

      str_offset = 0;
      while (a_strides[data_bands] > stop_band) {
        if (str_offset < data_bands) {
          str_offset++;
        }
        for (i = str_offset; i <= data_bands; i++) {
          a_strides[i]--;
        }
      }

      for (pb = 0; pb < data_bands; pb++) {
        cmp_old_data[start_band + pb] = old_data[a_strides[pb]];
        cmp_idx_data[0][start_band + pb] = data[ps][a_strides[pb]];

        if (pstr_lossless_data->bs_data_pair[param_idx][ps]) {
          cmp_idx_data[1][start_band + pb] = data[ps + 1][a_strides[pb]];
        }
      }

      if (pstr_lossless_data->bs_data_pair[param_idx][ps]) {
        error = ixheaace_mps_212_ec_data_pair_enc(
            pstr_bit_buf, cmp_idx_data, cmp_old_data, data_type, 0, start_band, data_bands,
            pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps],
            independency_flag && (ps == 0));
        if (error != IA_NO_ERROR) {
          return error;
        }
      } else {
        error = ixheaace_mps_212_ec_data_single_enc(
            pstr_bit_buf, cmp_idx_data, cmp_old_data, data_type, 0, start_band, data_bands,
            pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps],
            independency_flag && (ps == 0));
        if (error != IA_NO_ERROR) {
          return error;
        }
      }
      for (i = start_band; i < stop_band; i++) {
        if (pstr_lossless_data->bs_data_pair[param_idx][ps]) {
          old_data[i] = data[ps + 1][i];
        } else {
          old_data[i] = data[ps][i];
        }
      }

      quant_coarse_xxx_prev[param_idx] = pstr_lossless_data->bs_quant_coarse_xxx[param_idx][ps];

      if (pstr_lossless_data->bs_data_pair[param_idx][ps]) {
        ps++;
      }
    }
  }
  return IA_NO_ERROR;
}

static VOID ixheaace_mps_212_write_smg_data(ixheaace_bit_buf_handle pstr_bit_buf,
                                            const ixheaace_mps_smg_data *const pstr_smg_data,
                                            const WORD32 num_param_sets,
                                            const WORD32 data_bands) {
  WORD32 param, band;

  for (param = 0; param < num_param_sets; param++) {
    ixheaace_write_bits(pstr_bit_buf, pstr_smg_data->bs_smooth_mode[param], 2);
    if (pstr_smg_data->bs_smooth_mode[param] >= 2) {
      ixheaace_write_bits(pstr_bit_buf, pstr_smg_data->bs_smooth_time[param], 2);
    }
    if (pstr_smg_data->bs_smooth_mode[param] == 3) {
      WORD32 stride =
          ixheaace_mps_212_get_bs_freq_res_stride(pstr_smg_data->bs_freq_res_stride[param]);
      ixheaace_write_bits(pstr_bit_buf, pstr_smg_data->bs_freq_res_stride[param], 2);
      for (band = 0; band < data_bands; band += stride) {
        ixheaace_write_bits(pstr_bit_buf, pstr_smg_data->bs_smg_data[param][band], 1);
      }
    }
  }
}

static IA_ERRORCODE ixheaace_mps_212_write_ott_data(
    ixheaace_bit_buf_handle pstr_bit_buf, ixheaace_mps_prev_ott_data *const pstr_prev_ott_data,
    ixheaace_mps_ott_data *const pstr_ott_data,
    const ixheaace_mps_ott_config ott_config[IXHEAACE_MPS_MAX_NUM_BOXES],
    ixheaace_mps_lossless_data *const pstr_cld_lossless_data,
    ixheaace_mps_lossless_data *const pstr_icc_lossless_data, const WORD32 num_ott_boxes,
    const WORD32 num_bands, const WORD32 num_param_sets, const WORD32 bs_independency_flag) {
  IA_ERRORCODE error = IA_NO_ERROR;
  WORD32 box;
  for (box = 0; box < num_ott_boxes; box++) {
    error = ixheaace_mps_212_ec_data(
        pstr_bit_buf, pstr_ott_data->cld[box], pstr_prev_ott_data->cld_old[box],
        pstr_prev_ott_data->quant_coarse_cld_prev[box], pstr_cld_lossless_data,
        IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box, num_param_sets, bs_independency_flag, 0,
        ott_config[box].bs_ott_bands, 15);
    if (error != IA_NO_ERROR) {
      return error;
    }
  }
  for (box = 0; box < num_ott_boxes; box++) {
    error = ixheaace_mps_212_ec_data(pstr_bit_buf, pstr_ott_data->icc[box],
                                     pstr_prev_ott_data->icc_old[box],
                                     pstr_prev_ott_data->quant_coarse_icc_prev[box],
                                     pstr_icc_lossless_data, IXHEAACE_MPS_SAC_DATA_TYPE_ICC, box,
                                     num_param_sets, bs_independency_flag, 0, num_bands, 0);
    if (error != IA_NO_ERROR) {
      return error;
    }
  }

  return IA_NO_ERROR;
}

static VOID ixheaace_mps_212_write_framing_info(
    ixheaace_bit_buf_handle pstr_bit_buf,
    const ixheaace_mps_framing_info *const pstr_framing_info, const WORD32 frame_length) {
  ixheaace_write_bits(pstr_bit_buf, pstr_framing_info->bs_framing_type, 1);
  ixheaace_write_bits(pstr_bit_buf, pstr_framing_info->num_param_sets - 1, 1);

  if (pstr_framing_info->bs_framing_type) {
    WORD32 ps = 0;
    UWORD8 bits_param_slot = 0;
    WORD32 num_param_sets = pstr_framing_info->num_param_sets;
    while ((1 << bits_param_slot) < (frame_length + 1)) {
      bits_param_slot++;
    }
    if (bits_param_slot > 0) {
      for (ps = 0; ps < num_param_sets; ps++) {
        ixheaace_write_bits(pstr_bit_buf, pstr_framing_info->bs_param_slots[ps], bits_param_slot);
      }
    }
  }
}

static IA_ERRORCODE ixheaace_mps_515_ec_data(ixheaace_bit_buf_handle pstr_bit_buf,
                                             WORD32 data[MAX_NUM_PARAMS][MAX_NUM_BINS],
                                             WORD32 old_data[MAX_NUM_BINS],
                                             ixheaace_mps_sac_lossless_data *pstr_lossless_data,
                                             WORD32 data_type, WORD32 param_idx,
                                             WORD32 num_param_sets, WORD32 independency_flag,
                                             WORD32 start_band, WORD32 stop_band) {
  WORD32 param_set, set_idx, pb_stride, data_bands, bin, data_sets;
  WORD32 param_set_index[MAX_NUM_PARAMS] = {0};

  for (param_set = 0; param_set < num_param_sets; param_set++) {
    pstr_lossless_data->bs_xxx_data_mode[param_idx][param_set] =
        IXHEAACE_MPS_DATA_MODE_FINECOARSE;
    ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_xxx_data_mode[param_idx][param_set],
                        2);
  }

  for (param_set = 0, set_idx = 0; param_set < num_param_sets; param_set++) {
    param_set_index[set_idx] = param_set;
    if (param_set != num_param_sets - 1) {
      pstr_lossless_data->bs_data_pair[param_idx][set_idx] = 1;
      pstr_lossless_data->bs_data_pair[param_idx][set_idx + 1] = 1;
      param_set++;
      set_idx += 2;
    } else {
      pstr_lossless_data->bs_data_pair[param_idx][set_idx] = 0;
      set_idx++;
    }
  }
  data_sets = set_idx;

  for (set_idx = 0; set_idx < data_sets;) {
    ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_data_pair[param_idx][set_idx], 1);
    ixheaace_write_bits(pstr_bit_buf, pstr_lossless_data->bs_quant_coarse_xxx[param_idx][set_idx],
                        1);
    ixheaace_write_bits(pstr_bit_buf,
                        pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][set_idx], 2);

    pb_stride =
        freq_res_stride_table[pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][set_idx]];
    data_bands = (stop_band - start_band - 1) / pb_stride + 1;

    ixheaace_mps_515_ec_data_pair_enc(
        pstr_bit_buf, data, old_data, data_type, param_set_index[set_idx], start_band, data_bands,
        pstr_lossless_data->bs_data_pair[param_idx][set_idx],
        pstr_lossless_data->bs_quant_coarse_xxx[param_idx][set_idx], independency_flag);

    if (pstr_lossless_data->bs_data_pair[param_idx][set_idx]) {
      if (pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][set_idx + 1] !=
          pstr_lossless_data->bs_freq_res_stride_xxx[param_idx][set_idx]) {
        return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_RES_STRIDE;
      }
      if (pstr_lossless_data->bs_quant_coarse_xxx[param_idx][set_idx + 1] !=
          pstr_lossless_data->bs_quant_coarse_xxx[param_idx][set_idx]) {
        return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_QUANT_COARSE;
      }
    }

    for (bin = 0; bin < MAX_NUM_BINS; bin++) {
      old_data[bin] = data[param_set_index[set_idx] +
                           pstr_lossless_data->bs_data_pair[param_idx][set_idx]][bin];
    }

    set_idx += pstr_lossless_data->bs_data_pair[param_idx][set_idx] + 1;
  }
  return IA_NO_ERROR;
}

WORD32 ixheaace_mps_515_icc_quant(FLOAT32 val) {
  FLOAT32 p_qsteps[7] = {0.9685f, 0.88909f, 0.72105f, 0.48428f, 0.18382f, -0.2945f, -0.7895f};
  WORD32 i;

  if (val >= p_qsteps[0]) {
    return 0;
  }
  for (i = 1; i < 6; i++) {
    if ((val >= p_qsteps[i]) && (val <= p_qsteps[i - 1])) {
      return i;
    }
  }
  return 7;
}

WORD32 ixheaace_mps_515_cld_quant(FLOAT32 val) {
  FLOAT32 p_qsteps[30] = {-47.5, -42.5, -37.5, -32.5, -27.5, -23.5, -20.5, -17.5, -14.5, -11.5,
                          -9.0,  -7.0,  -5.0,  -3.0,  -1.0,  1.0,   3.0,   5.0,   7.0,   9.0,
                          11.5,  14.5,  17.5,  20.5,  23.5,  27.5,  32.5,  37.5,  42.5,  47.5};

  WORD32 i;

  if (val < p_qsteps[0]) {
    return 0 - 15;
  }
  for (i = 1; i < 30; i++) {
    if ((val <= p_qsteps[i]) && (val >= p_qsteps[i - 1])) {
      return i - 15;
    }
  }
  return 30 - 15;
}

VOID ixheaace_mps_515_ttt_box(WORD32 slots, FLOAT32 *ptr_real1, FLOAT32 *ptr_imag1,
                              FLOAT32 *ptr_real2, FLOAT32 *ptr_imag2, FLOAT32 *ptr_real3,
                              FLOAT32 *ptr_imag3, WORD32 *ptr_qclds1, WORD32 *ptr_qclds2) {
  WORD32 i, j;

  FLOAT32 cld_s1[PARAMETER_BANDS] = {0};
  FLOAT32 cld_s2[PARAMETER_BANDS] = {0};
  FLOAT32 p_pow1[MAX_HYBRID_BANDS] = {0};
  FLOAT32 p_pow2[MAX_HYBRID_BANDS] = {0};
  FLOAT32 p_pow3[MAX_HYBRID_BANDS] = {0};

  FLOAT32 p_pow_par_band1[PARAMETER_BANDS] = {0};
  FLOAT32 p_pow_par_band2[PARAMETER_BANDS] = {0};
  FLOAT32 p_pow_par_band3[PARAMETER_BANDS] = {0};

  for (i = 0; i < slots; i++) {
    for (j = 0; j < MAX_HYBRID_BANDS; j++) {
      p_pow1[j] += ptr_real1[i * MAX_HYBRID_BANDS + j] * ptr_real1[i * MAX_HYBRID_BANDS + j] +
                   ptr_imag1[i * MAX_HYBRID_BANDS + j] * ptr_imag1[i * MAX_HYBRID_BANDS + j];
      p_pow2[j] += ptr_real2[i * MAX_HYBRID_BANDS + j] * ptr_real2[i * MAX_HYBRID_BANDS + j] +
                   ptr_imag2[i * MAX_HYBRID_BANDS + j] * ptr_imag2[i * MAX_HYBRID_BANDS + j];
      p_pow3[j] += ptr_real3[i * MAX_HYBRID_BANDS + j] * ptr_real3[i * MAX_HYBRID_BANDS + j] +
                   ptr_imag3[i * MAX_HYBRID_BANDS + j] * ptr_imag3[i * MAX_HYBRID_BANDS + j];

      ptr_real1[i * MAX_HYBRID_BANDS + j] =
          (ptr_real1[i * MAX_HYBRID_BANDS + j] + ptr_real3[i * MAX_HYBRID_BANDS + j] * 0.7071f);
      ptr_imag1[i * MAX_HYBRID_BANDS + j] =
          (ptr_imag1[i * MAX_HYBRID_BANDS + j] + ptr_imag3[i * MAX_HYBRID_BANDS + j] * 0.7071f);

      ptr_real2[i * MAX_HYBRID_BANDS + j] =
          (ptr_real2[i * MAX_HYBRID_BANDS + j] + ptr_real3[i * MAX_HYBRID_BANDS + j] * 0.7071f);
      ptr_imag2[i * MAX_HYBRID_BANDS + j] =
          (ptr_imag2[i * MAX_HYBRID_BANDS + j] + ptr_imag3[i * MAX_HYBRID_BANDS + j] * 0.7071f);
    }
  }
  for (i = 0; i < MAX_HYBRID_BANDS; i++) {
    p_pow_par_band1[kernels_20[i]] += p_pow1[i];
    p_pow_par_band2[kernels_20[i]] += p_pow2[i];
    p_pow_par_band3[kernels_20[i]] += p_pow3[i];
  }
  for (i = 0; i < PARAMETER_BANDS; i++) {
    if (p_pow_par_band3[i]) {
      cld_s1[i] = ((p_pow_par_band1[i] + p_pow_par_band2[i]) / (p_pow_par_band3[i]));
      cld_s1[i] = (FLOAT32)(10.0 * log(cld_s1[i] + 1e-10) / log(10.0));
    } else if ((p_pow_par_band1[i] + p_pow_par_band2[i]))
      cld_s1[i] = 50.0;
    else
      cld_s1[i] = -50;
    ptr_qclds1[i] = ixheaace_mps_515_cld_quant(cld_s1[i]);

    if (p_pow_par_band2[i]) {
      cld_s2[i] = (p_pow_par_band1[i] / (p_pow_par_band2[i]));
      cld_s2[i] = (FLOAT32)(10 * log(cld_s2[i] + 1e-10f) / log(10.0));
    } else if (p_pow_par_band1[i])
      cld_s2[i] = 50.0;
    else
      cld_s2[i] = -50;
    ptr_qclds2[i] = ixheaace_mps_515_cld_quant(cld_s2[i]);
  }
}

VOID ixheaace_mps_515_ott_box(WORD32 slots, FLOAT32 *ptr_real1, FLOAT32 *ptr_imag1,
                              FLOAT32 *ptr_real2, FLOAT32 *ptr_imag2, WORD32 *ptr_p_qclds,
                              WORD32 *ptr_qiccs) {
  WORD32 i, j;

  FLOAT32 clds[PARAMETER_BANDS] = {0};
  FLOAT32 iccs[PARAMETER_BANDS] = {0};
  FLOAT32 p_pow1[MAX_HYBRID_BANDS] = {0};
  FLOAT32 p_pow2[MAX_HYBRID_BANDS] = {0};
  FLOAT32 p_xcor_real[MAX_HYBRID_BANDS] = {0};

  FLOAT32 p_pow_par_band1[PARAMETER_BANDS] = {0};
  FLOAT32 p_pow_par_band2[PARAMETER_BANDS] = {0};
  FLOAT32 p_xcor_par_band[PARAMETER_BANDS] = {0};

  for (i = 0; i < slots; i++) {
    for (j = 0; j < MAX_HYBRID_BANDS; j++) {
      p_pow1[j] += ptr_real1[i * MAX_HYBRID_BANDS + j] * ptr_real1[i * MAX_HYBRID_BANDS + j] +
                   ptr_imag1[i * MAX_HYBRID_BANDS + j] * ptr_imag1[i * MAX_HYBRID_BANDS + j];
      p_pow2[j] += ptr_real2[i * MAX_HYBRID_BANDS + j] * ptr_real2[i * MAX_HYBRID_BANDS + j] +
                   ptr_imag2[i * MAX_HYBRID_BANDS + j] * ptr_imag2[i * MAX_HYBRID_BANDS + j];
      p_xcor_real[j] +=
          ptr_real1[i * MAX_HYBRID_BANDS + j] * ptr_real2[i * MAX_HYBRID_BANDS + j] +
          ptr_imag1[i * MAX_HYBRID_BANDS + j] * ptr_imag2[i * MAX_HYBRID_BANDS + j];

      ptr_real1[i * MAX_HYBRID_BANDS + j] =
          (ptr_real1[i * MAX_HYBRID_BANDS + j] + ptr_real2[i * MAX_HYBRID_BANDS + j]);
      ptr_imag1[i * MAX_HYBRID_BANDS + j] =
          (ptr_imag1[i * MAX_HYBRID_BANDS + j] + ptr_imag2[i * MAX_HYBRID_BANDS + j]);
    }
  }
  for (i = 0; i < MAX_HYBRID_BANDS; i++) {
    p_pow_par_band1[kernels_20[i]] += p_pow1[i];
    p_pow_par_band2[kernels_20[i]] += p_pow2[i];
    p_xcor_par_band[kernels_20[i]] += p_xcor_real[i];
  }
  for (i = 0; i < PARAMETER_BANDS; i++) {
    if (p_pow_par_band2[i]) {
      clds[i] = (p_pow_par_band1[i] / (p_pow_par_band2[i]));
      clds[i] = (FLOAT32)(10 * log(clds[i] + 1e-10) / log(10.0));
    } else if (p_pow_par_band1[i])
      clds[i] = 50.0;
    else
      clds[i] = -50;  // 0.0;
    iccs[i] =
        p_xcor_par_band[i] / (FLOAT32)sqrt((p_pow_par_band1[i] * p_pow_par_band2[i] + 1e-10));

    ptr_p_qclds[i] = ixheaace_mps_515_cld_quant(clds[i]);
    ptr_qiccs[i] = ixheaace_mps_515_icc_quant(iccs[i]);
  }
}

IA_ERRORCODE ixheaace_mps_212_write_spatial_specific_config(
    ixheaace_mps_spatial_specific_config *const pstr_spatial_specific_config,
    UWORD8 *const ptr_output_buffer, const WORD32 output_buffer_size,
    WORD32 *const ptr_output_bits, WORD32 aot) {
  IA_ERRORCODE error = IA_NO_ERROR;
  WORD32 bs_sampling_frequency_index = 0;
  WORD32 bs_freq_res = 0;
  ixheaace_bit_buf bit_buf;
  ixheaace_bit_buf_handle pstr_bit_buf =
      ia_enhaacplus_enc_create_bitbuffer(&bit_buf, ptr_output_buffer, output_buffer_size);

  error = ixheaace_mps_212_get_bs_freq_res_index(pstr_spatial_specific_config->num_bands,
                                                 &bs_freq_res, aot);
  if (error) {
    return error;
  }

  if (aot == AOT_AAC_ELD) {
    ixheaace_mps_212_get_sampling_frequency_index(
        pstr_spatial_specific_config->bs_sampling_frequency, &bs_sampling_frequency_index);
    ixheaace_write_bits(pstr_bit_buf, bs_sampling_frequency_index, 4);

    if (bs_sampling_frequency_index == 15) {
      ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_sampling_frequency, 24);
    }

    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_frame_length, 5);

    ixheaace_write_bits(pstr_bit_buf, bs_freq_res, 3);
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_tree_config, 4);
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_quant_mode, 2);

    ixheaace_write_bits(pstr_bit_buf, 0, 1);

    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_fixed_gain_dmx, 3);

    ixheaace_write_bits(pstr_bit_buf, 0, 2);
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_decorr_config, 2);

    ixheaace_byte_align_buffer(pstr_bit_buf);

    if ((*ptr_output_bits = ia_enhaacplus_enc_get_bits_available(pstr_bit_buf)) >
        (output_buffer_size * 8)) {
      return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
    }

    ixheaace_byte_align_buffer(pstr_bit_buf);
  } else {
    ixheaace_mps_212_get_sampling_frequency_index(
        pstr_spatial_specific_config->bs_sampling_frequency, &bs_sampling_frequency_index);
    ixheaace_write_bits(pstr_bit_buf, bs_freq_res, 3);

    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_fixed_gain_dmx, 3);

    ixheaace_write_bits(pstr_bit_buf, 0, 2);
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_specific_config->bs_decorr_config, 2);

    ixheaace_write_bits(pstr_bit_buf, 0, 1);
    ixheaace_write_bits(pstr_bit_buf, 0, 1);
    ixheaace_write_bits(pstr_bit_buf, 0, 1);

    ixheaace_write_bits(pstr_bit_buf, 0, 5);
    ixheaace_write_bits(pstr_bit_buf, 0, 1);

    *ptr_output_bits = ia_enhaacplus_enc_get_bits_available(pstr_bit_buf);
  }
  return error;
}

IA_ERRORCODE ixheaace_mps_212_write_spatial_frame(
    UWORD8 *const ptr_output_buffer, const WORD32 output_buffer_size,
    WORD32 *const ptr_output_bits, ixheaace_mps_pstr_bsf_instance pstr_bsf_instance, WORD32 aot) {
  IA_ERRORCODE error = IA_NO_ERROR;
  WORD32 i, j, num_param_sets, num_ott_boxes;
  ixheaace_mps_spatial_frame *pstr_spatial_frame = NULL;
  ixheaace_mps_spatial_specific_config *pstr_specific_config = NULL;
  ixheaace_bit_buf bit_buf;
  ixheaace_bit_buf_handle pstr_bit_buf =
      ia_enhaacplus_enc_create_bitbuffer(&bit_buf, ptr_output_buffer, output_buffer_size);
  pstr_spatial_frame = &pstr_bsf_instance->frame;
  pstr_specific_config = &pstr_bsf_instance->spatial_specific_config;
  num_ott_boxes = pstr_bsf_instance->spatial_specific_config.tree_description.num_ott_boxes;
  num_param_sets = pstr_spatial_frame->framing_info.num_param_sets;

  if (pstr_spatial_frame->b_use_bb_cues) {
    for (i = 0; i < IXHEAACE_MPS_MAX_NUM_BOXES; i++) {
      if (num_param_sets == 1) {
        pstr_spatial_frame->cld_lossless_data.bs_freq_res_stride_xxx[i][0] = 3;
        pstr_spatial_frame->icc_lossless_data.bs_freq_res_stride_xxx[i][0] = 3;
      } else {
        for (j = 1; j < MAX_NUM_PARAMS; j++) {
          pstr_spatial_frame->cld_lossless_data.bs_freq_res_stride_xxx[i][j] = 3;
          pstr_spatial_frame->icc_lossless_data.bs_freq_res_stride_xxx[i][j] = 3;
        }
      }
    }
  }

  if (aot == AOT_AAC_ELD) {
    ixheaace_mps_212_write_framing_info(
        pstr_bit_buf, &(pstr_spatial_frame->framing_info),
        pstr_bsf_instance->spatial_specific_config.bs_frame_length);
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->bs_independency_flag, 1);
  } else if (aot == AOT_USAC) {
    if (!pstr_spatial_frame->bs_independency_flag) {
      ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->bs_independency_flag, 1);
    }
  }
  error = ixheaace_mps_212_write_ott_data(
      pstr_bit_buf, &pstr_bsf_instance->prev_frame_data.prev_ott_data,
      &pstr_spatial_frame->ott_data, pstr_specific_config->ott_config,
      &pstr_spatial_frame->cld_lossless_data, &pstr_spatial_frame->icc_lossless_data,
      num_ott_boxes, pstr_specific_config->num_bands, num_param_sets,
      pstr_spatial_frame->bs_independency_flag);
  if (error != IA_NO_ERROR) {
    return error;
  }
  if (aot == AOT_AAC_ELD) {
    ixheaace_mps_212_write_smg_data(pstr_bit_buf, &pstr_spatial_frame->smg_data, num_param_sets,
                                    pstr_specific_config->num_bands);
  }

  *ptr_output_bits = ia_enhaacplus_enc_get_bits_available(pstr_bit_buf);
  if ((*ptr_output_bits) > (output_buffer_size * 8)) {
    return IA_EXHEAACE_CONFIG_NONFATAL_MPS_INVALID_CONFIG;
  }
  return error;
}

IA_ERRORCODE
ixheaace_mps_515_write_spatial_specific_config(ixheaace_bit_buf_handle pstr_bit_buf,
                                               ixheaace_mps_sac_bsf_instance *pstr_bsf_instance) {
  WORD32 idx, box, bin;
  WORD32 bs_sampling_frequency_index;
  ixheaace_mps_sac_spatial_frame *pstr_spatial_frame = &(pstr_bsf_instance->current_frame);
  ixheaace_mps_sac_specific_config *pstr_specific_config =
      &(pstr_bsf_instance->spatial_specific_config);
  ixheaace_mps_sac_tree_description *pstr_tree_description =
      &(pstr_specific_config->tree_description);

  pstr_tree_description->num_ott_boxes =
      tree_config_table[pstr_specific_config->bs_tree_config].num_ott_boxes;
  pstr_tree_description->num_ttt_boxes =
      tree_config_table[pstr_specific_config->bs_tree_config].num_ttt_boxes;
  pstr_tree_description->num_in_chan =
      tree_config_table[pstr_specific_config->bs_tree_config].num_in_chan;
  pstr_tree_description->num_out_chan =
      tree_config_table[pstr_specific_config->bs_tree_config].num_out_chan;

  if (pstr_specific_config->bs_temp_shape_config == 2) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_GUIDED_ENV_SHAPE;
  }

  if (pstr_specific_config->bs_3d_audio_mode > 0) {
    return IA_EXHEAACE_EXE_FATAL_MPS_3D_STEREO_MODE_NOT_SUPPORTED;
  }

  if (pstr_specific_config->bs_residual_coding == 1) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_RESIDUAL_CODING;
  }
  if (pstr_specific_config->bs_arbitrary_downmix == 2) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_ARBITARY_DOWNMIX_CODING;
  }
  if (pstr_specific_config->tree_description.arbitrary_tree) {
    return IA_EXHEAACE_EXE_FATAL_MPS_ARBITARY_TREE_NOT_SUPPORTED;
  }

  for (box = 0; box < MAX_NUM_BOXES; box++) {
    pstr_tree_description->ott_mode_lfe[box] =
        tree_config_table[pstr_specific_config->bs_tree_config].ott_mode_lfe[box];
  }
  pstr_bsf_instance->num_bins = freq_res_bin_table[pstr_specific_config->bs_freq_res];

  bs_sampling_frequency_index = 15;
  for (idx = 0; idx < 15; idx++) {
    if (pstr_specific_config->bs_sampling_frequency == ia_sampl_freq_table[idx]) {
      bs_sampling_frequency_index = idx;
      break;
    }
  }

  ixheaace_write_bits(pstr_bit_buf, bs_sampling_frequency_index, 4);
  if (bs_sampling_frequency_index == 15) {
    ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_sampling_frequency, 24);
  }
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_frame_length, 5);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_freq_res, 3);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_tree_config, 4);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_quant_mode, 2);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_one_icc, 1);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_arbitrary_downmix, 1);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_fixed_gain_sur, 3);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_fixed_gain_lfe, 3);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_fixed_gain_dmx, 3);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_matrix_mode, 1);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_temp_shape_config, 2);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_decorr_config, 2);
  ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->bs_3d_audio_mode, 1);

  for (box = 0; box < pstr_tree_description->num_ott_boxes; box++) {
    if (pstr_tree_description->ott_mode_lfe[box]) {
      ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->ott_config[box].bs_ott_bands, 5);
    }
  }
  for (box = 0; box < pstr_tree_description->num_ttt_boxes; box++) {
    ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->ttt_config[box].bs_ttt_dual_mode, 1);
    ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->ttt_config[box].bs_ttt_mode_low, 3);
    if (pstr_specific_config->ttt_config[box].bs_ttt_dual_mode == 1) {
      ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->ttt_config[box].bs_ttt_mode_high,
                          3);
      ixheaace_write_bits(pstr_bit_buf, pstr_specific_config->ttt_config[box].bs_ttt_bands_low,
                          5);
    }
  }
  ixheaace_byte_align_buffer(pstr_bit_buf);

  for (box = 0; box < MAX_NUM_BOXES; box++) {
    pstr_specific_config->ttt_config[box].bs_ttt_bands_low = pstr_bsf_instance->num_bins;
    for (bin = 0; bin < MAX_NUM_BINS; bin++) {
      pstr_spatial_frame->ott_data.cld_old[box][bin] = 0;
      pstr_spatial_frame->ott_data.icc_old[box][bin] = 0;
      pstr_spatial_frame->ttt_data.cpc_cld1_old[box][bin] = 0;
      pstr_spatial_frame->ttt_data.cpc_cld2_old[box][bin] = 0;
      pstr_spatial_frame->ttt_data.icc_old[box][bin] = 0;
    }
  }

  for (box = 0; box < pstr_tree_description->num_ott_boxes; box++) {
    if (!pstr_tree_description->ott_mode_lfe[box]) {
      pstr_specific_config->ott_config[box].bs_ott_bands = pstr_bsf_instance->num_bins;
    }
    if (!pstr_specific_config->ttt_config[box].bs_ttt_dual_mode) {
      pstr_specific_config->ttt_config[box].bs_ttt_bands_low = pstr_bsf_instance->num_bins;
    }
  }

  return IA_NO_ERROR;
}

IA_ERRORCODE
ixheaace_mps_515_write_spatial_frame(ixheaace_bit_buf_handle pstr_bit_buf,
                                     ixheaace_mps_sac_bsf_instance *pstr_bsf_instance) {
  IA_ERRORCODE error = IA_NO_ERROR;
  UWORD8 bits_param_slot;
  WORD32 param, box, ch, bin;
  WORD32 prev_bs_param_slot, num_temp_shape_chan;
  ixheaace_mps_sac_spatial_frame *pstr_spatial_frame = &(pstr_bsf_instance->current_frame);
  ixheaace_mps_sac_specific_config *pstr_specific_config =
      &(pstr_bsf_instance->spatial_specific_config);
  WORD32 bs_independency_flag = pstr_spatial_frame->bs_independency_flag;
  WORD32 num_param_sets = pstr_spatial_frame->framing_info.bs_num_param_sets;
  WORD32 num_ott_boxes =
      pstr_bsf_instance->spatial_specific_config.tree_description.num_ott_boxes;
  WORD32 num_ttt_boxes =
      pstr_bsf_instance->spatial_specific_config.tree_description.num_ttt_boxes;
  WORD32 *ptr_ott_mode_lfe =
      pstr_bsf_instance->spatial_specific_config.tree_description.ott_mode_lfe;

  if (pstr_specific_config->bs_arbitrary_downmix) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_ARBITARY_DOWNMIX_CODING;
  }
  if (pstr_specific_config->bs_residual_coding == 1) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_RESIDUAL_CODING;
  }
  if (pstr_specific_config->bs_arbitrary_downmix == 2) {
    return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_ARBITARY_DOWNMIX_CODING;
  }
  if (pstr_specific_config->tree_description.arbitrary_tree) {
    return IA_EXHEAACE_EXE_FATAL_MPS_ARBITARY_TREE_NOT_SUPPORTED;
  }
  ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->framing_info.bs_framing_type, 1);
  ixheaace_write_bits(pstr_bit_buf, num_param_sets - 1, 1);

  if (pstr_spatial_frame->framing_info.bs_framing_type) {
    prev_bs_param_slot = -1;

    for (param = 0; param < num_param_sets; param++) {
      bits_param_slot = 0;
      while ((1 << bits_param_slot) < (pstr_specific_config->bs_frame_length + 1 -
                                       num_param_sets + param - prev_bs_param_slot)) {
        bits_param_slot++;
      }

      if (bits_param_slot > 0) {
        ixheaace_write_bits(
            pstr_bit_buf,
            pstr_spatial_frame->framing_info.bs_param_slots[param] - prev_bs_param_slot - 1,
            bits_param_slot);
      }
      prev_bs_param_slot = pstr_spatial_frame->framing_info.bs_param_slots[param];
    }
  }

  ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->bs_independency_flag, 1);

  for (box = 0; box < num_ott_boxes; box++) {
    error = ixheaace_mps_515_ec_data(
        pstr_bit_buf, pstr_spatial_frame->ott_data.cld[box],
        pstr_spatial_frame->ott_data.cld_old[box], &(pstr_spatial_frame->cld_lossless_data),
        IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box, num_param_sets, bs_independency_flag, 0,
        pstr_specific_config->ott_config[box].bs_ott_bands);
    if (error) {
      return error;
    }
  }
  if (!pstr_bsf_instance->spatial_specific_config.bs_one_icc) {
    for (box = 0; box < num_ott_boxes; box++) {
      if (!ptr_ott_mode_lfe[box]) {
        error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ott_data.icc[box],
                                         pstr_spatial_frame->ott_data.icc_old[box],
                                         &(pstr_spatial_frame->cld_lossless_data),
                                         IXHEAACE_MPS_SAC_DATA_TYPE_ICC, box, num_param_sets,
                                         bs_independency_flag, 0, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
      }
    }
  } else {
    error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ott_data.icc[0],
                                     pstr_spatial_frame->ott_data.icc_old[0],
                                     &(pstr_spatial_frame->cld_lossless_data),
                                     IXHEAACE_MPS_SAC_DATA_TYPE_ICC, 0, num_param_sets,
                                     bs_independency_flag, 0, pstr_bsf_instance->num_bins);
    if (error) {
      return error;
    }
  }
  for (box = 0; box < num_ttt_boxes; box++) {
    if (pstr_specific_config->ttt_config[box].bs_ttt_mode_low >= 2) {
      error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld1[box],
                                       pstr_spatial_frame->ttt_data.cpc_cld1_old[box],
                                       &(pstr_spatial_frame->cld_lossless_data),
                                       IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box, num_param_sets,
                                       bs_independency_flag, 0,
                                       pstr_specific_config->ttt_config[box].bs_ttt_bands_low);
      if (error) {
        return error;
      }
      error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld2[box],
                                       pstr_spatial_frame->ttt_data.cpc_cld2_old[box],
                                       &(pstr_spatial_frame->cld_lossless_data),
                                       IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box, num_param_sets,
                                       bs_independency_flag, 0,
                                       pstr_specific_config->ttt_config[box].bs_ttt_bands_low);
      if (error) {
        return error;
      }
    } else {
      error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld1[box],
                                       pstr_spatial_frame->ttt_data.cpc_cld1_old[box],
                                       &(pstr_spatial_frame->cpc_lossless_data),
                                       IXHEAACE_MPS_SAC_DATA_TYPE_CPC, box, num_param_sets,
                                       bs_independency_flag, 0,
                                       pstr_specific_config->ttt_config[box].bs_ttt_bands_low);
      if (error) {
        return error;
      }
      error = ixheaace_mps_515_ec_data(pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld2[box],
                                       pstr_spatial_frame->ttt_data.cpc_cld2_old[box],
                                       &(pstr_spatial_frame->cpc_lossless_data),
                                       IXHEAACE_MPS_SAC_DATA_TYPE_CPC, box, num_param_sets,
                                       bs_independency_flag, 0,
                                       pstr_specific_config->ttt_config[box].bs_ttt_bands_low);
      if (error) {
        return error;
      }
      error = ixheaace_mps_515_ec_data(
          pstr_bit_buf, pstr_spatial_frame->ttt_data.icc[box],
          pstr_spatial_frame->ttt_data.icc_old[box], &(pstr_spatial_frame->icc_lossless_data),
          IXHEAACE_MPS_SAC_DATA_TYPE_ICC, box, num_param_sets, bs_independency_flag, 0,
          pstr_specific_config->ttt_config[box].bs_ttt_bands_low);
      if (error) {
        return error;
      }
    }

    if (pstr_specific_config->ttt_config[box].bs_ttt_dual_mode) {
      if (pstr_specific_config->ttt_config[box].bs_ttt_mode_high >= 2) {
        error = ixheaace_mps_515_ec_data(
            pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld1[box],
            pstr_spatial_frame->ttt_data.cpc_cld1_old[box],
            &(pstr_spatial_frame->cld_lossless_data), IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box,
            num_param_sets, bs_independency_flag,
            pstr_specific_config->ttt_config[box].bs_ttt_bands_low, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
        error = ixheaace_mps_515_ec_data(
            pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld2[box],
            pstr_spatial_frame->ttt_data.cpc_cld2_old[box],
            &(pstr_spatial_frame->cld_lossless_data), IXHEAACE_MPS_SAC_DATA_TYPE_CLD, box,
            num_param_sets, bs_independency_flag,
            pstr_specific_config->ttt_config[box].bs_ttt_bands_low, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
      } else {
        error = ixheaace_mps_515_ec_data(
            pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld1[box],
            pstr_spatial_frame->ttt_data.cpc_cld1_old[box],
            &(pstr_spatial_frame->cpc_lossless_data), IXHEAACE_MPS_SAC_DATA_TYPE_CPC, box,
            num_param_sets, bs_independency_flag,
            pstr_specific_config->ttt_config[box].bs_ttt_bands_low, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
        error = ixheaace_mps_515_ec_data(
            pstr_bit_buf, pstr_spatial_frame->ttt_data.cpc_cld2[box],
            pstr_spatial_frame->ttt_data.cpc_cld2_old[box],
            &(pstr_spatial_frame->cpc_lossless_data), IXHEAACE_MPS_SAC_DATA_TYPE_CPC, box,
            num_param_sets, bs_independency_flag,
            pstr_specific_config->ttt_config[box].bs_ttt_bands_low, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
        error = ixheaace_mps_515_ec_data(
            pstr_bit_buf, pstr_spatial_frame->ttt_data.icc[box],
            pstr_spatial_frame->ttt_data.icc_old[box], &(pstr_spatial_frame->icc_lossless_data),
            IXHEAACE_MPS_SAC_DATA_TYPE_ICC, box, num_param_sets, bs_independency_flag,
            pstr_specific_config->ttt_config[box].bs_ttt_bands_low, pstr_bsf_instance->num_bins);
        if (error) {
          return error;
        }
      }
    }
  }
  for (param = 0; param < num_param_sets; param++) {
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->smg_data.bs_smooth_mode[param], 2);

    if (pstr_spatial_frame->smg_data.bs_smooth_mode[param] >= 2) {
      ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->smg_data.bs_smooth_time[param], 2);
    }
    if (pstr_spatial_frame->smg_data.bs_smooth_mode[param] == 3) {
      ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->smg_data.bs_freq_res_stride[param],
                          2);
      for (bin = 0; bin < pstr_bsf_instance->num_bins;
           bin += pstr_spatial_frame->smg_data.bs_freq_res_stride[param]) {
        ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->smg_data.bs_smg_data[param][bin],
                            1);
      }
    }
  }
  if (pstr_specific_config->bs_temp_shape_config != 0) {
    ixheaace_write_bits(pstr_bit_buf, pstr_spatial_frame->temp_shape_data.bs_temp_shape_enable,
                        1);
    if (pstr_spatial_frame->temp_shape_data.bs_temp_shape_enable) {
      num_temp_shape_chan = temp_shape_chan_table[pstr_specific_config->bs_temp_shape_config - 1]
                                                 [pstr_specific_config->bs_tree_config];
      for (ch = 0; ch < num_temp_shape_chan; ch++) {
        ixheaace_write_bits(pstr_bit_buf,
                            pstr_spatial_frame->temp_shape_data.bs_temp_shape_enable_channel[ch],
                            1);
      }
      if (pstr_specific_config->bs_temp_shape_config == 2) {
        return IA_EXHEAACE_EXE_FATAL_MPS_UNSUPPORTED_GUIDED_ENV_SHAPE;
      }
    }
  }

  ixheaace_byte_align_buffer(pstr_bit_buf);

  return IA_NO_ERROR;
}

Coverage Report

Created: 2025-07-12 07:02