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.
74465 Commits
32 Branches
290MB
Tree: 1907e19d0c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1907e19d0c'
${ 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_SQRT2     = Q30(0.7071067812);      // sqrt(2)/2

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

  81. 

  82. int fixed_log_table[10] =

  83. {

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

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

  86. };

  87. 

  88. static int fixed_log(int x)

  89. {

  90.     int i, ret, xpow, tmp;

  91. 

  92.     ret = x;

  93.     xpow = x;

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

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

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

  97.         ret -= tmp;

  98. 

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

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

  101.         ret += tmp;

  102.     }

  103. 

  104.     return ret;

  105. }

  106. 

  107. int fixed_exp_table[7] =

  108. {

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

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

  111. };

  112. 

  113. static int fixed_exp(int x)

  114. {

  115.     int i, ret, xpow, tmp;

  116. 

  117.     ret = 0x800000 + x;

  118.     xpow = x;

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

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

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

  122.         ret += tmp;

  123.     }

  124. 

  125.     return ret;

  126. }

  127. 

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

  129. {

  130.     int k, previous, present;

  131.     int base, prod, nz = 0;

  132. 

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

  134.     while (base < 0x40000000){

  135.         base <<= 1;

  136.         nz++;

  137.     }

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

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

  140.     base = fixed_exp(base);

  141. 

  142.     previous = start;

  143.     prod = start << 23;

  144. 

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

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

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

  148.         bands[k] = present - previous;

  149.         previous = present;

  150.     }

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

  152. }

  153. 

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

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

  156. {

  157.     int k, e;

  158.     int ch;

  159. 

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

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

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

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

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

  165.                 SoftFloat temp1, temp2, fac;

  166. 

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

  168.                 if (temp1.exp & 1)

  169.                   temp1.mant = 759250125;

  170.                 else

  171.                   temp1.mant = 0x20000000;

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

  173. 

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

  175.                 if (temp2.exp & 1)

  176.                   temp2.mant = 759250125;

  177.                 else

  178.                   temp2.mant = 0x20000000;

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

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

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

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

  183.             }

  184.         }

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

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

  187.                 SoftFloat temp1, temp2, fac;

  188. 

  189.                 temp1.exp = NOISE_FLOOR_OFFSET - \

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

  191.                 temp1.mant = 0x20000000;

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

  193.                 temp2.mant = 0x20000000;

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

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

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

  197.             }

  198.         }

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

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

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

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

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

  204.                     SoftFloat temp1;

  205. 

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

  207.                     if (temp1.exp & 1)

  208.                         temp1.mant = 759250125;

  209.                     else

  210.                         temp1.mant = 0x20000000;

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

  212. 

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

  214.                 }

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

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

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

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

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

  220.                 }

  221.         }

  222.     }

  223. }

  224. 

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

  226.  * (14496-3 sp04 p214)

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

  228.  */

  229. static void sbr_hf_inverse_filter(SBRDSPContext *dsp,

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

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

  232. {

  233.     int k;

  234.     int shift, round;

  235. 

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

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

  238.         SoftFloat a00, a01, a10, a11;

  239.         SoftFloat dk;

  240. 

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

  242. 

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

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

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

  246. 

  247.         if (!dk.mant) {

  248.             a10 = FLOAT_0;

  249.             a11 = FLOAT_0;

  250.         } else {

  251.             SoftFloat temp_real, temp_im;

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

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

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

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

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

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

  258. 

  259.             a10 = av_div_sf(temp_real, dk);

  260.             a11 = av_div_sf(temp_im,   dk);

  261.         }

  262. 

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

  264.             a00 = FLOAT_0;

  265.             a01 = FLOAT_0;

  266.         } else {

  267.             SoftFloat temp_real, temp_im;

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

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

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

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

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

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

  274. 

  275.             temp_real.mant = -temp_real.mant;

  276.             temp_im.mant   = -temp_im.mant;

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

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

  279.         }

  280. 

  281.         shift = a00.exp;

  282.         if (shift >= 3)

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

  284.         else {

  285.             a00.mant <<= 1;

  286.             shift = 2-shift;

  287.             if (shift == 0)

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

  289.             else {

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

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

  292.             }

  293.         }

  294. 

  295.         shift = a01.exp;

  296.         if (shift >= 3)

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

  298.         else {

  299.             a01.mant <<= 1;

  300.             shift = 2-shift;

  301.             if (shift == 0)

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

  303.             else {

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

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

  306.             }

  307.         }

  308.         shift = a10.exp;

  309.         if (shift >= 3)

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

  311.         else {

  312.             a10.mant <<= 1;

  313.             shift = 2-shift;

  314.             if (shift == 0)

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

  316.             else {

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

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

  319.             }

  320.         }

  321. 

  322.         shift = a11.exp;

  323.         if (shift >= 3)

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

  325.         else {

  326.             a11.mant <<= 1;

  327.             shift = 2-shift;

  328.             if (shift == 0)

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

  330.             else {

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

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

  333.             }

  334.         }

  335. 

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

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

  338.                        0x40000000) >> 31);

  339.         if (shift >= 0x20000000){

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

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

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

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

  344.         }

  345. 

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

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

  348.                        0x40000000) >> 31);

  349.         if (shift >= 0x20000000){

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

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

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

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

  354.         }

  355.     }

  356. }

  357. 

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

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

  360. {

  361.     int i;

  362.     int new_bw;

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

  364.     int64_t accu;

  365. 

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

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

  368.             new_bw = 1288490189;

  369.         else

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

  371. 

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

  373.             accu  = (int64_t)new_bw * 1610612736;

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

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

  376.         } else {

  377.             accu  = (int64_t)new_bw * 1946157056;

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

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

  380.         }

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

  382.     }

  383. }

  384. 

  385. /**

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

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

  388.  */

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

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

  391. {

  392.     int e, k, m;

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

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

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

  396. 

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

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

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

  400.             SoftFloat gain_boost, gain_max;

  401.             SoftFloat sum[2] = { { 0, 0}, { 0, 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"