开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
specrec.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：46k
源码类别：

多媒体编程

开发平台：

Visual C++

specrec.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 M. Bakker, Ahead Software AG, http://www.nero.com
  4. **  
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. ** 
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. ** 
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software 
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. **
  19. ** Any non-GPL usage of this software or parts of this software is strictly
  20. ** forbidden.
  21. **
  22. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: specrec.c,v 1.3 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. /*
  34.   Spectral reconstruction:
  35.    - grouping/sectioning
  36.    - inverse quantization
  37.    - applying scalefactors
  38. */
  40. #include "common.h"
  41. #include "structs.h"
  43. #include <string.h>
  44. #include <stdlib.h>
  45. #include "specrec.h"
  46. #include "filtbank.h"
  47. #include "syntax.h"
  48. #include "iq_table.h"
  49. #include "ms.h"
  50. #include "is.h"
  51. #include "pns.h"
  52. #include "tns.h"
  53. #include "drc.h"
  54. #include "lt_predict.h"
  55. #include "ic_predict.h"
  56. #ifdef SSR_DEC
  57. #include "ssr.h"
  58. #include "ssr_fb.h"
  59. #endif
  62. /* static function declarations */
  63. static uint8_t quant_to_spec(NeAACDecHandle hDecoder,
  64.                              ic_stream *ics, int16_t *quant_data,
  65.                              real_t *spec_data, uint16_t frame_len);
  68. #ifdef LD_DEC
  69. ALIGN static const uint8_t num_swb_512_window[] =
  70. {
  71.     0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0
  72. };
  73. ALIGN static const uint8_t num_swb_480_window[] =
  74. {
  75.     0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0
  76. };
  77. #endif
  79. ALIGN static const uint8_t num_swb_960_window[] =
  80. {
  81.     40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40
  82. };
  84. ALIGN static const uint8_t num_swb_1024_window[] =
  85. {
  86.     41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40
  87. };
  89. ALIGN static const uint8_t num_swb_128_window[] =
  90. {
  91.     12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15
  92. };
  94. ALIGN static const uint16_t swb_offset_1024_96[] =
  95. {
  96.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
  97.     64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172, 188, 212, 240,
  98.     276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024
  99. };
  101. ALIGN static const uint16_t swb_offset_128_96[] =
  102. {
  103.     0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
  104. };
  106. ALIGN static const uint16_t swb_offset_1024_64[] =
  107. {
  108.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
  109.     64, 72, 80, 88, 100, 112, 124, 140, 156, 172, 192, 216, 240, 268,
  110.     304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824,
  111.     864, 904, 944, 984, 1024
  112. };
  114. ALIGN static const uint16_t swb_offset_128_64[] =
  115. {
  116.     0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
  117. };
  119. ALIGN static const uint16_t swb_offset_1024_48[] =
  120. {
  121.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
  122.     80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
  123.     320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
  124.     768, 800, 832, 864, 896, 928, 1024
  125. };
  127. #ifdef LD_DEC
  128. ALIGN static const uint16_t swb_offset_512_48[] =
  129. {
  130.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 68, 76, 84,
  131.     92, 100, 112, 124, 136, 148, 164, 184, 208, 236, 268, 300, 332, 364, 396,
  132.     428, 460, 512
  133. };
  135. ALIGN static const uint16_t swb_offset_480_48[] =
  136. {
  137.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72 ,80 ,88,
  138.     96, 108, 120, 132, 144, 156, 172, 188, 212, 240, 272, 304, 336, 368, 400,
  139.     432, 480
  140. };
  141. #endif
  143. ALIGN static const uint16_t swb_offset_128_48[] =
  144. {
  145.     0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
  146. };
  148. ALIGN static const uint16_t swb_offset_1024_32[] =
  149. {
  150.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
  151.     80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
  152.     320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
  153.     768, 800, 832, 864, 896, 928, 960, 992, 1024
  154. };
  156. #ifdef LD_DEC
  157. ALIGN static const uint16_t swb_offset_512_32[] =
  158. {
  159.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80,
  160.     88, 96, 108, 120, 132, 144, 160, 176, 192, 212, 236, 260, 288, 320, 352,
  161.     384, 416, 448, 480, 512
  162. };
  164. ALIGN static const uint16_t swb_offset_480_32[] =
  165. {
  166.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80,
  167.     88, 96, 104, 112, 124, 136, 148, 164, 180, 200, 224, 256, 288, 320, 352,
  168.     384, 416, 448, 480
  169. };
  170. #endif
  172. ALIGN static const uint16_t swb_offset_1024_24[] =
  173. {
  174.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
  175.     76, 84, 92, 100, 108, 116, 124, 136, 148, 160, 172, 188, 204, 220,
  176.     240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704,
  177.     768, 832, 896, 960, 1024
  178. };
  180. #ifdef LD_DEC
  181. ALIGN static const uint16_t swb_offset_512_24[] =
  182. {
  183.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
  184.     80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416,
  185.     448, 480, 512
  186. };
  188. ALIGN static const uint16_t swb_offset_480_24[] =
  189. {
  190.     0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120,
  191.     140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480
  192. };
  193. #endif
  195. ALIGN static const uint16_t swb_offset_128_24[] =
  196. {
  197.     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
  198. };
  200. ALIGN static const uint16_t swb_offset_1024_16[] =
  201. {
  202.     0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124,
  203.     136, 148, 160, 172, 184, 196, 212, 228, 244, 260, 280, 300, 320, 344,
  204.     368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024
  205. };
  207. ALIGN static const uint16_t swb_offset_128_16[] =
  208. {
  209.     0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
  210. };
  212. ALIGN static const uint16_t swb_offset_1024_8[] =
  213. {
  214.     0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172,
  215.     188, 204, 220, 236, 252, 268, 288, 308, 328, 348, 372, 396, 420, 448,
  216.     476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024
  217. };
  219. ALIGN static const uint16_t swb_offset_128_8[] =
  220. {
  221.     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
  222. };
  224. ALIGN static const uint16_t *swb_offset_1024_window[] =
  225. {
  226.     swb_offset_1024_96,      /* 96000 */
  227.     swb_offset_1024_96,      /* 88200 */
  228.     swb_offset_1024_64,      /* 64000 */
  229.     swb_offset_1024_48,      /* 48000 */
  230.     swb_offset_1024_48,      /* 44100 */
  231.     swb_offset_1024_32,      /* 32000 */
  232.     swb_offset_1024_24,      /* 24000 */
  233.     swb_offset_1024_24,      /* 22050 */
  234.     swb_offset_1024_16,      /* 16000 */
  235.     swb_offset_1024_16,      /* 12000 */
  236.     swb_offset_1024_16,      /* 11025 */
  237.     swb_offset_1024_8        /* 8000  */
  238. };
  240. #ifdef LD_DEC
  241. ALIGN static const uint16_t *swb_offset_512_window[] =
  242. {
  243.     0,                       /* 96000 */
  244.     0,                       /* 88200 */
  245.     0,                       /* 64000 */
  246.     swb_offset_512_48,       /* 48000 */
  247.     swb_offset_512_48,       /* 44100 */
  248.     swb_offset_512_32,       /* 32000 */
  249.     swb_offset_512_24,       /* 24000 */
  250.     swb_offset_512_24,       /* 22050 */
  251.     0,                       /* 16000 */
  252.     0,                       /* 12000 */
  253.     0,                       /* 11025 */
  254.     0                        /* 8000  */
  255. };
  257. ALIGN static const uint16_t *swb_offset_480_window[] =
  258. {
  259.     0,                       /* 96000 */
  260.     0,                       /* 88200 */
  261.     0,                       /* 64000 */
  262.     swb_offset_480_48,       /* 48000 */
  263.     swb_offset_480_48,       /* 44100 */
  264.     swb_offset_480_32,       /* 32000 */
  265.     swb_offset_480_24,       /* 24000 */
  266.     swb_offset_480_24,       /* 22050 */
  267.     0,                       /* 16000 */
  268.     0,                       /* 12000 */
  269.     0,                       /* 11025 */
  270.     0                        /* 8000  */
  271. };
  272. #endif
  274. ALIGN static const  uint16_t *swb_offset_128_window[] =
  275. {
  276.     swb_offset_128_96,       /* 96000 */
  277.     swb_offset_128_96,       /* 88200 */
  278.     swb_offset_128_64,       /* 64000 */
  279.     swb_offset_128_48,       /* 48000 */
  280.     swb_offset_128_48,       /* 44100 */
  281.     swb_offset_128_48,       /* 32000 */
  282.     swb_offset_128_24,       /* 24000 */
  283.     swb_offset_128_24,       /* 22050 */
  284.     swb_offset_128_16,       /* 16000 */
  285.     swb_offset_128_16,       /* 12000 */
  286.     swb_offset_128_16,       /* 11025 */
  287.     swb_offset_128_8         /* 8000  */
  288. };
  290. #define bit_set(A, B) ((A) & (1<<(B)))
  292. /* 4.5.2.3.4 */
  293. /*
  294.   - determine the number of windows in a window_sequence named num_windows
  295.   - determine the number of window_groups named num_window_groups
  296.   - determine the number of windows in each group named window_group_length[g]
  297.   - determine the total number of scalefactor window bands named num_swb for
  298.     the actual window type
  299.   - determine swb_offset[swb], the offset of the first coefficient in
  300.     scalefactor window band named swb of the window actually used
  301.   - determine sect_sfb_offset[g][section],the offset of the first coefficient
  302.     in section named section. This offset depends on window_sequence and
  303.     scale_factor_grouping and is needed to decode the spectral_data().
  304. */
  305. uint8_t window_grouping_info(NeAACDecHandle hDecoder, ic_stream *ics)
  306. {
  307.     uint8_t i, g;
  309.     uint8_t sf_index = hDecoder->sf_index;
  311.     switch (ics->window_sequence) {
  312.     case ONLY_LONG_SEQUENCE:
  313.     case LONG_START_SEQUENCE:
  314.     case LONG_STOP_SEQUENCE:
  315.         ics->num_windows = 1;
  316.         ics->num_window_groups = 1;
  317.         ics->window_group_length[ics->num_window_groups-1] = 1;
  318. #ifdef LD_DEC
  319.         if (hDecoder->object_type == LD)
  320.         {
  321.             if (hDecoder->frameLength == 512)
  322.                 ics->num_swb = num_swb_512_window[sf_index];
  323.             else /* if (hDecoder->frameLength == 480) */
  324.                 ics->num_swb = num_swb_480_window[sf_index];
  325.         } else {
  326. #endif
  327.             if (hDecoder->frameLength == 1024)
  328.                 ics->num_swb = num_swb_1024_window[sf_index];
  329.             else /* if (hDecoder->frameLength == 960) */
  330.                 ics->num_swb = num_swb_960_window[sf_index];
  331. #ifdef LD_DEC
  332.         }
  333. #endif
  335.         if (ics->max_sfb > ics->num_swb)
  336.         {
  337.             return 32;
  338.         }
  340.         /* preparation of sect_sfb_offset for long blocks */
  341.         /* also copy the last value! */
  342. #ifdef LD_DEC
  343.         if (hDecoder->object_type == LD)
  344.         {
  345.             if (hDecoder->frameLength == 512)
  346.             {
  347.                 for (i = 0; i < ics->num_swb; i++)
  348.                 {
  349.                     ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
  350.                     ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
  351.                 }
  352.             } else /* if (hDecoder->frameLength == 480) */ {
  353.                 for (i = 0; i < ics->num_swb; i++)
  354.                 {
  355.                     ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
  356.                     ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
  357.                 }
  358.             }
  359.             ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
  360.             ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
  361.         } else {
  362. #endif
  363.             for (i = 0; i < ics->num_swb; i++)
  364.             {
  365.                 ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
  366.                 ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
  367.             }
  368.             ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
  369.             ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
  370. #ifdef LD_DEC
  371.         }
  372. #endif
  373.         return 0;
  374.     case EIGHT_SHORT_SEQUENCE:
  375.         ics->num_windows = 8;
  376.         ics->num_window_groups = 1;
  377.         ics->window_group_length[ics->num_window_groups-1] = 1;
  378.         ics->num_swb = num_swb_128_window[sf_index];
  380.         if (ics->max_sfb > ics->num_swb)
  381.         {
  382.             return 32;
  383.         }
  385.         for (i = 0; i < ics->num_swb; i++)
  386.             ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
  387.         ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
  389.         for (i = 0; i < ics->num_windows-1; i++) {
  390.             if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
  391.             {
  392.                 ics->num_window_groups += 1;
  393.                 ics->window_group_length[ics->num_window_groups-1] = 1;
  394.             } else {
  395.                 ics->window_group_length[ics->num_window_groups-1] += 1;
  396.             }
  397.         }
  399.         /* preparation of sect_sfb_offset for short blocks */
  400.         for (g = 0; g < ics->num_window_groups; g++)
  401.         {
  402.             uint16_t width;
  403.             uint8_t sect_sfb = 0;
  404.             uint16_t offset = 0;
  406.             for (i = 0; i < ics->num_swb; i++)
  407.             {
  408.                 if (i+1 == ics->num_swb)
  409.                 {
  410.                     width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
  411.                 } else {
  412.                     width = swb_offset_128_window[sf_index][i+1] -
  413.                         swb_offset_128_window[sf_index][i];
  414.                 }
  415.                 width *= ics->window_group_length[g];
  416.                 ics->sect_sfb_offset[g][sect_sfb++] = offset;
  417.                 offset += width;
  418.             }
  419.             ics->sect_sfb_offset[g][sect_sfb] = offset;
  420.         }
  421.         return 0;
  422.     default:
  423.         return 32;
  424.     }
  425. }
  427. /* iquant() *
  428. /* output = sign(input)*abs(input)^(4/3) */
  429. /**/
  430. static INLINE real_t iquant(int16_t q, const real_t *tab, uint8_t *error)
  431. {
  432. #ifdef FIXED_POINT
  433. /* For FIXED_POINT the iq_table is prescaled by 3 bits (iq_table[]/8) */
  434. /* BIG_IQ_TABLE allows you to use the full 8192 value table, if this is not
  435.  * defined a 1026 value table and interpolation will be used
  436.  */
  437. #ifndef BIG_IQ_TABLE
  438.     static const real_t errcorr[] = {
  439.         REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),
  440.         REAL_CONST(4.0/8.0),  REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0),
  441.         REAL_CONST(0)
  442.     };
  443.     real_t x1, x2;
  444. #endif
  445.     int16_t sgn = 1;
  447.     if (q < 0)
  448.     {
  449.         q = -q;
  450.         sgn = -1;
  451.     }
  453.     if (q < IQ_TABLE_SIZE)
  454.     {
  455. //#define IQUANT_PRINT
  456. #ifdef IQUANT_PRINT
  457.         //printf("0x%.8Xn", sgn * tab[q]);
  458.         printf("%dn", sgn * tab[q]);
  459. #endif
  460.         return sgn * tab[q];
  461.     }
  463. #ifndef BIG_IQ_TABLE
  464.     if (q >= 8192)
  465.     {
  466.         *error = 17;
  467.         return 0;
  468.     }
  470.     /* linear interpolation */
  471.     x1 = tab[q>>3];
  472.     x2 = tab[(q>>3) + 1];
  473.     return sgn * 16 * (MUL_R(errcorr[q&7],(x2-x1)) + x1);
  474. #else
  475.     *error = 17;
  476.     return 0;
  477. #endif
  479. #else
  480.     if (q < 0)
  481.     {
  482.         /* tab contains a value for all possible q [0,8192] */
  483.         if (-q < IQ_TABLE_SIZE)
  484.             return -tab[-q];
  486.         *error = 17;
  487.         return 0;
  488.     } else {
  489.         /* tab contains a value for all possible q [0,8192] */
  490.         if (q < IQ_TABLE_SIZE)
  491.             return tab[q];
  493.         *error = 17;
  494.         return 0;
  495.     }
  496. #endif
  497. }
  499. #ifndef FIXED_POINT
  500. ALIGN static const real_t pow2sf_tab[] = {
  501.     2.9802322387695313E-008, 5.9604644775390625E-008, 1.1920928955078125E-007,
  502.     2.384185791015625E-007, 4.76837158203125E-007, 9.5367431640625E-007,
  503.     1.9073486328125E-006, 3.814697265625E-006, 7.62939453125E-006,
  504.     1.52587890625E-005, 3.0517578125E-005, 6.103515625E-005,
  505.     0.0001220703125, 0.000244140625, 0.00048828125,
  506.     0.0009765625, 0.001953125, 0.00390625,
  507.     0.0078125, 0.015625, 0.03125,
  508.     0.0625, 0.125, 0.25,
  509.     0.5, 1.0, 2.0,
  510.     4.0, 8.0, 16.0, 32.0,
  511.     64.0, 128.0, 256.0,
  512.     512.0, 1024.0, 2048.0,
  513.     4096.0, 8192.0, 16384.0,
  514.     32768.0, 65536.0, 131072.0,
  515.     262144.0, 524288.0, 1048576.0,
  516.     2097152.0, 4194304.0, 8388608.0,
  517.     16777216.0, 33554432.0, 67108864.0,
  518.     134217728.0, 268435456.0, 536870912.0,
  519.     1073741824.0, 2147483648.0, 4294967296.0,
  520.     8589934592.0, 17179869184.0, 34359738368.0,
  521.     68719476736.0, 137438953472.0, 274877906944.0
  522. };
  523. #endif
  525. /* quant_to_spec: perform dequantisation and scaling
  526.  * and in case of short block it also does the deinterleaving
  527.  */
  528. /*
  529.   For ONLY_LONG_SEQUENCE windows (num_window_groups = 1,
  530.   window_group_length[0] = 1) the spectral data is in ascending spectral
  531.   order.
  532.   For the EIGHT_SHORT_SEQUENCE window, the spectral order depends on the
  533.   grouping in the following manner:
  534.   - Groups are ordered sequentially
  535.   - Within a group, a scalefactor band consists of the spectral data of all
  536.     grouped SHORT_WINDOWs for the associated scalefactor window band. To
  537.     clarify via example, the length of a group is in the range of one to eight
  538.     SHORT_WINDOWs.
  539.   - If there are eight groups each with length one (num_window_groups = 8,
  540.     window_group_length[0..7] = 1), the result is a sequence of eight spectra,
  541.     each in ascending spectral order.
  542.   - If there is only one group with length eight (num_window_groups = 1,
  543.     window_group_length[0] = 8), the result is that spectral data of all eight
  544.     SHORT_WINDOWs is interleaved by scalefactor window bands.
  545.   - Within a scalefactor window band, the coefficients are in ascending
  546.     spectral order.
  547. */
  548. static uint8_t quant_to_spec(NeAACDecHandle hDecoder,
  549.                              ic_stream *ics, int16_t *quant_data,
  550.                              real_t *spec_data, uint16_t frame_len)
  551. {
  552.     ALIGN static const real_t pow2_table[] =
  553.     {
  554.         COEF_CONST(1.0),
  555.         COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
  556.         COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
  557.         COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
  558.     };
  559.     const real_t *tab = iq_table;
  561.     uint8_t g, sfb, win;
  562.     uint16_t width, bin, k, gindex, wa, wb;
  563.     uint8_t error = 0; /* Init error flag */
  564. #ifndef FIXED_POINT
  565.     real_t scf;
  566. #endif
  568.     k = 0;
  569.     gindex = 0;
  571.     for (g = 0; g < ics->num_window_groups; g++)
  572.     {
  573.         uint16_t j = 0;
  574.         uint16_t gincrease = 0;
  575.         uint16_t win_inc = ics->swb_offset[ics->num_swb];
  577.         for (sfb = 0; sfb < ics->num_swb; sfb++)
  578.         {
  579.             int32_t exp, frac;
  581.             width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];
  583.             /* this could be scalefactor for IS or PNS, those can be negative or bigger then 255 */
  584.             /* just ignore them */
  585.             if (ics->scale_factors[g][sfb] < 0 || ics->scale_factors[g][sfb] > 255)
  586.             {
  587.                 exp = 0;
  588.                 frac = 0;
  589.             } else {
  590.                 /* ics->scale_factors[g][sfb] must be between 0 and 255 */
  591.                 exp = (ics->scale_factors[g][sfb] /* - 100 */) >> 2;
  592.                 /* frac must always be > 0 */
  593.                 frac = (ics->scale_factors[g][sfb] /* - 100 */) & 3;
  594.             }
  596. #ifdef FIXED_POINT
  597.             exp -= 25;
  598.             /* IMDCT pre-scaling */
  599.             if (hDecoder->object_type == LD)
  600.             {
  601.                 exp -= 6 /*9*/;
  602.             } else {
  603.                 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  604.                     exp -= 4 /*7*/;
  605.                 else
  606.                     exp -= 7 /*10*/;
  607.             }
  608. #endif
  610.             wa = gindex + j;
  612. #ifndef FIXED_POINT
  613.             scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac];
  614. #endif
  616.             for (win = 0; win < ics->window_group_length[g]; win++)
  617.             {
  618.                 for (bin = 0; bin < width; bin += 4)
  619.                 {
  620. #ifndef FIXED_POINT
  621.                     wb = wa + bin;
  623.                     spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;
  624.                     spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;                        
  625.                     spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;                        
  626.                     spec_data[wb+3] = iquant(quant_data[k+3], tab, &error) * scf;
  627.                         
  628. #else
  629.                     real_t iq0 = iquant(quant_data[k+0], tab, &error);
  630.                     real_t iq1 = iquant(quant_data[k+1], tab, &error);
  631.                     real_t iq2 = iquant(quant_data[k+2], tab, &error);
  632.                     real_t iq3 = iquant(quant_data[k+3], tab, &error);
  634.                     wb = wa + bin;
  636.                     if (exp < 0)
  637.                     {
  638.                         spec_data[wb+0] = iq0 >>= -exp;
  639.                         spec_data[wb+1] = iq1 >>= -exp;
  640.                         spec_data[wb+2] = iq2 >>= -exp;
  641.                         spec_data[wb+3] = iq3 >>= -exp;
  642.                     } else {
  643.                         spec_data[wb+0] = iq0 <<= exp;
  644.                         spec_data[wb+1] = iq1 <<= exp;
  645.                         spec_data[wb+2] = iq2 <<= exp;
  646.                         spec_data[wb+3] = iq3 <<= exp;
  647.                     }
  648.                     if (frac != 0)
  649.                     {
  650.                         spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]);
  651.                         spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]);
  652.                         spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]);
  653.                         spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]);
  654.                     }
  656. //#define SCFS_PRINT
  657. #ifdef SCFS_PRINT
  658.                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+0]);
  659.                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+1]);
  660.                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+2]);
  661.                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+3]);
  662.                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+0]);
  663.                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+1]);
  664.                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+2]);
  665.                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+3]);
  666. #endif
  667. #endif
  669.                     gincrease += 4;
  670.                     k += 4;
  671.                 }
  672.                 wa += win_inc;
  673.             }
  674.             j += width;
  675.         }
  676.         gindex += gincrease;
  677.     }
  679.     return error;
  680. }
  682. static uint8_t allocate_single_channel(NeAACDecHandle hDecoder, uint8_t channel,
  683.                                        uint8_t output_channels)
  684. {
  685.     uint8_t mul = 1;
  687. #ifdef MAIN_DEC
  688.     /* MAIN object type prediction */
  689.     if (hDecoder->object_type == MAIN)
  690.     {
  691.         /* allocate the state only when needed */
  692.         if (hDecoder->pred_stat[channel] != NULL)
  693.         {
  694.             faad_free(hDecoder->pred_stat[channel]);
  695.             hDecoder->pred_stat[channel] = NULL;
  696.         }
  698.         hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  699.         reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
  700.     }
  701. #endif
  703. #ifdef LTP_DEC
  704.     if (is_ltp_ot(hDecoder->object_type))
  705.     {
  706.         /* allocate the state only when needed */
  707.         if (hDecoder->lt_pred_stat[channel] != NULL)
  708.         {
  709.             faad_free(hDecoder->lt_pred_stat[channel]);
  710.             hDecoder->lt_pred_stat[channel] = NULL;
  711.         }
  713.         hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  714.         memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  715.     }
  716. #endif
  718.     if (hDecoder->time_out[channel] != NULL)
  719.     {
  720.         faad_free(hDecoder->time_out[channel]);
  721.         hDecoder->time_out[channel] = NULL;
  722.     }
  724.     {
  725.         mul = 1;
  726. #ifdef SBR_DEC
  727.         hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
  728.         if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  729.         {
  730.             /* SBR requires 2 times as much output data */
  731.             mul = 2;
  732.             hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
  733.         }
  734. #endif
  735.         hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  736.         memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  737.     }
  739. #if (defined(PS_DEC) || defined(DRM_PS))
  740.     if (output_channels == 2)
  741.     {
  742.         if (hDecoder->time_out[channel+1] != NULL)
  743.         {
  744.             faad_free(hDecoder->time_out[channel+1]);
  745.             hDecoder->time_out[channel+1] = NULL;
  746.         }
  748.         hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  749.         memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
  750.     }
  751. #endif
  753.     if (hDecoder->fb_intermed[channel] != NULL)
  754.     {
  755.         faad_free(hDecoder->fb_intermed[channel]);
  756.         hDecoder->fb_intermed[channel] = NULL;
  757.     }
  759.     hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  760.     memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
  762. #ifdef SSR_DEC
  763.     if (hDecoder->object_type == SSR)
  764.     {
  765.         if (hDecoder->ssr_overlap[channel] == NULL)
  766.         {
  767.             hDecoder->ssr_overlap[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  768.             memset(hDecoder->ssr_overlap[channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  769.         }
  770.         if (hDecoder->prev_fmd[channel] == NULL)
  771.         {
  772.             uint16_t k;
  773.             hDecoder->prev_fmd[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  774.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  775.                 hDecoder->prev_fmd[channel][k] = REAL_CONST(-1);
  776.         }
  777.     }
  778. #endif
  780.     return 0;
  781. }
  783. static uint8_t allocate_channel_pair(NeAACDecHandle hDecoder,
  784.                                      uint8_t channel, uint8_t paired_channel)
  785. {
  786.     uint8_t mul = 1;
  788. #ifdef MAIN_DEC
  789.     /* MAIN object type prediction */
  790.     if (hDecoder->object_type == MAIN)
  791.     {
  792.         /* allocate the state only when needed */
  793.         if (hDecoder->pred_stat[channel] == NULL)
  794.         {
  795.             hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  796.             reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
  797.         }
  798.         if (hDecoder->pred_stat[paired_channel] == NULL)
  799.         {
  800.             hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  801.             reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
  802.         }
  803.     }
  804. #endif
  806. #ifdef LTP_DEC
  807.     if (is_ltp_ot(hDecoder->object_type))
  808.     {
  809.         /* allocate the state only when needed */
  810.         if (hDecoder->lt_pred_stat[channel] == NULL)
  811.         {
  812.             hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  813.             memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  814.         }
  815.         if (hDecoder->lt_pred_stat[paired_channel] == NULL)
  816.         {
  817.             hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  818.             memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  819.         }
  820.     }
  821. #endif
  823.     if (hDecoder->time_out[channel] == NULL)
  824.     {
  825.         mul = 1;
  826. #ifdef SBR_DEC
  827.         hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
  828.         if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  829.         {
  830.             /* SBR requires 2 times as much output data */
  831.             mul = 2;
  832.             hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
  833.         }
  834. #endif
  835.         hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  836.         memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  837.     }
  838.     if (hDecoder->time_out[paired_channel] == NULL)
  839.     {
  840.         hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  841.         memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  842.     }
  844.     if (hDecoder->fb_intermed[channel] == NULL)
  845.     {
  846.         hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  847.         memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
  848.     }
  849.     if (hDecoder->fb_intermed[paired_channel] == NULL)
  850.     {
  851.         hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  852.         memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
  853.     }
  855. #ifdef SSR_DEC
  856.     if (hDecoder->object_type == SSR)
  857.     {
  858.         if (hDecoder->ssr_overlap[cpe->channel] == NULL)
  859.         {
  860.             hDecoder->ssr_overlap[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  861.             memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  862.         }
  863.         if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL)
  864.         {
  865.             hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  866.             memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  867.         }
  868.         if (hDecoder->prev_fmd[cpe->channel] == NULL)
  869.         {
  870.             uint16_t k;
  871.             hDecoder->prev_fmd[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  872.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  873.                 hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1);
  874.         }
  875.         if (hDecoder->prev_fmd[cpe->paired_channel] == NULL)
  876.         {
  877.             uint16_t k;
  878.             hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  879.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  880.                 hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1);
  881.         }
  882.     }
  883. #endif
  885.     return 0;
  886. }
  888. uint8_t reconstruct_single_channel(NeAACDecHandle hDecoder, ic_stream *ics,
  889.                                    element *sce, int16_t *spec_data)
  890. {
  891.     uint8_t retval, output_channels;
  892.     ALIGN real_t spec_coef[1024];
  894. #ifdef PROFILE
  895.     int64_t count = faad_get_ts();
  896. #endif
  899.     /* always allocate 2 channels, PS can always "suddenly" turn up */
  900. #if ( (defined(DRM) && defined(DRM_PS)) )
  901.     output_channels = 2;
  902. #elif defined(PS_DEC)
  903.     if (hDecoder->ps_used[hDecoder->fr_ch_ele])
  904.         output_channels = 2;
  905.     else
  906.         output_channels = 1;
  907. #endif
  909.     if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
  910.     {
  911.         /* element_output_channels not set yet */
  912.         hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
  913.     } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != output_channels) {
  914.         /* element inconsistency */
  916.         /* this only happens if PS is actually found but not in the first frame
  917.          * this means that there is only 1 bitstream element!
  918.          */
  920.         /* reset the allocation */
  921.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 0;
  923.         hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
  925.         //return 21;
  926.     }
  928.     if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
  929.     {
  930.         retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
  931.         if (retval > 0)
  932.             return retval;
  934.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
  935.     }
  938.     /* dequantisation and scaling */
  939.     retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
  940.     if (retval > 0)
  941.         return retval;
  943. #ifdef PROFILE
  944.     count = faad_get_ts() - count;
  945.     hDecoder->requant_cycles += count;
  946. #endif
  949.     /* pns decoding */
  950.     pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
  952. #ifdef MAIN_DEC
  953.     /* MAIN object type prediction */
  954.     if (hDecoder->object_type == MAIN)
  955.     {
  956.         /* intra channel prediction */
  957.         ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
  958.             hDecoder->sf_index);
  960.         /* In addition, for scalefactor bands coded by perceptual
  961.            noise substitution the predictors belonging to the
  962.            corresponding spectral coefficients are reset.
  963.         */
  964.         pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
  965.     }
  966. #endif
  968. #ifdef LTP_DEC
  969.     if (is_ltp_ot(hDecoder->object_type))
  970.     {
  971. #ifdef LD_DEC
  972.         if (hDecoder->object_type == LD)
  973.         {
  974.             if (ics->ltp.data_present)
  975.             {
  976.                 if (ics->ltp.lag_update)
  977.                     hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
  978.             }
  979.             ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
  980.         }
  981. #endif
  983.         /* long term prediction */
  984.         lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
  985.             ics->window_shape, hDecoder->window_shape_prev[sce->channel],
  986.             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
  987.     }
  988. #endif
  990.     /* tns decoding */
  991.     tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
  992.         spec_coef, hDecoder->frameLength);
  994.     /* drc decoding */
  995.     if (hDecoder->drc->present)
  996.     {
  997.         if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
  998.             drc_decode(hDecoder->drc, spec_coef);
  999.     }
  1001.     /* filter bank */
  1002. #ifdef SSR_DEC
  1003.     if (hDecoder->object_type != SSR)
  1004.     {
  1005. #endif
  1006.         ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
  1007.             hDecoder->window_shape_prev[sce->channel], spec_coef,
  1008.             hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
  1009.             hDecoder->object_type, hDecoder->frameLength);
  1010. #ifdef SSR_DEC
  1011.     } else {
  1012.         ssr_decode(&(ics->ssr), hDecoder->fb, ics->window_sequence, ics->window_shape,
  1013.             hDecoder->window_shape_prev[sce->channel], spec_coef, hDecoder->time_out[sce->channel],
  1014.             hDecoder->ssr_overlap[sce->channel], hDecoder->ipqf_buffer[sce->channel], hDecoder->prev_fmd[sce->channel],
  1015.             hDecoder->frameLength);
  1016.     }
  1017. #endif
  1019.     /* save window shape for next frame */
  1020.     hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
  1022. #ifdef LTP_DEC
  1023.     if (is_ltp_ot(hDecoder->object_type))
  1024.     {
  1025.         lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
  1026.             hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
  1027.     }
  1028. #endif
  1030. #ifdef SBR_DEC
  1031.     if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  1032.         && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
  1033.     {
  1034.         uint8_t ele = hDecoder->fr_ch_ele;
  1035.         uint8_t ch = sce->channel;
  1037.         /* following case can happen when forceUpSampling == 1 */
  1038.         if (hDecoder->sbr[ele] == NULL)
  1039.         {
  1040.             hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
  1041.                 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
  1042.                 hDecoder->downSampledSBR
  1043. #ifdef DRM
  1044.                 , 0
  1045. #endif
  1046.                 );
  1047.         }
  1049.         if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
  1050.             hDecoder->sbr[ele]->maxAACLine = 8*sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)];
  1051.         else
  1052.             hDecoder->sbr[ele]->maxAACLine = sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)];
  1054.         /* check if any of the PS tools is used */
  1055. #if (defined(PS_DEC) || defined(DRM_PS))
  1056.         if (hDecoder->ps_used[ele] == 0)
  1057.         {
  1058. #endif
  1059.             retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch],
  1060.                 hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
  1061. #if (defined(PS_DEC) || defined(DRM_PS))
  1062.         } else {
  1063.             retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
  1064.                 hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
  1065.                 hDecoder->downSampledSBR);
  1066.         }
  1067. #endif
  1068.         if (retval > 0)
  1069.             return retval;
  1070.     } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  1071.         && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
  1072.     {
  1073.         return 23;
  1074.     }
  1075. #endif
  1077.     /* copy L to R when no PS is used */
  1078. #if (defined(PS_DEC) || defined(DRM_PS))
  1079.     if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
  1080.         (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2))
  1081.     {
  1082.         uint8_t ele = hDecoder->fr_ch_ele;
  1083.         uint8_t ch = sce->channel;
  1084.         uint16_t frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1;
  1085.         frame_size *= hDecoder->frameLength*sizeof(real_t);
  1087.         memcpy(hDecoder->time_out[ch+1], hDecoder->time_out[ch], frame_size);
  1088.     }
  1089. #endif
  1091.     return 0;
  1092. }
  1094. uint8_t reconstruct_channel_pair(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
  1095.                                  element *cpe, int16_t *spec_data1, int16_t *spec_data2)
  1096. {
  1097.     uint8_t retval;
  1098.     ALIGN real_t spec_coef1[1024];
  1099.     ALIGN real_t spec_coef2[1024];
  1101. #ifdef PROFILE
  1102.     int64_t count = faad_get_ts();
  1103. #endif
  1104.     if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
  1105.     {
  1106.         retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
  1107.         if (retval > 0)
  1108.             return retval;
  1110.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
  1111.     }
  1113.     /* dequantisation and scaling */
  1114.     retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
  1115.     if (retval > 0)
  1116.         return retval;
  1117.     retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
  1118.     if (retval > 0)
  1119.         return retval;
  1121. #ifdef PROFILE
  1122.     count = faad_get_ts() - count;
  1123.     hDecoder->requant_cycles += count;
  1124. #endif
  1127.     /* pns decoding */
  1128.     if (ics1->ms_mask_present)
  1129.     {
  1130.         pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type);
  1131.     } else {
  1132.         pns_decode(ics1, NULL, spec_coef1, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
  1133.         pns_decode(ics2, NULL, spec_coef2, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
  1134.     }
  1136.     /* mid/side decoding */
  1137.     ms_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
  1139. #if 0
  1140.     {
  1141.         int i;
  1142.         for (i = 0; i < 1024; i++)
  1143.         {
  1144.             //printf("%dn", spec_coef1[i]);
  1145.             printf("0x%.8Xn", spec_coef1[i]);
  1146.         }
  1147.         for (i = 0; i < 1024; i++)
  1148.         {
  1149.             //printf("%dn", spec_coef2[i]);
  1150.             printf("0x%.8Xn", spec_coef2[i]);
  1151.         }
  1152.     }
  1153. #endif
  1155.     /* intensity stereo decoding */
  1156.     is_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
  1158. #if 0
  1159.     {
  1160.         int i;
  1161.         for (i = 0; i < 1024; i++)
  1162.         {
  1163.             printf("%dn", spec_coef1[i]);
  1164.             //printf("0x%.8Xn", spec_coef1[i]);
  1165.         }
  1166.         for (i = 0; i < 1024; i++)
  1167.         {
  1168.             printf("%dn", spec_coef2[i]);
  1169.             //printf("0x%.8Xn", spec_coef2[i]);
  1170.         }
  1171.     }
  1172. #endif
  1174. #ifdef MAIN_DEC
  1175.     /* MAIN object type prediction */
  1176.     if (hDecoder->object_type == MAIN)
  1177.     {
  1178.         /* intra channel prediction */
  1179.         ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
  1180.             hDecoder->sf_index);
  1181.         ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
  1182.             hDecoder->sf_index);
  1184.         /* In addition, for scalefactor bands coded by perceptual
  1185.            noise substitution the predictors belonging to the
  1186.            corresponding spectral coefficients are reset.
  1187.         */
  1188.         pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
  1189.         pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
  1190.     }
  1191. #endif
  1193. #ifdef LTP_DEC
  1194.     if (is_ltp_ot(hDecoder->object_type))
  1195.     {
  1196.         ltp_info *ltp1 = &(ics1->ltp);
  1197.         ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
  1198. #ifdef LD_DEC
  1199.         if (hDecoder->object_type == LD)
  1200.         {
  1201.             if (ltp1->data_present)
  1202.             {
  1203.                 if (ltp1->lag_update)
  1204.                     hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
  1205.             }
  1206.             ltp1->lag = hDecoder->ltp_lag[cpe->channel];
  1207.             if (ltp2->data_present)
  1208.             {
  1209.                 if (ltp2->lag_update)
  1210.                     hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
  1211.             }
  1212.             ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
  1213.         }
  1214. #endif
  1216.         /* long term prediction */
  1217.         lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
  1218.             ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
  1219.             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
  1220.         lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
  1221.             ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
  1222.             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
  1223.     }
  1224. #endif
  1226.     /* tns decoding */
  1227.     tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
  1228.         spec_coef1, hDecoder->frameLength);
  1229.     tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
  1230.         spec_coef2, hDecoder->frameLength);
  1232.     /* drc decoding */
  1233.     if (hDecoder->drc->present)
  1234.     {
  1235.         if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
  1236.             drc_decode(hDecoder->drc, spec_coef1);
  1237.         if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
  1238.             drc_decode(hDecoder->drc, spec_coef2);
  1239.     }
  1241.     /* filter bank */
  1242. #ifdef SSR_DEC
  1243.     if (hDecoder->object_type != SSR)
  1244.     {
  1245. #endif
  1246.         ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
  1247.             hDecoder->window_shape_prev[cpe->channel], spec_coef1,
  1248.             hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
  1249.             hDecoder->object_type, hDecoder->frameLength);
  1250.         ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
  1251.             hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
  1252.             hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
  1253.             hDecoder->object_type, hDecoder->frameLength);
  1254. #ifdef SSR_DEC
  1255.     } else {
  1256.         ssr_decode(&(ics1->ssr), hDecoder->fb, ics1->window_sequence, ics1->window_shape,
  1257.             hDecoder->window_shape_prev[cpe->channel], spec_coef1, hDecoder->time_out[cpe->channel],
  1258.             hDecoder->ssr_overlap[cpe->channel], hDecoder->ipqf_buffer[cpe->channel],
  1259.             hDecoder->prev_fmd[cpe->channel], hDecoder->frameLength);
  1260.         ssr_decode(&(ics2->ssr), hDecoder->fb, ics2->window_sequence, ics2->window_shape,
  1261.             hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2, hDecoder->time_out[cpe->paired_channel],
  1262.             hDecoder->ssr_overlap[cpe->paired_channel], hDecoder->ipqf_buffer[cpe->paired_channel],
  1263.             hDecoder->prev_fmd[cpe->paired_channel], hDecoder->frameLength);
  1264.     }
  1265. #endif
  1267.     /* save window shape for next frame */
  1268.     hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
  1269.     hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
  1271. #ifdef LTP_DEC
  1272.     if (is_ltp_ot(hDecoder->object_type))
  1273.     {
  1274.         lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
  1275.             hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
  1276.         lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
  1277.             hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
  1278.     }
  1279. #endif
  1281. #ifdef SBR_DEC
  1282.     if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  1283.         && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
  1284.     {
  1285.         uint8_t ele = hDecoder->fr_ch_ele;
  1286.         uint8_t ch0 = cpe->channel;
  1287.         uint8_t ch1 = cpe->paired_channel;
  1289.         /* following case can happen when forceUpSampling == 1 */
  1290.         if (hDecoder->sbr[ele] == NULL)
  1291.         {
  1292.             hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
  1293.                 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
  1294.                 hDecoder->downSampledSBR
  1295. #ifdef DRM
  1296.                 , 0
  1297. #endif
  1298.                 );
  1299.         }
  1301.         if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
  1302.             hDecoder->sbr[ele]->maxAACLine = 8*cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)];
  1303.         else
  1304.             hDecoder->sbr[ele]->maxAACLine = cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)];
  1306.         retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
  1307.             hDecoder->time_out[ch0], hDecoder->time_out[ch1],
  1308.             hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
  1309.         if (retval > 0)
  1310.             return retval;
  1311.     } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  1312.         && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
  1313.     {
  1314.         return 23;
  1315.     }
  1316. #endif
  1318.     return 0;
  1319. }