LCOV - code coverage report
Current view: top level - libavcodec - sbrdsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 99 99 100.0 %
Date: 2017-12-14 08:27:08 Functions: 9 9 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             : #define USE_FIXED 0
      24             : 
      25             : #include "aac.h"
      26             : #include "config.h"
      27             : #include "libavutil/attributes.h"
      28             : #include "libavutil/intfloat.h"
      29             : #include "sbrdsp.h"
      30             : 
      31      251188 : static float sbr_sum_square_c(float (*x)[2], int n)
      32             : {
      33      251188 :     float sum0 = 0.0f, sum1 = 0.0f;
      34             :     int i;
      35             : 
      36     3003652 :     for (i = 0; i < n; i += 2)
      37             :     {
      38     2752464 :         sum0 += x[i + 0][0] * x[i + 0][0];
      39     2752464 :         sum1 += x[i + 0][1] * x[i + 0][1];
      40     2752464 :         sum0 += x[i + 1][0] * x[i + 1][0];
      41     2752464 :         sum1 += x[i + 1][1] * x[i + 1][1];
      42             :     }
      43             : 
      44      251188 :     return sum0 + sum1;
      45             : }
      46             : 
      47      355459 : static void sbr_neg_odd_64_c(float *x)
      48             : {
      49      355459 :     union av_intfloat32 *xi = (union av_intfloat32*) x;
      50             :     int i;
      51     6042803 :     for (i = 1; i < 64; i += 4) {
      52     5687344 :         xi[i + 0].i ^= 1U << 31;
      53     5687344 :         xi[i + 2].i ^= 1U << 31;
      54             :     }
      55      355459 : }
      56             : 
      57      365091 : static void sbr_qmf_pre_shuffle_c(float *z)
      58             : {
      59      365091 :     union av_intfloat32 *zi = (union av_intfloat32*) z;
      60             :     int k;
      61      365091 :     zi[64].i = zi[0].i;
      62      365091 :     zi[65].i = zi[1].i;
      63     5841456 :     for (k = 1; k < 31; k += 2) {
      64     5476365 :         zi[64 + 2 * k + 0].i = zi[64 - k].i ^ (1U << 31);
      65     5476365 :         zi[64 + 2 * k + 1].i = zi[ k + 1].i;
      66     5476365 :         zi[64 + 2 * k + 2].i = zi[63 - k].i ^ (1U << 31);
      67     5476365 :         zi[64 + 2 * k + 3].i = zi[ k + 2].i;
      68             :     }
      69             : 
      70      365091 :     zi[64 + 2 * 31 + 0].i = zi[64 - 31].i ^ (1U << 31);
      71      365091 :     zi[64 + 2 * 31 + 1].i = zi[31 +  1].i;
      72      365091 : }
      73             : 
      74      365091 : static void sbr_qmf_post_shuffle_c(float W[32][2], const float *z)
      75             : {
      76      365091 :     const union av_intfloat32 *zi = (const union av_intfloat32*) z;
      77      365091 :     union av_intfloat32 *Wi       = (union av_intfloat32*) W;
      78             :     int k;
      79     6206547 :     for (k = 0; k < 32; k += 2) {
      80     5841456 :         Wi[2 * k + 0].i = zi[63 - k].i ^ (1U << 31);
      81     5841456 :         Wi[2 * k + 1].i = zi[ k + 0].i;
      82     5841456 :         Wi[2 * k + 2].i = zi[62 - k].i ^ (1U << 31);
      83     5841456 :         Wi[2 * k + 3].i = zi[ k + 1].i;
      84             :     }
      85      365091 : }
      86             : 
      87       73603 : static void sbr_qmf_deint_neg_c(float *v, const float *src)
      88             : {
      89       73603 :     const union av_intfloat32 *si = (const union av_intfloat32*)src;
      90       73603 :     union av_intfloat32 *vi = (union av_intfloat32*)v;
      91             :     int i;
      92     2428899 :     for (i = 0; i < 32; i++) {
      93     2355296 :         vi[     i].i = si[63 - 2 * i    ].i;
      94     2355296 :         vi[63 - i].i = si[63 - 2 * i - 1].i ^ (1U << 31);
      95             :     }
      96       73603 : }
      97             : 
      98             : #if 0
      99             :     /* This code is slower because it multiplies memory accesses.
     100             :      * It is left for educational purposes and because it may offer
     101             :      * a better reference for writing arch-specific DSP functions. */
     102             : static av_always_inline void autocorrelate(const float x[40][2],
     103             :                                            float phi[3][2][2], int lag)
     104             : {
     105             :     int i;
     106             :     float real_sum = 0.0f;
     107             :     float imag_sum = 0.0f;
     108             :     if (lag) {
     109             :         for (i = 1; i < 38; i++) {
     110             :             real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
     111             :             imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
     112             :         }
     113             :         phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
     114             :         phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
     115             :         if (lag == 1) {
     116             :             phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
     117             :             phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
     118             :         }
     119             :     } else {
     120             :         for (i = 1; i < 38; i++) {
     121             :             real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
     122             :         }
     123             :         phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
     124             :         phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
     125             :     }
     126             : }
     127             : 
     128             : static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
     129             : {
     130             :     autocorrelate(x, phi, 0);
     131             :     autocorrelate(x, phi, 1);
     132             :     autocorrelate(x, phi, 2);
     133             : }
     134             : #else
     135      124327 : static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
     136             : {
     137      124327 :     float real_sum2 = x[0][0] * x[2][0] + x[0][1] * x[2][1];
     138      124327 :     float imag_sum2 = x[0][0] * x[2][1] - x[0][1] * x[2][0];
     139      124327 :     float real_sum1 = 0.0f, imag_sum1 = 0.0f, real_sum0 = 0.0f;
     140             :     int   i;
     141     4724426 :     for (i = 1; i < 38; i++) {
     142     4600099 :         real_sum0 += x[i][0] * x[i    ][0] + x[i][1] * x[i    ][1];
     143     4600099 :         real_sum1 += x[i][0] * x[i + 1][0] + x[i][1] * x[i + 1][1];
     144     4600099 :         imag_sum1 += x[i][0] * x[i + 1][1] - x[i][1] * x[i + 1][0];
     145     4600099 :         real_sum2 += x[i][0] * x[i + 2][0] + x[i][1] * x[i + 2][1];
     146     4600099 :         imag_sum2 += x[i][0] * x[i + 2][1] - x[i][1] * x[i + 2][0];
     147             :     }
     148      124327 :     phi[2 - 2][1][0] = real_sum2;
     149      124327 :     phi[2 - 2][1][1] = imag_sum2;
     150      124327 :     phi[2    ][1][0] = real_sum0 + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
     151      124327 :     phi[1    ][0][0] = real_sum0 + x[38][0] * x[38][0] + x[38][1] * x[38][1];
     152      124327 :     phi[2 - 1][1][0] = real_sum1 + x[ 0][0] * x[ 1][0] + x[ 0][1] * x[ 1][1];
     153      124327 :     phi[2 - 1][1][1] = imag_sum1 + x[ 0][0] * x[ 1][1] - x[ 0][1] * x[ 1][0];
     154      124327 :     phi[0    ][0][0] = real_sum1 + x[38][0] * x[39][0] + x[38][1] * x[39][1];
     155      124327 :     phi[0    ][0][1] = imag_sum1 + x[38][0] * x[39][1] - x[38][1] * x[39][0];
     156      124327 : }
     157             : #endif
     158             : 
     159      172098 : static void sbr_hf_gen_c(float (*X_high)[2], const float (*X_low)[2],
     160             :                          const float alpha0[2], const float alpha1[2],
     161             :                          float bw, int start, int end)
     162             : {
     163             :     float alpha[4];
     164             :     int i;
     165             : 
     166      172098 :     alpha[0] = alpha1[0] * bw * bw;
     167      172098 :     alpha[1] = alpha1[1] * bw * bw;
     168      172098 :     alpha[2] = alpha0[0] * bw;
     169      172098 :     alpha[3] = alpha0[1] * bw;
     170             : 
     171     5685186 :     for (i = start; i < end; i++) {
     172    11026176 :         X_high[i][0] =
     173    11026176 :             X_low[i - 2][0] * alpha[0] -
     174    11026176 :             X_low[i - 2][1] * alpha[1] +
     175    11026176 :             X_low[i - 1][0] * alpha[2] -
     176    11026176 :             X_low[i - 1][1] * alpha[3] +
     177     5513088 :             X_low[i][0];
     178    11026176 :         X_high[i][1] =
     179    11026176 :             X_low[i - 2][1] * alpha[0] +
     180    11026176 :             X_low[i - 2][0] * alpha[1] +
     181    11026176 :             X_low[i - 1][1] * alpha[2] +
     182    11026176 :             X_low[i - 1][0] * alpha[3] +
     183     5513088 :             X_low[i][1];
     184             :     }
     185      172098 : }
     186             : 
     187      212195 : static void sbr_hf_g_filt_c(float (*Y)[2], const float (*X_high)[40][2],
     188             :                             const float *g_filt, int m_max, intptr_t ixh)
     189             : {
     190             :     int m;
     191             : 
     192     5716739 :     for (m = 0; m < m_max; m++) {
     193     5504544 :         Y[m][0] = X_high[m][ixh][0] * g_filt[m];
     194     5504544 :         Y[m][1] = X_high[m][ixh][1] * g_filt[m];
     195             :     }
     196      212195 : }
     197             : 
     198      209994 : static av_always_inline void sbr_hf_apply_noise(float (*Y)[2],
     199             :                                                 const float *s_m,
     200             :                                                 const float *q_filt,
     201             :                                                 int noise,
     202             :                                                 float phi_sign0,
     203             :                                                 float phi_sign1,
     204             :                                                 int m_max)
     205             : {
     206             :     int m;
     207             : 
     208     5659882 :     for (m = 0; m < m_max; m++) {
     209     5449888 :         float y0 = Y[m][0];
     210     5449888 :         float y1 = Y[m][1];
     211     5449888 :         noise = (noise + 1) & 0x1ff;
     212     5449888 :         if (s_m[m]) {
     213       39374 :             y0 += s_m[m] * phi_sign0;
     214       39374 :             y1 += s_m[m] * phi_sign1;
     215             :         } else {
     216     5410514 :             y0 += q_filt[m] * ff_sbr_noise_table[noise][0];
     217     5410514 :             y1 += q_filt[m] * ff_sbr_noise_table[noise][1];
     218             :         }
     219     5449888 :         Y[m][0] = y0;
     220     5449888 :         Y[m][1] = y1;
     221     5449888 :         phi_sign1 = -phi_sign1;
     222             :     }
     223      209994 : }
     224             : 
     225             : #include "sbrdsp_template.c"

Generated by: LCOV version 1.13