• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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,CODING_SCHEME * 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, CODING_SCHEME* 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 = (CODING_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 = (CODING_SCHEME)(*cdg_scheme | data);
606     } else {
607       *cdg_scheme = (CODING_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   CODING_SCHEME 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