LCOV - code coverage report
Current view: top level - src/libavutil - float_dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 62 63 98.4 %
Date: 2017-01-21 09:32:20 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright 2005 Balatoni Denes
       3             :  * Copyright 2006 Loren Merritt
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include "config.h"
      23             : #include "attributes.h"
      24             : #include "float_dsp.h"
      25             : #include "mem.h"
      26             : 
      27      527872 : static void vector_fmul_c(float *dst, const float *src0, const float *src1,
      28             :                           int len)
      29             : {
      30             :     int i;
      31    64279968 :     for (i = 0; i < len; i++)
      32    63752096 :         dst[i] = src0[i] * src1[i];
      33      527872 : }
      34             : 
      35       11558 : static void vector_fmac_scalar_c(float *dst, const float *src, float mul,
      36             :                                  int len)
      37             : {
      38             :     int i;
      39     9027238 :     for (i = 0; i < len; i++)
      40     9015680 :         dst[i] += src[i] * mul;
      41       11558 : }
      42             : 
      43      504367 : static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
      44             :                                  int len)
      45             : {
      46             :     int i;
      47    12659915 :     for (i = 0; i < len; i++)
      48    12155548 :         dst[i] = src[i] * mul;
      49      504367 : }
      50             : 
      51           2 : static void vector_dmul_scalar_c(double *dst, const double *src, double mul,
      52             :                                  int len)
      53             : {
      54             :     int i;
      55         482 :     for (i = 0; i < len; i++)
      56         480 :         dst[i] = src[i] * mul;
      57           2 : }
      58             : 
      59      204544 : static void vector_fmul_window_c(float *dst, const float *src0,
      60             :                                  const float *src1, const float *win, int len)
      61             : {
      62             :     int i, j;
      63             : 
      64      204544 :     dst  += len;
      65      204544 :     win  += len;
      66      204544 :     src0 += len;
      67             : 
      68    39411264 :     for (i = -len, j = len - 1; i < 0; i++, j--) {
      69    39206720 :         float s0 = src0[i];
      70    39206720 :         float s1 = src1[j];
      71    39206720 :         float wi = win[i];
      72    39206720 :         float wj = win[j];
      73    39206720 :         dst[i] = s0 * wj - s1 * wi;
      74    39206720 :         dst[j] = s0 * wi + s1 * wj;
      75             :     }
      76      204544 : }
      77             : 
      78     3800694 : static void vector_fmul_add_c(float *dst, const float *src0, const float *src1,
      79             :                               const float *src2, int len){
      80             :     int i;
      81             : 
      82   227475542 :     for (i = 0; i < len; i++)
      83   223674848 :         dst[i] = src0[i] * src1[i] + src2[i];
      84     3800694 : }
      85             : 
      86      399052 : static void vector_fmul_reverse_c(float *dst, const float *src0,
      87             :                                   const float *src1, int len)
      88             : {
      89             :     int i;
      90             : 
      91      399052 :     src1 += len-1;
      92   133028204 :     for (i = 0; i < len; i++)
      93   132629152 :         dst[i] = src0[i] * src1[-i];
      94      399052 : }
      95             : 
      96      505345 : static void butterflies_float_c(float *av_restrict v1, float *av_restrict v2,
      97             :                                 int len)
      98             : {
      99             :     int i;
     100             : 
     101     8078289 :     for (i = 0; i < len; i++) {
     102     7572944 :         float t = v1[i] - v2[i];
     103     7572944 :         v1[i] += v2[i];
     104     7572944 :         v2[i] = t;
     105             :     }
     106      505345 : }
     107             : 
     108     1426037 : float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
     109             : {
     110     1426037 :     float p = 0.0;
     111             :     int i;
     112             : 
     113    45817113 :     for (i = 0; i < len; i++)
     114    44391076 :         p += v1[i] * v2[i];
     115             : 
     116     1426037 :     return p;
     117             : }
     118             : 
     119         673 : av_cold AVFloatDSPContext *avpriv_float_dsp_alloc(int bit_exact)
     120             : {
     121         673 :     AVFloatDSPContext *fdsp = av_mallocz(sizeof(AVFloatDSPContext));
     122         673 :     if (!fdsp)
     123           0 :         return NULL;
     124             : 
     125         673 :     fdsp->vector_fmul = vector_fmul_c;
     126         673 :     fdsp->vector_fmac_scalar = vector_fmac_scalar_c;
     127         673 :     fdsp->vector_fmul_scalar = vector_fmul_scalar_c;
     128         673 :     fdsp->vector_dmul_scalar = vector_dmul_scalar_c;
     129         673 :     fdsp->vector_fmul_window = vector_fmul_window_c;
     130         673 :     fdsp->vector_fmul_add = vector_fmul_add_c;
     131         673 :     fdsp->vector_fmul_reverse = vector_fmul_reverse_c;
     132         673 :     fdsp->butterflies_float = butterflies_float_c;
     133         673 :     fdsp->scalarproduct_float = avpriv_scalarproduct_float_c;
     134             : 
     135             :     if (ARCH_AARCH64)
     136             :         ff_float_dsp_init_aarch64(fdsp);
     137             :     if (ARCH_ARM)
     138             :         ff_float_dsp_init_arm(fdsp);
     139             :     if (ARCH_PPC)
     140             :         ff_float_dsp_init_ppc(fdsp, bit_exact);
     141             :     if (ARCH_X86)
     142         673 :         ff_float_dsp_init_x86(fdsp);
     143             :     if (ARCH_MIPS)
     144             :         ff_float_dsp_init_mips(fdsp);
     145         673 :     return fdsp;
     146             : }

Generated by: LCOV version 1.12