1 /******************************************************************************
2 *
3 * Copyright (C) 2023 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 #include <string.h>
21 #include "ixheaacd_type_def.h"
22 #include "ixheaacd_mps_struct_def.h"
23 #include "ixheaacd_error_codes.h"
24 #include "ixheaacd_bitbuffer.h"
25 #include "ixheaacd_mps_res_rom.h"
26 #include "ixheaacd_mps_aac_struct.h"
27 #include "ixheaacd_mps_res_channel.h"
28 #include "ixheaacd_constants.h"
29 #include "ixheaacd_cnst.h"
30 #include "ixheaacd_common_rom.h"
31 #include "ixheaacd_sbrdecsettings.h"
32 #include "ixheaacd_sbr_scale.h"
33 #include "ixheaacd_env_extr_part.h"
34 #include "ixheaacd_sbr_rom.h"
35 #include "ixheaacd_hybrid.h"
36 #include "ixheaacd_ps_dec.h"
37 #include "ixheaacd_mps_polyphase.h"
38 #include "ixheaacd_error_standards.h"
39 #include "ixheaacd_config.h"
40 #include "ixheaacd_qmf_dec.h"
41 #include "ixheaacd_mps_dec.h"
42 #include "ixheaacd_mps_interface.h"
43 #include "ixheaacd_mps_macro_def.h"
44 #include "ixheaacd_mps_nlc_dec.h"
45 #include "ixheaacd_mps_bitdec.h"
46 #include "ixheaacd_mps_res_tns.h"
47 #include "ixheaacd_mps_mdct_2_qmf.h"
48 #include "ixheaacd_sbr_const.h"
49
ixheaacd_parse_extension_config(ia_mps_spatial_bs_config_struct * config,WORD32 num_ott_boxes,WORD32 num_ttt_boxes,WORD32 num_out_chan,WORD32 bits_available,ia_bit_buf_struct * it_bit_buff,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)50 static IA_ERRORCODE ixheaacd_parse_extension_config(
51 ia_mps_spatial_bs_config_struct *config, WORD32 num_ott_boxes, WORD32 num_ttt_boxes,
52 WORD32 num_out_chan, WORD32 bits_available, ia_bit_buf_struct *it_bit_buff,
53 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
54 WORD32 i, ch, idx, tmp, tmp_open, sac_ext_len, bits_read, n_fill_bits, temp;
55 WORD32 ba = bits_available;
56
57 config->sac_ext_cnt = 0;
58
59 while (ba >= 8) {
60 ba -= 8;
61 temp = ixheaacd_read_bits_buf(it_bit_buff, 8);
62 config->bs_sac_ext_type[config->sac_ext_cnt] = (temp >> 4) & FOUR_BIT_MASK;
63 sac_ext_len = temp & FOUR_BIT_MASK;
64 if (sac_ext_len == 15) {
65 sac_ext_len += ixheaacd_read_bits_buf(it_bit_buff, 8);
66 ba -= 8;
67 if (sac_ext_len == 15 + 255) {
68 sac_ext_len += ixheaacd_read_bits_buf(it_bit_buff, 16);
69 ba -= 16;
70 }
71 }
72
73 tmp = (WORD32)(((it_bit_buff->ptr_read_next - it_bit_buff->ptr_bit_buf_base + 1) << 3) -
74 (it_bit_buff->bit_pos + 1));
75
76 switch (config->bs_sac_ext_type[config->sac_ext_cnt]) {
77 case EXT_TYPE_0:
78 config->bs_residual_coding = 1;
79 temp = ixheaacd_read_bits_buf(it_bit_buff, 6);
80 config->bs_residual_sampling_freq_index = (temp >> 2) & FOUR_BIT_MASK;
81 config->bs_residual_frames_per_spatial_frame = temp & TWO_BIT_MASK;
82
83 for (i = 0; i < num_ott_boxes + num_ttt_boxes; i++) {
84 config->bs_residual_present[i] = ixheaacd_read_bits_buf(it_bit_buff, 1);
85 if (config->bs_residual_present[i]) {
86 config->bs_residual_bands[i] = ixheaacd_read_bits_buf(it_bit_buff, 5);
87 }
88 }
89 break;
90
91 case EXT_TYPE_1:
92 config->bs_arbitrary_downmix = 2;
93
94 temp = ixheaacd_read_bits_buf(it_bit_buff, 11);
95 config->bs_arbitrary_downmix_residual_sampling_freq_index = (temp >> 7) & FOUR_BIT_MASK;
96 config->bs_arbitrary_downmix_residual_frames_per_spatial_frame =
97 (temp >> 5) & TWO_BIT_MASK;
98 config->bs_arbitrary_downmix_residual_bands = temp & FIVE_BIT_MASK;
99
100 break;
101
102 case EXT_TYPE_2:
103 config->arbitrary_tree = 1;
104 config->num_out_chan_at = 0;
105 config->num_ott_boxes_at = 0;
106 for (ch = 0; ch < num_out_chan; ch++) {
107 tmp_open = 1;
108 idx = 0;
109 while (tmp_open > 0) {
110 config->bs_ott_box_present_at[ch][idx] = ixheaacd_read_bits_buf(it_bit_buff, 1);
111 if (config->bs_ott_box_present_at[ch][idx]) {
112 config->num_ott_boxes_at++;
113 tmp_open++;
114 } else {
115 config->num_out_chan_at++;
116 tmp_open--;
117 }
118 if (config->num_ott_boxes_at >= 56) return IA_FATAL_ERROR;
119 idx++;
120 if (idx >= MAX_ARBITRARY_TREE_INDEX) return IA_FATAL_ERROR;
121 }
122 }
123
124 for (i = 0; i < config->num_ott_boxes_at; i++) {
125 temp = ixheaacd_read_bits_buf(it_bit_buff, 2);
126 config->bs_ott_default_cld_at[i] = (temp >> 1) & ONE_BIT_MASK;
127 config->bs_ott_mode_lfe_at[i] = temp & ONE_BIT_MASK;
128 if (config->bs_ott_mode_lfe_at[i]) {
129 config->bs_ott_bands_at[i] = ixheaacd_read_bits_buf(it_bit_buff, 5);
130 if (config->bs_ott_bands_at[i] > MAX_PARAMETER_BANDS) return IA_FATAL_ERROR;
131 } else {
132 config->bs_ott_bands_at[i] =
133 ixheaacd_mps_dec_bitdec_tables->freq_res_table[config->bs_freq_res];
134 }
135 }
136
137 for (i = 0; i < config->num_out_chan_at; i++) {
138 config->bs_output_channel_pos_at[i] = ixheaacd_read_bits_buf(it_bit_buff, 5);
139 }
140
141 break;
142
143 default:
144 return IA_XHEAAC_MPS_DEC_EXE_NONFATAL_INVALID_EXTENSION_TYPE;
145 }
146
147 bits_read = (WORD32)(((it_bit_buff->ptr_read_next - it_bit_buff->ptr_bit_buf_base + 1) << 3) -
148 (it_bit_buff->bit_pos + 1) - tmp);
149 n_fill_bits = 8 * sac_ext_len - bits_read;
150
151 while (n_fill_bits > 7) {
152 ixheaacd_read_bits_buf(it_bit_buff, 8);
153 n_fill_bits -= 8;
154 }
155 if (n_fill_bits > 0) {
156 ixheaacd_read_bits_buf(it_bit_buff, n_fill_bits);
157 }
158
159 ba -= 8 * sac_ext_len;
160 config->sac_ext_cnt++;
161 if (config->sac_ext_cnt >= MAX_NUM_EXT_TYPES) {
162 return IA_FATAL_ERROR;
163 }
164 }
165
166 return IA_NO_ERROR;
167 }
168
ixheaacd_parse_specific_config(ia_heaac_mps_state_struct * pstr_mps_state,WORD32 sac_header_len)169 IA_ERRORCODE ixheaacd_parse_specific_config(ia_heaac_mps_state_struct *pstr_mps_state,
170 WORD32 sac_header_len) {
171 IA_ERRORCODE err_code = IA_NO_ERROR;
172 ia_mps_spatial_bs_config_struct *config = &(pstr_mps_state->bs_config);
173 ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
174 const ia_mps_dec_tree_properties_struct *p_tree_property_table =
175 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr->tree_property_table;
176 ia_bit_buf_struct *mps_bit_buf = pstr_mps_state->ptr_mps_bit_buff;
177
178 WORD32 i, hc, hb, num_header_bits, ott_mode_lfe[MAX_NUM_OTT];
179
180 WORD32 tmp = (WORD32)(((mps_bit_buf->ptr_read_next - mps_bit_buf->ptr_bit_buf_base + 1) << 3) -
181 (mps_bit_buf->bit_pos + 1));
182 WORD32 bits_available = (sac_header_len << 3);
183 WORD32 temp, alignment_bits = 0;
184
185 config->bs_sampling_freq_index = ixheaacd_read_bits_buf(mps_bit_buf, 4);
186 if (config->bs_sampling_freq_index == 15) {
187 config->bs_sampling_frequency = ixheaacd_read_bits_buf(mps_bit_buf, 24);
188 }
189 temp = ixheaacd_read_bits_buf(mps_bit_buf, 14);
190 config->bs_frame_length = (temp >> 7) & SEVEN_BIT_MASK;
191 if (config->bs_frame_length >= (MAX_QMF_BUF_LEN - 1)) {
192 return IA_FATAL_ERROR;
193 }
194 config->bs_freq_res = (temp >> 4) & THREE_BIT_MASK;
195 if (config->bs_freq_res == 0) {
196 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_PARAMETER_BANDS;
197 }
198 config->bs_tree_config = (temp)&FOUR_BIT_MASK;
199
200 if (config->bs_tree_config >= 7) {
201 return IA_FATAL_ERROR;
202 }
203
204 if (config->bs_tree_config != 15) {
205 curr_state->num_ott_boxes = p_tree_property_table[config->bs_tree_config].num_ott_boxes;
206 curr_state->num_ttt_boxes = p_tree_property_table[config->bs_tree_config].num_ttt_boxes;
207 curr_state->num_input_channels =
208 p_tree_property_table[config->bs_tree_config].num_input_channels;
209 curr_state->num_output_channels =
210 p_tree_property_table[config->bs_tree_config].num_output_channels;
211 for (i = 0; i < MAX_NUM_OTT; i++) {
212 ott_mode_lfe[i] = p_tree_property_table[config->bs_tree_config].ott_mode_lfe[i];
213 }
214 }
215 temp = ixheaacd_read_bits_buf(mps_bit_buf, 19);
216 config->bs_quant_mode = (temp >> 17) & TWO_BIT_MASK;
217 config->bs_one_icc = (temp >> 16) & ONE_BIT_MASK;
218 config->bs_arbitrary_downmix = (temp >> 15) & ONE_BIT_MASK;
219 config->bs_fixed_gain_sur = (temp >> 12) & THREE_BIT_MASK;
220 if (config->bs_fixed_gain_sur >= 5) {
221 return IA_FATAL_ERROR;
222 }
223 config->bs_fixed_gain_lfe = (temp >> 9) & THREE_BIT_MASK;
224
225 if (config->bs_fixed_gain_lfe >= 5) return IA_FATAL_ERROR;
226 config->bs_fixed_gain_dmx = (temp >> 6) & THREE_BIT_MASK;
227 config->bs_matrix_mode = (temp >> 5) & ONE_BIT_MASK;
228 config->bs_temp_shape_config = (temp >> 3) & TWO_BIT_MASK;
229 config->bs_decorr_config = (temp >> 1) & TWO_BIT_MASK;
230 config->bs_3d_audio_mode = (temp)&ONE_BIT_MASK;
231
232 for (i = 0; i < curr_state->num_ott_boxes; i++) {
233 if (ott_mode_lfe[i]) {
234 config->bs_ott_bands[i] = ixheaacd_read_bits_buf(mps_bit_buf, 5);
235 if (config->bs_ott_bands[i] > MAX_PARAMETER_BANDS) return IA_FATAL_ERROR;
236 }
237 }
238
239 for (i = 0; i < curr_state->num_ttt_boxes; i++) {
240 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
241 config->bs_ttt_dual_mode[i] = (temp >> 3) & ONE_BIT_MASK;
242 config->bs_ttt_mode_low[i] = (temp)&THREE_BIT_MASK;
243 if (config->bs_ttt_dual_mode[i]) {
244 temp = ixheaacd_read_bits_buf(mps_bit_buf, 8);
245 config->bs_ttt_mode_high[i] = (temp >> 5) & THREE_BIT_MASK;
246 config->bs_ttt_bands_low[i] = (temp)&FIVE_BIT_MASK;
247 if (config->bs_ttt_bands_low[i] > MAX_PARAMETER_BANDS) return IA_FATAL_ERROR;
248 }
249 }
250
251 if (config->bs_temp_shape_config == 2) {
252 config->bs_env_quant_mode = ixheaacd_read_bits_buf(mps_bit_buf, 1);
253 }
254
255 if (config->bs_3d_audio_mode) {
256 config->bs_3d_audio_hrtf_set = ixheaacd_read_bits_buf(mps_bit_buf, 2);
257 if (config->bs_3d_audio_hrtf_set == 0) {
258 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
259 config->bs_hrtf_freq_res = (temp >> 1) & THREE_BIT_MASK;
260 config->bs_hrtf_num_chan = 5;
261 config->bs_hrtf_asymmetric = (temp)&ONE_BIT_MASK;
262
263 config->hrtf_num_band = pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr
264 ->freq_res_table[config->bs_hrtf_freq_res];
265
266 for (hc = 0; hc < config->bs_hrtf_num_chan; hc++) {
267 for (hb = 0; hb < config->hrtf_num_band; hb++) {
268 config->bs_hrtf_level_left[hc][hb] = ixheaacd_read_bits_buf(mps_bit_buf, 6);
269 }
270 for (hb = 0; hb < config->hrtf_num_band; hb++) {
271 config->bs_hrtf_level_right[hc][hb] = config->bs_hrtf_asymmetric
272 ? ixheaacd_read_bits_buf(mps_bit_buf, 6)
273 : config->bs_hrtf_level_left[hc][hb];
274 }
275 config->bs_hrtf_phase[hc] = ixheaacd_read_bits_buf(mps_bit_buf, 1);
276 for (hb = 0; hb < config->hrtf_num_band; hb++) {
277 config->bs_hrtf_phase_lr[hc][hb] =
278 config->bs_hrtf_phase[hc] ? ixheaacd_read_bits_buf(mps_bit_buf, 6) : 0;
279 }
280 }
281 }
282 }
283
284 ixheaacd_byte_align(mps_bit_buf, &alignment_bits);
285
286 num_header_bits =
287 (WORD32)(((mps_bit_buf->ptr_read_next - mps_bit_buf->ptr_bit_buf_base + 1) << 3) -
288 (mps_bit_buf->bit_pos + 1) - tmp);
289 bits_available -= num_header_bits;
290
291 err_code = ixheaacd_parse_extension_config(
292 config, curr_state->num_ott_boxes, curr_state->num_ttt_boxes,
293 curr_state->num_output_channels, bits_available, mps_bit_buf,
294 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr);
295 if (err_code != IA_NO_ERROR) return err_code;
296
297 return IA_NO_ERROR;
298 }
299
ixheaacd_default_specific_config(ia_heaac_mps_state_struct * pstr_mps_state,WORD32 sampling_freq)300 IA_ERRORCODE ixheaacd_default_specific_config(ia_heaac_mps_state_struct *pstr_mps_state,
301 WORD32 sampling_freq) {
302 ia_mps_spatial_bs_config_struct *config = &(pstr_mps_state->bs_config);
303 ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
304 const ia_mps_dec_tree_properties_struct *p_tree_property_table =
305 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr->tree_property_table;
306 WORD32 i, ott_mode_lfe[MAX_NUM_OTT];
307
308 config->bs_sampling_freq_index = 15;
309 for (i = 0; i < 15; i++) {
310 if (sampling_freq ==
311 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr->sampling_freq_table[i]) {
312 config->bs_sampling_freq_index = i;
313 }
314 }
315 if (config->bs_sampling_freq_index == 15) {
316 config->bs_sampling_frequency = sampling_freq;
317 }
318 config->bs_frame_length = 31;
319 config->bs_freq_res = 1;
320 config->bs_tree_config = 2;
321 if (config->bs_tree_config > 5) return IA_XHEAAC_MPS_DEC_EXE_FATAL_UNSUPPRORTED_TREE_CONFIG;
322 if (config->bs_tree_config != 15) {
323 curr_state->num_ott_boxes = p_tree_property_table[config->bs_tree_config].num_ott_boxes;
324 curr_state->num_ttt_boxes = p_tree_property_table[config->bs_tree_config].num_ttt_boxes;
325 curr_state->num_input_channels =
326 p_tree_property_table[config->bs_tree_config].num_input_channels;
327 curr_state->num_output_channels =
328 p_tree_property_table[config->bs_tree_config].num_output_channels;
329 memcpy(ott_mode_lfe, p_tree_property_table[config->bs_tree_config].ott_mode_lfe,
330 MAX_NUM_OTT * sizeof(ott_mode_lfe[0]));
331 }
332 config->bs_quant_mode = 0;
333 config->bs_one_icc = 0;
334 config->bs_arbitrary_downmix = 0;
335 config->bs_residual_coding = 0;
336 config->bs_smooth_config = 0;
337 config->bs_fixed_gain_sur = 2;
338 config->bs_fixed_gain_lfe = 1;
339 config->bs_fixed_gain_dmx = 0;
340 config->bs_matrix_mode = 1;
341 config->bs_temp_shape_config = 0;
342 config->bs_decorr_config = 0;
343 if (config->bs_tree_config == 15) {
344 return IA_XHEAAC_MPS_DEC_EXE_FATAL_UNSUPPRORTED_TREE_CONFIG;
345 }
346 for (i = 0; i < curr_state->num_ott_boxes; i++) {
347 if (ott_mode_lfe[i]) {
348 config->bs_ott_bands[i] = 28;
349 }
350 }
351 for (i = 0; i < curr_state->num_ttt_boxes; i++) {
352 config->bs_ttt_dual_mode[i] = 0;
353 config->bs_ttt_mode_low[i] = 1;
354 if (config->bs_ttt_dual_mode[i]) {
355 config->bs_ttt_mode_high[i] = 1;
356 config->bs_ttt_bands_low[i] = 28;
357 }
358 }
359 return IA_NO_ERROR;
360 }
361
ixheaacd_coarse_2_fine(WORD32 * data,WORD32 data_type,WORD32 start_band,WORD32 num_bands)362 static VOID ixheaacd_coarse_2_fine(WORD32 *data, WORD32 data_type, WORD32 start_band,
363 WORD32 num_bands) {
364 WORD32 i;
365
366 for (i = start_band; i < start_band + num_bands; i++) {
367 data[i] <<= 1;
368 }
369
370 if (data_type == CLD) {
371 for (i = start_band; i < start_band + num_bands; i++) {
372 if (data[i] == -14)
373 data[i] = -15;
374 else if (data[i] == 14)
375 data[i] = 15;
376 }
377 }
378 }
379
ixheaacd_fine_2_coarse(WORD32 * data,WORD32 start_band,WORD32 num_bands)380 static VOID ixheaacd_fine_2_coarse(WORD32 *data, WORD32 start_band, WORD32 num_bands) {
381 WORD32 i;
382
383 for (i = start_band; i < start_band + num_bands; i++) {
384 data[i] >>= 1;
385 }
386 }
387
ixheaacd_get_stride_map(WORD32 freq_res_stride,WORD32 start_band,WORD32 stop_band,WORD32 * a_strides,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)388 static WORD32 ixheaacd_get_stride_map(
389 WORD32 freq_res_stride, WORD32 start_band, WORD32 stop_band, WORD32 *a_strides,
390 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
391 WORD32 i, pb, pb_stride, data_bands, str_offset;
392
393 pb_stride = ixheaacd_mps_dec_bitdec_tables->pb_stride_table[freq_res_stride];
394 data_bands = (stop_band - start_band - 1) / pb_stride + 1;
395
396 a_strides[0] = start_band;
397 for (pb = 1; pb <= data_bands; pb++) {
398 a_strides[pb] = a_strides[pb - 1] + pb_stride;
399 }
400 str_offset = 0;
401 while (a_strides[data_bands] > stop_band) {
402 if (str_offset < data_bands) str_offset++;
403 for (i = str_offset; i <= data_bands; i++) {
404 a_strides[i]--;
405 }
406 }
407
408 return data_bands;
409 }
410
ixheaacd_ec_data_dec(ia_heaac_mps_state_struct * pstr_mps_state,ia_mps_dec_lossless_data_struct * ll_data,WORD32 data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],WORD32 lastdata[][MAX_PARAMETER_BANDS],WORD32 datatype,WORD32 box_idx,WORD32 param_idx,WORD32 start_band,WORD32 stop_band)411 static IA_ERRORCODE ixheaacd_ec_data_dec(ia_heaac_mps_state_struct *pstr_mps_state,
412 ia_mps_dec_lossless_data_struct *ll_data,
413 WORD32 data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],
414 WORD32 lastdata[][MAX_PARAMETER_BANDS], WORD32 datatype,
415 WORD32 box_idx, WORD32 param_idx, WORD32 start_band,
416 WORD32 stop_band) {
417 IA_ERRORCODE error_code = IA_NO_ERROR;
418 WORD32 i, pb, data_sets, set_idx, bs_data_pair, data_bands, old_quant_coarse_xxx, temp;
419 WORD32 a_strides[MAX_PARAMETER_BANDS + 1] = {0};
420
421 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
422 ia_bit_buf_struct *mps_bit_buf = pstr_mps_state->ptr_mps_bit_buff;
423
424 data_sets = 0;
425 for (i = 0; i < pstr_mps_state->num_parameter_sets; i++) {
426 ll_data->bs_xxx_data_mode[param_idx][i] = ixheaacd_read_bits_buf(mps_bit_buf, 2);
427 if (ll_data->bs_xxx_data_mode[param_idx][i] == 3) {
428 data_sets++;
429 }
430 }
431 set_idx = 0;
432 old_quant_coarse_xxx = ll_data->bs_quant_coarse_xxx_prev[param_idx];
433
434 while (set_idx < data_sets) {
435 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
436 bs_data_pair = (temp >> 3) & ONE_BIT_MASK;
437 ll_data->bs_quant_coarse_xxx[param_idx][set_idx] = (temp >> 2) & ONE_BIT_MASK;
438 ll_data->bs_freq_res_stride_xxx[param_idx][set_idx] = temp & TWO_BIT_MASK;
439
440 if (ll_data->bs_quant_coarse_xxx[param_idx][set_idx] != old_quant_coarse_xxx) {
441 if (old_quant_coarse_xxx) {
442 ixheaacd_coarse_2_fine(lastdata[box_idx], datatype, start_band, stop_band - start_band);
443 } else {
444 ixheaacd_fine_2_coarse(lastdata[box_idx], start_band, stop_band - start_band);
445 }
446 }
447
448 data_bands = ixheaacd_get_stride_map(ll_data->bs_freq_res_stride_xxx[param_idx][set_idx],
449 start_band, stop_band, a_strides,
450 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr);
451
452 for (pb = 0; pb < data_bands; pb++) {
453 lastdata[box_idx][start_band + pb] = lastdata[box_idx][a_strides[pb]];
454 }
455
456 error_code = ixheaacd_mps_ecdatapairdec(
457 mps_bit_buf, data[box_idx], lastdata[box_idx], datatype, set_idx, start_band, data_bands,
458 bs_data_pair, ll_data->bs_quant_coarse_xxx[param_idx][set_idx],
459 (!frame->bs_independency_flag || (set_idx > 0)), 0, 1, pstr_mps_state->ec_flag);
460 if (error_code != IA_NO_ERROR) return error_code;
461
462 for (pb = 0; pb < data_bands; pb++) {
463 for (i = a_strides[pb]; i < a_strides[pb + 1]; i++) {
464 lastdata[box_idx][i] = data[box_idx][set_idx + bs_data_pair][start_band + pb];
465 }
466 }
467
468 old_quant_coarse_xxx = ll_data->bs_quant_coarse_xxx[param_idx][set_idx];
469
470 if (bs_data_pair) {
471 ll_data->bs_quant_coarse_xxx[param_idx][set_idx + 1] =
472 ll_data->bs_quant_coarse_xxx[param_idx][set_idx];
473 ll_data->bs_freq_res_stride_xxx[param_idx][set_idx + 1] =
474 ll_data->bs_freq_res_stride_xxx[param_idx][set_idx];
475 }
476 set_idx += bs_data_pair + 1;
477 }
478 return error_code;
479 }
480
ixheaacd_parse_arbitrary_downmix_data(ia_heaac_mps_state_struct * pstr_mps_state)481 static IA_ERRORCODE ixheaacd_parse_arbitrary_downmix_data(
482 ia_heaac_mps_state_struct *pstr_mps_state) {
483 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
484 IA_ERRORCODE error_code = IA_NO_ERROR;
485 WORD32 offset = pstr_mps_state->num_ott_boxes + 4 * pstr_mps_state->num_ttt_boxes;
486 WORD32 num_input_channels = pstr_mps_state->num_input_channels;
487 WORD32 bitstream_parameter_bands = pstr_mps_state->bitstream_parameter_bands;
488 WORD32 ch;
489
490 for (ch = 0; ch < num_input_channels; ch++) {
491 error_code = ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data,
492 frame->cmp_arbdmx_gain_idx, frame->cmp_arbdmx_gain_idx_prev,
493 CLD, ch, offset + ch, 0, bitstream_parameter_bands);
494 if (error_code != IA_NO_ERROR) return error_code;
495 }
496 return error_code;
497 }
498
ixheaacd_decode_icc_diff_code(ia_bit_buf_struct * it_bit_buff)499 static WORD32 ixheaacd_decode_icc_diff_code(ia_bit_buf_struct *it_bit_buff) {
500 WORD32 value = 0;
501 WORD32 count = 0;
502 while ((ixheaacd_read_bits_buf(it_bit_buff, 1) == 0) && (count++ < 7)) {
503 value++;
504 }
505
506 return value;
507 }
508
ixheaacd_parse_residual_data(ia_heaac_mps_state_struct * pstr_mps_state)509 static VOID ixheaacd_parse_residual_data(ia_heaac_mps_state_struct *pstr_mps_state) {
510 WORD32 ich, ch;
511 WORD32 rfpsf;
512 WORD32 ps;
513 WORD32 pb;
514
515 ia_mps_dec_residual_aac_tables_struct *aac_tables_ptr =
516 pstr_mps_state->ia_mps_dec_mps_table.aac_tab;
517 WORD32 i;
518
519 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
520 ia_mps_spatial_bs_config_struct *config = &(pstr_mps_state->bs_config);
521
522 WORD32 num_ott_boxes = pstr_mps_state->num_ott_boxes;
523 WORD32 num_parameter_sets = pstr_mps_state->num_parameter_sets;
524 WORD32 residual_frames_per_spatial_frame = pstr_mps_state->residual_frames_per_spatial_frame;
525 WORD32 upd_qmf = pstr_mps_state->upd_qmf;
526
527 WORD32 loop_counter = num_ott_boxes + pstr_mps_state->num_ttt_boxes;
528 WORD32 *p_mdct_res;
529
530 WORD32 *p_res_mdct = pstr_mps_state->array_struct->res_mdct;
531 ia_bit_buf_struct *mps_bit_buf = pstr_mps_state->ptr_mps_bit_buff;
532
533 for (ich = 0; ich < loop_counter; ich++) {
534 ch = ich;
535
536 p_mdct_res = p_res_mdct;
537 if (config->bs_residual_bands[ch] > 0) {
538 if (ch < num_ott_boxes) {
539 for (ps = 0; ps < num_parameter_sets; ps++) {
540 frame->res_data.bs_icc_diff_present[ch][ps] = ixheaacd_read_bits_buf(mps_bit_buf, 1);
541 if (frame->res_data.bs_icc_diff_present[ch][ps]) {
542 for (pb = 0; pb < config->bs_residual_bands[ch]; pb++) {
543 frame->res_data.bs_icc_diff[ch][ps][pb] =
544 ixheaacd_decode_icc_diff_code(mps_bit_buf);
545 frame->ott_icc_diff_idx[ch][ps][pb] = frame->res_data.bs_icc_diff[ch][ps][pb];
546 }
547 }
548 }
549 }
550 p_mdct_res = p_res_mdct;
551 for (rfpsf = 0; rfpsf < residual_frames_per_spatial_frame; rfpsf++) {
552 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info, 1,
553 aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
554 if (1 == pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
555 ixheaacd_res_ctns_apply(
556 pstr_mps_state->p_aac_decoder_channel_info[0],
557 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
558 aac_tables_ptr);
559 pstr_mps_state->res_block_type[ch][rfpsf] =
560 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
561 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
562 *p_mdct_res++ =
563 (pstr_mps_state->p_aac_decoder_channel_info[0]->p_spectral_coefficient[i]);
564 }
565
566 if ((pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence ==
567 EIGHT_SHORT_SEQUENCE) &&
568 ((upd_qmf == UPD_QMF_18) || (upd_qmf == UPD_QMF_24) || (upd_qmf == UPD_QMF_30))) {
569 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info, 1,
570 aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
571 if (1 == pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
572 ixheaacd_res_ctns_apply(
573 pstr_mps_state->p_aac_decoder_channel_info[0],
574 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
575 aac_tables_ptr);
576 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
577 *p_mdct_res++ =
578 (pstr_mps_state->p_aac_decoder_channel_info[0]->p_spectral_coefficient[i]);
579 }
580 }
581 }
582 }
583
584 p_res_mdct += RFX2XMDCTCOEF;
585 }
586 }
587
ixheaacd_parse_extension_frame(ia_heaac_mps_state_struct * pstr_mps_state)588 static IA_ERRORCODE ixheaacd_parse_extension_frame(ia_heaac_mps_state_struct *pstr_mps_state) {
589 WORD32 i, fr, gr, offset, ch;
590 WORD32 ext_num, sac_ext_type, sac_ext_len, tmp, bits_read, n_fill_bits, temp;
591 WORD32 channel_grouping[MAX_INPUT_CHANNELS_MPS];
592
593 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
594 ia_mps_spatial_bs_config_struct *p_bs_config = &pstr_mps_state->bs_config;
595
596 ia_mps_dec_residual_aac_tables_struct *aac_tables_ptr =
597 pstr_mps_state->ia_mps_dec_mps_table.aac_tab;
598
599 WORD32 arbdmx_upd_qmf = pstr_mps_state->arbdmx_upd_qmf;
600 WORD32 num_ott_boxes = pstr_mps_state->num_ott_boxes;
601 WORD32 num_input_channels = pstr_mps_state->num_input_channels;
602 WORD32 num_ttt_boxes = pstr_mps_state->num_ttt_boxes;
603 WORD32 arbdmx_frames_per_spatial_frame = pstr_mps_state->arbdmx_frames_per_spatial_frame;
604 WORD32 *p_res_mdct, *p_mdct_res;
605
606 WORD32 sfidx;
607 VOID *free_scratch = pstr_mps_state->mps_scratch_mem_v;
608 ia_mps_dec_residual_sfband_info_struct *p_sfband_info_tab = &pstr_mps_state->sfband_info_tab;
609 ia_bit_buf_struct *mps_bit_buf = pstr_mps_state->ptr_mps_bit_buff;
610
611 for (ch = 0; ch < 2; ch++) {
612 pstr_mps_state->p_aac_decoder_channel_info[ch] = free_scratch;
613 free_scratch = (WORD8 *)free_scratch + sizeof(ia_mps_dec_residual_channel_info_struct);
614 pstr_mps_state->p_aac_decoder_dynamic_data_init[ch] = free_scratch;
615 free_scratch = (WORD8 *)free_scratch + sizeof(ia_mps_dec_residual_dynamic_data_struct);
616 pstr_mps_state->p_aac_decoder_channel_info[ch]->p_scale_factor =
617 pstr_mps_state->p_aac_decoder_dynamic_data_init[ch]->a_scale_factor;
618 pstr_mps_state->p_aac_decoder_channel_info[ch]->p_code_book =
619 pstr_mps_state->p_aac_decoder_dynamic_data_init[ch]->a_code_book;
620 pstr_mps_state->p_aac_decoder_channel_info[ch]->p_spectral_coefficient = free_scratch;
621 free_scratch = (WORD8 *)free_scratch + 4096;
622 pstr_mps_state->p_aac_decoder_channel_info[ch]->p_tns_scratch = free_scratch;
623 free_scratch = (WORD8 *)free_scratch + 4096;
624 pstr_mps_state->p_aac_decoder_channel_info[ch]->ics_info.frame_length = AAC_FRAME_LENGTH;
625 pstr_mps_state->p_aac_decoder_channel_info[ch]->common_window = 0;
626 }
627 if (pstr_mps_state->arbitrary_downmix == 2)
628 sfidx = p_bs_config->bs_arbitrary_downmix_residual_sampling_freq_index;
629 else
630 sfidx = p_bs_config->bs_residual_sampling_freq_index;
631 {
632 WORD16 *psfb_idx[2];
633 const WORD8 *psfb_width[2];
634 WORD width_idx;
635 WORD32 j;
636
637 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.sampling_rate_index = sfidx;
638 psfb_idx[0] = p_sfband_info_tab->sfb_long_idx;
639 psfb_idx[1] = p_sfband_info_tab->sfb_short_idx;
640 psfb_width[0] = aac_tables_ptr->scale_factor_bands_long[sfidx];
641 psfb_width[1] = aac_tables_ptr->scale_factor_bands_short[sfidx];
642
643 for (j = 1; j >= 0; j--) {
644 const WORD8 *ptr_w = psfb_width[j];
645 WORD16 *ptr_i = psfb_idx[j];
646 width_idx = 0;
647 *ptr_i++ = width_idx;
648 do {
649 width_idx += (*ptr_w++);
650 *ptr_i++ = width_idx;
651 } while (*ptr_w != -1);
652
653 pstr_mps_state->tot_sf_bands_ls[j] = (WORD8)(ptr_w - psfb_width[j]);
654 }
655
656 {
657 aac_tables_ptr->sfb_index_long = p_sfband_info_tab->sfb_long_idx;
658 aac_tables_ptr->sfb_index_short = p_sfband_info_tab->sfb_short_idx;
659 aac_tables_ptr->sfb_index_long_width = (WORD8 *)psfb_width[0];
660 aac_tables_ptr->sfb_index_short_width = (WORD8 *)psfb_width[1];
661 }
662 }
663
664 for (ext_num = 0; ext_num < p_bs_config->sac_ext_cnt; ext_num++) {
665 sac_ext_type = p_bs_config->bs_sac_ext_type[ext_num];
666
667 if (sac_ext_type < 12) {
668 sac_ext_len = ixheaacd_read_bits_buf(mps_bit_buf, 8);
669 if (sac_ext_len == 255) {
670 sac_ext_len += ixheaacd_read_bits_buf(mps_bit_buf, 16);
671 }
672
673 tmp = (WORD32)(((mps_bit_buf->ptr_read_next - mps_bit_buf->ptr_bit_buf_base + 1) << 3) -
674 (mps_bit_buf->bit_pos + 1));
675
676 switch (sac_ext_type) {
677 case EXT_TYPE_0:
678 ixheaacd_parse_residual_data(pstr_mps_state);
679 break;
680
681 case EXT_TYPE_1:
682 switch (num_input_channels) {
683 case IN_CH_1:
684 channel_grouping[0] = 1;
685 break;
686 case IN_CH_2:
687 channel_grouping[0] = 2;
688 break;
689 case IN_CH_6:
690 channel_grouping[0] = 2;
691 channel_grouping[1] = 2;
692 channel_grouping[2] = 2;
693 break;
694 default:
695 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_INPUT_CHANNEL;
696 break;
697 }
698
699 offset = num_ott_boxes + num_ttt_boxes;
700
701 p_res_mdct = pstr_mps_state->array_struct->res_mdct + offset * RFX2XMDCTCOEF;
702
703 for (ch = 0, gr = 0; ch < num_input_channels; ch += channel_grouping[gr++]) {
704 p_mdct_res = p_res_mdct;
705
706 temp = ixheaacd_read_bits_buf(mps_bit_buf, 2);
707 frame->bs_arbitrary_downmix_residual_abs[ch] = (temp >> 1) & ONE_BIT_MASK;
708 frame->bs_arbitrary_downmix_residual_alpha_update_set[ch] = temp & ONE_BIT_MASK;
709
710 if (channel_grouping[gr] == 1) {
711 for (fr = 0; fr < arbdmx_frames_per_spatial_frame; fr++) {
712 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info, 1,
713 aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
714 if (1 == pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
715 ixheaacd_res_ctns_apply(
716 pstr_mps_state->p_aac_decoder_channel_info[0],
717 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
718 aac_tables_ptr);
719
720 pstr_mps_state->res_block_type[offset + ch][fr] =
721 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
722 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
723 *p_mdct_res++ =
724 (pstr_mps_state->p_aac_decoder_channel_info[0]->p_spectral_coefficient[i]);
725 }
726
727 if ((pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence ==
728 EIGHT_SHORT_SEQUENCE) &&
729 ((arbdmx_upd_qmf == UPD_QMF_18) || (arbdmx_upd_qmf == UPD_QMF_24) ||
730 (arbdmx_upd_qmf == UPD_QMF_30))) {
731 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info,
732 1, aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
733 if (1 ==
734 pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
735 ixheaacd_res_ctns_apply(
736 pstr_mps_state->p_aac_decoder_channel_info[0],
737 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
738 aac_tables_ptr);
739 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
740 *p_mdct_res++ = (pstr_mps_state->p_aac_decoder_channel_info[0]
741 ->p_spectral_coefficient[i]);
742 }
743 }
744 }
745 p_res_mdct += RFX2XMDCTCOEF;
746 } else {
747 frame->bs_arbitrary_downmix_residual_abs[ch + 1] =
748 frame->bs_arbitrary_downmix_residual_abs[ch];
749 frame->bs_arbitrary_downmix_residual_alpha_update_set[ch + 1] =
750 frame->bs_arbitrary_downmix_residual_alpha_update_set[ch];
751
752 for (fr = 0; fr < arbdmx_frames_per_spatial_frame; fr++) {
753 WORD32 *res_mdct_1 = p_mdct_res + RFX2XMDCTCOEF;
754 WORD32 temp, win1, win2;
755 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
756 temp = ixheaacd_read_bits_buf(mps_bit_buf, 1);
757
758 if (temp != 0) {
759 return IA_XHEAAC_MPS_DEC_EXE_FATAL_NONZERO_BIT;
760 }
761
762 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info, 1,
763 aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
764
765 if (1 == pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
766 ixheaacd_res_ctns_apply(
767 pstr_mps_state->p_aac_decoder_channel_info[0],
768 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
769 aac_tables_ptr);
770 win1 = pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
771 pstr_mps_state->res_block_type[offset + ch][fr] =
772 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
773
774 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
775 *p_mdct_res++ =
776 (pstr_mps_state->p_aac_decoder_channel_info[0]->p_spectral_coefficient[i]);
777 }
778
779 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info, 1,
780 aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
781
782 if (1 == pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
783 ixheaacd_res_ctns_apply(
784 pstr_mps_state->p_aac_decoder_channel_info[0],
785 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
786 aac_tables_ptr);
787 win2 = pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
788 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
789 *res_mdct_1++ =
790 (pstr_mps_state->p_aac_decoder_channel_info[0]->p_spectral_coefficient[i]);
791 }
792
793 if (win1 != win2) return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_WINDOW_SEQUENCE;
794
795 if ((win1 == EIGHT_SHORT_SEQUENCE) &&
796 ((arbdmx_upd_qmf == UPD_QMF_18) || (arbdmx_upd_qmf == UPD_QMF_24) ||
797 (arbdmx_upd_qmf == UPD_QMF_30))) {
798 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
799 temp = ixheaacd_read_bits_buf(mps_bit_buf, 1);
800
801 if (temp != 0) {
802 return IA_XHEAAC_MPS_DEC_EXE_FATAL_NONZERO_BIT;
803 }
804
805 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info,
806 1, aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
807
808 if (1 ==
809 pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
810 ixheaacd_res_ctns_apply(
811 pstr_mps_state->p_aac_decoder_channel_info[0],
812 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
813 aac_tables_ptr);
814 win1 = pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
815
816 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
817 *p_mdct_res++ = (pstr_mps_state->p_aac_decoder_channel_info[0]
818 ->p_spectral_coefficient[i]);
819 }
820
821 ixheaacd_res_read_ics(mps_bit_buf, pstr_mps_state->p_aac_decoder_channel_info,
822 1, aac_tables_ptr, pstr_mps_state->tot_sf_bands_ls);
823
824 if (1 ==
825 pstr_mps_state->p_aac_decoder_channel_info[0]->tns_data.tns_data_present)
826 ixheaacd_res_ctns_apply(
827 pstr_mps_state->p_aac_decoder_channel_info[0],
828 pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.max_sf_bands,
829 aac_tables_ptr);
830 win2 = pstr_mps_state->p_aac_decoder_channel_info[0]->ics_info.window_sequence;
831 for (i = 0; i < AAC_FRAME_LENGTH; i++) {
832 *res_mdct_1++ = (pstr_mps_state->p_aac_decoder_channel_info[0]
833 ->p_spectral_coefficient[i]);
834 }
835
836 if (win1 != win2) return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_WINDOW_SEQUENCE;
837 }
838 }
839 p_res_mdct += RFX2XMDCTCOEF;
840 }
841 }
842
843 break;
844
845 case EXT_TYPE_2:
846 for (i = 0; i < p_bs_config->num_ott_boxes_at; i++) {
847 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data,
848 frame->cmp_ott_cld_idx, frame->cmp_ott_cld_idx_prev, CLD,
849 num_ott_boxes + i, num_ott_boxes + i, 0,
850 p_bs_config->bs_ott_bands_at[i]);
851 }
852
853 break;
854
855 default:
856 return IA_XHEAAC_MPS_DEC_EXE_NONFATAL_INVALID_EXTENSION_TYPE;
857 }
858
859 bits_read =
860 (WORD32)(((mps_bit_buf->ptr_read_next - mps_bit_buf->ptr_bit_buf_base + 1) << 3) -
861 (mps_bit_buf->bit_pos + 1) - tmp);
862 n_fill_bits = (sac_ext_len << 3) - bits_read;
863
864 while (n_fill_bits > 7) {
865 ixheaacd_read_bits_buf(mps_bit_buf, 8);
866 n_fill_bits -= 8;
867 }
868 if (n_fill_bits > 0) {
869 ixheaacd_read_bits_buf(mps_bit_buf, n_fill_bits);
870 }
871 }
872 }
873 return IA_NO_ERROR;
874 }
875
ixheaacd_parse_frame(ia_heaac_mps_state_struct * pstr_mps_state)876 IA_ERRORCODE ixheaacd_parse_frame(ia_heaac_mps_state_struct *pstr_mps_state) {
877 ia_mps_spatial_bs_config_struct *p_bs_config = &pstr_mps_state->bs_config;
878
879 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
880 WORD32 i, bs_framing_type, prev_param_slot, data_bands, bs_temp_shape_enable,
881 num_temp_shape_chan;
882 WORD32 ttt_off, ps, pg, ts, pb, temp;
883 WORD32 *bs_env_shape_data = pstr_mps_state->mps_scratch_mem_v;
884 WORD32 const *reciprocal_tab = pstr_mps_state->ia_mps_dec_mps_table.m1_m2_table_ptr->reciprocal;
885 WORD32 num_parameter_sets;
886
887 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
888 ia_mps_dec_bitdec_tables_struct *bitdec_table =
889 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
890 WORD32 bs_num_output_channels =
891 bitdec_table->tree_property_table[pstr_mps_state->tree_config].num_output_channels;
892
893 WORD32 time_slots = pstr_mps_state->time_slots;
894 WORD32 bitstream_parameter_bands = pstr_mps_state->bitstream_parameter_bands;
895 WORD32 *b_ott_bands = pstr_mps_state->bitstream_ott_bands;
896 WORD32 *param_slot = pstr_mps_state->aux_struct->param_slot;
897
898 WORD32 num_ott_boxes = pstr_mps_state->num_ott_boxes;
899
900 WORD32 reciprocal, alignment_bits = 0;
901 ia_bit_buf_struct *mps_bit_buf = pstr_mps_state->ptr_mps_bit_buff;
902
903 if (pstr_mps_state->parse_next_bitstream_frame == 0) return IA_NO_ERROR;
904
905 temp = ixheaacd_read_bits_buf(mps_bit_buf, 4);
906 bs_framing_type = (temp >> 3) & ONE_BIT_MASK;
907 num_parameter_sets = (temp & THREE_BIT_MASK) + 1;
908 pstr_mps_state->num_parameter_sets = num_parameter_sets;
909
910 reciprocal = reciprocal_tab[num_parameter_sets - 1];
911
912 prev_param_slot = -1;
913 for (i = 0; i < num_parameter_sets; i++) {
914 if (bs_framing_type) {
915 WORD32 bits_param_slot = 0;
916 while ((1 << bits_param_slot) < (time_slots - num_parameter_sets + i - prev_param_slot))
917 bits_param_slot++;
918 param_slot[i] =
919 bits_param_slot
920 ? prev_param_slot + 1 + ixheaacd_read_bits_buf(mps_bit_buf, bits_param_slot)
921 : prev_param_slot + 1;
922 prev_param_slot = param_slot[i];
923 } else {
924 WORD64 temp = (WORD64)(
925 ((WORD64)((time_slots * (i + 1)) + num_parameter_sets - 1) * (WORD64)reciprocal) >> 28);
926 param_slot[i] = (WORD32)(temp - 1);
927 }
928 }
929 frame->bs_independency_flag = ixheaacd_read_bits_buf(mps_bit_buf, 1);
930
931 for (i = 0; i < num_ott_boxes; i++) {
932 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data, frame->cmp_ott_cld_idx,
933 frame->cmp_ott_cld_idx_prev, CLD, i, i, 0, b_ott_bands[i]);
934 }
935 if (pstr_mps_state->one_icc) {
936 ixheaacd_ec_data_dec(pstr_mps_state, &frame->icc_lossless_data, frame->cmp_ott_icc_idx,
937 frame->cmp_ott_icc_idx_prev, ICC, 0, 0, 0, bitstream_parameter_bands);
938 } else {
939 for (i = 0; i < num_ott_boxes; i++) {
940 if (!pstr_mps_state->ott_mode_lfe[i]) {
941 ixheaacd_ec_data_dec(pstr_mps_state, &frame->icc_lossless_data, frame->cmp_ott_icc_idx,
942 frame->cmp_ott_icc_idx_prev, ICC, i, i, 0, b_ott_bands[i]);
943 }
944 }
945 }
946
947 ttt_off = num_ott_boxes;
948 for (i = 0; i < pstr_mps_state->num_ttt_boxes; i++) {
949 if (p_aux_struct->ttt_config[0][i].mode < 2) {
950 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cpc_lossless_data, frame->cmp_ttt_cpc_1_idx,
951 frame->cmp_ttt_cpc_1_idx_prev, CPC, i, ttt_off + 4 * i,
952 p_aux_struct->ttt_config[0][i].bitstream_start_band,
953 p_aux_struct->ttt_config[0][i].bitstream_stop_band);
954 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cpc_lossless_data, frame->cmp_ttt_cpc_2_idx,
955 frame->cmp_ttt_cpc_2_idx_prev, CPC, i, ttt_off + 4 * i + 1,
956 p_aux_struct->ttt_config[0][i].bitstream_start_band,
957 p_aux_struct->ttt_config[0][i].bitstream_stop_band);
958 ixheaacd_ec_data_dec(pstr_mps_state, &frame->icc_lossless_data, frame->cmp_ttt_icc_idx,
959 frame->cmp_ttt_icc_idx_prev, ICC, i, ttt_off + 4 * i,
960 p_aux_struct->ttt_config[0][i].bitstream_start_band,
961 p_aux_struct->ttt_config[0][i].bitstream_stop_band);
962 } else {
963 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data, frame->cmp_ttt_cld_1_idx,
964 frame->cmp_ttt_cld_1_idx_prev, CLD, i, ttt_off + 4 * i,
965 p_aux_struct->ttt_config[0][i].bitstream_start_band,
966 p_aux_struct->ttt_config[0][i].bitstream_stop_band);
967 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data, frame->cmp_ttt_cld_2_idx,
968 frame->cmp_ttt_cld_2_idx_prev, CLD, i, ttt_off + 4 * i + 1,
969 p_aux_struct->ttt_config[0][i].bitstream_start_band,
970 p_aux_struct->ttt_config[0][i].bitstream_stop_band);
971 }
972
973 if (p_aux_struct->ttt_config[1][i].bitstream_start_band <
974 p_aux_struct->ttt_config[1][i].bitstream_stop_band) {
975 if (p_aux_struct->ttt_config[1][i].mode < 2) {
976 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cpc_lossless_data, frame->cmp_ttt_cpc_1_idx,
977 frame->cmp_ttt_cpc_1_idx_prev, CPC, i, ttt_off + 4 * i + 2,
978 p_aux_struct->ttt_config[1][i].bitstream_start_band,
979 p_aux_struct->ttt_config[1][i].bitstream_stop_band);
980 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cpc_lossless_data, frame->cmp_ttt_cpc_2_idx,
981 frame->cmp_ttt_cpc_2_idx_prev, CPC, i, ttt_off + 4 * i + 3,
982 p_aux_struct->ttt_config[1][i].bitstream_start_band,
983 p_aux_struct->ttt_config[1][i].bitstream_stop_band);
984 ixheaacd_ec_data_dec(pstr_mps_state, &frame->icc_lossless_data, frame->cmp_ttt_icc_idx,
985 frame->cmp_ttt_icc_idx_prev, ICC, i, ttt_off + 4 * i + 2,
986 p_aux_struct->ttt_config[1][i].bitstream_start_band,
987 p_aux_struct->ttt_config[1][i].bitstream_stop_band);
988 } else {
989 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data, frame->cmp_ttt_cld_1_idx,
990 frame->cmp_ttt_cld_1_idx_prev, CLD, i, ttt_off + 4 * i + 2,
991 p_aux_struct->ttt_config[1][i].bitstream_start_band,
992 p_aux_struct->ttt_config[1][i].bitstream_stop_band);
993 ixheaacd_ec_data_dec(pstr_mps_state, &frame->cld_lossless_data, frame->cmp_ttt_cld_2_idx,
994 frame->cmp_ttt_cld_2_idx_prev, CLD, i, ttt_off + 4 * i + 3,
995 p_aux_struct->ttt_config[1][i].bitstream_start_band,
996 p_aux_struct->ttt_config[1][i].bitstream_stop_band);
997 }
998 }
999 }
1000
1001 frame->bs_smooth_control = 1;
1002
1003 if (frame->bs_smooth_control) {
1004 for (ps = 0; ps < num_parameter_sets; ps++) {
1005 frame->bs_smooth_mode[ps] = ixheaacd_read_bits_buf(mps_bit_buf, 2);
1006 if (frame->bs_smooth_mode[ps] > 3 || frame->bs_smooth_mode[ps] < 0) {
1007 return IA_XHEAAC_MPS_DEC_EXE_NONFATAL_INVALID_SMOOTH_MODE;
1008 }
1009 if (frame->bs_smooth_mode[ps] >= 2) {
1010 frame->bs_smooth_time[ps] = ixheaacd_read_bits_buf(mps_bit_buf, 2);
1011 }
1012 if (frame->bs_smooth_mode[ps] == 3) {
1013 frame->bs_freq_res_stride_smg[ps] = ixheaacd_read_bits_buf(mps_bit_buf, 2);
1014 data_bands = (bitstream_parameter_bands - 1) /
1015 bitdec_table->pb_stride_table[frame->bs_freq_res_stride_smg[ps]] +
1016 1;
1017 for (pg = 0; pg < data_bands; pg++) {
1018 frame->bs_smg_data[ps][pg] = ixheaacd_read_bits_buf(mps_bit_buf, 1);
1019 }
1020 }
1021 }
1022 }
1023
1024 for (i = 0; i < bs_num_output_channels; i++) {
1025 p_aux_struct->temp_shape_enable_channel_stp[i] = 0;
1026 p_aux_struct->temp_shape_enable_channel_ges[i] = 0;
1027 }
1028
1029 if (p_bs_config->bs_temp_shape_config != 0) {
1030 bs_temp_shape_enable = ixheaacd_read_bits_buf(mps_bit_buf, 1);
1031 if (bs_temp_shape_enable) {
1032 num_temp_shape_chan =
1033 bitdec_table->temp_shape_chan_table[p_bs_config->bs_temp_shape_config - 1]
1034 [p_bs_config->bs_tree_config];
1035 switch (pstr_mps_state->temp_shape_config) {
1036 case 1:
1037 for (i = 0; i < num_temp_shape_chan; i++) {
1038 p_aux_struct->temp_shape_enable_channel_stp[i] =
1039 ixheaacd_read_bits_buf(mps_bit_buf, 1);
1040 }
1041 break;
1042 case 2:
1043 for (i = 0; i < num_temp_shape_chan; i++) {
1044 p_aux_struct->temp_shape_enable_channel_ges[i] =
1045 ixheaacd_read_bits_buf(mps_bit_buf, 1);
1046 }
1047 for (i = 0; i < num_temp_shape_chan; i++) {
1048 if (p_aux_struct->temp_shape_enable_channel_ges[i]) {
1049 WORD32 const *envshape_data =
1050 &bitdec_table->envshape_data[pstr_mps_state->env_quant_mode][0];
1051 ixheaacd_mps_huff_decode(mps_bit_buf, bs_env_shape_data, time_slots);
1052 for (ts = 0; ts < time_slots; ts++) {
1053 p_aux_struct->env_shape_data[i][ts] = envshape_data[bs_env_shape_data[ts]];
1054 }
1055 }
1056 }
1057 break;
1058 default:
1059 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_TEMPORAL_SHAPING_CONFIG;
1060 }
1061 }
1062 }
1063
1064 if (pstr_mps_state->up_mix_type == 2) {
1065 for (i = 0; i < bs_num_output_channels; i++) {
1066 p_aux_struct->temp_shape_enable_channel_stp[i] = 0;
1067 p_aux_struct->temp_shape_enable_channel_ges[i] = 0;
1068 }
1069 }
1070
1071 if (pstr_mps_state->arbitrary_downmix != 0) {
1072 ixheaacd_parse_arbitrary_downmix_data(pstr_mps_state);
1073 }
1074
1075 ixheaacd_byte_align(mps_bit_buf, &alignment_bits);
1076 ixheaacd_parse_extension_frame(pstr_mps_state);
1077
1078 for (i = 0; i < num_ott_boxes; i++) {
1079 for (ps = 0; ps < num_parameter_sets; ps++) {
1080 if (!frame->res_data.bs_icc_diff_present[i][ps] || (pstr_mps_state->up_mix_type == 2) ||
1081 (pstr_mps_state->up_mix_type == 3)) {
1082 for (pb = 0; pb < bitstream_parameter_bands; pb++) {
1083 pstr_mps_state->bs_frame->ott_icc_diff_idx[i][ps][pb] = 0;
1084 }
1085 }
1086 }
1087 }
1088
1089 pstr_mps_state->parse_next_bitstream_frame = 1;
1090
1091 return IA_NO_ERROR;
1092 }
1093
ixheaacd_create_mapping(WORD32 a_map[MAX_PARAMETER_BANDS+1],WORD32 start_band,WORD32 stop_band,WORD32 stride,VOID * scratch)1094 static VOID ixheaacd_create_mapping(WORD32 a_map[MAX_PARAMETER_BANDS + 1], WORD32 start_band,
1095 WORD32 stop_band, WORD32 stride, VOID *scratch) {
1096 WORD32 in_bands, out_bands, bands_achived, bands_diff, incr, k, i;
1097 WORD32 *v_dk;
1098 in_bands = stop_band - start_band;
1099 out_bands = (in_bands - 1) / stride + 1;
1100 v_dk = scratch;
1101 if (out_bands < 1) {
1102 out_bands = 1;
1103 }
1104
1105 bands_achived = out_bands * stride;
1106 bands_diff = in_bands - bands_achived;
1107 for (i = 0; i < out_bands; i++) {
1108 v_dk[i] = stride;
1109 }
1110
1111 if (bands_diff > 0) {
1112 incr = -1;
1113 k = out_bands - 1;
1114 } else {
1115 incr = 1;
1116 k = 0;
1117 }
1118
1119 while (bands_diff != 0) {
1120 v_dk[k] = v_dk[k] - incr;
1121 k = k + incr;
1122 bands_diff = bands_diff + incr;
1123 if (k >= out_bands) {
1124 if (bands_diff > 0) {
1125 k = out_bands - 1;
1126 } else if (bands_diff < 0) {
1127 k = 0;
1128 }
1129 }
1130 }
1131 a_map[0] = start_band;
1132 for (i = 0; i < out_bands; i++) {
1133 a_map[i + 1] = a_map[i] + v_dk[i];
1134 }
1135 }
1136
ixheaacd_map_frequency(WORD32 * p_input,WORD32 * p_output,WORD32 * p_map,WORD32 data_bands)1137 static VOID ixheaacd_map_frequency(WORD32 *p_input, WORD32 *p_output, WORD32 *p_map,
1138 WORD32 data_bands) {
1139 WORD32 i, j, start_band, stop_band, value;
1140 WORD32 start_band_0 = p_map[0];
1141
1142 for (i = 0; i < data_bands; i++) {
1143 value = p_input[i + start_band_0];
1144
1145 start_band = p_map[i];
1146 stop_band = p_map[i + 1];
1147 for (j = start_band; j < stop_band; j++) {
1148 p_output[j] = value;
1149 }
1150 }
1151 }
1152
ixheaacd_deq_coarse(WORD32 value,WORD32 param_type,WORD32 * dequant,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1153 static IA_ERRORCODE ixheaacd_deq_coarse(
1154 WORD32 value, WORD32 param_type, WORD32 *dequant,
1155 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1156 switch (param_type) {
1157 case CLD:
1158 if (value >= 8 || value < -7) return IA_FATAL_ERROR;
1159 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_cld_coarse[value + 7];
1160 break;
1161
1162 case ICC:
1163 if (value >= 8 || value < 0) return IA_FATAL_ERROR;
1164 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_icc[value];
1165 break;
1166
1167 case CPC:
1168 if (value >= 16 || value < -10) return IA_FATAL_ERROR;
1169 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_cpc_coarse[value + 10];
1170 break;
1171 default:
1172 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_DEQUANT_PARAM;
1173 }
1174 return IA_NO_ERROR;
1175 }
1176
ia_mps_dec_deq(WORD32 value,WORD32 param_type,WORD32 * dequant,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1177 static IA_ERRORCODE ia_mps_dec_deq(
1178 WORD32 value, WORD32 param_type, WORD32 *dequant,
1179 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1180 switch (param_type) {
1181 case CLD:
1182 if (value >= 16 || value < -15) return IA_FATAL_ERROR;
1183 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_cld[value + 15];
1184 break;
1185
1186 case ICC:
1187 if (value >= 8 || value < 0) return IA_FATAL_ERROR;
1188 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_icc[value];
1189 break;
1190
1191 case CPC:
1192 if (value >= 32 || value < -20) return IA_FATAL_ERROR;
1193 *dequant = ixheaacd_mps_dec_bitdec_tables->dequant_cpc[value + 20];
1194 break;
1195
1196 default:
1197 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_DEQUANT_PARAM;
1198 }
1199 return IA_NO_ERROR;
1200 }
1201
ixheaacd_factor_funct(WORD32 ott_vs_tot_db,WORD32 quant_mode,WORD32 * factor)1202 static IA_ERRORCODE ixheaacd_factor_funct(WORD32 ott_vs_tot_db, WORD32 quant_mode,
1203 WORD32 *factor) {
1204 WORD32 db_diff;
1205 WORD32 x_linear = 0;
1206
1207 WORD32 maxfactor = 0;
1208 WORD32 constfact;
1209
1210 if (ott_vs_tot_db > 0) return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_MPS_PARAM;
1211 db_diff = -ott_vs_tot_db;
1212
1213 switch (quant_mode) {
1214 case QUANT_MODE_0:
1215 return (ONE_IN_Q25);
1216 break;
1217 case QUANT_MODE_1:
1218 x_linear = 1024;
1219
1220 maxfactor = 167772160;
1221 constfact = 6554;
1222 break;
1223 case QUANT_MODE_2:
1224 x_linear = 1024;
1225
1226 maxfactor = ONE_IN_Q28;
1227 constfact = 9557;
1228 break;
1229 default:
1230 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_QUANT_MODE;
1231 }
1232
1233 if (db_diff > (x_linear << 5)) {
1234 WORD32 db_diff_fix = db_diff >> 5;
1235 *factor = (db_diff_fix - (WORD32)x_linear) * constfact + ONE_IN_Q25;
1236 } else {
1237 *factor = ONE_IN_Q25;
1238 }
1239
1240 *factor = min(maxfactor, *factor);
1241 return IA_NO_ERROR;
1242 }
1243
ixheaacd_factor_cld(WORD32 * idx,WORD32 ott_vs_tot_db,WORD32 * ott_vs_tot_db_1,WORD32 * ott_vs_tot_db_2,WORD32 quant_mode,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1244 static VOID ixheaacd_factor_cld(WORD32 *idx, WORD32 ott_vs_tot_db, WORD32 *ott_vs_tot_db_1,
1245 WORD32 *ott_vs_tot_db_2, WORD32 quant_mode,
1246 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1247 WORD32 factor = 0;
1248 WORD32 c1;
1249 WORD32 c2;
1250 WORD32 cld_idx;
1251
1252 ixheaacd_factor_funct(ott_vs_tot_db, quant_mode, &factor);
1253
1254 cld_idx = (((*idx * factor) + THIRTYONE_BY_TWO_IN_Q25) >> 25);
1255 cld_idx -= 15;
1256
1257 cld_idx = min(cld_idx, 15);
1258 cld_idx = max(cld_idx, -15);
1259
1260 *idx = cld_idx;
1261
1262 c1 = ixheaacd_mps_dec_bitdec_tables->factor_cld_tab_1[*idx + 15];
1263 c2 = ixheaacd_mps_dec_bitdec_tables->factor_cld_tab_1[15 - *idx];
1264
1265 *ott_vs_tot_db_1 = c1 + ott_vs_tot_db;
1266 *ott_vs_tot_db_2 = c2 + ott_vs_tot_db;
1267 }
1268
ixheaacd_map_index_data(ia_mps_dec_lossless_data_struct * ll_data,WORD32 output_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],WORD32 output_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],WORD32 cmp_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],WORD32 diff_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],WORD32 xtt_idx,WORD32 idx_prev[MAX_NUM_OTT][MAX_PARAMETER_BANDS],WORD32 param_idx,WORD32 param_type,WORD32 start_band,WORD32 stop_band,WORD32 default_value,WORD32 num_parameter_sets,WORD32 * param_slot,WORD32 extend_frame,WORD32 quant_mode,WORD32 * ott_vs_tot_db_in,WORD32 * ott_vs_tot_db_1,WORD32 * ott_vs_tot_db_2,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables,VOID * scratch)1269 static IA_ERRORCODE ixheaacd_map_index_data(
1270 ia_mps_dec_lossless_data_struct *ll_data,
1271 WORD32 output_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],
1272 WORD32 output_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],
1273 WORD32 cmp_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS],
1274 WORD32 diff_idx_data[][MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS], WORD32 xtt_idx,
1275 WORD32 idx_prev[MAX_NUM_OTT][MAX_PARAMETER_BANDS], WORD32 param_idx, WORD32 param_type,
1276 WORD32 start_band, WORD32 stop_band, WORD32 default_value, WORD32 num_parameter_sets,
1277 WORD32 *param_slot, WORD32 extend_frame, WORD32 quant_mode, WORD32 *ott_vs_tot_db_in,
1278 WORD32 *ott_vs_tot_db_1, WORD32 *ott_vs_tot_db_2,
1279 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables, VOID *scratch) {
1280 WORD32 *a_param_slots;
1281 WORD32 *a_interpolate;
1282
1283 WORD32 data_sets;
1284 WORD32 *a_map;
1285 VOID *free_scratch;
1286
1287 WORD32 set_idx, i, band, parm_slot;
1288 WORD32 data_bands, stride;
1289 WORD32 ps, pb;
1290
1291 WORD32 i1, i2, x1, xi, x2;
1292 WORD32 *db_in;
1293 WORD32 *db_1, *db_2;
1294 db_in = ott_vs_tot_db_in;
1295 db_1 = ott_vs_tot_db_1;
1296 db_2 = ott_vs_tot_db_2;
1297 a_param_slots = scratch;
1298 a_interpolate = a_param_slots + MAX_PARAMETER_SETS;
1299 a_map = a_interpolate + MAX_PARAMETER_SETS;
1300 free_scratch = a_map + MAX_PARAMETER_BANDS_PLUS_1;
1301
1302 data_sets = 0;
1303 for (i = 0; i < num_parameter_sets; i++) {
1304 if (ll_data->bs_xxx_data_mode[param_idx][i] == 3) {
1305 a_param_slots[data_sets] = i;
1306 data_sets++;
1307 }
1308 }
1309
1310 set_idx = 0;
1311
1312 for (i = 0; i < num_parameter_sets; i++) {
1313 if (ll_data->bs_xxx_data_mode[param_idx][i] == 0) {
1314 ll_data->no_cmp_quant_coarse_xxx[param_idx][i] = 0;
1315 for (band = start_band; band < stop_band; band++) {
1316 output_idx_data[xtt_idx][i][band] = default_value;
1317 }
1318 for (band = start_band; band < stop_band; band++) {
1319 idx_prev[xtt_idx][band] = output_idx_data[xtt_idx][i][band];
1320 }
1321 }
1322
1323 if (ll_data->bs_xxx_data_mode[param_idx][i] == 1) {
1324 for (band = start_band; band < stop_band; band++) {
1325 output_idx_data[xtt_idx][i][band] = idx_prev[xtt_idx][band];
1326 }
1327 ll_data->no_cmp_quant_coarse_xxx[param_idx][i] =
1328 ll_data->bs_quant_coarse_xxx_prev[param_idx];
1329 }
1330
1331 if (ll_data->bs_xxx_data_mode[param_idx][i] == 2) {
1332 for (band = start_band; band < stop_band; band++) {
1333 output_idx_data[xtt_idx][i][band] = idx_prev[xtt_idx][band];
1334 }
1335 a_interpolate[i] = 1;
1336 } else {
1337 a_interpolate[i] = 0;
1338 }
1339
1340 if (ll_data->bs_xxx_data_mode[param_idx][i] == 3) {
1341 parm_slot = a_param_slots[set_idx];
1342 stride = ixheaacd_mps_dec_bitdec_tables
1343 ->pb_stride_table[ll_data->bs_freq_res_stride_xxx[param_idx][set_idx]];
1344 data_bands = (stop_band - start_band - 1) / stride + 1;
1345 ixheaacd_create_mapping(a_map, start_band, stop_band, stride, free_scratch);
1346 ixheaacd_map_frequency(&cmp_idx_data[xtt_idx][set_idx][0],
1347 &output_idx_data[xtt_idx][parm_slot][0], a_map, data_bands);
1348
1349 for (band = start_band; band < stop_band; band++) {
1350 idx_prev[xtt_idx][band] = output_idx_data[xtt_idx][parm_slot][band];
1351 }
1352
1353 ll_data->bs_quant_coarse_xxx_prev[param_idx] =
1354 ll_data->bs_quant_coarse_xxx[param_idx][set_idx];
1355 ll_data->no_cmp_quant_coarse_xxx[param_idx][i] =
1356 ll_data->bs_quant_coarse_xxx[param_idx][set_idx];
1357
1358 set_idx++;
1359 }
1360
1361 if (diff_idx_data != NULL) {
1362 for (band = start_band; band < stop_band; band++) {
1363 output_idx_data[xtt_idx][i][band] += diff_idx_data[xtt_idx][i][band];
1364 }
1365 }
1366 }
1367
1368 for (i = 0; i < num_parameter_sets; i++) {
1369 if (a_interpolate[i] != 1) {
1370 if (ll_data->no_cmp_quant_coarse_xxx[param_idx][i] == 1) {
1371 for (band = start_band; band < stop_band; band++) {
1372 ixheaacd_deq_coarse(output_idx_data[xtt_idx][i][band], param_type,
1373 &(output_data[xtt_idx][i][band]), ixheaacd_mps_dec_bitdec_tables);
1374 }
1375 } else {
1376 for (band = start_band; band < stop_band; band++) {
1377 ia_mps_dec_deq(output_idx_data[xtt_idx][i][band], param_type,
1378 &(output_data[xtt_idx][i][band]), ixheaacd_mps_dec_bitdec_tables);
1379 }
1380 }
1381 }
1382 }
1383
1384 if (quant_mode && (param_type == CLD)) {
1385 if (db_in == 0 || db_1 == 0 || db_2 == 0)
1386 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_MPS_PARAM;
1387
1388 for (ps = 0; ps < num_parameter_sets; ps++) {
1389 if (a_interpolate[ps] != 1) {
1390 if (ll_data->no_cmp_quant_coarse_xxx[param_idx][ps]) {
1391 ixheaacd_coarse_2_fine(output_idx_data[xtt_idx][ps], param_type, start_band,
1392 stop_band - start_band);
1393 }
1394 for (pb = start_band; pb < stop_band; pb++) {
1395 ll_data->no_cmp_quant_coarse_xxx[param_idx][ps] = 1;
1396 ixheaacd_factor_cld(&(output_idx_data[xtt_idx][ps][pb]), *db_in++, &(*db_1++),
1397 &(*db_2++), quant_mode, ixheaacd_mps_dec_bitdec_tables);
1398 ia_mps_dec_deq(output_idx_data[xtt_idx][ps][pb], param_type,
1399 &(output_data[xtt_idx][ps][pb]), ixheaacd_mps_dec_bitdec_tables);
1400 }
1401 }
1402 }
1403 }
1404
1405 i1 = 0;
1406 x1 = 0;
1407 i2 = 0;
1408 for (i = 0; i < num_parameter_sets; i++) {
1409 if (a_interpolate[i] != 1) {
1410 i1 = i;
1411 }
1412 i2 = i;
1413 while (a_interpolate[i2] == 1) {
1414 i2++;
1415 }
1416 x1 = param_slot[i1];
1417 xi = param_slot[i];
1418 x2 = param_slot[i2];
1419
1420 if (a_interpolate[i] == 1) {
1421 if (i2 >= num_parameter_sets) return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_PARAMETER_SETS;
1422 if (ll_data->no_cmp_quant_coarse_xxx[param_idx][i1]) {
1423 ixheaacd_coarse_2_fine(output_idx_data[xtt_idx][i1], param_type, start_band,
1424 stop_band - start_band);
1425 }
1426 if (ll_data->no_cmp_quant_coarse_xxx[param_idx][i2]) {
1427 ixheaacd_coarse_2_fine(output_idx_data[xtt_idx][i2], param_type, start_band,
1428 stop_band - start_band);
1429 }
1430 for (band = start_band; band < stop_band; band++) {
1431 WORD32 yi = 0, y1, y2;
1432 y1 = output_idx_data[xtt_idx][i1][band];
1433 y2 = output_idx_data[xtt_idx][i2][band];
1434
1435 if (x2 != x1) {
1436 yi = y1 + (xi - x1) * (y2 - y1) / (x2 - x1);
1437 }
1438 output_idx_data[xtt_idx][i][band] = yi;
1439 ia_mps_dec_deq(output_idx_data[xtt_idx][i][band], param_type,
1440 &(output_data[xtt_idx][i][band]), ixheaacd_mps_dec_bitdec_tables);
1441 }
1442 }
1443 }
1444
1445 if (extend_frame) {
1446 for (band = start_band; band < stop_band; band++) {
1447 output_data[xtt_idx][num_parameter_sets][band] =
1448 output_data[xtt_idx][num_parameter_sets - 1][band];
1449 output_idx_data[xtt_idx][num_parameter_sets][band] =
1450 output_idx_data[xtt_idx][num_parameter_sets - 1][band];
1451 }
1452 }
1453 return IA_NO_ERROR;
1454 }
1455
ixheaacd_get_parameters_mapping(WORD32 bs_parameter_bands,WORD32 * mapping,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1456 static VOID ixheaacd_get_parameters_mapping(
1457 WORD32 bs_parameter_bands, WORD32 *mapping,
1458 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1459 switch (bs_parameter_bands) {
1460 case PARAMETER_BANDS_4:
1461 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_4_to_28;
1462 break;
1463 case PARAMETER_BANDS_5:
1464 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_5_to_28;
1465 break;
1466 case PARAMETER_BANDS_7:
1467 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_7_to_28;
1468 break;
1469 case PARAMETER_BANDS_10:
1470 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_10_to_28;
1471 break;
1472 case PARAMETER_BANDS_14:
1473 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_14_to_28;
1474 break;
1475 case PARAMETER_BANDS_20:
1476 mapping = ixheaacd_mps_dec_bitdec_tables->map_table.mapping_20_to_28;
1477 break;
1478 case PARAMETER_BANDS_28:
1479 break;
1480 default:
1481 break;
1482 }
1483 return;
1484 }
1485
ixheaacd_map_number_of_bands_to_28_bands(WORD32 bands,WORD32 bs_parameter_bands,WORD32 * bands28,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1486 static VOID ixheaacd_map_number_of_bands_to_28_bands(
1487 WORD32 bands, WORD32 bs_parameter_bands, WORD32 *bands28,
1488 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1489 WORD32 *mapping = NULL;
1490 WORD32 pb;
1491
1492 *bands28 = bands;
1493
1494 ixheaacd_get_parameters_mapping(bs_parameter_bands, mapping, ixheaacd_mps_dec_bitdec_tables);
1495
1496 if (mapping != NULL) {
1497 for (pb = 0; pb < MAX_PARAMETER_BANDS; pb++) {
1498 if (mapping[pb] == bands) {
1499 break;
1500 }
1501 }
1502 *bands28 = pb;
1503 }
1504 return;
1505 }
1506
ixheaacd_map_data_to_28_bands(WORD32 * data,WORD32 bs_parameter_bands,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)1507 static VOID ixheaacd_map_data_to_28_bands(
1508 WORD32 *data, WORD32 bs_parameter_bands,
1509 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
1510 WORD32 *mapping = NULL;
1511 WORD32 pb;
1512
1513 ixheaacd_get_parameters_mapping(bs_parameter_bands, mapping, ixheaacd_mps_dec_bitdec_tables);
1514
1515 if (mapping != NULL) {
1516 for (pb = MAX_PARAMETER_BANDS - 1; pb >= 0; pb--) {
1517 data[pb] = data[mapping[pb]];
1518 }
1519 }
1520 return;
1521 }
1522
ixheaacd_decode_and_map_frame_ott(ia_heaac_mps_state_struct * pstr_mps_state)1523 static VOID ixheaacd_decode_and_map_frame_ott(ia_heaac_mps_state_struct *pstr_mps_state) {
1524 ia_mps_dec_spatial_bs_frame_struct *p_cur_bs = pstr_mps_state->bs_frame;
1525 ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
1526 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
1527 ia_mps_dec_bitdec_tables_struct *bitdec_table =
1528 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
1529 WORD32 *param_slot = pstr_mps_state->aux_struct->param_slot;
1530
1531 WORD32 i, num_parameter_sets, ott_idx, band;
1532 WORD32 num_ott_boxes;
1533 VOID *free_scratch;
1534
1535 WORD32 ps, pb;
1536
1537 WORD32 *tot_db;
1538 WORD32 *ott_vs_tot_db_fc;
1539 WORD32 *ott_vs_tot_db_s;
1540 WORD32 *ott_vs_tot_db_f;
1541 WORD32 *ott_vs_tot_db_c;
1542 WORD32 *ott_vs_tot_db_lr;
1543 WORD32 *ott_vs_tot_db_l;
1544 WORD32 *ott_vs_tot_db_r;
1545 WORD32 *tmp1;
1546 WORD32 *tmp2;
1547
1548 WORD32 bitstream_parameter_bands = curr_state->bitstream_parameter_bands;
1549 WORD32 *b_ott_bands = curr_state->bitstream_ott_bands;
1550 WORD32 *ott_cld_default = curr_state->ott_cld_default;
1551 WORD32 parameter_sets = curr_state->num_parameter_sets;
1552 WORD32 extend_frame = curr_state->extend_frame;
1553 WORD32 quant_mode = curr_state->quant_mode;
1554
1555 tot_db = pstr_mps_state->mps_scratch_mem_v;
1556 ott_vs_tot_db_fc = tot_db + MAX_PSXPB;
1557 ott_vs_tot_db_s = ott_vs_tot_db_fc + MAX_PSXPB;
1558 ott_vs_tot_db_f = ott_vs_tot_db_s + MAX_PSXPB;
1559 ott_vs_tot_db_c = ott_vs_tot_db_f + MAX_PSXPB;
1560 ott_vs_tot_db_lr = ott_vs_tot_db_c + MAX_PSXPB;
1561 ott_vs_tot_db_l = ott_vs_tot_db_lr + MAX_PSXPB;
1562 ott_vs_tot_db_r = ott_vs_tot_db_l + MAX_PSXPB;
1563 tmp1 = ott_vs_tot_db_r + MAX_PSXPB;
1564 tmp2 = tmp1 + MAX_PSXPB;
1565 free_scratch = tmp2 + MAX_PSXPB;
1566
1567 p_cur_bs = pstr_mps_state->bs_frame;
1568 num_ott_boxes = curr_state->num_ott_boxes;
1569
1570 pb = MAX_PSXPB;
1571 for (i = 0; i < pb; i++) tot_db[i] = 0;
1572
1573 switch (curr_state->tree_config) {
1574 case TREE_5151:
1575 i = 0;
1576
1577 ixheaacd_map_index_data(
1578 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1579 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1580 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1581 quant_mode, tot_db, ott_vs_tot_db_fc, ott_vs_tot_db_s, bitdec_table, free_scratch);
1582
1583 i = 1;
1584
1585 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1586 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, i,
1587 p_cur_bs->ott_cld_idx_prev, i, CLD, 0, b_ott_bands[i],
1588 ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1589 quant_mode, ott_vs_tot_db_fc, ott_vs_tot_db_f, ott_vs_tot_db_c,
1590 bitdec_table, free_scratch);
1591
1592 i = 2;
1593 ixheaacd_map_index_data(
1594 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1595 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1596 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1597 quant_mode, ott_vs_tot_db_s, tmp1, tmp2, bitdec_table, free_scratch);
1598
1599 i = 3;
1600 ixheaacd_map_index_data(
1601 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1602 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1603 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1604 quant_mode, ott_vs_tot_db_f, tmp1, tmp2, bitdec_table, free_scratch);
1605
1606 i = 4;
1607 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1608 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, i,
1609 p_cur_bs->ott_cld_idx_prev, i, CLD, 0, b_ott_bands[i],
1610 ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1611 quant_mode, tot_db, tmp1, tmp2, bitdec_table, free_scratch);
1612
1613 break;
1614
1615 case TREE_5152:
1616 i = 0;
1617 ixheaacd_map_index_data(
1618 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1619 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1620 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1621 quant_mode, tot_db, ott_vs_tot_db_lr, ott_vs_tot_db_c, bitdec_table, free_scratch);
1622 i = 1;
1623 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1624 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, i,
1625 p_cur_bs->ott_cld_idx_prev, i, CLD, 0, b_ott_bands[i],
1626 ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1627 quant_mode, ott_vs_tot_db_lr, ott_vs_tot_db_l, ott_vs_tot_db_r,
1628 bitdec_table, free_scratch);
1629 i = 2;
1630 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1631 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, i,
1632 p_cur_bs->ott_cld_idx_prev, i, CLD, 0, b_ott_bands[i],
1633 ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1634 quant_mode, tot_db, tmp1, tmp2, bitdec_table, free_scratch);
1635 i = 3;
1636 ixheaacd_map_index_data(
1637 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1638 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1639 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1640 quant_mode, ott_vs_tot_db_l, tmp1, tmp2, bitdec_table, free_scratch);
1641 i = 4;
1642 ixheaacd_map_index_data(
1643 &p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld, p_cur_bs->ott_cld_idx,
1644 p_cur_bs->cmp_ott_cld_idx, NULL, i, p_cur_bs->ott_cld_idx_prev, i, CLD, 0,
1645 b_ott_bands[i], ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1646 quant_mode, ott_vs_tot_db_r, tmp1, tmp2, bitdec_table, free_scratch);
1647 break;
1648
1649 default:
1650 for (i = 0; i < num_ott_boxes; i++) {
1651 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1652 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, i,
1653 p_cur_bs->ott_cld_idx_prev, i, CLD, 0, b_ott_bands[i],
1654 ott_cld_default[i], parameter_sets, param_slot, extend_frame,
1655 (curr_state->tree_config == TREE_525) ? 0 : quant_mode, NULL,
1656 NULL, NULL, bitdec_table, free_scratch);
1657 }
1658 break;
1659 }
1660
1661 if (curr_state->one_icc == 1) {
1662 if (extend_frame == 0) {
1663 num_parameter_sets = parameter_sets;
1664 } else {
1665 num_parameter_sets = parameter_sets + 1;
1666 }
1667
1668 for (ott_idx = 1; ott_idx < num_ott_boxes; ott_idx++) {
1669 if (curr_state->ott_mode_lfe[ott_idx] == 0) {
1670 for (i = 0; i < num_parameter_sets; i++) {
1671 for (band = 0; band < bitstream_parameter_bands; band++) {
1672 p_cur_bs->cmp_ott_icc_idx[ott_idx][i][band] = p_cur_bs->cmp_ott_icc_idx[0][i][band];
1673 }
1674 }
1675 }
1676 }
1677
1678 for (ott_idx = 0; ott_idx < num_ott_boxes; ott_idx++) {
1679 if (curr_state->ott_mode_lfe[ott_idx] == 0) {
1680 ixheaacd_map_index_data(&p_cur_bs->icc_lossless_data, p_aux_struct->ott_icc,
1681 p_cur_bs->ott_icc_idx, p_cur_bs->cmp_ott_icc_idx,
1682 p_cur_bs->ott_icc_diff_idx, ott_idx, p_cur_bs->ott_icc_idx_prev,
1683 0, ICC, 0, b_ott_bands[ott_idx], curr_state->icc_default,
1684 parameter_sets, param_slot, extend_frame, quant_mode, NULL, NULL,
1685 NULL, bitdec_table, free_scratch);
1686 }
1687 }
1688 } else {
1689 for (ott_idx = 0; ott_idx < num_ott_boxes; ott_idx++) {
1690 if (curr_state->ott_mode_lfe[ott_idx] == 0) {
1691 ixheaacd_map_index_data(&p_cur_bs->icc_lossless_data, p_aux_struct->ott_icc,
1692 p_cur_bs->ott_icc_idx, p_cur_bs->cmp_ott_icc_idx,
1693 p_cur_bs->ott_icc_diff_idx, ott_idx, p_cur_bs->ott_icc_idx_prev,
1694 ott_idx, ICC, 0, b_ott_bands[ott_idx], curr_state->icc_default,
1695 parameter_sets, param_slot, extend_frame, quant_mode, NULL, NULL,
1696 NULL, bitdec_table, free_scratch);
1697 }
1698 }
1699 }
1700
1701 if (curr_state->up_mix_type == 2) {
1702 WORD32 num_parameter_sets = parameter_sets;
1703
1704 if (extend_frame) {
1705 num_parameter_sets++;
1706 }
1707
1708 for (ott_idx = 0; ott_idx < curr_state->num_ott_boxes; ott_idx++) {
1709 for (ps = 0; ps < num_parameter_sets; ps++) {
1710 ixheaacd_map_data_to_28_bands(p_aux_struct->ott_cld[ott_idx][ps],
1711 bitstream_parameter_bands, bitdec_table);
1712 ixheaacd_map_data_to_28_bands(p_aux_struct->ott_icc[ott_idx][ps],
1713 bitstream_parameter_bands, bitdec_table);
1714 }
1715 }
1716 }
1717 return;
1718 }
1719
ixheaacd_decode_and_map_frame_ttt(ia_heaac_mps_state_struct * pstr_mps_state)1720 static VOID ixheaacd_decode_and_map_frame_ttt(ia_heaac_mps_state_struct *pstr_mps_state) {
1721 ia_mps_dec_spatial_bs_frame_struct *p_cur_bs = pstr_mps_state->bs_frame;
1722 ia_mps_dec_bitdec_tables_struct *bitdec_table =
1723 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
1724 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
1725 WORD32 *param_slot = pstr_mps_state->aux_struct->param_slot;
1726
1727 WORD32 num_bands;
1728
1729 WORD32 i, j, offset;
1730 WORD32 num_ttt_boxes;
1731 VOID *free_scratch;
1732
1733 p_cur_bs = pstr_mps_state->bs_frame;
1734 num_bands = pstr_mps_state->bitstream_parameter_bands;
1735 offset = pstr_mps_state->num_ott_boxes;
1736 num_ttt_boxes = pstr_mps_state->num_ttt_boxes;
1737 free_scratch = pstr_mps_state->mps_scratch_mem_v;
1738
1739 for (i = 0; i < num_ttt_boxes; i++) {
1740 for (j = 0;
1741 (j < 2) &&
1742 p_aux_struct->ttt_config[j][i].start_band < p_aux_struct->ttt_config[j][i].stop_band;
1743 j++) {
1744 if (p_aux_struct->ttt_config[j][i].mode < 2) {
1745 ixheaacd_map_index_data(
1746 &p_cur_bs->cpc_lossless_data, p_aux_struct->ttt_cpc_1, p_cur_bs->ttt_cpc_1_idx,
1747 p_cur_bs->cmp_ttt_cpc_1_idx, NULL, i, p_cur_bs->ttt_cpc_1_idx_prev,
1748 offset + 4 * i + 2 * j, CPC, p_aux_struct->ttt_config[j][i].bitstream_start_band,
1749 p_aux_struct->ttt_config[j][i].bitstream_stop_band, pstr_mps_state->cpc_default,
1750 pstr_mps_state->num_parameter_sets, param_slot, pstr_mps_state->extend_frame,
1751 pstr_mps_state->quant_mode, NULL, NULL, NULL, bitdec_table, free_scratch);
1752
1753 ixheaacd_map_index_data(
1754 &p_cur_bs->cpc_lossless_data, p_aux_struct->ttt_cpc_2, p_cur_bs->ttt_cpc_2_idx,
1755 p_cur_bs->cmp_ttt_cpc_2_idx, NULL, i, p_cur_bs->ttt_cpc_2_idx_prev,
1756 offset + 4 * i + 1 + 2 * j, CPC, p_aux_struct->ttt_config[j][i].bitstream_start_band,
1757 p_aux_struct->ttt_config[j][i].bitstream_stop_band, pstr_mps_state->cpc_default,
1758 pstr_mps_state->num_parameter_sets, param_slot, pstr_mps_state->extend_frame,
1759 pstr_mps_state->quant_mode, NULL, NULL, NULL, bitdec_table, free_scratch);
1760
1761 ixheaacd_map_index_data(
1762 &p_cur_bs->icc_lossless_data, p_aux_struct->ttt_icc, p_cur_bs->ttt_icc_idx,
1763 p_cur_bs->cmp_ttt_icc_idx, NULL, i, p_cur_bs->ttt_icc_idx_prev,
1764 offset + 4 * i + 2 * j, ICC, p_aux_struct->ttt_config[j][i].bitstream_start_band,
1765 p_aux_struct->ttt_config[j][i].bitstream_stop_band, pstr_mps_state->icc_default,
1766 pstr_mps_state->num_parameter_sets, param_slot, pstr_mps_state->extend_frame,
1767 pstr_mps_state->quant_mode, NULL, NULL, NULL, bitdec_table, free_scratch);
1768 }
1769
1770 else {
1771 ixheaacd_map_index_data(
1772 &p_cur_bs->cld_lossless_data, p_aux_struct->ttt_cld_1, p_cur_bs->ttt_cld_1_idx,
1773 p_cur_bs->cmp_ttt_cld_1_idx, NULL, i, p_cur_bs->ttt_cld_1_idx_prev,
1774 offset + 4 * i + 2 * j, CLD, p_aux_struct->ttt_config[j][i].bitstream_start_band,
1775 p_aux_struct->ttt_config[j][i].bitstream_stop_band,
1776 pstr_mps_state->ttt_cld_1_default[i], pstr_mps_state->num_parameter_sets, param_slot,
1777 pstr_mps_state->extend_frame, pstr_mps_state->quant_mode, NULL, NULL, NULL,
1778 bitdec_table, free_scratch);
1779
1780 ixheaacd_map_index_data(
1781 &p_cur_bs->cld_lossless_data, p_aux_struct->ttt_cld_2, p_cur_bs->ttt_cld_2_idx,
1782 p_cur_bs->cmp_ttt_cld_2_idx, NULL, i, p_cur_bs->ttt_cld_2_idx_prev,
1783 offset + 4 * i + 1 + 2 * j, CLD, p_aux_struct->ttt_config[j][i].bitstream_start_band,
1784 p_aux_struct->ttt_config[j][i].bitstream_stop_band,
1785 pstr_mps_state->ttt_cld_2_default[i], pstr_mps_state->num_parameter_sets, param_slot,
1786 pstr_mps_state->extend_frame, pstr_mps_state->quant_mode, NULL, NULL, NULL,
1787 bitdec_table, free_scratch);
1788 }
1789
1790 if (pstr_mps_state->up_mix_type == 2) {
1791 WORD32 num_parameter_sets = pstr_mps_state->num_parameter_sets;
1792 WORD32 ps;
1793
1794 if (pstr_mps_state->extend_frame) {
1795 num_parameter_sets++;
1796 }
1797
1798 for (ps = 0; ps < num_parameter_sets; ps++) {
1799 ixheaacd_map_data_to_28_bands(p_aux_struct->ttt_cpc_1[i][ps], num_bands, bitdec_table);
1800 ixheaacd_map_data_to_28_bands(p_aux_struct->ttt_cpc_2[i][ps], num_bands, bitdec_table);
1801 ixheaacd_map_data_to_28_bands(p_aux_struct->ttt_cld_1[i][ps], num_bands, bitdec_table);
1802 ixheaacd_map_data_to_28_bands(p_aux_struct->ttt_cld_2[i][ps], num_bands, bitdec_table);
1803 ixheaacd_map_data_to_28_bands(p_aux_struct->ttt_icc[i][ps], num_bands, bitdec_table);
1804 }
1805 }
1806 }
1807 }
1808 }
1809
ixheaacd_decode_and_map_frame_smg(ia_heaac_mps_state_struct * pstr_mps_state)1810 static VOID ixheaacd_decode_and_map_frame_smg(ia_heaac_mps_state_struct *pstr_mps_state) {
1811 ia_mps_dec_smoothing_state_struct *smooth_state =
1812 pstr_mps_state->mps_persistent_mem.smooth_state;
1813 ia_mps_dec_bitdec_tables_struct *bitdec_table =
1814 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
1815 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
1816 WORD32 *smg_time = p_aux_struct->smg_time;
1817 WORD32 ps, pb, pg, pb_stride, data_bands, pb_start, pb_stop;
1818 WORD32 *a_group_to_band;
1819 VOID *free_scratch;
1820 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
1821 pstr_mps_state->smooth_control = frame->bs_smooth_control;
1822 a_group_to_band = pstr_mps_state->mps_scratch_mem_v;
1823 free_scratch = a_group_to_band + MAX_PARAMETER_BANDS_PLUS_1;
1824
1825 if (pstr_mps_state->smooth_control) {
1826 for (ps = 0; ps < pstr_mps_state->num_parameter_sets; ps++) {
1827 switch (frame->bs_smooth_mode[ps]) {
1828 case SMOOTH_MODE_0:
1829 smg_time[ps] = 256;
1830 for (pb = 0; pb < pstr_mps_state->bitstream_parameter_bands; pb++) {
1831 p_aux_struct->smg_data[ps][pb] = 0;
1832 }
1833 break;
1834
1835 case SMOOTH_MODE_1:
1836 if (ps > 0)
1837 smg_time[ps] = smg_time[ps - 1];
1838 else
1839 smg_time[ps] = smooth_state->prev_smg_time;
1840
1841 for (pb = 0; pb < pstr_mps_state->bitstream_parameter_bands; pb++) {
1842 if (ps > 0)
1843 p_aux_struct->smg_data[ps][pb] = p_aux_struct->smg_data[ps - 1][pb];
1844 else
1845 p_aux_struct->smg_data[ps][pb] = smooth_state->prev_smg_data[pb];
1846 }
1847 break;
1848
1849 case SMOOTH_MODE_2:
1850 smg_time[ps] = bitdec_table->smg_time_table[frame->bs_smooth_time[ps]];
1851 for (pb = 0; pb < pstr_mps_state->bitstream_parameter_bands; pb++) {
1852 p_aux_struct->smg_data[ps][pb] = 1;
1853 }
1854 break;
1855
1856 case SMOOTH_MODE_3:
1857 smg_time[ps] = bitdec_table->smg_time_table[frame->bs_smooth_time[ps]];
1858 pb_stride = bitdec_table->pb_stride_table[frame->bs_freq_res_stride_smg[ps]];
1859 data_bands = (pstr_mps_state->bitstream_parameter_bands - 1) / pb_stride + 1;
1860 ixheaacd_create_mapping(a_group_to_band, 0, pstr_mps_state->bitstream_parameter_bands,
1861 pb_stride, free_scratch);
1862 for (pg = 0; pg < data_bands; pg++) {
1863 pb_start = a_group_to_band[pg];
1864 pb_stop = a_group_to_band[pg + 1];
1865 for (pb = pb_start; pb < pb_stop; pb++) {
1866 p_aux_struct->smg_data[ps][pb] = frame->bs_smg_data[ps][pg];
1867 }
1868 }
1869 break;
1870
1871 default:
1872 break;
1873 }
1874 }
1875
1876 smooth_state->prev_smg_time = smg_time[pstr_mps_state->num_parameter_sets - 1];
1877 for (pb = 0; pb < pstr_mps_state->bitstream_parameter_bands; pb++) {
1878 smooth_state->prev_smg_data[pb] =
1879 p_aux_struct->smg_data[pstr_mps_state->num_parameter_sets - 1][pb];
1880 }
1881
1882 if (pstr_mps_state->extend_frame) {
1883 smg_time[pstr_mps_state->num_parameter_sets] =
1884 smg_time[pstr_mps_state->num_parameter_sets - 1];
1885 for (pb = 0; pb < pstr_mps_state->bitstream_parameter_bands; pb++) {
1886 p_aux_struct->smg_data[pstr_mps_state->num_parameter_sets][pb] =
1887 p_aux_struct->smg_data[pstr_mps_state->num_parameter_sets - 1][pb];
1888 }
1889 }
1890
1891 if (pstr_mps_state->up_mix_type == 2) {
1892 WORD32 *mapping = NULL;
1893 ixheaacd_get_parameters_mapping(pstr_mps_state->bitstream_parameter_bands, mapping,
1894 bitdec_table);
1895
1896 if (mapping != NULL) {
1897 WORD32 num_parameter_sets = pstr_mps_state->num_parameter_sets;
1898
1899 if (pstr_mps_state->extend_frame) {
1900 num_parameter_sets++;
1901 }
1902
1903 for (ps = 0; ps < num_parameter_sets; ps++) {
1904 for (pb = MAX_PARAMETER_BANDS - 1; pb >= 0; pb--) {
1905 p_aux_struct->smg_data[ps][pb] = p_aux_struct->smg_data[ps][mapping[pb]];
1906 }
1907 }
1908 }
1909 }
1910 }
1911 return;
1912 }
1913
ixheaacd_decode_and_map_frame_arbdmx(ia_heaac_mps_state_struct * pstr_mps_state)1914 static VOID ixheaacd_decode_and_map_frame_arbdmx(ia_heaac_mps_state_struct *pstr_mps_state) {
1915 ia_mps_dec_spatial_bs_frame_struct *frame = pstr_mps_state->bs_frame;
1916 ia_mps_dec_bitdec_tables_struct *bitdec_table =
1917 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
1918 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
1919 WORD32 *param_slot = p_aux_struct->param_slot;
1920 WORD32 offset = pstr_mps_state->num_ott_boxes + 4 * pstr_mps_state->num_ttt_boxes;
1921 WORD32 ch;
1922
1923 VOID *scratch = pstr_mps_state->mps_scratch_mem_v;
1924
1925 for (ch = 0; ch < pstr_mps_state->num_input_channels; ch++) {
1926 ixheaacd_map_index_data(
1927 &frame->cld_lossless_data, p_aux_struct->arbdmx_gain, frame->arbdmx_gain_idx,
1928 frame->cmp_arbdmx_gain_idx, NULL, ch, frame->arbdmx_gain_idx_prev, offset + ch, CLD, 0,
1929 pstr_mps_state->bitstream_parameter_bands, pstr_mps_state->arbdmx_gain_default,
1930 pstr_mps_state->num_parameter_sets, param_slot, pstr_mps_state->extend_frame, 0, NULL,
1931 NULL, NULL, bitdec_table, scratch);
1932
1933 p_aux_struct->arbdmx_residual_abs[ch] = frame->bs_arbitrary_downmix_residual_abs[ch];
1934 p_aux_struct->arbdmx_alpha_upd_set[ch] =
1935 frame->bs_arbitrary_downmix_residual_alpha_update_set[ch];
1936
1937 if (pstr_mps_state->up_mix_type == 2) {
1938 WORD32 num_parameter_sets = pstr_mps_state->num_parameter_sets;
1939 WORD32 ps;
1940
1941 if (pstr_mps_state->extend_frame) {
1942 num_parameter_sets++;
1943 }
1944
1945 for (ps = 0; ps < num_parameter_sets; ps++) {
1946 ixheaacd_map_data_to_28_bands(p_aux_struct->arbdmx_gain[ch][ps],
1947 pstr_mps_state->bitstream_parameter_bands, bitdec_table);
1948 }
1949 }
1950 }
1951 }
1952
ixheaacd_decode_and_map_frame_arb_tree(ia_heaac_mps_state_struct * pstr_mps_state)1953 static VOID ixheaacd_decode_and_map_frame_arb_tree(ia_heaac_mps_state_struct *pstr_mps_state) {
1954 ia_mps_dec_spatial_bs_frame_struct *p_cur_bs = pstr_mps_state->bs_frame;
1955 ia_mps_spatial_bs_config_struct *p_config = &(pstr_mps_state->bs_config);
1956 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
1957 WORD32 *param_slot = p_aux_struct->param_slot;
1958 WORD32 offset = pstr_mps_state->num_ott_boxes;
1959
1960 VOID *scratch = pstr_mps_state->mps_scratch_mem_v;
1961
1962 WORD32 i;
1963
1964 for (i = 0; i < p_config->num_ott_boxes_at; i++) {
1965 ixheaacd_map_index_data(&p_cur_bs->cld_lossless_data, p_aux_struct->ott_cld,
1966 p_cur_bs->ott_cld_idx, p_cur_bs->cmp_ott_cld_idx, NULL, offset + i,
1967 p_cur_bs->ott_cld_idx_prev, offset + i, CLD, 0,
1968 p_config->bs_ott_bands_at[i], p_config->bs_ott_default_cld_at[i],
1969 pstr_mps_state->num_parameter_sets, param_slot,
1970 pstr_mps_state->extend_frame, pstr_mps_state->quant_mode, NULL, NULL,
1971 NULL, pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr, scratch);
1972 }
1973 }
1974
ixheaacd_decode_frame(ia_heaac_mps_state_struct * pstr_mps_state)1975 IA_ERRORCODE ixheaacd_decode_frame(ia_heaac_mps_state_struct *pstr_mps_state) {
1976 ia_mps_spatial_bs_config_struct *p_bs_config = &pstr_mps_state->bs_config;
1977 WORD32 *param_slot = pstr_mps_state->aux_struct->param_slot;
1978
1979 pstr_mps_state->extend_frame = 0;
1980 if (param_slot[pstr_mps_state->num_parameter_sets - 1] != pstr_mps_state->time_slots - 1) {
1981 pstr_mps_state->extend_frame = 1;
1982 }
1983
1984 ixheaacd_decode_and_map_frame_ott(pstr_mps_state);
1985 ixheaacd_decode_and_map_frame_ttt(pstr_mps_state);
1986
1987 ixheaacd_decode_and_map_frame_smg(pstr_mps_state);
1988 if (p_bs_config->arbitrary_tree != 0) {
1989 ixheaacd_decode_and_map_frame_arb_tree(pstr_mps_state);
1990 }
1991
1992 if (pstr_mps_state->arbitrary_downmix != 0) {
1993 ixheaacd_decode_and_map_frame_arbdmx(pstr_mps_state);
1994 }
1995
1996 if (pstr_mps_state->extend_frame) {
1997 pstr_mps_state->num_parameter_sets++;
1998 if (pstr_mps_state->num_parameter_sets > MAX_PARAMETER_SETS) {
1999 if (pstr_mps_state->ec_flag)
2000 pstr_mps_state->num_parameter_sets = 1;
2001 else
2002 return IA_FATAL_ERROR;
2003 }
2004
2005 param_slot[pstr_mps_state->num_parameter_sets - 1] = pstr_mps_state->time_slots - 1;
2006 }
2007 return IA_NO_ERROR;
2008 }
2009
ixheaacd_set_current_state_parameters(ia_heaac_mps_state_struct * pstr_mps_state)2010 IA_ERRORCODE ixheaacd_set_current_state_parameters(ia_heaac_mps_state_struct *pstr_mps_state) {
2011 WORD32 i;
2012
2013 ia_mps_spatial_bs_config_struct *config = &(pstr_mps_state->bs_config);
2014 ia_mps_spatial_bs_config_struct *p_bs_config = &pstr_mps_state->bs_config;
2015 ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
2016 ia_mps_dec_bitdec_tables_struct *bitdec_table =
2017 pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr;
2018 ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
2019 WORD32 *b_ott_bands = curr_state->bitstream_ott_bands;
2020
2021 if (config->bs_sampling_freq_index == 15) {
2022 curr_state->sampling_freq = config->bs_sampling_frequency;
2023 } else {
2024 curr_state->sampling_freq = bitdec_table->sampling_freq_table[config->bs_sampling_freq_index];
2025 }
2026 curr_state->time_slots = config->bs_frame_length + 1;
2027 curr_state->frame_length = curr_state->time_slots * curr_state->qmf_bands;
2028 curr_state->bitstream_parameter_bands = bitdec_table->freq_res_table[config->bs_freq_res];
2029
2030 curr_state->hybrid_bands = curr_state->qmf_bands - QMF_BANDS_TO_HYBRID + 10;
2031 curr_state->tp_hyb_band_border = 12;
2032 if (curr_state->hybrid_bands > 71) {
2033 return IA_FATAL_ERROR;
2034 }
2035 if (curr_state->up_mix_type == 2) {
2036 curr_state->num_parameter_bands = MAX_PARAMETER_BANDS;
2037 } else {
2038 curr_state->num_parameter_bands = curr_state->bitstream_parameter_bands;
2039 }
2040
2041 switch (curr_state->num_parameter_bands) {
2042 case PARAMETER_BANDS_4:
2043 for (i = 0; i < curr_state->hybrid_bands; i++) {
2044 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_4_to_71[i];
2045 }
2046 break;
2047 case PARAMETER_BANDS_5:
2048 for (i = 0; i < curr_state->hybrid_bands; i++) {
2049 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_5_to_71[i];
2050 }
2051 break;
2052 case PARAMETER_BANDS_7:
2053 for (i = 0; i < curr_state->hybrid_bands; i++) {
2054 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_7_to_71[i];
2055 }
2056 break;
2057 case PARAMETER_BANDS_10:
2058 for (i = 0; i < curr_state->hybrid_bands; i++) {
2059 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_10_to_71[i];
2060 }
2061 break;
2062 case PARAMETER_BANDS_14:
2063 for (i = 0; i < curr_state->hybrid_bands; i++) {
2064 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_14_to_71[i];
2065 }
2066 break;
2067 case PARAMETER_BANDS_20:
2068 for (i = 0; i < curr_state->hybrid_bands; i++) {
2069 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_20_to_71[i];
2070 }
2071 break;
2072 case PARAMETER_BANDS_28:
2073 for (i = 0; i < curr_state->hybrid_bands; i++) {
2074 curr_state->kernels[i] = bitdec_table->kernel_table.kernels_28_to_71[i];
2075 }
2076 break;
2077 default:
2078 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_PARAMETER_BANDS;
2079 };
2080
2081 curr_state->tree_config = config->bs_tree_config;
2082
2083 switch (curr_state->tree_config) {
2084 case TREE_5151:
2085 case TREE_5152:
2086 case TREE_525:
2087 config->ui_channel_mask = FIVE_POINT_ONE_CHANNEL_MASK;
2088 break;
2089 case TREE_7271:
2090 case TREE_7571:
2091 config->ui_channel_mask = SEVEN_POINT_ONE_CHANNEL_MASK1;
2092 break;
2093 case TREE_7272:
2094 case TREE_7572:
2095 config->ui_channel_mask = SEVEN_POINT_ONE_CHANNEL_MASK2;
2096 break;
2097 default:
2098 return IA_XHEAAC_MPS_DEC_EXE_FATAL_UNSUPPRORTED_TREE_CONFIG;
2099 }
2100
2101 curr_state->num_ott_boxes =
2102 bitdec_table->tree_property_table[curr_state->tree_config].num_ott_boxes;
2103 curr_state->num_ttt_boxes =
2104 bitdec_table->tree_property_table[curr_state->tree_config].num_ttt_boxes;
2105 curr_state->num_input_channels =
2106 bitdec_table->tree_property_table[curr_state->tree_config].num_input_channels;
2107 curr_state->num_output_channels =
2108 bitdec_table->tree_property_table[curr_state->tree_config].num_output_channels;
2109 curr_state->quant_mode = config->bs_quant_mode;
2110 curr_state->one_icc = config->bs_one_icc;
2111 curr_state->arbitrary_downmix = config->bs_arbitrary_downmix;
2112 curr_state->residual_coding = config->bs_residual_coding;
2113 curr_state->smooth_config = config->bs_smooth_config;
2114 curr_state->mtx_inversion = config->bs_matrix_mode;
2115 curr_state->temp_shape_config = config->bs_temp_shape_config;
2116 curr_state->decorr_config = config->bs_decorr_config;
2117 curr_state->env_quant_mode = config->bs_env_quant_mode;
2118 curr_state->lfe_gain = bitdec_table->lfe_gain_table[config->bs_fixed_gain_lfe];
2119 curr_state->surround_gain = bitdec_table->surround_gain_table[config->bs_fixed_gain_sur];
2120 curr_state->clip_protect_gain = bitdec_table->clip_gain_table[config->bs_fixed_gain_dmx];
2121
2122 if (curr_state->up_mix_type == 2) {
2123 curr_state->num_output_channels = 2;
2124 curr_state->decorr_config = 0;
2125 }
2126
2127 if (curr_state->up_mix_type == 3) {
2128 curr_state->num_output_channels = 2;
2129 }
2130
2131 if (p_bs_config->arbitrary_tree == 1)
2132 curr_state->num_output_channels_at = p_bs_config->num_out_chan_at;
2133 else
2134 curr_state->num_output_channels_at = curr_state->num_output_channels;
2135
2136 p_bs_config->ui_out_channels = curr_state->num_output_channels_at;
2137
2138 curr_state->_3d_stereo_inversion = config->bs_3d_audio_mode;
2139
2140 if (curr_state->mtx_inversion == 1 || curr_state->_3d_stereo_inversion == 1)
2141 curr_state->m1_param_imag_present = 1;
2142
2143 for (i = 0; i < curr_state->num_ott_boxes; i++) {
2144 if (bitdec_table->tree_property_table[curr_state->tree_config].ott_mode_lfe[i]) {
2145 b_ott_bands[i] = config->bs_ott_bands[i];
2146 curr_state->ott_mode_lfe[i] = 1;
2147 } else {
2148 b_ott_bands[i] = curr_state->bitstream_parameter_bands;
2149 curr_state->ott_mode_lfe[i] = 0;
2150 }
2151
2152 if (curr_state->up_mix_type == 2) {
2153 ixheaacd_map_number_of_bands_to_28_bands(b_ott_bands[i],
2154 curr_state->bitstream_parameter_bands,
2155 &p_aux_struct->num_ott_bands[i], bitdec_table);
2156 } else {
2157 p_aux_struct->num_ott_bands[i] = b_ott_bands[i];
2158 }
2159 }
2160 for (i = 0; i < curr_state->num_ttt_boxes; i++) {
2161 p_aux_struct->ttt_config[0][i].mode = config->bs_ttt_mode_low[i];
2162 p_aux_struct->ttt_config[1][i].mode = config->bs_ttt_mode_high[i];
2163 p_aux_struct->ttt_config[0][i].bitstream_start_band = 0;
2164 p_aux_struct->ttt_config[1][i].bitstream_stop_band = curr_state->bitstream_parameter_bands;
2165
2166 if (config->bs_ttt_dual_mode[i]) {
2167 p_aux_struct->ttt_config[0][i].bitstream_stop_band = config->bs_ttt_bands_low[i];
2168 p_aux_struct->ttt_config[1][i].bitstream_start_band = config->bs_ttt_bands_low[i];
2169 } else {
2170 p_aux_struct->ttt_config[0][i].bitstream_stop_band = curr_state->bitstream_parameter_bands;
2171 p_aux_struct->ttt_config[1][i].bitstream_start_band = curr_state->bitstream_parameter_bands;
2172 }
2173
2174 if (curr_state->up_mix_type == 2) {
2175 ixheaacd_map_number_of_bands_to_28_bands(
2176 p_aux_struct->ttt_config[0][i].bitstream_start_band,
2177 curr_state->bitstream_parameter_bands, &p_aux_struct->ttt_config[0][i].start_band,
2178 bitdec_table);
2179
2180 ixheaacd_map_number_of_bands_to_28_bands(p_aux_struct->ttt_config[0][i].bitstream_stop_band,
2181 curr_state->bitstream_parameter_bands,
2182 &p_aux_struct->ttt_config[0][i].stop_band,
2183 bitdec_table);
2184
2185 ixheaacd_map_number_of_bands_to_28_bands(
2186 p_aux_struct->ttt_config[1][i].bitstream_start_band,
2187 curr_state->bitstream_parameter_bands, &p_aux_struct->ttt_config[1][i].start_band,
2188 bitdec_table);
2189
2190 ixheaacd_map_number_of_bands_to_28_bands(p_aux_struct->ttt_config[1][i].bitstream_stop_band,
2191 curr_state->bitstream_parameter_bands,
2192 &p_aux_struct->ttt_config[1][i].stop_band,
2193 bitdec_table);
2194 } else {
2195 p_aux_struct->ttt_config[0][i].start_band =
2196 p_aux_struct->ttt_config[0][i].bitstream_start_band;
2197 p_aux_struct->ttt_config[0][i].stop_band =
2198 p_aux_struct->ttt_config[0][i].bitstream_stop_band;
2199 p_aux_struct->ttt_config[1][i].start_band =
2200 p_aux_struct->ttt_config[1][i].bitstream_start_band;
2201 p_aux_struct->ttt_config[1][i].stop_band =
2202 p_aux_struct->ttt_config[1][i].bitstream_stop_band;
2203 }
2204 }
2205 curr_state->residual_coding = config->bs_residual_coding;
2206 curr_state->num_residual_signals = 0;
2207 if (curr_state->residual_coding) {
2208 for (i = 0; i < curr_state->num_ttt_boxes + curr_state->num_ott_boxes; i++) {
2209 if (config->bs_residual_present[i]) {
2210 curr_state->res_bands[i] = config->bs_residual_bands[i];
2211 curr_state->num_residual_signals++;
2212 } else {
2213 curr_state->res_bands[i] = 0;
2214 }
2215
2216 if (curr_state->up_mix_type == 2 || curr_state->up_mix_type == 3) {
2217 curr_state->res_bands[i] = 0;
2218 }
2219 }
2220 }
2221
2222 curr_state->residual_frames_per_spatial_frame =
2223 p_bs_config->bs_residual_frames_per_spatial_frame + 1;
2224 if (curr_state->residual_frames_per_spatial_frame > 0) {
2225 WORD32 const *reciprocal_tab =
2226 pstr_mps_state->ia_mps_dec_mps_table.m1_m2_table_ptr->reciprocal;
2227
2228 WORD64 temp =
2229 (WORD64)(((WORD64)(p_bs_config->bs_frame_length + 1) *
2230 (WORD64)reciprocal_tab[p_bs_config->bs_residual_frames_per_spatial_frame]) >>
2231 28);
2232 curr_state->upd_qmf = (WORD32)temp;
2233 if (curr_state->upd_qmf != UPD_QMF_15 && curr_state->upd_qmf != UPD_QMF_16 &&
2234 curr_state->upd_qmf != UPD_QMF_32 && curr_state->upd_qmf != UPD_QMF_18 &&
2235 curr_state->upd_qmf != UPD_QMF_30 && curr_state->upd_qmf != UPD_QMF_24)
2236 return IA_XHEAAC_MPS_DEC_EXE_NONFATAL_INVALID_QMF_UPDATE;
2237 }
2238
2239 curr_state->arbdmx_residual_bands = config->bs_arbitrary_downmix_residual_bands;
2240 curr_state->arbdmx_frames_per_spatial_frame =
2241 config->bs_arbitrary_downmix_residual_frames_per_spatial_frame + 1;
2242 if (curr_state->arbdmx_frames_per_spatial_frame > 0) {
2243 curr_state->arbdmx_upd_qmf =
2244 curr_state->time_slots / curr_state->arbdmx_frames_per_spatial_frame;
2245 if (curr_state->arbdmx_upd_qmf != UPD_QMF_15 && curr_state->arbdmx_upd_qmf != UPD_QMF_16 &&
2246 curr_state->arbdmx_upd_qmf != UPD_QMF_32 && curr_state->arbdmx_upd_qmf != UPD_QMF_18 &&
2247 curr_state->arbdmx_upd_qmf != UPD_QMF_30 && curr_state->arbdmx_upd_qmf != UPD_QMF_24)
2248 return IA_XHEAAC_MPS_DEC_EXE_NONFATAL_INVALID_QMF_UPDATE;
2249 }
2250
2251 curr_state->cpc_default = 10;
2252 curr_state->ttt_cld_1_default[0] = 15;
2253 curr_state->ttt_cld_2_default[0] = 0;
2254 curr_state->icc_default = 0;
2255 curr_state->arbdmx_gain_default = 0;
2256
2257 if (curr_state->_3d_stereo_inversion) {
2258 if (config->bs_3d_audio_hrtf_set == 0) {
2259 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_HRTF_SET;
2260 } else {
2261 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_HRTF_SET;
2262 }
2263 }
2264
2265 switch (curr_state->tree_config) {
2266 case TREE_5151:
2267 curr_state->num_direct_signals = 1;
2268 curr_state->num_decor_signals = 4;
2269
2270 if (curr_state->up_mix_type == 2) {
2271 curr_state->num_decor_signals = 1;
2272 }
2273
2274 if (curr_state->up_mix_type == 3) {
2275 curr_state->num_decor_signals = 3;
2276 }
2277
2278 curr_state->num_x_channels = 1;
2279 if (curr_state->arbitrary_downmix == 2) {
2280 curr_state->num_x_channels += 1;
2281 }
2282 curr_state->num_v_channels = curr_state->num_direct_signals + curr_state->num_decor_signals;
2283 curr_state->num_w_channels = curr_state->num_v_channels;
2284 curr_state->w_start_residual_idx = 0;
2285 curr_state->ott_cld_default[0] = 15;
2286 curr_state->ott_cld_default[1] = 15;
2287 curr_state->ott_cld_default[2] = 0;
2288 curr_state->ott_cld_default[3] = 0;
2289 curr_state->ott_cld_default[4] = 15;
2290 break;
2291 case TREE_5152:
2292 curr_state->num_direct_signals = 1;
2293 curr_state->num_decor_signals = 4;
2294
2295 if (curr_state->up_mix_type == 2) {
2296 curr_state->num_decor_signals = 1;
2297 }
2298
2299 if (curr_state->up_mix_type == 3) {
2300 curr_state->num_decor_signals = 2;
2301 }
2302
2303 curr_state->num_x_channels = 1;
2304 if (curr_state->arbitrary_downmix == 2) {
2305 curr_state->num_x_channels += 1;
2306 }
2307 curr_state->num_v_channels = curr_state->num_direct_signals + curr_state->num_decor_signals;
2308 curr_state->num_w_channels = curr_state->num_v_channels;
2309 curr_state->w_start_residual_idx = 0;
2310 curr_state->ott_cld_default[0] = 15;
2311 curr_state->ott_cld_default[1] = 0;
2312 curr_state->ott_cld_default[2] = 15;
2313 curr_state->ott_cld_default[3] = 15;
2314 curr_state->ott_cld_default[4] = 15;
2315 break;
2316 case TREE_525:
2317 curr_state->num_direct_signals = 3;
2318
2319 for (i = 0; i < 2; i++) {
2320 switch (p_aux_struct->ttt_config[i][0].mode) {
2321 case TTT_MODE_0:
2322 p_aux_struct->ttt_config[i][0].use_ttt_decorr = 1;
2323 curr_state->num_decor_signals = 3;
2324 break;
2325 case TTT_MODE_1:
2326 case TTT_MODE_2:
2327 case TTT_MODE_3:
2328 case TTT_MODE_4:
2329 case TTT_MODE_5:
2330 p_aux_struct->ttt_config[i][0].use_ttt_decorr = 0;
2331 curr_state->num_decor_signals = 2;
2332 break;
2333 default:
2334 if (p_bs_config->bs_ttt_mode_low[0] <= 1)
2335 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_TTT_MODE;
2336 break;
2337 }
2338 }
2339
2340 if (curr_state->residual_coding == 1) {
2341 curr_state->num_x_channels = 3;
2342 } else {
2343 curr_state->num_x_channels = 2;
2344 }
2345
2346 if (curr_state->arbitrary_downmix == 2) {
2347 curr_state->num_x_channels = 5;
2348 }
2349
2350 if (curr_state->up_mix_type == 2) {
2351 curr_state->num_direct_signals = 2;
2352 curr_state->num_decor_signals = 0;
2353 curr_state->num_x_channels = 2;
2354
2355 if (curr_state->arbitrary_downmix == 2) {
2356 curr_state->num_direct_signals = 4;
2357 curr_state->num_x_channels = 5;
2358 }
2359 }
2360
2361 curr_state->num_v_channels = curr_state->num_direct_signals + curr_state->num_decor_signals;
2362 curr_state->num_w_channels = curr_state->num_v_channels;
2363 curr_state->w_start_residual_idx = 1;
2364 curr_state->ott_cld_default[0] = 15;
2365 curr_state->ott_cld_default[1] = 15;
2366 curr_state->ott_cld_default[2] = 15;
2367 break;
2368 case TREE_7271:
2369 case TREE_7272:
2370 curr_state->num_direct_signals = 3;
2371
2372 for (i = 0; i < 2; i++) {
2373 switch (p_aux_struct->ttt_config[i][0].mode) {
2374 case TTT_MODE_0:
2375 p_aux_struct->ttt_config[i][0].use_ttt_decorr = 1;
2376 curr_state->num_decor_signals = 5;
2377 break;
2378 case TTT_MODE_1:
2379 case TTT_MODE_2:
2380 case TTT_MODE_3:
2381 case TTT_MODE_4:
2382 case TTT_MODE_5:
2383 p_aux_struct->ttt_config[i][0].use_ttt_decorr = 0;
2384 curr_state->num_decor_signals = 5;
2385 break;
2386 default:
2387 if (p_bs_config->bs_ttt_mode_low[0] <= 1)
2388 return IA_XHEAAC_MPS_DEC_EXE_FATAL_INVALID_TTT_MODE;
2389 break;
2390 }
2391 }
2392
2393 if (curr_state->residual_coding == 1) {
2394 curr_state->num_x_channels = 3;
2395 } else {
2396 curr_state->num_x_channels = 2;
2397 }
2398
2399 if (curr_state->arbitrary_downmix == 2) {
2400 curr_state->num_x_channels = 5;
2401 }
2402
2403 if (curr_state->up_mix_type == 2) {
2404 curr_state->num_direct_signals = 2;
2405 curr_state->num_decor_signals = 0;
2406 curr_state->num_x_channels = 2;
2407
2408 if (curr_state->arbitrary_downmix == 2) {
2409 curr_state->num_direct_signals = 4;
2410 curr_state->num_x_channels = 5;
2411 }
2412 }
2413
2414 curr_state->num_v_channels = curr_state->num_direct_signals + curr_state->num_decor_signals;
2415 curr_state->num_w_channels = curr_state->num_v_channels;
2416 curr_state->w_start_residual_idx = 1;
2417 curr_state->ott_cld_default[0] = 15;
2418 curr_state->ott_cld_default[1] = 15;
2419 curr_state->ott_cld_default[2] = 15;
2420 curr_state->ott_cld_default[3] = 15;
2421 curr_state->ott_cld_default[4] = 15;
2422 break;
2423 case TREE_7571:
2424 case TREE_7572:
2425 curr_state->num_direct_signals = 6;
2426 curr_state->num_decor_signals = 2;
2427 curr_state->num_x_channels = 6;
2428 curr_state->num_v_channels = curr_state->num_direct_signals + curr_state->num_decor_signals;
2429 curr_state->num_w_channels = curr_state->num_v_channels;
2430 curr_state->w_start_residual_idx = 0;
2431 curr_state->ott_cld_default[0] = 15;
2432 curr_state->ott_cld_default[1] = 15;
2433 break;
2434 default:
2435 return IA_XHEAAC_MPS_DEC_EXE_FATAL_UNSUPPRORTED_TREE_CONFIG;
2436 break;
2437 }
2438 return IA_NO_ERROR;
2439 }
2440
ixheaacd_get_dequant_tables(WORD32 ** cld,WORD32 ** icc,WORD32 ** cpc,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)2441 VOID ixheaacd_get_dequant_tables(
2442 WORD32 **cld, WORD32 **icc, WORD32 **cpc,
2443 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
2444 *cld = ixheaacd_mps_dec_bitdec_tables->dequant_cld;
2445 *icc = ixheaacd_mps_dec_bitdec_tables->dequant_icc;
2446 *cpc = ixheaacd_mps_dec_bitdec_tables->dequant_cpc;
2447 }
2448
ixheaacd_quantize_cld(WORD32 v,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)2449 WORD32 ixheaacd_quantize_cld(WORD32 v,
2450 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
2451 WORD32 i = 1;
2452 WORD32 temp_1;
2453 WORD32 vmin = ixheaacd_mps_dec_bitdec_tables->dequant_cld[0];
2454 WORD32 dmin = abs(v - vmin);
2455
2456 do {
2457 temp_1 = abs(v - ixheaacd_mps_dec_bitdec_tables->dequant_cld[i]);
2458 if (temp_1 < dmin) {
2459 dmin = temp_1;
2460 vmin = ixheaacd_mps_dec_bitdec_tables->dequant_cld[i];
2461 }
2462 } while (ixheaacd_mps_dec_bitdec_tables->dequant_cld[i++] < ONE_FORTYNINE_Q15);
2463 return vmin;
2464 }
2465
ixheaacd_quantize_icc(WORD32 v,ia_mps_dec_bitdec_tables_struct * ixheaacd_mps_dec_bitdec_tables)2466 WORD32 ixheaacd_quantize_icc(WORD32 v,
2467 ia_mps_dec_bitdec_tables_struct *ixheaacd_mps_dec_bitdec_tables) {
2468 WORD32 i = 1;
2469 WORD32 temp_1;
2470 WORD32 vmin = ixheaacd_mps_dec_bitdec_tables->dequant_icc[0];
2471 WORD32 dmin = abs(v - vmin);
2472
2473 do {
2474 temp_1 = abs(v - ixheaacd_mps_dec_bitdec_tables->dequant_icc[i]);
2475 if (temp_1 < dmin) {
2476 dmin = temp_1;
2477 vmin = ixheaacd_mps_dec_bitdec_tables->dequant_icc[i];
2478 }
2479 } while (ixheaacd_mps_dec_bitdec_tables->dequant_icc[i++] > MINUS_POINT_NINE_EIGHT_Q15);
2480
2481 return vmin;
2482 }
2483