LCOV - code coverage report
Current view: top level - src/libavcodec - aacsbr_fixed.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 271 291 93.1 %
Date: 2017-07-21 15:41:20 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       68096 :         else if (shift <= -30)
     292        2123 :             alpha0[k][0] = 0;
     293             :         else {
     294       65973 :             shift = 1-shift;
     295       65973 :             if (shift <= 0)
     296        1838 :                 alpha0[k][0] = a00.mant * (1<<-shift);
     297             :             else {
     298       64135 :                 round = 1 << (shift-1);
     299       64135 :                 alpha0[k][0] = (a00.mant + round) >> shift;
     300             :             }
     301             :         }
     302             : 
     303       68098 :         shift = a01.exp;
     304       68098 :         if (shift >= 3)
     305           3 :             alpha0[k][1] = 0x7fffffff;
     306       68095 :         else if (shift <= -30)
     307        2078 :             alpha0[k][1] = 0;
     308             :         else {
     309       66017 :             shift = 1-shift;
     310       66017 :             if (shift <= 0)
     311       14382 :                 alpha0[k][1] = a01.mant * (1<<-shift);
     312             :             else {
     313       51635 :                 round = 1 << (shift-1);
     314       51635 :                 alpha0[k][1] = (a01.mant + round) >> shift;
     315             :             }
     316             :         }
     317       68098 :         shift = a10.exp;
     318       68098 :         if (shift >= 3)
     319           5 :             alpha1[k][0] = 0x7fffffff;
     320       68093 :         else if (shift <= -30)
     321        2024 :             alpha1[k][0] = 0;
     322             :         else {
     323       66069 :             shift = 1-shift;
     324       66069 :             if (shift <= 0)
     325          76 :                 alpha1[k][0] = a10.mant * (1<<-shift);
     326             :             else {
     327       65993 :                 round = 1 << (shift-1);
     328       65993 :                 alpha1[k][0] = (a10.mant + round) >> shift;
     329             :             }
     330             :         }
     331             : 
     332       68098 :         shift = a11.exp;
     333       68098 :         if (shift >= 3)
     334           0 :             alpha1[k][1] = 0x7fffffff;
     335       68098 :         else if (shift <= -30)
     336        2114 :             alpha1[k][1] = 0;
     337             :         else {
     338       65984 :             shift = 1-shift;
     339       65984 :             if (shift <= 0)
     340          84 :                 alpha1[k][1] = a11.mant * (1<<-shift);
     341             :             else {
     342       65900 :                 round = 1 << (shift-1);
     343       65900 :                 alpha1[k][1] = (a11.mant + round) >> shift;
     344             :             }
     345             :         }
     346             : 
     347      204294 :         shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
     348      136196 :                        (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
     349       68098 :                        0x40000000) >> 31);
     350       68098 :         if (shift >= 0x20000000){
     351           0 :             alpha1[k][0] = 0;
     352           0 :             alpha1[k][1] = 0;
     353           0 :             alpha0[k][0] = 0;
     354           0 :             alpha0[k][1] = 0;
     355             :         }
     356             : 
     357      204294 :         shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
     358      136196 :                        (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
     359       68098 :                        0x40000000) >> 31);
     360       68098 :         if (shift >= 0x20000000){
     361           0 :             alpha1[k][0] = 0;
     362           0 :             alpha1[k][1] = 0;
     363           0 :             alpha0[k][0] = 0;
     364           0 :             alpha0[k][1] = 0;
     365             :         }
     366             :     }
     367        3787 : }
     368             : 
     369             : /// Chirp Factors (14496-3 sp04 p214)
     370        3787 : static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
     371             : {
     372             :     int i;
     373             :     int new_bw;
     374             :     static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
     375             :     int64_t accu;
     376             : 
     377       14000 :     for (i = 0; i < sbr->n_q; i++) {
     378       10213 :         if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
     379         799 :             new_bw = 1288490189;
     380             :         else
     381        9414 :             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
     382             : 
     383       10213 :         if (new_bw < ch_data->bw_array[i]){
     384        2080 :             accu  = (int64_t)new_bw * 1610612736;
     385        2080 :             accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
     386        2080 :             new_bw = (int)((accu + 0x40000000) >> 31);
     387             :         } else {
     388        8133 :             accu  = (int64_t)new_bw * 1946157056;
     389        8133 :             accu += (int64_t)ch_data->bw_array[i] * 201326592;
     390        8133 :             new_bw = (int)((accu + 0x40000000) >> 31);
     391             :         }
     392       10213 :         ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
     393             :     }
     394        3787 : }
     395             : 
     396             : /**
     397             :  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
     398             :  * and Calculation of gain (14496-3 sp04 p219)
     399             :  */
     400        3787 : static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
     401             :                           SBRData *ch_data, const int e_a[2])
     402             : {
     403             :     int e, k, m;
     404             :     // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
     405             :     static const SoftFloat limgain[4] = { { 760155524,  0 }, { 0x20000000,  1 },
     406             :                                             { 758351638,  1 }, { 625000000, 34 } };
     407             : 
     408        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     409        5588 :         int delta = !((e == e_a[1]) || (e == e_a[0]));
     410       23292 :         for (k = 0; k < sbr->n_lim; k++) {
     411             :             SoftFloat gain_boost, gain_max;
     412             :             SoftFloat sum[2];
     413       17704 :             sum[0] = sum[1] = FLOAT_0;
     414      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     415      127837 :                 const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
     416             :                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
     417      127837 :                 sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
     418      127837 :                 sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
     419      127837 :                 if (!sbr->s_mapped[e][m]) {
     420      123205 :                     if (delta) {
     421      115357 :                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
     422             :                                             av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
     423             :                                             av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
     424             :                     } else {
     425        7848 :                       sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
     426             :                                             av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
     427             :                     }
     428             :                 } else {
     429        4632 :                     sbr->gain[e][m] = av_sqrt_sf(
     430             :                                         av_div_sf(
     431             :                                             av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
     432             :                                             av_mul_sf(
     433             :                                                 av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
     434             :                                                 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
     435             :                 }
     436             :             }
     437      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     438      127837 :                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
     439      127837 :                 sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
     440             :             }
     441       17704 :             gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
     442             :                             av_sqrt_sf(
     443             :                                 av_div_sf(
     444             :                                     av_add_sf(FLOAT_EPSILON, sum[0]),
     445             :                                     av_add_sf(FLOAT_EPSILON, sum[1]))));
     446       17704 :             if (av_gt_sf(gain_max, FLOAT_100000))
     447        3741 :               gain_max = FLOAT_100000;
     448      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     449      127837 :                 SoftFloat q_m_max = av_div_sf(
     450             :                                         av_mul_sf(sbr->q_m[e][m], gain_max),
     451             :                                         sbr->gain[e][m]);
     452      127837 :                 if (av_gt_sf(sbr->q_m[e][m], q_m_max))
     453       33577 :                   sbr->q_m[e][m] = q_m_max;
     454      127837 :                 if (av_gt_sf(sbr->gain[e][m], gain_max))
     455       33577 :                   sbr->gain[e][m] = gain_max;
     456             :             }
     457       17704 :             sum[0] = sum[1] = FLOAT_0;
     458      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     459      127837 :                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
     460      127837 :                 sum[1] = av_add_sf(sum[1],
     461             :                             av_mul_sf(
     462             :                                 av_mul_sf(sbr->e_curr[e][m],
     463             :                                           sbr->gain[e][m]),
     464             :                                 sbr->gain[e][m]));
     465      127837 :                 sum[1] = av_add_sf(sum[1],
     466             :                             av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
     467      127837 :                 if (delta && !sbr->s_m[e][m].mant)
     468      117689 :                   sum[1] = av_add_sf(sum[1],
     469             :                                 av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
     470             :             }
     471       17704 :             gain_boost = av_sqrt_sf(
     472             :                             av_div_sf(
     473             :                                 av_add_sf(FLOAT_EPSILON, sum[0]),
     474             :                                 av_add_sf(FLOAT_EPSILON, sum[1])));
     475       17704 :             if (av_gt_sf(gain_boost, FLOAT_1584893192))
     476        1483 :               gain_boost = FLOAT_1584893192;
     477             : 
     478      145541 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     479      127837 :                 sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
     480      127837 :                 sbr->q_m[e][m]  = av_mul_sf(sbr->q_m[e][m], gain_boost);
     481      127837 :                 sbr->s_m[e][m]  = av_mul_sf(sbr->s_m[e][m], gain_boost);
     482             :             }
     483             :         }
     484             :     }
     485        3787 : }
     486             : 
     487             : /// Assembling HF Signals (14496-3 sp04 p220)
     488        3787 : static void sbr_hf_assemble(int Y1[38][64][2],
     489             :                             const int X_high[64][40][2],
     490             :                             SpectralBandReplication *sbr, SBRData *ch_data,
     491             :                             const int e_a[2])
     492             : {
     493             :     int e, i, j, m;
     494        3787 :     const int h_SL = 4 * !sbr->bs_smoothing_mode;
     495        3787 :     const int kx = sbr->kx[1];
     496        3787 :     const int m_max = sbr->m[1];
     497             :     static const SoftFloat h_smooth[5] = {
     498             :       { 715827883, -1 },
     499             :       { 647472402, -1 },
     500             :       { 937030863, -2 },
     501             :       { 989249804, -3 },
     502             :       { 546843842, -4 },
     503             :     };
     504        3787 :     SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
     505        3787 :     int indexnoise = ch_data->f_indexnoise;
     506        3787 :     int indexsine  = ch_data->f_indexsine;
     507             : 
     508        3787 :     if (sbr->reset) {
     509          17 :         for (i = 0; i < h_SL; i++) {
     510           8 :             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
     511           8 :             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
     512             :         }
     513        3778 :     } else if (h_SL) {
     514        5730 :         for (i = 0; i < 4; i++) {
     515        4584 :             memcpy(g_temp[i + 2 * ch_data->t_env[0]],
     516        4584 :                    g_temp[i + 2 * ch_data->t_env_num_env_old],
     517             :                    sizeof(g_temp[0]));
     518        4584 :             memcpy(q_temp[i + 2 * ch_data->t_env[0]],
     519        4584 :                    q_temp[i + 2 * ch_data->t_env_num_env_old],
     520             :                    sizeof(q_temp[0]));
     521             :         }
     522             :     }
     523             : 
     524        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     525      126772 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     526      121184 :             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
     527      121184 :             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
     528             :         }
     529             :     }
     530             : 
     531        9375 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     532      253544 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     533             :             SoftFloat g_filt_tab[48];
     534             :             SoftFloat q_filt_tab[48];
     535             :             SoftFloat *g_filt, *q_filt;
     536             : 
     537      157818 :             if (h_SL && e != e_a[0] && e != e_a[1]) {
     538       36634 :                 g_filt = g_filt_tab;
     539       36634 :                 q_filt = q_filt_tab;
     540      659412 :                 for (m = 0; m < m_max; m++) {
     541      622778 :                     const int idx1 = i + h_SL;
     542      622778 :                     g_filt[m].mant = g_filt[m].exp = 0;
     543      622778 :                     q_filt[m].mant = q_filt[m].exp = 0;
     544     3736668 :                     for (j = 0; j <= h_SL; j++) {
     545     3113890 :                         g_filt[m] = av_add_sf(g_filt[m],
     546     3113890 :                                         av_mul_sf(g_temp[idx1 - j][m],
     547             :                                             h_smooth[j]));
     548     3113890 :                         q_filt[m] = av_add_sf(q_filt[m],
     549     3113890 :                                         av_mul_sf(q_temp[idx1 - j][m],
     550             :                                             h_smooth[j]));
     551             :                     }
     552             :                 }
     553             :             } else {
     554       84550 :                 g_filt = g_temp[i + h_SL];
     555       84550 :                 q_filt = q_temp[i];
     556             :             }
     557             : 
     558      242368 :             sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
     559      121184 :                                i + ENVELOPE_ADJUSTMENT_OFFSET);
     560             : 
     561      121184 :             if (e != e_a[0] && e != e_a[1]) {
     562      119686 :                 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
     563             :                                                    q_filt, indexnoise,
     564             :                                                    kx, m_max);
     565             :             } else {
     566        1498 :                 int idx = indexsine&1;
     567        1498 :                 int A = (1-((indexsine+(kx & 1))&2));
     568        1498 :                 int B = (A^(-idx)) + idx;
     569        1498 :                 int *out = &Y1[i][kx][idx];
     570             :                 int shift, round;
     571             : 
     572        1498 :                 SoftFloat *in  = sbr->s_m[e];
     573       18898 :                 for (m = 0; m+1 < m_max; m+=2) {
     574             :                     int shift2;
     575       17400 :                     shift = 22 - in[m  ].exp;
     576       17400 :                     shift2= 22 - in[m+1].exp;
     577       17400 :                     if (shift < 1 || shift2 < 1) {
     578           0 :                         av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
     579           0 :                         return;
     580             :                     }
     581       17400 :                     if (shift < 32) {
     582         600 :                         round = 1 << (shift-1);
     583         600 :                         out[2*m  ] += (in[m  ].mant * A + round) >> shift;
     584             :                     }
     585             : 
     586       17400 :                     if (shift2 < 32) {
     587         152 :                         round = 1 << (shift2-1);
     588         152 :                         out[2*m+2] += (in[m+1].mant * B + round) >> shift2;
     589             :                     }
     590             :                 }
     591        1498 :                 if(m_max&1)
     592             :                 {
     593        1004 :                     shift = 22 - in[m  ].exp;
     594        1004 :                     if (shift < 1) {
     595           0 :                         av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
     596           0 :                         return;
     597        1004 :                     } else if (shift < 32) {
     598           0 :                         round = 1 << (shift-1);
     599           0 :                         out[2*m  ] += (in[m  ].mant * A + round) >> shift;
     600             :                     }
     601             :                 }
     602             :             }
     603      121184 :             indexnoise = (indexnoise + m_max) & 0x1ff;
     604      121184 :             indexsine = (indexsine + 1) & 3;
     605             :         }
     606             :     }
     607        3787 :     ch_data->f_indexnoise = indexnoise;
     608        3787 :     ch_data->f_indexsine  = indexsine;
     609             : }
     610             : 
     611             : #include "aacsbr_template.c"

Generated by: LCOV version 1.13