avcodec/mips: MSA (MIPS-SIMD-Arch) optimizations for hpel functions
[ffmpeg.git] / libavcodec / mips / hpeldsp_msa.c
1 /*
2  * Copyright (c) 2015 Parag Salasakar (Parag.Salasakar@imgtec.com)
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/mips/generic_macros_msa.h"
22 #include "libavcodec/mips/hpeldsp_mips.h"
23
24 #define PCKEV_AVG_ST_UB(in0, in1, dst, pdst)                  \
25 {                                                             \
26     v16u8 tmp_m;                                              \
27                                                               \
28     tmp_m = (v16u8) __msa_pckev_b((v16i8) in0, (v16i8) in1);  \
29     tmp_m = __msa_aver_u_b(tmp_m, (v16u8) dst);               \
30     ST_UB(tmp_m, (pdst));                                     \
31 }
32
33 #define PCKEV_ST_SB4(in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride)  \
34 {                                                                           \
35     v16i8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                                   \
36     uint8_t *pdst_m = (uint8_t *) (pdst);                                   \
37                                                                             \
38     PCKEV_B4_SB(in0, in1, in2, in3, in4, in5, in6, in7,                     \
39                 tmp0_m, tmp1_m, tmp2_m, tmp3_m);                            \
40     ST_SB4(tmp0_m, tmp1_m, tmp2_m, tmp3_m, pdst_m, stride);                 \
41 }
42
43 #define PCKEV_AVG_ST8x4_UB(in1, dst0, in2, dst1, in3, dst2, in4, dst3,  \
44                            pdst, stride)                                \
45 {                                                                       \
46     v16u8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                               \
47     uint8_t *pdst_m = (uint8_t *) (pdst);                               \
48                                                                         \
49     PCKEV_B2_UB(in2, in1, in4, in3, tmp0_m, tmp1_m);                    \
50     PCKEV_D2_UB(dst1, dst0, dst3, dst2, tmp2_m, tmp3_m);                \
51     AVER_UB2_UB(tmp0_m, tmp2_m, tmp1_m, tmp3_m, tmp0_m, tmp1_m);        \
52     ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                           \
53 }
54
55 static void common_hz_bil_4w_msa(const uint8_t *src, int32_t src_stride,
56                                  uint8_t *dst, int32_t dst_stride,
57                                  uint8_t height)
58 {
59     uint8_t loop_cnt;
60     uint32_t out0, out1;
61     v16u8 src0, src1, src0_sld1, src1_sld1, res0, res1;
62
63     for (loop_cnt = (height >> 1); loop_cnt--;) {
64         LD_UB2(src, src_stride, src0, src1);
65         src += (2 * src_stride);
66
67         SLDI_B2_0_UB(src0, src1, src0_sld1, src1_sld1, 1);
68         AVER_UB2_UB(src0_sld1, src0, src1_sld1, src1, res0, res1);
69
70         out0 = __msa_copy_u_w((v4i32) res0, 0);
71         out1 = __msa_copy_u_w((v4i32) res1, 0);
72         SW(out0, dst);
73         dst += dst_stride;
74         SW(out1, dst);
75         dst += dst_stride;
76     }
77 }
78
79 static void common_hz_bil_8w_msa(const uint8_t *src, int32_t src_stride,
80                                  uint8_t *dst, int32_t dst_stride,
81                                  uint8_t height)
82 {
83     uint8_t loop_cnt;
84     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;
85
86     for (loop_cnt = (height >> 2); loop_cnt--;) {
87         LD_SB4(src, src_stride, src0, src1, src2, src3);
88         src += (4 * src_stride);
89
90         SLDI_B4_0_SB(src0, src1, src2, src3,
91                      src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);
92         AVER_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,
93                       src2, src2_sld1, src3, src3_sld1, dst, dst_stride);
94         dst += (4 * dst_stride);
95     }
96 }
97
98 static void common_hz_bil_16w_msa(const uint8_t *src, int32_t src_stride,
99                                   uint8_t *dst, int32_t dst_stride,
100                                   uint8_t height)
101 {
102     uint8_t loop_cnt;
103     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
104     v16u8 src8, src9, src10, src11, src12, src13, src14, src15;
105
106     for (loop_cnt = (height >> 3); loop_cnt--;) {
107         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
108         LD_UB8((src + 1), src_stride,
109                src8, src9, src10, src11, src12, src13, src14, src15);
110         src += (8 * src_stride);
111
112         AVER_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,
113                        dst, dst_stride);
114         dst += (4 * dst_stride);
115
116         AVER_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,
117                        dst, dst_stride);
118         dst += (4 * dst_stride);
119     }
120 }
121
122 static void common_hz_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,
123                                          uint8_t *dst, int32_t dst_stride)
124 {
125     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
126     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1;
127     v16i8 src4_sld1, src5_sld1, src6_sld1, src7_sld1;
128
129     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
130     src += (8 * src_stride);
131
132     SLDI_B4_0_SB(src0, src1, src2, src3,
133                  src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);
134     SLDI_B4_0_SB(src4, src5, src6, src7,
135                  src4_sld1, src5_sld1, src6_sld1, src7_sld1, 1);
136
137     AVE_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,
138                  src2, src2_sld1, src3, src3_sld1, dst, dst_stride);
139     dst += (4 * dst_stride);
140     AVE_ST8x4_UB(src4, src4_sld1, src5, src5_sld1,
141                  src6, src6_sld1, src7, src7_sld1, dst, dst_stride);
142 }
143
144 static void common_hz_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,
145                                          uint8_t *dst, int32_t dst_stride)
146 {
147     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;
148
149     LD_SB4(src, src_stride, src0, src1, src2, src3);
150     SLDI_B4_0_SB(src0, src1, src2, src3,
151                  src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);
152     AVE_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,
153                  src2, src2_sld1, src3, src3_sld1, dst, dst_stride);
154 }
155
156 static void common_hz_bil_no_rnd_16x16_msa(const uint8_t *src,
157                                            int32_t src_stride,
158                                            uint8_t *dst, int32_t dst_stride)
159 {
160     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
161     v16u8 src9, src10, src11, src12, src13, src14, src15;
162
163     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
164     LD_UB8((src + 1), src_stride,
165            src8, src9, src10, src11, src12, src13, src14, src15);
166     src += (8 * src_stride);
167
168     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,
169                   dst, dst_stride);
170     dst += (4 * dst_stride);
171
172     LD_UB4(src, src_stride, src0, src1, src2, src3);
173     LD_UB4((src + 1), src_stride, src8, src9, src10, src11);
174     src += (4 * src_stride);
175
176     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,
177                   dst, dst_stride);
178     dst += (4 * dst_stride);
179
180     LD_UB4(src, src_stride, src4, src5, src6, src7);
181     LD_UB4((src + 1), src_stride, src12, src13, src14, src15);
182     src += (4 * src_stride);
183
184     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,
185                   dst, dst_stride);
186     dst += (4 * dst_stride);
187     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,
188                   dst, dst_stride);
189 }
190
191 static void common_hz_bil_no_rnd_8x16_msa(const uint8_t *src,
192                                           int32_t src_stride,
193                                           uint8_t *dst, int32_t dst_stride)
194 {
195     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
196     v16u8 src9, src10, src11, src12, src13, src14, src15;
197
198     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
199     LD_UB8((src + 1), src_stride,
200            src8, src9, src10, src11, src12, src13, src14, src15);
201
202     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,
203                   dst, dst_stride);
204     dst += (4 * dst_stride);
205     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,
206                   dst, dst_stride);
207 }
208
209 static void common_hz_bil_and_aver_dst_4w_msa(const uint8_t *src,
210                                               int32_t src_stride,
211                                               uint8_t *dst, int32_t dst_stride,
212                                               uint8_t height)
213 {
214     uint8_t loop_cnt;
215     uint32_t dst0, dst1, out0, out1;
216     v16u8 src0, src1, src0_sld1, src1_sld1, res0, res1;
217     v16u8 tmp0 = { 0 };
218     v16u8 tmp1 = { 0 };
219
220     for (loop_cnt = (height >> 1); loop_cnt--;) {
221         LD_UB2(src, src_stride, src0, src1);
222         src += (2 * src_stride);
223
224         SLDI_B2_0_UB(src0, src1, src0_sld1, src1_sld1, 1);
225
226         dst0 = LW(dst);
227         dst1 = LW(dst + dst_stride);
228         tmp0 = (v16u8) __msa_insert_w((v4i32) tmp0, 0, dst0);
229         tmp1 = (v16u8) __msa_insert_w((v4i32) tmp1, 0, dst1);
230
231         AVER_UB2_UB(src0_sld1, src0, src1_sld1, src1, res0, res1);
232         AVER_UB2_UB(res0, tmp0, res1, tmp1, res0, res1);
233
234         out0 = __msa_copy_u_w((v4i32) res0, 0);
235         out1 = __msa_copy_u_w((v4i32) res1, 0);
236         SW(out0, dst);
237         dst += dst_stride;
238         SW(out1, dst);
239         dst += dst_stride;
240     }
241 }
242
243 static void common_hz_bil_and_aver_dst_8w_msa(const uint8_t *src,
244                                               int32_t src_stride,
245                                               uint8_t *dst, int32_t dst_stride,
246                                               uint8_t height)
247 {
248     uint8_t loop_cnt;
249     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;
250
251     for (loop_cnt = (height >> 2); loop_cnt--;) {
252         LD_SB4(src, src_stride, src0, src1, src2, src3);
253         src += (4 * src_stride);
254
255         SLDI_B4_0_SB(src0, src1, src2, src3,
256                      src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);
257
258         AVER_DST_ST8x4_UB(src0, src0_sld1, src1, src1_sld1, src2, src2_sld1,
259                           src3, src3_sld1, dst, dst_stride);
260         dst += (4 * dst_stride);
261     }
262 }
263
264 static void common_hz_bil_and_aver_dst_16w_msa(const uint8_t *src,
265                                                int32_t src_stride,
266                                                uint8_t *dst, int32_t dst_stride,
267                                                uint8_t height)
268 {
269     uint8_t loop_cnt;
270     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
271     v16u8 src9, src10, src11, src12, src13, src14, src15;
272
273     for (loop_cnt = (height >> 3); loop_cnt--;) {
274         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
275         LD_UB8((src + 1), src_stride,
276                src8, src9, src10, src11, src12, src13, src14, src15);
277         src += (8 * src_stride);
278
279         AVER_DST_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,
280                            dst, dst_stride);
281         dst += (4 * dst_stride);
282         AVER_DST_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,
283                            dst, dst_stride);
284         dst += (4 * dst_stride);
285     }
286 }
287
288 static void common_vt_bil_4w_msa(const uint8_t *src, int32_t src_stride,
289                                  uint8_t *dst, int32_t dst_stride,
290                                  uint8_t height)
291 {
292     uint8_t loop_cnt;
293     uint32_t out0, out1;
294     v16u8 src0, src1, src2, res0, res1;
295
296     src0 = LD_UB(src);
297     src += src_stride;
298
299     for (loop_cnt = (height >> 1); loop_cnt--;) {
300         LD_UB2(src, src_stride, src1, src2);
301         src += (2 * src_stride);
302
303         AVER_UB2_UB(src0, src1, src1, src2, res0, res1);
304
305         out0 = __msa_copy_u_w((v4i32) res0, 0);
306         out1 = __msa_copy_u_w((v4i32) res1, 0);
307         SW(out0, dst);
308         dst += dst_stride;
309         SW(out1, dst);
310         dst += dst_stride;
311
312         src0 = src2;
313     }
314 }
315
316 static void common_vt_bil_8w_msa(const uint8_t *src, int32_t src_stride,
317                                  uint8_t *dst, int32_t dst_stride,
318                                  uint8_t height)
319 {
320     uint8_t loop_cnt;
321     v16u8 src0, src1, src2, src3, src4;
322
323     src0 = LD_UB(src);
324     src += src_stride;
325
326     for (loop_cnt = (height >> 2); loop_cnt--;) {
327         LD_UB4(src, src_stride, src1, src2, src3, src4);
328         src += (4 * src_stride);
329
330         AVER_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
331                       dst, dst_stride);
332         dst += (4 * dst_stride);
333
334         src0 = src4;
335     }
336 }
337
338 static void common_vt_bil_16w_msa(const uint8_t *src, int32_t src_stride,
339                                   uint8_t *dst, int32_t dst_stride,
340                                   uint8_t height)
341 {
342     uint8_t loop_cnt;
343     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
344
345     src0 = LD_UB(src);
346     src += src_stride;
347
348     for (loop_cnt = (height >> 3); loop_cnt--;) {
349         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);
350         src += (8 * src_stride);
351
352         AVER_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
353                        dst, dst_stride);
354         dst += (4 * dst_stride);
355         AVER_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,
356                        dst, dst_stride);
357         dst += (4 * dst_stride);
358
359         src0 = src8;
360     }
361 }
362
363 static void common_vt_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,
364                                          uint8_t *dst, int32_t dst_stride)
365 {
366     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
367
368     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
369     src += (8 * src_stride);
370     src8 = LD_UB(src);
371
372     AVE_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
373                  dst, dst_stride);
374     dst += (4 * dst_stride);
375
376     AVE_ST8x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,
377                  dst, dst_stride);
378 }
379
380 static void common_vt_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,
381                                          uint8_t *dst, int32_t dst_stride)
382 {
383     v16u8 src0, src1, src2, src3, src4;
384
385     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
386     AVE_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
387                  dst, dst_stride);
388 }
389
390 static void common_vt_bil_no_rnd_16x16_msa(const uint8_t *src,
391                                            int32_t src_stride,
392                                            uint8_t *dst, int32_t dst_stride)
393 {
394     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
395     v16u8 src9, src10, src11, src12, src13, src14, src15, src16;
396
397     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
398     src += (8 * src_stride);
399     LD_UB8(src, src_stride,
400            src8, src9, src10, src11, src12, src13, src14, src15);
401     src += (8 * src_stride);
402     src16 = LD_UB(src);
403
404     AVE_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
405                   dst, dst_stride);
406     dst += (4 * dst_stride);
407     AVE_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,
408                   dst, dst_stride);
409     dst += (4 * dst_stride);
410     AVE_ST16x4_UB(src8, src9, src9, src10, src10, src11, src11, src12,
411                   dst, dst_stride);
412     dst += (4 * dst_stride);
413     AVE_ST16x4_UB(src12, src13, src13, src14,
414                   src14, src15, src15, src16, dst, dst_stride);
415 }
416
417 static void common_vt_bil_no_rnd_8x16_msa(const uint8_t *src,
418                                           int32_t src_stride,
419                                           uint8_t *dst, int32_t dst_stride)
420 {
421     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
422
423     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
424     src += (8 * src_stride);
425     src8 = LD_UB(src);
426
427     AVE_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
428                   dst, dst_stride);
429     dst += (4 * dst_stride);
430     AVE_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,
431                   dst, dst_stride);
432 }
433
434 static void common_vt_bil_and_aver_dst_4w_msa(const uint8_t *src,
435                                               int32_t src_stride,
436                                               uint8_t *dst, int32_t dst_stride,
437                                               uint8_t height)
438 {
439     uint8_t loop_cnt;
440     uint32_t out0, out1, dst0, dst1;
441     v16u8 src0, src1, src2;
442     v16u8 tmp0 = { 0 };
443     v16u8 tmp1 = { 0 };
444     v16u8 res0, res1;
445
446     src0 = LD_UB(src);
447     src += src_stride;
448
449     for (loop_cnt = (height >> 1); loop_cnt--;) {
450         LD_UB2(src, src_stride, src1, src2);
451         src += (2 * src_stride);
452         dst0 = LW(dst);
453         dst1 = LW(dst + dst_stride);
454         tmp0 = (v16u8) __msa_insert_w((v4i32) tmp0, 0, dst0);
455         tmp1 = (v16u8) __msa_insert_w((v4i32) tmp1, 0, dst1);
456         AVER_UB2_UB(src0, src1, src1, src2, res0, res1);
457         AVER_UB2_UB(res0, tmp0, res1, tmp1, res0, res1);
458         out0 = __msa_copy_u_w((v4i32) res0, 0);
459         out1 = __msa_copy_u_w((v4i32) res1, 0);
460         SW(out0, dst);
461         dst += dst_stride;
462         SW(out1, dst);
463         dst += dst_stride;
464         src0 = src2;
465     }
466 }
467
468 static void common_vt_bil_and_aver_dst_8w_msa(const uint8_t *src,
469                                               int32_t src_stride,
470                                               uint8_t *dst, int32_t dst_stride,
471                                               uint8_t height)
472 {
473     uint8_t loop_cnt;
474     v16u8 src0, src1, src2, src3, src4;
475
476     src0 = LD_UB(src);
477     src += src_stride;
478
479     for (loop_cnt = (height >> 2); loop_cnt--;) {
480         LD_UB4(src, src_stride, src1, src2, src3, src4);
481         src += (4 * src_stride);
482
483         AVER_DST_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
484                           dst, dst_stride);
485         dst += (4 * dst_stride);
486         src0 = src4;
487     }
488 }
489
490 static void common_vt_bil_and_aver_dst_16w_msa(const uint8_t *src,
491                                                int32_t src_stride,
492                                                uint8_t *dst, int32_t dst_stride,
493                                                uint8_t height)
494 {
495     uint8_t loop_cnt;
496     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
497     v16u8 res0, res1, res2, res3, res4, res5, res6, res7;
498     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
499
500     src0 = LD_UB(src);
501     src += src_stride;
502
503     for (loop_cnt = (height >> 3); loop_cnt--;) {
504         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);
505         src += (8 * src_stride);
506         AVER_UB4_UB(src0, src1, src1, src2, src2, src3, src3, src4,
507                     res0, res1, res2, res3);
508         AVER_UB4_UB(src4, src5, src5, src6, src6, src7, src7, src8,
509                     res4, res5, res6, res7);
510
511         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
512         AVER_UB4_UB(dst0, res0, dst1, res1, dst2, res2, dst3, res3,
513                     res0, res1, res2, res3);
514         AVER_UB4_UB(dst4, res4, dst5, res5, dst6, res6, dst7, res7,
515                     res4, res5, res6, res7);
516         ST_UB8(res0, res1, res2, res3, res4, res5, res6, res7, dst, dst_stride);
517         dst += (8 * dst_stride);
518
519         src0 = src8;
520     }
521 }
522
523 static void common_hv_bil_4w_msa(const uint8_t *src, int32_t src_stride,
524                                  uint8_t *dst, int32_t dst_stride,
525                                  uint8_t height)
526 {
527     uint8_t loop_cnt;
528     uint32_t res0, res1;
529     v16i8 src0, src1, src2, src0_sld1, src1_sld1, src2_sld1;
530     v16u8 src0_r, src1_r, src2_r, res;
531     v8u16 add0, add1, add2, sum0, sum1;
532
533     src0 = LD_SB(src);
534     src += src_stride;
535
536     for (loop_cnt = (height >> 1); loop_cnt--;) {
537         LD_SB2(src, src_stride, src1, src2);
538         src += (2 * src_stride);
539
540         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);
541         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2,
542                    src0_r, src1_r, src2_r);
543         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
544         ADD2(add0, add1, add1, add2, sum0, sum1);
545         SRARI_H2_UH(sum0, sum1, 2);
546         res = (v16u8) __msa_pckev_b((v16i8) sum1, (v16i8) sum0);
547         res0 = __msa_copy_u_w((v4i32) res, 0);
548         res1 = __msa_copy_u_w((v4i32) res, 2);
549         SW(res0, dst);
550         dst += dst_stride;
551         SW(res1, dst);
552         dst += dst_stride;
553
554         src0 = src2;
555     }
556 }
557
558 static void common_hv_bil_8w_msa(const uint8_t *src, int32_t src_stride,
559                                  uint8_t *dst, int32_t dst_stride,
560                                  uint8_t height)
561 {
562     uint8_t loop_cnt;
563     v16i8 src0, src1, src2, src3, src4;
564     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;
565     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r;
566     v8u16 add0, add1, add2, add3, add4;
567     v8u16 sum0, sum1, sum2, sum3;
568
569     src0 = LD_SB(src);
570     src += src_stride;
571
572     for (loop_cnt = (height >> 2); loop_cnt--;) {
573         LD_SB4(src, src_stride, src1, src2, src3, src4);
574         src += (4 * src_stride);
575
576         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);
577         SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);
578         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,
579                    src1_r, src2_r);
580         ILVR_B2_UB(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);
581         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
582         HADD_UB2_UH(src3_r, src4_r, add3, add4);
583         ADD4(add0, add1, add1, add2, add2, add3, add3, add4,
584              sum0, sum1, sum2, sum3);
585         SRARI_H4_UH(sum0, sum1, sum2, sum3, 2);
586         PCKEV_B2_SB(sum1, sum0, sum3, sum2, src0, src1);
587         ST8x4_UB(src0, src1, dst, dst_stride);
588         dst += (4 * dst_stride);
589         src0 = src4;
590     }
591 }
592
593 static void common_hv_bil_16w_msa(const uint8_t *src, int32_t src_stride,
594                                   uint8_t *dst, int32_t dst_stride,
595                                   uint8_t height)
596 {
597     uint8_t loop_cnt;
598     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
599     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;
600     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
601     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;
602     v8u16 src7_l, src8_l;
603     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;
604     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;
605
606     for (loop_cnt = (height >> 3); loop_cnt--;) {
607         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
608         LD_UB8((src + 1), src_stride,
609                src9, src10, src11, src12, src13, src14, src15, src16);
610         src += (8 * src_stride);
611
612         src8 = LD_UB(src);
613         src17 = LD_UB(src + 1);
614
615         ILVRL_B2_UH(src9, src0, src0_r, src0_l);
616         ILVRL_B2_UH(src10, src1, src1_r, src1_l);
617         ILVRL_B2_UH(src11, src2, src2_r, src2_l);
618         ILVRL_B2_UH(src12, src3, src3_r, src3_l);
619         ILVRL_B2_UH(src13, src4, src4_r, src4_l);
620         ILVRL_B2_UH(src14, src5, src5_r, src5_l);
621         ILVRL_B2_UH(src15, src6, src6_r, src6_l);
622         ILVRL_B2_UH(src16, src7, src7_r, src7_l);
623         ILVRL_B2_UH(src17, src8, src8_r, src8_l);
624         HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);
625         HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);
626         HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);
627         HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);
628         HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);
629         HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);
630         ADD4(src0_r, src1_r, src1_r, src2_r, src2_r, src3_r, src3_r, src4_r,
631              sum0_r, sum1_r, sum2_r, sum3_r);
632         ADD4(src4_r, src5_r, src5_r, src6_r, src6_r, src7_r, src7_r, src8_r,
633              sum4_r, sum5_r, sum6_r, sum7_r);
634         ADD4(src0_l, src1_l, src1_l, src2_l, src2_l, src3_l, src3_l, src4_l,
635              sum0_l, sum1_l, sum2_l, sum3_l);
636         ADD4(src4_l, src5_l, src5_l, src6_l, src6_l, src7_l, src7_l, src8_l,
637              sum4_l, sum5_l, sum6_l, sum7_l);
638         SRARI_H4_UH(sum0_r, sum1_r, sum2_r, sum3_r, 2);
639         SRARI_H4_UH(sum4_r, sum5_r, sum6_r, sum7_r, 2);
640         SRARI_H4_UH(sum0_l, sum1_l, sum2_l, sum3_l, 2);
641         SRARI_H4_UH(sum4_l, sum5_l, sum6_l, sum7_l, 2);
642         PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r, sum2_l, sum2_r,
643                      sum3_l, sum3_r, dst, dst_stride);
644         dst += (4 * dst_stride);
645         PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r, sum6_l, sum6_r,
646                      sum7_l, sum7_r, dst, dst_stride);
647         dst += (4 * dst_stride);
648     }
649 }
650
651 static void common_hv_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,
652                                          uint8_t *dst, int32_t dst_stride)
653 {
654     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
655     v16u8 src0_sld1, src1_sld1, src2_sld1, src3_sld1;
656     v16u8 src4_sld1, src5_sld1, src6_sld1, src7_sld1, src8_sld1;
657     v8u16 src0_r, src1_r, src2_r, src3_r;
658     v8u16 src4_r, src5_r, src6_r, src7_r, src8_r;
659     v8u16 add0, add1, add2, add3, add4, add5, add6, add7, add8;
660     v8u16 sum0, sum1, sum2, sum3, sum4, sum5, sum6, sum7;
661     v16i8 out0, out1;
662
663     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
664     src += (8 * src_stride);
665     src8 = LD_UB(src);
666
667     SLDI_B4_0_UB(src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1,
668                  src3_sld1, 1);
669     SLDI_B3_0_UB(src4, src5, src6, src4_sld1, src5_sld1, src6_sld1, 1);
670     SLDI_B2_0_UB(src7, src8, src7_sld1, src8_sld1, 1);
671     ILVR_B4_UH(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src3_sld1,
672                src3, src0_r, src1_r, src2_r, src3_r);
673     ILVR_B3_UH(src4_sld1, src4, src5_sld1, src5, src6_sld1, src6, src4_r,
674                src5_r, src6_r);
675     ILVR_B2_UH(src7_sld1, src7, src8_sld1, src8, src7_r, src8_r);
676     HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
677     HADD_UB3_UH(src3_r, src4_r, src5_r, add3, add4, add5);
678     HADD_UB3_UH(src6_r, src7_r, src8_r, add6, add7, add8);
679
680     sum0 = add0 + add1 + 1;
681     sum1 = add1 + add2 + 1;
682     sum2 = add2 + add3 + 1;
683     sum3 = add3 + add4 + 1;
684     sum4 = add4 + add5 + 1;
685     sum5 = add5 + add6 + 1;
686     sum6 = add6 + add7 + 1;
687     sum7 = add7 + add8 + 1;
688
689     SRA_4V(sum0, sum1, sum2, sum3, 2);
690     SRA_4V(sum4, sum5, sum6, sum7, 2);
691     PCKEV_B2_SB(sum1, sum0, sum3, sum2, out0, out1);
692     ST8x4_UB(out0, out1, dst, dst_stride);
693     PCKEV_B2_SB(sum5, sum4, sum7, sum6, out0, out1);
694     ST8x4_UB(out0, out1, dst + 4 * dst_stride, dst_stride);
695 }
696
697 static void common_hv_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,
698                                          uint8_t *dst, int32_t dst_stride)
699 {
700     v16i8 src0, src1, src2, src3, src4;
701     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;
702     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r;
703     v8u16 add0, add1, add2, add3, add4;
704     v8u16 sum0, sum1, sum2, sum3;
705     v16i8 out0, out1;
706
707     LD_SB4(src, src_stride, src0, src1, src2, src3);
708     src += (4 * src_stride);
709     src4 = LD_SB(src);
710
711     SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);
712     SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);
713     ILVR_B3_UH(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,
714                src1_r, src2_r);
715     ILVR_B2_UH(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);
716     HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
717     HADD_UB2_UH(src3_r, src4_r, add3, add4);
718
719     sum0 = add0 + add1 + 1;
720     sum1 = add1 + add2 + 1;
721     sum2 = add2 + add3 + 1;
722     sum3 = add3 + add4 + 1;
723
724     SRA_4V(sum0, sum1, sum2, sum3, 2);
725     PCKEV_B2_SB(sum1, sum0, sum3, sum2, out0, out1);
726     ST8x4_UB(out0, out1, dst, dst_stride);
727 }
728
729 static void common_hv_bil_no_rnd_16x16_msa(const uint8_t *src,
730                                            int32_t src_stride,
731                                            uint8_t *dst, int32_t dst_stride)
732 {
733     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
734     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;
735     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
736     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;
737     v8u16 src7_l, src8_l;
738     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;
739     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;
740
741     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
742     LD_UB8((src + 1), src_stride,
743            src9, src10, src11, src12, src13, src14, src15, src16);
744     src += (8 * src_stride);
745     src8 = LD_UB(src);
746     src17 = LD_UB(src + 1);
747
748     ILVRL_B2_UH(src9, src0, src0_r, src0_l);
749     ILVRL_B2_UH(src10, src1, src1_r, src1_l);
750     ILVRL_B2_UH(src11, src2, src2_r, src2_l);
751     ILVRL_B2_UH(src12, src3, src3_r, src3_l);
752     ILVRL_B2_UH(src13, src4, src4_r, src4_l);
753     ILVRL_B2_UH(src14, src5, src5_r, src5_l);
754     ILVRL_B2_UH(src15, src6, src6_r, src6_l);
755     ILVRL_B2_UH(src16, src7, src7_r, src7_l);
756     ILVRL_B2_UH(src17, src8, src8_r, src8_l);
757
758     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);
759     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);
760     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);
761     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);
762     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);
763     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);
764
765     sum0_r = src0_r + src1_r + 1;
766     sum1_r = src1_r + src2_r + 1;
767     sum2_r = src2_r + src3_r + 1;
768     sum3_r = src3_r + src4_r + 1;
769     sum4_r = src4_r + src5_r + 1;
770     sum5_r = src5_r + src6_r + 1;
771     sum6_r = src6_r + src7_r + 1;
772     sum7_r = src7_r + src8_r + 1;
773     sum0_l = src0_l + src1_l + 1;
774     sum1_l = src1_l + src2_l + 1;
775     sum2_l = src2_l + src3_l + 1;
776     sum3_l = src3_l + src4_l + 1;
777     sum4_l = src4_l + src5_l + 1;
778     sum5_l = src5_l + src6_l + 1;
779     sum6_l = src6_l + src7_l + 1;
780     sum7_l = src7_l + src8_l + 1;
781
782     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);
783     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);
784     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);
785     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);
786     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,
787                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);
788     dst += (4 * dst_stride);
789
790     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
791     LD_UB8((src + 1), src_stride,
792            src9, src10, src11, src12, src13, src14, src15, src16);
793     src += (8 * src_stride);
794     src8 = LD_UB(src);
795     src17 = LD_UB(src + 1);
796
797     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,
798                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);
799     dst += (4 * dst_stride);
800
801     ILVRL_B2_UH(src9, src0, src0_r, src0_l);
802     ILVRL_B2_UH(src10, src1, src1_r, src1_l);
803     ILVRL_B2_UH(src11, src2, src2_r, src2_l);
804     ILVRL_B2_UH(src12, src3, src3_r, src3_l);
805     ILVRL_B2_UH(src13, src4, src4_r, src4_l);
806     ILVRL_B2_UH(src14, src5, src5_r, src5_l);
807     ILVRL_B2_UH(src15, src6, src6_r, src6_l);
808     ILVRL_B2_UH(src16, src7, src7_r, src7_l);
809     ILVRL_B2_UH(src17, src8, src8_r, src8_l);
810
811     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);
812     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);
813     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);
814     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);
815     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);
816     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);
817
818     sum0_r = src0_r + src1_r + 1;
819     sum1_r = src1_r + src2_r + 1;
820     sum2_r = src2_r + src3_r + 1;
821     sum3_r = src3_r + src4_r + 1;
822     sum4_r = src4_r + src5_r + 1;
823     sum5_r = src5_r + src6_r + 1;
824     sum6_r = src6_r + src7_r + 1;
825     sum7_r = src7_r + src8_r + 1;
826     sum0_l = src0_l + src1_l + 1;
827     sum1_l = src1_l + src2_l + 1;
828     sum2_l = src2_l + src3_l + 1;
829     sum3_l = src3_l + src4_l + 1;
830     sum4_l = src4_l + src5_l + 1;
831     sum5_l = src5_l + src6_l + 1;
832     sum6_l = src6_l + src7_l + 1;
833     sum7_l = src7_l + src8_l + 1;
834
835     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);
836     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);
837     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);
838     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);
839     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,
840                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);
841     dst += (4 * dst_stride);
842     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,
843                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);
844 }
845
846 static void common_hv_bil_no_rnd_8x16_msa(const uint8_t *src,
847                                           int32_t src_stride,
848                                           uint8_t *dst, int32_t dst_stride)
849 {
850     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
851     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;
852     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
853     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;
854     v8u16 src7_l, src8_l;
855     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;
856     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;
857
858     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
859     LD_UB8((src + 1), src_stride,
860            src9, src10, src11, src12, src13, src14, src15, src16);
861     src += (8 * src_stride);
862     src8 = LD_UB(src);
863     src17 = LD_UB(src + 1);
864
865     ILVRL_B2_UH(src9, src0, src0_r, src0_l);
866     ILVRL_B2_UH(src10, src1, src1_r, src1_l);
867     ILVRL_B2_UH(src11, src2, src2_r, src2_l);
868     ILVRL_B2_UH(src12, src3, src3_r, src3_l);
869     ILVRL_B2_UH(src13, src4, src4_r, src4_l);
870     ILVRL_B2_UH(src14, src5, src5_r, src5_l);
871     ILVRL_B2_UH(src15, src6, src6_r, src6_l);
872     ILVRL_B2_UH(src16, src7, src7_r, src7_l);
873     ILVRL_B2_UH(src17, src8, src8_r, src8_l);
874
875     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);
876     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);
877     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);
878     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);
879     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);
880     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);
881
882     sum0_r = src0_r + src1_r + 1;
883     sum1_r = src1_r + src2_r + 1;
884     sum2_r = src2_r + src3_r + 1;
885     sum3_r = src3_r + src4_r + 1;
886     sum4_r = src4_r + src5_r + 1;
887     sum5_r = src5_r + src6_r + 1;
888     sum6_r = src6_r + src7_r + 1;
889     sum7_r = src7_r + src8_r + 1;
890     sum0_l = src0_l + src1_l + 1;
891     sum1_l = src1_l + src2_l + 1;
892     sum2_l = src2_l + src3_l + 1;
893     sum3_l = src3_l + src4_l + 1;
894     sum4_l = src4_l + src5_l + 1;
895     sum5_l = src5_l + src6_l + 1;
896     sum6_l = src6_l + src7_l + 1;
897     sum7_l = src7_l + src8_l + 1;
898
899     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);
900     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);
901     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);
902     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);
903     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,
904                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);
905     dst += (4 * dst_stride);
906     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,
907                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);
908 }
909
910 static void common_hv_bil_and_aver_dst_4w_msa(const uint8_t *src,
911                                               int32_t src_stride,
912                                               uint8_t *dst, int32_t dst_stride,
913                                               uint8_t height)
914 {
915     uint8_t loop_cnt;
916     uint32_t out0, out1;
917     v16i8 src0, src1, src2, src0_sld1, src1_sld1, src2_sld1;
918     v16u8 src0_r, src1_r, src2_r;
919     v8u16 add0, add1, add2, sum0, sum1;
920     v16u8 dst0, dst1, res0, res1;
921
922     src0 = LD_SB(src);
923     src += src_stride;
924
925     for (loop_cnt = (height >> 1); loop_cnt--;) {
926         LD_SB2(src, src_stride, src1, src2);
927         src += (2 * src_stride);
928
929         LD_UB2(dst, dst_stride, dst0, dst1);
930         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);
931         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,
932                    src1_r, src2_r);
933         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
934         ADD2(add0, add1, add1, add2, sum0, sum1);
935         SRARI_H2_UH(sum0, sum1, 2);
936         PCKEV_B2_UB(sum0, sum0, sum1, sum1, res0, res1);
937         AVER_UB2_UB(dst0, res0, dst1, res1, res0, res1);
938
939         out0 = __msa_copy_u_w((v4i32) res0, 0);
940         out1 = __msa_copy_u_w((v4i32) res1, 0);
941         SW(out0, dst);
942         dst += dst_stride;
943         SW(out1, dst);
944         dst += dst_stride;
945
946         src0 = src2;
947     }
948 }
949
950 static void common_hv_bil_and_aver_dst_8w_msa(const uint8_t *src,
951                                               int32_t src_stride,
952                                               uint8_t *dst, int32_t dst_stride,
953                                               uint8_t height)
954 {
955     uint8_t loop_cnt;
956     v16i8 src0, src1, src2, src3, src4;
957     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;
958     v16u8 dst0, dst1, dst2, dst3;
959     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r;
960     v8u16 add0, add1, add2, add3, add4;
961     v8u16 sum0, sum1, sum2, sum3;
962
963     src0 = LD_SB(src);
964     src += src_stride;
965
966     for (loop_cnt = (height >> 2); loop_cnt--;) {
967         LD_SB4(src, src_stride, src1, src2, src3, src4);
968         src += (4 * src_stride);
969
970         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
971         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);
972         SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);
973         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,
974                    src1_r, src2_r);
975         ILVR_B2_UB(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);
976         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
977         HADD_UB2_UH(src3_r, src4_r, add3, add4);
978         ADD4(add0, add1, add1, add2, add2, add3, add3, add4,
979              sum0, sum1, sum2, sum3);
980         SRARI_H4_UH(sum0, sum1, sum2, sum3, 2);
981         PCKEV_AVG_ST8x4_UB(sum0, dst0, sum1, dst1,
982                            sum2, dst2, sum3, dst3, dst, dst_stride);
983         dst += (4 * dst_stride);
984         src0 = src4;
985     }
986 }
987
988 static void common_hv_bil_and_aver_dst_16w_msa(const uint8_t *src,
989                                                int32_t src_stride,
990                                                uint8_t *dst, int32_t dst_stride,
991                                                uint8_t height)
992 {
993     uint8_t loop_cnt;
994     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
995     v16u8 src11, src12, src13, src14, src15, src16, src17;
996     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
997     v16u8 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;
998     v16u8 src7_l, src8_l;
999     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1000     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;
1001     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;
1002     v8u16 add0, add1, add2, add3, add4, add5, add6, add7, add8;
1003
1004     for (loop_cnt = (height >> 3); loop_cnt--;) {
1005         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
1006         LD_UB8((src + 1), src_stride,
1007                src9, src10, src11, src12, src13, src14, src15, src16);
1008         src += (8 * src_stride);
1009
1010         src8 = LD_UB(src);
1011         src17 = LD_UB(src + 1);
1012
1013         ILVRL_B2_UB(src9, src0, src0_r, src0_l);
1014         ILVRL_B2_UB(src10, src1, src1_r, src1_l);
1015         ILVRL_B2_UB(src11, src2, src2_r, src2_l);
1016         ILVRL_B2_UB(src12, src3, src3_r, src3_l);
1017         ILVRL_B2_UB(src13, src4, src4_r, src4_l);
1018         ILVRL_B2_UB(src14, src5, src5_r, src5_l);
1019         ILVRL_B2_UB(src15, src6, src6_r, src6_l);
1020         ILVRL_B2_UB(src16, src7, src7_r, src7_l);
1021         ILVRL_B2_UB(src17, src8, src8_r, src8_l);
1022         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);
1023         HADD_UB3_UH(src3_r, src4_r, src5_r, add3, add4, add5);
1024         HADD_UB3_UH(src6_r, src7_r, src8_r, add6, add7, add8);
1025         ADD4(add0, add1, add1, add2, add2, add3, add3, add4, sum0_r, sum1_r,
1026              sum2_r, sum3_r);
1027         ADD4(add4, add5, add5, add6, add6, add7, add7, add8, sum4_r, sum5_r,
1028              sum6_r, sum7_r);
1029         HADD_UB3_UH(src0_l, src1_l, src2_l, add0, add1, add2);
1030         HADD_UB3_UH(src3_l, src4_l, src5_l, add3, add4, add5);
1031         HADD_UB3_UH(src6_l, src7_l, src8_l, add6, add7, add8);
1032         ADD4(add0, add1, add1, add2, add2, add3, add3, add4, sum0_l, sum1_l,
1033              sum2_l, sum3_l);
1034         ADD4(add4, add5, add5, add6, add6, add7, add7, add8, sum4_l, sum5_l,
1035              sum6_l, sum7_l);
1036         SRARI_H4_UH(sum0_r, sum1_r, sum2_r, sum3_r, 2);
1037         SRARI_H4_UH(sum4_r, sum5_r, sum6_r, sum7_r, 2);
1038         SRARI_H4_UH(sum0_l, sum1_l, sum2_l, sum3_l, 2);
1039         SRARI_H4_UH(sum4_l, sum5_l, sum6_l, sum7_l, 2);
1040         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
1041         PCKEV_AVG_ST_UB(sum0_l, sum0_r, dst0, dst);
1042         dst += dst_stride;
1043         PCKEV_AVG_ST_UB(sum1_l, sum1_r, dst1, dst);
1044         dst += dst_stride;
1045         PCKEV_AVG_ST_UB(sum2_l, sum2_r, dst2, dst);
1046         dst += dst_stride;
1047         PCKEV_AVG_ST_UB(sum3_l, sum3_r, dst3, dst);
1048         dst += dst_stride;
1049         PCKEV_AVG_ST_UB(sum4_l, sum4_r, dst4, dst);
1050         dst += dst_stride;
1051         PCKEV_AVG_ST_UB(sum5_l, sum5_r, dst5, dst);
1052         dst += dst_stride;
1053         PCKEV_AVG_ST_UB(sum6_l, sum6_r, dst6, dst);
1054         dst += dst_stride;
1055         PCKEV_AVG_ST_UB(sum7_l, sum7_r, dst7, dst);
1056         dst += dst_stride;
1057     }
1058 }
1059
1060 static void copy_width8_msa(const uint8_t *src, int32_t src_stride,
1061                             uint8_t *dst, int32_t dst_stride,
1062                             int32_t height)
1063 {
1064     int32_t cnt;
1065     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
1066     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1067
1068     if (0 == height % 12) {
1069         for (cnt = (height / 12); cnt--;) {
1070             LD_UB8(src, src_stride,
1071                    src0, src1, src2, src3, src4, src5, src6, src7);
1072             src += (8 * src_stride);
1073
1074             out0 = __msa_copy_u_d((v2i64) src0, 0);
1075             out1 = __msa_copy_u_d((v2i64) src1, 0);
1076             out2 = __msa_copy_u_d((v2i64) src2, 0);
1077             out3 = __msa_copy_u_d((v2i64) src3, 0);
1078             out4 = __msa_copy_u_d((v2i64) src4, 0);
1079             out5 = __msa_copy_u_d((v2i64) src5, 0);
1080             out6 = __msa_copy_u_d((v2i64) src6, 0);
1081             out7 = __msa_copy_u_d((v2i64) src7, 0);
1082
1083             SD4(out0, out1, out2, out3, dst, dst_stride);
1084             dst += (4 * dst_stride);
1085             SD4(out4, out5, out6, out7, dst, dst_stride);
1086             dst += (4 * dst_stride);
1087
1088             LD_UB4(src, src_stride, src0, src1, src2, src3);
1089             src += (4 * src_stride);
1090
1091             out0 = __msa_copy_u_d((v2i64) src0, 0);
1092             out1 = __msa_copy_u_d((v2i64) src1, 0);
1093             out2 = __msa_copy_u_d((v2i64) src2, 0);
1094             out3 = __msa_copy_u_d((v2i64) src3, 0);
1095
1096             SD4(out0, out1, out2, out3, dst, dst_stride);
1097             dst += (4 * dst_stride);
1098         }
1099     } else if (0 == height % 8) {
1100         for (cnt = height >> 3; cnt--;) {
1101             LD_UB8(src, src_stride,
1102                    src0, src1, src2, src3, src4, src5, src6, src7);
1103             src += (8 * src_stride);
1104
1105             out0 = __msa_copy_u_d((v2i64) src0, 0);
1106             out1 = __msa_copy_u_d((v2i64) src1, 0);
1107             out2 = __msa_copy_u_d((v2i64) src2, 0);
1108             out3 = __msa_copy_u_d((v2i64) src3, 0);
1109             out4 = __msa_copy_u_d((v2i64) src4, 0);
1110             out5 = __msa_copy_u_d((v2i64) src5, 0);
1111             out6 = __msa_copy_u_d((v2i64) src6, 0);
1112             out7 = __msa_copy_u_d((v2i64) src7, 0);
1113
1114             SD4(out0, out1, out2, out3, dst, dst_stride);
1115             dst += (4 * dst_stride);
1116             SD4(out4, out5, out6, out7, dst, dst_stride);
1117             dst += (4 * dst_stride);
1118         }
1119     } else if (0 == height % 4) {
1120         for (cnt = (height / 4); cnt--;) {
1121             LD_UB4(src, src_stride, src0, src1, src2, src3);
1122             src += (4 * src_stride);
1123             out0 = __msa_copy_u_d((v2i64) src0, 0);
1124             out1 = __msa_copy_u_d((v2i64) src1, 0);
1125             out2 = __msa_copy_u_d((v2i64) src2, 0);
1126             out3 = __msa_copy_u_d((v2i64) src3, 0);
1127
1128             SD4(out0, out1, out2, out3, dst, dst_stride);
1129             dst += (4 * dst_stride);
1130         }
1131     } else if (0 == height % 2) {
1132         for (cnt = (height / 2); cnt--;) {
1133             LD_UB2(src, src_stride, src0, src1);
1134             src += (2 * src_stride);
1135             out0 = __msa_copy_u_d((v2i64) src0, 0);
1136             out1 = __msa_copy_u_d((v2i64) src1, 0);
1137
1138             SD(out0, dst);
1139             dst += dst_stride;
1140             SD(out1, dst);
1141             dst += dst_stride;
1142         }
1143     }
1144 }
1145
1146 static void copy_16multx8mult_msa(const uint8_t *src, int32_t src_stride,
1147                                   uint8_t *dst, int32_t dst_stride,
1148                                   int32_t height, int32_t width)
1149 {
1150     int32_t cnt, loop_cnt;
1151     const uint8_t *src_tmp;
1152     uint8_t *dst_tmp;
1153     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1154
1155     for (cnt = (width >> 4); cnt--;) {
1156         src_tmp = src;
1157         dst_tmp = dst;
1158
1159         for (loop_cnt = (height >> 3); loop_cnt--;) {
1160             LD_UB8(src_tmp, src_stride,
1161                    src0, src1, src2, src3, src4, src5, src6, src7);
1162             src_tmp += (8 * src_stride);
1163
1164             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
1165                    dst_tmp, dst_stride);
1166             dst_tmp += (8 * dst_stride);
1167         }
1168
1169         src += 16;
1170         dst += 16;
1171     }
1172 }
1173
1174 static void copy_width16_msa(const uint8_t *src, int32_t src_stride,
1175                              uint8_t *dst, int32_t dst_stride,
1176                              int32_t height)
1177 {
1178     int32_t cnt;
1179     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1180
1181     if (0 == height % 12) {
1182         for (cnt = (height / 12); cnt--;) {
1183             LD_UB8(src, src_stride,
1184                    src0, src1, src2, src3, src4, src5, src6, src7);
1185             src += (8 * src_stride);
1186             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
1187                    dst, dst_stride);
1188             dst += (8 * dst_stride);
1189
1190             LD_UB4(src, src_stride, src0, src1, src2, src3);
1191             src += (4 * src_stride);
1192             ST_UB4(src0, src1, src2, src3, dst, dst_stride);
1193             dst += (4 * dst_stride);
1194         }
1195     } else if (0 == height % 8) {
1196         copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
1197     } else if (0 == height % 4) {
1198         for (cnt = (height >> 2); cnt--;) {
1199             LD_UB4(src, src_stride, src0, src1, src2, src3);
1200             src += (4 * src_stride);
1201
1202             ST_UB4(src0, src1, src2, src3, dst, dst_stride);
1203             dst += (4 * dst_stride);
1204         }
1205     }
1206 }
1207
1208 static void avg_width4_msa(const uint8_t *src, int32_t src_stride,
1209                            uint8_t *dst, int32_t dst_stride,
1210                            int32_t height)
1211 {
1212     int32_t cnt;
1213     uint32_t out0, out1, out2, out3;
1214     v16u8 src0, src1, src2, src3;
1215     v16u8 dst0, dst1, dst2, dst3;
1216
1217     if (0 == (height % 4)) {
1218         for (cnt = (height / 4); cnt--;) {
1219             LD_UB4(src, src_stride, src0, src1, src2, src3);
1220             src += (4 * src_stride);
1221
1222             LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1223
1224             AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
1225                         dst0, dst1, dst2, dst3);
1226
1227             out0 = __msa_copy_u_w((v4i32) dst0, 0);
1228             out1 = __msa_copy_u_w((v4i32) dst1, 0);
1229             out2 = __msa_copy_u_w((v4i32) dst2, 0);
1230             out3 = __msa_copy_u_w((v4i32) dst3, 0);
1231             SW4(out0, out1, out2, out3, dst, dst_stride);
1232             dst += (4 * dst_stride);
1233         }
1234     } else if (0 == (height % 2)) {
1235         for (cnt = (height / 2); cnt--;) {
1236             LD_UB2(src, src_stride, src0, src1);
1237             src += (2 * src_stride);
1238
1239             LD_UB2(dst, dst_stride, dst0, dst1);
1240
1241             AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
1242
1243             out0 = __msa_copy_u_w((v4i32) dst0, 0);
1244             out1 = __msa_copy_u_w((v4i32) dst1, 0);
1245             SW(out0, dst);
1246             dst += dst_stride;
1247             SW(out1, dst);
1248             dst += dst_stride;
1249         }
1250     }
1251 }
1252
1253 static void avg_width8_msa(const uint8_t *src, int32_t src_stride,
1254                            uint8_t *dst, int32_t dst_stride,
1255                            int32_t height)
1256 {
1257     int32_t cnt;
1258     uint64_t out0, out1, out2, out3;
1259     v16u8 src0, src1, src2, src3;
1260     v16u8 dst0, dst1, dst2, dst3;
1261
1262     for (cnt = (height / 4); cnt--;) {
1263         LD_UB4(src, src_stride, src0, src1, src2, src3);
1264         src += (4 * src_stride);
1265         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1266
1267         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
1268                     dst0, dst1, dst2, dst3);
1269
1270         out0 = __msa_copy_u_d((v2i64) dst0, 0);
1271         out1 = __msa_copy_u_d((v2i64) dst1, 0);
1272         out2 = __msa_copy_u_d((v2i64) dst2, 0);
1273         out3 = __msa_copy_u_d((v2i64) dst3, 0);
1274         SD4(out0, out1, out2, out3, dst, dst_stride);
1275         dst += (4 * dst_stride);
1276     }
1277 }
1278
1279 static void avg_width16_msa(const uint8_t *src, int32_t src_stride,
1280                             uint8_t *dst, int32_t dst_stride,
1281                             int32_t height)
1282 {
1283     int32_t cnt;
1284     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1285     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1286
1287     for (cnt = (height / 8); cnt--;) {
1288         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
1289         src += (8 * src_stride);
1290         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
1291
1292         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
1293                     dst0, dst1, dst2, dst3);
1294         AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
1295                     dst4, dst5, dst6, dst7);
1296         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);
1297         dst += (8 * dst_stride);
1298     }
1299 }
1300
1301 void ff_put_pixels16_msa(uint8_t *block, const uint8_t *pixels,
1302                          ptrdiff_t line_size, int h)
1303 {
1304     copy_width16_msa(pixels, line_size, block, line_size, h);
1305 }
1306
1307 void ff_put_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,
1308                             ptrdiff_t line_size, int h)
1309 {
1310     common_hz_bil_16w_msa(pixels, line_size, block, line_size, h);
1311 }
1312
1313 void ff_put_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,
1314                             ptrdiff_t line_size, int h)
1315 {
1316     common_vt_bil_16w_msa(pixels, line_size, block, line_size, h);
1317 }
1318
1319 void ff_put_pixels16_xy2_msa(uint8_t *block, const uint8_t *pixels,
1320                              ptrdiff_t line_size, int h)
1321 {
1322     common_hv_bil_16w_msa(pixels, line_size, block, line_size, h);
1323 }
1324
1325 void ff_put_pixels8_msa(uint8_t *block, const uint8_t *pixels,
1326                         ptrdiff_t line_size, int h)
1327 {
1328     copy_width8_msa(pixels, line_size, block, line_size, h);
1329 }
1330
1331 void ff_put_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,
1332                            ptrdiff_t line_size, int h)
1333 {
1334     common_hz_bil_8w_msa(pixels, line_size, block, line_size, h);
1335 }
1336
1337 void ff_put_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,
1338                            ptrdiff_t line_size, int h)
1339 {
1340     common_vt_bil_8w_msa(pixels, line_size, block, line_size, h);
1341 }
1342
1343 void ff_put_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,
1344                             ptrdiff_t line_size, int h)
1345 {
1346     common_hv_bil_8w_msa(pixels, line_size, block, line_size, h);
1347 }
1348
1349 void ff_put_pixels4_x2_msa(uint8_t *block, const uint8_t *pixels,
1350                            ptrdiff_t line_size, int h)
1351 {
1352     common_hz_bil_4w_msa(pixels, line_size, block, line_size, h);
1353 }
1354
1355 void ff_put_pixels4_y2_msa(uint8_t *block, const uint8_t *pixels,
1356                            ptrdiff_t line_size, int h)
1357 {
1358     common_vt_bil_4w_msa(pixels, line_size, block, line_size, h);
1359 }
1360
1361 void ff_put_pixels4_xy2_msa(uint8_t *block, const uint8_t *pixels,
1362                             ptrdiff_t line_size, int h)
1363 {
1364     common_hv_bil_4w_msa(pixels, line_size, block, line_size, h);
1365 }
1366
1367 void ff_put_no_rnd_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,
1368                                    ptrdiff_t line_size, int h)
1369 {
1370     if (h == 16) {
1371         common_hz_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);
1372     } else if (h == 8) {
1373         common_hz_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);
1374     }
1375 }
1376
1377 void ff_put_no_rnd_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,
1378                                    ptrdiff_t line_size, int h)
1379 {
1380     if (h == 16) {
1381         common_vt_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);
1382     } else if (h == 8) {
1383         common_vt_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);
1384     }
1385 }
1386
1387 void ff_put_no_rnd_pixels16_xy2_msa(uint8_t *block,
1388                                     const uint8_t *pixels,
1389                                     ptrdiff_t line_size, int h)
1390 {
1391     if (h == 16) {
1392         common_hv_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);
1393     } else if (h == 8) {
1394         common_hv_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);
1395     }
1396 }
1397
1398 void ff_put_no_rnd_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,
1399                                   ptrdiff_t line_size, int h)
1400 {
1401     if (h == 8) {
1402         common_hz_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);
1403     } else if (h == 4) {
1404         common_hz_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);
1405     }
1406 }
1407
1408 void ff_put_no_rnd_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,
1409                                   ptrdiff_t line_size, int h)
1410 {
1411     if (h == 8) {
1412         common_vt_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);
1413     } else if (h == 4) {
1414         common_vt_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);
1415     }
1416 }
1417
1418 void ff_put_no_rnd_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,
1419                                    ptrdiff_t line_size, int h)
1420 {
1421     if (h == 8) {
1422         common_hv_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);
1423     } else if (h == 4) {
1424         common_hv_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);
1425     }
1426 }
1427
1428 void ff_avg_pixels16_msa(uint8_t *block, const uint8_t *pixels,
1429                          ptrdiff_t line_size, int h)
1430 {
1431     avg_width16_msa(pixels, line_size, block, line_size, h);
1432 }
1433
1434 void ff_avg_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,
1435                             ptrdiff_t line_size, int h)
1436 {
1437     common_hz_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);
1438 }
1439
1440 void ff_avg_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,
1441                             ptrdiff_t line_size, int h)
1442 {
1443     common_vt_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);
1444 }
1445
1446 void ff_avg_pixels16_xy2_msa(uint8_t *block, const uint8_t *pixels,
1447                              ptrdiff_t line_size, int h)
1448 {
1449     common_hv_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);
1450 }
1451
1452 void ff_avg_pixels8_msa(uint8_t *block, const uint8_t *pixels,
1453                         ptrdiff_t line_size, int h)
1454 {
1455     avg_width8_msa(pixels, line_size, block, line_size, h);
1456 }
1457
1458 void ff_avg_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,
1459                            ptrdiff_t line_size, int h)
1460 {
1461     common_hz_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);
1462 }
1463
1464 void ff_avg_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,
1465                            ptrdiff_t line_size, int h)
1466 {
1467     common_vt_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);
1468 }
1469
1470 void ff_avg_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,
1471                             ptrdiff_t line_size, int h)
1472 {
1473     common_hv_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);
1474 }
1475
1476 void ff_avg_pixels4_msa(uint8_t *block, const uint8_t *pixels,
1477                         ptrdiff_t line_size, int h)
1478 {
1479     avg_width4_msa(pixels, line_size, block, line_size, h);
1480 }
1481
1482 void ff_avg_pixels4_x2_msa(uint8_t *block, const uint8_t *pixels,
1483                            ptrdiff_t line_size, int h)
1484 {
1485     common_hz_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);
1486 }
1487
1488 void ff_avg_pixels4_y2_msa(uint8_t *block, const uint8_t *pixels,
1489                            ptrdiff_t line_size, int h)
1490 {
1491     common_vt_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);
1492 }
1493
1494 void ff_avg_pixels4_xy2_msa(uint8_t *block, const uint8_t *pixels,
1495                             ptrdiff_t line_size, int h)
1496 {
1497     common_hv_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);
1498 }