LCOV - code coverage report
Current view: top level - tests/checkasm - aacpsdsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 121 129 93.8 %
Date: 2017-10-18 21:45:51 Functions: 7 7 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 "libavcodec/aacpsdsp.h"
      20             : 
      21             : #include "checkasm.h"
      22             : 
      23             : #define N 32
      24             : #define STRIDE 128
      25             : #define BUF_SIZE (N * STRIDE)
      26             : 
      27             : #define randomize(buf, len) do {                                \
      28             :     int i;                                                      \
      29             :     for (i = 0; i < len; i++) {                                 \
      30             :         const INTFLOAT f = (INTFLOAT)rnd() / UINT_MAX;          \
      31             :         (buf)[i] = f;                                           \
      32             :     }                                                           \
      33             : } while (0)
      34             : 
      35             : #define EPS 0.005
      36             : 
      37           3 : static void test_add_squares(void)
      38             : {
      39           3 :     LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE]);
      40           3 :     LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE]);
      41           3 :     LOCAL_ALIGNED_16(INTFLOAT, src, [BUF_SIZE], [2]);
      42             : 
      43           3 :     declare_func(void, INTFLOAT *dst,
      44             :                  const INTFLOAT (*src)[2], int n);
      45             : 
      46           3 :     randomize((INTFLOAT *)src, BUF_SIZE * 2);
      47           3 :     randomize(dst0, BUF_SIZE);
      48           3 :     memcpy(dst1, dst0, BUF_SIZE * sizeof(INTFLOAT));
      49           3 :     call_ref(dst0, src, BUF_SIZE);
      50           3 :     call_new(dst1, src, BUF_SIZE);
      51           3 :     if (!float_near_abs_eps_array(dst0, dst1, EPS, BUF_SIZE))
      52           0 :         fail();
      53           3 :     bench_new(dst1, src, BUF_SIZE);
      54           3 : }
      55             : 
      56           2 : static void test_mul_pair_single(void)
      57             : {
      58           2 :     LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
      59           2 :     LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
      60           2 :     LOCAL_ALIGNED_16(INTFLOAT, src0, [BUF_SIZE], [2]);
      61           2 :     LOCAL_ALIGNED_16(INTFLOAT, src1, [BUF_SIZE]);
      62             : 
      63           2 :     declare_func(void, INTFLOAT (*dst)[2],
      64             :                        INTFLOAT (*src0)[2], INTFLOAT *src1, int n);
      65             : 
      66           2 :     randomize((INTFLOAT *)src0, BUF_SIZE * 2);
      67           2 :     randomize(src1, BUF_SIZE);
      68           2 :     call_ref(dst0, src0, src1, BUF_SIZE);
      69           2 :     call_new(dst1, src0, src1, BUF_SIZE);
      70           2 :     if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
      71           0 :         fail();
      72           2 :     bench_new(dst1, src0, src1, BUF_SIZE);
      73           2 : }
      74             : 
      75           3 : static void test_hybrid_analysis(void)
      76             : {
      77           3 :     LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
      78           3 :     LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
      79           3 :     LOCAL_ALIGNED_16(INTFLOAT, in, [13], [2]);
      80           3 :     LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
      81             : 
      82           3 :     declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
      83             :                  const INTFLOAT (*filter)[8][2],
      84             :                  ptrdiff_t stride, int n);
      85             : 
      86           3 :     randomize((INTFLOAT *)in, 13 * 2);
      87           3 :     randomize((INTFLOAT *)filter, N * 8 * 2);
      88             : 
      89           3 :     randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
      90           3 :     memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
      91             : 
      92           3 :     call_ref(dst0, in, filter, STRIDE, N);
      93           3 :     call_new(dst1, in, filter, STRIDE, N);
      94             : 
      95           3 :     if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
      96           0 :         fail();
      97           3 :     bench_new(dst1, in, filter, STRIDE, N);
      98           3 : }
      99             : 
     100           2 : static void test_hybrid_analysis_ileave(void)
     101             : {
     102           2 :     LOCAL_ALIGNED_16(INTFLOAT, in,   [2], [38][64]);
     103           2 :     LOCAL_ALIGNED_16(INTFLOAT, out0, [91], [32][2]);
     104           2 :     LOCAL_ALIGNED_16(INTFLOAT, out1, [91], [32][2]);
     105             : 
     106           2 :     declare_func(void, INTFLOAT (*out)[32][2], INTFLOAT L[2][38][64],
     107             :                        int i, int len);
     108             : 
     109           2 :     randomize((INTFLOAT *)out0, 91 * 32 * 2);
     110           2 :     randomize((INTFLOAT *)in,    2 * 38 * 64);
     111           2 :     memcpy(out1, out0, 91 * 32 * 2 * sizeof(INTFLOAT));
     112             : 
     113             :     /* len is hardcoded to 32 as that's the only value used in
     114             :        libavcodec. asm functions are likely to be optimized
     115             :        hardcoding this value in their loops and could fail with
     116             :        anything else.
     117             :        i is hardcoded to the two values currently used by the
     118             :        aac decoder because the arm neon implementation is
     119             :        micro-optimized for them and will fail for almost every
     120             :        other value. */
     121           2 :     call_ref(out0, in, 3, 32);
     122           2 :     call_new(out1, in, 3, 32);
     123             : 
     124             :     /* the function just moves data around, so memcmp is enough */
     125           2 :     if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
     126           0 :         fail();
     127             : 
     128           2 :     call_ref(out0, in, 5, 32);
     129           2 :     call_new(out1, in, 5, 32);
     130             : 
     131           2 :     if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
     132           0 :         fail();
     133             : 
     134           2 :     bench_new(out1, in, 3, 32);
     135           2 : }
     136             : 
     137           3 : static void test_hybrid_synthesis_deint(void)
     138             : {
     139           3 :     LOCAL_ALIGNED_16(INTFLOAT, out0, [2], [38][64]);
     140           3 :     LOCAL_ALIGNED_16(INTFLOAT, out1, [2], [38][64]);
     141           3 :     LOCAL_ALIGNED_16(INTFLOAT, in,  [91], [32][2]);
     142             : 
     143           3 :     declare_func(void, INTFLOAT out[2][38][64], INTFLOAT (*in)[32][2],
     144             :                        int i, int len);
     145             : 
     146           3 :     randomize((INTFLOAT *)in,  91 * 32 * 2);
     147           3 :     randomize((INTFLOAT *)out0, 2 * 38 * 64);
     148           3 :     memcpy(out1, out0, 2 * 38 * 64 * sizeof(INTFLOAT));
     149             : 
     150             :     /* len is hardcoded to 32 as that's the only value used in
     151             :        libavcodec. asm functions are likely to be optimized
     152             :        hardcoding this value in their loops and could fail with
     153             :        anything else.
     154             :        i is hardcoded to the two values currently used by the
     155             :        aac decoder because the arm neon implementation is
     156             :        micro-optimized for them and will fail for almost every
     157             :        other value. */
     158           3 :     call_ref(out0, in, 3, 32);
     159           3 :     call_new(out1, in, 3, 32);
     160             : 
     161             :     /* the function just moves data around, so memcmp is enough */
     162           3 :     if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
     163           0 :         fail();
     164             : 
     165           3 :     call_ref(out0, in, 5, 32);
     166           3 :     call_new(out1, in, 5, 32);
     167             : 
     168           3 :     if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
     169           0 :         fail();
     170             : 
     171           3 :     bench_new(out1, in, 3, 32);
     172           3 : }
     173             : 
     174          13 : static void test_stereo_interpolate(PSDSPContext *psdsp)
     175             : {
     176             :     int i;
     177          13 :     LOCAL_ALIGNED_16(INTFLOAT, l,  [BUF_SIZE], [2]);
     178          13 :     LOCAL_ALIGNED_16(INTFLOAT, r,  [BUF_SIZE], [2]);
     179          13 :     LOCAL_ALIGNED_16(INTFLOAT, l0, [BUF_SIZE], [2]);
     180          13 :     LOCAL_ALIGNED_16(INTFLOAT, r0, [BUF_SIZE], [2]);
     181          13 :     LOCAL_ALIGNED_16(INTFLOAT, l1, [BUF_SIZE], [2]);
     182          13 :     LOCAL_ALIGNED_16(INTFLOAT, r1, [BUF_SIZE], [2]);
     183          13 :     LOCAL_ALIGNED_16(INTFLOAT, h, [2], [4]);
     184          13 :     LOCAL_ALIGNED_16(INTFLOAT, h_step, [2], [4]);
     185             : 
     186          13 :     declare_func(void, INTFLOAT (*l)[2], INTFLOAT (*r)[2],
     187             :                        INTFLOAT h[2][4], INTFLOAT h_step[2][4], int len);
     188             : 
     189          13 :     randomize((INTFLOAT *)l, BUF_SIZE * 2);
     190          13 :     randomize((INTFLOAT *)r, BUF_SIZE * 2);
     191             : 
     192          39 :     for (i = 0; i < 2; i++) {
     193          26 :         if (check_func(psdsp->stereo_interpolate[i], "ps_stereo_interpolate%s", i ? "_ipdopd" : "")) {
     194           4 :             memcpy(l0, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
     195           4 :             memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
     196           4 :             memcpy(r0, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
     197           4 :             memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
     198             : 
     199           4 :             randomize((INTFLOAT *)h, 2 * 4);
     200           4 :             randomize((INTFLOAT *)h_step, 2 * 4);
     201             : 
     202           4 :             call_ref(l0, r0, h, h_step, BUF_SIZE);
     203           4 :             call_new(l1, r1, h, h_step, BUF_SIZE);
     204           8 :             if (!float_near_abs_eps_array((float *)l0, (float *)l1, EPS, BUF_SIZE * 2) ||
     205           4 :                 !float_near_abs_eps_array((float *)r0, (float *)r1, EPS, BUF_SIZE * 2))
     206           0 :                 fail();
     207             : 
     208           4 :             memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
     209           4 :             memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
     210           4 :             bench_new(l1, r1, h, h_step, BUF_SIZE);
     211             :         }
     212             :     }
     213          13 : }
     214             : 
     215          13 : void checkasm_check_aacpsdsp(void)
     216             : {
     217             :     PSDSPContext psdsp;
     218             : 
     219          13 :     ff_psdsp_init(&psdsp);
     220             : 
     221          13 :     if (check_func(psdsp.add_squares, "ps_add_squares"))
     222           3 :         test_add_squares();
     223          13 :     report("add_squares");
     224             : 
     225          13 :     if (check_func(psdsp.mul_pair_single, "ps_mul_pair_single"))
     226           2 :         test_mul_pair_single();
     227          13 :     report("mul_pair_single");
     228             : 
     229          13 :     if (check_func(psdsp.hybrid_analysis, "ps_hybrid_analysis"))
     230           3 :         test_hybrid_analysis();
     231          13 :     report("hybrid_analysis");
     232             : 
     233          13 :     if (check_func(psdsp.hybrid_analysis_ileave, "ps_hybrid_analysis_ileave"))
     234           2 :         test_hybrid_analysis_ileave();
     235          13 :     report("hybrid_analysis_ileave");
     236             : 
     237          13 :     if (check_func(psdsp.hybrid_synthesis_deint, "ps_hybrid_synthesis_deint"))
     238           3 :         test_hybrid_synthesis_deint();
     239          13 :     report("hybrid_synthesis_deint");
     240             : 
     241          13 :     test_stereo_interpolate(&psdsp);
     242          13 :     report("stereo_interpolate");
     243          13 : }

Generated by: LCOV version 1.13