LCOV - code coverage report
Current view: top level - src/libavfilter/x86 - vf_gradfun_init.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 37 16.2 %
Date: 2017-01-22 02:20:28 Functions: 1 4 25.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2009 Loren Merritt <lorenm@u.washington.edu>
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include "config.h"
      22             : #include "libavutil/attributes.h"
      23             : #include "libavutil/cpu.h"
      24             : #include "libavutil/mem.h"
      25             : #include "libavutil/x86/cpu.h"
      26             : #include "libavfilter/gradfun.h"
      27             : 
      28             : void ff_gradfun_filter_line_mmxext(intptr_t x, uint8_t *dst, const uint8_t *src,
      29             :                                    const uint16_t *dc, int thresh,
      30             :                                    const uint16_t *dithers);
      31             : void ff_gradfun_filter_line_ssse3(intptr_t x, uint8_t *dst, const uint8_t *src,
      32             :                                   const uint16_t *dc, int thresh,
      33             :                                   const uint16_t *dithers);
      34             : 
      35             : void ff_gradfun_blur_line_movdqa_sse2(intptr_t x, uint16_t *buf,
      36             :                                       const uint16_t *buf1, uint16_t *dc,
      37             :                                       const uint8_t *src1, const uint8_t *src2);
      38             : void ff_gradfun_blur_line_movdqu_sse2(intptr_t x, uint16_t *buf,
      39             :                                       const uint16_t *buf1, uint16_t *dc,
      40             :                                       const uint8_t *src1, const uint8_t *src2);
      41             : 
      42             : #if HAVE_YASM
      43           0 : static void gradfun_filter_line_mmxext(uint8_t *dst, const uint8_t *src,
      44             :                                        const uint16_t *dc,
      45             :                                        int width, int thresh,
      46             :                                        const uint16_t *dithers)
      47             : {
      48             :     intptr_t x;
      49           0 :     if (width & 3) {
      50           0 :         x = width & ~3;
      51           0 :         ff_gradfun_filter_line_c(dst + x, src + x, dc + x / 2,
      52           0 :                                  width - x, thresh, dithers);
      53           0 :         width = x;
      54             :     }
      55           0 :     x = -width;
      56           0 :     ff_gradfun_filter_line_mmxext(x, dst + width, src + width, dc + width / 2,
      57             :                                   thresh, dithers);
      58           0 : }
      59             : 
      60           0 : static void gradfun_filter_line_ssse3(uint8_t *dst, const uint8_t *src, const uint16_t *dc,
      61             :                                       int width, int thresh,
      62             :                                       const uint16_t *dithers)
      63             : {
      64             :     intptr_t x;
      65           0 :     if (width & 7) {
      66             :         // could be 10% faster if I somehow eliminated this
      67           0 :         x = width & ~7;
      68           0 :         ff_gradfun_filter_line_c(dst + x, src + x, dc + x / 2,
      69           0 :                                  width - x, thresh, dithers);
      70           0 :         width = x;
      71             :     }
      72           0 :     x = -width;
      73           0 :     ff_gradfun_filter_line_ssse3(x, dst + width, src + width, dc + width / 2,
      74             :                                  thresh, dithers);
      75           0 : }
      76             : 
      77           0 : static void gradfun_blur_line_sse2(uint16_t *dc, uint16_t *buf, const uint16_t *buf1,
      78             :                                    const uint8_t *src, int src_linesize, int width)
      79             : {
      80           0 :     intptr_t x = -2 * width;
      81           0 :     if (((intptr_t) src | src_linesize) & 15)
      82           0 :         ff_gradfun_blur_line_movdqu_sse2(x, buf + width, buf1 + width,
      83           0 :                                          dc + width, src + width * 2,
      84           0 :                                          src + width * 2 + src_linesize);
      85             :     else
      86           0 :         ff_gradfun_blur_line_movdqa_sse2(x, buf + width, buf1 + width,
      87           0 :                                          dc + width, src + width * 2,
      88           0 :                                          src + width * 2 + src_linesize);
      89           0 : }
      90             : #endif /* HAVE_YASM */
      91             : 
      92           2 : av_cold void ff_gradfun_init_x86(GradFunContext *gf)
      93             : {
      94             : #if HAVE_YASM
      95           2 :     int cpu_flags = av_get_cpu_flags();
      96             : 
      97           2 :     if (EXTERNAL_MMXEXT(cpu_flags))
      98           0 :         gf->filter_line = gradfun_filter_line_mmxext;
      99           2 :     if (EXTERNAL_SSSE3(cpu_flags))
     100           0 :         gf->filter_line = gradfun_filter_line_ssse3;
     101             : 
     102           2 :     if (EXTERNAL_SSE2(cpu_flags))
     103           0 :         gf->blur_line = gradfun_blur_line_sse2;
     104             : #endif /* HAVE_YASM */
     105           2 : }

Generated by: LCOV version 1.12