LCOV - code coverage report
Current view: top level - libavcodec/x86 - rv40dsp_init.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 9 57 15.8 %
Date: 2017-10-18 21:45:51 Functions: 1 108 0.9 %

          Line data    Source code
       1             : /*
       2             :  * RV40 decoder motion compensation functions x86-optimised
       3             :  * Copyright (c) 2008 Konstantin Shishkov
       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             : /**
      23             :  * @file
      24             :  * RV40 decoder motion compensation functions x86-optimised
      25             :  * 2,0 and 0,2 have h264 equivalents.
      26             :  * 3,3 is bugged in the rv40 format and maps to _xy2 version
      27             :  */
      28             : 
      29             : #include "libavcodec/rv34dsp.h"
      30             : #include "libavutil/attributes.h"
      31             : #include "libavutil/mem.h"
      32             : #include "libavutil/x86/cpu.h"
      33             : #include "hpeldsp.h"
      34             : 
      35             : #define DEFINE_FN(op, size, insn) \
      36             : static void op##_rv40_qpel##size##_mc33_##insn(uint8_t *dst, const uint8_t *src, \
      37             :                                                ptrdiff_t stride) \
      38             : { \
      39             :     ff_##op##_pixels##size##_xy2_##insn(dst, src, stride, size); \
      40             : }
      41             : 
      42             : #if HAVE_X86ASM
      43             : void ff_put_rv40_chroma_mc8_mmx  (uint8_t *dst, uint8_t *src,
      44             :                                   ptrdiff_t stride, int h, int x, int y);
      45             : void ff_avg_rv40_chroma_mc8_mmxext(uint8_t *dst, uint8_t *src,
      46             :                                    ptrdiff_t stride, int h, int x, int y);
      47             : void ff_avg_rv40_chroma_mc8_3dnow(uint8_t *dst, uint8_t *src,
      48             :                                   ptrdiff_t stride, int h, int x, int y);
      49             : 
      50             : void ff_put_rv40_chroma_mc4_mmx  (uint8_t *dst, uint8_t *src,
      51             :                                   ptrdiff_t stride, int h, int x, int y);
      52             : void ff_avg_rv40_chroma_mc4_mmxext(uint8_t *dst, uint8_t *src,
      53             :                                    ptrdiff_t stride, int h, int x, int y);
      54             : void ff_avg_rv40_chroma_mc4_3dnow(uint8_t *dst, uint8_t *src,
      55             :                                   ptrdiff_t stride, int h, int x, int y);
      56             : 
      57             : #define DECLARE_WEIGHT(opt) \
      58             : void ff_rv40_weight_func_rnd_16_##opt(uint8_t *dst, uint8_t *src1, uint8_t *src2, \
      59             :                                       int w1, int w2, ptrdiff_t stride); \
      60             : void ff_rv40_weight_func_rnd_8_##opt (uint8_t *dst, uint8_t *src1, uint8_t *src2, \
      61             :                                       int w1, int w2, ptrdiff_t stride); \
      62             : void ff_rv40_weight_func_nornd_16_##opt(uint8_t *dst, uint8_t *src1, uint8_t *src2, \
      63             :                                         int w1, int w2, ptrdiff_t stride); \
      64             : void ff_rv40_weight_func_nornd_8_##opt (uint8_t *dst, uint8_t *src1, uint8_t *src2, \
      65             :                                         int w1, int w2, ptrdiff_t stride);
      66             : DECLARE_WEIGHT(mmxext)
      67             : DECLARE_WEIGHT(sse2)
      68             : DECLARE_WEIGHT(ssse3)
      69             : 
      70             : /** @{ */
      71             : /**
      72             :  * Define one qpel function.
      73             :  * LOOPSIZE must be already set to the number of pixels processed per
      74             :  * iteration in the inner loop of the called functions.
      75             :  * COFF(x) must be already defined so as to provide the offset into any
      76             :  * array of coeffs used by the called function for the qpel position x.
      77             :  */
      78             : #define QPEL_FUNC_DECL(OP, SIZE, PH, PV, OPT)                           \
      79             : static void OP ## rv40_qpel ##SIZE ##_mc ##PH ##PV ##OPT(uint8_t *dst,  \
      80             :                                                          const uint8_t *src, \
      81             :                                                          ptrdiff_t stride)  \
      82             : {                                                                       \
      83             :     int i;                                                              \
      84             :     if (PH && PV) {                                                     \
      85             :         LOCAL_ALIGNED(16, uint8_t, tmp, [SIZE * (SIZE + 5)]);           \
      86             :         uint8_t *tmpptr = tmp + SIZE * 2;                               \
      87             :         src -= stride * 2;                                              \
      88             :                                                                         \
      89             :         for (i = 0; i < SIZE; i += LOOPSIZE)                            \
      90             :             ff_put_rv40_qpel_h ##OPT(tmp + i, SIZE, src + i, stride,    \
      91             :                                      SIZE + 5, HCOFF(PH));              \
      92             :         for (i = 0; i < SIZE; i += LOOPSIZE)                            \
      93             :             ff_ ##OP ##rv40_qpel_v ##OPT(dst + i, stride, tmpptr + i,   \
      94             :                                          SIZE, SIZE, VCOFF(PV));        \
      95             :     } else if (PV) {                                                    \
      96             :         for (i = 0; i < SIZE; i += LOOPSIZE)                            \
      97             :             ff_ ##OP ##rv40_qpel_v ## OPT(dst + i, stride, src + i,     \
      98             :                                           stride, SIZE, VCOFF(PV));     \
      99             :     } else {                                                            \
     100             :         for (i = 0; i < SIZE; i += LOOPSIZE)                            \
     101             :             ff_ ##OP ##rv40_qpel_h ## OPT(dst + i, stride, src + i,     \
     102             :                                           stride, SIZE, HCOFF(PH));     \
     103             :     }                                                                   \
     104             : }
     105             : 
     106             : /** Declare functions for sizes 8 and 16 and given operations
     107             :  *  and qpel position. */
     108             : #define QPEL_FUNCS_DECL(OP, PH, PV, OPT) \
     109             :     QPEL_FUNC_DECL(OP,  8, PH, PV, OPT)  \
     110             :     QPEL_FUNC_DECL(OP, 16, PH, PV, OPT)
     111             : 
     112             : /** Declare all functions for all sizes and qpel positions */
     113             : #define QPEL_MC_DECL(OP, OPT)                                           \
     114             : void ff_ ##OP ##rv40_qpel_h ##OPT(uint8_t *dst, ptrdiff_t dstStride,    \
     115             :                                   const uint8_t *src,                   \
     116             :                                   ptrdiff_t srcStride,                  \
     117             :                                   int len, int m);                      \
     118             : void ff_ ##OP ##rv40_qpel_v ##OPT(uint8_t *dst, ptrdiff_t dstStride,    \
     119             :                                   const uint8_t *src,                   \
     120             :                                   ptrdiff_t srcStride,                  \
     121             :                                   int len, int m);                      \
     122             : QPEL_FUNCS_DECL(OP, 0, 1, OPT)                                          \
     123             : QPEL_FUNCS_DECL(OP, 0, 3, OPT)                                          \
     124             : QPEL_FUNCS_DECL(OP, 1, 0, OPT)                                          \
     125             : QPEL_FUNCS_DECL(OP, 1, 1, OPT)                                          \
     126             : QPEL_FUNCS_DECL(OP, 1, 2, OPT)                                          \
     127             : QPEL_FUNCS_DECL(OP, 1, 3, OPT)                                          \
     128             : QPEL_FUNCS_DECL(OP, 2, 1, OPT)                                          \
     129             : QPEL_FUNCS_DECL(OP, 2, 2, OPT)                                          \
     130             : QPEL_FUNCS_DECL(OP, 2, 3, OPT)                                          \
     131             : QPEL_FUNCS_DECL(OP, 3, 0, OPT)                                          \
     132             : QPEL_FUNCS_DECL(OP, 3, 1, OPT)                                          \
     133             : QPEL_FUNCS_DECL(OP, 3, 2, OPT)
     134             : /** @} */
     135             : 
     136             : #define LOOPSIZE  8
     137             : #define HCOFF(x)  (32 * ((x) - 1))
     138             : #define VCOFF(x)  (32 * ((x) - 1))
     139           0 : QPEL_MC_DECL(put_, _ssse3)
     140           0 : QPEL_MC_DECL(avg_, _ssse3)
     141             : 
     142             : #undef LOOPSIZE
     143             : #undef HCOFF
     144             : #undef VCOFF
     145             : #define LOOPSIZE  8
     146             : #define HCOFF(x)  (64 * ((x) - 1))
     147             : #define VCOFF(x)  (64 * ((x) - 1))
     148           0 : QPEL_MC_DECL(put_, _sse2)
     149           0 : QPEL_MC_DECL(avg_, _sse2)
     150             : 
     151             : #if ARCH_X86_32
     152             : #undef LOOPSIZE
     153             : #undef HCOFF
     154             : #undef VCOFF
     155             : #define LOOPSIZE  4
     156             : #define HCOFF(x)  (64 * ((x) - 1))
     157             : #define VCOFF(x)  (64 * ((x) - 1))
     158             : 
     159             : QPEL_MC_DECL(put_, _mmx)
     160             : 
     161             : #define ff_put_rv40_qpel_h_mmxext  ff_put_rv40_qpel_h_mmx
     162             : #define ff_put_rv40_qpel_v_mmxext  ff_put_rv40_qpel_v_mmx
     163             : QPEL_MC_DECL(avg_, _mmxext)
     164             : 
     165             : #define ff_put_rv40_qpel_h_3dnow  ff_put_rv40_qpel_h_mmx
     166             : #define ff_put_rv40_qpel_v_3dnow  ff_put_rv40_qpel_v_mmx
     167             : QPEL_MC_DECL(avg_, _3dnow)
     168             : #endif
     169             : 
     170             : /** @{ */
     171             : /** Set one function */
     172             : #define QPEL_FUNC_SET(OP, SIZE, PH, PV, OPT)                            \
     173             :     c-> OP ## pixels_tab[2 - SIZE / 8][4 * PV + PH] = OP ## rv40_qpel ##SIZE ## _mc ##PH ##PV ##OPT;
     174             : 
     175             : /** Set functions put and avg for sizes 8 and 16 and a given qpel position */
     176             : #define QPEL_FUNCS_SET(OP, PH, PV, OPT)         \
     177             :     QPEL_FUNC_SET(OP,  8, PH, PV, OPT)          \
     178             :     QPEL_FUNC_SET(OP, 16, PH, PV, OPT)
     179             : 
     180             : /** Set all functions for all sizes and qpel positions */
     181             : #define QPEL_MC_SET(OP, OPT)   \
     182             : QPEL_FUNCS_SET (OP, 0, 1, OPT) \
     183             : QPEL_FUNCS_SET (OP, 0, 3, OPT) \
     184             : QPEL_FUNCS_SET (OP, 1, 0, OPT) \
     185             : QPEL_FUNCS_SET (OP, 1, 1, OPT) \
     186             : QPEL_FUNCS_SET (OP, 1, 2, OPT) \
     187             : QPEL_FUNCS_SET (OP, 1, 3, OPT) \
     188             : QPEL_FUNCS_SET (OP, 2, 1, OPT) \
     189             : QPEL_FUNCS_SET (OP, 2, 2, OPT) \
     190             : QPEL_FUNCS_SET (OP, 2, 3, OPT) \
     191             : QPEL_FUNCS_SET (OP, 3, 0, OPT) \
     192             : QPEL_FUNCS_SET (OP, 3, 1, OPT) \
     193             : QPEL_FUNCS_SET (OP, 3, 2, OPT)
     194             : /** @} */
     195             : 
     196           0 : DEFINE_FN(put, 8, ssse3)
     197             : 
     198           0 : DEFINE_FN(put, 16, sse2)
     199           0 : DEFINE_FN(put, 16, ssse3)
     200             : 
     201           0 : DEFINE_FN(avg, 8, mmxext)
     202           0 : DEFINE_FN(avg, 8, ssse3)
     203             : 
     204           0 : DEFINE_FN(avg, 16, sse2)
     205           0 : DEFINE_FN(avg, 16, ssse3)
     206             : #endif /* HAVE_X86ASM */
     207             : 
     208             : #if HAVE_MMX_INLINE
     209           0 : DEFINE_FN(put, 8, mmx)
     210           0 : DEFINE_FN(avg, 8, mmx)
     211           0 : DEFINE_FN(put, 16, mmx)
     212           0 : DEFINE_FN(avg, 16, mmx)
     213             : #endif
     214             : 
     215           4 : av_cold void ff_rv40dsp_init_x86(RV34DSPContext *c)
     216             : {
     217           4 :     av_unused int cpu_flags = av_get_cpu_flags();
     218             : 
     219             : #if HAVE_MMX_INLINE
     220           4 :     if (INLINE_MMX(cpu_flags)) {
     221           0 :         c->put_pixels_tab[0][15] = put_rv40_qpel16_mc33_mmx;
     222           0 :         c->put_pixels_tab[1][15] = put_rv40_qpel8_mc33_mmx;
     223           0 :         c->avg_pixels_tab[0][15] = avg_rv40_qpel16_mc33_mmx;
     224           0 :         c->avg_pixels_tab[1][15] = avg_rv40_qpel8_mc33_mmx;
     225             :     }
     226             : #endif /* HAVE_MMX_INLINE */
     227             : 
     228             : #if HAVE_X86ASM
     229           4 :     if (EXTERNAL_MMX(cpu_flags)) {
     230           0 :         c->put_chroma_pixels_tab[0] = ff_put_rv40_chroma_mc8_mmx;
     231           0 :         c->put_chroma_pixels_tab[1] = ff_put_rv40_chroma_mc4_mmx;
     232             : #if ARCH_X86_32
     233             :         QPEL_MC_SET(put_, _mmx)
     234             : #endif
     235             :     }
     236           4 :     if (EXTERNAL_AMD3DNOW(cpu_flags)) {
     237           0 :         c->avg_chroma_pixels_tab[0] = ff_avg_rv40_chroma_mc8_3dnow;
     238           0 :         c->avg_chroma_pixels_tab[1] = ff_avg_rv40_chroma_mc4_3dnow;
     239             : #if ARCH_X86_32
     240             :         QPEL_MC_SET(avg_, _3dnow)
     241             : #endif
     242             :     }
     243           4 :     if (EXTERNAL_MMXEXT(cpu_flags)) {
     244           0 :         c->avg_pixels_tab[1][15]        = avg_rv40_qpel8_mc33_mmxext;
     245           0 :         c->avg_chroma_pixels_tab[0]     = ff_avg_rv40_chroma_mc8_mmxext;
     246           0 :         c->avg_chroma_pixels_tab[1]     = ff_avg_rv40_chroma_mc4_mmxext;
     247           0 :         c->rv40_weight_pixels_tab[0][0] = ff_rv40_weight_func_rnd_16_mmxext;
     248           0 :         c->rv40_weight_pixels_tab[0][1] = ff_rv40_weight_func_rnd_8_mmxext;
     249           0 :         c->rv40_weight_pixels_tab[1][0] = ff_rv40_weight_func_nornd_16_mmxext;
     250           0 :         c->rv40_weight_pixels_tab[1][1] = ff_rv40_weight_func_nornd_8_mmxext;
     251             : #if ARCH_X86_32
     252             :         QPEL_MC_SET(avg_, _mmxext)
     253             : #endif
     254             :     }
     255           4 :     if (EXTERNAL_SSE2(cpu_flags)) {
     256           0 :         c->put_pixels_tab[0][15]        = put_rv40_qpel16_mc33_sse2;
     257           0 :         c->avg_pixels_tab[0][15]        = avg_rv40_qpel16_mc33_sse2;
     258           0 :         c->rv40_weight_pixels_tab[0][0] = ff_rv40_weight_func_rnd_16_sse2;
     259           0 :         c->rv40_weight_pixels_tab[0][1] = ff_rv40_weight_func_rnd_8_sse2;
     260           0 :         c->rv40_weight_pixels_tab[1][0] = ff_rv40_weight_func_nornd_16_sse2;
     261           0 :         c->rv40_weight_pixels_tab[1][1] = ff_rv40_weight_func_nornd_8_sse2;
     262           0 :         QPEL_MC_SET(put_, _sse2)
     263           0 :         QPEL_MC_SET(avg_, _sse2)
     264             :     }
     265           4 :     if (EXTERNAL_SSSE3(cpu_flags)) {
     266           0 :         c->put_pixels_tab[0][15]        = put_rv40_qpel16_mc33_ssse3;
     267           0 :         c->put_pixels_tab[1][15]        = put_rv40_qpel8_mc33_ssse3;
     268           0 :         c->avg_pixels_tab[0][15]        = avg_rv40_qpel16_mc33_ssse3;
     269           0 :         c->avg_pixels_tab[1][15]        = avg_rv40_qpel8_mc33_ssse3;
     270           0 :         c->rv40_weight_pixels_tab[0][0] = ff_rv40_weight_func_rnd_16_ssse3;
     271           0 :         c->rv40_weight_pixels_tab[0][1] = ff_rv40_weight_func_rnd_8_ssse3;
     272           0 :         c->rv40_weight_pixels_tab[1][0] = ff_rv40_weight_func_nornd_16_ssse3;
     273           0 :         c->rv40_weight_pixels_tab[1][1] = ff_rv40_weight_func_nornd_8_ssse3;
     274           0 :         QPEL_MC_SET(put_, _ssse3)
     275           0 :         QPEL_MC_SET(avg_, _ssse3)
     276             :     }
     277             : #endif /* HAVE_X86ASM */
     278           4 : }

Generated by: LCOV version 1.13