LCOV - code coverage report
Current view: top level - src/libavcodec - aacsbr.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 186 190 97.9 %
Date: 2017-08-17 10:06:07 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         116 : 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         116 :     base = powf((float)stop / start, 1.0f / num_bands);
      60         116 :     prod = start;
      61         116 :     previous = start;
      62             : 
      63        1310 :     for (k = 0; k < num_bands-1; k++) {
      64        1194 :         prod *= base;
      65        1194 :         present  = lrintf(prod);
      66        1194 :         bands[k] = present - previous;
      67        1194 :         previous = present;
      68             :     }
      69         116 :     bands[num_bands-1] = stop - previous;
      70         116 : }
      71             : 
      72             : /// Dequantization and stereo decoding (14496-3 sp04 p203)
      73        4450 : 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        5795 :     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        7046 :         for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
     115        9997 :             for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
     116       82225 :                 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
     117       76169 :                     if (sbr->data[ch].bs_amp_res)
     118       44051 :                         sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
     119             :                     else
     120       64236 :                         sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
     121       32118 :                                                        * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
     122       76169 :                     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        9437 :             for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
     129       24583 :                 for (k = 0; k < sbr->n_q; k++)
     130       19087 :                     sbr->data[ch].noise_facs[e][k] =
     131       19087 :                         ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
     132             :         }
     133             :     }
     134        4450 : }
     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        6631 : 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      130955 :     for (k = 0; k < k0; k++) {
     146      124324 :         LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
     147             :         float dk;
     148             : 
     149      124324 :         dsp->autocorrelate(X_low[k], phi);
     150             : 
     151      248648 :         dk =  phi[2][1][0] * phi[1][0][0] -
     152      124324 :              (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
     153             : 
     154      124324 :         if (!dk) {
     155        4007 :             alpha1[k][0] = 0;
     156        4007 :             alpha1[k][1] = 0;
     157             :         } else {
     158             :             float temp_real, temp_im;
     159      360951 :             temp_real = phi[0][0][0] * phi[1][1][0] -
     160      120317 :                         phi[0][0][1] * phi[1][1][1] -
     161      120317 :                         phi[0][1][0] * phi[1][0][0];
     162      360951 :             temp_im   = phi[0][0][0] * phi[1][1][1] +
     163      120317 :                         phi[0][0][1] * phi[1][1][0] -
     164      120317 :                         phi[0][1][1] * phi[1][0][0];
     165             : 
     166      120317 :             alpha1[k][0] = temp_real / dk;
     167      120317 :             alpha1[k][1] = temp_im   / dk;
     168             :         }
     169             : 
     170      124324 :         if (!phi[1][0][0]) {
     171        3622 :             alpha0[k][0] = 0;
     172        3622 :             alpha0[k][1] = 0;
     173             :         } else {
     174             :             float temp_real, temp_im;
     175      241404 :             temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
     176      120702 :                                        alpha1[k][1] * phi[1][1][1];
     177      241404 :             temp_im   = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
     178      120702 :                                        alpha1[k][0] * phi[1][1][1];
     179             : 
     180      120702 :             alpha0[k][0] = -temp_real / phi[1][0][0];
     181      120702 :             alpha0[k][1] = -temp_im   / phi[1][0][0];
     182             :         }
     183             : 
     184      248262 :         if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
     185      123938 :            alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
     186         604 :             alpha1[k][0] = 0;
     187         604 :             alpha1[k][1] = 0;
     188         604 :             alpha0[k][0] = 0;
     189         604 :             alpha0[k][1] = 0;
     190             :         }
     191             :     }
     192        6631 : }
     193             : 
     194             : /// Chirp Factors (14496-3 sp04 p214)
     195        6631 : 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       27190 :     for (i = 0; i < sbr->n_q; i++) {
     202       20559 :         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       19266 :             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
     206             : 
     207       20559 :         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       16977 :             new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
     211       20559 :         ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
     212             :     }
     213        6631 : }
     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        6631 : 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       16203 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     227        9572 :         int delta = !((e == e_a[1]) || (e == e_a[0]));
     228       44040 :         for (k = 0; k < sbr->n_lim; k++) {
     229             :             float gain_boost, gain_max;
     230       34468 :             float sum[2] = { 0.0f, 0.0f };
     231      285653 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     232      251185 :                 const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
     233      251185 :                 sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
     234      251185 :                 sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
     235      251185 :                 if (!sbr->s_mapped[e][m]) {
     236      491804 :                     sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
     237      491804 :                                             ((1.0f + sbr->e_curr[e][m]) *
     238      245902 :                                              (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      251185 :                 sbr->gain[e][m] += FLT_MIN;
     245             :             }
     246      285653 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     247      251185 :                 sum[0] += sbr->e_origmapped[e][m];
     248      251185 :                 sum[1] += sbr->e_curr[e][m];
     249             :             }
     250       34468 :             gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
     251       34468 :             gain_max = FFMIN(100000.f, gain_max);
     252      285653 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     253      251185 :                 float q_m_max   = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
     254      251185 :                 sbr->q_m[e][m]  = FFMIN(sbr->q_m[e][m], q_m_max);
     255      251185 :                 sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
     256             :             }
     257       34468 :             sum[0] = sum[1] = 0.0f;
     258      285653 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     259      251185 :                 sum[0] += sbr->e_origmapped[e][m];
     260      502370 :                 sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
     261      251185 :                           + sbr->s_m[e][m] * sbr->s_m[e][m]
     262      251185 :                           + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
     263             :             }
     264       34468 :             gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
     265       34468 :             gain_boost = FFMIN(1.584893192f, gain_boost);
     266      285653 :             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
     267      251185 :                 sbr->gain[e][m] *= gain_boost;
     268      251185 :                 sbr->q_m[e][m]  *= gain_boost;
     269      251185 :                 sbr->s_m[e][m]  *= gain_boost;
     270             :             }
     271             :         }
     272             :     }
     273        6631 : }
     274             : 
     275             : /// Assembling HF Signals (14496-3 sp04 p220)
     276        6631 : static void sbr_hf_assemble(float Y1[38][64][2],
     277             :                             const float X_high[64][40][2],
     278             :                             SpectralBandReplication *sbr, SBRData *ch_data,
     279             :                             const int e_a[2])
     280             : {
     281             :     int e, i, j, m;
     282        6631 :     const int h_SL = 4 * !sbr->bs_smoothing_mode;
     283        6631 :     const int kx = sbr->kx[1];
     284        6631 :     const int m_max = sbr->m[1];
     285             :     static const float h_smooth[5] = {
     286             :         0.33333333333333,
     287             :         0.30150283239582,
     288             :         0.21816949906249,
     289             :         0.11516383427084,
     290             :         0.03183050093751,
     291             :     };
     292        6631 :     float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
     293        6631 :     int indexnoise = ch_data->f_indexnoise;
     294        6631 :     int indexsine  = ch_data->f_indexsine;
     295             : 
     296        6631 :     if (sbr->reset) {
     297          87 :         for (i = 0; i < h_SL; i++) {
     298           8 :             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
     299           8 :             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
     300             :         }
     301        6552 :     } else if (h_SL) {
     302        5730 :         for (i = 0; i < 4; i++) {
     303        4584 :             memcpy(g_temp[i + 2 * ch_data->t_env[0]],
     304        4584 :                    g_temp[i + 2 * ch_data->t_env_num_env_old],
     305             :                    sizeof(g_temp[0]));
     306        4584 :             memcpy(q_temp[i + 2 * ch_data->t_env[0]],
     307        4584 :                    q_temp[i + 2 * ch_data->t_env_num_env_old],
     308             :                    sizeof(q_temp[0]));
     309             :         }
     310             :     }
     311             : 
     312       16203 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     313      221764 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     314      212192 :             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
     315      212192 :             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
     316             :         }
     317             :     }
     318             : 
     319       16203 :     for (e = 0; e < ch_data->bs_num_env; e++) {
     320      221764 :         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
     321      212192 :             LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
     322      212192 :             LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
     323             :             float *g_filt, *q_filt;
     324             : 
     325      248826 :             if (h_SL && e != e_a[0] && e != e_a[1]) {
     326       36634 :                 g_filt = g_filt_tab;
     327       36634 :                 q_filt = q_filt_tab;
     328      659412 :                 for (m = 0; m < m_max; m++) {
     329      622778 :                     const int idx1 = i + h_SL;
     330      622778 :                     g_filt[m] = 0.0f;
     331      622778 :                     q_filt[m] = 0.0f;
     332     3736668 :                     for (j = 0; j <= h_SL; j++) {
     333     3113890 :                         g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
     334     3113890 :                         q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
     335             :                     }
     336             :                 }
     337             :             } else {
     338      175558 :                 g_filt = g_temp[i + h_SL];
     339      175558 :                 q_filt = q_temp[i];
     340             :             }
     341             : 
     342      424384 :             sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
     343      212192 :                                i + ENVELOPE_ADJUSTMENT_OFFSET);
     344             : 
     345      212192 :             if (e != e_a[0] && e != e_a[1]) {
     346      209970 :                 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
     347             :                                                    q_filt, indexnoise,
     348             :                                                    kx, m_max);
     349             :             } else {
     350        2222 :                 int idx = indexsine&1;
     351        2222 :                 int A = (1-((indexsine+(kx & 1))&2));
     352        2222 :                 int B = (A^(-idx)) + idx;
     353        2222 :                 float *out = &Y1[i][kx][idx];
     354        2222 :                 float *in  = sbr->s_m[e];
     355       30250 :                 for (m = 0; m+1 < m_max; m+=2) {
     356       28028 :                     out[2*m  ] += in[m  ] * A;
     357       28028 :                     out[2*m+2] += in[m+1] * B;
     358             :                 }
     359        2222 :                 if(m_max&1)
     360        1288 :                     out[2*m  ] += in[m  ] * A;
     361             :             }
     362      212192 :             indexnoise = (indexnoise + m_max) & 0x1ff;
     363      212192 :             indexsine = (indexsine + 1) & 3;
     364             :         }
     365             :     }
     366        6631 :     ch_data->f_indexnoise = indexnoise;
     367        6631 :     ch_data->f_indexsine  = indexsine;
     368        6631 : }
     369             : 
     370             : #include "aacsbr_template.c"

Generated by: LCOV version 1.13