0a063479039a753b3cbb6a0cd05614884f7134ef
[ffmpeg.git] / libavcodec / x86 / hevcdsp_init.c
1 /*
2  * Copyright (c) 2013 Seppo Tomperi
3  * Copyright (c) 2013 - 2014 Pierre-Edouard Lepere
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "config.h"
23
24 #include "libavutil/cpu.h"
25 #include "libavutil/x86/cpu.h"
26
27 #include "libavcodec/hevcdsp.h"
28
29 #define LFC_FUNC(DIR, DEPTH, OPT) \
30 void ff_hevc_ ## DIR ## _loop_filter_chroma_ ## DEPTH ## _ ## OPT(uint8_t *pix, ptrdiff_t stride, int *tc, uint8_t *no_p, uint8_t *no_q);
31
32 #define LFL_FUNC(DIR, DEPTH, OPT) \
33 void ff_hevc_ ## DIR ## _loop_filter_luma_ ## DEPTH ## _ ## OPT(uint8_t *pix, ptrdiff_t stride, int beta, int *tc, uint8_t *no_p, uint8_t *no_q);
34
35 #define LFC_FUNCS(type, depth) \
36     LFC_FUNC(h, depth, sse2)   \
37     LFC_FUNC(v, depth, sse2)
38
39 #define LFL_FUNCS(type, depth) \
40     LFL_FUNC(h, depth, ssse3)  \
41     LFL_FUNC(v, depth, ssse3)
42
43 LFC_FUNCS(uint8_t, 8)
44 LFC_FUNCS(uint8_t, 10)
45 LFL_FUNCS(uint8_t, 8)
46 LFL_FUNCS(uint8_t, 10)
47
48 #define idct_dc_proto(size, bitd, opt) \
49                 void ff_hevc_idct_ ## size ## _dc_add_ ## bitd ## _ ## opt(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
50
51 idct_dc_proto(4, 8,mmxext);
52 idct_dc_proto(8, 8,mmxext);
53 idct_dc_proto(16,8,  sse2);
54 idct_dc_proto(32,8,  sse2);
55
56 idct_dc_proto(32,8,  avx2);
57
58 idct_dc_proto(4, 10,mmxext);
59 idct_dc_proto(8, 10,  sse2);
60 idct_dc_proto(16,10,  sse2);
61 idct_dc_proto(32,10,  sse2);
62 idct_dc_proto(8, 10,   avx);
63 idct_dc_proto(16,10,   avx);
64 idct_dc_proto(32,10,   avx);
65
66 idct_dc_proto(16,10,  avx2);
67 idct_dc_proto(32,10,  avx2);
68
69 #define IDCT_DC_FUNCS(W, opt) \
70 void ff_hevc_idct_ ## W ## _dc_8_ ## opt(int16_t *coeffs); \
71 void ff_hevc_idct_ ## W ## _dc_10_ ## opt(int16_t *coeffs)
72
73 IDCT_DC_FUNCS(4x4,   mmxext);
74 IDCT_DC_FUNCS(8x8,   mmxext);
75 IDCT_DC_FUNCS(8x8,   sse2);
76 IDCT_DC_FUNCS(16x16, sse2);
77 IDCT_DC_FUNCS(32x32, sse2);
78 IDCT_DC_FUNCS(16x16, avx2);
79 IDCT_DC_FUNCS(32x32, avx2);
80
81 #define IDCT_FUNCS(opt)                                             \
82 void ff_hevc_idct_4x4_8_    ## opt(int16_t *coeffs, int col_limit); \
83 void ff_hevc_idct_4x4_10_   ## opt(int16_t *coeffs, int col_limit); \
84 void ff_hevc_idct_8x8_8_    ## opt(int16_t *coeffs, int col_limit); \
85 void ff_hevc_idct_8x8_10_   ## opt(int16_t *coeffs, int col_limit); \
86 void ff_hevc_idct_16x16_8_  ## opt(int16_t *coeffs, int col_limit); \
87 void ff_hevc_idct_16x16_10_ ## opt(int16_t *coeffs, int col_limit); \
88 void ff_hevc_idct_32x32_8_  ## opt(int16_t *coeffs, int col_limit); \
89 void ff_hevc_idct_32x32_10_ ## opt(int16_t *coeffs, int col_limit);
90
91 IDCT_FUNCS(sse2)
92 IDCT_FUNCS(avx)
93
94 #define GET_PIXELS(width, depth, cf)                                                                      \
95 void ff_hevc_get_pixels_ ## width ## _ ## depth ## _ ## cf(int16_t *dst, ptrdiff_t dststride,             \
96                                                            uint8_t *src, ptrdiff_t srcstride,             \
97                                                            int height, int mx, int my, int16_t *mcbuffer);
98
99 GET_PIXELS(4,  8, sse2)
100 GET_PIXELS(8,  8, sse2)
101 GET_PIXELS(12, 8, sse2)
102 GET_PIXELS(16, 8, sse2)
103 GET_PIXELS(24, 8, sse2)
104 GET_PIXELS(32, 8, sse2)
105 GET_PIXELS(48, 8, sse2)
106 GET_PIXELS(64, 8, sse2)
107
108 GET_PIXELS(4,  10, sse2)
109 GET_PIXELS(8,  10, sse2)
110 GET_PIXELS(12, 10, sse2)
111 GET_PIXELS(16, 10, sse2)
112 GET_PIXELS(24, 10, sse2)
113 GET_PIXELS(32, 10, sse2)
114 GET_PIXELS(48, 10, sse2)
115 GET_PIXELS(64, 10, sse2)
116
117 /* those are independent of the bit depth, so declared separately */
118 #define INTERP_HV_FUNC(width, cf)                                                         \
119 void ff_hevc_qpel_hv_ ## width ## _ ## cf(int16_t *dst, ptrdiff_t dststride,              \
120                                           int16_t *src, ptrdiff_t srcstride,              \
121                                           int height, int mx, int my, int16_t *mcbuffer); \
122 void ff_hevc_epel_hv_ ## width ## _ ## cf(int16_t *dst, ptrdiff_t dststride,              \
123                                           int16_t *src, ptrdiff_t srcstride,              \
124                                           int height, int mx, int my, int16_t *mcbuffer);
125
126 INTERP_HV_FUNC(4,  avx)
127 INTERP_HV_FUNC(8,  avx)
128 INTERP_HV_FUNC(12, avx)
129 INTERP_HV_FUNC(16, avx)
130 INTERP_HV_FUNC(24, avx)
131 INTERP_HV_FUNC(32, avx)
132 INTERP_HV_FUNC(48, avx)
133 INTERP_HV_FUNC(64, avx)
134
135 #if ARCH_X86_64 && HAVE_AVX_EXTERNAL
136 #define QPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)                                                         \
137 static void hevc_qpel_hv_ ## width ## _ ## depth ## _ ## cf_hv(int16_t *dst, ptrdiff_t dststride,             \
138                                                                uint8_t *src, ptrdiff_t srcstride,             \
139                                                                int height, int mx, int my, int16_t *mcbuffer) \
140 {                                                                                                             \
141     const ptrdiff_t stride = FFALIGN(width + 7, 8);                                                           \
142     ff_hevc_qpel_h_ ## width ## _ ## depth ## _ ## cf_h(mcbuffer, 2 * stride, src - 3 * srcstride, srcstride, \
143                                                         height + 7, mx, my, mcbuffer);                        \
144     ff_hevc_qpel_hv_ ## width ## _ ## cf_hv(dst, dststride, mcbuffer + 3 * stride, 2 * stride,                \
145                                             height, mx, my, mcbuffer);                                        \
146 }
147 #else
148 #define QPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)
149 #endif /* ARCH_X86_64 && HAVE_AVX_EXTERNAL */
150
151 #define QPEL_FUNCS(width, depth, cf_h, cf_v, cf_hv)                                                           \
152 void ff_hevc_qpel_h_ ## width ## _ ## depth ## _ ## cf_h(int16_t *dst, ptrdiff_t dststride,                   \
153                                                          uint8_t *src, ptrdiff_t srcstride,                   \
154                                                          int height, int mx, int my, int16_t *mcbuffer);      \
155 void ff_hevc_qpel_v_ ## width ## _ ## depth ## _ ## cf_v(int16_t *dst, ptrdiff_t dststride,                   \
156                                                          uint8_t *src, ptrdiff_t srcstride,                   \
157                                                          int height, int mx, int my, int16_t *mcbuffer);      \
158 QPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)
159
160 QPEL_FUNCS(4,  8, ssse3, ssse3, avx)
161 QPEL_FUNCS(8,  8, ssse3, ssse3, avx)
162 QPEL_FUNCS(12, 8, ssse3, ssse3, avx)
163 QPEL_FUNCS(16, 8, ssse3, ssse3, avx)
164 QPEL_FUNCS(24, 8, ssse3, ssse3, avx)
165 QPEL_FUNCS(32, 8, ssse3, ssse3, avx)
166 QPEL_FUNCS(48, 8, ssse3, ssse3, avx)
167 QPEL_FUNCS(64, 8, ssse3, ssse3, avx)
168
169 QPEL_FUNCS(4,  10, avx, avx, avx)
170 QPEL_FUNCS(8,  10, avx, avx, avx)
171 QPEL_FUNCS(12, 10, avx, avx, avx)
172 QPEL_FUNCS(16, 10, avx, avx, avx)
173 QPEL_FUNCS(24, 10, avx, avx, avx)
174 QPEL_FUNCS(32, 10, avx, avx, avx)
175 QPEL_FUNCS(48, 10, avx, avx, avx)
176 QPEL_FUNCS(64, 10, avx, avx, avx)
177
178 #if ARCH_X86_64 && HAVE_AVX_EXTERNAL
179 #define EPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)                                                         \
180 static void hevc_epel_hv_ ## width ## _ ## depth ## _ ## cf_hv(int16_t *dst, ptrdiff_t dststride,             \
181                                                                uint8_t *src, ptrdiff_t srcstride,             \
182                                                                int height, int mx, int my, int16_t *mcbuffer) \
183 {                                                                                                             \
184     const ptrdiff_t stride = FFALIGN(width + 3, 8);                                                           \
185     ff_hevc_epel_h_ ## width ## _ ## depth ## _ ## cf_h(mcbuffer, 2 * stride, src - srcstride, srcstride,     \
186                                                         height + 3, mx, my, mcbuffer);                        \
187     ff_hevc_epel_hv_ ## width ## _ ## cf_hv(dst, dststride, mcbuffer + stride, 2 * stride,                    \
188                                             height, mx, my, mcbuffer);                                        \
189 }
190 #else
191 #define EPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)
192 #endif /* ARCH_X86_64 && HAVE_AVX_EXTERNAL */
193
194 #define EPEL_FUNCS(width, depth, cf_h, cf_v, cf_hv)                                                           \
195 void ff_hevc_epel_h_ ## width ## _ ## depth ## _ ## cf_h(int16_t *dst, ptrdiff_t dststride,                   \
196                                                          uint8_t *src, ptrdiff_t srcstride,                   \
197                                                          int height, int mx, int my, int16_t *mcbuffer);      \
198 void ff_hevc_epel_v_ ## width ## _ ## depth ## _ ## cf_v(int16_t *dst, ptrdiff_t dststride,                   \
199                                                          uint8_t *src, ptrdiff_t srcstride,                   \
200                                                          int height, int mx, int my, int16_t *mcbuffer);      \
201 EPEL_FUNC_HV(width, depth, cf_h, cf_v, cf_hv)
202
203 EPEL_FUNCS(4,  8, ssse3, ssse3, avx)
204 EPEL_FUNCS(8,  8, ssse3, ssse3, avx)
205 EPEL_FUNCS(12, 8, ssse3, ssse3, avx)
206 EPEL_FUNCS(16, 8, ssse3, ssse3, avx)
207 EPEL_FUNCS(24, 8, ssse3, ssse3, avx)
208 EPEL_FUNCS(32, 8, ssse3, ssse3, avx)
209
210 EPEL_FUNCS(4,  10, avx, avx, avx)
211 EPEL_FUNCS(8,  10, avx, avx, avx)
212 EPEL_FUNCS(12, 10, avx, avx, avx)
213 EPEL_FUNCS(16, 10, avx, avx, avx)
214 EPEL_FUNCS(24, 10, avx, avx, avx)
215 EPEL_FUNCS(32, 10, avx, avx, avx)
216
217 #define PUT_PRED(width, depth, cf_uw, cf_w) \
218 void ff_hevc_put_unweighted_pred_ ## width ## _ ## depth ## _ ## cf_uw(uint8_t *dst, ptrdiff_t dststride,                   \
219                                                                        int16_t *src, ptrdiff_t srcstride,                   \
220                                                                        int height);                                         \
221 void ff_hevc_put_unweighted_pred_avg_ ## width ## _ ## depth ## _ ## cf_uw(uint8_t *dst, ptrdiff_t dststride,               \
222                                                                            int16_t *src1, int16_t *src2,                    \
223                                                                            ptrdiff_t srcstride, int height);                \
224 void ff_hevc_put_weighted_pred_ ## width ## _ ## depth ## _ ## cf_w(uint8_t denom, int16_t weight, int16_t offset,          \
225                                                                     uint8_t *dst, ptrdiff_t dststride,                      \
226                                                                     int16_t *src, ptrdiff_t srcstride,                      \
227                                                                     int height);                                            \
228 void ff_hevc_put_weighted_pred_avg_ ## width ## _ ## depth ## _ ## cf_w(uint8_t denom, int16_t weight0, int16_t weight1,    \
229                                                                         int16_t offset0, int16_t offset1,                   \
230                                                                         uint8_t *dst, ptrdiff_t dststride,                  \
231                                                                         int16_t *src0, int16_t *src1, ptrdiff_t srcstride,  \
232                                                                         int height);
233
234 PUT_PRED(4,  8, sse2, sse4)
235 PUT_PRED(8,  8, sse2, sse4)
236 PUT_PRED(12, 8, sse2, sse4)
237 PUT_PRED(16, 8, sse2, sse4)
238 PUT_PRED(24, 8, sse2, sse4)
239 PUT_PRED(32, 8, sse2, sse4)
240 PUT_PRED(48, 8, sse2, sse4)
241 PUT_PRED(64, 8, sse2, sse4)
242
243 PUT_PRED(4,  10, sse2, sse4)
244 PUT_PRED(8,  10, sse2, sse4)
245 PUT_PRED(12, 10, sse2, sse4)
246 PUT_PRED(16, 10, sse2, sse4)
247 PUT_PRED(24, 10, sse2, sse4)
248 PUT_PRED(32, 10, sse2, sse4)
249 PUT_PRED(48, 10, sse2, sse4)
250 PUT_PRED(64, 10, sse2, sse4)
251
252 void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
253 {
254     int cpu_flags = av_get_cpu_flags();
255
256 #define SET_LUMA_FUNCS(tabname, funcname, depth, cf)      \
257     c->tabname[0] = funcname ## _4_  ## depth ## _ ## cf; \
258     c->tabname[1] = funcname ## _8_  ## depth ## _ ## cf; \
259     c->tabname[2] = funcname ## _12_ ## depth ## _ ## cf; \
260     c->tabname[3] = funcname ## _16_ ## depth ## _ ## cf; \
261     c->tabname[4] = funcname ## _24_ ## depth ## _ ## cf; \
262     c->tabname[5] = funcname ## _32_ ## depth ## _ ## cf; \
263     c->tabname[6] = funcname ## _48_ ## depth ## _ ## cf; \
264     c->tabname[7] = funcname ## _64_ ## depth ## _ ## cf;
265
266 #define SET_CHROMA_FUNCS(tabname, funcname, depth, cf)    \
267     c->tabname[1] = funcname ## _4_  ## depth ## _ ## cf; \
268     c->tabname[3] = funcname ## _8_  ## depth ## _ ## cf; \
269     c->tabname[4] = funcname ## _12_ ## depth ## _ ## cf; \
270     c->tabname[5] = funcname ## _16_ ## depth ## _ ## cf; \
271     c->tabname[6] = funcname ## _24_ ## depth ## _ ## cf; \
272     c->tabname[7] = funcname ## _32_ ## depth ## _ ## cf;
273
274 #define SET_QPEL_FUNCS(v, h, depth, cf, name) SET_LUMA_FUNCS  (put_hevc_qpel[v][h], name, depth, cf)
275 #define SET_EPEL_FUNCS(v, h, depth, cf, name) SET_CHROMA_FUNCS(put_hevc_epel[v][h], name, depth, cf)
276
277     if (bit_depth == 8) {
278         if (EXTERNAL_MMXEXT(cpu_flags)) {
279             c->idct_dc[0] = ff_hevc_idct_4x4_dc_8_mmxext;
280             c->idct_dc[1] = ff_hevc_idct_8x8_dc_8_mmxext;
281         }
282         if (EXTERNAL_SSE2(cpu_flags)) {
283             c->hevc_v_loop_filter_chroma = ff_hevc_v_loop_filter_chroma_8_sse2;
284             c->hevc_h_loop_filter_chroma = ff_hevc_h_loop_filter_chroma_8_sse2;
285
286             c->idct_dc[1] = ff_hevc_idct_8x8_dc_8_sse2;
287             c->idct_dc[2] = ff_hevc_idct_16x16_dc_8_sse2;
288             c->idct_dc[3] = ff_hevc_idct_32x32_dc_8_sse2;
289
290             c->idct[0]    = ff_hevc_idct_4x4_8_sse2;
291             c->idct[1]    = ff_hevc_idct_8x8_8_sse2;
292             SET_QPEL_FUNCS(0, 0, 8, sse2, ff_hevc_get_pixels);
293             SET_EPEL_FUNCS(0, 0, 8, sse2, ff_hevc_get_pixels);
294
295             SET_LUMA_FUNCS(put_unweighted_pred,              ff_hevc_put_unweighted_pred,     8, sse2);
296             SET_LUMA_FUNCS(put_unweighted_pred_avg,          ff_hevc_put_unweighted_pred_avg, 8, sse2);
297             SET_CHROMA_FUNCS(put_unweighted_pred_chroma,     ff_hevc_put_unweighted_pred,     8, sse2);
298             SET_CHROMA_FUNCS(put_unweighted_pred_avg_chroma, ff_hevc_put_unweighted_pred_avg, 8, sse2);
299         }
300         if (EXTERNAL_SSSE3(cpu_flags)) {
301             SET_QPEL_FUNCS(0, 1, 8, ssse3, ff_hevc_qpel_h);
302             SET_QPEL_FUNCS(1, 0, 8, ssse3, ff_hevc_qpel_v);
303             SET_EPEL_FUNCS(0, 1, 8, ssse3, ff_hevc_epel_h);
304             SET_EPEL_FUNCS(1, 0, 8, ssse3, ff_hevc_epel_v);
305
306         }
307         if (EXTERNAL_AVX(cpu_flags)) {
308             c->idct[0] = ff_hevc_idct_4x4_8_avx;
309             c->idct[1] = ff_hevc_idct_8x8_8_avx;
310         }
311     } else if (bit_depth == 10) {
312         if (EXTERNAL_MMXEXT(cpu_flags)) {
313             c->idct_dc[0] = ff_hevc_idct_4x4_dc_10_mmxext;
314             c->idct_dc[1] = ff_hevc_idct_8x8_dc_10_mmxext;
315         }
316         if (EXTERNAL_SSE2(cpu_flags)) {
317             c->hevc_v_loop_filter_chroma = ff_hevc_v_loop_filter_chroma_10_sse2;
318             c->hevc_h_loop_filter_chroma = ff_hevc_h_loop_filter_chroma_10_sse2;
319
320             c->idct_dc[1] = ff_hevc_idct_8x8_dc_10_sse2;
321             c->idct_dc[2] = ff_hevc_idct_16x16_dc_10_sse2;
322             c->idct_dc[3] = ff_hevc_idct_32x32_dc_10_sse2;
323
324             c->idct[0]    = ff_hevc_idct_4x4_10_sse2;
325             c->idct[1]    = ff_hevc_idct_8x8_10_sse2;
326             SET_QPEL_FUNCS(0, 0, 10, sse2, ff_hevc_get_pixels);
327             SET_EPEL_FUNCS(0, 0, 10, sse2, ff_hevc_get_pixels);
328
329             SET_LUMA_FUNCS(put_unweighted_pred,              ff_hevc_put_unweighted_pred,     10, sse2);
330             SET_LUMA_FUNCS(put_unweighted_pred_avg,          ff_hevc_put_unweighted_pred_avg, 10, sse2);
331             SET_CHROMA_FUNCS(put_unweighted_pred_chroma,     ff_hevc_put_unweighted_pred,     10, sse2);
332             SET_CHROMA_FUNCS(put_unweighted_pred_avg_chroma, ff_hevc_put_unweighted_pred_avg, 10, sse2);
333         }
334         if (EXTERNAL_AVX(cpu_flags)) {
335             c->idct[0] = ff_hevc_idct_4x4_10_avx;
336             c->idct[1] = ff_hevc_idct_8x8_10_avx;
337         }
338     }
339
340 #if ARCH_X86_64
341     if (bit_depth == 8) {
342         if (EXTERNAL_SSE2(cpu_flags)) {
343             c->idct[2] = ff_hevc_idct_16x16_8_sse2;
344             c->idct[3] = ff_hevc_idct_32x32_8_sse2;
345         }
346         if (EXTERNAL_SSSE3(cpu_flags)) {
347             c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_8_ssse3;
348             c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_8_ssse3;
349         }
350
351         if (EXTERNAL_SSE4(cpu_flags)) {
352             SET_LUMA_FUNCS(weighted_pred,              ff_hevc_put_weighted_pred,     8, sse4);
353             SET_CHROMA_FUNCS(weighted_pred_chroma,     ff_hevc_put_weighted_pred,     8, sse4);
354             SET_LUMA_FUNCS(weighted_pred_avg,          ff_hevc_put_weighted_pred_avg, 8, sse4);
355             SET_CHROMA_FUNCS(weighted_pred_avg_chroma, ff_hevc_put_weighted_pred_avg, 8, sse4);
356         }
357
358         if (EXTERNAL_AVX(cpu_flags)) {
359 #if HAVE_AVX_EXTERNAL
360             SET_QPEL_FUNCS(1, 1, 8, avx, hevc_qpel_hv);
361             SET_EPEL_FUNCS(1, 1, 8, avx, hevc_epel_hv);
362 #endif /* HAVE_AVX_EXTERNAL */
363             c->idct[2] = ff_hevc_idct_16x16_8_avx;
364             c->idct[3] = ff_hevc_idct_32x32_8_avx;
365         }
366         if (EXTERNAL_AVX2(cpu_flags)) {
367             c->idct_dc[2] = ff_hevc_idct_16x16_dc_8_avx2;
368             c->idct_dc[3] = ff_hevc_idct_32x32_dc_8_avx2;
369         }
370     } else if (bit_depth == 10) {
371         if (EXTERNAL_SSE2(cpu_flags)) {
372             c->idct[2] = ff_hevc_idct_16x16_10_sse2;
373             c->idct[3] = ff_hevc_idct_32x32_10_sse2;
374         }
375         if (EXTERNAL_SSSE3(cpu_flags)) {
376             c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_10_ssse3;
377             c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_10_ssse3;
378         }
379         if (EXTERNAL_SSE4(cpu_flags)) {
380             SET_LUMA_FUNCS(weighted_pred,              ff_hevc_put_weighted_pred,     10, sse4);
381             SET_CHROMA_FUNCS(weighted_pred_chroma,     ff_hevc_put_weighted_pred,     10, sse4);
382             SET_LUMA_FUNCS(weighted_pred_avg,          ff_hevc_put_weighted_pred_avg, 10, sse4);
383             SET_CHROMA_FUNCS(weighted_pred_avg_chroma, ff_hevc_put_weighted_pred_avg, 10, sse4);
384         }
385         if (EXTERNAL_AVX(cpu_flags)) {
386 #if HAVE_AVX_EXTERNAL
387             SET_QPEL_FUNCS(0, 1, 10, avx, ff_hevc_qpel_h);
388             SET_QPEL_FUNCS(1, 0, 10, avx, ff_hevc_qpel_v);
389             SET_QPEL_FUNCS(1, 1, 10, avx, hevc_qpel_hv);
390             SET_EPEL_FUNCS(0, 1, 10, avx, ff_hevc_epel_h);
391             SET_EPEL_FUNCS(1, 0, 10, avx, ff_hevc_epel_v);
392             SET_EPEL_FUNCS(1, 1, 10, avx, hevc_epel_hv);
393 #endif /* HAVE_AVX_EXTERNAL */
394             c->idct[2] = ff_hevc_idct_16x16_10_avx;
395             c->idct[3] = ff_hevc_idct_32x32_10_avx;
396         }
397         if (EXTERNAL_AVX2(cpu_flags)) {
398             c->idct_dc[2] = ff_hevc_idct_16x16_dc_10_avx2;
399             c->idct_dc[3] = ff_hevc_idct_32x32_dc_10_avx2;
400         }
401     }
402 #endif /* ARCH_X86_64 */
403 }