LCOV - code coverage report
Current view: top level - src/libavcodec - aacps_tablegen.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 75 75 100.0 %
Date: 2017-01-24 04:42:20 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Header file for hardcoded Parametric Stereo tables
       3             :  *
       4             :  * Copyright (c) 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             : #ifndef AVCODEC_AACPS_TABLEGEN_H
      24             : #define AVCODEC_AACPS_TABLEGEN_H
      25             : 
      26             : #include <math.h>
      27             : #include <stdint.h>
      28             : 
      29             : #if CONFIG_HARDCODED_TABLES
      30             : #define ps_tableinit()
      31             : #define TABLE_CONST const
      32             : #include "libavcodec/aacps_tables.h"
      33             : #else
      34             : #include "libavutil/common.h"
      35             : #include "libavutil/libm.h"
      36             : #include "libavutil/mathematics.h"
      37             : #include "libavutil/mem.h"
      38             : #define NR_ALLPASS_BANDS20 30
      39             : #define NR_ALLPASS_BANDS34 50
      40             : #define PS_AP_LINKS 3
      41             : #define TABLE_CONST
      42             : static float pd_re_smooth[8*8*8];
      43             : static float pd_im_smooth[8*8*8];
      44             : static float HA[46][8][4];
      45             : static float HB[46][8][4];
      46             : static DECLARE_ALIGNED(16, float, f20_0_8) [ 8][8][2];
      47             : static DECLARE_ALIGNED(16, float, f34_0_12)[12][8][2];
      48             : static DECLARE_ALIGNED(16, float, f34_1_8) [ 8][8][2];
      49             : static DECLARE_ALIGNED(16, float, f34_2_4) [ 4][8][2];
      50             : static TABLE_CONST DECLARE_ALIGNED(16, float, Q_fract_allpass)[2][50][3][2];
      51             : static DECLARE_ALIGNED(16, float, phi_fract)[2][50][2];
      52             : 
      53             : static const float g0_Q8[] = {
      54             :     0.00746082949812f, 0.02270420949825f, 0.04546865930473f, 0.07266113929591f,
      55             :     0.09885108575264f, 0.11793710567217f, 0.125f
      56             : };
      57             : 
      58             : static const float g0_Q12[] = {
      59             :     0.04081179924692f, 0.03812810994926f, 0.05144908135699f, 0.06399831151592f,
      60             :     0.07428313801106f, 0.08100347892914f, 0.08333333333333f
      61             : };
      62             : 
      63             : static const float g1_Q8[] = {
      64             :     0.01565675600122f, 0.03752716391991f, 0.05417891378782f, 0.08417044116767f,
      65             :     0.10307344158036f, 0.12222452249753f, 0.125f
      66             : };
      67             : 
      68             : static const float g2_Q4[] = {
      69             :     -0.05908211155639f, -0.04871498374946f, 0.0f,   0.07778723915851f,
      70             :      0.16486303567403f,  0.23279856662996f, 0.25f
      71             : };
      72             : 
      73         544 : static av_cold void make_filters_from_proto(float (*filter)[8][2], const float *proto, int bands)
      74             : {
      75             :     int q, n;
      76        4896 :     for (q = 0; q < bands; q++) {
      77       34816 :         for (n = 0; n < 7; n++) {
      78       30464 :             double theta = 2 * M_PI * (q + 0.5) * (n - 6) / bands;
      79       30464 :             filter[q][n][0] = proto[n] *  cos(theta);
      80       30464 :             filter[q][n][1] = proto[n] * -sin(theta);
      81             :         }
      82             :     }
      83         544 : }
      84             : 
      85         136 : static av_cold void ps_tableinit(void)
      86             : {
      87             :     static const float ipdopd_sin[] = { 0, M_SQRT1_2, 1,  M_SQRT1_2,  0, -M_SQRT1_2, -1, -M_SQRT1_2 };
      88             :     static const float ipdopd_cos[] = { 1, M_SQRT1_2, 0, -M_SQRT1_2, -1, -M_SQRT1_2,  0,  M_SQRT1_2 };
      89             :     int pd0, pd1, pd2;
      90             : 
      91             :     static const float iid_par_dequant[] = {
      92             :         //iid_par_dequant_default
      93             :         0.05623413251903, 0.12589254117942, 0.19952623149689, 0.31622776601684,
      94             :         0.44668359215096, 0.63095734448019, 0.79432823472428, 1,
      95             :         1.25892541179417, 1.58489319246111, 2.23872113856834, 3.16227766016838,
      96             :         5.01187233627272, 7.94328234724282, 17.7827941003892,
      97             :         //iid_par_dequant_fine
      98             :         0.00316227766017, 0.00562341325190, 0.01,             0.01778279410039,
      99             :         0.03162277660168, 0.05623413251903, 0.07943282347243, 0.11220184543020,
     100             :         0.15848931924611, 0.22387211385683, 0.31622776601684, 0.39810717055350,
     101             :         0.50118723362727, 0.63095734448019, 0.79432823472428, 1,
     102             :         1.25892541179417, 1.58489319246111, 1.99526231496888, 2.51188643150958,
     103             :         3.16227766016838, 4.46683592150963, 6.30957344480193, 8.91250938133745,
     104             :         12.5892541179417, 17.7827941003892, 31.6227766016838, 56.2341325190349,
     105             :         100,              177.827941003892, 316.227766016837,
     106             :     };
     107             :     static const float icc_invq[] = {
     108             :         1, 0.937,      0.84118,    0.60092,    0.36764,   0,      -0.589,    -1
     109             :     };
     110             :     static const float acos_icc_invq[] = {
     111             :         0, 0.35685527, 0.57133466, 0.92614472, 1.1943263, M_PI/2, 2.2006171, M_PI
     112             :     };
     113             :     int iid, icc;
     114             : 
     115             :     int k, m;
     116             :     static const int8_t f_center_20[] = {
     117             :         -3, -1, 1, 3, 5, 7, 10, 14, 18, 22,
     118             :     };
     119             :     static const int8_t f_center_34[] = {
     120             :          2,  6, 10, 14, 18, 22, 26, 30,
     121             :         34,-10, -6, -2, 51, 57, 15, 21,
     122             :         27, 33, 39, 45, 54, 66, 78, 42,
     123             :        102, 66, 78, 90,102,114,126, 90,
     124             :     };
     125             :     static const float fractional_delay_links[] = { 0.43f, 0.75f, 0.347f };
     126         136 :     const float fractional_delay_gain = 0.39f;
     127             : 
     128        1224 :     for (pd0 = 0; pd0 < 8; pd0++) {
     129        1088 :         float pd0_re = ipdopd_cos[pd0];
     130        1088 :         float pd0_im = ipdopd_sin[pd0];
     131        9792 :         for (pd1 = 0; pd1 < 8; pd1++) {
     132        8704 :             float pd1_re = ipdopd_cos[pd1];
     133        8704 :             float pd1_im = ipdopd_sin[pd1];
     134       78336 :             for (pd2 = 0; pd2 < 8; pd2++) {
     135       69632 :                 float pd2_re = ipdopd_cos[pd2];
     136       69632 :                 float pd2_im = ipdopd_sin[pd2];
     137       69632 :                 float re_smooth = 0.25f * pd0_re + 0.5f * pd1_re + pd2_re;
     138       69632 :                 float im_smooth = 0.25f * pd0_im + 0.5f * pd1_im + pd2_im;
     139       69632 :                 float pd_mag = 1 / hypot(im_smooth, re_smooth);
     140       69632 :                 pd_re_smooth[pd0*64+pd1*8+pd2] = re_smooth * pd_mag;
     141       69632 :                 pd_im_smooth[pd0*64+pd1*8+pd2] = im_smooth * pd_mag;
     142             :             }
     143             :         }
     144             :     }
     145             : 
     146        6392 :     for (iid = 0; iid < 46; iid++) {
     147        6256 :         float c = iid_par_dequant[iid]; ///< Linear Inter-channel Intensity Difference
     148        6256 :         float c1 = (float)M_SQRT2 / sqrtf(1.0f + c*c);
     149        6256 :         float c2 = c * c1;
     150       56304 :         for (icc = 0; icc < 8; icc++) {
     151             :             /*if (PS_BASELINE || ps->icc_mode < 3)*/ {
     152       50048 :                 float alpha = 0.5f * acos_icc_invq[icc];
     153       50048 :                 float beta  = alpha * (c1 - c2) * (float)M_SQRT1_2;
     154       50048 :                 HA[iid][icc][0] = c2 * cosf(beta + alpha);
     155       50048 :                 HA[iid][icc][1] = c1 * cosf(beta - alpha);
     156       50048 :                 HA[iid][icc][2] = c2 * sinf(beta + alpha);
     157       50048 :                 HA[iid][icc][3] = c1 * sinf(beta - alpha);
     158             :             } /* else */ {
     159             :                 float alpha, gamma, mu, rho;
     160             :                 float alpha_c, alpha_s, gamma_c, gamma_s;
     161       50048 :                 rho = FFMAX(icc_invq[icc], 0.05f);
     162       50048 :                 alpha = 0.5f * atan2f(2.0f * c * rho, c*c - 1.0f);
     163       50048 :                 mu = c + 1.0f / c;
     164       50048 :                 mu = sqrtf(1 + (4 * rho * rho - 4)/(mu * mu));
     165       50048 :                 gamma = atanf(sqrtf((1.0f - mu)/(1.0f + mu)));
     166       50048 :                 if (alpha < 0) alpha += M_PI/2;
     167       50048 :                 alpha_c = cosf(alpha);
     168       50048 :                 alpha_s = sinf(alpha);
     169       50048 :                 gamma_c = cosf(gamma);
     170       50048 :                 gamma_s = sinf(gamma);
     171       50048 :                 HB[iid][icc][0] =  M_SQRT2 * alpha_c * gamma_c;
     172       50048 :                 HB[iid][icc][1] =  M_SQRT2 * alpha_s * gamma_c;
     173       50048 :                 HB[iid][icc][2] = -M_SQRT2 * alpha_s * gamma_s;
     174       50048 :                 HB[iid][icc][3] =  M_SQRT2 * alpha_c * gamma_s;
     175             :             }
     176             :         }
     177             :     }
     178             : 
     179        4216 :     for (k = 0; k < NR_ALLPASS_BANDS20; k++) {
     180             :         double f_center, theta;
     181        4080 :         if (k < FF_ARRAY_ELEMS(f_center_20))
     182        1360 :             f_center = f_center_20[k] * 0.125;
     183             :         else
     184        2720 :             f_center = k - 6.5f;
     185       16320 :         for (m = 0; m < PS_AP_LINKS; m++) {
     186       12240 :             theta = -M_PI * fractional_delay_links[m] * f_center;
     187       12240 :             Q_fract_allpass[0][k][m][0] = cos(theta);
     188       12240 :             Q_fract_allpass[0][k][m][1] = sin(theta);
     189             :         }
     190        4080 :         theta = -M_PI*fractional_delay_gain*f_center;
     191        4080 :         phi_fract[0][k][0] = cos(theta);
     192        4080 :         phi_fract[0][k][1] = sin(theta);
     193             :     }
     194        6936 :     for (k = 0; k < NR_ALLPASS_BANDS34; k++) {
     195             :         double f_center, theta;
     196        6800 :         if (k < FF_ARRAY_ELEMS(f_center_34))
     197        4352 :             f_center = f_center_34[k] / 24.0;
     198             :         else
     199        2448 :             f_center = k - 26.5f;
     200       27200 :         for (m = 0; m < PS_AP_LINKS; m++) {
     201       20400 :             theta = -M_PI * fractional_delay_links[m] * f_center;
     202       20400 :             Q_fract_allpass[1][k][m][0] = cos(theta);
     203       20400 :             Q_fract_allpass[1][k][m][1] = sin(theta);
     204             :         }
     205        6800 :         theta = -M_PI*fractional_delay_gain*f_center;
     206        6800 :         phi_fract[1][k][0] = cos(theta);
     207        6800 :         phi_fract[1][k][1] = sin(theta);
     208             :     }
     209             : 
     210         136 :     make_filters_from_proto(f20_0_8,  g0_Q8,   8);
     211         136 :     make_filters_from_proto(f34_0_12, g0_Q12, 12);
     212         136 :     make_filters_from_proto(f34_1_8,  g1_Q8,   8);
     213         136 :     make_filters_from_proto(f34_2_4,  g2_Q4,   4);
     214         136 : }
     215             : #endif /* CONFIG_HARDCODED_TABLES */
     216             : 
     217             : #endif /* AVCODEC_AACPS_TABLEGEN_H */

Generated by: LCOV version 1.12