1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
5 Forschung e.V. All rights reserved.
6
7 1. INTRODUCTION
8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10 scheme for digital audio. This FDK AAC Codec software is intended to be used on
11 a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14 general perceptual audio codecs. AAC-ELD is considered the best-performing
15 full-bandwidth communications codec by independent studies and is widely
16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17 specifications.
18
19 Patent licenses for necessary patent claims for the FDK AAC Codec (including
20 those of Fraunhofer) may be obtained through Via Licensing
21 (www.vialicensing.com) or through the respective patent owners individually for
22 the purpose of encoding or decoding bit streams in products that are compliant
23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24 Android devices already license these patent claims through Via Licensing or
25 directly from the patent owners, and therefore FDK AAC Codec software may
26 already be covered under those patent licenses when it is used for those
27 licensed purposes only.
28
29 Commercially-licensed AAC software libraries, including floating-point versions
30 with enhanced sound quality, are also available from Fraunhofer. Users are
31 encouraged to check the Fraunhofer website for additional applications
32 information and documentation.
33
34 2. COPYRIGHT LICENSE
35
36 Redistribution and use in source and binary forms, with or without modification,
37 are permitted without payment of copyright license fees provided that you
38 satisfy the following conditions:
39
40 You must retain the complete text of this software license in redistributions of
41 the FDK AAC Codec or your modifications thereto in source code form.
42
43 You must retain the complete text of this software license in the documentation
44 and/or other materials provided with redistributions of the FDK AAC Codec or
45 your modifications thereto in binary form. You must make available free of
46 charge copies of the complete source code of the FDK AAC Codec and your
47 modifications thereto to recipients of copies in binary form.
48
49 The name of Fraunhofer may not be used to endorse or promote products derived
50 from this library without prior written permission.
51
52 You may not charge copyright license fees for anyone to use, copy or distribute
53 the FDK AAC Codec software or your modifications thereto.
54
55 Your modified versions of the FDK AAC Codec must carry prominent notices stating
56 that you changed the software and the date of any change. For modified versions
57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59 AAC Codec Library for Android."
60
61 3. NO PATENT LICENSE
62
63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65 Fraunhofer provides no warranty of patent non-infringement with respect to this
66 software.
67
68 You may use this FDK AAC Codec software or modifications thereto only for
69 purposes that are authorized by appropriate patent licenses.
70
71 4. DISCLAIMER
72
73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75 including but not limited to the implied warranties of merchantability and
76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78 or consequential damages, including but not limited to procurement of substitute
79 goods or services; loss of use, data, or profits, or business interruption,
80 however caused and on any theory of liability, whether in contract, strict
81 liability, or tort (including negligence), arising in any way out of the use of
82 this software, even if advised of the possibility of such damage.
83
84 5. CONTACT INFORMATION
85
86 Fraunhofer Institute for Integrated Circuits IIS
87 Attention: Audio and Multimedia Departments - FDK AAC LL
88 Am Wolfsmantel 33
89 91058 Erlangen, Germany
90
91 www.iis.fraunhofer.de/amm
92 amm-info@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /******************* Library for basic calculation routines ********************
96
97 Author(s): Omer Osman
98
99 Description: SAC/SAOC Dec Noiseless Coding
100
101 *******************************************************************************/
102
103 #include "nlc_dec.h"
104 #include "FDK_tools_rom.h"
105
106 /* MAX_PARAMETER_BANDS defines array length in huffdec */
107
108 #ifndef min
109 #define min(a, b) (((a) < (b)) ? (a) : (b))
110 #endif
111
sym_restoreIPD(HANDLE_FDK_BITSTREAM strm,int lav,SCHAR data[2])112 ERROR_t sym_restoreIPD(HANDLE_FDK_BITSTREAM strm, int lav, SCHAR data[2]) {
113 int sum_val = data[0] + data[1];
114 int diff_val = data[0] - data[1];
115
116 if (sum_val > lav) {
117 data[0] = -sum_val + (2 * lav + 1);
118 data[1] = -diff_val;
119 } else {
120 data[0] = sum_val;
121 data[1] = diff_val;
122 }
123
124 if (data[0] - data[1] != 0) {
125 ULONG sym_bit;
126 sym_bit = FDKreadBits(strm, 1);
127 if (sym_bit) {
128 int tmp;
129 tmp = data[0];
130 data[0] = data[1];
131 data[1] = tmp;
132 }
133 }
134
135 return HUFFDEC_OK;
136 }
137
ilog2(unsigned int i)138 static int ilog2(unsigned int i) {
139 int l = 0;
140
141 if (i) i--;
142 while (i > 0) {
143 i >>= 1;
144 l++;
145 }
146
147 return l;
148 }
149
pcm_decode(HANDLE_FDK_BITSTREAM strm,SCHAR * out_data_1,SCHAR * out_data_2,int offset,int num_val,int num_levels)150 static ERROR_t pcm_decode(HANDLE_FDK_BITSTREAM strm, SCHAR* out_data_1,
151 SCHAR* out_data_2, int offset, int num_val,
152 int num_levels) {
153 int i = 0, j = 0, idx = 0;
154 int max_grp_len = 0, next_val = 0;
155 ULONG tmp;
156
157 int pcm_chunk_size[7] = {0};
158
159 switch (num_levels) {
160 case 3:
161 max_grp_len = 5;
162 break;
163 case 7:
164 max_grp_len = 6;
165 break;
166 case 11:
167 max_grp_len = 2;
168 break;
169 case 13:
170 max_grp_len = 4;
171 break;
172 case 19:
173 max_grp_len = 4;
174 break;
175 case 25:
176 max_grp_len = 3;
177 break;
178 case 51:
179 max_grp_len = 4;
180 break;
181 case 4:
182 case 8:
183 case 15:
184 case 16:
185 case 26:
186 case 31:
187 max_grp_len = 1;
188 break;
189 default:
190 return HUFFDEC_NOTOK;
191 }
192
193 tmp = 1;
194 for (i = 1; i <= max_grp_len; i++) {
195 tmp *= num_levels;
196 pcm_chunk_size[i] = ilog2(tmp);
197 }
198
199 for (i = 0; i < num_val; i += max_grp_len) {
200 int grp_len, grp_val, data;
201 grp_len = min(max_grp_len, num_val - i);
202 data = FDKreadBits(strm, pcm_chunk_size[grp_len]);
203
204 grp_val = data;
205
206 for (j = 0; j < grp_len; j++) {
207 idx = i + (grp_len - j - 1);
208 next_val = grp_val % num_levels;
209
210 if (out_data_2 == NULL) {
211 out_data_1[idx] = next_val - offset;
212 } else if (out_data_1 == NULL) {
213 out_data_2[idx] = next_val - offset;
214 } else {
215 if (idx % 2) {
216 out_data_2[idx / 2] = next_val - offset;
217 } else {
218 out_data_1[idx / 2] = next_val - offset;
219 }
220 }
221
222 grp_val = (grp_val - next_val) / num_levels;
223 }
224 }
225
226 return HUFFDEC_OK;
227 }
228
huff_read(HANDLE_FDK_BITSTREAM strm,const SHORT (* nodeTab)[MAX_ENTRIES][2],int * out_data)229 static ERROR_t huff_read(HANDLE_FDK_BITSTREAM strm,
230 const SHORT (*nodeTab)[MAX_ENTRIES][2],
231 int* out_data) {
232 int node = 0;
233 int len = 0;
234
235 do {
236 ULONG next_bit;
237 next_bit = FDKreadBits(strm, 1);
238 len++;
239 node = (*nodeTab)[node][next_bit];
240 } while (node > 0);
241
242 *out_data = node;
243
244 return HUFFDEC_OK;
245 }
246
huff_read_2D(HANDLE_FDK_BITSTREAM strm,const SHORT (* nodeTab)[MAX_ENTRIES][2],SCHAR out_data[2],int * escape)247 static ERROR_t huff_read_2D(HANDLE_FDK_BITSTREAM strm,
248 const SHORT (*nodeTab)[MAX_ENTRIES][2],
249 SCHAR out_data[2], int* escape) {
250 ERROR_t err = HUFFDEC_OK;
251
252 int huff_2D_8bit = 0;
253 int node = 0;
254
255 if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
256 goto bail;
257 }
258 *escape = (node == 0);
259
260 if (*escape) {
261 out_data[0] = 0;
262 out_data[1] = 1;
263 } else {
264 huff_2D_8bit = -(node + 1);
265 out_data[0] = huff_2D_8bit >> 4;
266 out_data[1] = huff_2D_8bit & 0xf;
267 }
268
269 bail:
270 return err;
271 }
272
sym_restore(HANDLE_FDK_BITSTREAM strm,int lav,SCHAR data[2])273 static ERROR_t sym_restore(HANDLE_FDK_BITSTREAM strm, int lav, SCHAR data[2]) {
274 ULONG sym_bit = 0;
275
276 int sum_val = data[0] + data[1];
277 int diff_val = data[0] - data[1];
278
279 if (sum_val > lav) {
280 data[0] = -sum_val + (2 * lav + 1);
281 data[1] = -diff_val;
282 } else {
283 data[0] = sum_val;
284 data[1] = diff_val;
285 }
286
287 if (data[0] + data[1] != 0) {
288 sym_bit = FDKreadBits(strm, 1);
289 if (sym_bit) {
290 data[0] = -data[0];
291 data[1] = -data[1];
292 }
293 }
294
295 if (data[0] - data[1] != 0) {
296 sym_bit = FDKreadBits(strm, 1);
297 if (sym_bit) {
298 int tmp;
299 tmp = data[0];
300 data[0] = data[1];
301 data[1] = tmp;
302 }
303 }
304
305 return HUFFDEC_OK;
306 }
307
huff_dec_1D(HANDLE_FDK_BITSTREAM strm,const DATA_TYPE data_type,const INT dim1,SCHAR * out_data,const INT num_val,const INT p0_flag)308 static ERROR_t huff_dec_1D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
309 const INT dim1, SCHAR* out_data, const INT num_val,
310 const INT p0_flag)
311
312 {
313 ERROR_t err = HUFFDEC_OK;
314 int i = 0, node = 0, offset = 0;
315 int od = 0, od_sign = 0;
316 ULONG data = 0;
317 int bitsAvail = 0;
318
319 const SHORT(*partTab)[MAX_ENTRIES][2] = NULL;
320 const SHORT(*nodeTab)[MAX_ENTRIES][2] = NULL;
321
322 switch (data_type) {
323 case t_CLD:
324 partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.cld[0][0];
325 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h1D[dim1]->nodeTab[0][0];
326 break;
327 case t_ICC:
328 partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.icc[0][0];
329 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h1D[dim1]->nodeTab[0][0];
330 break;
331 case t_OLD:
332 partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.old[0][0];
333 nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h1D[dim1]->nodeTab[0][0];
334 break;
335 case t_IPD:
336 partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.ipd[0][0];
337 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h1D[dim1].nodeTab[0][0];
338 break;
339 default:
340 FDK_ASSERT(0);
341 err = HUFFDEC_NOTOK;
342 goto bail;
343 }
344
345 if (p0_flag) {
346 if ((err = huff_read(strm, partTab, &node)) != HUFFDEC_OK) {
347 goto bail;
348 }
349
350 out_data[0] = -(node + 1);
351 offset = 1;
352 }
353
354 for (i = offset; i < num_val; i++) {
355 bitsAvail = FDKgetValidBits(strm);
356 if (bitsAvail < 1) {
357 err = HUFFDEC_NOTOK;
358 goto bail;
359 }
360
361 if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
362 goto bail;
363 }
364 od = -(node + 1);
365
366 if (data_type != t_IPD) {
367 if (od != 0) {
368 bitsAvail = FDKgetValidBits(strm);
369 if (bitsAvail < 1) {
370 err = HUFFDEC_NOTOK;
371 goto bail;
372 }
373
374 data = FDKreadBits(strm, 1);
375 od_sign = data;
376
377 if (od_sign) od = -od;
378 }
379 }
380
381 out_data[i] = od;
382 }
383
384 bail:
385 return err;
386 }
387
huff_dec_2D(HANDLE_FDK_BITSTREAM strm,const DATA_TYPE data_type,const INT dim1,const INT dim2,SCHAR out_data[][2],const INT num_val,const INT stride,SCHAR * p0_data[2])388 static ERROR_t huff_dec_2D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
389 const INT dim1, const INT dim2, SCHAR out_data[][2],
390 const INT num_val, const INT stride,
391 SCHAR* p0_data[2]) {
392 ERROR_t err = HUFFDEC_OK;
393 int i = 0, lav = 0, escape = 0, escCntr = 0;
394 int node = 0;
395 unsigned long data = 0;
396
397 SCHAR esc_data[2][28] = {{0}};
398 int escIdx[28] = {0};
399 const SHORT(*nodeTab)[MAX_ENTRIES][2] = NULL;
400
401 /* LAV */
402 if ((err =
403 huff_read(strm, (HANDLE_HUFF_NODE)&FDK_huffLavIdxNodes.nodeTab[0][0],
404 &node)) != HUFFDEC_OK) {
405 goto bail;
406 }
407 data = -(node + 1);
408
409 switch (data_type) {
410 case t_CLD:
411 lav = 2 * data + 3; /* 3, 5, 7, 9 */
412 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.cld[0][0];
413 break;
414 case t_ICC:
415 lav = 2 * data + 1; /* 1, 3, 5, 7 */
416 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.icc[0][0];
417 break;
418 case t_OLD:
419 lav = 3 * data + 3;
420 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.old[0][0];
421 break;
422 case t_IPD:
423 if (data == 0)
424 data = 3;
425 else
426 data--;
427 lav = 2 * data + 1; /* 1, 3, 5, 7 */
428 nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.ipd[0][0];
429 break;
430 default:
431 FDK_ASSERT(0);
432 err = HUFFDEC_NOTOK;
433 goto bail;
434 }
435
436 /* Partition 0 */
437 if (p0_data[0] != NULL) {
438 if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
439 goto bail;
440 }
441 *p0_data[0] = -(node + 1);
442 }
443 if (p0_data[1] != NULL) {
444 if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
445 goto bail;
446 }
447 *p0_data[1] = -(node + 1);
448 }
449
450 switch (data_type) {
451 case t_CLD:
452 switch (lav) {
453 case 3:
454 nodeTab =
455 (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav3[0][0];
456 break;
457 case 5:
458 nodeTab =
459 (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav5[0][0];
460 break;
461 case 7:
462 nodeTab =
463 (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav7[0][0];
464 break;
465 case 9:
466 nodeTab =
467 (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav9[0][0];
468 break;
469 }
470 break;
471 case t_ICC:
472 switch (lav) {
473 case 1:
474 nodeTab =
475 (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav1[0][0];
476 break;
477 case 3:
478 nodeTab =
479 (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav3[0][0];
480 break;
481 case 5:
482 nodeTab =
483 (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav5[0][0];
484 break;
485 case 7:
486 nodeTab =
487 (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav7[0][0];
488 break;
489 }
490 break;
491 case t_OLD:
492 switch (lav) {
493 case 3:
494 nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav3[0][0];
495 break;
496 case 6:
497 nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav6[0][0];
498 break;
499 case 9:
500 nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav9[0][0];
501 break;
502 case 12:
503 nodeTab =
504 (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav12[0][0];
505 break;
506 }
507 break;
508 case t_IPD:
509 switch (lav) {
510 case 1:
511 nodeTab =
512 (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav1[0][0];
513 break;
514 case 3:
515 nodeTab =
516 (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav3[0][0];
517 break;
518 case 5:
519 nodeTab =
520 (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav5[0][0];
521 break;
522 case 7:
523 nodeTab =
524 (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav7[0][0];
525 break;
526 }
527 break;
528 default:
529 break;
530 }
531
532 for (i = 0; i < num_val; i += stride) {
533 if ((err = huff_read_2D(strm, nodeTab, out_data[i], &escape)) !=
534 HUFFDEC_OK) {
535 goto bail;
536 }
537
538 if (escape) {
539 escIdx[escCntr++] = i;
540 } else {
541 if (data_type == t_IPD) {
542 if ((err = sym_restoreIPD(strm, lav, out_data[i])) != HUFFDEC_OK) {
543 goto bail;
544 }
545 } else {
546 if ((err = sym_restore(strm, lav, out_data[i])) != HUFFDEC_OK) {
547 goto bail;
548 }
549 }
550 }
551 } /* i */
552
553 if (escCntr > 0) {
554 if ((err = pcm_decode(strm, esc_data[0], esc_data[1], 0, 2 * escCntr,
555 (2 * lav + 1))) != HUFFDEC_OK) {
556 goto bail;
557 }
558
559 for (i = 0; i < escCntr; i++) {
560 out_data[escIdx[i]][0] = esc_data[0][i] - lav;
561 out_data[escIdx[i]][1] = esc_data[1][i] - lav;
562 }
563 }
564 bail:
565 return err;
566 }
567
huff_decode(HANDLE_FDK_BITSTREAM strm,SCHAR * out_data_1,SCHAR * out_data_2,DATA_TYPE data_type,DIFF_TYPE diff_type_1,DIFF_TYPE diff_type_2,int num_val,int * cdg_scheme,int ldMode)568 static ERROR_t huff_decode(HANDLE_FDK_BITSTREAM strm, SCHAR* out_data_1,
569 SCHAR* out_data_2, DATA_TYPE data_type,
570 DIFF_TYPE diff_type_1, DIFF_TYPE diff_type_2,
571 int num_val, int* cdg_scheme, int ldMode) {
572 ERROR_t err = HUFFDEC_OK;
573 DIFF_TYPE diff_type;
574
575 int i = 0;
576 ULONG data = 0;
577
578 SCHAR pair_vec[28][2];
579
580 SCHAR* p0_data_1[2] = {NULL, NULL};
581 SCHAR* p0_data_2[2] = {NULL, NULL};
582
583 int p0_flag[2];
584
585 int num_val_1_int = num_val;
586 int num_val_2_int = num_val;
587
588 SCHAR* out_data_1_int = out_data_1;
589 SCHAR* out_data_2_int = out_data_2;
590
591 int df_rest_flag_1 = 0;
592 int df_rest_flag_2 = 0;
593
594 int hufYY1;
595 int hufYY2;
596 int hufYY;
597
598 /* Coding scheme */
599 data = FDKreadBits(strm, 1);
600 *cdg_scheme = (data << PAIR_SHIFT);
601
602 if (*cdg_scheme >> PAIR_SHIFT == HUFF_2D) {
603 if ((out_data_1 != NULL) && (out_data_2 != NULL) && (ldMode == 0)) {
604 data = FDKreadBits(strm, 1);
605 *cdg_scheme = (*cdg_scheme | data);
606 } else {
607 *cdg_scheme = (*cdg_scheme | FREQ_PAIR);
608 }
609 }
610
611 {
612 hufYY1 = diff_type_1;
613 hufYY2 = diff_type_2;
614 }
615
616 switch (*cdg_scheme >> PAIR_SHIFT) {
617 case HUFF_1D:
618 p0_flag[0] = (diff_type_1 == DIFF_FREQ);
619 p0_flag[1] = (diff_type_2 == DIFF_FREQ);
620 if (out_data_1 != NULL) {
621 if ((err = huff_dec_1D(strm, data_type, hufYY1, out_data_1,
622 num_val_1_int, p0_flag[0])) != HUFFDEC_OK) {
623 goto bail;
624 }
625 }
626 if (out_data_2 != NULL) {
627 if ((err = huff_dec_1D(strm, data_type, hufYY2, out_data_2,
628 num_val_2_int, p0_flag[1])) != HUFFDEC_OK) {
629 goto bail;
630 }
631 }
632
633 break; /* HUFF_1D */
634
635 case HUFF_2D:
636
637 switch (*cdg_scheme & PAIR_MASK) {
638 case FREQ_PAIR:
639
640 if (out_data_1 != NULL) {
641 if (diff_type_1 == DIFF_FREQ) {
642 p0_data_1[0] = &out_data_1[0];
643 p0_data_1[1] = NULL;
644
645 num_val_1_int -= 1;
646 out_data_1_int += 1;
647 }
648 df_rest_flag_1 = num_val_1_int % 2;
649 if (df_rest_flag_1) num_val_1_int -= 1;
650 if (num_val_1_int < 0) {
651 err = HUFFDEC_NOTOK;
652 goto bail;
653 }
654 }
655 if (out_data_2 != NULL) {
656 if (diff_type_2 == DIFF_FREQ) {
657 p0_data_2[0] = NULL;
658 p0_data_2[1] = &out_data_2[0];
659
660 num_val_2_int -= 1;
661 out_data_2_int += 1;
662 }
663 df_rest_flag_2 = num_val_2_int % 2;
664 if (df_rest_flag_2) num_val_2_int -= 1;
665 if (num_val_2_int < 0) {
666 err = HUFFDEC_NOTOK;
667 goto bail;
668 }
669 }
670
671 if (out_data_1 != NULL) {
672 if ((err = huff_dec_2D(strm, data_type, hufYY1, FREQ_PAIR, pair_vec,
673 num_val_1_int, 2, p0_data_1)) !=
674 HUFFDEC_OK) {
675 goto bail;
676 }
677 if (df_rest_flag_1) {
678 if ((err = huff_dec_1D(strm, data_type, hufYY1,
679 out_data_1_int + num_val_1_int, 1, 0)) !=
680 HUFFDEC_OK) {
681 goto bail;
682 }
683 }
684 }
685 if (out_data_2 != NULL) {
686 if ((err = huff_dec_2D(strm, data_type, hufYY2, FREQ_PAIR,
687 pair_vec + 1, num_val_2_int, 2,
688 p0_data_2)) != HUFFDEC_OK) {
689 goto bail;
690 }
691 if (df_rest_flag_2) {
692 if ((err = huff_dec_1D(strm, data_type, hufYY2,
693 out_data_2_int + num_val_2_int, 1, 0)) !=
694 HUFFDEC_OK) {
695 goto bail;
696 }
697 }
698 }
699
700 if (out_data_1 != NULL) {
701 for (i = 0; i < num_val_1_int - 1; i += 2) {
702 out_data_1_int[i] = pair_vec[i][0];
703 out_data_1_int[i + 1] = pair_vec[i][1];
704 }
705 }
706 if (out_data_2 != NULL) {
707 for (i = 0; i < num_val_2_int - 1; i += 2) {
708 out_data_2_int[i] = pair_vec[i + 1][0];
709 out_data_2_int[i + 1] = pair_vec[i + 1][1];
710 }
711 }
712 break; /* FREQ_PAIR */
713
714 case TIME_PAIR:
715 if (((diff_type_1 == DIFF_FREQ) || (diff_type_2 == DIFF_FREQ))) {
716 p0_data_1[0] = &out_data_1[0];
717 p0_data_1[1] = &out_data_2[0];
718
719 out_data_1_int += 1;
720 out_data_2_int += 1;
721
722 num_val_1_int -= 1;
723 }
724
725 if ((diff_type_1 == DIFF_TIME) || (diff_type_2 == DIFF_TIME)) {
726 diff_type = DIFF_TIME;
727 } else {
728 diff_type = DIFF_FREQ;
729 }
730 { hufYY = diff_type; }
731
732 if ((err = huff_dec_2D(strm, data_type, hufYY, TIME_PAIR, pair_vec,
733 num_val_1_int, 1, p0_data_1)) != HUFFDEC_OK) {
734 goto bail;
735 }
736
737 for (i = 0; i < num_val_1_int; i++) {
738 out_data_1_int[i] = pair_vec[i][0];
739 out_data_2_int[i] = pair_vec[i][1];
740 }
741
742 break; /* TIME_PAIR */
743
744 default:
745 break;
746 }
747
748 break; /* HUFF_2D */
749
750 default:
751 break;
752 }
753 bail:
754 return err;
755 }
756
diff_freq_decode(const SCHAR * const diff_data,SCHAR * const out_data,const int num_val)757 static void diff_freq_decode(const SCHAR* const diff_data,
758 SCHAR* const out_data, const int num_val) {
759 int i = 0;
760 out_data[0] = diff_data[0];
761
762 for (i = 1; i < num_val; i++) {
763 out_data[i] = out_data[i - 1] + diff_data[i];
764 }
765 }
766
diff_time_decode_backwards(const SCHAR * const prev_data,const SCHAR * const diff_data,SCHAR * const out_data,const int mixed_diff_type,const int num_val)767 static void diff_time_decode_backwards(const SCHAR* const prev_data,
768 const SCHAR* const diff_data,
769 SCHAR* const out_data,
770 const int mixed_diff_type,
771 const int num_val) {
772 int i = 0; /* default start value*/
773
774 if (mixed_diff_type) {
775 out_data[0] = diff_data[0];
776 i = 1; /* new start value */
777 }
778 for (; i < num_val; i++) {
779 out_data[i] = prev_data[i] + diff_data[i];
780 }
781 }
782
diff_time_decode_forwards(const SCHAR * const prev_data,const SCHAR * const diff_data,SCHAR * const out_data,const int mixed_diff_type,const int num_val)783 static void diff_time_decode_forwards(const SCHAR* const prev_data,
784 const SCHAR* const diff_data,
785 SCHAR* const out_data,
786 const int mixed_diff_type,
787 const int num_val) {
788 int i = 0; /* default start value*/
789
790 if (mixed_diff_type) {
791 out_data[0] = diff_data[0];
792 i = 1; /* new start value */
793 }
794 for (; i < num_val; i++) {
795 out_data[i] = prev_data[i] - diff_data[i];
796 }
797 }
798
attach_lsb(HANDLE_FDK_BITSTREAM strm,SCHAR * in_data_msb,int offset,int num_lsb,int num_val,SCHAR * out_data)799 static ERROR_t attach_lsb(HANDLE_FDK_BITSTREAM strm, SCHAR* in_data_msb,
800 int offset, int num_lsb, int num_val,
801 SCHAR* out_data) {
802 int i = 0, lsb = 0;
803 ULONG data = 0;
804
805 for (i = 0; i < num_val; i++) {
806 int msb;
807 msb = in_data_msb[i];
808
809 if (num_lsb > 0) {
810 data = FDKreadBits(strm, num_lsb);
811 lsb = data;
812
813 out_data[i] = ((msb << num_lsb) | lsb) - offset;
814 } else
815 out_data[i] = msb - offset;
816 }
817
818 return HUFFDEC_OK; /* dummy */
819 }
820
EcDataPairDec(DECODER_TYPE DECODER,HANDLE_FDK_BITSTREAM strm,SCHAR * aaOutData1,SCHAR * aaOutData2,SCHAR * aHistory,DATA_TYPE data_type,int startBand,int dataBands,int pair_flag,int coarse_flag,int allowDiffTimeBack_flag)821 ERROR_t EcDataPairDec(DECODER_TYPE DECODER, HANDLE_FDK_BITSTREAM strm,
822 SCHAR* aaOutData1, SCHAR* aaOutData2, SCHAR* aHistory,
823 DATA_TYPE data_type, int startBand, int dataBands,
824 int pair_flag, int coarse_flag,
825 int allowDiffTimeBack_flag)
826
827 {
828 ERROR_t err = HUFFDEC_OK;
829
830 // int allowDiffTimeBack_flag = !independency_flag || (setIdx > 0);
831 int attachLsb_flag = 0;
832 int pcmCoding_flag = 0;
833
834 int mixed_time_pair = 0, numValPcm = 0;
835 int quant_levels = 0, quant_offset = 0;
836 ULONG data = 0;
837
838 SCHAR aaDataPair[2][28] = {{0}};
839 SCHAR aaDataDiff[2][28] = {{0}};
840
841 SCHAR aHistoryMsb[28] = {0};
842
843 SCHAR* pDataVec[2] = {NULL, NULL};
844
845 DIFF_TYPE diff_type[2] = {DIFF_FREQ, DIFF_FREQ};
846 int cdg_scheme = HUFF_1D;
847 DIRECTION direction = BACKWARDS;
848
849 switch (data_type) {
850 case t_CLD:
851 if (coarse_flag) {
852 attachLsb_flag = 0;
853 quant_levels = 15;
854 quant_offset = 7;
855 } else {
856 attachLsb_flag = 0;
857 quant_levels = 31;
858 quant_offset = 15;
859 }
860
861 break;
862
863 case t_ICC:
864 if (coarse_flag) {
865 attachLsb_flag = 0;
866 quant_levels = 4;
867 quant_offset = 0;
868 } else {
869 attachLsb_flag = 0;
870 quant_levels = 8;
871 quant_offset = 0;
872 }
873
874 break;
875
876 case t_OLD:
877 if (coarse_flag) {
878 attachLsb_flag = 0;
879 quant_levels = 8;
880 quant_offset = 0;
881 } else {
882 attachLsb_flag = 0;
883 quant_levels = 16;
884 quant_offset = 0;
885 }
886 break;
887
888 case t_NRG:
889 if (coarse_flag) {
890 attachLsb_flag = 0;
891 quant_levels = 32;
892 quant_offset = 0;
893 } else {
894 attachLsb_flag = 0;
895 quant_levels = 64;
896 quant_offset = 0;
897 }
898 break;
899
900 case t_IPD:
901 if (!coarse_flag) {
902 attachLsb_flag = 1;
903 quant_levels = 16;
904 quant_offset = 0;
905 } else {
906 attachLsb_flag = 0;
907 quant_levels = 8;
908 quant_offset = 0;
909 }
910 break;
911
912 default:
913 return HUFFDEC_NOTOK;
914 }
915
916 data = FDKreadBits(strm, 1);
917 pcmCoding_flag = data;
918
919 if (pcmCoding_flag) {
920 if (pair_flag) {
921 pDataVec[0] = aaDataPair[0];
922 pDataVec[1] = aaDataPair[1];
923 numValPcm = 2 * dataBands;
924 } else {
925 pDataVec[0] = aaDataPair[0];
926 pDataVec[1] = NULL;
927 numValPcm = dataBands;
928 }
929
930 err = pcm_decode(strm, pDataVec[0], pDataVec[1], quant_offset, numValPcm,
931 quant_levels);
932 if (err != HUFFDEC_OK) return HUFFDEC_NOTOK;
933
934 } else { /* Differential/Huffman/LSB Coding */
935
936 if (pair_flag) {
937 pDataVec[0] = aaDataDiff[0];
938 pDataVec[1] = aaDataDiff[1];
939 } else {
940 pDataVec[0] = aaDataDiff[0];
941 pDataVec[1] = NULL;
942 }
943
944 diff_type[0] = DIFF_FREQ;
945 diff_type[1] = DIFF_FREQ;
946
947 direction = BACKWARDS;
948 {
949 if (pair_flag || allowDiffTimeBack_flag) {
950 data = FDKreadBits(strm, 1);
951 diff_type[0] = (DIFF_TYPE)data;
952 }
953
954 if (pair_flag &&
955 ((diff_type[0] == DIFF_FREQ) || allowDiffTimeBack_flag)) {
956 data = FDKreadBits(strm, 1);
957 diff_type[1] = (DIFF_TYPE)data;
958 }
959 }
960 /* Huffman decoding */
961 err = huff_decode(strm, pDataVec[0], pDataVec[1], data_type, diff_type[0],
962 diff_type[1], dataBands, &cdg_scheme,
963 (DECODER == SAOC_DECODER));
964 if (err != HUFFDEC_OK) {
965 return HUFFDEC_NOTOK;
966 }
967
968 {
969 /* Differential decoding */
970 if ((diff_type[0] == DIFF_TIME) || (diff_type[1] == DIFF_TIME)) {
971 if (DECODER == SAOC_DECODER) {
972 direction = BACKWARDS;
973 } else {
974 if (pair_flag) {
975 if ((diff_type[0] == DIFF_TIME) && !allowDiffTimeBack_flag) {
976 direction = FORWARDS;
977 } else if (diff_type[1] == DIFF_TIME) {
978 direction = BACKWARDS;
979 } else {
980 data = FDKreadBits(strm, 1);
981 direction = (DIRECTION)data;
982 }
983 } else {
984 direction = BACKWARDS;
985 }
986 }
987 }
988
989 mixed_time_pair = (diff_type[0] != diff_type[1]) &&
990 ((cdg_scheme & PAIR_MASK) == TIME_PAIR);
991
992 if (direction == BACKWARDS) {
993 if (diff_type[0] == DIFF_FREQ) {
994 diff_freq_decode(aaDataDiff[0], aaDataPair[0], dataBands);
995 } else {
996 int i;
997 for (i = 0; i < dataBands; i++) {
998 aHistoryMsb[i] = aHistory[i + startBand] + quant_offset;
999 if (attachLsb_flag) {
1000 aHistoryMsb[i] >>= 1;
1001 }
1002 }
1003 diff_time_decode_backwards(aHistoryMsb, aaDataDiff[0], aaDataPair[0],
1004 mixed_time_pair, dataBands);
1005 }
1006 if (diff_type[1] == DIFF_FREQ) {
1007 diff_freq_decode(aaDataDiff[1], aaDataPair[1], dataBands);
1008 } else {
1009 diff_time_decode_backwards(aaDataPair[0], aaDataDiff[1],
1010 aaDataPair[1], mixed_time_pair, dataBands);
1011 }
1012 } else {
1013 /* diff_type[1] MUST BE DIFF_FREQ */
1014 diff_freq_decode(aaDataDiff[1], aaDataPair[1], dataBands);
1015
1016 if (diff_type[0] == DIFF_FREQ) {
1017 diff_freq_decode(aaDataDiff[0], aaDataPair[0], dataBands);
1018 } else {
1019 diff_time_decode_forwards(aaDataPair[1], aaDataDiff[0], aaDataPair[0],
1020 mixed_time_pair, dataBands);
1021 }
1022 }
1023 }
1024
1025 /* LSB decoding */
1026 err = attach_lsb(strm, aaDataPair[0], quant_offset, attachLsb_flag ? 1 : 0,
1027 dataBands, aaDataPair[0]);
1028 if (err != HUFFDEC_OK) goto bail;
1029
1030 if (pair_flag) {
1031 err = attach_lsb(strm, aaDataPair[1], quant_offset,
1032 attachLsb_flag ? 1 : 0, dataBands, aaDataPair[1]);
1033 if (err != HUFFDEC_OK) goto bail;
1034 }
1035 } /* End: Differential/Huffman/LSB Coding */
1036
1037 /* Copy data to output arrays */
1038 FDKmemcpy(aaOutData1 + startBand, aaDataPair[0], sizeof(SCHAR) * dataBands);
1039 if (pair_flag) {
1040 FDKmemcpy(aaOutData2 + startBand, aaDataPair[1], sizeof(SCHAR) * dataBands);
1041 }
1042
1043 bail:
1044 return err;
1045 }
1046
huff_dec_reshape(HANDLE_FDK_BITSTREAM strm,int * out_data,int num_val)1047 ERROR_t huff_dec_reshape(HANDLE_FDK_BITSTREAM strm, int* out_data,
1048 int num_val) {
1049 ERROR_t err = HUFFDEC_OK;
1050 int val_rcvd = 0, dummy = 0, i = 0, val = 0, len = 0;
1051 SCHAR rl_data[2] = {0};
1052
1053 while (val_rcvd < num_val) {
1054 err = huff_read_2D(strm,
1055 (HANDLE_HUFF_NODE)&FDK_huffReshapeNodes.nodeTab[0][0],
1056 rl_data, &dummy);
1057 if (err != HUFFDEC_OK) goto bail;
1058 val = rl_data[0];
1059 len = rl_data[1] + 1;
1060 if (val_rcvd + len > num_val) {
1061 err = HUFFDEC_NOTOK;
1062 goto bail;
1063 }
1064 for (i = val_rcvd; i < val_rcvd + len; i++) {
1065 out_data[i] = val;
1066 }
1067 val_rcvd += len;
1068 }
1069 bail:
1070 return err;
1071 }
1072