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

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

多媒体编程

开发平台：

Visual C++

ps_dec.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: ps_dec.c,v 1.3 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. #include "common.h"
  35. #ifdef PS_DEC
  37. #include <stdlib.h>
  38. #include "ps_dec.h"
  39. #include "ps_tables.h"
  41. /* constants */
  42. #define NEGATE_IPD_MASK            (0x1000)
  43. #define DECAY_SLOPE                FRAC_CONST(0.05)
  44. #define COEF_SQRT2                 COEF_CONST(1.4142135623731)
  46. /* tables */
  47. /* filters are mirrored in coef 6, second half left out */
  48. static const real_t p8_13_20[7] =
  49. {
  50.     FRAC_CONST(0.00746082949812),
  51.     FRAC_CONST(0.02270420949825),
  52.     FRAC_CONST(0.04546865930473),
  53.     FRAC_CONST(0.07266113929591),
  54.     FRAC_CONST(0.09885108575264),
  55.     FRAC_CONST(0.11793710567217),
  56.     FRAC_CONST(0.125)
  57. };
  59. static const real_t p2_13_20[7] =
  60. {
  61.     FRAC_CONST(0.0),
  62.     FRAC_CONST(0.01899487526049),
  63.     FRAC_CONST(0.0),
  64.     FRAC_CONST(-0.07293139167538),
  65.     FRAC_CONST(0.0),
  66.     FRAC_CONST(0.30596630545168),
  67.     FRAC_CONST(0.5)
  68. };
  70. static const real_t p12_13_34[7] =
  71. {
  72.     FRAC_CONST(0.04081179924692),
  73.     FRAC_CONST(0.03812810994926),
  74.     FRAC_CONST(0.05144908135699),
  75.     FRAC_CONST(0.06399831151592),
  76.     FRAC_CONST(0.07428313801106),
  77.     FRAC_CONST(0.08100347892914),
  78.     FRAC_CONST(0.08333333333333)
  79. };
  81. static const real_t p8_13_34[7] =
  82. {
  83.     FRAC_CONST(0.01565675600122),
  84.     FRAC_CONST(0.03752716391991),
  85.     FRAC_CONST(0.05417891378782),
  86.     FRAC_CONST(0.08417044116767),
  87.     FRAC_CONST(0.10307344158036),
  88.     FRAC_CONST(0.12222452249753),
  89.     FRAC_CONST(0.125)
  90. };
  92. static const real_t p4_13_34[7] =
  93. {
  94.     FRAC_CONST(-0.05908211155639),
  95.     FRAC_CONST(-0.04871498374946),
  96.     FRAC_CONST(0.0),
  97.     FRAC_CONST(0.07778723915851),
  98.     FRAC_CONST(0.16486303567403),
  99.     FRAC_CONST(0.23279856662996),
  100.     FRAC_CONST(0.25)
  101. };
  103. #ifdef PARAM_32KHZ
  104. static const uint8_t delay_length_d[2][NO_ALLPASS_LINKS] = {
  105.     { 1, 2, 3 } /* d_24kHz */,
  106.     { 3, 4, 5 } /* d_48kHz */
  107. };
  108. #else
  109. static const uint8_t delay_length_d[NO_ALLPASS_LINKS] = {
  110.     3, 4, 5 /* d_48kHz */
  111. };
  112. #endif
  113. static const real_t filter_a[NO_ALLPASS_LINKS] = { /* a(m) = exp(-d_48kHz(m)/7) */
  114.     FRAC_CONST(0.65143905753106),
  115.     FRAC_CONST(0.56471812200776),
  116.     FRAC_CONST(0.48954165955695)
  117. };
  119. static const uint8_t group_border20[10+12 + 1] =
  120. {
  121.     6, 7, 0, 1, 2, 3, /* 6 subqmf subbands */
  122.     9, 8,             /* 2 subqmf subbands */
  123.     10, 11,           /* 2 subqmf subbands */
  124.     3, 4, 5, 6, 7, 8, 9, 11, 14, 18, 23, 35, 64
  125. };
  127. static const uint8_t group_border34[32+18 + 1] =
  128. {
  129.      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, /* 12 subqmf subbands */
  130.      12, 13, 14, 15, 16, 17, 18, 19,                 /*  8 subqmf subbands */
  131.      20, 21, 22, 23,                                 /*  4 subqmf subbands */
  132.      24, 25, 26, 27,                                 /*  4 subqmf subbands */
  133.      28, 29, 30, 31,                                 /*  4 subqmf subbands */
  134.      32-27, 33-27, 34-27, 35-27, 36-27, 37-27, 38-27, 40-27, 42-27, 44-27, 46-27, 48-27, 51-27, 54-27, 57-27, 60-27, 64-27, 68-27, 91-27
  135. };
  137. static const uint16_t map_group2bk20[10+12] =
  138. {
  139.     (NEGATE_IPD_MASK | 1), (NEGATE_IPD_MASK | 0),
  140.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
  141. };
  143. static const uint16_t map_group2bk34[32+18] =
  144. {
  145.     0,  1,  2,  3,  4,  5,  6,  6,  7, (NEGATE_IPD_MASK | 2), (NEGATE_IPD_MASK | 1), (NEGATE_IPD_MASK | 0),
  146.     10, 10, 4,  5,  6,  7,  8,  9,
  147.     10, 11, 12, 9,
  148.     14, 11, 12, 13,
  149.     14, 15, 16, 13,
  150.     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33
  151. };
  153. /* type definitions */
  154. typedef struct
  155. {
  156.     uint8_t frame_len;
  157.     uint8_t resolution20[3];
  158.     uint8_t resolution34[5];
  160.     qmf_t *work;
  161.     qmf_t **buffer;
  162.     qmf_t **temp;
  163. } hyb_info;
  165. /* static function declarations */
  166. static void ps_data_decode(ps_info *ps);
  167. static hyb_info *hybrid_init();
  168. static void channel_filter2(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  169.                             qmf_t *buffer, qmf_t **X_hybrid);
  170. static void INLINE DCT3_4_unscaled(real_t *y, real_t *x);
  171. static void channel_filter8(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  172.                             qmf_t *buffer, qmf_t **X_hybrid);
  173. static void hybrid_analysis(hyb_info *hyb, qmf_t X[32][64], qmf_t X_hybrid[32][32],
  174.                             uint8_t use34);
  175. static void hybrid_synthesis(hyb_info *hyb, qmf_t X[32][64], qmf_t X_hybrid[32][32],
  176.                              uint8_t use34);
  177. static int8_t delta_clip(int8_t i, int8_t min, int8_t max);
  178. static void delta_decode(uint8_t enable, int8_t *index, int8_t *index_prev,
  179.                          uint8_t dt_flag, uint8_t nr_par, uint8_t stride,
  180.                          int8_t min_index, int8_t max_index);
  181. static void delta_modulo_decode(uint8_t enable, int8_t *index, int8_t *index_prev,
  182.                                 uint8_t dt_flag, uint8_t nr_par, uint8_t stride,
  183.                                 int8_t and_modulo);
  184. static void map20indexto34(int8_t *index, uint8_t bins);
  185. #ifdef PS_LOW_POWER
  186. static void map34indexto20(int8_t *index, uint8_t bins);
  187. #endif
  188. static void ps_data_decode(ps_info *ps);
  189. static void ps_decorrelate(ps_info *ps, qmf_t X_left[38][64], qmf_t X_right[38][64],
  190.                            qmf_t X_hybrid_left[32][32], qmf_t X_hybrid_right[32][32]);
  191. static void ps_mix_phase(ps_info *ps, qmf_t X_left[38][64], qmf_t X_right[38][64],
  192.                          qmf_t X_hybrid_left[32][32], qmf_t X_hybrid_right[32][32]);
  194. /*  */
  197. static hyb_info *hybrid_init()
  198. {
  199.     uint8_t i;
  201.     hyb_info *hyb = (hyb_info*)faad_malloc(sizeof(hyb_info));
  203.     hyb->resolution34[0] = 12;
  204.     hyb->resolution34[1] = 8;
  205.     hyb->resolution34[2] = 4;
  206.     hyb->resolution34[3] = 4;
  207.     hyb->resolution34[4] = 4;
  209.     hyb->resolution20[0] = 8;
  210.     hyb->resolution20[1] = 2;
  211.     hyb->resolution20[2] = 2;
  213.     hyb->frame_len = 32;
  215.     hyb->work = (qmf_t*)faad_malloc((hyb->frame_len+12) * sizeof(qmf_t));
  216.     memset(hyb->work, 0, (hyb->frame_len+12) * sizeof(qmf_t));
  218.     hyb->buffer = (qmf_t**)faad_malloc(5 * sizeof(qmf_t*));
  219.     for (i = 0; i < 5; i++)
  220.     {
  221.         hyb->buffer[i] = (qmf_t*)faad_malloc(hyb->frame_len * sizeof(qmf_t));
  222.         memset(hyb->buffer[i], 0, hyb->frame_len * sizeof(qmf_t));
  223.     }
  225.     hyb->temp = (qmf_t**)faad_malloc(hyb->frame_len * sizeof(qmf_t*));
  226.     for (i = 0; i < hyb->frame_len; i++)
  227.     {
  228.         hyb->temp[i] = (qmf_t*)faad_malloc(12 /*max*/ * sizeof(qmf_t));
  229.     }
  231.     return hyb;
  232. }
  234. static void hybrid_free(hyb_info *hyb)
  235. {
  236.     uint8_t i;
  238.     if (hyb->work)
  239.         faad_free(hyb->work);
  241.     for (i = 0; i < 5; i++)
  242.     {
  243.         if (hyb->buffer[i])
  244.             faad_free(hyb->buffer[i]);
  245.     }
  246.     if (hyb->buffer)
  247.         faad_free(hyb->buffer);
  249.     for (i = 0; i < hyb->frame_len; i++)
  250.     {
  251.         if (hyb->temp[i])
  252.             faad_free(hyb->temp[i]);
  253.     }
  254.     if (hyb->temp)
  255.         faad_free(hyb->temp);
  256. }
  258. /* real filter, size 2 */
  259. static void channel_filter2(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  260.                             qmf_t *buffer, qmf_t **X_hybrid)
  261. {
  262.     uint8_t i;
  264.     for (i = 0; i < frame_len; i++)
  265.     {
  266.         real_t r0 = MUL_F(filter[0],(QMF_RE(buffer[0+i]) + QMF_RE(buffer[12+i])));
  267.         real_t r1 = MUL_F(filter[1],(QMF_RE(buffer[1+i]) + QMF_RE(buffer[11+i])));
  268.         real_t r2 = MUL_F(filter[2],(QMF_RE(buffer[2+i]) + QMF_RE(buffer[10+i])));
  269.         real_t r3 = MUL_F(filter[3],(QMF_RE(buffer[3+i]) + QMF_RE(buffer[9+i])));
  270.         real_t r4 = MUL_F(filter[4],(QMF_RE(buffer[4+i]) + QMF_RE(buffer[8+i])));
  271.         real_t r5 = MUL_F(filter[5],(QMF_RE(buffer[5+i]) + QMF_RE(buffer[7+i])));
  272.         real_t r6 = MUL_F(filter[6],QMF_RE(buffer[6+i]));
  273.         real_t i0 = MUL_F(filter[0],(QMF_IM(buffer[0+i]) + QMF_IM(buffer[12+i])));
  274.         real_t i1 = MUL_F(filter[1],(QMF_IM(buffer[1+i]) + QMF_IM(buffer[11+i])));
  275.         real_t i2 = MUL_F(filter[2],(QMF_IM(buffer[2+i]) + QMF_IM(buffer[10+i])));
  276.         real_t i3 = MUL_F(filter[3],(QMF_IM(buffer[3+i]) + QMF_IM(buffer[9+i])));
  277.         real_t i4 = MUL_F(filter[4],(QMF_IM(buffer[4+i]) + QMF_IM(buffer[8+i])));
  278.         real_t i5 = MUL_F(filter[5],(QMF_IM(buffer[5+i]) + QMF_IM(buffer[7+i])));
  279.         real_t i6 = MUL_F(filter[6],QMF_IM(buffer[6+i]));
  281.         /* q = 0 */
  282.         QMF_RE(X_hybrid[i][0]) = r0 + r1 + r2 + r3 + r4 + r5 + r6;
  283.         QMF_IM(X_hybrid[i][0]) = i0 + i1 + i2 + i3 + i4 + i5 + i6;
  285.         /* q = 1 */
  286.         QMF_RE(X_hybrid[i][1]) = r0 - r1 + r2 - r3 + r4 - r5 + r6;
  287.         QMF_IM(X_hybrid[i][1]) = i0 - i1 + i2 - i3 + i4 - i5 + i6;
  288.     }
  289. }
  291. /* complex filter, size 4 */
  292. static void channel_filter4(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  293.                             qmf_t *buffer, qmf_t **X_hybrid)
  294. {
  295.     uint8_t i;
  296.     real_t input_re1[2], input_re2[2], input_im1[2], input_im2[2];
  298.     for (i = 0; i < frame_len; i++)
  299.     {
  300.         input_re1[0] = -MUL_F(filter[2], (QMF_RE(buffer[i+2]) + QMF_RE(buffer[i+10]))) +
  301.             MUL_F(filter[6], QMF_RE(buffer[i+6]));
  302.         input_re1[1] = MUL_F(FRAC_CONST(-0.70710678118655),
  303.             (MUL_F(filter[1], (QMF_RE(buffer[i+1]) + QMF_RE(buffer[i+11]))) +
  304.             MUL_F(filter[3], (QMF_RE(buffer[i+3]) + QMF_RE(buffer[i+9]))) -
  305.             MUL_F(filter[5], (QMF_RE(buffer[i+5]) + QMF_RE(buffer[i+7])))));
  307.         input_im1[0] = MUL_F(filter[0], (QMF_IM(buffer[i+0]) - QMF_IM(buffer[i+12]))) -
  308.             MUL_F(filter[4], (QMF_IM(buffer[i+4]) - QMF_IM(buffer[i+8])));
  309.         input_im1[1] = MUL_F(FRAC_CONST(0.70710678118655),
  310.             (MUL_F(filter[1], (QMF_IM(buffer[i+1]) - QMF_IM(buffer[i+11]))) -
  311.             MUL_F(filter[3], (QMF_IM(buffer[i+3]) - QMF_IM(buffer[i+9]))) -
  312.             MUL_F(filter[5], (QMF_IM(buffer[i+5]) - QMF_IM(buffer[i+7])))));
  314.         input_re2[0] = MUL_F(filter[0], (QMF_RE(buffer[i+0]) - QMF_RE(buffer[i+12]))) -
  315.             MUL_F(filter[4], (QMF_RE(buffer[i+4]) - QMF_RE(buffer[i+8])));
  316.         input_re2[1] = MUL_F(FRAC_CONST(0.70710678118655),
  317.             (MUL_F(filter[1], (QMF_RE(buffer[i+1]) - QMF_RE(buffer[i+11]))) -
  318.             MUL_F(filter[3], (QMF_RE(buffer[i+3]) - QMF_RE(buffer[i+9]))) -
  319.             MUL_F(filter[5], (QMF_RE(buffer[i+5]) - QMF_RE(buffer[i+7])))));
  321.         input_im2[0] = -MUL_F(filter[2], (QMF_IM(buffer[i+2]) + QMF_IM(buffer[i+10]))) +
  322.             MUL_F(filter[6], QMF_IM(buffer[i+6]));
  323.         input_im2[1] = MUL_F(FRAC_CONST(-0.70710678118655),
  324.             (MUL_F(filter[1], (QMF_IM(buffer[i+1]) + QMF_IM(buffer[i+11]))) +
  325.             MUL_F(filter[3], (QMF_IM(buffer[i+3]) + QMF_IM(buffer[i+9]))) -
  326.             MUL_F(filter[5], (QMF_IM(buffer[i+5]) + QMF_IM(buffer[i+7])))));
  328.         /* q == 0 */
  329.         QMF_RE(X_hybrid[i][0]) =  input_re1[0] + input_re1[1] + input_im1[0] + input_im1[1];
  330.         QMF_IM(X_hybrid[i][0]) = -input_re2[0] - input_re2[1] + input_im2[0] + input_im2[1];
  332.         /* q == 1 */
  333.         QMF_RE(X_hybrid[i][1]) =  input_re1[0] - input_re1[1] - input_im1[0] + input_im1[1];
  334.         QMF_IM(X_hybrid[i][1]) =  input_re2[0] - input_re2[1] + input_im2[0] - input_im2[1];
  336.         /* q == 2 */
  337.         QMF_RE(X_hybrid[i][2]) =  input_re1[0] - input_re1[1] + input_im1[0] - input_im1[1];
  338.         QMF_IM(X_hybrid[i][2]) = -input_re2[0] + input_re2[1] + input_im2[0] - input_im2[1];
  340.         /* q == 3 */
  341.         QMF_RE(X_hybrid[i][3]) =  input_re1[0] + input_re1[1] - input_im1[0] - input_im1[1];
  342.         QMF_IM(X_hybrid[i][3]) =  input_re2[0] + input_re2[1] + input_im2[0] + input_im2[1];
  343.     }
  344. }
  346. static void INLINE DCT3_4_unscaled(real_t *y, real_t *x)
  347. {
  348.     real_t f0, f1, f2, f3, f4, f5, f6, f7, f8;
  350.     f0 = MUL_F(x[2], FRAC_CONST(0.7071067811865476));
  351.     f1 = x[0] - f0;
  352.     f2 = x[0] + f0;
  353.     f3 = x[1] + x[3];
  354.     f4 = MUL_C(x[1], COEF_CONST(1.3065629648763766));
  355.     f5 = MUL_F(f3, FRAC_CONST(-0.9238795325112866));
  356.     f6 = MUL_F(x[3], FRAC_CONST(-0.5411961001461967));
  357.     f7 = f4 + f5;
  358.     f8 = f6 - f5;
  359.     y[3] = f2 - f8;
  360.     y[0] = f2 + f8;
  361.     y[2] = f1 - f7;
  362.     y[1] = f1 + f7;
  363. }
  365. /* complex filter, size 8 */
  366. static void channel_filter8(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  367.                             qmf_t *buffer, qmf_t **X_hybrid)
  368. {
  369.     uint8_t i, n;
  370.     real_t input_re1[4], input_re2[4], input_im1[4], input_im2[4];
  371.     real_t x[4];
  373.     for (i = 0; i < frame_len; i++)
  374.     {
  375.         input_re1[0] =  MUL_F(filter[6],QMF_RE(buffer[6+i]));
  376.         input_re1[1] =  MUL_F(filter[5],(QMF_RE(buffer[5+i]) + QMF_RE(buffer[7+i])));
  377.         input_re1[2] = -MUL_F(filter[0],(QMF_RE(buffer[0+i]) + QMF_RE(buffer[12+i]))) + MUL_F(filter[4],(QMF_RE(buffer[4+i]) + QMF_RE(buffer[8+i])));
  378.         input_re1[3] = -MUL_F(filter[1],(QMF_RE(buffer[1+i]) + QMF_RE(buffer[11+i]))) + MUL_F(filter[3],(QMF_RE(buffer[3+i]) + QMF_RE(buffer[9+i])));
  380.         input_im1[0] = MUL_F(filter[5],(QMF_IM(buffer[7+i]) - QMF_IM(buffer[5+i])));
  381.         input_im1[1] = MUL_F(filter[0],(QMF_IM(buffer[12+i]) - QMF_IM(buffer[0+i]))) + MUL_F(filter[4],(QMF_IM(buffer[8+i]) - QMF_IM(buffer[4+i])));
  382.         input_im1[2] = MUL_F(filter[1],(QMF_IM(buffer[11+i]) - QMF_IM(buffer[1+i]))) + MUL_F(filter[3],(QMF_IM(buffer[9+i]) - QMF_IM(buffer[3+i])));
  383.         input_im1[3] = MUL_F(filter[2],(QMF_IM(buffer[10+i]) - QMF_IM(buffer[2+i])));
  385.         for (n = 0; n < 4; n++)
  386.         {
  387.             x[n] = input_re1[n] - input_im1[3-n];
  388.         }
  389.         DCT3_4_unscaled(x, x);
  390.         QMF_RE(X_hybrid[i][7]) = x[0];
  391.         QMF_RE(X_hybrid[i][5]) = x[2];
  392.         QMF_RE(X_hybrid[i][3]) = x[3];
  393.         QMF_RE(X_hybrid[i][1]) = x[1];
  395.         for (n = 0; n < 4; n++)
  396.         {
  397.             x[n] = input_re1[n] + input_im1[3-n];
  398.         }
  399.         DCT3_4_unscaled(x, x);
  400.         QMF_RE(X_hybrid[i][6]) = x[1];
  401.         QMF_RE(X_hybrid[i][4]) = x[3];
  402.         QMF_RE(X_hybrid[i][2]) = x[2];
  403.         QMF_RE(X_hybrid[i][0]) = x[0];
  405.         input_im2[0] =  MUL_F(filter[6],QMF_IM(buffer[6+i]));
  406.         input_im2[1] =  MUL_F(filter[5],(QMF_IM(buffer[5+i]) + QMF_IM(buffer[7+i])));
  407.         input_im2[2] = -MUL_F(filter[0],(QMF_IM(buffer[0+i]) + QMF_IM(buffer[12+i]))) + MUL_F(filter[4],(QMF_IM(buffer[4+i]) + QMF_IM(buffer[8+i])));
  408.         input_im2[3] = -MUL_F(filter[1],(QMF_IM(buffer[1+i]) + QMF_IM(buffer[11+i]))) + MUL_F(filter[3],(QMF_IM(buffer[3+i]) + QMF_IM(buffer[9+i])));
  410.         input_re2[0] = MUL_F(filter[5],(QMF_RE(buffer[7+i]) - QMF_RE(buffer[5+i])));
  411.         input_re2[1] = MUL_F(filter[0],(QMF_RE(buffer[12+i]) - QMF_RE(buffer[0+i]))) + MUL_F(filter[4],(QMF_RE(buffer[8+i]) - QMF_RE(buffer[4+i])));
  412.         input_re2[2] = MUL_F(filter[1],(QMF_RE(buffer[11+i]) - QMF_RE(buffer[1+i]))) + MUL_F(filter[3],(QMF_RE(buffer[9+i]) - QMF_RE(buffer[3+i])));
  413.         input_re2[3] = MUL_F(filter[2],(QMF_RE(buffer[10+i]) - QMF_RE(buffer[2+i])));
  415.         for (n = 0; n < 4; n++)
  416.         {
  417.             x[n] = input_im2[n] + input_re2[3-n];
  418.         }
  419.         DCT3_4_unscaled(x, x);
  420.         QMF_IM(X_hybrid[i][7]) = x[0];
  421.         QMF_IM(X_hybrid[i][5]) = x[2];
  422.         QMF_IM(X_hybrid[i][3]) = x[3];
  423.         QMF_IM(X_hybrid[i][1]) = x[1];
  425.         for (n = 0; n < 4; n++)
  426.         {
  427.             x[n] = input_im2[n] - input_re2[3-n];
  428.         }
  429.         DCT3_4_unscaled(x, x);
  430.         QMF_IM(X_hybrid[i][6]) = x[1];
  431.         QMF_IM(X_hybrid[i][4]) = x[3];
  432.         QMF_IM(X_hybrid[i][2]) = x[2];
  433.         QMF_IM(X_hybrid[i][0]) = x[0];
  434.     }
  435. }
  437. static void INLINE DCT3_6_unscaled(real_t *y, real_t *x)
  438. {
  439.     real_t f0, f1, f2, f3, f4, f5, f6, f7;
  441.     f0 = MUL_F(x[3], FRAC_CONST(0.70710678118655));
  442.     f1 = x[0] + f0;
  443.     f2 = x[0] - f0;
  444.     f3 = MUL_F((x[1] - x[5]), FRAC_CONST(0.70710678118655));
  445.     f4 = MUL_F(x[2], FRAC_CONST(0.86602540378444)) + MUL_F(x[4], FRAC_CONST(0.5));
  446.     f5 = f4 - x[4];
  447.     f6 = MUL_F(x[1], FRAC_CONST(0.96592582628907)) + MUL_F(x[5], FRAC_CONST(0.25881904510252));
  448.     f7 = f6 - f3;
  449.     y[0] = f1 + f6 + f4;
  450.     y[1] = f2 + f3 - x[4];
  451.     y[2] = f7 + f2 - f5;
  452.     y[3] = f1 - f7 - f5;
  453.     y[4] = f1 - f3 - x[4];
  454.     y[5] = f2 - f6 + f4;
  455. }
  457. /* complex filter, size 12 */
  458. static void channel_filter12(hyb_info *hyb, uint8_t frame_len, const real_t *filter,
  459.                              qmf_t *buffer, qmf_t **X_hybrid)
  460. {
  461.     uint8_t i, n;
  462.     real_t input_re1[6], input_re2[6], input_im1[6], input_im2[6];
  463.     real_t out_re1[6], out_re2[6], out_im1[6], out_im2[6];
  465.     for (i = 0; i < frame_len; i++)
  466.     {
  467.         for (n = 0; n < 6; n++)
  468.         {
  469.             if (n == 0)
  470.             {
  471.                 input_re1[0] = MUL_F(QMF_RE(buffer[6+i]), filter[6]);
  472.                 input_re2[0] = MUL_F(QMF_IM(buffer[6+i]), filter[6]);
  473.             } else {
  474.                 input_re1[6-n] = MUL_F((QMF_RE(buffer[n+i]) + QMF_RE(buffer[12-n+i])), filter[n]);
  475.                 input_re2[6-n] = MUL_F((QMF_IM(buffer[n+i]) + QMF_IM(buffer[12-n+i])), filter[n]);
  476.             }
  477.             input_im2[n] = MUL_F((QMF_RE(buffer[n+i]) - QMF_RE(buffer[12-n+i])), filter[n]);
  478.             input_im1[n] = MUL_F((QMF_IM(buffer[n+i]) - QMF_IM(buffer[12-n+i])), filter[n]);
  479.         }
  481.         DCT3_6_unscaled(out_re1, input_re1);
  482.         DCT3_6_unscaled(out_re2, input_re2);
  484.         DCT3_6_unscaled(out_im1, input_im1);
  485.         DCT3_6_unscaled(out_im2, input_im2);
  487.         for (n = 0; n < 6; n += 2)
  488.         {
  489.             QMF_RE(X_hybrid[i][n]) = out_re1[n] - out_im1[n];
  490.             QMF_IM(X_hybrid[i][n]) = out_re2[n] + out_im2[n];
  491.             QMF_RE(X_hybrid[i][n+1]) = out_re1[n+1] + out_im1[n+1];
  492.             QMF_IM(X_hybrid[i][n+1]) = out_re2[n+1] - out_im2[n+1];
  494.             QMF_RE(X_hybrid[i][10-n]) = out_re1[n+1] - out_im1[n+1];
  495.             QMF_IM(X_hybrid[i][10-n]) = out_re2[n+1] + out_im2[n+1];
  496.             QMF_RE(X_hybrid[i][11-n]) = out_re1[n] + out_im1[n];
  497.             QMF_IM(X_hybrid[i][11-n]) = out_re2[n] - out_im2[n];
  498.         }
  499.     }
  500. }
  502. /* Hybrid analysis: further split up QMF subbands
  503.  * to improve frequency resolution
  504.  */
  505. static void hybrid_analysis(hyb_info *hyb, qmf_t X[32][64], qmf_t X_hybrid[32][32],
  506.                             uint8_t use34)
  507. {
  508.     uint8_t k, n, band;
  509.     uint8_t offset = 0;
  510.     uint8_t qmf_bands = (use34) ? 5 : 3;
  511.     uint8_t *resolution = (use34) ? hyb->resolution34 : hyb->resolution20;
  513.     for (band = 0; band < qmf_bands; band++)
  514.     {
  515.         /* build working buffer */
  516.         memcpy(hyb->work, hyb->buffer[band], 12 * sizeof(qmf_t));
  518.         /* add new samples */
  519.         for (n = 0; n < hyb->frame_len; n++)
  520.         {
  521.             QMF_RE(hyb->work[12 + n]) = QMF_RE(X[n + 6 /*delay*/][band]);
  522.             QMF_IM(hyb->work[12 + n]) = QMF_IM(X[n + 6 /*delay*/][band]);
  523.         }
  525.         /* store samples */
  526.         memcpy(hyb->buffer[band], hyb->work + hyb->frame_len, 12 * sizeof(qmf_t));
  529.         switch(resolution[band])
  530.         {
  531.         case 2:
  532.             /* Type B real filter, Q[p] = 2 */
  533.             channel_filter2(hyb, hyb->frame_len, p2_13_20, hyb->work, hyb->temp);
  534.             break;
  535.         case 4:
  536.             /* Type A complex filter, Q[p] = 4 */
  537.             channel_filter4(hyb, hyb->frame_len, p4_13_34, hyb->work, hyb->temp);
  538.             break;
  539.         case 8:
  540.             /* Type A complex filter, Q[p] = 8 */
  541.             channel_filter8(hyb, hyb->frame_len, (use34) ? p8_13_34 : p8_13_20,
  542.                 hyb->work, hyb->temp);
  543.             break;
  544.         case 12:
  545.             /* Type A complex filter, Q[p] = 12 */
  546.             channel_filter12(hyb, hyb->frame_len, p12_13_34, hyb->work, hyb->temp);
  547.             break;
  548.         }
  550.         for (n = 0; n < hyb->frame_len; n++)
  551.         {
  552.             for (k = 0; k < resolution[band]; k++)
  553.             {
  554.                 QMF_RE(X_hybrid[n][offset + k]) = QMF_RE(hyb->temp[n][k]);
  555.                 QMF_IM(X_hybrid[n][offset + k]) = QMF_IM(hyb->temp[n][k]);
  556.             }
  557.         }
  558.         offset += resolution[band];
  559.     }
  561.     /* group hybrid channels */
  562.     if (!use34)
  563.     {
  564.         for (n = 0; n < 32 /*30?*/; n++)
  565.         {
  566.             QMF_RE(X_hybrid[n][3]) += QMF_RE(X_hybrid[n][4]);
  567.             QMF_IM(X_hybrid[n][3]) += QMF_IM(X_hybrid[n][4]);
  568.             QMF_RE(X_hybrid[n][4]) = 0;
  569.             QMF_IM(X_hybrid[n][4]) = 0;
  571.             QMF_RE(X_hybrid[n][2]) += QMF_RE(X_hybrid[n][5]);
  572.             QMF_IM(X_hybrid[n][2]) += QMF_IM(X_hybrid[n][5]);
  573.             QMF_RE(X_hybrid[n][5]) = 0;
  574.             QMF_IM(X_hybrid[n][5]) = 0;
  575.         }
  576.     }
  577. }
  579. static void hybrid_synthesis(hyb_info *hyb, qmf_t X[32][64], qmf_t X_hybrid[32][32],
  580.                              uint8_t use34)
  581. {
  582.     uint8_t k, n, band;
  583.     uint8_t offset = 0;
  584.     uint8_t qmf_bands = (use34) ? 5 : 3;
  585.     uint8_t *resolution = (use34) ? hyb->resolution34 : hyb->resolution20;
  587.     for(band = 0; band < qmf_bands; band++)
  588.     {
  589.         for (n = 0; n < hyb->frame_len; n++)
  590.         {
  591.             QMF_RE(X[n][band]) = 0;
  592.             QMF_IM(X[n][band]) = 0;
  594.             for (k = 0; k < resolution[band]; k++)
  595.             {
  596.                 QMF_RE(X[n][band]) += QMF_RE(X_hybrid[n][offset + k]);
  597.                 QMF_IM(X[n][band]) += QMF_IM(X_hybrid[n][offset + k]);
  598.             }
  599.         }
  600.         offset += resolution[band];
  601.     }
  602. }
  604. /* limits the value i to the range [min,max] */
  605. static int8_t delta_clip(int8_t i, int8_t min, int8_t max)
  606. {
  607.     if (i < min)
  608.         return min;
  609.     else if (i > max)
  610.         return max;
  611.     else
  612.         return i;
  613. }
  615. //int iid = 0;
  617. /* delta decode array */
  618. static void delta_decode(uint8_t enable, int8_t *index, int8_t *index_prev,
  619.                          uint8_t dt_flag, uint8_t nr_par, uint8_t stride,
  620.                          int8_t min_index, int8_t max_index)
  621. {
  622.     int8_t i;
  624.     if (enable == 1)
  625.     {
  626.         if (dt_flag == 0)
  627.         {
  628.             /* delta coded in frequency direction */
  629.             index[0] = 0 + index[0];
  630.             index[0] = delta_clip(index[0], min_index, max_index);
  632.             for (i = 1; i < nr_par; i++)
  633.             {
  634.                 index[i] = index[i-1] + index[i];
  635.                 index[i] = delta_clip(index[i], min_index, max_index);
  636.             }
  637.         } else {
  638.             /* delta coded in time direction */
  639.             for (i = 0; i < nr_par; i++)
  640.             {
  641.                 //int8_t tmp2;
  642.                 //int8_t tmp = index[i];
  644.                 //printf("%d %dn", index_prev[i*stride], index[i]);
  645.                 //printf("%dn", index[i]);
  647.                 index[i] = index_prev[i*stride] + index[i];
  648.                 //tmp2 = index[i];
  649.                 index[i] = delta_clip(index[i], min_index, max_index);
  651.                 //if (iid)
  652.                 //{
  653.                 //    if (index[i] == 7)
  654.                 //    {
  655.                 //        printf("%d %d %dn", index_prev[i*stride], tmp, tmp2);
  656.                 //    }
  657.                 //}
  658.             }
  659.         }
  660.     } else {
  661.         /* set indices to zero */
  662.         for (i = 0; i < nr_par; i++)
  663.         {
  664.             index[i] = 0;
  665.         }
  666.     }
  668.     /* coarse */
  669.     if (stride == 2)
  670.     {
  671.         for (i = (nr_par<<1)-1; i > 0; i--)
  672.         {
  673.             index[i] = index[i>>1];
  674.         }
  675.     }
  676. }
  678. /* delta modulo decode array */
  679. /* in: log2 value of the modulo value to allow using AND instead of MOD */
  680. static void delta_modulo_decode(uint8_t enable, int8_t *index, int8_t *index_prev,
  681.                                 uint8_t dt_flag, uint8_t nr_par, uint8_t stride,
  682.                                 int8_t and_modulo)
  683. {
  684.     int8_t i;
  686.     if (enable == 1)
  687.     {
  688.         if (dt_flag == 0)
  689.         {
  690.             /* delta coded in frequency direction */
  691.             index[0] = 0 + index[0];
  692.             index[0] &= and_modulo;
  694.             for (i = 1; i < nr_par; i++)
  695.             {
  696.                 index[i] = index[i-1] + index[i];
  697.                 index[i] &= and_modulo;
  698.             }
  699.         } else {
  700.             /* delta coded in time direction */
  701.             for (i = 0; i < nr_par; i++)
  702.             {
  703.                 index[i] = index_prev[i*stride] + index[i];
  704.                 index[i] &= and_modulo;
  705.             }
  706.         }
  707.     } else {
  708.         /* set indices to zero */
  709.         for (i = 0; i < nr_par; i++)
  710.         {
  711.             index[i] = 0;
  712.         }
  713.     }
  715.     /* coarse */
  716.     if (stride == 2)
  717.     {
  718.         index[0] = 0;
  719.         for (i = (nr_par<<1)-1; i > 0; i--)
  720.         {
  721.             index[i] = index[i>>1];
  722.         }
  723.     }
  724. }
  726. #ifdef PS_LOW_POWER
  727. static void map34indexto20(int8_t *index, uint8_t bins)
  728. {
  729.     index[0] = (2*index[0]+index[1])/3;
  730.     index[1] = (index[1]+2*index[2])/3;
  731.     index[2] = (2*index[3]+index[4])/3;
  732.     index[3] = (index[4]+2*index[5])/3;
  733.     index[4] = (index[6]+index[7])/2;
  734.     index[5] = (index[8]+index[9])/2;
  735.     index[6] = index[10];
  736.     index[7] = index[11];
  737.     index[8] = (index[12]+index[13])/2;
  738.     index[9] = (index[14]+index[15])/2;
  739.     index[10] = index[16];
  741.     if (bins == 34)
  742.     {
  743.         index[11] = index[17];
  744.         index[12] = index[18];
  745.         index[13] = index[19];
  746.         index[14] = (index[20]+index[21])/2;
  747.         index[15] = (index[22]+index[23])/2;
  748.         index[16] = (index[24]+index[25])/2;
  749.         index[17] = (index[26]+index[27])/2;
  750.         index[18] = (index[28]+index[29]+index[30]+index[31])/4;
  751.         index[19] = (index[32]+index[33])/2;
  752.     }
  753. }
  754. #endif
  756. static void map20indexto34(int8_t *index, uint8_t bins)
  757. {
  758.     index[0] = index[0];
  759.     index[1] = (index[0] + index[1])/2;
  760.     index[2] = index[1];
  761.     index[3] = index[2];
  762.     index[4] = (index[2] + index[3])/2;
  763.     index[5] = index[3];
  764.     index[6] = index[4];
  765.     index[7] = index[4];
  766.     index[8] = index[5];
  767.     index[9] = index[5];
  768.     index[10] = index[6];
  769.     index[11] = index[7];
  770.     index[12] = index[8];
  771.     index[13] = index[8];
  772.     index[14] = index[9];
  773.     index[15] = index[9];
  774.     index[16] = index[10];
  776.     if (bins == 34)
  777.     {
  778.         index[17] = index[11];
  779.         index[18] = index[12];
  780.         index[19] = index[13];
  781.         index[20] = index[14];
  782.         index[21] = index[14];
  783.         index[22] = index[15];
  784.         index[23] = index[15];
  785.         index[24] = index[16];
  786.         index[25] = index[16];
  787.         index[26] = index[17];
  788.         index[27] = index[17];
  789.         index[28] = index[18];
  790.         index[29] = index[18];
  791.         index[30] = index[18];
  792.         index[31] = index[18];
  793.         index[32] = index[19];
  794.         index[33] = index[19];
  795.     }
  796. }
  798. /* parse the bitstream data decoded in ps_data() */
  799. static void ps_data_decode(ps_info *ps)
  800. {
  801.     uint8_t env, bin;
  803.     /* ps data not available, use data from previous frame */
  804.     if (ps->ps_data_available == 0)
  805.     {
  806.         ps->num_env = 0;
  807.     }
  809.     for (env = 0; env < ps->num_env; env++)
  810.     {
  811.         int8_t *iid_index_prev;
  812.         int8_t *icc_index_prev;
  813.         int8_t *ipd_index_prev;
  814.         int8_t *opd_index_prev;
  816.         int8_t num_iid_steps = (ps->iid_mode < 3) ? 7 : 15 /*fine quant*/;
  818.         if (env == 0)
  819.         {
  820.             /* take last envelope from previous frame */
  821.             iid_index_prev = ps->iid_index_prev;
  822.             icc_index_prev = ps->icc_index_prev;
  823.             ipd_index_prev = ps->ipd_index_prev;
  824.             opd_index_prev = ps->opd_index_prev;
  825.         } else {
  826.             /* take index values from previous envelope */
  827.             iid_index_prev = ps->iid_index[env - 1];
  828.             icc_index_prev = ps->icc_index[env - 1];
  829.             ipd_index_prev = ps->ipd_index[env - 1];
  830.             opd_index_prev = ps->opd_index[env - 1];
  831.         }
  833. //        iid = 1;
  834.         /* delta decode iid parameters */
  835.         delta_decode(ps->enable_iid, ps->iid_index[env], iid_index_prev,
  836.             ps->iid_dt[env], ps->nr_iid_par,
  837.             (ps->iid_mode == 0 || ps->iid_mode == 3) ? 2 : 1,
  838.             -num_iid_steps, num_iid_steps);
  839. //        iid = 0;
  841.         /* delta decode icc parameters */
  842.         delta_decode(ps->enable_icc, ps->icc_index[env], icc_index_prev,
  843.             ps->icc_dt[env], ps->nr_icc_par,
  844.             (ps->icc_mode == 0 || ps->icc_mode == 3) ? 2 : 1,
  845.             0, 7);
  847.         /* delta modulo decode ipd parameters */
  848.         delta_modulo_decode(ps->enable_ipdopd, ps->ipd_index[env], ipd_index_prev,
  849.             ps->ipd_dt[env], ps->nr_ipdopd_par, 1, 7);
  851.         /* delta modulo decode opd parameters */
  852.         delta_modulo_decode(ps->enable_ipdopd, ps->opd_index[env], opd_index_prev,
  853.             ps->opd_dt[env], ps->nr_ipdopd_par, 1, 7);
  854.     }
  856.     /* handle error case */
  857.     if (ps->num_env == 0)
  858.     {
  859.         /* force to 1 */
  860.         ps->num_env = 1;
  862.         if (ps->enable_iid)
  863.         {
  864.             for (bin = 0; bin < 34; bin++)
  865.                 ps->iid_index[0][bin] = ps->iid_index_prev[bin];
  866.         } else {
  867.             for (bin = 0; bin < 34; bin++)
  868.                 ps->iid_index[0][bin] = 0;
  869.         }
  871.         if (ps->enable_icc)
  872.         {
  873.             for (bin = 0; bin < 34; bin++)
  874.                 ps->icc_index[0][bin] = ps->icc_index_prev[bin];
  875.         } else {
  876.             for (bin = 0; bin < 34; bin++)
  877.                 ps->icc_index[0][bin] = 0;
  878.         }
  880.         if (ps->enable_ipdopd)
  881.         {
  882.             for (bin = 0; bin < 17; bin++)
  883.             {
  884.                 ps->ipd_index[0][bin] = ps->ipd_index_prev[bin];
  885.                 ps->opd_index[0][bin] = ps->opd_index_prev[bin];
  886.             }
  887.         } else {
  888.             for (bin = 0; bin < 17; bin++)
  889.             {
  890.                 ps->ipd_index[0][bin] = 0;
  891.                 ps->opd_index[0][bin] = 0;
  892.             }
  893.         }
  894.     }
  896.     /* update previous indices */
  897.     for (bin = 0; bin < 34; bin++)
  898.         ps->iid_index_prev[bin] = ps->iid_index[ps->num_env-1][bin];
  899.     for (bin = 0; bin < 34; bin++)
  900.         ps->icc_index_prev[bin] = ps->icc_index[ps->num_env-1][bin];
  901.     for (bin = 0; bin < 17; bin++)
  902.     {
  903.         ps->ipd_index_prev[bin] = ps->ipd_index[ps->num_env-1][bin];
  904.         ps->opd_index_prev[bin] = ps->opd_index[ps->num_env-1][bin];
  905.     }
  907.     ps->ps_data_available = 0;
  909.     if (ps->frame_class == 0)
  910.     {
  911.         ps->border_position[0] = 0;
  912.         for (env = 1; env < ps->num_env; env++)
  913.         {
  914.             ps->border_position[env] = (env * 32 /* 30 for 960? */) / ps->num_env;
  915.         }
  916.         ps->border_position[ps->num_env] = 32 /* 30 for 960? */;
  917.     } else {
  918.         ps->border_position[0] = 0;
  920.         if (ps->border_position[ps->num_env] < 32 /* 30 for 960? */)
  921.         {
  922.             ps->num_env++;
  923.             ps->border_position[ps->num_env] = 32 /* 30 for 960? */;
  924.             for (bin = 0; bin < 34; bin++)
  925.             {
  926.                 ps->iid_index[ps->num_env][bin] = ps->iid_index[ps->num_env-1][bin];
  927.                 ps->icc_index[ps->num_env][bin] = ps->icc_index[ps->num_env-1][bin];
  928.             }
  929.             for (bin = 0; bin < 17; bin++)
  930.             {
  931.                 ps->ipd_index[ps->num_env][bin] = ps->ipd_index[ps->num_env-1][bin];
  932.                 ps->opd_index[ps->num_env][bin] = ps->opd_index[ps->num_env-1][bin];
  933.             }
  934.         }
  936.         for (env = 1; env < ps->num_env; env++)
  937.         {
  938.             int8_t thr = 32 /* 30 for 960? */ - (ps->num_env - env);
  940.             if (ps->border_position[env] > thr)
  941.             {
  942.                 ps->border_position[env] = thr;
  943.             } else {
  944.                 thr = ps->border_position[env-1]+1;
  945.                 if (ps->border_position[env] < thr)
  946.                 {
  947.                     ps->border_position[env] = thr;
  948.                 }
  949.             }
  950.         }
  951.     }
  953.     /* make sure that the indices of all parameters can be mapped
  954.      * to the same hybrid synthesis filterbank
  955.      */
  956. #ifdef PS_LOW_POWER
  957.     for (env = 0; env < ps->num_env; env++)
  958.     {
  959.         if (ps->iid_mode == 2 || ps->iid_mode == 5)
  960.             map34indexto20(ps->iid_index[env], 34);
  961.         if (ps->icc_mode == 2 || ps->icc_mode == 5)
  962.             map34indexto20(ps->icc_index[env], 34);
  964.         /* disable ipd/opd */
  965.         for (bin = 0; bin < 17; bin++)
  966.         {
  967.             ps->aaIpdIndex[env][bin] = 0;
  968.             ps->aaOpdIndex[env][bin] = 0;
  969.         }
  970.     }
  971. #else
  972.     if (ps->use34hybrid_bands)
  973.     {
  974.         for (env = 0; env < ps->num_env; env++)
  975.         {
  976.             if (ps->iid_mode != 2 && ps->iid_mode != 5)
  977.                 map20indexto34(ps->iid_index[env], 34);
  978.             if (ps->icc_mode != 2 && ps->icc_mode != 5)
  979.                 map20indexto34(ps->icc_index[env], 34);
  980.             if (ps->ipd_mode != 2 && ps->ipd_mode != 5)
  981.             {
  982.                 map20indexto34(ps->ipd_index[env], 17);
  983.                 map20indexto34(ps->opd_index[env], 17);
  984.             }
  985.         }
  986.     }
  987. #endif
  989. #if 0
  990.     for (env = 0; env < ps->num_env; env++)
  991.     {
  992.         printf("iid[env:%d]:", env);
  993.         for (bin = 0; bin < 34; bin++)
  994.         {
  995.             printf(" %d", ps->iid_index[env][bin]);
  996.         }
  997.         printf("n");
  998.     }
  999.     for (env = 0; env < ps->num_env; env++)
  1000.     {
  1001.         printf("icc[env:%d]:", env);
  1002.         for (bin = 0; bin < 34; bin++)
  1003.         {
  1004.             printf(" %d", ps->icc_index[env][bin]);
  1005.         }
  1006.         printf("n");
  1007.     }
  1008.     for (env = 0; env < ps->num_env; env++)
  1009.     {
  1010.         printf("ipd[env:%d]:", env);
  1011.         for (bin = 0; bin < 17; bin++)
  1012.         {
  1013.             printf(" %d", ps->ipd_index[env][bin]);
  1014.         }
  1015.         printf("n");
  1016.     }
  1017.     for (env = 0; env < ps->num_env; env++)
  1018.     {
  1019.         printf("opd[env:%d]:", env);
  1020.         for (bin = 0; bin < 17; bin++)
  1021.         {
  1022.             printf(" %d", ps->opd_index[env][bin]);
  1023.         }
  1024.         printf("n");
  1025.     }
  1026.     printf("n");
  1027. #endif
  1028. }
  1030. /* decorrelate the mono signal using an allpass filter */
  1031. static void ps_decorrelate(ps_info *ps, qmf_t X_left[38][64], qmf_t X_right[38][64],
  1032.                            qmf_t X_hybrid_left[32][32], qmf_t X_hybrid_right[32][32])
  1033. {
  1034.     uint8_t gr, n, m, bk;
  1035.     uint8_t temp_delay;
  1036.     uint8_t sb, maxsb;
  1037.     const complex_t *Phi_Fract_SubQmf;
  1038.     uint8_t temp_delay_ser[NO_ALLPASS_LINKS];
  1039.     real_t P_SmoothPeakDecayDiffNrg, nrg;
  1040.     real_t P[32][34];
  1041.     real_t G_TransientRatio[32][34] = {{0}};
  1042.     complex_t inputLeft;
  1045.     /* chose hybrid filterbank: 20 or 34 band case */
  1046.     if (ps->use34hybrid_bands)
  1047.     {
  1048.         Phi_Fract_SubQmf = Phi_Fract_SubQmf34;
  1049.     } else{
  1050.         Phi_Fract_SubQmf = Phi_Fract_SubQmf20;
  1051.     }
  1053.     /* clear the energy values */
  1054.     for (n = 0; n < 32; n++)
  1055.     {
  1056.         for (bk = 0; bk < 34; bk++)
  1057.         {
  1058.             P[n][bk] = 0;
  1059.         }
  1060.     }
  1062.     /* calculate the energy in each parameter band b(k) */
  1063.     for (gr = 0; gr < ps->num_groups; gr++)
  1064.     {
  1065.         /* select the parameter index b(k) to which this group belongs */
  1066.         bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr];
  1068.         /* select the upper subband border for this group */
  1069.         maxsb = (gr < ps->num_hybrid_groups) ? ps->group_border[gr]+1 : ps->group_border[gr+1];
  1071.         for (sb = ps->group_border[gr]; sb < maxsb; sb++)
  1072.         {
  1073.             for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++)
  1074.             {
  1075. #ifdef FIXED_POINT
  1076.                 uint32_t in_re, in_im;
  1077. #endif
  1079.                 /* input from hybrid subbands or QMF subbands */
  1080.                 if (gr < ps->num_hybrid_groups)
  1081.                 {
  1082.                     RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]);
  1083.                     IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]);
  1084.                 } else {
  1085.                     RE(inputLeft) = QMF_RE(X_left[n][sb]);
  1086.                     IM(inputLeft) = QMF_IM(X_left[n][sb]);
  1087.                 }
  1089.                 /* accumulate energy */
  1090. #ifdef FIXED_POINT
  1091.                 /* NOTE: all input is scaled by 2^(-5) because of fixed point QMF
  1092.                  * meaning that P will be scaled by 2^(-10) compared to floating point version
  1093.                  */
  1094.                 in_re = ((abs(RE(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS);
  1095.                 in_im = ((abs(IM(inputLeft))+(1<<(REAL_BITS-1)))>>REAL_BITS);
  1096.                 P[n][bk] += in_re*in_re + in_im*in_im;
  1097. #else
  1098.                 P[n][bk] += MUL_R(RE(inputLeft),RE(inputLeft)) + MUL_R(IM(inputLeft),IM(inputLeft));
  1099. #endif
  1100.             }
  1101.         }
  1102.     }
  1104. #if 0
  1105.     for (n = 0; n < 32; n++)
  1106.     {
  1107.         for (bk = 0; bk < 34; bk++)
  1108.         {
  1109. #ifdef FIXED_POINT
  1110.             printf("%d %d: %dn", n, bk, P[n][bk] /*/(float)REAL_PRECISION*/);
  1111. #else
  1112.             printf("%d %d: %fn", n, bk, P[n][bk]/1024.0);
  1113. #endif
  1114.         }
  1115.     }
  1116. #endif
  1118.     /* calculate transient reduction ratio for each parameter band b(k) */
  1119.     for (bk = 0; bk < ps->nr_par_bands; bk++)
  1120.     {
  1121.         for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++)
  1122.         {
  1123.             const real_t gamma = COEF_CONST(1.5);
  1125.             ps->P_PeakDecayNrg[bk] = MUL_F(ps->P_PeakDecayNrg[bk], ps->alpha_decay);
  1126.             if (ps->P_PeakDecayNrg[bk] < P[n][bk])
  1127.                 ps->P_PeakDecayNrg[bk] = P[n][bk];
  1129.             /* apply smoothing filter to peak decay energy */
  1130.             P_SmoothPeakDecayDiffNrg = ps->P_SmoothPeakDecayDiffNrg_prev[bk];
  1131.             P_SmoothPeakDecayDiffNrg += MUL_F((ps->P_PeakDecayNrg[bk] - P[n][bk] - ps->P_SmoothPeakDecayDiffNrg_prev[bk]), ps->alpha_smooth);
  1132.             ps->P_SmoothPeakDecayDiffNrg_prev[bk] = P_SmoothPeakDecayDiffNrg;
  1134.             /* apply smoothing filter to energy */
  1135.             nrg = ps->P_prev[bk];
  1136.             nrg += MUL_F((P[n][bk] - ps->P_prev[bk]), ps->alpha_smooth);
  1137.             ps->P_prev[bk] = nrg;
  1139.             /* calculate transient ratio */
  1140.             if (MUL_C(P_SmoothPeakDecayDiffNrg, gamma) <= nrg)
  1141.             {
  1142.                 G_TransientRatio[n][bk] = REAL_CONST(1.0);
  1143.             } else {
  1144.                 G_TransientRatio[n][bk] = DIV_R(nrg, (MUL_C(P_SmoothPeakDecayDiffNrg, gamma)));
  1145.             }
  1146.         }
  1147.     }
  1149. #if 0
  1150.     for (n = 0; n < 32; n++)
  1151.     {
  1152.         for (bk = 0; bk < 34; bk++)
  1153.         {
  1154. #ifdef FIXED_POINT
  1155.             printf("%d %d: %fn", n, bk, G_TransientRatio[n][bk]/(float)REAL_PRECISION);
  1156. #else
  1157.             printf("%d %d: %fn", n, bk, G_TransientRatio[n][bk]);
  1158. #endif
  1159.         }
  1160.     }
  1161. #endif
  1163.     /* apply stereo decorrelation filter to the signal */
  1164.     for (gr = 0; gr < ps->num_groups; gr++)
  1165.     {
  1166.         if (gr < ps->num_hybrid_groups)
  1167.             maxsb = ps->group_border[gr] + 1;
  1168.         else
  1169.             maxsb = ps->group_border[gr + 1];
  1171.         /* QMF channel */
  1172.         for (sb = ps->group_border[gr]; sb < maxsb; sb++)
  1173.         {
  1174.             real_t g_DecaySlope;
  1175.             real_t g_DecaySlope_filt[NO_ALLPASS_LINKS];
  1177.             /* g_DecaySlope: [0..1] */
  1178.             if (gr < ps->num_hybrid_groups || sb <= ps->decay_cutoff)
  1179.             {
  1180.                 g_DecaySlope = FRAC_CONST(1.0);
  1181.             } else {
  1182.                 int8_t decay = ps->decay_cutoff - sb;
  1183.                 if (decay <= -20 /* -1/DECAY_SLOPE */)
  1184.                 {
  1185.                     g_DecaySlope = 0;
  1186.                 } else {
  1187.                     /* decay(int)*decay_slope(frac) = g_DecaySlope(frac) */
  1188.                     g_DecaySlope = FRAC_CONST(1.0) + DECAY_SLOPE * decay;
  1189.                 }
  1190.             }
  1192.             /* calculate g_DecaySlope_filt for every m multiplied by filter_a[m] */
  1193.             for (m = 0; m < NO_ALLPASS_LINKS; m++)
  1194.             {
  1195.                 g_DecaySlope_filt[m] = MUL_F(g_DecaySlope, filter_a[m]);
  1196.             }
  1199.             /* set delay indices */
  1200.             temp_delay = ps->saved_delay;
  1201.             for (n = 0; n < NO_ALLPASS_LINKS; n++)
  1202.                 temp_delay_ser[n] = ps->delay_buf_index_ser[n];
  1204.             for (n = ps->border_position[0]; n < ps->border_position[ps->num_env]; n++)
  1205.             {
  1206.                 complex_t tmp, tmp0, R0;
  1208.                 if (gr < ps->num_hybrid_groups)
  1209.                 {
  1210.                     /* hybrid filterbank input */
  1211.                     RE(inputLeft) = QMF_RE(X_hybrid_left[n][sb]);
  1212.                     IM(inputLeft) = QMF_IM(X_hybrid_left[n][sb]);
  1213.                 } else {
  1214.                     /* QMF filterbank input */
  1215.                     RE(inputLeft) = QMF_RE(X_left[n][sb]);
  1216.                     IM(inputLeft) = QMF_IM(X_left[n][sb]);
  1217.                 }
  1219.                 if (sb > ps->nr_allpass_bands && gr >= ps->num_hybrid_groups)
  1220.                 {
  1221.                     /* delay */
  1223.                     /* never hybrid subbands here, always QMF subbands */
  1224.                     RE(tmp) = RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]);
  1225.                     IM(tmp) = IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]);
  1226.                     RE(R0) = RE(tmp);
  1227.                     IM(R0) = IM(tmp);
  1228.                     RE(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = RE(inputLeft);
  1229.                     IM(ps->delay_Qmf[ps->delay_buf_index_delay[sb]][sb]) = IM(inputLeft);
  1230.                 } else {
  1231.                     /* allpass filter */
  1232.                     uint8_t m;
  1233.                     complex_t Phi_Fract;
  1235.                     /* fetch parameters */
  1236.                     if (gr < ps->num_hybrid_groups)
  1237.                     {
  1238.                         /* select data from the hybrid subbands */
  1239.                         RE(tmp0) = RE(ps->delay_SubQmf[temp_delay][sb]);
  1240.                         IM(tmp0) = IM(ps->delay_SubQmf[temp_delay][sb]);
  1242.                         RE(ps->delay_SubQmf[temp_delay][sb]) = RE(inputLeft);
  1243.                         IM(ps->delay_SubQmf[temp_delay][sb]) = IM(inputLeft);
  1245.                         RE(Phi_Fract) = RE(Phi_Fract_SubQmf[sb]);
  1246.                         IM(Phi_Fract) = IM(Phi_Fract_SubQmf[sb]);
  1247.                     } else {
  1248.                         /* select data from the QMF subbands */
  1249.                         RE(tmp0) = RE(ps->delay_Qmf[temp_delay][sb]);
  1250.                         IM(tmp0) = IM(ps->delay_Qmf[temp_delay][sb]);
  1252.                         RE(ps->delay_Qmf[temp_delay][sb]) = RE(inputLeft);
  1253.                         IM(ps->delay_Qmf[temp_delay][sb]) = IM(inputLeft);
  1255.                         RE(Phi_Fract) = RE(Phi_Fract_Qmf[sb]);
  1256.                         IM(Phi_Fract) = IM(Phi_Fract_Qmf[sb]);
  1257.                     }
  1259.                     /* z^(-2) * Phi_Fract[k] */
  1260.                     ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Phi_Fract), IM(Phi_Fract));
  1262.                     RE(R0) = RE(tmp);
  1263.                     IM(R0) = IM(tmp);
  1264.                     for (m = 0; m < NO_ALLPASS_LINKS; m++)
  1265.                     {
  1266.                         complex_t Q_Fract_allpass, tmp2;
  1268.                         /* fetch parameters */
  1269.                         if (gr < ps->num_hybrid_groups)
  1270.                         {
  1271.                             /* select data from the hybrid subbands */
  1272.                             RE(tmp0) = RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]);
  1273.                             IM(tmp0) = IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]);
  1275.                             if (ps->use34hybrid_bands)
  1276.                             {
  1277.                                 RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf34[sb][m]);
  1278.                                 IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf34[sb][m]);
  1279.                             } else {
  1280.                                 RE(Q_Fract_allpass) = RE(Q_Fract_allpass_SubQmf20[sb][m]);
  1281.                                 IM(Q_Fract_allpass) = IM(Q_Fract_allpass_SubQmf20[sb][m]);
  1282.                             }
  1283.                         } else {
  1284.                             /* select data from the QMF subbands */
  1285.                             RE(tmp0) = RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]);
  1286.                             IM(tmp0) = IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]);
  1288.                             RE(Q_Fract_allpass) = RE(Q_Fract_allpass_Qmf[sb][m]);
  1289.                             IM(Q_Fract_allpass) = IM(Q_Fract_allpass_Qmf[sb][m]);
  1290.                         }
  1292.                         /* delay by a fraction */
  1293.                         /* z^(-d(m)) * Q_Fract_allpass[k,m] */
  1294.                         ComplexMult(&RE(tmp), &IM(tmp), RE(tmp0), IM(tmp0), RE(Q_Fract_allpass), IM(Q_Fract_allpass));
  1296.                         /* -a(m) * g_DecaySlope[k] */
  1297.                         RE(tmp) += -MUL_F(g_DecaySlope_filt[m], RE(R0));
  1298.                         IM(tmp) += -MUL_F(g_DecaySlope_filt[m], IM(R0));
  1300.                         /* -a(m) * g_DecaySlope[k] * Q_Fract_allpass[k,m] * z^(-d(m)) */
  1301.                         RE(tmp2) = RE(R0) + MUL_F(g_DecaySlope_filt[m], RE(tmp));
  1302.                         IM(tmp2) = IM(R0) + MUL_F(g_DecaySlope_filt[m], IM(tmp));
  1304.                         /* store sample */
  1305.                         if (gr < ps->num_hybrid_groups)
  1306.                         {
  1307.                             RE(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2);
  1308.                             IM(ps->delay_SubQmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2);
  1309.                         } else {
  1310.                             RE(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = RE(tmp2);
  1311.                             IM(ps->delay_Qmf_ser[m][temp_delay_ser[m]][sb]) = IM(tmp2);
  1312.                         }
  1314.                         /* store for next iteration (or as output value if last iteration) */
  1315.                         RE(R0) = RE(tmp);
  1316.                         IM(R0) = IM(tmp);
  1317.                     }
  1318.                 }
  1320.                 /* select b(k) for reading the transient ratio */
  1321.                 bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr];
  1323.                 /* duck if a past transient is found */
  1324.                 RE(R0) = MUL_R(G_TransientRatio[n][bk], RE(R0));
  1325.                 IM(R0) = MUL_R(G_TransientRatio[n][bk], IM(R0));
  1327.                 if (gr < ps->num_hybrid_groups)
  1328.                 {
  1329.                     /* hybrid */
  1330.                     QMF_RE(X_hybrid_right[n][sb]) = RE(R0);
  1331.                     QMF_IM(X_hybrid_right[n][sb]) = IM(R0);
  1332.                 } else {
  1333.                     /* QMF */
  1334.                     QMF_RE(X_right[n][sb]) = RE(R0);
  1335.                     QMF_IM(X_right[n][sb]) = IM(R0);
  1336.                 }
  1338.                 /* Update delay buffer index */
  1339.                 if (++temp_delay >= 2)
  1340.                 {
  1341.                     temp_delay = 0;
  1342.                 }
  1344.                 /* update delay indices */
  1345.                 if (sb > ps->nr_allpass_bands && gr >= ps->num_hybrid_groups)
  1346.                 {
  1347.                     /* delay_D depends on the samplerate, it can hold the values 14 and 1 */
  1348.                     if (++ps->delay_buf_index_delay[sb] >= ps->delay_D[sb])
  1349.                     {
  1350.                         ps->delay_buf_index_delay[sb] = 0;
  1351.                     }
  1352.                 }
  1354.                 for (m = 0; m < NO_ALLPASS_LINKS; m++)
  1355.                 {
  1356.                     if (++temp_delay_ser[m] >= ps->num_sample_delay_ser[m])
  1357.                     {
  1358.                         temp_delay_ser[m] = 0;
  1359.                     }
  1360.                 }
  1361.             }
  1362.         }
  1363.     }
  1365.     /* update delay indices */
  1366.     ps->saved_delay = temp_delay;
  1367.     for (m = 0; m < NO_ALLPASS_LINKS; m++)
  1368.         ps->delay_buf_index_ser[m] = temp_delay_ser[m];
  1369. }
  1371. #ifdef FIXED_POINT
  1372. #define step(shift) 
  1373.     if ((0x40000000l >> shift) + root <= value)       
  1374.     {                                                 
  1375.         value -= (0x40000000l >> shift) + root;       
  1376.         root = (root >> 1) | (0x40000000l >> shift);  
  1377.     } else {                                          
  1378.         root = root >> 1;                             
  1379.     }
  1381. /* fixed point square root approximation */
  1382. static real_t ps_sqrt(real_t value)
  1383. {
  1384.     real_t root = 0;
  1386.     step( 0); step( 2); step( 4); step( 6);
  1387.     step( 8); step(10); step(12); step(14);
  1388.     step(16); step(18); step(20); step(22);
  1389.     step(24); step(26); step(28); step(30);
  1391.     if (root < value)
  1392.         ++root;
  1394.     root <<= (REAL_BITS/2);
  1396.     return root;
  1397. }
  1398. #else
  1399. #define ps_sqrt(A) sqrt(A)
  1400. #endif
  1402. static const real_t ipdopd_cos_tab[] = {
  1403.     FRAC_CONST(1.000000000000000),
  1404.     FRAC_CONST(0.707106781186548),
  1405.     FRAC_CONST(0.000000000000000),
  1406.     FRAC_CONST(-0.707106781186547),
  1407.     FRAC_CONST(-1.000000000000000),
  1408.     FRAC_CONST(-0.707106781186548),
  1409.     FRAC_CONST(-0.000000000000000),
  1410.     FRAC_CONST(0.707106781186547),
  1411.     FRAC_CONST(1.000000000000000)
  1412. };
  1414. static const real_t ipdopd_sin_tab[] = {
  1415.     FRAC_CONST(0.000000000000000),
  1416.     FRAC_CONST(0.707106781186547),
  1417.     FRAC_CONST(1.000000000000000),
  1418.     FRAC_CONST(0.707106781186548),
  1419.     FRAC_CONST(0.000000000000000),
  1420.     FRAC_CONST(-0.707106781186547),
  1421.     FRAC_CONST(-1.000000000000000),
  1422.     FRAC_CONST(-0.707106781186548),
  1423.     FRAC_CONST(-0.000000000000000)
  1424. };
  1426. static real_t magnitude_c(complex_t c)
  1427. {
  1428. #ifdef FIXED_POINT
  1429. #define ps_abs(A) (((A) > 0) ? (A) : (-(A)))
  1430. #define ALPHA FRAC_CONST(0.948059448969)
  1431. #define BETA  FRAC_CONST(0.392699081699)
  1433.     real_t abs_inphase = ps_abs(RE(c));
  1434.     real_t abs_quadrature = ps_abs(IM(c));
  1436.     if (abs_inphase > abs_quadrature) {
  1437.         return MUL_F(abs_inphase, ALPHA) + MUL_F(abs_quadrature, BETA);
  1438.     } else {
  1439.         return MUL_F(abs_quadrature, ALPHA) + MUL_F(abs_inphase, BETA);
  1440.     }
  1441. #else
  1442.     return sqrt(RE(c)*RE(c) + IM(c)*IM(c));
  1443. #endif
  1444. }
  1446. static void ps_mix_phase(ps_info *ps, qmf_t X_left[38][64], qmf_t X_right[38][64],
  1447.                          qmf_t X_hybrid_left[32][32], qmf_t X_hybrid_right[32][32])
  1448. {
  1449.     uint8_t n;
  1450.     uint8_t gr;
  1451.     uint8_t bk = 0;
  1452.     uint8_t sb, maxsb;
  1453.     uint8_t env;
  1454.     uint8_t nr_ipdopd_par;
  1455.     complex_t h11, h12, h21, h22;
  1456.     complex_t H11, H12, H21, H22;
  1457.     complex_t deltaH11, deltaH12, deltaH21, deltaH22;
  1458.     complex_t tempLeft;
  1459.     complex_t tempRight;
  1460.     complex_t phaseLeft;
  1461.     complex_t phaseRight;
  1462.     real_t L;
  1463.     const real_t *sf_iid;
  1464.     uint8_t no_iid_steps;
  1466.     if (ps->iid_mode >= 3)
  1467.     {
  1468.         no_iid_steps = 15;
  1469.         sf_iid = sf_iid_fine;
  1470.     } else {
  1471.         no_iid_steps = 7;
  1472.         sf_iid = sf_iid_normal;
  1473.     }
  1475.     if (ps->ipd_mode == 0 || ps->ipd_mode == 3)
  1476.     {
  1477.         nr_ipdopd_par = 11; /* resolution */
  1478.     } else {
  1479.         nr_ipdopd_par = ps->nr_ipdopd_par;
  1480.     }
  1482.     for (gr = 0; gr < ps->num_groups; gr++)
  1483.     {
  1484.         bk = (~NEGATE_IPD_MASK) & ps->map_group2bk[gr];
  1486.         /* use one channel per group in the subqmf domain */
  1487.         maxsb = (gr < ps->num_hybrid_groups) ? ps->group_border[gr] + 1 : ps->group_border[gr + 1];
  1489.         for (env = 0; env < ps->num_env; env++)
  1490.         {
  1491.             if (ps->icc_mode < 3)
  1492.             {
  1493.                 /* type 'A' mixing as described in 8.6.4.6.2.1 */
  1494.                 real_t c_1, c_2;
  1495.                 real_t cosa, sina;
  1496.                 real_t cosb, sinb;
  1497.                 real_t ab1, ab2;
  1498.                 real_t ab3, ab4;
  1500.                 /*
  1501.                 c_1 = sqrt(2.0 / (1.0 + pow(10.0, quant_iid[no_iid_steps + iid_index] / 10.0)));
  1502.                 c_2 = sqrt(2.0 / (1.0 + pow(10.0, quant_iid[no_iid_steps - iid_index] / 10.0)));
  1503.                 alpha = 0.5 * acos(quant_rho[icc_index]);
  1504.                 beta = alpha * ( c_1 - c_2 ) / sqrt(2.0);
  1505.                 */
  1507.                 //printf("%dn", ps->iid_index[env][bk]);
  1509.                 /* calculate the scalefactors c_1 and c_2 from the intensity differences */
  1510.                 c_1 = sf_iid[no_iid_steps + ps->iid_index[env][bk]];
  1511.                 c_2 = sf_iid[no_iid_steps - ps->iid_index[env][bk]];
  1513.                 /* calculate alpha and beta using the ICC parameters */
  1514.                 cosa = cos_alphas[ps->icc_index[env][bk]];
  1515.                 sina = sin_alphas[ps->icc_index[env][bk]];
  1517.                 if (ps->iid_mode >= 3)
  1518.                 {
  1519.                     if (ps->iid_index[env][bk] < 0)
  1520.                     {
  1521.                         cosb =  cos_betas_fine[-ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1522.                         sinb = -sin_betas_fine[-ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1523.                     } else {
  1524.                         cosb = cos_betas_fine[ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1525.                         sinb = sin_betas_fine[ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1526.                     }
  1527.                 } else {
  1528.                     if (ps->iid_index[env][bk] < 0)
  1529.                     {
  1530.                         cosb =  cos_betas_normal[-ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1531.                         sinb = -sin_betas_normal[-ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1532.                     } else {
  1533.                         cosb = cos_betas_normal[ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1534.                         sinb = sin_betas_normal[ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1535.                     }
  1536.                 }
  1538.                 ab1 = MUL_C(cosb, cosa);
  1539.                 ab2 = MUL_C(sinb, sina);
  1540.                 ab3 = MUL_C(sinb, cosa);
  1541.                 ab4 = MUL_C(cosb, sina);
  1543.                 /* h_xy: COEF */
  1544.                 RE(h11) = MUL_C(c_2, (ab1 - ab2));
  1545.                 RE(h12) = MUL_C(c_1, (ab1 + ab2));
  1546.                 RE(h21) = MUL_C(c_2, (ab3 + ab4));
  1547.                 RE(h22) = MUL_C(c_1, (ab3 - ab4));
  1548.             } else {
  1549.                 /* type 'B' mixing as described in 8.6.4.6.2.2 */
  1550.                 real_t sina, cosa;
  1551.                 real_t cosg, sing;
  1553.                 /*
  1554.                 real_t c, rho, mu, alpha, gamma;
  1555.                 uint8_t i;
  1557.                 i = ps->iid_index[env][bk];
  1558.                 c = (real_t)pow(10.0, ((i)?(((i>0)?1:-1)*quant_iid[((i>0)?i:-i)-1]):0.)/20.0);
  1559.                 rho = quant_rho[ps->icc_index[env][bk]];
  1561.                 if (rho == 0.0f && c == 1.)
  1562.                 {
  1563.                     alpha = (real_t)M_PI/4.0f;
  1564.                     rho = 0.05f;
  1565.                 } else {
  1566.                     if (rho <= 0.05f)
  1567.                     {
  1568.                         rho = 0.05f;
  1569.                     }
  1570.                     alpha = 0.5f*(real_t)atan( (2.0f*c*rho) / (c*c-1.0f) );
  1572.                     if (alpha < 0.)
  1573.                     {
  1574.                         alpha += (real_t)M_PI/2.0f;
  1575.                     }
  1576.                     if (rho < 0.)
  1577.                     {
  1578.                         alpha += (real_t)M_PI;
  1579.                     }
  1580.                 }
  1581.                 mu = c+1.0f/c;
  1582.                 mu = 1+(4.0f*rho*rho-4.0f)/(mu*mu);
  1583.                 gamma = (real_t)atan(sqrt((1.0f-sqrt(mu))/(1.0f+sqrt(mu))));
  1584.                 */
  1586.                 if (ps->iid_mode >= 3)
  1587.                 {
  1588.                     uint8_t abs_iid = abs(ps->iid_index[env][bk]);
  1590.                     cosa = sincos_alphas_B_fine[no_iid_steps + ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1591.                     sina = sincos_alphas_B_fine[30 - (no_iid_steps + ps->iid_index[env][bk])][ps->icc_index[env][bk]];
  1592.                     cosg = cos_gammas_fine[abs_iid][ps->icc_index[env][bk]];
  1593.                     sing = sin_gammas_fine[abs_iid][ps->icc_index[env][bk]];
  1594.                 } else {
  1595.                     uint8_t abs_iid = abs(ps->iid_index[env][bk]);
  1597.                     cosa = sincos_alphas_B_normal[no_iid_steps + ps->iid_index[env][bk]][ps->icc_index[env][bk]];
  1598.                     sina = sincos_alphas_B_normal[14 - (no_iid_steps + ps->iid_index[env][bk])][ps->icc_index[env][bk]];
  1599.                     cosg = cos_gammas_normal[abs_iid][ps->icc_index[env][bk]];
  1600.                     sing = sin_gammas_normal[abs_iid][ps->icc_index[env][bk]];
  1601.                 }
  1603.                 RE(h11) = MUL_C(COEF_SQRT2, MUL_C(cosa, cosg));
  1604.                 RE(h12) = MUL_C(COEF_SQRT2, MUL_C(sina, cosg));
  1605.                 RE(h21) = MUL_C(COEF_SQRT2, MUL_C(-cosa, sing));
  1606.                 RE(h22) = MUL_C(COEF_SQRT2, MUL_C(sina, sing));
  1607.             }
  1609.             /* calculate phase rotation parameters H_xy */
  1610.             /* note that the imaginary part of these parameters are only calculated when
  1611.                IPD and OPD are enabled
  1612.              */
  1613.             if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par))
  1614.             {
  1615.                 int8_t i;
  1616.                 real_t xy, pq, xypq;
  1618.                 /* ringbuffer index */
  1619.                 i = ps->phase_hist;
  1621.                 /* previous value */
  1622. #ifdef FIXED_POINT
  1623.                 /* divide by 4, shift right 2 bits */
  1624.                 RE(tempLeft)  = RE(ps->ipd_prev[bk][i]) >> 2;
  1625.                 IM(tempLeft)  = IM(ps->ipd_prev[bk][i]) >> 2;
  1626.                 RE(tempRight) = RE(ps->opd_prev[bk][i]) >> 2;
  1627.                 IM(tempRight) = IM(ps->opd_prev[bk][i]) >> 2;
  1628. #else
  1629.                 RE(tempLeft)  = MUL_F(RE(ps->ipd_prev[bk][i]), FRAC_CONST(0.25));
  1630.                 IM(tempLeft)  = MUL_F(IM(ps->ipd_prev[bk][i]), FRAC_CONST(0.25));
  1631.                 RE(tempRight) = MUL_F(RE(ps->opd_prev[bk][i]), FRAC_CONST(0.25));
  1632.                 IM(tempRight) = MUL_F(IM(ps->opd_prev[bk][i]), FRAC_CONST(0.25));
  1633. #endif
  1635.                 /* save current value */
  1636.                 RE(ps->ipd_prev[bk][i]) = ipdopd_cos_tab[abs(ps->ipd_index[env][bk])];
  1637.                 IM(ps->ipd_prev[bk][i]) = ipdopd_sin_tab[abs(ps->ipd_index[env][bk])];
  1638.                 RE(ps->opd_prev[bk][i]) = ipdopd_cos_tab[abs(ps->opd_index[env][bk])];
  1639.                 IM(ps->opd_prev[bk][i]) = ipdopd_sin_tab[abs(ps->opd_index[env][bk])];
  1641.                 /* add current value */
  1642.                 RE(tempLeft)  += RE(ps->ipd_prev[bk][i]);
  1643.                 IM(tempLeft)  += IM(ps->ipd_prev[bk][i]);
  1644.                 RE(tempRight) += RE(ps->opd_prev[bk][i]);
  1645.                 IM(tempRight) += IM(ps->opd_prev[bk][i]);
  1647.                 /* ringbuffer index */
  1648.                 if (i == 0)
  1649.                 {
  1650.                     i = 2;
  1651.                 }
  1652.                 i--;
  1654.                 /* get value before previous */
  1655. #ifdef FIXED_POINT
  1656.                 /* dividing by 2, shift right 1 bit */
  1657.                 RE(tempLeft)  += (RE(ps->ipd_prev[bk][i]) >> 1);
  1658.                 IM(tempLeft)  += (IM(ps->ipd_prev[bk][i]) >> 1);
  1659.                 RE(tempRight) += (RE(ps->opd_prev[bk][i]) >> 1);
  1660.                 IM(tempRight) += (IM(ps->opd_prev[bk][i]) >> 1);
  1661. #else
  1662.                 RE(tempLeft)  += MUL_F(RE(ps->ipd_prev[bk][i]), FRAC_CONST(0.5));
  1663.                 IM(tempLeft)  += MUL_F(IM(ps->ipd_prev[bk][i]), FRAC_CONST(0.5));
  1664.                 RE(tempRight) += MUL_F(RE(ps->opd_prev[bk][i]), FRAC_CONST(0.5));
  1665.                 IM(tempRight) += MUL_F(IM(ps->opd_prev[bk][i]), FRAC_CONST(0.5));
  1666. #endif
  1668. #if 0 /* original code */
  1669.                 ipd = (float)atan2(IM(tempLeft), RE(tempLeft));
  1670.                 opd = (float)atan2(IM(tempRight), RE(tempRight));
  1672.                 /* phase rotation */
  1673.                 RE(phaseLeft) = (float)cos(opd);
  1674.                 IM(phaseLeft) = (float)sin(opd);
  1675.                 opd -= ipd;
  1676.                 RE(phaseRight) = (float)cos(opd);
  1677.                 IM(phaseRight) = (float)sin(opd);
  1678. #else
  1680.                 // x = IM(tempLeft)
  1681.                 // y = RE(tempLeft)
  1682.                 // p = IM(tempRight)
  1683.                 // q = RE(tempRight)
  1684.                 // cos(atan2(x,y)) = y/sqrt((x*x) + (y*y))
  1685.                 // sin(atan2(x,y)) = x/sqrt((x*x) + (y*y))
  1686.                 // cos(atan2(x,y)-atan2(p,q)) = (y*q + x*p) / ( sqrt((x*x) + (y*y)) * sqrt((p*p) + (q*q)) );
  1687.                 // sin(atan2(x,y)-atan2(p,q)) = (x*q - y*p) / ( sqrt((x*x) + (y*y)) * sqrt((p*p) + (q*q)) );
  1689.                 xy = magnitude_c(tempRight);
  1690.                 pq = magnitude_c(tempLeft);
  1692.                 if (xy != 0)
  1693.                 {
  1694.                     RE(phaseLeft) = DIV_R(RE(tempRight), xy);
  1695.                     IM(phaseLeft) = DIV_R(IM(tempRight), xy);
  1696.                 } else {
  1697.                     RE(phaseLeft) = 0;
  1698.                     IM(phaseLeft) = 0;
  1699.                 }
  1701.                 xypq = MUL_R(xy, pq);
  1703.                 if (xypq != 0)
  1704.                 {
  1705.                     real_t tmp1 = MUL_R(RE(tempRight), RE(tempLeft)) + MUL_R(IM(tempRight), IM(tempLeft));
  1706.                     real_t tmp2 = MUL_R(IM(tempRight), RE(tempLeft)) - MUL_R(RE(tempRight), IM(tempLeft));
  1708.                     RE(phaseRight) = DIV_R(tmp1, xypq);
  1709.                     IM(phaseRight) = DIV_R(tmp2, xypq);
  1710.                 } else {
  1711.                     RE(phaseRight) = 0;
  1712.                     IM(phaseRight) = 0;
  1713.                 }
  1715. #endif
  1717.                 /* MUL_F(COEF, REAL) = COEF */
  1718.                 IM(h11) = MUL_R(RE(h11), IM(phaseLeft));
  1719.                 IM(h12) = MUL_R(RE(h12), IM(phaseRight));
  1720.                 IM(h21) = MUL_R(RE(h21), IM(phaseLeft));
  1721.                 IM(h22) = MUL_R(RE(h22), IM(phaseRight));
  1723.                 RE(h11) = MUL_R(RE(h11), RE(phaseLeft));
  1724.                 RE(h12) = MUL_R(RE(h12), RE(phaseRight));
  1725.                 RE(h21) = MUL_R(RE(h21), RE(phaseLeft));
  1726.                 RE(h22) = MUL_R(RE(h22), RE(phaseRight));
  1727.             }
  1729.             /* length of the envelope n_e+1 - n_e (in time samples) */
  1730.             /* 0 < L <= 32: integer */
  1731.             L = (real_t)(ps->border_position[env + 1] - ps->border_position[env]);
  1733.             /* obtain final H_xy by means of linear interpolation */
  1734.             RE(deltaH11) = (RE(h11) - RE(ps->h11_prev[gr])) / L;
  1735.             RE(deltaH12) = (RE(h12) - RE(ps->h12_prev[gr])) / L;
  1736.             RE(deltaH21) = (RE(h21) - RE(ps->h21_prev[gr])) / L;
  1737.             RE(deltaH22) = (RE(h22) - RE(ps->h22_prev[gr])) / L;
  1739.             RE(H11) = RE(ps->h11_prev[gr]);
  1740.             RE(H12) = RE(ps->h12_prev[gr]);
  1741.             RE(H21) = RE(ps->h21_prev[gr]);
  1742.             RE(H22) = RE(ps->h22_prev[gr]);
  1744.             RE(ps->h11_prev[gr]) = RE(h11);
  1745.             RE(ps->h12_prev[gr]) = RE(h12);
  1746.             RE(ps->h21_prev[gr]) = RE(h21);
  1747.             RE(ps->h22_prev[gr]) = RE(h22);
  1749.             /* only calculate imaginary part when needed */
  1750.             if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par))
  1751.             {
  1752.                 /* obtain final H_xy by means of linear interpolation */
  1753.                 IM(deltaH11) = (IM(h11) - IM(ps->h11_prev[gr])) / L;
  1754.                 IM(deltaH12) = (IM(h12) - IM(ps->h12_prev[gr])) / L;
  1755.                 IM(deltaH21) = (IM(h21) - IM(ps->h21_prev[gr])) / L;
  1756.                 IM(deltaH22) = (IM(h22) - IM(ps->h22_prev[gr])) / L;
  1758.                 IM(H11) = IM(ps->h11_prev[gr]);
  1759.                 IM(H12) = IM(ps->h12_prev[gr]);
  1760.                 IM(H21) = IM(ps->h21_prev[gr]);
  1761.                 IM(H22) = IM(ps->h22_prev[gr]);
  1763.                 if ((NEGATE_IPD_MASK & ps->map_group2bk[gr]) != 0)
  1764.                 {
  1765.                     IM(deltaH11) = -IM(deltaH11);
  1766.                     IM(deltaH12) = -IM(deltaH12);
  1767.                     IM(deltaH21) = -IM(deltaH21);
  1768.                     IM(deltaH22) = -IM(deltaH22);
  1770.                     IM(H11) = -IM(H11);
  1771.                     IM(H12) = -IM(H12);
  1772.                     IM(H21) = -IM(H21);
  1773.                     IM(H22) = -IM(H22);
  1774.                 }
  1776.                 IM(ps->h11_prev[gr]) = IM(h11);
  1777.                 IM(ps->h12_prev[gr]) = IM(h12);
  1778.                 IM(ps->h21_prev[gr]) = IM(h21);
  1779.                 IM(ps->h22_prev[gr]) = IM(h22);
  1780.             }
  1782.             /* apply H_xy to the current envelope band of the decorrelated subband */
  1783.             for (n = ps->border_position[env]; n < ps->border_position[env + 1]; n++)
  1784.             {
  1785.                 /* addition finalises the interpolation over every n */
  1786.                 RE(H11) += RE(deltaH11);
  1787.                 RE(H12) += RE(deltaH12);
  1788.                 RE(H21) += RE(deltaH21);
  1789.                 RE(H22) += RE(deltaH22);
  1790.                 if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par))
  1791.                 {
  1792.                     IM(H11) += IM(deltaH11);
  1793.                     IM(H12) += IM(deltaH12);
  1794.                     IM(H21) += IM(deltaH21);
  1795.                     IM(H22) += IM(deltaH22);
  1796.                 }
  1798.                 /* channel is an alias to the subband */
  1799.                 for (sb = ps->group_border[gr]; sb < maxsb; sb++)
  1800.                 {
  1801.                     complex_t inLeft, inRight;
  1803.                     /* load decorrelated samples */
  1804.                     if (gr < ps->num_hybrid_groups)
  1805.                     {
  1806.                         RE(inLeft) =  RE(X_hybrid_left[n][sb]);
  1807.                         IM(inLeft) =  IM(X_hybrid_left[n][sb]);
  1808.                         RE(inRight) = RE(X_hybrid_right[n][sb]);
  1809.                         IM(inRight) = IM(X_hybrid_right[n][sb]);
  1810.                     } else {
  1811.                         RE(inLeft) =  RE(X_left[n][sb]);
  1812.                         IM(inLeft) =  IM(X_left[n][sb]);
  1813.                         RE(inRight) = RE(X_right[n][sb]);
  1814.                         IM(inRight) = IM(X_right[n][sb]);
  1815.                     }
  1817.                     /* apply mixing */
  1818.                     RE(tempLeft) =  MUL_C(RE(H11), RE(inLeft)) + MUL_C(RE(H21), RE(inRight));
  1819.                     IM(tempLeft) =  MUL_C(RE(H11), IM(inLeft)) + MUL_C(RE(H21), IM(inRight));
  1820.                     RE(tempRight) = MUL_C(RE(H12), RE(inLeft)) + MUL_C(RE(H22), RE(inRight));
  1821.                     IM(tempRight) = MUL_C(RE(H12), IM(inLeft)) + MUL_C(RE(H22), IM(inRight));
  1823.                     /* only perform imaginary operations when needed */
  1824.                     if ((ps->enable_ipdopd) && (bk < nr_ipdopd_par))
  1825.                     {
  1826.                         /* apply rotation */
  1827.                         RE(tempLeft)  -= MUL_C(IM(H11), IM(inLeft)) + MUL_C(IM(H21), IM(inRight));
  1828.                         IM(tempLeft)  += MUL_C(IM(H11), RE(inLeft)) + MUL_C(IM(H21), RE(inRight));
  1829.                         RE(tempRight) -= MUL_C(IM(H12), IM(inLeft)) + MUL_C(IM(H22), IM(inRight));
  1830.                         IM(tempRight) += MUL_C(IM(H12), RE(inLeft)) + MUL_C(IM(H22), RE(inRight));
  1831.                     }
  1833.                     /* store final samples */
  1834.                     if (gr < ps->num_hybrid_groups)
  1835.                     {
  1836.                         RE(X_hybrid_left[n][sb])  = RE(tempLeft);
  1837.                         IM(X_hybrid_left[n][sb])  = IM(tempLeft);
  1838.                         RE(X_hybrid_right[n][sb]) = RE(tempRight);
  1839.                         IM(X_hybrid_right[n][sb]) = IM(tempRight);
  1840.                     } else {
  1841.                         RE(X_left[n][sb])  = RE(tempLeft);
  1842.                         IM(X_left[n][sb])  = IM(tempLeft);
  1843.                         RE(X_right[n][sb]) = RE(tempRight);
  1844.                         IM(X_right[n][sb]) = IM(tempRight);
  1845.                     }
  1846.                 }
  1847.             }
  1849.             /* shift phase smoother's circular buffer index */
  1850.             ps->phase_hist++;
  1851.             if (ps->phase_hist == 2)
  1852.             {
  1853.                 ps->phase_hist = 0;
  1854.             }
  1855.         }
  1856.     }
  1857. }
  1859. void ps_free(ps_info *ps)
  1860. {
  1861.     /* free hybrid filterbank structures */
  1862.     hybrid_free(ps->hyb);
  1864.     faad_free(ps);
  1865. }
  1867. ps_info *ps_init(uint8_t sr_index)
  1868. {
  1869.     uint8_t i;
  1870.     uint8_t short_delay_band;
  1872.     ps_info *ps = (ps_info*)faad_malloc(sizeof(ps_info));
  1873.     memset(ps, 0, sizeof(ps_info));
  1875.     ps->hyb = hybrid_init();
  1877.     ps->ps_data_available = 0;
  1879.     /* delay stuff*/
  1880.     ps->saved_delay = 0;
  1882.     for (i = 0; i < 64; i++)
  1883.     {
  1884.         ps->delay_buf_index_delay[i] = 0;
  1885.     }
  1887.     for (i = 0; i < NO_ALLPASS_LINKS; i++)
  1888.     {
  1889.         ps->delay_buf_index_ser[i] = 0;
  1890. #ifdef PARAM_32KHZ
  1891.         if (sr_index <= 5) /* >= 32 kHz*/
  1892.         {
  1893.             ps->num_sample_delay_ser[i] = delay_length_d[1][i];
  1894.         } else {
  1895.             ps->num_sample_delay_ser[i] = delay_length_d[0][i];
  1896.         }
  1897. #else
  1898.         /* THESE ARE CONSTANTS NOW */
  1899.         ps->num_sample_delay_ser[i] = delay_length_d[i];
  1900. #endif
  1901.     }
  1903. #ifdef PARAM_32KHZ
  1904.     if (sr_index <= 5) /* >= 32 kHz*/
  1905.     {
  1906.         short_delay_band = 35;
  1907.         ps->nr_allpass_bands = 22;
  1908.         ps->alpha_decay = FRAC_CONST(0.76592833836465);
  1909.         ps->alpha_smooth = FRAC_CONST(0.25);
  1910.     } else {
  1911.         short_delay_band = 64;
  1912.         ps->nr_allpass_bands = 45;
  1913.         ps->alpha_decay = FRAC_CONST(0.58664621951003);
  1914.         ps->alpha_smooth = FRAC_CONST(0.6);
  1915.     }
  1916. #else
  1917.     /* THESE ARE CONSTANTS NOW */
  1918.     short_delay_band = 35;
  1919.     ps->nr_allpass_bands = 22;
  1920.     ps->alpha_decay = FRAC_CONST(0.76592833836465);
  1921.     ps->alpha_smooth = FRAC_CONST(0.25);
  1922. #endif
  1924.     /* THESE ARE CONSTANT NOW IF PS IS INDEPENDANT OF SAMPLERATE */
  1925.     for (i = 0; i < short_delay_band; i++)
  1926.     {
  1927.         ps->delay_D[i] = 14;
  1928.     }
  1929.     for (i = short_delay_band; i < 64; i++)
  1930.     {
  1931.         ps->delay_D[i] = 1;
  1932.     }
  1934.     /* mixing and phase */
  1935.     for (i = 0; i < 50; i++)
  1936.     {
  1937.         RE(ps->h11_prev[i]) = 1;
  1938.         IM(ps->h12_prev[i]) = 1;
  1939.         RE(ps->h11_prev[i]) = 1;
  1940.         IM(ps->h12_prev[i]) = 1;
  1941.     }
  1943.     ps->phase_hist = 0;
  1945.     for (i = 0; i < 20; i++)
  1946.     {
  1947.         RE(ps->ipd_prev[i][0]) = 0;
  1948.         IM(ps->ipd_prev[i][0]) = 0;
  1949.         RE(ps->ipd_prev[i][1]) = 0;
  1950.         IM(ps->ipd_prev[i][1]) = 0;
  1951.         RE(ps->opd_prev[i][0]) = 0;
  1952.         IM(ps->opd_prev[i][0]) = 0;
  1953.         RE(ps->opd_prev[i][1]) = 0;
  1954.         IM(ps->opd_prev[i][1]) = 0;
  1955.     }
  1957.     return ps;
  1958. }
  1960. /* main Parametric Stereo decoding function */
  1961. uint8_t ps_decode(ps_info *ps, qmf_t X_left[38][64], qmf_t X_right[38][64])
  1962. {
  1963.     qmf_t X_hybrid_left[32][32] = {{0}};
  1964.     qmf_t X_hybrid_right[32][32] = {{0}};
  1966.     /* delta decoding of the bitstream data */
  1967.     ps_data_decode(ps);
  1969.     /* set up some parameters depending on filterbank type */
  1970.     if (ps->use34hybrid_bands)
  1971.     {
  1972.         ps->group_border = (uint8_t*)group_border34;
  1973.         ps->map_group2bk = (uint16_t*)map_group2bk34;
  1974.         ps->num_groups = 32+18;
  1975.         ps->num_hybrid_groups = 32;
  1976.         ps->nr_par_bands = 34;
  1977.         ps->decay_cutoff = 5;
  1978.     } else {
  1979.         ps->group_border = (uint8_t*)group_border20;
  1980.         ps->map_group2bk = (uint16_t*)map_group2bk20;
  1981.         ps->num_groups = 10+12;
  1982.         ps->num_hybrid_groups = 10;
  1983.         ps->nr_par_bands = 20;
  1984.         ps->decay_cutoff = 3;
  1985.     }
  1987.     /* Perform further analysis on the lowest subbands to get a higher
  1988.      * frequency resolution
  1989.      */
  1990.     hybrid_analysis((hyb_info*)ps->hyb, X_left, X_hybrid_left,
  1991.         ps->use34hybrid_bands);
  1993.     /* decorrelate mono signal */
  1994.     ps_decorrelate(ps, X_left, X_right, X_hybrid_left, X_hybrid_right);
  1996.     /* apply mixing and phase parameters */
  1997.     ps_mix_phase(ps, X_left, X_right, X_hybrid_left, X_hybrid_right);
  1999.     /* hybrid synthesis, to rebuild the SBR QMF matrices */
  2000.     hybrid_synthesis((hyb_info*)ps->hyb, X_left, X_hybrid_left,
  2001.         ps->use34hybrid_bands);
  2003.     hybrid_synthesis((hyb_info*)ps->hyb, X_right, X_hybrid_right,
  2004.         ps->use34hybrid_bands);
  2006.     return 0;
  2007. }
  2009. #endif