LCOV - code coverage report
Current view: top level - src/libavcodec/x86 - h264dsp_init.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 115 119 96.6 %
Date: 2017-01-22 02:20:28 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2004-2005 Michael Niedermayer, Loren Merritt
       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 "libavutil/attributes.h"
      22             : #include "libavutil/cpu.h"
      23             : #include "libavutil/x86/asm.h"
      24             : #include "libavutil/x86/cpu.h"
      25             : #include "libavcodec/h264dsp.h"
      26             : 
      27             : /***********************************/
      28             : /* IDCT */
      29             : #define IDCT_ADD_FUNC(NUM, DEPTH, OPT)                                  \
      30             : void ff_h264_idct ## NUM ## _add_ ## DEPTH ## _ ## OPT(uint8_t *dst,    \
      31             :                                                        int16_t *block,  \
      32             :                                                        int stride);
      33             : 
      34             : IDCT_ADD_FUNC(, 8, mmx)
      35             : IDCT_ADD_FUNC(, 10, sse2)
      36             : IDCT_ADD_FUNC(_dc, 8, mmxext)
      37             : IDCT_ADD_FUNC(_dc, 10, mmxext)
      38             : IDCT_ADD_FUNC(8_dc, 8, mmxext)
      39             : IDCT_ADD_FUNC(8_dc, 10, sse2)
      40             : IDCT_ADD_FUNC(8, 8, mmx)
      41             : IDCT_ADD_FUNC(8, 8, sse2)
      42             : IDCT_ADD_FUNC(8, 10, sse2)
      43             : IDCT_ADD_FUNC(, 10, avx)
      44             : IDCT_ADD_FUNC(8_dc, 10, avx)
      45             : IDCT_ADD_FUNC(8, 10, avx)
      46             : 
      47             : 
      48             : #define IDCT_ADD_REP_FUNC(NUM, REP, DEPTH, OPT)                         \
      49             : void ff_h264_idct ## NUM ## _add ## REP ## _ ## DEPTH ## _ ## OPT       \
      50             :     (uint8_t *dst, const int *block_offset,                             \
      51             :      int16_t *block, int stride, const uint8_t nnzc[6 * 8]);
      52             : 
      53             : IDCT_ADD_REP_FUNC(8, 4, 8, mmx)
      54             : IDCT_ADD_REP_FUNC(8, 4, 8, mmxext)
      55             : IDCT_ADD_REP_FUNC(8, 4, 8, sse2)
      56             : IDCT_ADD_REP_FUNC(8, 4, 10, sse2)
      57             : IDCT_ADD_REP_FUNC(8, 4, 10, avx)
      58             : IDCT_ADD_REP_FUNC(, 16, 8, mmx)
      59             : IDCT_ADD_REP_FUNC(, 16, 8, mmxext)
      60             : IDCT_ADD_REP_FUNC(, 16, 8, sse2)
      61             : IDCT_ADD_REP_FUNC(, 16, 10, sse2)
      62             : IDCT_ADD_REP_FUNC(, 16intra, 8, mmx)
      63             : IDCT_ADD_REP_FUNC(, 16intra, 8, mmxext)
      64             : IDCT_ADD_REP_FUNC(, 16intra, 8, sse2)
      65             : IDCT_ADD_REP_FUNC(, 16intra, 10, sse2)
      66             : IDCT_ADD_REP_FUNC(, 16, 10, avx)
      67             : IDCT_ADD_REP_FUNC(, 16intra, 10, avx)
      68             : 
      69             : 
      70             : #define IDCT_ADD_REP_FUNC2(NUM, REP, DEPTH, OPT)                      \
      71             : void ff_h264_idct ## NUM ## _add ## REP ## _ ## DEPTH ## _ ## OPT     \
      72             :     (uint8_t **dst, const int *block_offset,                          \
      73             :      int16_t *block, int stride, const uint8_t nnzc[6 * 8]);
      74             : 
      75             : IDCT_ADD_REP_FUNC2(, 8, 8, mmx)
      76             : IDCT_ADD_REP_FUNC2(, 8, 8, mmxext)
      77             : IDCT_ADD_REP_FUNC2(, 8, 8, sse2)
      78             : IDCT_ADD_REP_FUNC2(, 8, 10, sse2)
      79             : IDCT_ADD_REP_FUNC2(, 8, 10, avx)
      80             : 
      81             : IDCT_ADD_REP_FUNC2(, 8_422, 8, mmx)
      82             : 
      83             : IDCT_ADD_REP_FUNC2(, 8_422, 10, sse2)
      84             : IDCT_ADD_REP_FUNC2(, 8_422, 10, avx)
      85             : 
      86             : void ff_h264_luma_dc_dequant_idct_mmx(int16_t *output, int16_t *input, int qmul);
      87             : void ff_h264_luma_dc_dequant_idct_sse2(int16_t *output, int16_t *input, int qmul);
      88             : 
      89             : /***********************************/
      90             : /* deblocking */
      91             : 
      92             : void ff_h264_loop_filter_strength_mmxext(int16_t bS[2][4][4], uint8_t nnz[40],
      93             :                                          int8_t ref[2][40],
      94             :                                          int16_t mv[2][40][2],
      95             :                                          int bidir, int edges, int step,
      96             :                                          int mask_mv0, int mask_mv1, int field);
      97             : 
      98             : #define LF_FUNC(DIR, TYPE, DEPTH, OPT)                                        \
      99             : void ff_deblock_ ## DIR ## _ ## TYPE ## _ ## DEPTH ## _ ## OPT(uint8_t *pix,  \
     100             :                                                                int stride,    \
     101             :                                                                int alpha,     \
     102             :                                                                int beta,      \
     103             :                                                                int8_t *tc0);
     104             : #define LF_IFUNC(DIR, TYPE, DEPTH, OPT) \
     105             : void ff_deblock_ ## DIR ## _ ## TYPE ## _ ## DEPTH ## _ ## OPT(uint8_t *pix,  \
     106             :                                                                int stride,    \
     107             :                                                                int alpha,     \
     108             :                                                                int beta);
     109             : 
     110             : #define LF_FUNCS(type, depth)                   \
     111             : LF_FUNC(h,  chroma,          depth, mmxext)     \
     112             : LF_IFUNC(h, chroma_intra,    depth, mmxext)     \
     113             : LF_FUNC(h,  chroma422,       depth, mmxext)     \
     114             : LF_IFUNC(h, chroma422_intra, depth, mmxext)     \
     115             : LF_FUNC(v,  chroma,          depth, mmxext)     \
     116             : LF_IFUNC(v, chroma_intra,    depth, mmxext)     \
     117             : LF_FUNC(h,  luma,            depth, mmxext)     \
     118             : LF_IFUNC(h, luma_intra,      depth, mmxext)     \
     119             : LF_FUNC(h,  luma,            depth, sse2)       \
     120             : LF_IFUNC(h, luma_intra,      depth, sse2)       \
     121             : LF_FUNC(v,  luma,            depth, sse2)       \
     122             : LF_IFUNC(v, luma_intra,      depth, sse2)       \
     123             : LF_FUNC(h,  chroma,          depth, sse2)       \
     124             : LF_IFUNC(h, chroma_intra,    depth, sse2)       \
     125             : LF_FUNC(h,  chroma422,       depth, sse2)       \
     126             : LF_IFUNC(h, chroma422_intra, depth, sse2)       \
     127             : LF_FUNC(v,  chroma,          depth, sse2)       \
     128             : LF_IFUNC(v, chroma_intra,    depth, sse2)       \
     129             : LF_FUNC(h,  luma,            depth, avx)        \
     130             : LF_IFUNC(h, luma_intra,      depth, avx)        \
     131             : LF_FUNC(v,  luma,            depth, avx)        \
     132             : LF_IFUNC(v, luma_intra,      depth, avx)        \
     133             : LF_FUNC(h,  chroma,          depth, avx)        \
     134             : LF_IFUNC(h, chroma_intra,    depth, avx)        \
     135             : LF_FUNC(h,  chroma422,       depth, avx)        \
     136             : LF_IFUNC(h, chroma422_intra, depth, avx)        \
     137             : LF_FUNC(v,  chroma,          depth, avx)        \
     138             : LF_IFUNC(v, chroma_intra,    depth, avx)
     139             : 
     140             : LF_FUNCS(uint8_t,   8)
     141             : LF_FUNCS(uint16_t, 10)
     142             : 
     143             : #if ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL
     144             : LF_FUNC(v8, luma, 8, mmxext)
     145             : static void deblock_v_luma_8_mmxext(uint8_t *pix, int stride, int alpha,
     146             :                                     int beta, int8_t *tc0)
     147             : {
     148             :     if ((tc0[0] & tc0[1]) >= 0)
     149             :         ff_deblock_v8_luma_8_mmxext(pix + 0, stride, alpha, beta, tc0);
     150             :     if ((tc0[2] & tc0[3]) >= 0)
     151             :         ff_deblock_v8_luma_8_mmxext(pix + 8, stride, alpha, beta, tc0 + 2);
     152             : }
     153             : LF_IFUNC(v8, luma_intra, 8, mmxext)
     154             : static void deblock_v_luma_intra_8_mmxext(uint8_t *pix, int stride,
     155             :                                           int alpha, int beta)
     156             : {
     157             :     ff_deblock_v8_luma_intra_8_mmxext(pix + 0, stride, alpha, beta);
     158             :     ff_deblock_v8_luma_intra_8_mmxext(pix + 8, stride, alpha, beta);
     159             : }
     160             : #endif /* ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL */
     161             : 
     162             : LF_FUNC(v,  luma,       10, mmxext)
     163             : LF_IFUNC(v, luma_intra, 10, mmxext)
     164             : 
     165             : /***********************************/
     166             : /* weighted prediction */
     167             : 
     168             : #define H264_WEIGHT(W, OPT)                                             \
     169             : void ff_h264_weight_ ## W ## _ ## OPT(uint8_t *dst, ptrdiff_t stride,   \
     170             :                                       int height, int log2_denom,       \
     171             :                                       int weight, int offset);
     172             : 
     173             : #define H264_BIWEIGHT(W, OPT)                                           \
     174             : void ff_h264_biweight_ ## W ## _ ## OPT(uint8_t *dst, uint8_t *src,     \
     175             :                                         ptrdiff_t stride, int height,   \
     176             :                                         int log2_denom, int weightd,    \
     177             :                                         int weights, int offset);
     178             : 
     179             : #define H264_BIWEIGHT_MMX(W)                    \
     180             :     H264_WEIGHT(W, mmxext)                      \
     181             :     H264_BIWEIGHT(W, mmxext)
     182             : 
     183             : #define H264_BIWEIGHT_MMX_SSE(W)                \
     184             :     H264_BIWEIGHT_MMX(W)                        \
     185             :     H264_WEIGHT(W, sse2)                        \
     186             :     H264_BIWEIGHT(W, sse2)                      \
     187             :     H264_BIWEIGHT(W, ssse3)
     188             : 
     189             : H264_BIWEIGHT_MMX_SSE(16)
     190             : H264_BIWEIGHT_MMX_SSE(8)
     191             : H264_BIWEIGHT_MMX(4)
     192             : 
     193             : #define H264_WEIGHT_10(W, DEPTH, OPT)                                   \
     194             : void ff_h264_weight_ ## W ## _ ## DEPTH ## _ ## OPT(uint8_t *dst,       \
     195             :                                                     ptrdiff_t stride,   \
     196             :                                                     int height,         \
     197             :                                                     int log2_denom,     \
     198             :                                                     int weight,         \
     199             :                                                     int offset);
     200             : 
     201             : #define H264_BIWEIGHT_10(W, DEPTH, OPT)                                 \
     202             : void ff_h264_biweight_ ## W ## _ ## DEPTH ## _ ## OPT(uint8_t *dst,     \
     203             :                                                       uint8_t *src,     \
     204             :                                                       ptrdiff_t stride, \
     205             :                                                       int height,       \
     206             :                                                       int log2_denom,   \
     207             :                                                       int weightd,      \
     208             :                                                       int weights,      \
     209             :                                                       int offset);
     210             : 
     211             : #define H264_BIWEIGHT_10_SSE(W, DEPTH)          \
     212             :     H264_WEIGHT_10(W, DEPTH, sse2)              \
     213             :     H264_WEIGHT_10(W, DEPTH, sse4)              \
     214             :     H264_BIWEIGHT_10(W, DEPTH, sse2)            \
     215             :     H264_BIWEIGHT_10(W, DEPTH, sse4)
     216             : 
     217             : H264_BIWEIGHT_10_SSE(16, 10)
     218             : H264_BIWEIGHT_10_SSE(8,  10)
     219             : H264_BIWEIGHT_10_SSE(4,  10)
     220             : 
     221         783 : av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
     222             :                                  const int chroma_format_idc)
     223             : {
     224             : #if HAVE_YASM
     225         783 :     int cpu_flags = av_get_cpu_flags();
     226             : 
     227         783 :     if (EXTERNAL_MMXEXT(cpu_flags) && chroma_format_idc <= 1)
     228          53 :         c->h264_loop_filter_strength = ff_h264_loop_filter_strength_mmxext;
     229             : 
     230         783 :     if (bit_depth == 8) {
     231         719 :         if (EXTERNAL_MMX(cpu_flags)) {
     232          38 :             c->h264_idct_dc_add   =
     233          38 :             c->h264_idct_add      = ff_h264_idct_add_8_mmx;
     234          38 :             c->h264_idct8_dc_add  =
     235          38 :             c->h264_idct8_add     = ff_h264_idct8_add_8_mmx;
     236             : 
     237          38 :             c->h264_idct_add16 = ff_h264_idct_add16_8_mmx;
     238          38 :             c->h264_idct8_add4 = ff_h264_idct8_add4_8_mmx;
     239          38 :             if (chroma_format_idc <= 1) {
     240          36 :                 c->h264_idct_add8 = ff_h264_idct_add8_8_mmx;
     241             :             } else {
     242           2 :                 c->h264_idct_add8 = ff_h264_idct_add8_422_8_mmx;
     243             :             }
     244          38 :             c->h264_idct_add16intra = ff_h264_idct_add16intra_8_mmx;
     245          38 :             if (cpu_flags & AV_CPU_FLAG_CMOV)
     246          38 :                 c->h264_luma_dc_dequant_idct = ff_h264_luma_dc_dequant_idct_mmx;
     247             :         }
     248         719 :         if (EXTERNAL_MMXEXT(cpu_flags)) {
     249          37 :             c->h264_idct_dc_add  = ff_h264_idct_dc_add_8_mmxext;
     250          37 :             c->h264_idct8_dc_add = ff_h264_idct8_dc_add_8_mmxext;
     251          37 :             c->h264_idct_add16   = ff_h264_idct_add16_8_mmxext;
     252          37 :             c->h264_idct8_add4   = ff_h264_idct8_add4_8_mmxext;
     253          37 :             if (chroma_format_idc <= 1)
     254          35 :                 c->h264_idct_add8 = ff_h264_idct_add8_8_mmxext;
     255          37 :             c->h264_idct_add16intra = ff_h264_idct_add16intra_8_mmxext;
     256             : 
     257          37 :             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_8_mmxext;
     258          37 :             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_8_mmxext;
     259          37 :             if (chroma_format_idc <= 1) {
     260          35 :                 c->h264_h_loop_filter_chroma       = ff_deblock_h_chroma_8_mmxext;
     261          35 :                 c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma_intra_8_mmxext;
     262             :             } else {
     263           2 :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_8_mmxext;
     264           2 :                 c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma422_intra_8_mmxext;
     265             :             }
     266             : #if ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL
     267             :             c->h264_v_loop_filter_luma       = deblock_v_luma_8_mmxext;
     268             :             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_8_mmxext;
     269             :             c->h264_v_loop_filter_luma_intra = deblock_v_luma_intra_8_mmxext;
     270             :             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_mmxext;
     271             : #endif /* ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL */
     272          37 :             c->weight_h264_pixels_tab[0] = ff_h264_weight_16_mmxext;
     273          37 :             c->weight_h264_pixels_tab[1] = ff_h264_weight_8_mmxext;
     274          37 :             c->weight_h264_pixels_tab[2] = ff_h264_weight_4_mmxext;
     275             : 
     276          37 :             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_mmxext;
     277          37 :             c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_mmxext;
     278          37 :             c->biweight_h264_pixels_tab[2] = ff_h264_biweight_4_mmxext;
     279             :         }
     280         719 :         if (EXTERNAL_SSE2(cpu_flags)) {
     281          35 :             c->h264_idct8_add  = ff_h264_idct8_add_8_sse2;
     282             : 
     283          35 :             c->h264_idct_add16 = ff_h264_idct_add16_8_sse2;
     284          35 :             c->h264_idct8_add4 = ff_h264_idct8_add4_8_sse2;
     285          35 :             if (chroma_format_idc <= 1)
     286          33 :                 c->h264_idct_add8 = ff_h264_idct_add8_8_sse2;
     287          35 :             c->h264_idct_add16intra      = ff_h264_idct_add16intra_8_sse2;
     288          35 :             c->h264_luma_dc_dequant_idct = ff_h264_luma_dc_dequant_idct_sse2;
     289             : 
     290          35 :             c->weight_h264_pixels_tab[0] = ff_h264_weight_16_sse2;
     291          35 :             c->weight_h264_pixels_tab[1] = ff_h264_weight_8_sse2;
     292             : 
     293          35 :             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_sse2;
     294          35 :             c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_sse2;
     295             : 
     296          35 :             c->h264_v_loop_filter_luma       = ff_deblock_v_luma_8_sse2;
     297          35 :             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_8_sse2;
     298          35 :             c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_8_sse2;
     299          35 :             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_sse2;
     300             :         }
     301         719 :         if (EXTERNAL_SSSE3(cpu_flags)) {
     302          33 :             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_ssse3;
     303          33 :             c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_ssse3;
     304             :         }
     305         719 :         if (EXTERNAL_AVX(cpu_flags)) {
     306          29 :             c->h264_v_loop_filter_luma       = ff_deblock_v_luma_8_avx;
     307          29 :             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_8_avx;
     308          29 :             c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_8_avx;
     309          29 :             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_avx;
     310             :         }
     311          64 :     } else if (bit_depth == 10) {
     312          48 :         if (EXTERNAL_MMXEXT(cpu_flags)) {
     313             : #if ARCH_X86_32
     314             :             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_mmxext;
     315             :             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_mmxext;
     316             :             if (chroma_format_idc <= 1) {
     317             :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_mmxext;
     318             :             } else {
     319             :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_mmxext;
     320             :             }
     321             :             c->h264_v_loop_filter_luma         = ff_deblock_v_luma_10_mmxext;
     322             :             c->h264_h_loop_filter_luma         = ff_deblock_h_luma_10_mmxext;
     323             :             c->h264_v_loop_filter_luma_intra   = ff_deblock_v_luma_intra_10_mmxext;
     324             :             c->h264_h_loop_filter_luma_intra   = ff_deblock_h_luma_intra_10_mmxext;
     325             : #endif /* ARCH_X86_32 */
     326           9 :             c->h264_idct_dc_add = ff_h264_idct_dc_add_10_mmxext;
     327             :         }
     328          48 :         if (EXTERNAL_SSE2(cpu_flags)) {
     329           7 :             c->h264_idct_add     = ff_h264_idct_add_10_sse2;
     330           7 :             c->h264_idct8_dc_add = ff_h264_idct8_dc_add_10_sse2;
     331             : 
     332           7 :             c->h264_idct_add16 = ff_h264_idct_add16_10_sse2;
     333           7 :             if (chroma_format_idc <= 1) {
     334           7 :                 c->h264_idct_add8 = ff_h264_idct_add8_10_sse2;
     335             :             } else {
     336           0 :                 c->h264_idct_add8 = ff_h264_idct_add8_422_10_sse2;
     337             :             }
     338           7 :             c->h264_idct_add16intra = ff_h264_idct_add16intra_10_sse2;
     339             : #if HAVE_ALIGNED_STACK
     340           7 :             c->h264_idct8_add  = ff_h264_idct8_add_10_sse2;
     341           7 :             c->h264_idct8_add4 = ff_h264_idct8_add4_10_sse2;
     342             : #endif /* HAVE_ALIGNED_STACK */
     343             : 
     344           7 :             c->weight_h264_pixels_tab[0] = ff_h264_weight_16_10_sse2;
     345           7 :             c->weight_h264_pixels_tab[1] = ff_h264_weight_8_10_sse2;
     346           7 :             c->weight_h264_pixels_tab[2] = ff_h264_weight_4_10_sse2;
     347             : 
     348           7 :             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_10_sse2;
     349           7 :             c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_10_sse2;
     350           7 :             c->biweight_h264_pixels_tab[2] = ff_h264_biweight_4_10_sse2;
     351             : 
     352           7 :             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_sse2;
     353           7 :             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_sse2;
     354           7 :             if (chroma_format_idc <= 1) {
     355           7 :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_sse2;
     356             :             } else {
     357           0 :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_sse2;
     358             :             }
     359             : #if HAVE_ALIGNED_STACK
     360           7 :             c->h264_v_loop_filter_luma       = ff_deblock_v_luma_10_sse2;
     361           7 :             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_10_sse2;
     362           7 :             c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_10_sse2;
     363           7 :             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_10_sse2;
     364             : #endif /* HAVE_ALIGNED_STACK */
     365             :         }
     366          48 :         if (EXTERNAL_SSE4(cpu_flags)) {
     367           4 :             c->weight_h264_pixels_tab[0] = ff_h264_weight_16_10_sse4;
     368           4 :             c->weight_h264_pixels_tab[1] = ff_h264_weight_8_10_sse4;
     369           4 :             c->weight_h264_pixels_tab[2] = ff_h264_weight_4_10_sse4;
     370             : 
     371           4 :             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_10_sse4;
     372           4 :             c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_10_sse4;
     373           4 :             c->biweight_h264_pixels_tab[2] = ff_h264_biweight_4_10_sse4;
     374             :         }
     375          48 :         if (EXTERNAL_AVX(cpu_flags)) {
     376           1 :             c->h264_idct_dc_add  =
     377           1 :             c->h264_idct_add     = ff_h264_idct_add_10_avx;
     378           1 :             c->h264_idct8_dc_add = ff_h264_idct8_dc_add_10_avx;
     379             : 
     380           1 :             c->h264_idct_add16 = ff_h264_idct_add16_10_avx;
     381           1 :             if (chroma_format_idc <= 1) {
     382           1 :                 c->h264_idct_add8 = ff_h264_idct_add8_10_avx;
     383             :             } else {
     384           0 :                 c->h264_idct_add8 = ff_h264_idct_add8_422_10_avx;
     385             :             }
     386           1 :             c->h264_idct_add16intra = ff_h264_idct_add16intra_10_avx;
     387             : #if HAVE_ALIGNED_STACK
     388           1 :             c->h264_idct8_add  = ff_h264_idct8_add_10_avx;
     389           1 :             c->h264_idct8_add4 = ff_h264_idct8_add4_10_avx;
     390             : #endif /* HAVE_ALIGNED_STACK */
     391             : 
     392           1 :             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_avx;
     393           1 :             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_avx;
     394           1 :             if (chroma_format_idc <= 1) {
     395           1 :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_avx;
     396             :             } else {
     397           0 :                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_avx;
     398             :             }
     399             : #if HAVE_ALIGNED_STACK
     400           1 :             c->h264_v_loop_filter_luma         = ff_deblock_v_luma_10_avx;
     401           1 :             c->h264_h_loop_filter_luma         = ff_deblock_h_luma_10_avx;
     402           1 :             c->h264_v_loop_filter_luma_intra   = ff_deblock_v_luma_intra_10_avx;
     403           1 :             c->h264_h_loop_filter_luma_intra   = ff_deblock_h_luma_intra_10_avx;
     404             : #endif /* HAVE_ALIGNED_STACK */
     405             :         }
     406             :     }
     407             : #endif
     408         783 : }

Generated by: LCOV version 1.12