LCOV - code coverage report
Current view: top level - src/tests/checkasm - float_dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 150 189 79.4 %
Date: 2017-08-17 10:06:07 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        1024 :         if (!float_near_abs_eps(cdst[i],  odst[i],  FLT_EPSILON) ||
     223         512 :             !float_near_abs_eps(cdst1[i], odst1[i], FLT_EPSILON)) {
     224           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     225           0 :                     i, cdst[i], odst[i], cdst[i] - odst[i]);
     226           0 :             fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
     227           0 :                     i, cdst1[i], odst1[i], cdst1[i] - odst1[i]);
     228           0 :             fail();
     229           0 :             break;
     230             :         }
     231             :     }
     232           2 :     memcpy(odst,  src0, LEN * sizeof(*src0));
     233           2 :     memcpy(odst1, src1, LEN * sizeof(*src1));
     234           2 :     bench_new(odst, odst1, LEN);
     235           2 : }
     236             : 
     237             : #define ARBITRARY_SCALARPRODUCT_CONST 0.2
     238           2 : static void test_scalarproduct_float(const float *src0, const float *src1)
     239             : {
     240             :     float cprod, oprod;
     241             : 
     242           2 :     declare_func_float(float, const float *src0, const float *src1, int len);
     243             : 
     244           2 :     cprod = call_ref(src0, src1, LEN);
     245           2 :     oprod = call_new(src0, src1, LEN);
     246           2 :     if (!float_near_abs_eps(cprod, oprod, ARBITRARY_SCALARPRODUCT_CONST)) {
     247           0 :         fprintf(stderr, "%- .12f - %- .12f = % .12g\n",
     248           0 :                 cprod, oprod, cprod - oprod);
     249           0 :         fail();
     250             :     }
     251           2 :     bench_new(src0, src1, LEN);
     252           2 : }
     253             : 
     254          13 : void checkasm_check_float_dsp(void)
     255             : {
     256          13 :     LOCAL_ALIGNED_32(float,  src0,     [LEN]);
     257          13 :     LOCAL_ALIGNED_32(float,  src1,     [LEN]);
     258          13 :     LOCAL_ALIGNED_32(float,  src2,     [LEN]);
     259          13 :     LOCAL_ALIGNED_16(float,  src3,     [LEN]);
     260          13 :     LOCAL_ALIGNED_16(float,  src4,     [LEN]);
     261          13 :     LOCAL_ALIGNED_16(float,  src5,     [LEN]);
     262          13 :     LOCAL_ALIGNED_32(double, dbl_src0, [LEN]);
     263          13 :     LOCAL_ALIGNED_32(double, dbl_src1, [LEN]);
     264          13 :     LOCAL_ALIGNED_32(double, dbl_src2, [LEN]);
     265          13 :     AVFloatDSPContext *fdsp = avpriv_float_dsp_alloc(1);
     266             : 
     267          13 :     if (!fdsp) {
     268           0 :         fprintf(stderr, "floatdsp: Out of memory error\n");
     269           0 :         return;
     270             :     }
     271             : 
     272          13 :     randomize_buffer(src0);
     273          13 :     randomize_buffer(src1);
     274          13 :     randomize_buffer(src2);
     275          13 :     randomize_buffer(src3);
     276          13 :     randomize_buffer(src4);
     277          13 :     randomize_buffer(src5);
     278          13 :     randomize_buffer(dbl_src0);
     279          13 :     randomize_buffer(dbl_src1);
     280          13 :     randomize_buffer(dbl_src2);
     281             : 
     282          13 :     if (check_func(fdsp->vector_fmul, "vector_fmul"))
     283           3 :         test_vector_fmul(src0, src1);
     284          13 :     if (check_func(fdsp->vector_fmul_add, "vector_fmul_add"))
     285           4 :         test_vector_fmul_add(src0, src1, src2);
     286          13 :     if (check_func(fdsp->vector_fmul_scalar, "vector_fmul_scalar"))
     287           2 :         test_vector_fmul_scalar(src3, src4);
     288          13 :     if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse"))
     289           4 :         test_vector_fmul(src0, src1);
     290          13 :     if (check_func(fdsp->vector_fmul_window, "vector_fmul_window"))
     291           2 :         test_vector_fmul_window(src3, src4, src5);
     292          13 :     report("vector_fmul");
     293          13 :     if (check_func(fdsp->vector_fmac_scalar, "vector_fmac_scalar"))
     294           4 :         test_vector_fmac_scalar(src0, src1, src2);
     295          13 :     report("vector_fmac");
     296          13 :     if (check_func(fdsp->vector_dmul_scalar, "vector_dmul_scalar"))
     297           3 :         test_vector_dmul_scalar(dbl_src0, dbl_src1);
     298          13 :     report("vector_dmul");
     299          13 :     if (check_func(fdsp->vector_dmac_scalar, "vector_dmac_scalar"))
     300           4 :         test_vector_dmac_scalar(dbl_src0, dbl_src1, dbl_src2);
     301          13 :     report("vector_dmac");
     302          13 :     if (check_func(fdsp->butterflies_float, "butterflies_float"))
     303           2 :         test_butterflies_float(src3, src4);
     304          13 :     report("butterflies_float");
     305          13 :     if (check_func(fdsp->scalarproduct_float, "scalarproduct_float"))
     306           2 :         test_scalarproduct_float(src3, src4);
     307          13 :     report("scalarproduct_float");
     308             : 
     309          13 :     av_freep(&fdsp);
     310             : }

Generated by: LCOV version 1.13