LCOV - code coverage report
Current view: top level - src/libavcodec - aacsbr_fixed.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 265 279 95.0 %
Date: 2017-03-16 17:17:40 Functions: 8 8 100.0 %

          Line data    Source code
       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          24 : static int fixed_log(int x)
      88             : {
      89             :     int i, ret, xpow, tmp;
      90             : 
      91          24 :     ret = x;
      92          24 :     xpow = x;
      93         144 :     for (i=0; i<10; i+=2){
      94         120 :         xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
      95         120 :         tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
      96         120 :         ret -= tmp;
      97             : 
      98         120 :         xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
      99         120 :         tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
     100         120 :         ret += tmp;
     101             :     }
     102             : 
     103          24 :     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          12 : static int fixed_exp(int x)
     113             : {
     114             :     int i, ret, xpow, tmp;
     115             : 
     116          12 :     ret = 0x800000 + x;
     117          12 :     xpow = x;
     118          96 :     for (i=0; i<7; i++){
     119          84 :         xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
     120          84 :         tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
     121          84 :         ret += tmp;
     122             :     }
     123             : 
     124          12 :     return ret;
     125             : }
     126             : 
     127          12 : static void make_bands(int16_t* bands, int start, int stop, int num_bands)
     128             : {
     129             :     int k, previous, present;
     130          12 :     int base, prod, nz = 0;
     131             : 
     132          12 :     base = (stop << 23) / start;
     133          97 :     while (base < 0x40000000){
     134          73 :         base <<= 1;
     135          73 :         nz++;
     136             :     }
     137          12 :     base = fixed_log(base - 0x80000000);
     138          12 :     base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
     139          12 :     base = fixed_exp(base);
     140             : 
     141          12 :     previous = start;
     142          12 :     prod = start << 23;
     143             : 
     144         123 :     for (k = 0; k < num_bands-1; k++) {
     145         111 :         prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
     146         111 :         present = (prod + 0x400000) >> 23;
     147         111 :         bands[k] = present - previous;
     148         111 :         previous = present;
     149             :     }
     150          12 :     bands[num_bands-1] = stop - previous;
     151          12 : }
     152             : 
     153             : /// Dequantization and stereo decoding (14496-3 sp04 p203)
     154        2082 : static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
     155             : {
     156             :     int k, e;
     157             :     int ch;
     158             : 
     159        3362 :     if (id_aac == TYPE_CPE && sbr->bs_coupling) {
     160        1280 :         int alpha      = sbr->data[0].bs_amp_res ?  2 :  1;
     161        1280 :         int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
     162        2922 :         for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
     163       19065 :             for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
     164             :                 SoftFloat temp1, temp2, fac;
     165             : 
     166       17423 :                 temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
     167       17423 :                 if (temp1.exp & 1)
     168        4733 :                   temp1.mant = 759250125;
     169             :                 else
     170       12690 :                   temp1.mant = 0x20000000;
     171       17423 :                 temp1.exp = (temp1.exp >> 1) + 1;
     172       17423 :                 if (temp1.exp > 66) { // temp1 > 1E20
     173           0 :                     av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
     174           0 :                     temp1 = FLOAT_1;
     175             :                 }
     176             : 
     177       17423 :                 temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
     178       17423 :                 if (temp2.exp & 1)
     179           0 :                   temp2.mant = 759250125;
     180             :                 else
     181       17423 :                   temp2.mant = 0x20000000;
     182       17423 :                 temp2.exp = (temp2.exp >> 1) + 1;
     183       17423 :                 fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
     184       17423 :                 sbr->data[0].env_facs[e][k] = fac;
     185       17423 :                 sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
     186             :             }
     187             :         }
     188        2837 :         for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
     189        5699 :             for (k = 0; k < sbr->n_q; k++) {
     190             :                 SoftFloat temp1, temp2, fac;
     191             : 
     192        4142 :                 temp1.exp = NOISE_FLOOR_OFFSET - \
     193        4142 :                     sbr->data[0].noise_facs_q[e][k] + 2;
     194        4142 :                 temp1.mant = 0x20000000;
     195        4142 :                 av_assert0(temp1.exp <= 66);
     196        4142 :                 temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
     197        4142 :                 temp2.mant = 0x20000000;
     198        4142 :                 fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
     199        4142 :                 sbr->data[0].noise_facs[e][k] = fac;
     200        4142 :                 sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
     201             :             }
     202             :         }
     203             :     } else { // SCE or one non-coupled CPE
     204        2029 :         for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
     205        1227 :             int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
     206        3531 :             for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
     207       26435 :                 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
     208             :                     SoftFloat temp1;
     209             : 
     210       24131 :                     temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
     211       24131 :                     if (temp1.exp & 1)
     212        2958 :                         temp1.mant = 759250125;
     213             :                     else
     214       21173 :                         temp1.mant = 0x20000000;
     215       24131 :                     temp1.exp = (temp1.exp >> 1) + 1;
     216       24131 :                     if (temp1.exp > 66) { // temp1 > 1E20
     217           0 :                         av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
     218           0 :                         temp1 = FLOAT_1;
     219             :                     }
     220       24131 :                     sbr->data[ch].env_facs[e][k] = temp1;
     221             :                 }
     222        3181 :             for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
     223        7656 :                 for (k = 0; k < sbr->n_q; k++){
     224        5702 :                     sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
     225        5702 :                         sbr->data[ch].noise_facs_q[e][k] + 1;
     226        5702 :                     sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
     227             :                 }
     228             :         }
     229             :     }
     230        2082 : }
     231             : 
     232             : /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
     233             :  * (14496-3 sp04 p214)
     234             :  * Warning: This routine does not seem numerically stable.
     235             :  */
     236        3787 : static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
     237             :                                   int (*alpha0)[2], int (*alpha1)[2],
     238             :                                   const int X_low[32][40][2], int k0)
     239             : {
     240             :     int k;
     241             :     int shift, round;
     242             : 
     243       71885 :     for (k = 0; k < k0; k++) {
     244             :         SoftFloat phi[3][2][2];
     245             :         SoftFloat a00, a01, a10, a11;
     246             :         SoftFloat dk;
     247             : 
     248       68098 :         dsp->autocorrelate(X_low[k], phi);
     249             : 
     250       68098 :         dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
     251             :              av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
     252             :              av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
     253             : 
     254       68098 :         if (!dk.mant) {
     255        1708 :             a10 = FLOAT_0;
     256        1708 :             a11 = FLOAT_0;
     257             :         } else {
     258             :             SoftFloat temp_real, temp_im;
     259       66390 :             temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
     260             :                                             av_mul_sf(phi[0][0][1], phi[1][1][1])),
     261             :                                   av_mul_sf(phi[0][1][0], phi[1][0][0]));
     262       66390 :             temp_im   = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
     263             :                                             av_mul_sf(phi[0][0][1], phi[1][1][0])),
     264             :                                   av_mul_sf(phi[0][1][1], phi[1][0][0]));
     265             : 
     266       66390 :             a10 = av_div_sf(temp_real, dk);
     267       66390 :             a11 = av_div_sf(temp_im,   dk);
     268             :         }
     269             : 
     270       68098 :         if (!phi[1][0][0].mant) {
     271        1708 :             a00 = FLOAT_0;
     272        1708 :             a01 = FLOAT_0;
     273             :         } else {
     274             :             SoftFloat temp_real, temp_im;
     275       66390 :             temp_real = av_add_sf(phi[0][0][0],
     276             :                                   av_add_sf(av_mul_sf(a10, phi[1][1][0]),
     277             :                                             av_mul_sf(a11, phi[1][1][1])));
     278       66390 :             temp_im   = av_add_sf(phi[0][0][1],
     279             :                                   av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
     280             :                                             av_mul_sf(a10, phi[1][1][1])));
     281             : 
     282       66390 :             temp_real.mant = -temp_real.mant;
     283       66390 :             temp_im.mant   = -temp_im.mant;
     284       66390 :             a00 = av_div_sf(temp_real, phi[1][0][0]);
     285       66390 :             a01 = av_div_sf(temp_im,   phi[1][0][0]);
     286             :         }
     287             : 
     288       68098 :         shift = a00.exp;
     289       68098 :         if (shift >= 3)
     290           2 :             alpha0[k][0] = 0x7fffffff;
     291             :         else {
     292       68096 :             a00.mant <<= 1;
     293       68096 :             shift = 2-shift;
     294       68096 :             if (shift == 0)
     295           6 :                 alpha0[k][0] = a00.mant;
     296             :             else {
     297       68090 :                 round = 1 << (shift-1);
     298       68090 :                 alpha0[k][0] = (a00.mant + round) >> shift;
     299             :             }
     300             :         }
     301             : 
     302       68098 :         shift = a01.exp;
     303       68098 :         if (shift >= 3)
     304           3 :             alpha0[k][1] = 0x7fffffff;
     305             :         else {
     306       68095 :             a01.mant <<= 1;
     307       68095 :             shift = 2-shift;
     308       68095 :             if (shift == 0)
     309           2 :                 alpha0[k][1] = a01.mant;
     310             :             else {
     311       68093 :                 round = 1 << (shift-1);
     312       68093 :                 alpha0[k][1] = (a01.mant + round) >> shift;
     313             :             }
     314             :         }
     315       68098 :         shift = a10.exp;
     316       68098 :         if (shift >= 3)
     317           5 :             alpha1[k][0] = 0x7fffffff;
     318             :         else {
     319       68093 :             a10.mant <<= 1;
     320       68093 :             shift = 2-shift;
     321       68093 :             if (shift == 0)
     322           3 :                 alpha1[k][0] = a10.mant;
     323             :             else {
     324       68090 :                 round = 1 << (shift-1);
     325       68090 :                 alpha1[k][0] = (a10.mant + round) >> shift;
     326             :             }
     327             :         }
     328             : 
     329       68098 :         shift = a11.exp;
     330       68098 :         if (shift >= 3)
     331           0 :             alpha1[k][1] = 0x7fffffff;
     332             :         else {
     333       68098 :             a11.mant <<= 1;
     334       68098 :             shift = 2-shift;
     335       68098 :             if (shift == 0)
     336           1 :                 alpha1[k][1] = a11.mant;
     337             :             else {
     338       68097 :                 round = 1 << (shift-1);
     339       68097 :                 alpha1[k][1] = (a11.mant + round) >> shift;
     340             :             }
     341             :         }
     342             : 
     343      204294 :         shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
     344      136196 :                        (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
     345       68098 :                        0x40000000) >> 31);
     346       68098 :         if (shift >= 0x20000000){
     347           0 :             alpha1[k][0] = 0;
     348           0 :             alpha1[k][1] = 0;
     349           0 :             alpha0[k][0] = 0;
     350           0 :             alpha0[k][1] = 0;
     351             :         }
     352             : 
     353      204294 :         shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
     354      136196 :                        (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
     355       68098 :                        0x40000000) >> 31);
     356       68098 :         if (shift >= 0x20000000){
     357           0 :             alpha1[k][0] = 0;
     358           0 :             alpha1[k][1] = 0;
     359           0 :             alpha0[k][0] = 0;
     360           0 :             alpha0[k][1] = 0;
     361             :         }
     362             :     }
     363        3787 : }
     364             : 
     365             : /// Chirp Factors (14496-3 sp04 p214)
     366        3787 : static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
     367             : {
     368             :     int i;
     369             :     int new_bw;
     370             :     static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
     371             :     int64_t accu;
     372             : 
     373       14000 :     for (i = 0; i < sbr->n_q; i++) {
     374       10213 :         if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
     375         799 :             new_bw = 1288490189;
     376             :         else
     377        9414 :             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
     378             : 
     379       10213 :         if (new_bw < ch_data->bw_array[i]){
     380        2080 :             accu  = (int64_t)new_bw * 1610612736;
     381        2080 :             accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
     382        2080 :             new_bw = (int)((accu + 0x40000000) >> 31);
     383             :         } else {
     384        8133 :             accu  = (int64_t)new_bw * 1946157056;
     385        8133 :             accu += (int64_t)ch_data->bw_array[i] * 201326592;
     386        8133 :             new_bw = (int)((accu + 0x40000000) >> 31);
     387             :         }
     388       10213 :         ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
     389             :     }
     390        3787 : }
     391             : 
     392             : /**
     393             :  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
     394             :  * and Calculation of gain (14496-3 sp04 p219)
     395             :  */
     396        3787 : static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
     397             :                           SBRData *ch_data, const int e_a[2])
     398             : {
     399             :     int e, k, m;
     400             :     // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
     401             :     static const SoftFloat limgain[4] = { { 760155524,  0 }, { 0x20000000,  1 },
     402             :                                             { 758351638,  1 }, { 625000000, 34 } };
     403             : 
     404        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     405        5588 :         int delta = !((e == e_a[1]) || (e == e_a[0]));
     406       23292 :         for (k = 0; k < sbr->n_lim; k++) {
     407             :             SoftFloat gain_boost, gain_max;
     408             :             SoftFloat sum[2];
     409       17704 :             sum[0] = sum[1] = FLOAT_0;
     410      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     411      127837 :                 const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
     412             :                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
     413      127837 :                 sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
     414      127837 :                 sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
     415      127837 :                 if (!sbr->s_mapped[e][m]) {
     416      123205 :                     if (delta) {
     417      115357 :                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
     418             :                                             av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
     419             :                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
     420             :                     } else {
     421        7848 :                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
     422             :                                             av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
     423             :                     }
     424             :                 } else {
     425        4632 :                     sbr->gain[e][m] = av_sqrt_sf(
     426             :                                         av_div_sf(
     427             :                                             av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
     428             :                                             av_mul_sf(
     429             :                                                 av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
     430             :                                                 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
     431             :                 }
     432             :             }
     433      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     434      127837 :                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
     435      127837 :                 sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
     436             :             }
     437       17704 :             gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
     438             :                             av_sqrt_sf(
     439             :                                 av_div_sf(
     440             :                                     av_add_sf(FLOAT_EPSILON, sum[0]),
     441             :                                     av_add_sf(FLOAT_EPSILON, sum[1]))));
     442       17704 :             if (av_gt_sf(gain_max, FLOAT_100000))
     443        3741 :               gain_max = FLOAT_100000;
     444      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     445      127837 :                 SoftFloat q_m_max = av_div_sf(
     446             :                                         av_mul_sf(sbr->q_m[e][m], gain_max),
     447             :                                         sbr->gain[e][m]);
     448      127837 :                 if (av_gt_sf(sbr->q_m[e][m], q_m_max))
     449       33577 :                   sbr->q_m[e][m] = q_m_max;
     450      127837 :                 if (av_gt_sf(sbr->gain[e][m], gain_max))
     451       33577 :                   sbr->gain[e][m] = gain_max;
     452             :             }
     453       17704 :             sum[0] = sum[1] = FLOAT_0;
     454      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     455      127837 :                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
     456      127837 :                 sum[1] = av_add_sf(sum[1],
     457             :                             av_mul_sf(
     458             :                                 av_mul_sf(sbr->e_curr[e][m],
     459             :                                           sbr->gain[e][m]),
     460             :                                 sbr->gain[e][m]));
     461      127837 :                 sum[1] = av_add_sf(sum[1],
     462             :                             av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
     463      127837 :                 if (delta && !sbr->s_m[e][m].mant)
     464      117689 :                   sum[1] = av_add_sf(sum[1],
     465             :                                 av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
     466             :             }
     467       17704 :             gain_boost = av_sqrt_sf(
     468             :                             av_div_sf(
     469             :                                 av_add_sf(FLOAT_EPSILON, sum[0]),
     470             :                                 av_add_sf(FLOAT_EPSILON, sum[1])));
     471       17704 :             if (av_gt_sf(gain_boost, FLOAT_1584893192))
     472        1483 :               gain_boost = FLOAT_1584893192;
     473             : 
     474      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     475      127837 :                 sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
     476      127837 :                 sbr->q_m[e][m]  = av_mul_sf(sbr->q_m[e][m], gain_boost);
     477      127837 :                 sbr->s_m[e][m]  = av_mul_sf(sbr->s_m[e][m], gain_boost);
     478             :             }
     479             :         }
     480             :     }
     481        3787 : }
     482             : 
     483             : /// Assembling HF Signals (14496-3 sp04 p220)
     484        3787 : static void sbr_hf_assemble(int Y1[38][64][2],
     485             :                             const int X_high[64][40][2],
     486             :                             SpectralBandReplication *sbr, SBRData *ch_data,
     487             :                             const int e_a[2])
     488             : {
     489             :     int e, i, j, m;
     490        3787 :     const int h_SL = 4 * !sbr->bs_smoothing_mode;
     491        3787 :     const int kx = sbr->kx[1];
     492        3787 :     const int m_max = sbr->m[1];
     493             :     static const SoftFloat h_smooth[5] = {
     494             :       { 715827883, -1 },
     495             :       { 647472402, -1 },
     496             :       { 937030863, -2 },
     497             :       { 989249804, -3 },
     498             :       { 546843842, -4 },
     499             :     };
     500        3787 :     SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
     501        3787 :     int indexnoise = ch_data->f_indexnoise;
     502        3787 :     int indexsine  = ch_data->f_indexsine;
     503             : 
     504        3787 :     if (sbr->reset) {
     505          17 :         for (i = 0; i < h_SL; i++) {
     506           8 :             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
     507           8 :             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
     508             :         }
     509        3778 :     } else if (h_SL) {
     510        5730 :         for (i = 0; i < 4; i++) {
     511        4584 :             memcpy(g_temp[i + 2 * ch_data->t_env[0]],
     512        4584 :                    g_temp[i + 2 * ch_data->t_env_num_env_old],
     513             :                    sizeof(g_temp[0]));
     514        4584 :             memcpy(q_temp[i + 2 * ch_data->t_env[0]],
     515        4584 :                    q_temp[i + 2 * ch_data->t_env_num_env_old],
     516             :                    sizeof(q_temp[0]));
     517             :         }
     518             :     }
     519             : 
     520        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     521      126772 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     522      121184 :             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
     523      121184 :             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
     524             :         }
     525             :     }
     526             : 
     527        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     528      126772 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     529             :             SoftFloat g_filt_tab[48];
     530             :             SoftFloat q_filt_tab[48];
     531             :             SoftFloat *g_filt, *q_filt;
     532             : 
     533      157818 :             if (h_SL && e != e_a[0] && e != e_a[1]) {
     534       36634 :                 g_filt = g_filt_tab;
     535       36634 :                 q_filt = q_filt_tab;
     536      659412 :                 for (m = 0; m < m_max; m++) {
     537      622778 :                     const int idx1 = i + h_SL;
     538      622778 :                     g_filt[m].mant = g_filt[m].exp = 0;
     539      622778 :                     q_filt[m].mant = q_filt[m].exp = 0;
     540     3736668 :                     for (j = 0; j <= h_SL; j++) {
     541     6227780 :                         g_filt[m] = av_add_sf(g_filt[m],
     542     3113890 :                                         av_mul_sf(g_temp[idx1 - j][m],
     543             :                                             h_smooth[j]));
     544     6227780 :                         q_filt[m] = av_add_sf(q_filt[m],
     545     3113890 :                                         av_mul_sf(q_temp[idx1 - j][m],
     546             :                                             h_smooth[j]));
     547             :                     }
     548             :                 }
     549             :             } else {
     550       84550 :                 g_filt = g_temp[i + h_SL];
     551       84550 :                 q_filt = q_temp[i];
     552             :             }
     553             : 
     554      242368 :             sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
     555      121184 :                                i + ENVELOPE_ADJUSTMENT_OFFSET);
     556             : 
     557      121184 :             if (e != e_a[0] && e != e_a[1]) {
     558      119686 :                 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
     559             :                                                    q_filt, indexnoise,
     560             :                                                    kx, m_max);
     561             :             } else {
     562        1498 :                 int idx = indexsine&1;
     563        1498 :                 int A = (1-((indexsine+(kx & 1))&2));
     564        1498 :                 int B = (A^(-idx)) + idx;
     565        1498 :                 int *out = &Y1[i][kx][idx];
     566             :                 int shift, round;
     567             : 
     568        1498 :                 SoftFloat *in  = sbr->s_m[e];
     569       18898 :                 for (m = 0; m+1 < m_max; m+=2) {
     570       17400 :                   shift = 22 - in[m  ].exp;
     571       17400 :                   round = 1 << (shift-1);
     572       17400 :                   out[2*m  ] += (in[m  ].mant * A + round) >> shift;
     573             : 
     574       17400 :                   shift = 22 - in[m+1].exp;
     575       17400 :                   round = 1 << (shift-1);
     576       17400 :                   out[2*m+2] += (in[m+1].mant * B + round) >> shift;
     577             :                 }
     578        1498 :                 if(m_max&1)
     579             :                 {
     580        1004 :                   shift = 22 - in[m  ].exp;
     581        1004 :                   round = 1 << (shift-1);
     582             : 
     583        1004 :                   out[2*m  ] += (in[m  ].mant * A + round) >> shift;
     584             :                 }
     585             :             }
     586      121184 :             indexnoise = (indexnoise + m_max) & 0x1ff;
     587      121184 :             indexsine = (indexsine + 1) & 3;
     588             :         }
     589             :     }
     590        3787 :     ch_data->f_indexnoise = indexnoise;
     591        3787 :     ch_data->f_indexsine  = indexsine;
     592        3787 : }
     593             : 
     594             : #include "aacsbr_template.c"

Generated by: LCOV version 1.12