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
21 #include <string.h>
22 #include <stdlib.h>
23 #include <math.h>
24 #include "ixheaac_type_def.h"
25 #include "ixheaac_error_standards.h"
26 #include "ixheaace_error_codes.h"
27 #include "ixheaace_mps_common_fix.h"
28 #include "ixheaace_mps_defines.h"
29 #include "ixheaace_mps_common_define.h"
30 #include "ixheaace_bitbuffer.h"
31 #include "ixheaace_mps_nlc_enc.h"
32 #include "ixheaace_mps_huff_tab.h"
33 #include "ixheaace_mps_param_extract.h"
34 #include "ixheaace_mps_sac_nlc_enc.h"
35 #include "ixheaace_mps_bitstream.h"
36 #include "ixheaace_mps_struct_def.h"
37 #include "ixheaace_mps_sac_polyphase.h"
38 #include "ixheaace_mps_sac_nlc_enc.h"
39 #include "ixheaace_mps_sac_hybfilter.h"
40 #include "ixheaace_mps_spatial_bitstream.h"
41 #include "ixheaace_mps_tree.h"
42 #include "ixheaace_mps_rom.h"
43 #include "ixheaace_common_utils.h"
44 #include "ixheaac_constants.h"
45 #include "ixheaac_basic_ops32.h"
46 #include "ixheaac_basic_ops40.h"
47 #include "ixheaac_basic_ops.h"
48
ixheaace_mps_212_sym_check(WORD16 data[2],const WORD16 lav,WORD16 * const p_sym_bits)49 static UWORD8 ixheaace_mps_212_sym_check(WORD16 data[2], const WORD16 lav,
50 WORD16 *const p_sym_bits) {
51 UWORD8 sym_bits = 0;
52 UWORD8 num_sbits = 0;
53 WORD16 sum_val = data[0] + data[1];
54 WORD16 diff_val = data[0] - data[1];
55
56 if (sum_val != 0) {
57 WORD8 sum_neg = (sum_val < 0) ? 1 : 0;
58 if (sum_neg) {
59 sum_val = -sum_val;
60 diff_val = -diff_val;
61 }
62 sym_bits = (sym_bits << 1) | sum_neg;
63 num_sbits++;
64 }
65
66 if (diff_val != 0) {
67 WORD8 diff_neg = (diff_val < 0) ? 1 : 0;
68 if (diff_neg) {
69 diff_val = -diff_val;
70 }
71 sym_bits = (sym_bits << 1) | diff_neg;
72 num_sbits++;
73 }
74 *p_sym_bits = sym_bits;
75
76 if (!(sum_val % 2)) {
77 data[0] = (sum_val / 2);
78 data[1] = (diff_val / 2);
79 } else {
80 data[0] = (lav - sum_val / 2);
81 data[1] = (lav - diff_val / 2);
82 }
83
84 return num_sbits;
85 }
86
ixheaace_mps_212_calc_pcm_bits(const WORD16 num_val,const WORD16 n_levels)87 static WORD16 ixheaace_mps_212_calc_pcm_bits(const WORD16 num_val, const WORD16 n_levels) {
88 WORD16 num_complete_chunks = 0, rest_chunk_size = 0;
89 WORD16 max_grp_len = 0, bits_pcm = 0;
90 WORD32 chunk_levels, lvl;
91
92 switch (n_levels) {
93 case 7:
94 max_grp_len = 6;
95 break;
96 case 3:
97 case 6:
98 max_grp_len = 5;
99 break;
100 case 13:
101 case 19:
102 case 51:
103 max_grp_len = 4;
104 break;
105 case 25:
106 max_grp_len = 3;
107 break;
108 case 11:
109 max_grp_len = 2;
110 break;
111 default:
112 max_grp_len = 1;
113 }
114
115 num_complete_chunks = num_val / max_grp_len;
116 rest_chunk_size = num_val % max_grp_len;
117
118 chunk_levels = 1;
119 for (lvl = 1; lvl <= max_grp_len; lvl++) {
120 chunk_levels *= n_levels;
121 }
122 bits_pcm = (WORD16)(round(log(chunk_levels) / log(2)) * num_complete_chunks);
123 bits_pcm += (WORD16)(round(log(chunk_levels) / log(2)) * rest_chunk_size);
124
125 return bits_pcm;
126 }
127
ixheaace_mps_212_apply_pcm_coding(ixheaace_bit_buf_handle pstr_bit_buf,const WORD16 * const in_data_1,const WORD16 * const in_data_2,const WORD16 offset,const WORD16 num_val,const WORD16 n_levels)128 static VOID ixheaace_mps_212_apply_pcm_coding(ixheaace_bit_buf_handle pstr_bit_buf,
129 const WORD16 *const in_data_1,
130 const WORD16 *const in_data_2, const WORD16 offset,
131 const WORD16 num_val, const WORD16 n_levels) {
132 WORD16 val = 0, lvl = 0, idx = 0;
133 WORD16 max_grp_len = 0, grp_len = 0, next_val = 0;
134 WORD32 grp_val = 0, chunk_levels = 0;
135 UWORD8 pcm_block_size[7] = {0};
136
137 switch (n_levels) {
138 case 7:
139 max_grp_len = 6;
140 break;
141 case 3:
142 case 6:
143 case 9:
144 max_grp_len = 5;
145 break;
146 case 13:
147 case 19:
148 case 51:
149 max_grp_len = 4;
150 break;
151 case 5:
152 case 25:
153 max_grp_len = 3;
154 break;
155 case 11:
156 max_grp_len = 2;
157 break;
158 default:
159 max_grp_len = 1;
160 }
161
162 chunk_levels = 1;
163 for (lvl = 1; lvl <= max_grp_len; lvl++) {
164 chunk_levels *= n_levels;
165 pcm_block_size[lvl] = (UWORD8)round(log(chunk_levels) / log(2));
166 }
167
168 for (val = 0; val < num_val; val += max_grp_len) {
169 grp_len = MIN(max_grp_len, num_val - val);
170 grp_val = 0;
171 for (lvl = 0; lvl < grp_len; lvl++) {
172 idx = val + lvl;
173 next_val = (in_data_2 == NULL)
174 ? in_data_1[idx]
175 : (in_data_1 == NULL)
176 ? in_data_2[idx]
177 : ((idx & 01) ? in_data_2[idx >> 1] : in_data_1[idx >> 1]);
178 grp_val = grp_val * n_levels + next_val + offset;
179 }
180 ixheaace_write_bits(pstr_bit_buf, grp_val, pcm_block_size[grp_len]);
181 }
182 }
183
ixheaace_mps_212_huff_enc_1_d(ixheaace_bit_buf_handle pstr_bit_buf,const WORD32 data_type,const WORD32 dim_1,WORD16 * const in_data,const WORD16 num_bands,const WORD16 part_0_flag,UWORD16 * huff_code_bits)184 static IA_ERRORCODE ixheaace_mps_212_huff_enc_1_d(ixheaace_bit_buf_handle pstr_bit_buf,
185 const WORD32 data_type, const WORD32 dim_1,
186 WORD16 *const in_data, const WORD16 num_bands,
187 const WORD16 part_0_flag,
188 UWORD16 *huff_code_bits) {
189 WORD32 band, offset = 0;
190 UWORD16 huff_bits = 0;
191 ixheaace_mps_huff_entry part0;
192 const ixheaace_mps_huff_entry *p_huff_tab = NULL;
193
194 *huff_code_bits = 0;
195 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
196 p_huff_tab = ixheaace_mps_212_huff_icc_tab.h1_d[dim_1];
197 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
198 p_huff_tab = ixheaace_mps_212_huff_cld_tab.h1_d[dim_1];
199 } else {
200 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_HUFF_DATA_TYPE;
201 }
202
203 if (part_0_flag) {
204 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
205 part0 = ixheaace_mps_212_huff_part_0_tab.icc[in_data[0]];
206 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
207 part0 = ixheaace_mps_212_huff_part_0_tab.cld[in_data[0]];
208 } else {
209 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_HUFF_DATA_TYPE;
210 }
211 huff_bits += ixheaace_write_bits(pstr_bit_buf, part0.value, part0.length);
212 offset = 1;
213 }
214
215 for (band = offset; band < num_bands; band++) {
216 WORD32 id_sign = 0;
217 WORD32 id = in_data[band];
218
219 if (id != 0) {
220 id_sign = 0;
221 if (id < 0) {
222 id = -id;
223 id_sign = 1;
224 }
225 }
226
227 huff_bits += ixheaace_write_bits(pstr_bit_buf, p_huff_tab[id].value, p_huff_tab[id].length);
228
229 if (id != 0) {
230 huff_bits += ixheaace_write_bits(pstr_bit_buf, id_sign, 1);
231 }
232 }
233
234 *huff_code_bits = huff_bits;
235 return IA_NO_ERROR;
236 }
237
ixheaace_mps_212_get_huff_entry(const WORD32 lav,const WORD32 data_type,const WORD32 band,WORD16 tab_idx_2_d[2],WORD16 in_data[][2],ixheaace_mps_huff_entry * const pstr_huff_entry,ixheaace_mps_huff_entry * const pstr_huff_escape)238 static VOID ixheaace_mps_212_get_huff_entry(const WORD32 lav, const WORD32 data_type,
239 const WORD32 band, WORD16 tab_idx_2_d[2],
240 WORD16 in_data[][2],
241 ixheaace_mps_huff_entry *const pstr_huff_entry,
242 ixheaace_mps_huff_entry *const pstr_huff_escape) {
243 const ixheaace_mps_huff_cld_tab_2d *pstr_huff_cld_tab_2d =
244 &ixheaace_mps_212_huff_cld_tab.h2_d[tab_idx_2_d[0]][tab_idx_2_d[1]];
245 const ixheaace_mps_huff_icc_tab_2d *pstr_huff_icc_tab_2d =
246 &ixheaace_mps_212_huff_icc_tab.h2_d[tab_idx_2_d[0]][tab_idx_2_d[1]];
247
248 switch (lav) {
249 case 9: {
250 *pstr_huff_entry = pstr_huff_cld_tab_2d->lav9.entry[in_data[band][0]][in_data[band][1]];
251 *pstr_huff_escape = pstr_huff_cld_tab_2d->lav9.escape;
252 } break;
253 case 7: {
254 switch (data_type) {
255 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
256 *pstr_huff_entry = pstr_huff_cld_tab_2d->lav7.entry[in_data[band][0]][in_data[band][1]];
257 *pstr_huff_escape = pstr_huff_cld_tab_2d->lav7.escape;
258 break;
259 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
260 *pstr_huff_entry = pstr_huff_icc_tab_2d->lav7.entry[in_data[band][0]][in_data[band][1]];
261 *pstr_huff_escape = pstr_huff_icc_tab_2d->lav7.escape;
262 break;
263 }
264 } break;
265 case 5: {
266 switch (data_type) {
267 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
268 *pstr_huff_entry = pstr_huff_cld_tab_2d->lav5.entry[in_data[band][0]][in_data[band][1]];
269 *pstr_huff_escape = pstr_huff_cld_tab_2d->lav5.escape;
270 break;
271 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
272 *pstr_huff_entry = pstr_huff_icc_tab_2d->lav5.entry[in_data[band][0]][in_data[band][1]];
273 *pstr_huff_escape = pstr_huff_icc_tab_2d->lav5.escape;
274 break;
275 }
276 } break;
277 case 3: {
278 switch (data_type) {
279 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
280 *pstr_huff_entry = pstr_huff_cld_tab_2d->lav3.entry[in_data[band][0]][in_data[band][1]];
281 *pstr_huff_escape = pstr_huff_cld_tab_2d->lav3.escape;
282 break;
283 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
284 *pstr_huff_entry = pstr_huff_icc_tab_2d->lav3.entry[in_data[band][0]][in_data[band][1]];
285 *pstr_huff_escape = pstr_huff_icc_tab_2d->lav3.escape;
286 break;
287 }
288 } break;
289 case 1: {
290 *pstr_huff_entry = pstr_huff_icc_tab_2d->lav1.entry[in_data[band][0]][in_data[band][1]];
291 *pstr_huff_escape = pstr_huff_icc_tab_2d->lav1.escape;
292 } break;
293 }
294 }
295
ixheaace_mps_212_huff_enc_2_d(ixheaace_bit_buf_handle pstr_bit_buf,const WORD32 data_type,WORD16 tab_idx_2_d[2],WORD16 lav_idx,WORD16 in_data[][2],WORD16 num_bands,WORD16 stride,WORD16 * p_0_data[2],UWORD16 * huff_bits)296 static IA_ERRORCODE ixheaace_mps_212_huff_enc_2_d(ixheaace_bit_buf_handle pstr_bit_buf,
297 const WORD32 data_type, WORD16 tab_idx_2_d[2],
298 WORD16 lav_idx, WORD16 in_data[][2],
299 WORD16 num_bands, WORD16 stride,
300 WORD16 *p_0_data[2], UWORD16 *huff_bits) {
301 WORD16 band = 0, lav = 0, sym_bits = 0, esc_idx = 0;
302 UWORD8 num_sbits = 0;
303 WORD16 esc_data[2][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {{0}};
304
305 *huff_bits = 0;
306 const ixheaace_mps_huff_entry *pstr_huff_entry = NULL;
307 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
308 lav = 2 * lav_idx + 1;
309 pstr_huff_entry = ixheaace_mps_212_huff_part_0_tab.icc;
310 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
311 lav = 2 * lav_idx + 3;
312 pstr_huff_entry = ixheaace_mps_212_huff_part_0_tab.cld;
313 } else {
314 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_HUFF_DATA_TYPE;
315 }
316
317 if (p_0_data[0] != NULL) {
318 ixheaace_mps_huff_entry entry = pstr_huff_entry[*p_0_data[0]];
319 *huff_bits += ixheaace_write_bits(pstr_bit_buf, entry.value, entry.length);
320 }
321 if (p_0_data[1] != NULL) {
322 ixheaace_mps_huff_entry entry = pstr_huff_entry[*p_0_data[1]];
323 *huff_bits += ixheaace_write_bits(pstr_bit_buf, entry.value, entry.length);
324 }
325
326 for (band = 0; band < num_bands; band += stride) {
327 ixheaace_mps_huff_entry entry = {0};
328 ixheaace_mps_huff_entry escape = {0};
329
330 esc_data[0][esc_idx] = in_data[band][0] + lav;
331 esc_data[1][esc_idx] = in_data[band][1] + lav;
332
333 num_sbits = ixheaace_mps_212_sym_check(in_data[band], lav, &sym_bits);
334
335 ixheaace_mps_212_get_huff_entry(lav, data_type, band, tab_idx_2_d, in_data, &entry, &escape);
336
337 *huff_bits += ixheaace_write_bits(pstr_bit_buf, entry.value, entry.length);
338
339 if ((entry.value == escape.value) && (entry.length == escape.length)) {
340 esc_idx++;
341 } else {
342 *huff_bits += ixheaace_write_bits(pstr_bit_buf, sym_bits, num_sbits);
343 }
344 }
345 if (esc_idx > 0) {
346 *huff_bits += ixheaace_mps_212_calc_pcm_bits(2 * esc_idx, (2 * lav + 1));
347 ixheaace_mps_212_apply_pcm_coding(pstr_bit_buf, esc_data[0], esc_data[1], 0, 2 * esc_idx,
348 (2 * lav + 1));
349 }
350
351 return IA_NO_ERROR;
352 }
353
ixheaace_mps_212_get_next_lav_step(const WORD32 lav,const WORD32 data_type)354 static WORD8 ixheaace_mps_212_get_next_lav_step(const WORD32 lav, const WORD32 data_type) {
355 WORD8 lav_step = 0;
356 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
357 lav_step = (lav > 7) ? -1 : lav_step_icc[lav];
358 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
359 lav_step = (lav > 9) ? -1 : lav_step_cld[lav];
360 } else {
361 lav_step = 0;
362 }
363
364 return lav_step;
365 }
366
ixheaace_mps_212_calc_huff_bits(WORD16 * in_data_1,WORD16 * in_data_2,const WORD32 data_type,const WORD32 diff_type_1,const WORD32 diff_type_2,const WORD16 num_bands,WORD16 * const lav_idx,WORD16 * bit_count,WORD16 * const huff_dim,WORD16 * const huff_pair_type)367 static IA_ERRORCODE ixheaace_mps_212_calc_huff_bits(
368 WORD16 *in_data_1, WORD16 *in_data_2, const WORD32 data_type, const WORD32 diff_type_1,
369 const WORD32 diff_type_2, const WORD16 num_bands, WORD16 *const lav_idx, WORD16 *bit_count,
370 WORD16 *const huff_dim, WORD16 *const huff_pair_type) {
371 IA_ERRORCODE error;
372 WORD16 band = 0;
373 WORD16 bit_count_1_d = 0;
374 WORD16 bit_count_2_d_freq = 0;
375 WORD16 bit_count_min = 0;
376 WORD16 num_band_short_data_1 = 0;
377 WORD16 num_band_short_data_2 = 0;
378 UWORD16 huff_bits;
379 WORD16 tab_idx_2_d[2][2] = {{0}};
380 WORD16 tab_idx_1_d[2] = {0};
381 WORD16 df_rest_flag[2] = {0};
382 WORD16 part_0_flag[2] = {0};
383 WORD16 lav_fp[2] = {0};
384 WORD16 pair_vec[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS][2] = {{0}};
385 WORD16 *part_0_data_1[2] = {NULL};
386 WORD16 *part_0_data_2[2] = {NULL};
387 WORD16 *in_short_data_1 = NULL;
388 WORD16 *in_short_data_2 = NULL;
389
390 bit_count_1_d = 1;
391 bit_count_2_d_freq = 1;
392 num_band_short_data_1 = num_bands;
393 num_band_short_data_2 = num_bands;
394
395 tab_idx_1_d[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
396 tab_idx_1_d[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
397
398 part_0_flag[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ);
399 part_0_flag[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ);
400
401 if (in_data_1 != NULL) {
402 in_short_data_1 = in_data_1 + (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
403 error = ixheaace_mps_212_huff_enc_1_d(NULL, data_type, tab_idx_1_d[0], in_short_data_1,
404 num_band_short_data_1, part_0_flag[0], &huff_bits);
405 if (error) {
406 return error;
407 }
408 bit_count_1_d += huff_bits;
409 }
410 if (in_data_2 != NULL) {
411 in_short_data_2 = in_data_2 + (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
412 error = ixheaace_mps_212_huff_enc_1_d(NULL, data_type, tab_idx_1_d[1], in_short_data_2,
413 num_band_short_data_2, part_0_flag[1], &huff_bits);
414 if (error) {
415 return error;
416 }
417 bit_count_1_d += huff_bits;
418 }
419
420 bit_count_min = bit_count_1_d;
421 *huff_dim = IXHEAACE_MPS_SAC_HUFF_1D;
422 lav_idx[0] = lav_idx[1] = -1;
423
424 if (in_data_1 != NULL) {
425 if (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) {
426 part_0_data_1[0] = &in_data_1[0];
427 part_0_data_1[1] = NULL;
428
429 num_band_short_data_1 -= 1;
430 in_short_data_1 += 1;
431 }
432
433 df_rest_flag[0] = num_band_short_data_1 % 2;
434
435 if (df_rest_flag[0]) {
436 num_band_short_data_1 -= 1;
437 }
438
439 for (band = 0; band < num_band_short_data_1 - 1; band += 2) {
440 pair_vec[band][0] = in_short_data_1[band];
441 pair_vec[band][1] = in_short_data_1[band + 1];
442
443 lav_fp[0] = (WORD16)MAX(lav_fp[0], abs(pair_vec[band][0]));
444 lav_fp[0] = (WORD16)MAX(lav_fp[0], abs(pair_vec[band][1]));
445 }
446
447 tab_idx_2_d[0][0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
448 tab_idx_2_d[0][1] = 0;
449
450 tab_idx_1_d[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
451
452 lav_fp[0] = ixheaace_mps_212_get_next_lav_step(lav_fp[0], data_type);
453
454 if (lav_fp[0] != -1) {
455 bit_count_2_d_freq += lav_huff_len[lav_fp[0]];
456 }
457 }
458
459 if (in_data_2 != NULL) {
460 if (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) {
461 part_0_data_2[0] = NULL;
462 part_0_data_2[1] = &in_data_2[0];
463
464 num_band_short_data_2 -= 1;
465 in_short_data_2 += 1;
466 }
467
468 df_rest_flag[1] = num_band_short_data_2 % 2;
469
470 if (df_rest_flag[1]) {
471 num_band_short_data_2 -= 1;
472 }
473
474 for (band = 0; band < num_band_short_data_2 - 1; band += 2) {
475 pair_vec[band + 1][0] = in_short_data_2[band];
476 pair_vec[band + 1][1] = in_short_data_2[band + 1];
477
478 lav_fp[1] = (WORD16)MAX(lav_fp[1], abs(pair_vec[band + 1][0]));
479 lav_fp[1] = (WORD16)MAX(lav_fp[1], abs(pair_vec[band + 1][1]));
480 }
481
482 tab_idx_2_d[1][0] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
483 tab_idx_2_d[1][1] = 0;
484
485 tab_idx_1_d[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
486
487 lav_fp[1] = ixheaace_mps_212_get_next_lav_step(lav_fp[1], data_type);
488
489 if (lav_fp[1] != -1) bit_count_2_d_freq += lav_huff_len[lav_fp[1]];
490 }
491
492 if ((lav_fp[0] != -1) && (lav_fp[1] != -1)) {
493 if (in_data_1 != NULL) {
494 error = ixheaace_mps_212_huff_enc_2_d(NULL, data_type, tab_idx_2_d[0], lav_fp[0], pair_vec,
495 num_band_short_data_1, 2, part_0_data_1, &huff_bits);
496 if (error) {
497 return error;
498 }
499
500 bit_count_2_d_freq += huff_bits;
501 }
502 if (in_data_2 != NULL) {
503 error =
504 ixheaace_mps_212_huff_enc_2_d(NULL, data_type, tab_idx_2_d[1], lav_fp[1], pair_vec + 1,
505 num_band_short_data_2, 2, part_0_data_2, &huff_bits);
506 if (error) {
507 return error;
508 }
509 bit_count_2_d_freq += huff_bits;
510 }
511 if (in_data_1 != NULL) {
512 if (df_rest_flag[0]) {
513 error = ixheaace_mps_212_huff_enc_1_d(NULL, data_type, tab_idx_1_d[0],
514 in_short_data_1 + num_band_short_data_1, 1, 0,
515 &huff_bits);
516 if (error) {
517 return error;
518 }
519 bit_count_2_d_freq += huff_bits;
520 }
521 }
522 if (in_data_2 != NULL) {
523 if (df_rest_flag[1]) {
524 error = ixheaace_mps_212_huff_enc_1_d(NULL, data_type, tab_idx_1_d[1],
525 in_short_data_2 + num_band_short_data_2, 1, 0,
526 &huff_bits);
527 if (error) {
528 return error;
529 }
530 bit_count_2_d_freq += huff_bits;
531 }
532 }
533
534 if (bit_count_2_d_freq < bit_count_min) {
535 bit_count_min = bit_count_2_d_freq;
536 *huff_dim = IXHEAACE_MPS_SAC_HUFF_2D;
537 *huff_pair_type = IXHEAACE_MPS_SAC_FREQ_PAIR;
538 lav_idx[0] = lav_fp[0];
539 lav_idx[1] = lav_fp[1];
540 }
541 }
542
543 *bit_count = bit_count_min;
544 return IA_NO_ERROR;
545 }
546
ixheaace_mps_212_apply_huff_coding(ixheaace_bit_buf_handle pstr_bit_buf,WORD16 * const in_data_1,WORD16 * const in_data_2,const WORD32 data_type,const WORD32 diff_type_1,const WORD32 diff_type_2,const WORD16 bands,const WORD16 * const lav_idx,WORD16 huff_dim,WORD16 huff_pair_type)547 static IA_ERRORCODE ixheaace_mps_212_apply_huff_coding(
548 ixheaace_bit_buf_handle pstr_bit_buf, WORD16 *const in_data_1, WORD16 *const in_data_2,
549 const WORD32 data_type, const WORD32 diff_type_1, const WORD32 diff_type_2,
550 const WORD16 bands, const WORD16 *const lav_idx, WORD16 huff_dim, WORD16 huff_pair_type) {
551 IA_ERRORCODE error;
552 WORD16 band = 0;
553 WORD16 num_band_short_data_1 = bands;
554 WORD16 num_band_short_data_2 = bands;
555 UWORD16 huff_bits;
556
557 WORD16 df_rest_flag[2] = {0};
558 WORD16 part_0_flag[2] = {0};
559 WORD16 tab_idx_1_d[2] = {0};
560 WORD16 tab_idx_2_d[2][2] = {{0}};
561 WORD16 pair_vec[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS][2] = {{0}};
562
563 WORD16 *part_0_data_1[2] = {NULL};
564 WORD16 *part_0_data_2[2] = {NULL};
565 WORD16 *in_short_data_1 = NULL;
566 WORD16 *in_short_data_2 = NULL;
567
568 ixheaace_write_bits(pstr_bit_buf, huff_dim, 1);
569 if (huff_dim == IXHEAACE_MPS_SAC_HUFF_1D) {
570 part_0_flag[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ);
571 part_0_flag[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ);
572
573 tab_idx_1_d[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
574 tab_idx_1_d[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
575
576 if (in_data_1 != NULL) {
577 in_short_data_1 = in_data_1 + (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
578 error =
579 ixheaace_mps_212_huff_enc_1_d(pstr_bit_buf, data_type, tab_idx_1_d[0], in_short_data_1,
580 num_band_short_data_1, part_0_flag[0], &huff_bits);
581 if (error) {
582 return error;
583 }
584 }
585 if (in_data_2 != NULL) {
586 in_short_data_2 = in_data_2 + (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
587 error =
588 ixheaace_mps_212_huff_enc_1_d(pstr_bit_buf, data_type, tab_idx_1_d[1], in_short_data_2,
589 num_band_short_data_2, part_0_flag[1], &huff_bits);
590 if (error) {
591 return error;
592 }
593 }
594 } else {
595 if (huff_pair_type == IXHEAACE_MPS_SAC_FREQ_PAIR) {
596 if (in_data_1 != NULL) {
597 in_short_data_1 = in_data_1 + (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
598 if (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) {
599 part_0_data_1[0] = &in_data_1[0];
600 part_0_data_1[1] = NULL;
601
602 num_band_short_data_1 -= 1;
603 in_short_data_1 += 1;
604 }
605
606 df_rest_flag[0] = num_band_short_data_1 % 2;
607
608 if (df_rest_flag[0]) num_band_short_data_1 -= 1;
609
610 for (band = 0; band < num_band_short_data_1 - 1; band += 2) {
611 pair_vec[band][0] = in_short_data_1[band];
612 pair_vec[band][1] = in_short_data_1[band + 1];
613 }
614
615 tab_idx_2_d[0][0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
616 tab_idx_2_d[0][1] = 0;
617
618 tab_idx_1_d[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
619 }
620 if (in_data_2 != NULL) {
621 in_short_data_2 = in_data_2 + (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME ? 2 : 0);
622 if (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) {
623 part_0_data_2[0] = NULL;
624 part_0_data_2[1] = &in_data_2[0];
625
626 num_band_short_data_2 -= 1;
627 in_short_data_2 += 1;
628 }
629
630 df_rest_flag[1] = num_band_short_data_2 % 2;
631
632 if (df_rest_flag[1]) num_band_short_data_2 -= 1;
633
634 for (band = 0; band < num_band_short_data_2 - 1; band += 2) {
635 pair_vec[band + 1][0] = in_short_data_2[band];
636 pair_vec[band + 1][1] = in_short_data_2[band + 1];
637 }
638
639 tab_idx_2_d[1][0] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
640 tab_idx_2_d[1][1] = 0;
641
642 tab_idx_1_d[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ) ? 0 : 1;
643 }
644 if (in_data_1 != NULL) {
645 ixheaace_write_bits(pstr_bit_buf, lav_huff_val[lav_idx[0]], lav_huff_len[lav_idx[0]]);
646 error = ixheaace_mps_212_huff_enc_2_d(pstr_bit_buf, data_type, tab_idx_2_d[0], lav_idx[0],
647 pair_vec, num_band_short_data_1, 2, part_0_data_1,
648 &huff_bits);
649 if (error) {
650 return error;
651 }
652 if (df_rest_flag[0]) {
653 error = ixheaace_mps_212_huff_enc_1_d(pstr_bit_buf, data_type, tab_idx_1_d[0],
654 in_short_data_1 + num_band_short_data_1, 1, 0,
655 &huff_bits);
656 if (error) {
657 return error;
658 }
659 }
660 }
661 if (in_data_2 != NULL) {
662 ixheaace_write_bits(pstr_bit_buf, lav_huff_val[lav_idx[1]], lav_huff_len[lav_idx[1]]);
663 error = ixheaace_mps_212_huff_enc_2_d(pstr_bit_buf, data_type, tab_idx_2_d[1], lav_idx[1],
664 pair_vec + 1, num_band_short_data_2, 2,
665 part_0_data_2, &huff_bits);
666 if (error) {
667 return error;
668 }
669 if (df_rest_flag[1]) {
670 error = ixheaace_mps_212_huff_enc_1_d(pstr_bit_buf, data_type, tab_idx_1_d[1],
671 in_short_data_2 + num_band_short_data_2, 1, 0,
672 &huff_bits);
673 if (error) {
674 return error;
675 }
676 }
677 }
678 } else {
679 if (in_data_1 == NULL || in_data_2 == NULL || in_short_data_1 == NULL ||
680 in_short_data_2 == NULL) {
681 return IA_EXHEAACE_EXE_FATAL_MPS_NULL_DATA_HANDLE;
682 }
683
684 if ((diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ) ||
685 (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ)) {
686 part_0_data_1[0] = &in_data_1[0];
687 part_0_data_1[1] = &in_data_2[0];
688
689 in_short_data_1 += 1;
690 in_short_data_2 += 1;
691
692 num_band_short_data_1 -= 1;
693 }
694
695 for (band = 0; band < num_band_short_data_1; band++) {
696 pair_vec[band][0] = in_short_data_1[band];
697 pair_vec[band][1] = in_short_data_2[band];
698 }
699 tab_idx_2_d[0][0] = ((diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME) ||
700 (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME))
701 ? 1
702 : 0;
703 tab_idx_2_d[0][1] = 1;
704 ixheaace_write_bits(pstr_bit_buf, lav_huff_val[lav_idx[0]], lav_huff_len[lav_idx[0]]);
705 error = ixheaace_mps_212_huff_enc_2_d(pstr_bit_buf, data_type, tab_idx_2_d[0], lav_idx[0],
706 pair_vec, num_band_short_data_1, 1, part_0_data_1,
707 &huff_bits);
708 if (error) {
709 return error;
710 }
711 }
712 }
713 return IA_NO_ERROR;
714 }
715
ixheaace_mps_515_split_lsb(WORD32 * in_data,WORD32 offset,WORD32 num_lsb,WORD32 num_val,WORD32 * out_data_lsb,WORD32 * out_data_msb)716 static WORD32 ixheaace_mps_515_split_lsb(WORD32 *in_data, WORD32 offset, WORD32 num_lsb,
717 WORD32 num_val, WORD32 *out_data_lsb,
718 WORD32 *out_data_msb) {
719 WORD32 i = 0, val = 0, lsb = 0, msb = 0;
720
721 UWORD32 mask = (1 << num_lsb) - 1;
722 WORD32 no_lsb_bits = 0;
723
724 for (i = 0; i < num_val; i++) {
725 val = in_data[i] + offset;
726
727 lsb = val & mask;
728 msb = val >> num_lsb;
729
730 if (out_data_lsb != NULL) out_data_lsb[i] = lsb;
731 if (out_data_msb != NULL) out_data_msb[i] = msb;
732
733 no_lsb_bits += num_lsb;
734 }
735
736 return no_lsb_bits;
737 }
738
ixheaace_mps_515_apply_lsb_coding(ixheaace_bit_buf_handle pstr_bit_buf,WORD32 * in_data_lsb,UWORD8 num_lsb,WORD32 num_val)739 static VOID ixheaace_mps_515_apply_lsb_coding(ixheaace_bit_buf_handle pstr_bit_buf,
740 WORD32 *in_data_lsb, UWORD8 num_lsb,
741 WORD32 num_val) {
742 WORD32 i = 0;
743
744 for (i = 0; i < num_val; i++) {
745 ixheaace_write_bits(pstr_bit_buf, in_data_lsb[i], num_lsb);
746 }
747 }
748
ixheaace_mps_515_calc_diff_freq(WORD32 * in_data,WORD32 * out_data,WORD32 num_val)749 static VOID ixheaace_mps_515_calc_diff_freq(WORD32 *in_data, WORD32 *out_data, WORD32 num_val) {
750 WORD32 i = 0;
751
752 out_data[0] = in_data[0];
753
754 for (i = 1; i < num_val; i++) {
755 out_data[i] = in_data[i] - in_data[i - 1];
756 }
757 }
758
ixheaace_mps_515_calc_diff_time(WORD32 * in_data,WORD32 * prev_data,WORD32 * out_data,WORD32 direction,WORD32 num_val)759 static VOID ixheaace_mps_515_calc_diff_time(WORD32 *in_data, WORD32 *prev_data, WORD32 *out_data,
760 WORD32 direction, WORD32 num_val) {
761 WORD32 i = 0;
762
763 out_data[-1] = (direction == IXHEAACE_MPS_SAC_DIRECTION_BACKWARDS) ? in_data[0] : prev_data[0];
764
765 for (i = 0; i < num_val; i++) {
766 out_data[i] = in_data[i] - prev_data[i];
767 }
768 }
769
ixheaace_mps_515_calc_pcm_bits(WORD32 num_val,WORD32 n_levels)770 static WORD32 ixheaace_mps_515_calc_pcm_bits(WORD32 num_val, WORD32 n_levels) {
771 WORD32 num_complete_chunks = 0, rest_chunk_size = 0;
772 WORD32 max_grp_len = 0, bits_pcm = 0;
773
774 FLOAT32 num_ld_levels = 0.f;
775
776 switch (n_levels) {
777 case 3:
778 max_grp_len = 5;
779 break;
780 case 7:
781 max_grp_len = 6;
782 break;
783 case 11:
784 max_grp_len = 2;
785 break;
786 case 13:
787 max_grp_len = 4;
788 break;
789 case 19:
790 max_grp_len = 4;
791 break;
792 case 25:
793 max_grp_len = 3;
794 break;
795 case 51:
796 max_grp_len = 4;
797 break;
798
799 case 4:
800 case 8:
801 case 15:
802 case 26:
803 case 31:
804 max_grp_len = 1;
805 break;
806 default:
807 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_LEVELS;
808 }
809
810 num_ld_levels = (FLOAT32)(log((FLOAT32)n_levels) / log(2.f));
811
812 num_complete_chunks = num_val / max_grp_len;
813 rest_chunk_size = num_val % max_grp_len;
814
815 bits_pcm = ((WORD32)ceil((FLOAT32)(max_grp_len)*num_ld_levels)) * num_complete_chunks;
816 bits_pcm += (WORD32)ceil((FLOAT32)(rest_chunk_size)*num_ld_levels);
817
818 return bits_pcm;
819 }
820
ixheaace_mps_515_apply_pcm_coding(ixheaace_bit_buf_handle pstr_bit_buf,WORD32 * in_data_1,WORD32 * in_data_2,WORD32 offset,WORD32 num_val,WORD32 n_levels)821 static VOID ixheaace_mps_515_apply_pcm_coding(ixheaace_bit_buf_handle pstr_bit_buf,
822 WORD32 *in_data_1, WORD32 *in_data_2, WORD32 offset,
823 WORD32 num_val, WORD32 n_levels) {
824 WORD32 i = 0, j = 0, idx = 0;
825 WORD32 max_grp_len = 1, grp_len = 0, next_val = 0, grp_val = 0;
826
827 FLOAT32 num_ld_levels = 0.f;
828
829 UWORD8 pcm_block_size[7] = {0};
830 switch (n_levels) {
831 case 4:
832 num_ld_levels = 2.00000000f;
833 break;
834 case 8:
835 num_ld_levels = 3.00000000f;
836 break;
837 case 15:
838 num_ld_levels = 3.90689060f;
839 break;
840 case 26:
841 num_ld_levels = 4.70043972f;
842 break;
843 case 31:
844 num_ld_levels = 4.95419645f;
845 break;
846 case 51:
847 max_grp_len = 4;
848 num_ld_levels = 5.67242534f;
849 break;
850 }
851
852 for (i = 1; i <= max_grp_len; i++) {
853 pcm_block_size[i] = (UWORD8)ceil((FLOAT32)(i)*num_ld_levels);
854 }
855
856 for (i = 0; i < num_val; i += max_grp_len) {
857 grp_len = MIN(max_grp_len, num_val - i);
858 grp_val = 0;
859 for (j = 0; j < grp_len; j++) {
860 idx = i + j;
861 next_val = (in_data_2 == NULL)
862 ? in_data_1[idx]
863 : (in_data_1 == NULL)
864 ? in_data_2[idx]
865 : ((idx & 01) ? in_data_2[idx >> 1] : in_data_1[idx >> 1]);
866 grp_val = grp_val * n_levels + next_val + offset;
867 }
868
869 ixheaace_write_bits(pstr_bit_buf, grp_val, pcm_block_size[grp_len]);
870 }
871 }
872
ixheaace_mps_515_count_huff_cld(const ixheaace_mps_sac_huff_cld_tab * pstr_huff_cld_tab_pt0,const ixheaace_mps_sac_huff_cld_tab * pstr_huff_cld_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)873 static WORD32 ixheaace_mps_515_count_huff_cld(
874 const ixheaace_mps_sac_huff_cld_tab *pstr_huff_cld_tab_pt0,
875 const ixheaace_mps_sac_huff_cld_tab *pstr_huff_cld_tab_diff, WORD32 *in_data, WORD32 num_val,
876 WORD32 p0_flag) {
877 WORD32 i = 0, id = 0;
878 WORD32 huff_bits = 0;
879 WORD32 offset = 0;
880 if (p0_flag) {
881 huff_bits += pstr_huff_cld_tab_pt0->length[in_data[0]];
882 offset = 1;
883 }
884
885 for (i = offset; i < num_val; i++) {
886 id = in_data[i];
887
888 if (id != 0) {
889 if (id < 0) {
890 id = -id;
891 }
892 huff_bits += 1;
893 }
894
895 huff_bits += pstr_huff_cld_tab_diff->length[id];
896 }
897
898 return huff_bits;
899 }
900
ixheaace_mps_515_count_huff_icc(const ixheaace_mps_sac_huff_icc_tab * pstr_huff_icc_tab_pt0,const ixheaace_mps_sac_huff_icc_tab * pstr_huff_icc_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)901 static WORD32 ixheaace_mps_515_count_huff_icc(
902 const ixheaace_mps_sac_huff_icc_tab *pstr_huff_icc_tab_pt0,
903 const ixheaace_mps_sac_huff_icc_tab *pstr_huff_icc_tab_diff, WORD32 *in_data, WORD32 num_val,
904 WORD32 p0_flag) {
905 WORD32 i = 0, id = 0;
906 WORD32 huff_bits = 0;
907 WORD32 offset = 0;
908
909 if (p0_flag) {
910 huff_bits += pstr_huff_icc_tab_pt0->length[in_data[0]];
911 offset = 1;
912 }
913
914 for (i = offset; i < num_val; i++) {
915 id = in_data[i];
916
917 if (id != 0) {
918 if (id < 0) {
919 id = -id;
920 }
921 huff_bits += 1;
922 }
923
924 huff_bits += pstr_huff_icc_tab_diff->length[id];
925 }
926
927 return huff_bits;
928 }
929
ixheaace_mps_515_count_huff_cpc(const ixheaace_mps_sac_huff_cpc_tab * pstr_huff_cpc_tab_pt0,const ixheaace_mps_sac_huff_cpc_tab * pstr_huff_cpc_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)930 static WORD32 ixheaace_mps_515_count_huff_cpc(
931 const ixheaace_mps_sac_huff_cpc_tab *pstr_huff_cpc_tab_pt0,
932 const ixheaace_mps_sac_huff_cpc_tab *pstr_huff_cpc_tab_diff, WORD32 *in_data, WORD32 num_val,
933 WORD32 p0_flag) {
934 WORD32 i = 0, id = 0;
935 WORD32 huff_bits = 0;
936 WORD32 offset = 0;
937
938 if (p0_flag) {
939 huff_bits += pstr_huff_cpc_tab_pt0->length[in_data[0]];
940 offset = 1;
941 }
942
943 for (i = offset; i < num_val; i++) {
944 id = in_data[i];
945
946 if (id != 0) {
947 if (id < 0) {
948 id = -id;
949 }
950 huff_bits += 1;
951 }
952
953 huff_bits += pstr_huff_cpc_tab_diff->length[id];
954 }
955
956 return huff_bits;
957 }
958
ixheaace_mps_515_huff_enc_cld(ixheaace_bit_buf_handle pstr_bit_buf,const ixheaace_mps_sac_huff_cld_tab * pstr_huff_cld_tab_pt0,const ixheaace_mps_sac_huff_cld_tab * pstr_huff_cld_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)959 static VOID ixheaace_mps_515_huff_enc_cld(
960 ixheaace_bit_buf_handle pstr_bit_buf,
961 const ixheaace_mps_sac_huff_cld_tab *pstr_huff_cld_tab_pt0,
962 const ixheaace_mps_sac_huff_cld_tab *pstr_huff_cld_tab_diff, WORD32 *in_data, WORD32 num_val,
963 WORD32 p0_flag) {
964 WORD32 i = 0, id = 0, id_sign = 0;
965 WORD32 offset = 0;
966
967 if (p0_flag) {
968 ixheaace_write_bits(pstr_bit_buf, pstr_huff_cld_tab_pt0->value[in_data[0]],
969 pstr_huff_cld_tab_pt0->length[in_data[0]]);
970 offset = 1;
971 }
972
973 for (i = offset; i < num_val; i++) {
974 id = in_data[i];
975
976 if (id != 0) {
977 id_sign = 0;
978 if (id < 0) {
979 id = -id;
980 id_sign = 1;
981 }
982 }
983
984 ixheaace_write_bits(pstr_bit_buf, pstr_huff_cld_tab_diff->value[id],
985 pstr_huff_cld_tab_diff->length[id]);
986
987 if (id != 0) {
988 ixheaace_write_bits(pstr_bit_buf, id_sign, 1);
989 }
990 }
991 }
992
ixheaace_mps_515_huff_enc_icc(ixheaace_bit_buf_handle pstr_bit_buf,const ixheaace_mps_sac_huff_icc_tab * pstr_huff_icc_tab_pt0,const ixheaace_mps_sac_huff_icc_tab * pstr_huff_icc_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)993 static VOID ixheaace_mps_515_huff_enc_icc(
994 ixheaace_bit_buf_handle pstr_bit_buf,
995 const ixheaace_mps_sac_huff_icc_tab *pstr_huff_icc_tab_pt0,
996 const ixheaace_mps_sac_huff_icc_tab *pstr_huff_icc_tab_diff, WORD32 *in_data, WORD32 num_val,
997 WORD32 p0_flag) {
998 WORD32 i = 0, id = 0, id_sign = 0;
999 WORD32 offset = 0;
1000
1001 if (p0_flag) {
1002 ixheaace_write_bits(pstr_bit_buf, pstr_huff_icc_tab_pt0->value[in_data[0]],
1003 pstr_huff_icc_tab_pt0->length[in_data[0]]);
1004 offset = 1;
1005 }
1006
1007 for (i = offset; i < num_val; i++) {
1008 id = in_data[i];
1009
1010 if (id != 0) {
1011 id_sign = 0;
1012 if (id < 0) {
1013 id = -id;
1014 id_sign = 1;
1015 }
1016 }
1017
1018 ixheaace_write_bits(pstr_bit_buf, pstr_huff_icc_tab_diff->value[id],
1019 pstr_huff_icc_tab_diff->length[id]);
1020
1021 if (id != 0) {
1022 ixheaace_write_bits(pstr_bit_buf, id_sign, 1);
1023 }
1024 }
1025 }
1026
ixheaace_mps_515_huff_enc_cpc(ixheaace_bit_buf_handle pstr_bit_buf,const ixheaace_mps_sac_huff_cpc_tab * pstr_huff_cpc_tab_pt0,const ixheaace_mps_sac_huff_cpc_tab * pstr_huff_cpc_tab_diff,WORD32 * in_data,WORD32 num_val,WORD32 p0_flag)1027 static VOID ixheaace_mps_515_huff_enc_cpc(
1028 ixheaace_bit_buf_handle pstr_bit_buf,
1029 const ixheaace_mps_sac_huff_cpc_tab *pstr_huff_cpc_tab_pt0,
1030 const ixheaace_mps_sac_huff_cpc_tab *pstr_huff_cpc_tab_diff, WORD32 *in_data, WORD32 num_val,
1031 WORD32 p0_flag) {
1032 WORD32 i = 0, id = 0, id_sign = 0;
1033 WORD32 offset = 0;
1034
1035 if (p0_flag) {
1036 ixheaace_write_bits(pstr_bit_buf, pstr_huff_cpc_tab_pt0->value[in_data[0]],
1037 pstr_huff_cpc_tab_pt0->length[in_data[0]]);
1038 offset = 1;
1039 }
1040
1041 for (i = offset; i < num_val; i++) {
1042 id = in_data[i];
1043
1044 if (id != 0) {
1045 id_sign = 0;
1046 if (id < 0) {
1047 id = -id;
1048 id_sign = 1;
1049 }
1050 }
1051
1052 ixheaace_write_bits(pstr_bit_buf, pstr_huff_cpc_tab_diff->value[id],
1053 pstr_huff_cpc_tab_diff->length[id]);
1054
1055 if (id != 0) {
1056 ixheaace_write_bits(pstr_bit_buf, id_sign, 1);
1057 }
1058 }
1059 }
1060
ixheaace_mps_515_calc_huff_bits(WORD32 * in_data_1,WORD32 * in_data_2,WORD32 data_type,WORD32 diff_type_1,WORD32 diff_type_2,WORD32 num_val)1061 static WORD32 ixheaace_mps_515_calc_huff_bits(WORD32 *in_data_1, WORD32 *in_data_2,
1062 WORD32 data_type, WORD32 diff_type_1,
1063 WORD32 diff_type_2, WORD32 num_val) {
1064 WORD32 p0_flag[2];
1065
1066 WORD32 offset_1 = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
1067 WORD32 offset_2 = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME) ? 1 : 0;
1068
1069 WORD32 bit_count_huff = 0;
1070
1071 WORD32 num_val_1_int = 0;
1072 WORD32 num_val_2_int = 0;
1073
1074 WORD32 *in_data_1_int = in_data_1 + offset_1;
1075 WORD32 *in_data_2_int = in_data_2 + offset_2;
1076
1077 bit_count_huff = 1;
1078
1079 num_val_1_int = num_val;
1080 num_val_2_int = num_val;
1081
1082 p0_flag[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ);
1083 p0_flag[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ);
1084
1085 switch (data_type) {
1086 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
1087 if (in_data_1 != NULL)
1088 bit_count_huff +=
1089 ixheaace_mps_515_count_huff_cld(&ixheaace_mps_515_huff_cld_tab.huff_pt0,
1090 &ixheaace_mps_515_huff_cld_tab.huff_diff[diff_type_1],
1091 in_data_1_int, num_val_1_int, p0_flag[0]);
1092 if (in_data_2 != NULL)
1093 bit_count_huff +=
1094 ixheaace_mps_515_count_huff_cld(&ixheaace_mps_515_huff_cld_tab.huff_pt0,
1095 &ixheaace_mps_515_huff_cld_tab.huff_diff[diff_type_2],
1096 in_data_2_int, num_val_2_int, p0_flag[1]);
1097 break;
1098
1099 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
1100 if (in_data_1 != NULL)
1101 bit_count_huff +=
1102 ixheaace_mps_515_count_huff_icc(&ixheaace_mps_515_huff_icc_tab.huff_pt0,
1103 &ixheaace_mps_515_huff_icc_tab.huff_diff[diff_type_1],
1104 in_data_1_int, num_val_1_int, p0_flag[0]);
1105 if (in_data_2 != NULL)
1106 bit_count_huff +=
1107 ixheaace_mps_515_count_huff_icc(&ixheaace_mps_515_huff_icc_tab.huff_pt0,
1108 &ixheaace_mps_515_huff_icc_tab.huff_diff[diff_type_2],
1109 in_data_2_int, num_val_2_int, p0_flag[1]);
1110 break;
1111
1112 case IXHEAACE_MPS_SAC_DATA_TYPE_CPC:
1113 if (in_data_1 != NULL)
1114 bit_count_huff +=
1115 ixheaace_mps_515_count_huff_cpc(&ixheaace_mps_515_huff_cpc_tab.huff_pt0,
1116 &ixheaace_mps_515_huff_cpc_tab.huff_diff[diff_type_1],
1117 in_data_1_int, num_val_1_int, p0_flag[0]);
1118 if (in_data_2 != NULL)
1119 bit_count_huff +=
1120 ixheaace_mps_515_count_huff_cpc(&ixheaace_mps_515_huff_cpc_tab.huff_pt0,
1121 &ixheaace_mps_515_huff_cpc_tab.huff_diff[diff_type_2],
1122 in_data_2_int, num_val_2_int, p0_flag[1]);
1123 break;
1124
1125 default:
1126 break;
1127 }
1128
1129 return bit_count_huff;
1130 }
1131
ixheaace_mps_515_apply_huff_coding(ixheaace_bit_buf_handle pstr_bit_buf,WORD32 * in_data_1,WORD32 * in_data_2,WORD32 data_type,WORD32 diff_type_1,WORD32 diff_type_2,WORD32 num_val)1132 static VOID ixheaace_mps_515_apply_huff_coding(ixheaace_bit_buf_handle pstr_bit_buf,
1133 WORD32 *in_data_1, WORD32 *in_data_2,
1134 WORD32 data_type, WORD32 diff_type_1,
1135 WORD32 diff_type_2, WORD32 num_val) {
1136 WORD32 p0_flag[2];
1137
1138 WORD32 num_val_1_int = num_val;
1139 WORD32 num_val_2_int = num_val;
1140
1141 WORD32 *in_data_1_int = in_data_1;
1142 WORD32 *in_data_2_int = in_data_2;
1143
1144 if (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_TIME) in_data_1_int += 1;
1145 if (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_TIME) in_data_2_int += 1;
1146
1147 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_HUFF_1D, 1);
1148
1149 p0_flag[0] = (diff_type_1 == IXHEAACE_MPS_SAC_DIFF_FREQ);
1150 p0_flag[1] = (diff_type_2 == IXHEAACE_MPS_SAC_DIFF_FREQ);
1151
1152 switch (data_type) {
1153 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
1154 if (in_data_1 != NULL)
1155 ixheaace_mps_515_huff_enc_cld(pstr_bit_buf, &ixheaace_mps_515_huff_cld_tab.huff_pt0,
1156 &ixheaace_mps_515_huff_cld_tab.huff_diff[diff_type_1],
1157 in_data_1_int, num_val_1_int, p0_flag[0]);
1158 if (in_data_2 != NULL)
1159 ixheaace_mps_515_huff_enc_cld(pstr_bit_buf, &ixheaace_mps_515_huff_cld_tab.huff_pt0,
1160 &ixheaace_mps_515_huff_cld_tab.huff_diff[diff_type_2],
1161 in_data_2_int, num_val_2_int, p0_flag[1]);
1162 break;
1163
1164 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
1165 if (in_data_1 != NULL)
1166 ixheaace_mps_515_huff_enc_icc(pstr_bit_buf, &ixheaace_mps_515_huff_icc_tab.huff_pt0,
1167 &ixheaace_mps_515_huff_icc_tab.huff_diff[diff_type_1],
1168 in_data_1_int, num_val_1_int, p0_flag[0]);
1169 if (in_data_2 != NULL)
1170 ixheaace_mps_515_huff_enc_icc(pstr_bit_buf, &ixheaace_mps_515_huff_icc_tab.huff_pt0,
1171 &ixheaace_mps_515_huff_icc_tab.huff_diff[diff_type_2],
1172 in_data_2_int, num_val_2_int, p0_flag[1]);
1173 break;
1174
1175 case IXHEAACE_MPS_SAC_DATA_TYPE_CPC:
1176 if (in_data_1 != NULL)
1177 ixheaace_mps_515_huff_enc_cpc(pstr_bit_buf, &ixheaace_mps_515_huff_cpc_tab.huff_pt0,
1178 &ixheaace_mps_515_huff_cpc_tab.huff_diff[diff_type_1],
1179 in_data_1_int, num_val_1_int, p0_flag[0]);
1180 if (in_data_2 != NULL)
1181 ixheaace_mps_515_huff_enc_cpc(pstr_bit_buf, &ixheaace_mps_515_huff_cpc_tab.huff_pt0,
1182 &ixheaace_mps_515_huff_cpc_tab.huff_diff[diff_type_2],
1183 in_data_2_int, num_val_2_int, p0_flag[1]);
1184 break;
1185
1186 default:
1187 break;
1188 }
1189 }
1190
ixheaace_mps_212_ec_data_pair_enc(ixheaace_bit_buf_handle pstr_bit_buf,WORD16 pp_in_data[][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],WORD16 p_in_data[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],const WORD32 data_type,const WORD32 set_idx,const WORD32 start_band,const WORD16 data_bands,const WORD32 coarse_flag,const WORD32 independency_flag)1191 IA_ERRORCODE ixheaace_mps_212_ec_data_pair_enc(
1192 ixheaace_bit_buf_handle pstr_bit_buf, WORD16 pp_in_data[][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],
1193 WORD16 p_in_data[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS], const WORD32 data_type,
1194 const WORD32 set_idx, const WORD32 start_band, const WORD16 data_bands,
1195 const WORD32 coarse_flag, const WORD32 independency_flag) {
1196 IA_ERRORCODE error;
1197 WORD16 band = 0;
1198 WORD16 quant_levels = 0, quant_offset = 0, num_pcm_val = 0;
1199 WORD16 pcm_coding_flag = 0;
1200 WORD16 min_bits_all = 0;
1201 WORD16 min_found = 0;
1202 WORD16 huff_dim_df_df = 0;
1203 WORD16 huff_pair_type_df_df = 0;
1204 WORD16 huff_dim_df_dt = 0;
1205 WORD16 huff_pair_type_df_dt = 0;
1206 WORD16 huff_dim_dtbw_df = 0;
1207 WORD16 huff_pair_type_dtbw_df = 0;
1208 WORD16 huff_dim_dt_dt = 0;
1209 WORD16 huff_pair_type_dt_dt = 0;
1210 WORD16 num_pcm_bits = -1;
1211 WORD16 min_bits_df_df = -1;
1212 WORD16 min_bits_df_dt = -1;
1213 WORD16 min_bits_dtbw_df = -1;
1214 WORD16 min_bits_dt_dt = -1;
1215 WORD16 allow_diff_time_back_flag = !independency_flag || (set_idx > 0);
1216
1217 WORD16 quant_data_msb[2][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {{0}};
1218 WORD16 quant_data_hist_msb[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {0};
1219 WORD16 data_diff_freq[2][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {{0}};
1220 WORD16 data_diff_time[2][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS + 2];
1221 WORD16 lav_df_df[2] = {-1, -1};
1222 WORD16 lav_df_dt[2] = {-1, -1};
1223 WORD16 lav_dtbw_df[2] = {-1, -1};
1224 WORD16 lav_dt_dt[2] = {-1, -1};
1225 WORD16 *p_quant_data_msb[2] = {NULL, NULL};
1226 WORD16 *p_quant_data_hist_msb = NULL;
1227
1228 if (data_bands <= 0) {
1229 return IA_EXHEAACE_EXE_NONFATAL_MPS_INVALID_DATA_BANDS;
1230 }
1231
1232 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
1233 if (coarse_flag) {
1234 quant_levels = 4;
1235 quant_offset = 0;
1236 } else {
1237 quant_levels = 8;
1238 quant_offset = 0;
1239 }
1240 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
1241 if (coarse_flag) {
1242 quant_levels = 15;
1243 quant_offset = 7;
1244 } else {
1245 quant_levels = 31;
1246 quant_offset = 15;
1247 }
1248 } else {
1249 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_HUFF_DATA_TYPE;
1250 }
1251 if (quant_offset != 0) {
1252 for (band = 0; band < data_bands; band++) {
1253 quant_data_msb[0][band] = pp_in_data[set_idx][start_band + band] + quant_offset;
1254 quant_data_msb[1][band] = pp_in_data[set_idx + 1][start_band + band] + quant_offset;
1255 }
1256 p_quant_data_msb[0] = quant_data_msb[0];
1257 p_quant_data_msb[1] = quant_data_msb[1];
1258 } else {
1259 p_quant_data_msb[0] = pp_in_data[set_idx] + start_band;
1260 p_quant_data_msb[1] = pp_in_data[set_idx + 1] + start_band;
1261 }
1262
1263 if (allow_diff_time_back_flag) {
1264 if (quant_offset != 0) {
1265 for (band = 0; band < data_bands; band++) {
1266 quant_data_hist_msb[band] = p_in_data[start_band + band] + quant_offset;
1267 }
1268 p_quant_data_hist_msb = quant_data_hist_msb;
1269 } else {
1270 p_quant_data_hist_msb = p_in_data + start_band;
1271 }
1272 }
1273
1274 data_diff_freq[0][0] = p_quant_data_msb[0][0];
1275 data_diff_freq[1][0] = p_quant_data_msb[1][0];
1276
1277 for (band = 1; band < data_bands; band++) {
1278 data_diff_freq[0][band] = p_quant_data_msb[0][band] - p_quant_data_msb[0][band - 1];
1279 data_diff_freq[1][band] = p_quant_data_msb[1][band] - p_quant_data_msb[1][band - 1];
1280 }
1281
1282 if (allow_diff_time_back_flag) {
1283 data_diff_time[0][0] = p_quant_data_msb[0][0];
1284 data_diff_time[0][1] = p_quant_data_hist_msb[0];
1285
1286 for (band = 0; band < data_bands; band++) {
1287 data_diff_time[0][band + 2] = p_quant_data_msb[0][band] - p_quant_data_hist_msb[band];
1288 }
1289 }
1290
1291 data_diff_time[1][0] = p_quant_data_msb[1][0];
1292 data_diff_time[1][1] = p_quant_data_msb[0][0];
1293
1294 for (band = 0; band < data_bands; band++) {
1295 data_diff_time[1][band + 2] = p_quant_data_msb[1][band] - p_quant_data_msb[0][band];
1296 }
1297
1298 num_pcm_bits = ixheaace_mps_212_calc_pcm_bits((WORD16)(2 * data_bands), quant_levels);
1299 num_pcm_val = (WORD16)(2 * data_bands);
1300
1301 min_bits_all = num_pcm_bits;
1302
1303 error = ixheaace_mps_212_calc_huff_bits(data_diff_freq[0], data_diff_freq[1], data_type,
1304 IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_FREQ,
1305 data_bands, lav_df_df, &min_bits_df_df, &huff_dim_df_df,
1306 &huff_pair_type_df_df);
1307 if (error) {
1308 return error;
1309 }
1310
1311 min_bits_df_df += 2;
1312
1313 if (min_bits_df_df < min_bits_all) {
1314 min_bits_all = min_bits_df_df;
1315 }
1316 error = ixheaace_mps_212_calc_huff_bits(data_diff_freq[0], data_diff_time[1], data_type,
1317 IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_TIME,
1318 data_bands, lav_df_dt, &min_bits_df_dt, &huff_dim_df_dt,
1319 &huff_pair_type_df_dt);
1320 if (error) {
1321 return error;
1322 }
1323
1324 min_bits_df_dt += 2;
1325
1326 if (min_bits_df_dt < min_bits_all) {
1327 min_bits_all = min_bits_df_dt;
1328 }
1329
1330 if (allow_diff_time_back_flag) {
1331 error = ixheaace_mps_212_calc_huff_bits(
1332 data_diff_time[0], data_diff_freq[1], data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1333 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands, lav_dtbw_df, &min_bits_dtbw_df, &huff_dim_dtbw_df,
1334 &huff_pair_type_dtbw_df);
1335 if (error) {
1336 return error;
1337 }
1338
1339 min_bits_dtbw_df += 2;
1340
1341 if (min_bits_dtbw_df < min_bits_all) {
1342 min_bits_all = min_bits_dtbw_df;
1343 }
1344
1345 error = ixheaace_mps_212_calc_huff_bits(
1346 data_diff_time[0], data_diff_time[1], data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1347 IXHEAACE_MPS_SAC_DIFF_TIME, data_bands, lav_dt_dt, &min_bits_dt_dt, &huff_dim_dt_dt,
1348 &huff_pair_type_dt_dt);
1349 if (error) {
1350 return error;
1351 }
1352
1353 min_bits_dt_dt += 2;
1354
1355 if (min_bits_dt_dt < min_bits_all) {
1356 min_bits_all = min_bits_dt_dt;
1357 }
1358 }
1359
1360 pcm_coding_flag = (min_bits_all == num_pcm_bits);
1361
1362 ixheaace_write_bits(pstr_bit_buf, pcm_coding_flag, 1);
1363
1364 if (pcm_coding_flag) {
1365 ixheaace_mps_212_apply_pcm_coding(pstr_bit_buf, pp_in_data[set_idx] + start_band,
1366 pp_in_data[set_idx + 1] + start_band, quant_offset,
1367 num_pcm_val, quant_levels);
1368 } else {
1369 min_found = 0;
1370
1371 if (min_bits_all == min_bits_df_df) {
1372 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1373 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1374
1375 error = ixheaace_mps_212_apply_huff_coding(
1376 pstr_bit_buf, data_diff_freq[0], data_diff_freq[1], data_type,
1377 IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands, lav_df_df,
1378 huff_dim_df_df, huff_pair_type_df_df);
1379 if (error) {
1380 return error;
1381 }
1382 min_found = 1;
1383 }
1384
1385 if (!min_found && (min_bits_all == min_bits_df_dt)) {
1386 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1387 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1388
1389 error = ixheaace_mps_212_apply_huff_coding(
1390 pstr_bit_buf, data_diff_freq[0], data_diff_time[1], data_type,
1391 IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_TIME, data_bands, lav_df_dt,
1392 huff_dim_df_dt, huff_pair_type_df_dt);
1393 if (error) {
1394 return error;
1395 }
1396 min_found = 1;
1397 }
1398
1399 if (allow_diff_time_back_flag) {
1400 if (!min_found && (min_bits_all == min_bits_dtbw_df)) {
1401 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1402 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1403
1404 error = ixheaace_mps_212_apply_huff_coding(
1405 pstr_bit_buf, data_diff_time[0], data_diff_freq[1], data_type,
1406 IXHEAACE_MPS_SAC_DIFF_TIME, IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands, lav_dtbw_df,
1407 huff_dim_dtbw_df, huff_pair_type_dtbw_df);
1408 if (error) {
1409 return error;
1410 }
1411 min_found = 1;
1412 }
1413 if (!min_found && (min_bits_all == min_bits_dt_dt)) {
1414 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1415 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1416
1417 error = ixheaace_mps_212_apply_huff_coding(
1418 pstr_bit_buf, data_diff_time[0], data_diff_time[1], data_type,
1419 IXHEAACE_MPS_SAC_DIFF_TIME, IXHEAACE_MPS_SAC_DIFF_TIME, data_bands, lav_dt_dt,
1420 huff_dim_dt_dt, huff_pair_type_dt_dt);
1421 if (error) {
1422 return error;
1423 }
1424 }
1425 }
1426 }
1427
1428 return IA_NO_ERROR;
1429 }
1430
ixheaace_mps_212_ec_data_single_enc(ixheaace_bit_buf_handle pstr_bit_buf,WORD16 pp_in_data[][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],WORD16 p_in_data[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],const WORD32 data_type,const WORD32 set_idx,const WORD32 start_band,const WORD16 data_bands,const WORD32 coarse_flag,const WORD32 independency_flag)1431 IA_ERRORCODE ixheaace_mps_212_ec_data_single_enc(
1432 ixheaace_bit_buf_handle pstr_bit_buf, WORD16 pp_in_data[][IXHEAACE_MPS_SAC_MAX_FREQ_BANDS],
1433 WORD16 p_in_data[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS], const WORD32 data_type,
1434 const WORD32 set_idx, const WORD32 start_band, const WORD16 data_bands,
1435 const WORD32 coarse_flag, const WORD32 independency_flag) {
1436 IA_ERRORCODE error;
1437 WORD16 band = 0;
1438 WORD16 quant_levels = 0, quant_offset = 0, num_pcm_val = 0;
1439 WORD16 pcm_coding_flag = 0;
1440 WORD16 min_bits_all = 0;
1441 WORD16 min_found = 0;
1442 WORD16 huff_dim_df = 0;
1443 WORD16 huff_pair_type_df = 0;
1444 WORD16 huff_dim_dt = 0;
1445 WORD16 huff_pair_type_dt = 0;
1446 WORD16 allow_diff_time_back_flag = !independency_flag || (set_idx > 0);
1447 WORD16 num_pcm_bits = -1;
1448 WORD16 min_bits_df = -1;
1449 WORD16 min_bits_dt = -1;
1450
1451 WORD16 quant_data_msb[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {0};
1452 WORD16 quant_data_hist_msb[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {0};
1453 WORD16 data_diff_freq[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS] = {0};
1454 WORD16 data_diff_time[IXHEAACE_MPS_SAC_MAX_FREQ_BANDS + 2] = {0};
1455 WORD16 *p_quant_data_msb;
1456 WORD16 *p_quant_data_hist_msb = NULL;
1457 WORD16 lav_df[2] = {-1, -1};
1458 WORD16 lav_dt[2] = {-1, -1};
1459
1460 if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_ICC) {
1461 if (coarse_flag) {
1462 quant_levels = 4;
1463 quant_offset = 0;
1464 } else {
1465 quant_levels = 8;
1466 quant_offset = 0;
1467 }
1468 } else if (data_type == IXHEAACE_MPS_SAC_DATA_TYPE_CLD) {
1469 if (coarse_flag) {
1470 quant_levels = 15;
1471 quant_offset = 7;
1472 } else {
1473 quant_levels = 31;
1474 quant_offset = 15;
1475 }
1476 } else {
1477 return IA_EXHEAACE_EXE_FATAL_MPS_INVALID_HUFF_DATA_TYPE;
1478 }
1479 if (quant_offset != 0) {
1480 for (band = 0; band < data_bands; band++) {
1481 quant_data_msb[band] = pp_in_data[set_idx][start_band + band] + quant_offset;
1482 }
1483 p_quant_data_msb = quant_data_msb;
1484 } else {
1485 p_quant_data_msb = pp_in_data[set_idx] + start_band;
1486 }
1487
1488 if (allow_diff_time_back_flag) {
1489 if (quant_offset != 0) {
1490 for (band = 0; band < data_bands; band++) {
1491 quant_data_hist_msb[band] = p_in_data[start_band + band] + quant_offset;
1492 }
1493 p_quant_data_hist_msb = quant_data_hist_msb;
1494 } else {
1495 p_quant_data_hist_msb = p_in_data + start_band;
1496 }
1497 }
1498
1499 data_diff_freq[0] = p_quant_data_msb[0];
1500
1501 for (band = 1; band < data_bands; band++) {
1502 data_diff_freq[band] = p_quant_data_msb[band] - p_quant_data_msb[band - 1];
1503 }
1504
1505 if (allow_diff_time_back_flag) {
1506 data_diff_time[0] = p_quant_data_msb[0];
1507 data_diff_time[1] = p_quant_data_hist_msb[0];
1508
1509 for (band = 0; band < data_bands; band++) {
1510 data_diff_time[band + 2] = p_quant_data_msb[band] - p_quant_data_hist_msb[band];
1511 }
1512 }
1513
1514 num_pcm_bits = ixheaace_mps_212_calc_pcm_bits(data_bands, quant_levels);
1515 num_pcm_val = data_bands;
1516 min_bits_all = num_pcm_bits;
1517
1518 error = ixheaace_mps_212_calc_huff_bits(
1519 data_diff_freq, NULL, data_type, IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_FREQ,
1520 data_bands, lav_df, &min_bits_df, &huff_dim_df, &huff_pair_type_df);
1521 if (error) {
1522 return error;
1523 }
1524
1525 if (allow_diff_time_back_flag) min_bits_df += 1;
1526
1527 if (min_bits_df < min_bits_all) {
1528 min_bits_all = min_bits_df;
1529 }
1530 if (allow_diff_time_back_flag) {
1531 error = ixheaace_mps_212_calc_huff_bits(
1532 data_diff_time, NULL, data_type, IXHEAACE_MPS_SAC_DIFF_TIME, IXHEAACE_MPS_SAC_DIFF_TIME,
1533 data_bands, lav_dt, &min_bits_dt, &huff_dim_dt, &huff_pair_type_dt);
1534 if (error) {
1535 return error;
1536 }
1537
1538 min_bits_dt += 1;
1539
1540 if (min_bits_dt < min_bits_all) {
1541 min_bits_all = min_bits_dt;
1542 }
1543 }
1544 pcm_coding_flag = (min_bits_all == num_pcm_bits);
1545
1546 ixheaace_write_bits(pstr_bit_buf, pcm_coding_flag, 1);
1547
1548 if (pcm_coding_flag) {
1549 ixheaace_mps_212_apply_pcm_coding(pstr_bit_buf, pp_in_data[set_idx] + start_band, NULL,
1550 quant_offset, num_pcm_val, quant_levels);
1551 } else {
1552 min_found = 0;
1553 if (min_bits_all == min_bits_df) {
1554 if (allow_diff_time_back_flag) {
1555 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1556 }
1557
1558 error = ixheaace_mps_212_apply_huff_coding(
1559 pstr_bit_buf, data_diff_freq, NULL, data_type, IXHEAACE_MPS_SAC_DIFF_FREQ,
1560 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands, lav_df, huff_dim_df, huff_pair_type_df);
1561 if (error) {
1562 return error;
1563 }
1564 min_found = 1;
1565 }
1566
1567 if (allow_diff_time_back_flag) {
1568 if (!min_found && (min_bits_all == min_bits_dt)) {
1569 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1570
1571 error = ixheaace_mps_212_apply_huff_coding(
1572 pstr_bit_buf, data_diff_time, NULL, data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1573 IXHEAACE_MPS_SAC_DIFF_TIME, data_bands, lav_dt, huff_dim_dt, huff_pair_type_dt);
1574 if (error) {
1575 return error;
1576 }
1577 }
1578 }
1579 }
1580
1581 return IA_NO_ERROR;
1582 }
1583
ixheaace_mps_515_ec_data_pair_enc(ixheaace_bit_buf_handle pstr_bit_buf,WORD32 pp_in_data[][MAXBANDS],WORD32 p_in_data[MAXBANDS],WORD32 data_type,WORD32 set_idx,WORD32 start_band,WORD32 data_bands,WORD32 pair_flag,WORD32 coarse_flag,WORD32 independency_flag)1584 VOID ixheaace_mps_515_ec_data_pair_enc(ixheaace_bit_buf_handle pstr_bit_buf,
1585 WORD32 pp_in_data[][MAXBANDS],
1586 WORD32 p_in_data[MAXBANDS], WORD32 data_type,
1587 WORD32 set_idx, WORD32 start_band, WORD32 data_bands,
1588 WORD32 pair_flag, WORD32 coarse_flag,
1589 WORD32 independency_flag) {
1590 WORD32 dummy = 0;
1591 WORD32 quant_levels = 0, quant_offset = 0, num_pcm_val = 0;
1592
1593 WORD32 split_lsb_flag = 0;
1594 WORD32 pcm_coding_flag = 0;
1595
1596 WORD32 min_bits_df_df = -1;
1597 WORD32 min_bits_df_dt = -1;
1598 WORD32 min_bits_dtbw_df = -1;
1599 WORD32 min_bits_dtfw_df = -1;
1600
1601 WORD32 min_bits_dt_dt = -1;
1602 WORD32 allow_diff_time_back_flag = !independency_flag || (set_idx > 0);
1603
1604 WORD32 num_lsb_bits[2] = {0, 0};
1605 WORD32 num_pcm_bits = 0;
1606
1607 WORD32 a_data_hist[MAXBANDS] = {0};
1608 WORD32 aa_data_pair[2][MAXBANDS] = {{0}};
1609
1610 WORD32 quant_data_lsb[2][MAXBANDS] = {{0}};
1611 WORD32 quant_data_msb[2][MAXBANDS] = {{0}};
1612
1613 WORD32 quant_data_hist_lsb[MAXBANDS] = {0};
1614 WORD32 quant_data_hist_msb[MAXBANDS] = {0};
1615
1616 WORD32 data_diff_freq[2][MAXBANDS] = {{0}};
1617 WORD32 data_diff_time_bw[2][MAXBANDS + 1] = {{0}};
1618 WORD32 data_diff_time_fw[MAXBANDS + 1] = {0};
1619
1620 WORD32 *p_data_pcm[2] = {NULL};
1621 WORD32 *p_data_diff_freq[2] = {NULL};
1622 WORD32 *p_data_diff_time_bw[2] = {NULL};
1623 WORD32 *p_data_diff_time_fw = NULL;
1624
1625 WORD32 min_bits_all = 0;
1626 WORD32 min_found = 0;
1627
1628 switch (data_type) {
1629 case IXHEAACE_MPS_SAC_DATA_TYPE_CLD:
1630 if (coarse_flag) {
1631 split_lsb_flag = 0;
1632 quant_levels = 15;
1633 quant_offset = 7;
1634 } else {
1635 split_lsb_flag = 0;
1636 quant_levels = 31;
1637 quant_offset = 15;
1638 }
1639
1640 break;
1641
1642 case IXHEAACE_MPS_SAC_DATA_TYPE_ICC:
1643 if (coarse_flag) {
1644 split_lsb_flag = 0;
1645 quant_levels = 4;
1646 quant_offset = 0;
1647 } else {
1648 split_lsb_flag = 0;
1649 quant_levels = 8;
1650 quant_offset = 0;
1651 }
1652
1653 break;
1654
1655 case IXHEAACE_MPS_SAC_DATA_TYPE_CPC:
1656 if (coarse_flag) {
1657 split_lsb_flag = 0;
1658 quant_levels = 26;
1659 quant_offset = 0;
1660 } else {
1661 split_lsb_flag = 1;
1662 quant_levels = 51;
1663 quant_offset = 0;
1664 }
1665
1666 break;
1667
1668 default:
1669 return;
1670 }
1671
1672 memcpy(a_data_hist, p_in_data + start_band, sizeof(WORD32) * data_bands);
1673
1674 memcpy(aa_data_pair[0], pp_in_data[set_idx] + start_band, sizeof(int) * data_bands);
1675 p_data_pcm[0] = aa_data_pair[0];
1676 if (pair_flag) {
1677 memcpy(aa_data_pair[1], pp_in_data[set_idx + 1] + start_band, sizeof(int) * data_bands);
1678 p_data_pcm[1] = aa_data_pair[1];
1679 }
1680
1681 num_lsb_bits[0] =
1682 ixheaace_mps_515_split_lsb(aa_data_pair[0], quant_offset, split_lsb_flag ? 1 : 0,
1683 data_bands, quant_data_lsb[0], quant_data_msb[0]);
1684
1685 if (pair_flag) {
1686 num_lsb_bits[1] =
1687 ixheaace_mps_515_split_lsb(aa_data_pair[1], quant_offset, split_lsb_flag ? 1 : 0,
1688 data_bands, quant_data_lsb[1], quant_data_msb[1]);
1689 }
1690 (VOID) num_lsb_bits;
1691 if (allow_diff_time_back_flag) {
1692 dummy = ixheaace_mps_515_split_lsb(a_data_hist, quant_offset, split_lsb_flag ? 1 : 0,
1693 data_bands, quant_data_hist_lsb, quant_data_hist_msb);
1694 (VOID) dummy;
1695 }
1696
1697 ixheaace_mps_515_calc_diff_freq(quant_data_msb[0], data_diff_freq[0], data_bands);
1698 p_data_diff_freq[0] = data_diff_freq[0];
1699
1700 if (pair_flag) {
1701 ixheaace_mps_515_calc_diff_freq(quant_data_msb[1], data_diff_freq[1], data_bands);
1702 p_data_diff_freq[1] = data_diff_freq[1];
1703 }
1704
1705 if (allow_diff_time_back_flag) {
1706 ixheaace_mps_515_calc_diff_time(quant_data_msb[0], quant_data_hist_msb,
1707 data_diff_time_bw[0] + 1,
1708 IXHEAACE_MPS_SAC_DIRECTION_BACKWARDS, data_bands);
1709 p_data_diff_time_bw[0] = data_diff_time_bw[0];
1710 }
1711
1712 if (pair_flag) {
1713 ixheaace_mps_515_calc_diff_time(quant_data_msb[1], quant_data_msb[0],
1714 data_diff_time_bw[1] + 1,
1715 IXHEAACE_MPS_SAC_DIRECTION_BACKWARDS, data_bands);
1716 p_data_diff_time_bw[1] = data_diff_time_bw[1];
1717
1718 ixheaace_mps_515_calc_diff_time(quant_data_msb[1], quant_data_msb[0], data_diff_time_fw + 1,
1719 IXHEAACE_MPS_SAC_DIRECTION_FORWARDS, data_bands);
1720 p_data_diff_time_fw = data_diff_time_fw;
1721 }
1722
1723 if (pair_flag) {
1724 num_pcm_bits = ixheaace_mps_515_calc_pcm_bits(2 * data_bands, quant_levels);
1725 num_pcm_val = 2 * data_bands;
1726 } else {
1727 num_pcm_bits = ixheaace_mps_515_calc_pcm_bits(data_bands, quant_levels);
1728 num_pcm_val = data_bands;
1729 }
1730
1731 min_bits_all = num_pcm_bits;
1732
1733 if ((p_data_diff_freq[0] != NULL) || (p_data_diff_freq[1] != NULL)) {
1734 min_bits_df_df = ixheaace_mps_515_calc_huff_bits(p_data_diff_freq[0], p_data_diff_freq[1],
1735 data_type, IXHEAACE_MPS_SAC_DIFF_FREQ,
1736 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1737
1738 if (pair_flag || allow_diff_time_back_flag) min_bits_df_df += 1;
1739 if (pair_flag) min_bits_df_df += 1;
1740
1741 if (min_bits_df_df < min_bits_all) {
1742 min_bits_all = min_bits_df_df;
1743 }
1744 }
1745
1746 if ((p_data_diff_freq[0] != NULL) || (p_data_diff_time_bw[1] != NULL)) {
1747 min_bits_df_dt = ixheaace_mps_515_calc_huff_bits(p_data_diff_freq[0], p_data_diff_time_bw[1],
1748 data_type, IXHEAACE_MPS_SAC_DIFF_FREQ,
1749 IXHEAACE_MPS_SAC_DIFF_TIME, data_bands);
1750
1751 if (pair_flag || allow_diff_time_back_flag) min_bits_df_dt += 1;
1752 if (pair_flag) min_bits_df_dt += 1;
1753
1754 if (min_bits_df_dt < min_bits_all) {
1755 min_bits_all = min_bits_df_dt;
1756 }
1757 }
1758
1759 if ((p_data_diff_time_fw != NULL) || (p_data_diff_freq[1] != NULL)) {
1760 min_bits_dtfw_df = ixheaace_mps_515_calc_huff_bits(p_data_diff_time_fw, p_data_diff_freq[1],
1761 data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1762 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1763
1764 if (pair_flag || allow_diff_time_back_flag) min_bits_dtfw_df += 1;
1765 if (pair_flag && allow_diff_time_back_flag) min_bits_dtfw_df += 1;
1766
1767 if (pair_flag && allow_diff_time_back_flag) {
1768 min_bits_dtfw_df += 1;
1769 }
1770
1771 if (min_bits_dtfw_df < min_bits_all) {
1772 min_bits_all = min_bits_dtfw_df;
1773 }
1774 }
1775
1776 if (allow_diff_time_back_flag) {
1777 if ((p_data_diff_time_bw[0] != NULL) || (p_data_diff_freq[1] != NULL)) {
1778 min_bits_dtbw_df = ixheaace_mps_515_calc_huff_bits(
1779 p_data_diff_time_bw[0], p_data_diff_freq[1], data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1780 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1781
1782 min_bits_dtbw_df += 1;
1783 if (pair_flag) {
1784 min_bits_dtbw_df += 2;
1785 }
1786
1787 if (min_bits_dtbw_df < min_bits_all) {
1788 min_bits_all = min_bits_dtbw_df;
1789 }
1790 }
1791
1792 if ((p_data_diff_time_bw[0] != NULL) || (p_data_diff_time_bw[1] != NULL)) {
1793 min_bits_dt_dt = ixheaace_mps_515_calc_huff_bits(
1794 p_data_diff_time_bw[0], p_data_diff_time_bw[1], data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1795 IXHEAACE_MPS_SAC_DIFF_TIME, data_bands);
1796
1797 min_bits_dt_dt += 1;
1798 if (pair_flag) min_bits_dt_dt += 1;
1799
1800 if (min_bits_dt_dt < min_bits_all) {
1801 min_bits_all = min_bits_dt_dt;
1802 }
1803 }
1804 }
1805
1806 pcm_coding_flag = (min_bits_all == num_pcm_bits);
1807
1808 ixheaace_write_bits(pstr_bit_buf, pcm_coding_flag, 1);
1809
1810 if (pcm_coding_flag) {
1811 if (data_bands >= PBC_MIN_BANDS) {
1812 ixheaace_write_bits(pstr_bit_buf, 0, 1);
1813 }
1814
1815 ixheaace_mps_515_apply_pcm_coding(pstr_bit_buf, p_data_pcm[0], p_data_pcm[1], quant_offset,
1816 num_pcm_val, quant_levels);
1817 } else {
1818 min_found = 0;
1819
1820 if (min_bits_all == min_bits_df_df) {
1821 if (pair_flag || allow_diff_time_back_flag) {
1822 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1823 }
1824
1825 if (pair_flag) {
1826 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1827 }
1828
1829 ixheaace_mps_515_apply_huff_coding(pstr_bit_buf, p_data_diff_freq[0], p_data_diff_freq[1],
1830 data_type, IXHEAACE_MPS_SAC_DIFF_FREQ,
1831 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1832
1833 min_found = 1;
1834 }
1835
1836 if (!min_found && (min_bits_all == min_bits_df_dt)) {
1837 if (pair_flag || allow_diff_time_back_flag) {
1838 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1839 }
1840
1841 if (pair_flag) {
1842 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1843 }
1844
1845 ixheaace_mps_515_apply_huff_coding(
1846 pstr_bit_buf, p_data_diff_freq[0], p_data_diff_time_bw[1], data_type,
1847 IXHEAACE_MPS_SAC_DIFF_FREQ, IXHEAACE_MPS_SAC_DIFF_TIME, data_bands);
1848
1849 min_found = 1;
1850 }
1851
1852 if (!min_found && (min_bits_all == min_bits_dtfw_df)) {
1853 if (pair_flag || allow_diff_time_back_flag) {
1854 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1855 }
1856
1857 if (pair_flag && allow_diff_time_back_flag) {
1858 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1859 }
1860
1861 ixheaace_mps_515_apply_huff_coding(pstr_bit_buf, p_data_diff_time_fw, p_data_diff_freq[1],
1862 data_type, IXHEAACE_MPS_SAC_DIFF_TIME,
1863 IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1864
1865 if (pair_flag && allow_diff_time_back_flag) {
1866 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIRECTION_FORWARDS, 1);
1867 }
1868
1869 min_found = 1;
1870 }
1871
1872 if (allow_diff_time_back_flag) {
1873 if (!min_found && (min_bits_all == min_bits_dtbw_df)) {
1874 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1875
1876 if (pair_flag) {
1877 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_FREQ, 1);
1878 }
1879
1880 ixheaace_mps_515_apply_huff_coding(
1881 pstr_bit_buf, p_data_diff_time_bw[0], p_data_diff_freq[1], data_type,
1882 IXHEAACE_MPS_SAC_DIFF_TIME, IXHEAACE_MPS_SAC_DIFF_FREQ, data_bands);
1883
1884 if (pair_flag) {
1885 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIRECTION_BACKWARDS, 1);
1886 }
1887
1888 min_found = 1;
1889 }
1890
1891 if (!min_found && (min_bits_all == min_bits_dt_dt)) {
1892 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1893
1894 if (pair_flag) {
1895 ixheaace_write_bits(pstr_bit_buf, IXHEAACE_MPS_SAC_DIFF_TIME, 1);
1896 }
1897
1898 ixheaace_mps_515_apply_huff_coding(
1899 pstr_bit_buf, p_data_diff_time_bw[0], p_data_diff_time_bw[1], data_type,
1900 IXHEAACE_MPS_SAC_DIFF_TIME, IXHEAACE_MPS_SAC_DIFF_TIME, data_bands);
1901 }
1902 }
1903
1904 if (split_lsb_flag) {
1905 ixheaace_mps_515_apply_lsb_coding(pstr_bit_buf, quant_data_lsb[0], 1, data_bands);
1906
1907 if (pair_flag) {
1908 ixheaace_mps_515_apply_lsb_coding(pstr_bit_buf, quant_data_lsb[1], 1, data_bands);
1909 }
1910 }
1911 }
1912
1913 return;
1914 }
1915