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

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

多媒体编程

开发平台：

Visual C++

sbr_hfgen.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: sbr_hfgen.c,v 1.2 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. /* High Frequency generation */
  35. #include "common.h"
  36. #include "structs.h"
  38. #ifdef SBR_DEC
  40. #include "sbr_syntax.h"
  41. #include "sbr_hfgen.h"
  42. #include "sbr_fbt.h"
  44. /* static function declarations */
  45. #ifdef SBR_LOW_POWER
  46. static void calc_prediction_coef_lp(sbr_info *sbr, qmf_t Xlow[MAX_NTSRHFG][64],
  47.                                     complex_t *alpha_0, complex_t *alpha_1, real_t *rxx);
  48. static void calc_aliasing_degree(sbr_info *sbr, real_t *rxx, real_t *deg);
  49. #else
  50. static void calc_prediction_coef(sbr_info *sbr, qmf_t Xlow[MAX_NTSRHFG][64],
  51.                                  complex_t *alpha_0, complex_t *alpha_1, uint8_t k);
  52. #endif
  53. static void calc_chirp_factors(sbr_info *sbr, uint8_t ch);
  54. static void patch_construction(sbr_info *sbr);
  57. void hf_generation(sbr_info *sbr, qmf_t Xlow[MAX_NTSRHFG][64],
  58.                    qmf_t Xhigh[MAX_NTSRHFG][64]
  59. #ifdef SBR_LOW_POWER
  60.                    ,real_t *deg
  61. #endif
  62.                    ,uint8_t ch)
  63. {
  64.     uint8_t l, i, x;
  65.     ALIGN complex_t alpha_0[64], alpha_1[64];
  66. #ifdef SBR_LOW_POWER
  67.     ALIGN real_t rxx[64];
  68. #endif
  70.     uint8_t offset = sbr->tHFAdj;
  71.     uint8_t first = sbr->t_E[ch][0];
  72.     uint8_t last = sbr->t_E[ch][sbr->L_E[ch]];
  74.     calc_chirp_factors(sbr, ch);
  76. #ifdef SBR_LOW_POWER
  77.     memset(deg, 0, 64*sizeof(real_t));
  78. #endif
  80.     if ((ch == 0) && (sbr->Reset))
  81.         patch_construction(sbr);
  83.     /* calculate the prediction coefficients */
  84. #ifdef SBR_LOW_POWER
  85.     calc_prediction_coef_lp(sbr, Xlow, alpha_0, alpha_1, rxx);
  86.     calc_aliasing_degree(sbr, rxx, deg);
  87. #endif
  89.     /* actual HF generation */
  90.     for (i = 0; i < sbr->noPatches; i++)
  91.     {
  92.         for (x = 0; x < sbr->patchNoSubbands[i]; x++)
  93.         {
  94.             real_t a0_r, a0_i, a1_r, a1_i;
  95.             real_t bw, bw2;
  96.             uint8_t q, p, k, g;
  98.             /* find the low and high band for patching */
  99.             k = sbr->kx + x;
  100.             for (q = 0; q < i; q++)
  101.             {
  102.                 k += sbr->patchNoSubbands[q];
  103.             }
  104.             p = sbr->patchStartSubband[i] + x;
  106. #ifdef SBR_LOW_POWER
  107.             if (x != 0 /*x < sbr->patchNoSubbands[i]-1*/)
  108.                 deg[k] = deg[p];
  109.             else
  110.                 deg[k] = 0;
  111. #endif
  113.             g = sbr->table_map_k_to_g[k];
  115.             bw = sbr->bwArray[ch][g];
  116.             bw2 = MUL_C(bw, bw);
  118.             /* do the patching */
  119.             /* with or without filtering */
  120.             if (bw2 > 0)
  121.             {
  122.                 real_t temp1_r, temp2_r, temp3_r;
  123. #ifndef SBR_LOW_POWER
  124.                 real_t temp1_i, temp2_i, temp3_i;
  125.                 calc_prediction_coef(sbr, Xlow, alpha_0, alpha_1, p);
  126. #endif
  128.                 a0_r = MUL_C(RE(alpha_0[p]), bw);
  129.                 a1_r = MUL_C(RE(alpha_1[p]), bw2);
  130. #ifndef SBR_LOW_POWER
  131.                 a0_i = MUL_C(IM(alpha_0[p]), bw);
  132.                 a1_i = MUL_C(IM(alpha_1[p]), bw2);
  133. #endif
  135.              temp2_r = QMF_RE(Xlow[first - 2 + offset][p]);
  136.              temp3_r = QMF_RE(Xlow[first - 1 + offset][p]);
  137. #ifndef SBR_LOW_POWER
  138.              temp2_i = QMF_IM(Xlow[first - 2 + offset][p]);
  139.              temp3_i = QMF_IM(Xlow[first - 1 + offset][p]);
  140. #endif
  141. for (l = first; l < last; l++)
  142.                 {
  143.                  temp1_r = temp2_r;
  144.                  temp2_r = temp3_r;
  145.                  temp3_r = QMF_RE(Xlow[l + offset][p]);
  146. #ifndef SBR_LOW_POWER
  147.                  temp1_i = temp2_i;
  148.                  temp2_i = temp3_i;
  149.                     temp3_i = QMF_IM(Xlow[l + offset][p]);
  150. #endif
  152. #ifdef SBR_LOW_POWER
  153.                     QMF_RE(Xhigh[l + offset][k]) =
  154.                         temp3_r
  155.                       +(MUL_R(a0_r, temp2_r) +
  156.                         MUL_R(a1_r, temp1_r));
  157. #else
  158.                     QMF_RE(Xhigh[l + offset][k]) =
  159.                         temp3_r
  160.                       +(MUL_R(a0_r, temp2_r) -
  161.                         MUL_R(a0_i, temp2_i) +
  162.                         MUL_R(a1_r, temp1_r) -
  163.                         MUL_R(a1_i, temp1_i));
  164.                     QMF_IM(Xhigh[l + offset][k]) =
  165.                         temp3_i
  166.                       +(MUL_R(a0_i, temp2_r) +
  167.                         MUL_R(a0_r, temp2_i) +
  168.                         MUL_R(a1_i, temp1_r) +
  169.                         MUL_R(a1_r, temp1_i));
  170. #endif
  171.                 }
  172.             } else {
  173.                 for (l = first; l < last; l++)
  174.                 {
  175.                     QMF_RE(Xhigh[l + offset][k]) = QMF_RE(Xlow[l + offset][p]);
  176. #ifndef SBR_LOW_POWER
  177.                     QMF_IM(Xhigh[l + offset][k]) = QMF_IM(Xlow[l + offset][p]);
  178. #endif
  179.                 }
  180.             }
  181.         }
  182.     }
  184.     if (sbr->Reset)
  185.     {
  186.         limiter_frequency_table(sbr);
  187.     }
  188. }
  190. typedef struct
  191. {
  192.     complex_t r01;
  193.     complex_t r02;
  194.     complex_t r11;
  195.     complex_t r12;
  196.     complex_t r22;
  197.     real_t det;
  198. } acorr_coef;
  200. #ifdef SBR_LOW_POWER
  201. static void auto_correlation(sbr_info *sbr, acorr_coef *ac,
  202.                              qmf_t buffer[MAX_NTSRHFG][64],
  203.                              uint8_t bd, uint8_t len)
  204. {
  205.     real_t r01 = 0, r02 = 0, r11 = 0;
  206.     int8_t j;
  207.     uint8_t offset = sbr->tHFAdj;
  208. #ifdef FIXED_POINT
  209.     const real_t rel = FRAC_CONST(0.999999); // 1 / (1 + 1e-6f);
  210.     uint32_t maxi = 0;
  211.     uint32_t pow2, exp;
  212. #else
  213.     const real_t rel = 1 / (1 + 1e-6f);
  214. #endif
  217. #ifdef FIXED_POINT
  218.     mask = 0;
  220.     for (j = (offset-2); j < (len + offset); j++)
  221.     {
  222.         real_t x;
  223.         x = QMF_RE(buffer[j][bd])>>REAL_BITS;
  224.         mask |= x ^ (x >> 31);
  225.     }
  227.     exp = wl_min_lzc(mask);
  229.     /* improves accuracy */
  230.     if (exp > 0)
  231.         exp -= 1;
  233.     for (j = offset; j < len + offset; j++)
  234.     {
  235.         real_t buf_j = ((QMF_RE(buffer[j][bd])+(1<<(exp-1)))>>exp);
  236.         real_t buf_j_1 = ((QMF_RE(buffer[j-1][bd])+(1<<(exp-1)))>>exp);
  237.         real_t buf_j_2 = ((QMF_RE(buffer[j-2][bd])+(1<<(exp-1)))>>exp);
  239.         /* normalisation with rounding */
  240.         r01 += MUL_R(buf_j, buf_j_1);
  241.         r02 += MUL_R(buf_j, buf_j_2);
  242.         r11 += MUL_R(buf_j_1, buf_j_1);
  243.     }
  244.     RE(ac->r12) = r01 -
  245.         MUL_R(((QMF_RE(buffer[len+offset-1][bd])+(1<<(exp-1)))>>exp), ((QMF_RE(buffer[len+offset-2][bd])+(1<<(exp-1)))>>exp)) +
  246.         MUL_R(((QMF_RE(buffer[offset-1][bd])+(1<<(exp-1)))>>exp), ((QMF_RE(buffer[offset-2][bd])+(1<<(exp-1)))>>exp));
  247.     RE(ac->r22) = r11 -
  248.         MUL_R(((QMF_RE(buffer[len+offset-2][bd])+(1<<(exp-1)))>>exp), ((QMF_RE(buffer[len+offset-2][bd])+(1<<(exp-1)))>>exp)) +
  249.         MUL_R(((QMF_RE(buffer[offset-2][bd])+(1<<(exp-1)))>>exp), ((QMF_RE(buffer[offset-2][bd])+(1<<(exp-1)))>>exp));
  250. #else
  251.     for (j = offset; j < len + offset; j++)
  252.     {
  253.         r01 += QMF_RE(buffer[j][bd]) * QMF_RE(buffer[j-1][bd]);
  254.         r02 += QMF_RE(buffer[j][bd]) * QMF_RE(buffer[j-2][bd]);
  255.         r11 += QMF_RE(buffer[j-1][bd]) * QMF_RE(buffer[j-1][bd]);
  256.     }
  257.     RE(ac->r12) = r01 -
  258.         QMF_RE(buffer[len+offset-1][bd]) * QMF_RE(buffer[len+offset-2][bd]) +
  259.         QMF_RE(buffer[offset-1][bd]) * QMF_RE(buffer[offset-2][bd]);
  260.     RE(ac->r22) = r11 -
  261.         QMF_RE(buffer[len+offset-2][bd]) * QMF_RE(buffer[len+offset-2][bd]) +
  262.         QMF_RE(buffer[offset-2][bd]) * QMF_RE(buffer[offset-2][bd]);
  263. #endif
  264.     RE(ac->r01) = r01;
  265.     RE(ac->r02) = r02;
  266.     RE(ac->r11) = r11;
  268.     ac->det = MUL_R(RE(ac->r11), RE(ac->r22)) - MUL_F(MUL_R(RE(ac->r12), RE(ac->r12)), rel);
  269. }
  270. #else
  271. static void auto_correlation(sbr_info *sbr, acorr_coef *ac, qmf_t buffer[MAX_NTSRHFG][64],
  272.                              uint8_t bd, uint8_t len)
  273. {
  274.     real_t r01r = 0, r01i = 0, r02r = 0, r02i = 0, r11r = 0;
  275.     real_t temp1_r, temp1_i, temp2_r, temp2_i, temp3_r, temp3_i, temp4_r, temp4_i, temp5_r, temp5_i;
  276. #ifdef FIXED_POINT
  277.     const real_t rel = FRAC_CONST(0.999999); // 1 / (1 + 1e-6f);
  278.     uint32_t mask, exp;
  279.     real_t pow2_to_exp;
  280. #else
  281.     const real_t rel = 1 / (1 + 1e-6f);
  282. #endif
  283.     int8_t j;
  284.     uint8_t offset = sbr->tHFAdj;
  286. #ifdef FIXED_POINT
  287.     mask = 0;
  289.     for (j = (offset-2); j < (len + offset); j++)
  290.     {
  291.         real_t x;
  292.         x = QMF_RE(buffer[j][bd])>>REAL_BITS;
  293.         mask |= x ^ (x >> 31);
  294.         x = QMF_IM(buffer[j][bd])>>REAL_BITS;
  295.         mask |= x ^ (x >> 31);
  296.     }
  298.     exp = wl_min_lzc(mask);
  300.     /* improves accuracy */
  301.     if (exp > 0)
  302.         exp -= 1;
  303.    
  304.     pow2_to_exp = 1<<(exp-1);
  306.     temp2_r = (QMF_RE(buffer[offset-2][bd]) + pow2_to_exp) >> exp;
  307.     temp2_i = (QMF_IM(buffer[offset-2][bd]) + pow2_to_exp) >> exp;
  308.     temp3_r = (QMF_RE(buffer[offset-1][bd]) + pow2_to_exp) >> exp;
  309.     temp3_i = (QMF_IM(buffer[offset-1][bd]) + pow2_to_exp) >> exp;
  310.     // Save these because they are needed after loop
  311.     temp4_r = temp2_r;
  312.     temp4_i = temp2_i;
  313.     temp5_r = temp3_r;
  314.     temp5_i = temp3_i;
  316.     for (j = offset; j < len + offset; j++)
  317.     {
  318.      temp1_r = temp2_r; // temp1_r = (QMF_RE(buffer[offset-2][bd] + (1<<(exp-1))) >> exp;
  319.      temp1_i = temp2_i; // temp1_i = (QMF_IM(buffer[offset-2][bd] + (1<<(exp-1))) >> exp;
  320.      temp2_r = temp3_r; // temp2_r = (QMF_RE(buffer[offset-1][bd] + (1<<(exp-1))) >> exp;
  321.      temp2_i = temp3_i; // temp2_i = (QMF_IM(buffer[offset-1][bd] + (1<<(exp-1))) >> exp;
  322.         temp3_r = (QMF_RE(buffer[j][bd]) + pow2_to_exp) >> exp;
  323.         temp3_i = (QMF_IM(buffer[j][bd]) + pow2_to_exp) >> exp;
  324.         r01r += MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i);
  325.         r01i += MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i);
  326.         r02r += MUL_R(temp3_r, temp1_r) + MUL_R(temp3_i, temp1_i);
  327.         r02i += MUL_R(temp3_i, temp1_r) - MUL_R(temp3_r, temp1_i);
  328.         r11r += MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i);
  329.     }
  331.     // These are actual values in temporary variable at this point
  332.     // temp1_r = (QMF_RE(buffer[len+offset-1-2][bd] + (1<<(exp-1))) >> exp;
  333.     // temp1_i = (QMF_IM(buffer[len+offset-1-2][bd] + (1<<(exp-1))) >> exp;
  334.     // temp2_r = (QMF_RE(buffer[len+offset-1-1][bd] + (1<<(exp-1))) >> exp;
  335.     // temp2_i = (QMF_IM(buffer[len+offset-1-1][bd] + (1<<(exp-1))) >> exp;
  336.     // temp3_r = (QMF_RE(buffer[len+offset-1][bd]) + (1<<(exp-1))) >> exp;
  337.     // temp3_i = (QMF_IM(buffer[len+offset-1][bd]) + (1<<(exp-1))) >> exp;
  338.     // temp4_r = (QMF_RE(buffer[offset-2][bd]) + (1<<(exp-1))) >> exp;
  339.     // temp4_i = (QMF_IM(buffer[offset-2][bd]) + (1<<(exp-1))) >> exp;
  340.     // temp5_r = (QMF_RE(buffer[offset-1][bd]) + (1<<(exp-1))) >> exp;
  341.     // temp5_i = (QMF_IM(buffer[offset-1][bd]) + (1<<(exp-1))) >> exp;
  343.     RE(ac->r12) = r01r -
  344.         (MUL_R(temp3_r, temp2_r) + MUL_R(temp3_i, temp2_i)) +
  345.         (MUL_R(temp5_r, temp4_r) + MUL_R(temp5_i, temp4_i));
  346.     IM(ac->r12) = r01i -
  347.         (MUL_R(temp3_i, temp2_r) - MUL_R(temp3_r, temp2_i)) +
  348.         (MUL_R(temp5_i, temp4_r) - MUL_R(temp5_r, temp4_i));
  349.     RE(ac->r22) = r11r -
  350.         (MUL_R(temp2_r, temp2_r) + MUL_R(temp2_i, temp2_i)) +
  351.         (MUL_R(temp4_r, temp4_r) + MUL_R(temp4_i, temp4_i));
  353. #else
  355.     temp2_r = QMF_RE(buffer[offset-2][bd]);
  356.     temp2_i = QMF_IM(buffer[offset-2][bd]);
  357.     temp3_r = QMF_RE(buffer[offset-1][bd]);
  358.     temp3_i = QMF_IM(buffer[offset-1][bd]);
  359.     // Save these because they are needed after loop
  360.     temp4_r = temp2_r;
  361.     temp4_i = temp2_i;
  362.     temp5_r = temp3_r;
  363.     temp5_i = temp3_i;
  365.     for (j = offset; j < len + offset; j++)
  366.     {
  367.      temp1_r = temp2_r; // temp1_r = QMF_RE(buffer[j-2][bd];
  368.      temp1_i = temp2_i; // temp1_i = QMF_IM(buffer[j-2][bd];
  369.      temp2_r = temp3_r; // temp2_r = QMF_RE(buffer[j-1][bd];
  370.      temp2_i = temp3_i; // temp2_i = QMF_IM(buffer[j-1][bd];
  371.         temp3_r = QMF_RE(buffer[j][bd]);
  372.         temp3_i = QMF_IM(buffer[j][bd]);
  373.         r01r += temp3_r * temp2_r + temp3_i * temp2_i;
  374.         r01i += temp3_i * temp2_r - temp3_r * temp2_i;
  375.         r02r += temp3_r * temp1_r + temp3_i * temp1_i;
  376.         r02i += temp3_i * temp1_r - temp3_r * temp1_i;
  377.         r11r += temp2_r * temp2_r + temp2_i * temp2_i;
  378.     }
  380.     // These are actual values in temporary variable at this point
  381.     // temp1_r = QMF_RE(buffer[len+offset-1-2][bd];
  382.     // temp1_i = QMF_IM(buffer[len+offset-1-2][bd];
  383.     // temp2_r = QMF_RE(buffer[len+offset-1-1][bd];
  384.     // temp2_i = QMF_IM(buffer[len+offset-1-1][bd];
  385.     // temp3_r = QMF_RE(buffer[len+offset-1][bd]);
  386.     // temp3_i = QMF_IM(buffer[len+offset-1][bd]);
  387.     // temp4_r = QMF_RE(buffer[offset-2][bd]);
  388.     // temp4_i = QMF_IM(buffer[offset-2][bd]);
  389.     // temp5_r = QMF_RE(buffer[offset-1][bd]);
  390.     // temp5_i = QMF_IM(buffer[offset-1][bd]);
  392.     RE(ac->r12) = r01r -
  393.         (temp3_r * temp2_r + temp3_i * temp2_i) +
  394.         (temp5_r * temp4_r + temp5_i * temp4_i);
  395.     IM(ac->r12) = r01i -
  396.         (temp3_i * temp2_r - temp3_r * temp2_i) +
  397.         (temp5_i * temp4_r - temp5_r * temp4_i);
  398.     RE(ac->r22) = r11r -
  399.         (temp2_r * temp2_r + temp2_i * temp2_i) +
  400.         (temp4_r * temp4_r + temp4_i * temp4_i);
  402. #endif
  404.     RE(ac->r01) = r01r;
  405.     IM(ac->r01) = r01i;
  406.     RE(ac->r02) = r02r;
  407.     IM(ac->r02) = r02i;
  408.     RE(ac->r11) = r11r;
  410.     ac->det = MUL_R(RE(ac->r11), RE(ac->r22)) - MUL_F(rel, (MUL_R(RE(ac->r12), RE(ac->r12)) + MUL_R(IM(ac->r12), IM(ac->r12))));
  411. }
  412. #endif
  414. /* calculate linear prediction coefficients using the covariance method */
  415. #ifndef SBR_LOW_POWER
  416. static void calc_prediction_coef(sbr_info *sbr, qmf_t Xlow[MAX_NTSRHFG][64],
  417.                                  complex_t *alpha_0, complex_t *alpha_1, uint8_t k)
  418. {
  419.     real_t tmp;
  420.     acorr_coef ac;
  422.     auto_correlation(sbr, &ac, Xlow, k, sbr->numTimeSlotsRate + 6);
  424.     if (ac.det == 0)
  425.     {
  426.         RE(alpha_1[k]) = 0;
  427.         IM(alpha_1[k]) = 0;
  428.     } else {
  429. #ifdef FIXED_POINT
  430.         tmp = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11)));
  431.         RE(alpha_1[k]) = DIV_R(tmp, ac.det);
  432.         tmp = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11)));
  433.         IM(alpha_1[k]) = DIV_R(tmp, ac.det);
  434. #else
  435.         tmp = REAL_CONST(1.0) / ac.det;
  436.         RE(alpha_1[k]) = (MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(IM(ac.r01), IM(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11))) * tmp;
  437.         IM(alpha_1[k]) = (MUL_R(IM(ac.r01), RE(ac.r12)) + MUL_R(RE(ac.r01), IM(ac.r12)) - MUL_R(IM(ac.r02), RE(ac.r11))) * tmp;
  438. #endif
  439.     }
  441.     if (RE(ac.r11) == 0)
  442.     {
  443.         RE(alpha_0[k]) = 0;
  444.         IM(alpha_0[k]) = 0;
  445.     } else {
  446. #ifdef FIXED_POINT
  447.         tmp = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12)));
  448.         RE(alpha_0[k]) = DIV_R(tmp, RE(ac.r11));
  449.         tmp = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12)));
  450.         IM(alpha_0[k]) = DIV_R(tmp, RE(ac.r11));
  451. #else
  452.         tmp = 1.0f / RE(ac.r11);
  453.         RE(alpha_0[k]) = -(RE(ac.r01) + MUL_R(RE(alpha_1[k]), RE(ac.r12)) + MUL_R(IM(alpha_1[k]), IM(ac.r12))) * tmp;
  454.         IM(alpha_0[k]) = -(IM(ac.r01) + MUL_R(IM(alpha_1[k]), RE(ac.r12)) - MUL_R(RE(alpha_1[k]), IM(ac.r12))) * tmp;
  455. #endif
  456.     }
  458.     if ((MUL_R(RE(alpha_0[k]),RE(alpha_0[k])) + MUL_R(IM(alpha_0[k]),IM(alpha_0[k])) >= REAL_CONST(16)) ||
  459.         (MUL_R(RE(alpha_1[k]),RE(alpha_1[k])) + MUL_R(IM(alpha_1[k]),IM(alpha_1[k])) >= REAL_CONST(16)))
  460.     {
  461.         RE(alpha_0[k]) = 0;
  462.         IM(alpha_0[k]) = 0;
  463.         RE(alpha_1[k]) = 0;
  464.         IM(alpha_1[k]) = 0;
  465.     }
  466. }
  467. #else
  468. static void calc_prediction_coef_lp(sbr_info *sbr, qmf_t Xlow[MAX_NTSRHFG][64],
  469.                                     complex_t *alpha_0, complex_t *alpha_1, real_t *rxx)
  470. {
  471.     uint8_t k;
  472.     real_t tmp;
  473.     acorr_coef ac;
  475.     for (k = 1; k < sbr->f_master[0]; k++)
  476.     {
  477.         auto_correlation(sbr, &ac, Xlow, k, sbr->numTimeSlotsRate + 6);
  479.         if (ac.det == 0)
  480.         {
  481.             RE(alpha_0[k]) = 0;
  482.             RE(alpha_1[k]) = 0;
  483.         } else {
  484.             tmp = MUL_R(RE(ac.r01), RE(ac.r22)) - MUL_R(RE(ac.r12), RE(ac.r02));
  485.             RE(alpha_0[k]) = DIV_R(tmp, (-ac.det));
  487.             tmp = MUL_R(RE(ac.r01), RE(ac.r12)) - MUL_R(RE(ac.r02), RE(ac.r11));
  488.             RE(alpha_1[k]) = DIV_R(tmp, ac.det);
  489.         }
  491.         if ((RE(alpha_0[k]) >= REAL_CONST(4)) || (RE(alpha_1[k]) >= REAL_CONST(4)))
  492.         {
  493.             RE(alpha_0[k]) = REAL_CONST(0);
  494.             RE(alpha_1[k]) = REAL_CONST(0);
  495.         }
  497.         /* reflection coefficient */
  498.         if (RE(ac.r11) == 0)
  499.         {
  500.             rxx[k] = COEF_CONST(0.0);
  501.         } else {
  502.             rxx[k] = DIV_C(RE(ac.r01), RE(ac.r11));
  503.             rxx[k] = -rxx[k];
  504.             if (rxx[k] > COEF_CONST(1.0)) rxx[k] = COEF_CONST(1.0);
  505.             if (rxx[k] < COEF_CONST(-1.0)) rxx[k] = COEF_CONST(-1.0);
  506.         }
  507.     }
  508. }
  510. static void calc_aliasing_degree(sbr_info *sbr, real_t *rxx, real_t *deg)
  511. {
  512.     uint8_t k;
  514.     rxx[0] = COEF_CONST(0.0);
  515.     deg[1] = COEF_CONST(0.0);
  517.     for (k = 2; k < sbr->k0; k++)
  518.     {
  519.         deg[k] = 0.0;
  521.         if ((k % 2 == 0) && (rxx[k] < COEF_CONST(0.0)))
  522.         {
  523.             if (rxx[k-1] < 0.0)
  524.             {
  525.                 deg[k] = COEF_CONST(1.0);
  527.                 if (rxx[k-2] > COEF_CONST(0.0))
  528.                 {
  529.                     deg[k-1] = COEF_CONST(1.0) - MUL_C(rxx[k-1], rxx[k-1]);
  530.                 }
  531.             } else if (rxx[k-2] > COEF_CONST(0.0)) {
  532.                 deg[k] = COEF_CONST(1.0) - MUL_C(rxx[k-1], rxx[k-1]);
  533.             }
  534.         }
  536.         if ((k % 2 == 1) && (rxx[k] > COEF_CONST(0.0)))
  537.         {
  538.             if (rxx[k-1] > COEF_CONST(0.0))
  539.             {
  540.                 deg[k] = COEF_CONST(1.0);
  542.                 if (rxx[k-2] < COEF_CONST(0.0))
  543.                 {
  544.                     deg[k-1] = COEF_CONST(1.0) - MUL_C(rxx[k-1], rxx[k-1]);
  545.                 }
  546.             } else if (rxx[k-2] < COEF_CONST(0.0)) {
  547.                 deg[k] = COEF_CONST(1.0) - MUL_C(rxx[k-1], rxx[k-1]);
  548.             }
  549.         }
  550.     }
  551. }
  552. #endif
  554. /* FIXED POINT: bwArray = COEF */
  555. static real_t mapNewBw(uint8_t invf_mode, uint8_t invf_mode_prev)
  556. {
  557.     switch (invf_mode)
  558.     {
  559.     case 1: /* LOW */
  560.         if (invf_mode_prev == 0) /* NONE */
  561.             return COEF_CONST(0.6);
  562.         else
  563.             return COEF_CONST(0.75);
  565.     case 2: /* MID */
  566.         return COEF_CONST(0.9);
  568.     case 3: /* HIGH */
  569.         return COEF_CONST(0.98);
  571.     default: /* NONE */
  572.         if (invf_mode_prev == 1) /* LOW */
  573.             return COEF_CONST(0.6);
  574.         else
  575.             return COEF_CONST(0.0);
  576.     }
  577. }
  579. /* FIXED POINT: bwArray = COEF */
  580. static void calc_chirp_factors(sbr_info *sbr, uint8_t ch)
  581. {
  582.     uint8_t i;
  584.     for (i = 0; i < sbr->N_Q; i++)
  585.     {
  586.         sbr->bwArray[ch][i] = mapNewBw(sbr->bs_invf_mode[ch][i], sbr->bs_invf_mode_prev[ch][i]);
  588.         if (sbr->bwArray[ch][i] < sbr->bwArray_prev[ch][i])
  589.             sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.75)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.25));
  590.         else
  591.             sbr->bwArray[ch][i] = MUL_F(sbr->bwArray[ch][i], FRAC_CONST(0.90625)) + MUL_F(sbr->bwArray_prev[ch][i], FRAC_CONST(0.09375));
  593.         if (sbr->bwArray[ch][i] < COEF_CONST(0.015625))
  594.             sbr->bwArray[ch][i] = COEF_CONST(0.0);
  596.         if (sbr->bwArray[ch][i] >= COEF_CONST(0.99609375))
  597.             sbr->bwArray[ch][i] = COEF_CONST(0.99609375);
  599.         sbr->bwArray_prev[ch][i] = sbr->bwArray[ch][i];
  600.         sbr->bs_invf_mode_prev[ch][i] = sbr->bs_invf_mode[ch][i];
  601.     }
  602. }
  604. static void patch_construction(sbr_info *sbr)
  605. {
  606.     uint8_t i, k;
  607.     uint8_t odd, sb;
  608.     uint8_t msb = sbr->k0;
  609.     uint8_t usb = sbr->kx;
  610.     uint8_t goalSbTab[] = { 21, 23, 32, 43, 46, 64, 85, 93, 128, 0, 0, 0 };
  611.     /* (uint8_t)(2.048e6/sbr->sample_rate + 0.5); */
  612.     uint8_t goalSb = goalSbTab[get_sr_index(sbr->sample_rate)];
  614.     sbr->noPatches = 0;
  616.     if (goalSb < (sbr->kx + sbr->M))
  617.     {
  618.         for (i = 0, k = 0; sbr->f_master[i] < goalSb; i++)
  619.             k = i+1;
  620.     } else {
  621.         k = sbr->N_master;
  622.     }
  624.     if (sbr->N_master == 0)
  625.     {
  626.         sbr->noPatches = 0;
  627.         sbr->patchNoSubbands[0] = 0;
  628.         sbr->patchStartSubband[0] = 0;
  630.         return;
  631.     }
  633.     do
  634.     {
  635.         uint8_t j = k + 1;
  637.         do
  638.         {
  639.             j--;
  641.             sb = sbr->f_master[j];
  642.             odd = (sb - 2 + sbr->k0) % 2;
  643.         } while (sb > (sbr->k0 - 1 + msb - odd));
  645.         sbr->patchNoSubbands[sbr->noPatches] = max(sb - usb, 0);
  646.         sbr->patchStartSubband[sbr->noPatches] = sbr->k0 - odd -
  647.             sbr->patchNoSubbands[sbr->noPatches];
  649.         if (sbr->patchNoSubbands[sbr->noPatches] > 0)
  650.         {
  651.             usb = sb;
  652.             msb = sb;
  653.             sbr->noPatches++;
  654.         } else {
  655.             msb = sbr->kx;
  656.         }
  658.         if (sbr->f_master[k] - sb < 3)
  659.             k = sbr->N_master;
  660.     } while (sb != (sbr->kx + sbr->M));
  662.     if ((sbr->patchNoSubbands[sbr->noPatches-1] < 3) && (sbr->noPatches > 1))
  663.     {
  664.         sbr->noPatches--;
  665.     }
  667.     sbr->noPatches = min(sbr->noPatches, 5);
  668. }
  670. #endif