LCOV - code coverage report
Current view: top level - src/tests/checkasm - float_dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 149 186 80.1 %
Date: 2017-06-23 19:00:59 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This file is part of FFmpeg.
       3             :  *
       4             :  * FFmpeg is free software; you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation; either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * FFmpeg is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU General Public License along
      15             :  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : #include "config.h"
      20             : 
      21             : #include <float.h>
      22             : #include <stdint.h>
      23             : 
      24             : #include "libavutil/float_dsp.h"
      25             : #include "libavutil/internal.h"
      26             : #include "checkasm.h"
      27             : 
      28             : #define LEN 256
      29             : 
      30             : #define randomize_buffer(buf)                 \
      31             : do {                                          \
      32             :     int i;                                    \
      33             :     double bmg[2], stddev = 10.0, mean = 0.0; \
      34             :                                               \
      35             :     for (i = 0; i < LEN; i += 2) {            \
      36             :         av_bmg_get(&checkasm_lfg, bmg);       \
      37             :         buf[i]     = bmg[0] * stddev + mean;  \
      38             :         buf[i + 1] = bmg[1] * stddev + mean;  \
      39             :     }                                         \
      40             : } while(0);
      41             : 
      42           7 : static void test_vector_fmul(const float *src0, const float *src1)
      43             : {
      44           7 :     LOCAL_ALIGNED_32(float, cdst, [LEN]);
      45           7 :     LOCAL_ALIGNED_32(float, odst, [LEN]);
      46             :     int i;
      47             : 
      48           7 :     declare_func(void, float *dst, const float *src0, const float *src1,
      49             :                  int len);
      50             : 
      51           7 :     call_ref(cdst, src0, src1, LEN);
      52           7 :     call_new(odst, src0, src1, LEN);
      53        1799 :     for (i = 0; i < LEN; i++) {
      54        1792 :         if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON)) {
      55           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
      56           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
      57           0 :             fail();
      58           0 :             break;
      59             :         }
      60             :     }
      61           7 :     bench_new(odst, src0, src1, LEN);
      62           7 : }
      63             : 
      64             : #define ARBITRARY_FMUL_ADD_CONST 0.005
      65           4 : static void test_vector_fmul_add(const float *src0, const float *src1, const float *src2)
      66             : {
      67           4 :     LOCAL_ALIGNED_32(float, cdst, [LEN]);
      68           4 :     LOCAL_ALIGNED_32(float, odst, [LEN]);
      69             :     int i;
      70             : 
      71           4 :     declare_func(void, float *dst, const float *src0, const float *src1,
      72             :                      const float *src2, int len);
      73             : 
      74           4 :     call_ref(cdst, src0, src1, src2, LEN);
      75           4 :     call_new(odst, src0, src1, src2, LEN);
      76        1028 :     for (i = 0; i < LEN; i++) {
      77        1024 :         if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_ADD_CONST)) {
      78           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
      79           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
      80           0 :             fail();
      81           0 :             break;
      82             :         }
      83             :     }
      84           4 :     bench_new(odst, src0, src1, src2, LEN);
      85           4 : }
      86             : 
      87           2 : static void test_vector_fmul_scalar(const float *src0, const float *src1)
      88             : {
      89           2 :     LOCAL_ALIGNED_16(float, cdst, [LEN]);
      90           2 :     LOCAL_ALIGNED_16(float, odst, [LEN]);
      91             :     int i;
      92             : 
      93           2 :     declare_func(void, float *dst, const float *src, float mul, int len);
      94             : 
      95           2 :     call_ref(cdst, src0, src1[0], LEN);
      96           2 :     call_new(odst, src0, src1[0], LEN);
      97         514 :         for (i = 0; i < LEN; i++) {
      98         512 :             if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON)) {
      99           0 :                 fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     100           0 :                         i, cdst[i], odst[i], cdst[i] - odst[i]);
     101           0 :                 fail();
     102           0 :                 break;
     103             :             }
     104             :         }
     105           2 :     bench_new(odst, src0, src1[0], LEN);
     106           2 : }
     107             : 
     108             : #define ARBITRARY_FMUL_WINDOW_CONST 0.008
     109           2 : static void test_vector_fmul_window(const float *src0, const float *src1, const float *win)
     110             : {
     111           2 :     LOCAL_ALIGNED_16(float, cdst, [LEN]);
     112           2 :     LOCAL_ALIGNED_16(float, odst, [LEN]);
     113             :     int i;
     114             : 
     115           2 :     declare_func(void, float *dst, const float *src0, const float *src1,
     116             :                  const float *win, int len);
     117             : 
     118           2 :     call_ref(cdst, src0, src1, win, LEN / 2);
     119           2 :     call_new(odst, src0, src1, win, LEN / 2);
     120         514 :     for (i = 0; i < LEN; i++) {
     121         512 :         if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_WINDOW_CONST)) {
     122           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     123           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
     124           0 :             fail();
     125           0 :             break;
     126             :         }
     127             :     }
     128           2 :     bench_new(odst, src0, src1, win, LEN / 2);
     129           2 : }
     130             : 
     131             : #define ARBITRARY_FMAC_SCALAR_CONST 0.005
     132           4 : static void test_vector_fmac_scalar(const float *src0, const float *src1, const float *src2)
     133             : {
     134           4 :     LOCAL_ALIGNED_32(float, cdst, [LEN]);
     135           4 :     LOCAL_ALIGNED_32(float, odst, [LEN]);
     136             :     int i;
     137             : 
     138           4 :     declare_func(void, float *dst, const float *src, float mul, int len);
     139             : 
     140           4 :     memcpy(cdst, src2, LEN * sizeof(*src2));
     141           4 :     memcpy(odst, src2, LEN * sizeof(*src2));
     142             : 
     143           4 :     call_ref(cdst, src0, src1[0], LEN);
     144           4 :     call_new(odst, src0, src1[0], LEN);
     145        1028 :     for (i = 0; i < LEN; i++) {
     146        1024 :         if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMAC_SCALAR_CONST)) {
     147           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     148           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
     149           0 :             fail();
     150           0 :             break;
     151             :         }
     152             :     }
     153           4 :     memcpy(odst, src2, LEN * sizeof(*src2));
     154           4 :     bench_new(odst, src0, src1[0], LEN);
     155           4 : }
     156             : 
     157           3 : static void test_vector_dmul_scalar(const double *src0, const double *src1)
     158             : {
     159           3 :     LOCAL_ALIGNED_32(double, cdst, [LEN]);
     160           3 :     LOCAL_ALIGNED_32(double, odst, [LEN]);
     161             :     int i;
     162             : 
     163           3 :     declare_func(void, double *dst, const double *src, double mul, int len);
     164             : 
     165           3 :     call_ref(cdst, src0, src1[0], LEN);
     166           3 :     call_new(odst, src0, src1[0], LEN);
     167         771 :     for (i = 0; i < LEN; i++) {
     168         768 :         if (!double_near_abs_eps(cdst[i], odst[i], DBL_EPSILON)) {
     169           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n", i,
     170           0 :                     cdst[i], odst[i], cdst[i] - odst[i]);
     171           0 :             fail();
     172           0 :             break;
     173             :         }
     174             :     }
     175           3 :     bench_new(odst, src0, src1[0], LEN);
     176           3 : }
     177             : 
     178             : #define ARBITRARY_DMAC_SCALAR_CONST 0.005
     179           4 : static void test_vector_dmac_scalar(const double *src0, const double *src1, const double *src2)
     180             : {
     181           4 :     LOCAL_ALIGNED_32(double, cdst, [LEN]);
     182           4 :     LOCAL_ALIGNED_32(double, odst, [LEN]);
     183             :     int i;
     184             : 
     185           4 :     declare_func(void, double *dst, const double *src, double mul, int len);
     186             : 
     187           4 :     memcpy(cdst, src2, LEN * sizeof(*src2));
     188           4 :     memcpy(odst, src2, LEN * sizeof(*src2));
     189           4 :     call_ref(cdst, src0, src1[0], LEN);
     190           4 :     call_new(odst, src0, src1[0], LEN);
     191        1028 :     for (i = 0; i < LEN; i++) {
     192        1024 :         if (!double_near_abs_eps(cdst[i], odst[i], ARBITRARY_DMAC_SCALAR_CONST)) {
     193           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     194           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
     195           0 :             fail();
     196           0 :             break;
     197             :         }
     198             :     }
     199           4 :     memcpy(odst, src2, LEN * sizeof(*src2));
     200           4 :     bench_new(odst, src0, src1[0], LEN);
     201           4 : }
     202             : 
     203           2 : static void test_butterflies_float(const float *src0, const float *src1)
     204             : {
     205           2 :     LOCAL_ALIGNED_16(float,  cdst,  [LEN]);
     206           2 :     LOCAL_ALIGNED_16(float,  odst,  [LEN]);
     207           2 :     LOCAL_ALIGNED_16(float,  cdst1, [LEN]);
     208           2 :     LOCAL_ALIGNED_16(float,  odst1, [LEN]);
     209             :     int i;
     210             : 
     211           2 :     declare_func(void, float *av_restrict src0, float *av_restrict src1,
     212             :     int len);
     213             : 
     214           2 :     memcpy(cdst,  src0, LEN * sizeof(*src0));
     215           2 :     memcpy(cdst1, src1, LEN * sizeof(*src1));
     216           2 :     memcpy(odst,  src0, LEN * sizeof(*src0));
     217           2 :     memcpy(odst1, src1, LEN * sizeof(*src1));
     218             : 
     219           2 :     call_ref(cdst, cdst1, LEN);
     220           2 :     call_new(odst, odst1, LEN);
     221         514 :     for (i = 0; i < LEN; i++) {
     222         512 :         if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON)) {
     223           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     224           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
     225           0 :             fail();
     226           0 :             break;
     227             :         }
     228             :     }
     229           2 :     memcpy(odst,  src0, LEN * sizeof(*src0));
     230           2 :     memcpy(odst1, src1, LEN * sizeof(*src1));
     231           2 :     bench_new(odst, odst1, LEN);
     232           2 : }
     233             : 
     234             : #define ARBITRARY_SCALARPRODUCT_CONST 0.2
     235           2 : static void test_scalarproduct_float(const float *src0, const float *src1)
     236             : {
     237             :     float cprod, oprod;
     238             : 
     239           2 :     declare_func_float(float, const float *src0, const float *src1, int len);
     240             : 
     241           2 :     cprod = call_ref(src0, src1, LEN);
     242           2 :     oprod = call_new(src0, src1, LEN);
     243           2 :     if (!float_near_abs_eps(cprod, oprod, ARBITRARY_SCALARPRODUCT_CONST)) {
     244           0 :         fprintf(stderr, "%- .12f - %- .12f = % .12g\n",
     245           0 :                 cprod, oprod, cprod - oprod);
     246           0 :         fail();
     247             :     }
     248           2 :     bench_new(src0, src1, LEN);
     249           2 : }
     250             : 
     251          13 : void checkasm_check_float_dsp(void)
     252             : {
     253          13 :     LOCAL_ALIGNED_32(float,  src0,     [LEN]);
     254          13 :     LOCAL_ALIGNED_32(float,  src1,     [LEN]);
     255          13 :     LOCAL_ALIGNED_32(float,  src2,     [LEN]);
     256          13 :     LOCAL_ALIGNED_16(float,  src3,     [LEN]);
     257          13 :     LOCAL_ALIGNED_16(float,  src4,     [LEN]);
     258          13 :     LOCAL_ALIGNED_16(float,  src5,     [LEN]);
     259          13 :     LOCAL_ALIGNED_32(double, dbl_src0, [LEN]);
     260          13 :     LOCAL_ALIGNED_32(double, dbl_src1, [LEN]);
     261          13 :     LOCAL_ALIGNED_32(double, dbl_src2, [LEN]);
     262          13 :     AVFloatDSPContext *fdsp = avpriv_float_dsp_alloc(1);
     263             : 
     264          13 :     if (!fdsp) {
     265           0 :         fprintf(stderr, "floatdsp: Out of memory error\n");
     266           0 :         return;
     267             :     }
     268             : 
     269          13 :     randomize_buffer(src0);
     270          13 :     randomize_buffer(src1);
     271          13 :     randomize_buffer(src2);
     272          13 :     randomize_buffer(src3);
     273          13 :     randomize_buffer(src4);
     274          13 :     randomize_buffer(src5);
     275          13 :     randomize_buffer(dbl_src0);
     276          13 :     randomize_buffer(dbl_src1);
     277          13 :     randomize_buffer(dbl_src2);
     278             : 
     279          13 :     if (check_func(fdsp->vector_fmul, "vector_fmul"))
     280           3 :         test_vector_fmul(src0, src1);
     281          13 :     if (check_func(fdsp->vector_fmul_add, "vector_fmul_add"))
     282           4 :         test_vector_fmul_add(src0, src1, src2);
     283          13 :     if (check_func(fdsp->vector_fmul_scalar, "vector_fmul_scalar"))
     284           2 :         test_vector_fmul_scalar(src3, src4);
     285          13 :     if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse"))
     286           4 :         test_vector_fmul(src0, src1);
     287          13 :     if (check_func(fdsp->vector_fmul_window, "vector_fmul_window"))
     288           2 :         test_vector_fmul_window(src3, src4, src5);
     289          13 :     report("vector_fmul");
     290          13 :     if (check_func(fdsp->vector_fmac_scalar, "vector_fmac_scalar"))
     291           4 :         test_vector_fmac_scalar(src0, src1, src2);
     292          13 :     report("vector_fmac");
     293          13 :     if (check_func(fdsp->vector_dmul_scalar, "vector_dmul_scalar"))
     294           3 :         test_vector_dmul_scalar(dbl_src0, dbl_src1);
     295          13 :     report("vector_dmul");
     296          13 :     if (check_func(fdsp->vector_dmac_scalar, "vector_dmac_scalar"))
     297           4 :         test_vector_dmac_scalar(dbl_src0, dbl_src1, dbl_src2);
     298          13 :     report("vector_dmac");
     299          13 :     if (check_func(fdsp->butterflies_float, "butterflies_float"))
     300           2 :         test_butterflies_float(src3, src4);
     301          13 :     report("butterflies_float");
     302          13 :     if (check_func(fdsp->scalarproduct_float, "scalarproduct_float"))
     303           2 :         test_scalarproduct_float(src3, src4);
     304          13 :     report("scalarproduct_float");
     305             : 
     306          13 :     av_freep(&fdsp);
     307             : }

Generated by: LCOV version 1.13