falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
76541 Commits
32 Branches
380MB
Tree: 8a024f6a43
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8a024f6a43'
${ noResults }
FFmpeg/libavcodec/aacsbr_fixed.c

587 lines
22KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2013

  3.  *      MIPS Technologies, Inc., California.

  4.  *

  5.  * Redistribution and use in source and binary forms, with or without

  6.  * modification, are permitted provided that the following conditions

  7.  * are met:

  8.  * 1. Redistributions of source code must retain the above copyright

  9.  *    notice, this list of conditions and the following disclaimer.

  10.  * 2. Redistributions in binary form must reproduce the above copyright

  11.  *    notice, this list of conditions and the following disclaimer in the

  12.  *    documentation and/or other materials provided with the distribution.

  13.  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its

  14.  *    contributors may be used to endorse or promote products derived from

  15.  *    this software without specific prior written permission.

  16.  *

  17.  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND

  18.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  19.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  20.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE

  21.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  22.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

  23.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

  24.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

  25.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

  26.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  27.  * SUCH DAMAGE.

  28.  *

  29.  * AAC Spectral Band Replication decoding functions (fixed-point)

  30.  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )

  31.  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>

  32.  *

  33.  * This file is part of FFmpeg.

  34.  *

  35.  * FFmpeg is free software; you can redistribute it and/or

  36.  * modify it under the terms of the GNU Lesser General Public

  37.  * License as published by the Free Software Foundation; either

  38.  * version 2.1 of the License, or (at your option) any later version.

  39.  *

  40.  * FFmpeg is distributed in the hope that it will be useful,

  41.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  42.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  43.  * Lesser General Public License for more details.

  44.  *

  45.  * You should have received a copy of the GNU Lesser General Public

  46.  * License along with FFmpeg; if not, write to the Free Software

  47.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  48.  */

  49. 

  50. /**

  51.  * @file

  52.  * AAC Spectral Band Replication decoding functions (fixed-point)

  53.  * Note: Rounding-to-nearest used unless otherwise stated

  54.  * @author Robert Swain ( rob opendot cl )

  55.  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )

  56.  */

  57. #define USE_FIXED 1

  58. 

  59. #include "aac.h"

  60. #include "sbr.h"

  61. #include "aacsbr.h"

  62. #include "aacsbrdata.h"

  63. #include "aacsbr_fixed_tablegen.h"

  64. #include "fft.h"

  65. #include "aacps.h"

  66. #include "sbrdsp.h"

  67. #include "libavutil/internal.h"

  68. #include "libavutil/libm.h"

  69. #include "libavutil/avassert.h"

  70. 

  71. #include <stdint.h>

  72. #include <float.h>

  73. #include <math.h>

  74. 

  75. static VLC vlc_sbr[10];

  76. static void aacsbr_func_ptr_init(AACSBRContext *c);

  77. static const int CONST_LN2       = Q31(0.6931471806/256);  // ln(2)/256

  78. static const int CONST_RECIP_LN2 = Q31(0.7213475204);      // 0.5/ln(2)

  79. static const int CONST_076923    = Q31(0.76923076923076923077f);

  80. 

  81. static const int fixed_log_table[10] =

  82. {

  83.     Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),

  84.     Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)

  85. };

  86. 

  87. static int fixed_log(int x)

  88. {

  89.     int i, ret, xpow, tmp;

  90. 

  91.     ret = x;

  92.     xpow = x;

  93.     for (i=0; i<10; i+=2){

  94.         xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);

  95.         tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);

  96.         ret -= tmp;

  97. 

  98.         xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);

  99.         tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);

  100.         ret += tmp;

  101.     }

  102. 

  103.     return ret;

  104. }

  105. 

  106. static const int fixed_exp_table[7] =

  107. {

  108.     Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),

  109.     Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)

  110. };

  111. 

  112. static int fixed_exp(int x)

  113. {

  114.     int i, ret, xpow, tmp;

  115. 

  116.     ret = 0x800000 + x;

  117.     xpow = x;

  118.     for (i=0; i<7; i++){

  119.         xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);

  120.         tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);

  121.         ret += tmp;

  122.     }

  123. 

  124.     return ret;

  125. }

  126. 

  127. static void make_bands(int16_t* bands, int start, int stop, int num_bands)

  128. {

  129.     int k, previous, present;

  130.     int base, prod, nz = 0;

  131. 

  132.     base = (stop << 23) / start;

  133.     while (base < 0x40000000){

  134.         base <<= 1;

  135.         nz++;

  136.     }

  137.     base = fixed_log(base - 0x80000000);

  138.     base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;

  139.     base = fixed_exp(base);

  140. 

  141.     previous = start;

  142.     prod = start << 23;

  143. 

  144.     for (k = 0; k < num_bands-1; k++) {

  145.         prod = (int)(((int64_t)prod * base + 0x400000) >> 23);

  146.         present = (prod + 0x400000) >> 23;

  147.         bands[k] = present - previous;

  148.         previous = present;

  149.     }

  150.     bands[num_bands-1] = stop - previous;

  151. }

  152. 

  153. /// Dequantization and stereo decoding (14496-3 sp04 p203)

  154. static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)

  155. {

  156.     int k, e;

  157.     int ch;

  158. 

  159.     if (id_aac == TYPE_CPE && sbr->bs_coupling) {

  160.         int alpha      = sbr->data[0].bs_amp_res ?  2 :  1;

  161.         int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;

  162.         for (e = 1; e <= sbr->data[0].bs_num_env; e++) {

  163.             for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {

  164.                 SoftFloat temp1, temp2, fac;

  165. 

  166.                 temp1.exp = sbr->data[0].env_facs[e][k].mant * alpha + 14;

  167.                 if (temp1.exp & 1)

  168.                   temp1.mant = 759250125;

  169.                 else

  170.                   temp1.mant = 0x20000000;

  171.                 temp1.exp = (temp1.exp >> 1) + 1;

  172. 

  173.                 temp2.exp = (pan_offset - sbr->data[1].env_facs[e][k].mant) * alpha;

  174.                 if (temp2.exp & 1)

  175.                   temp2.mant = 759250125;

  176.                 else

  177.                   temp2.mant = 0x20000000;

  178.                 temp2.exp = (temp2.exp >> 1) + 1;

  179.                 fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));

  180.                 sbr->data[0].env_facs[e][k] = fac;

  181.                 sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);

  182.             }

  183.         }

  184.         for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {

  185.             for (k = 0; k < sbr->n_q; k++) {

  186.                 SoftFloat temp1, temp2, fac;

  187. 

  188.                 temp1.exp = NOISE_FLOOR_OFFSET - \

  189.                     sbr->data[0].noise_facs[e][k].mant + 2;

  190.                 temp1.mant = 0x20000000;

  191.                 temp2.exp = 12 - sbr->data[1].noise_facs[e][k].mant + 1;

  192.                 temp2.mant = 0x20000000;

  193.                 fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));

  194.                 sbr->data[0].noise_facs[e][k] = fac;

  195.                 sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);

  196.             }

  197.         }

  198.     } else { // SCE or one non-coupled CPE

  199.         for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {

  200.             int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;

  201.             for (e = 1; e <= sbr->data[ch].bs_num_env; e++)

  202.                 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){

  203.                     SoftFloat temp1;

  204. 

  205.                     temp1.exp = alpha * sbr->data[ch].env_facs[e][k].mant + 12;

  206.                     if (temp1.exp & 1)

  207.                         temp1.mant = 759250125;

  208.                     else

  209.                         temp1.mant = 0x20000000;

  210.                     temp1.exp = (temp1.exp >> 1) + 1;

  211. 

  212.                     sbr->data[ch].env_facs[e][k] = temp1;

  213.                 }

  214.             for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)

  215.                 for (k = 0; k < sbr->n_q; k++){

  216.                     sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \

  217.                         sbr->data[ch].noise_facs[e][k].mant + 1;

  218.                     sbr->data[ch].noise_facs[e][k].mant = 0x20000000;

  219.                 }

  220.         }

  221.     }

  222. }

  223. 

  224. /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering

  225.  * (14496-3 sp04 p214)

  226.  * Warning: This routine does not seem numerically stable.

  227.  */

  228. static void sbr_hf_inverse_filter(SBRDSPContext *dsp,

  229.                                   int (*alpha0)[2], int (*alpha1)[2],

  230.                                   const int X_low[32][40][2], int k0)

  231. {

  232.     int k;

  233.     int shift, round;

  234. 

  235.     for (k = 0; k < k0; k++) {

  236.         SoftFloat phi[3][2][2];

  237.         SoftFloat a00, a01, a10, a11;

  238.         SoftFloat dk;

  239. 

  240.         dsp->autocorrelate(X_low[k], phi);

  241. 

  242.         dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),

  243.              av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),

  244.              av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));

  245. 

  246.         if (!dk.mant) {

  247.             a10 = FLOAT_0;

  248.             a11 = FLOAT_0;

  249.         } else {

  250.             SoftFloat temp_real, temp_im;

  251.             temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),

  252.                                             av_mul_sf(phi[0][0][1], phi[1][1][1])),

  253.                                   av_mul_sf(phi[0][1][0], phi[1][0][0]));

  254.             temp_im   = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),

  255.                                             av_mul_sf(phi[0][0][1], phi[1][1][0])),

  256.                                   av_mul_sf(phi[0][1][1], phi[1][0][0]));

  257. 

  258.             a10 = av_div_sf(temp_real, dk);

  259.             a11 = av_div_sf(temp_im,   dk);

  260.         }

  261. 

  262.         if (!phi[1][0][0].mant) {

  263.             a00 = FLOAT_0;

  264.             a01 = FLOAT_0;

  265.         } else {

  266.             SoftFloat temp_real, temp_im;

  267.             temp_real = av_add_sf(phi[0][0][0],

  268.                                   av_add_sf(av_mul_sf(a10, phi[1][1][0]),

  269.                                             av_mul_sf(a11, phi[1][1][1])));

  270.             temp_im   = av_add_sf(phi[0][0][1],

  271.                                   av_sub_sf(av_mul_sf(a11, phi[1][1][0]),

  272.                                             av_mul_sf(a10, phi[1][1][1])));

  273. 

  274.             temp_real.mant = -temp_real.mant;

  275.             temp_im.mant   = -temp_im.mant;

  276.             a00 = av_div_sf(temp_real, phi[1][0][0]);

  277.             a01 = av_div_sf(temp_im,   phi[1][0][0]);

  278.         }

  279. 

  280.         shift = a00.exp;

  281.         if (shift >= 3)

  282.             alpha0[k][0] = 0x7fffffff;

  283.         else {

  284.             a00.mant <<= 1;

  285.             shift = 2-shift;

  286.             if (shift == 0)

  287.                 alpha0[k][0] = a00.mant;

  288.             else {

  289.                 round = 1 << (shift-1);

  290.                 alpha0[k][0] = (a00.mant + round) >> shift;

  291.             }

  292.         }

  293. 

  294.         shift = a01.exp;

  295.         if (shift >= 3)

  296.             alpha0[k][1] = 0x7fffffff;

  297.         else {

  298.             a01.mant <<= 1;

  299.             shift = 2-shift;

  300.             if (shift == 0)

  301.                 alpha0[k][1] = a01.mant;

  302.             else {

  303.                 round = 1 << (shift-1);

  304.                 alpha0[k][1] = (a01.mant + round) >> shift;

  305.             }

  306.         }

  307.         shift = a10.exp;

  308.         if (shift >= 3)

  309.             alpha1[k][0] = 0x7fffffff;

  310.         else {

  311.             a10.mant <<= 1;

  312.             shift = 2-shift;

  313.             if (shift == 0)

  314.                 alpha1[k][0] = a10.mant;

  315.             else {

  316.                 round = 1 << (shift-1);

  317.                 alpha1[k][0] = (a10.mant + round) >> shift;

  318.             }

  319.         }

  320. 

  321.         shift = a11.exp;

  322.         if (shift >= 3)

  323.             alpha1[k][1] = 0x7fffffff;

  324.         else {

  325.             a11.mant <<= 1;

  326.             shift = 2-shift;

  327.             if (shift == 0)

  328.                 alpha1[k][1] = a11.mant;

  329.             else {

  330.                 round = 1 << (shift-1);

  331.                 alpha1[k][1] = (a11.mant + round) >> shift;

  332.             }

  333.         }

  334. 

  335.         shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \

  336.                        (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \

  337.                        0x40000000) >> 31);

  338.         if (shift >= 0x20000000){

  339.             alpha1[k][0] = 0;

  340.             alpha1[k][1] = 0;

  341.             alpha0[k][0] = 0;

  342.             alpha0[k][1] = 0;

  343.         }

  344. 

  345.         shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \

  346.                        (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \

  347.                        0x40000000) >> 31);

  348.         if (shift >= 0x20000000){

  349.             alpha1[k][0] = 0;

  350.             alpha1[k][1] = 0;

  351.             alpha0[k][0] = 0;

  352.             alpha0[k][1] = 0;

  353.         }

  354.     }

  355. }

  356. 

  357. /// Chirp Factors (14496-3 sp04 p214)

  358. static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)

  359. {

  360.     int i;

  361.     int new_bw;

  362.     static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };

  363.     int64_t accu;

  364. 

  365.     for (i = 0; i < sbr->n_q; i++) {

  366.         if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)

  367.             new_bw = 1288490189;

  368.         else

  369.             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];

  370. 

  371.         if (new_bw < ch_data->bw_array[i]){

  372.             accu  = (int64_t)new_bw * 1610612736;

  373.             accu += (int64_t)ch_data->bw_array[i] * 0x20000000;

  374.             new_bw = (int)((accu + 0x40000000) >> 31);

  375.         } else {

  376.             accu  = (int64_t)new_bw * 1946157056;

  377.             accu += (int64_t)ch_data->bw_array[i] * 201326592;

  378.             new_bw = (int)((accu + 0x40000000) >> 31);

  379.         }

  380.         ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;

  381.     }

  382. }

  383. 

  384. /**

  385.  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)

  386.  * and Calculation of gain (14496-3 sp04 p219)

  387.  */

  388. static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,

  389.                           SBRData *ch_data, const int e_a[2])

  390. {

  391.     int e, k, m;

  392.     // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)

  393.     static const SoftFloat limgain[4] = { { 760155524,  0 }, { 0x20000000,  1 },

  394.                                             { 758351638,  1 }, { 625000000, 34 } };

  395. 

  396.     for (e = 0; e < ch_data->bs_num_env; e++) {

  397.         int delta = !((e == e_a[1]) || (e == e_a[0]));

  398.         for (k = 0; k < sbr->n_lim; k++) {

  399.             SoftFloat gain_boost, gain_max;

  400.             SoftFloat sum[2];

  401.             sum[0] = sum[1] = FLOAT_0;

  402.             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

  403.                 const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],

  404.                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));

  405.                 sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));

  406.                 sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));

  407.                 if (!sbr->s_mapped[e][m]) {

  408.                     if (delta) {

  409.                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],

  410.                                             av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),

  411.                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));

  412.                     } else {

  413.                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],

  414.                                             av_add_sf(FLOAT_1, sbr->e_curr[e][m])));

  415.                     }

  416.                 } else {

  417.                     sbr->gain[e][m] = av_sqrt_sf(

  418.                                         av_div_sf(

  419.                                             av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),

  420.                                             av_mul_sf(

  421.                                                 av_add_sf(FLOAT_1, sbr->e_curr[e][m]),

  422.                                                 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));

  423.                 }

  424.             }

  425.             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

  426.                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);

  427.                 sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);

  428.             }

  429.             gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],

  430.                             av_sqrt_sf(

  431.                                 av_div_sf(

  432.                                     av_add_sf(FLOAT_EPSILON, sum[0]),

  433.                                     av_add_sf(FLOAT_EPSILON, sum[1]))));

  434.             if (av_gt_sf(gain_max, FLOAT_100000))

  435.               gain_max = FLOAT_100000;

  436.             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

  437.                 SoftFloat q_m_max = av_div_sf(

  438.                                         av_mul_sf(sbr->q_m[e][m], gain_max),

  439.                                         sbr->gain[e][m]);

  440.                 if (av_gt_sf(sbr->q_m[e][m], q_m_max))

  441.                   sbr->q_m[e][m] = q_m_max;

  442.                 if (av_gt_sf(sbr->gain[e][m], gain_max))

  443.                   sbr->gain[e][m] = gain_max;

  444.             }

  445.             sum[0] = sum[1] = FLOAT_0;

  446.             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

  447.                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);

  448.                 sum[1] = av_add_sf(sum[1],

  449.                             av_mul_sf(

  450.                                 av_mul_sf(sbr->e_curr[e][m],

  451.                                           sbr->gain[e][m]),

  452.                                 sbr->gain[e][m]));

  453.                 sum[1] = av_add_sf(sum[1],

  454.                             av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));

  455.                 if (delta && !sbr->s_m[e][m].mant)

  456.                   sum[1] = av_add_sf(sum[1],

  457.                                 av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));

  458.             }

  459.             gain_boost = av_sqrt_sf(

  460.                             av_div_sf(

  461.                                 av_add_sf(FLOAT_EPSILON, sum[0]),

  462.                                 av_add_sf(FLOAT_EPSILON, sum[1])));

  463.             if (av_gt_sf(gain_boost, FLOAT_1584893192))

  464.               gain_boost = FLOAT_1584893192;

  465. 

  466.             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

  467.                 sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);

  468.                 sbr->q_m[e][m]  = av_mul_sf(sbr->q_m[e][m], gain_boost);

  469.                 sbr->s_m[e][m]  = av_mul_sf(sbr->s_m[e][m], gain_boost);

  470.             }

  471.         }

  472.     }

  473. }

  474. 

  475. /// Assembling HF Signals (14496-3 sp04 p220)

  476. static void sbr_hf_assemble(int Y1[38][64][2],

  477.                             const int X_high[64][40][2],

  478.                             SpectralBandReplication *sbr, SBRData *ch_data,

  479.                             const int e_a[2])

  480. {

  481.     int e, i, j, m;

  482.     const int h_SL = 4 * !sbr->bs_smoothing_mode;

  483.     const int kx = sbr->kx[1];

  484.     const int m_max = sbr->m[1];

  485.     static const SoftFloat h_smooth[5] = {

  486.       { 715827883, -1 },

  487.       { 647472402, -1 },

  488.       { 937030863, -2 },

  489.       { 989249804, -3 },

  490.       { 546843842, -4 },

  491.     };

  492.     SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;

  493.     int indexnoise = ch_data->f_indexnoise;

  494.     int indexsine  = ch_data->f_indexsine;

  495. 

  496.     if (sbr->reset) {

  497.         for (i = 0; i < h_SL; i++) {

  498.             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));

  499.             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));

  500.         }

  501.     } else if (h_SL) {

  502.         for (i = 0; i < 4; i++) {

  503.             memcpy(g_temp[i + 2 * ch_data->t_env[0]],

  504.                    g_temp[i + 2 * ch_data->t_env_num_env_old],

  505.                    sizeof(g_temp[0]));

  506.             memcpy(q_temp[i + 2 * ch_data->t_env[0]],

  507.                    q_temp[i + 2 * ch_data->t_env_num_env_old],

  508.                    sizeof(q_temp[0]));

  509.         }

  510.     }

  511. 

  512.     for (e = 0; e < ch_data->bs_num_env; e++) {

  513.         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {

  514.             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));

  515.             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));

  516.         }

  517.     }

  518. 

  519.     for (e = 0; e < ch_data->bs_num_env; e++) {

  520.         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {

  521.             SoftFloat g_filt_tab[48];

  522.             SoftFloat q_filt_tab[48];

  523.             SoftFloat *g_filt, *q_filt;

  524. 

  525.             if (h_SL && e != e_a[0] && e != e_a[1]) {

  526.                 g_filt = g_filt_tab;

  527.                 q_filt = q_filt_tab;

  528.                 for (m = 0; m < m_max; m++) {

  529.                     const int idx1 = i + h_SL;

  530.                     g_filt[m].mant = g_filt[m].exp = 0;

  531.                     q_filt[m].mant = q_filt[m].exp = 0;

  532.                     for (j = 0; j <= h_SL; j++) {

  533.                         g_filt[m] = av_add_sf(g_filt[m],

  534.                                         av_mul_sf(g_temp[idx1 - j][m],

  535.                                             h_smooth[j]));

  536.                         q_filt[m] = av_add_sf(q_filt[m],

  537.                                         av_mul_sf(q_temp[idx1 - j][m],

  538.                                             h_smooth[j]));

  539.                     }

  540.                 }

  541.             } else {

  542.                 g_filt = g_temp[i + h_SL];

  543.                 q_filt = q_temp[i];

  544.             }

  545. 

  546.             sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,

  547.                                i + ENVELOPE_ADJUSTMENT_OFFSET);

  548. 

  549.             if (e != e_a[0] && e != e_a[1]) {

  550.                 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],

  551.                                                    q_filt, indexnoise,

  552.                                                    kx, m_max);

  553.             } else {

  554.                 int idx = indexsine&1;

  555.                 int A = (1-((indexsine+(kx & 1))&2));

  556.                 int B = (A^(-idx)) + idx;

  557.                 int *out = &Y1[i][kx][idx];

  558.                 int shift, round;

  559. 

  560.                 SoftFloat *in  = sbr->s_m[e];

  561.                 for (m = 0; m+1 < m_max; m+=2) {

  562.                   shift = 22 - in[m  ].exp;

  563.                   round = 1 << (shift-1);

  564.                   out[2*m  ] += (in[m  ].mant * A + round) >> shift;

  565. 

  566.                   shift = 22 - in[m+1].exp;

  567.                   round = 1 << (shift-1);

  568.                   out[2*m+2] += (in[m+1].mant * B + round) >> shift;

  569.                 }

  570.                 if(m_max&1)

  571.                 {

  572.                   shift = 22 - in[m  ].exp;

  573.                   round = 1 << (shift-1);

  574. 

  575.                   out[2*m  ] += (in[m  ].mant * A + round) >> shift;

  576.                 }

  577.             }

  578.             indexnoise = (indexnoise + m_max) & 0x1ff;

  579.             indexsine = (indexsine + 1) & 3;

  580.         }

  581.     }

  582.     ch_data->f_indexnoise = indexnoise;

  583.     ch_data->f_indexsine  = indexsine;

  584. }

  585. 

  586. #include "aacsbr_template.c"