LCOV - code coverage report
Current view: top level - src/libavcodec - aacsbr.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 185 189 97.9 %
Date: 2017-01-24 04:42:20 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * AAC Spectral Band Replication decoding functions
       3             :  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
       4             :  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * AAC Spectral Band Replication decoding functions
      26             :  * @author Robert Swain ( rob opendot cl )
      27             :  */
      28             : #define USE_FIXED 0
      29             : 
      30             : #include "aac.h"
      31             : #include "sbr.h"
      32             : #include "aacsbr.h"
      33             : #include "aacsbrdata.h"
      34             : #include "aacsbr_tablegen.h"
      35             : #include "fft.h"
      36             : #include "internal.h"
      37             : #include "aacps.h"
      38             : #include "sbrdsp.h"
      39             : #include "libavutil/internal.h"
      40             : #include "libavutil/libm.h"
      41             : #include "libavutil/avassert.h"
      42             : 
      43             : #include <stdint.h>
      44             : #include <float.h>
      45             : #include <math.h>
      46             : 
      47             : #if ARCH_MIPS
      48             : #include "mips/aacsbr_mips.h"
      49             : #endif /* ARCH_MIPS */
      50             : 
      51             : static VLC vlc_sbr[10];
      52             : static void aacsbr_func_ptr_init(AACSBRContext *c);
      53             : 
      54         114 : static void make_bands(int16_t* bands, int start, int stop, int num_bands)
      55             : {
      56             :     int k, previous, present;
      57             :     float base, prod;
      58             : 
      59         114 :     base = powf((float)stop / start, 1.0f / num_bands);
      60         114 :     prod = start;
      61         114 :     previous = start;
      62             : 
      63        1295 :     for (k = 0; k < num_bands-1; k++) {
      64        1181 :         prod *= base;
      65        1181 :         present  = lrintf(prod);
      66        1181 :         bands[k] = present - previous;
      67        1181 :         previous = present;
      68             :     }
      69         114 :     bands[num_bands-1] = stop - previous;
      70         114 : }
      71             : 
      72             : /// Dequantization and stereo decoding (14496-3 sp04 p203)
      73        4397 : static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
      74             : {
      75             :     int k, e;
      76             :     int ch;
      77             :     static const double exp2_tab[2] = {1, M_SQRT2};
      78        5742 :     if (id_aac == TYPE_CPE && sbr->bs_coupling) {
      79        1345 :         int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
      80        3103 :         for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
      81       20143 :             for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
      82             :                 float temp1, temp2, fac;
      83       18385 :                 if (sbr->data[0].bs_amp_res) {
      84        7387 :                     temp1 = ff_exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
      85        7387 :                     temp2 = ff_exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
      86             :                 }
      87             :                 else {
      88       21996 :                     temp1 = ff_exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
      89       10998 :                             exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
      90       21996 :                     temp2 = ff_exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
      91       10998 :                             exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
      92             :                 }
      93       18385 :                 if (temp1 > 1E20) {
      94           0 :                     av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
      95           0 :                     temp1 = 1;
      96             :                 }
      97       18385 :                 fac   = temp1 / (1.0f + temp2);
      98       18385 :                 sbr->data[0].env_facs[e][k] = fac;
      99       18385 :                 sbr->data[1].env_facs[e][k] = fac * temp2;
     100             :             }
     101             :         }
     102        2995 :         for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
     103        6017 :             for (k = 0; k < sbr->n_q; k++) {
     104        4367 :                 float temp1 = ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
     105        4367 :                 float temp2 = ff_exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
     106             :                 float fac;
     107        4367 :                 av_assert0(temp1 <= 1E20);
     108        4367 :                 fac = temp1 / (1.0f + temp2);
     109        4367 :                 sbr->data[0].noise_facs[e][k] = fac;
     110        4367 :                 sbr->data[1].noise_facs[e][k] = fac * temp2;
     111             :             }
     112             :         }
     113             :     } else { // SCE or one non-coupled CPE
     114        6940 :         for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
     115        9884 :             for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
     116       82049 :                 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
     117       76053 :                     if (sbr->data[ch].bs_amp_res)
     118       44033 :                         sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
     119             :                     else
     120       64040 :                         sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
     121       32020 :                                                        * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
     122       76053 :                     if (sbr->data[ch].env_facs[e][k] > 1E20) {
     123           0 :                         av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
     124           0 :                         sbr->data[ch].env_facs[e][k] = 1;
     125             :                     }
     126             :                 }
     127             : 
     128        9327 :             for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
     129       24469 :                 for (k = 0; k < sbr->n_q; k++)
     130       19030 :                     sbr->data[ch].noise_facs[e][k] =
     131       19030 :                         ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
     132             :         }
     133             :     }
     134        4397 : }
     135             : 
     136             : /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
     137             :  * (14496-3 sp04 p214)
     138             :  * Warning: This routine does not seem numerically stable.
     139             :  */
     140        6578 : static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
     141             :                                   float (*alpha0)[2], float (*alpha1)[2],
     142             :                                   const float X_low[32][40][2], int k0)
     143             : {
     144             :     int k;
     145      129206 :     for (k = 0; k < k0; k++) {
     146      122628 :         LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
     147             :         float dk;
     148             : 
     149      122628 :         dsp->autocorrelate(X_low[k], phi);
     150             : 
     151      245256 :         dk =  phi[2][1][0] * phi[1][0][0] -
     152      122628 :              (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
     153             : 
     154      122628 :         if (!dk) {
     155        3911 :             alpha1[k][0] = 0;
     156        3911 :             alpha1[k][1] = 0;
     157             :         } else {
     158             :             float temp_real, temp_im;
     159      356151 :             temp_real = phi[0][0][0] * phi[1][1][0] -
     160      118717 :                         phi[0][0][1] * phi[1][1][1] -
     161      118717 :                         phi[0][1][0] * phi[1][0][0];
     162      356151 :             temp_im   = phi[0][0][0] * phi[1][1][1] +
     163      118717 :                         phi[0][0][1] * phi[1][1][0] -
     164      118717 :                         phi[0][1][1] * phi[1][0][0];
     165             : 
     166      118717 :             alpha1[k][0] = temp_real / dk;
     167      118717 :             alpha1[k][1] = temp_im   / dk;
     168             :         }
     169             : 
     170      122628 :         if (!phi[1][0][0]) {
     171        3526 :             alpha0[k][0] = 0;
     172        3526 :             alpha0[k][1] = 0;
     173             :         } else {
     174             :             float temp_real, temp_im;
     175      238204 :             temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
     176      119102 :                                        alpha1[k][1] * phi[1][1][1];
     177      238204 :             temp_im   = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
     178      119102 :                                        alpha1[k][0] * phi[1][1][1];
     179             : 
     180      119102 :             alpha0[k][0] = -temp_real / phi[1][0][0];
     181      119102 :             alpha0[k][1] = -temp_im   / phi[1][0][0];
     182             :         }
     183             : 
     184      244897 :         if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
     185      122269 :            alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
     186         577 :             alpha1[k][0] = 0;
     187         577 :             alpha1[k][1] = 0;
     188         577 :             alpha0[k][0] = 0;
     189         577 :             alpha0[k][1] = 0;
     190             :         }
     191             :     }
     192        6578 : }
     193             : 
     194             : /// Chirp Factors (14496-3 sp04 p214)
     195        6578 : static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
     196             : {
     197             :     int i;
     198             :     float new_bw;
     199             :     static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
     200             : 
     201       27084 :     for (i = 0; i < sbr->n_q; i++) {
     202       20506 :         if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
     203        1293 :             new_bw = 0.6f;
     204             :         } else
     205       19213 :             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
     206             : 
     207       20506 :         if (new_bw < ch_data->bw_array[i]) {
     208        3582 :             new_bw = 0.75f    * new_bw + 0.25f    * ch_data->bw_array[i];
     209             :         } else
     210       16924 :             new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
     211       20506 :         ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
     212             :     }
     213        6578 : }
     214             : 
     215             : /**
     216             :  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
     217             :  * and Calculation of gain (14496-3 sp04 p219)
     218             :  */
     219        6578 : static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
     220             :                           SBRData *ch_data, const int e_a[2])
     221             : {
     222             :     int e, k, m;
     223             :     // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
     224             :     static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
     225             : 
     226       16090 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     227        9512 :         int delta = !((e == e_a[1]) || (e == e_a[0]));
     228       43920 :         for (k = 0; k < sbr->n_lim; k++) {
     229             :             float gain_boost, gain_max;
     230       34408 :             float sum[2] = { 0.0f, 0.0f };
     231      285353 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     232      250945 :                 const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
     233      250945 :                 sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
     234      250945 :                 sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
     235      250945 :                 if (!sbr->s_mapped[e][m]) {
     236      491324 :                     sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
     237      491324 :                                             ((1.0f + sbr->e_curr[e][m]) *
     238      245662 :                                              (1.0f + sbr->q_mapped[e][m] * delta)));
     239             :                 } else {
     240       10566 :                     sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
     241       10566 :                                             ((1.0f + sbr->e_curr[e][m]) *
     242        5283 :                                              (1.0f + sbr->q_mapped[e][m])));
     243             :                 }
     244             :             }
     245      285353 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     246      250945 :                 sum[0] += sbr->e_origmapped[e][m];
     247      250945 :                 sum[1] += sbr->e_curr[e][m];
     248             :             }
     249       34408 :             gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
     250       34408 :             gain_max = FFMIN(100000.f, gain_max);
     251      285353 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     252      250945 :                 float q_m_max   = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
     253      250945 :                 sbr->q_m[e][m]  = FFMIN(sbr->q_m[e][m], q_m_max);
     254      250945 :                 sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
     255             :             }
     256       34408 :             sum[0] = sum[1] = 0.0f;
     257      285353 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     258      250945 :                 sum[0] += sbr->e_origmapped[e][m];
     259      501890 :                 sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
     260      250945 :                           + sbr->s_m[e][m] * sbr->s_m[e][m]
     261      250945 :                           + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
     262             :             }
     263       34408 :             gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
     264       34408 :             gain_boost = FFMIN(1.584893192f, gain_boost);
     265      285353 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     266      250945 :                 sbr->gain[e][m] *= gain_boost;
     267      250945 :                 sbr->q_m[e][m]  *= gain_boost;
     268      250945 :                 sbr->s_m[e][m]  *= gain_boost;
     269             :             }
     270             :         }
     271             :     }
     272        6578 : }
     273             : 
     274             : /// Assembling HF Signals (14496-3 sp04 p220)
     275        6578 : static void sbr_hf_assemble(float Y1[38][64][2],
     276             :                             const float X_high[64][40][2],
     277             :                             SpectralBandReplication *sbr, SBRData *ch_data,
     278             :                             const int e_a[2])
     279             : {
     280             :     int e, i, j, m;
     281        6578 :     const int h_SL = 4 * !sbr->bs_smoothing_mode;
     282        6578 :     const int kx = sbr->kx[1];
     283        6578 :     const int m_max = sbr->m[1];
     284             :     static const float h_smooth[5] = {
     285             :         0.33333333333333,
     286             :         0.30150283239582,
     287             :         0.21816949906249,
     288             :         0.11516383427084,
     289             :         0.03183050093751,
     290             :     };
     291        6578 :     float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
     292        6578 :     int indexnoise = ch_data->f_indexnoise;
     293        6578 :     int indexsine  = ch_data->f_indexsine;
     294             : 
     295        6578 :     if (sbr->reset) {
     296          86 :         for (i = 0; i < h_SL; i++) {
     297           8 :             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
     298           8 :             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
     299             :         }
     300        6500 :     } else if (h_SL) {
     301        5730 :         for (i = 0; i < 4; i++) {
     302        4584 :             memcpy(g_temp[i + 2 * ch_data->t_env[0]],
     303        4584 :                    g_temp[i + 2 * ch_data->t_env_num_env_old],
     304             :                    sizeof(g_temp[0]));
     305        4584 :             memcpy(q_temp[i + 2 * ch_data->t_env[0]],
     306        4584 :                    q_temp[i + 2 * ch_data->t_env_num_env_old],
     307             :                    sizeof(q_temp[0]));
     308             :         }
     309             :     }
     310             : 
     311       16090 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     312      220008 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     313      210496 :             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
     314      210496 :             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
     315             :         }
     316             :     }
     317             : 
     318       16090 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     319      220008 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     320      210496 :             LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
     321      210496 :             LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
     322             :             float *g_filt, *q_filt;
     323             : 
     324      247130 :             if (h_SL && e != e_a[0] && e != e_a[1]) {
     325       36634 :                 g_filt = g_filt_tab;
     326       36634 :                 q_filt = q_filt_tab;
     327      659412 :                 for (m = 0; m < m_max; m++) {
     328      622778 :                     const int idx1 = i + h_SL;
     329      622778 :                     g_filt[m] = 0.0f;
     330      622778 :                     q_filt[m] = 0.0f;
     331     3736668 :                     for (j = 0; j <= h_SL; j++) {
     332     3113890 :                         g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
     333     3113890 :                         q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
     334             :                     }
     335             :                 }
     336             :             } else {
     337      173862 :                 g_filt = g_temp[i + h_SL];
     338      173862 :                 q_filt = q_temp[i];
     339             :             }
     340             : 
     341      420992 :             sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
     342      210496 :                                i + ENVELOPE_ADJUSTMENT_OFFSET);
     343             : 
     344      210496 :             if (e != e_a[0] && e != e_a[1]) {
     345      208282 :                 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
     346             :                                                    q_filt, indexnoise,
     347             :                                                    kx, m_max);
     348             :             } else {
     349        2214 :                 int idx = indexsine&1;
     350        2214 :                 int A = (1-((indexsine+(kx & 1))&2));
     351        2214 :                 int B = (A^(-idx)) + idx;
     352        2214 :                 float *out = &Y1[i][kx][idx];
     353        2214 :                 float *in  = sbr->s_m[e];
     354       30226 :                 for (m = 0; m+1 < m_max; m+=2) {
     355       28012 :                     out[2*m  ] += in[m  ] * A;
     356       28012 :                     out[2*m+2] += in[m+1] * B;
     357             :                 }
     358        2214 :                 if(m_max&1)
     359        1288 :                     out[2*m  ] += in[m  ] * A;
     360             :             }
     361      210496 :             indexnoise = (indexnoise + m_max) & 0x1ff;
     362      210496 :             indexsine = (indexsine + 1) & 3;
     363             :         }
     364             :     }
     365        6578 :     ch_data->f_indexnoise = indexnoise;
     366        6578 :     ch_data->f_indexsine  = indexsine;
     367        6578 : }
     368             : 
     369             : #include "aacsbr_template.c"

Generated by: LCOV version 1.12