lavc/vp9: split into vp9{block,data,mvs}
[ffmpeg.git] / libavcodec / mips / vp9_mc_msa.c
1 /*
2  * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@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 "libavcodec/vp9.h"
22 #include "libavutil/mips/generic_macros_msa.h"
23 #include "vp9dsp_mips.h"
24
25 static const uint8_t mc_filt_mask_arr[16 * 3] = {
26     /* 8 width cases */
27     0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
28     /* 4 width cases */
29     0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20,
30     /* 4 width cases */
31     8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
32 };
33
34 static const int8_t vp9_bilinear_filters_msa[15][2] = {
35     {120, 8},
36     {112, 16},
37     {104, 24},
38     {96, 32},
39     {88, 40},
40     {80, 48},
41     {72, 56},
42     {64, 64},
43     {56, 72},
44     {48, 80},
45     {40, 88},
46     {32, 96},
47     {24, 104},
48     {16, 112},
49     {8, 120}
50 };
51
52 #define FILT_8TAP_DPADD_S_H(vec0, vec1, vec2, vec3,             \
53                             filt0, filt1, filt2, filt3)         \
54 ( {                                                             \
55     v8i16 tmp0, tmp1;                                           \
56                                                                 \
57     tmp0 = __msa_dotp_s_h((v16i8) vec0, (v16i8) filt0);         \
58     tmp0 = __msa_dpadd_s_h(tmp0, (v16i8) vec1, (v16i8) filt1);  \
59     tmp1 = __msa_dotp_s_h((v16i8) vec2, (v16i8) filt2);         \
60     tmp1 = __msa_dpadd_s_h(tmp1, (v16i8) vec3, (v16i8) filt3);  \
61     tmp0 = __msa_adds_s_h(tmp0, tmp1);                          \
62                                                                 \
63     tmp0;                                                       \
64 } )
65
66 #define HORIZ_8TAP_FILT(src0, src1, mask0, mask1, mask2, mask3,          \
67                         filt_h0, filt_h1, filt_h2, filt_h3)              \
68 ( {                                                                      \
69     v16i8 vec0_m, vec1_m, vec2_m, vec3_m;                                \
70     v8i16 hz_out_m;                                                      \
71                                                                          \
72     VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,                   \
73                vec0_m, vec1_m, vec2_m, vec3_m);                          \
74     hz_out_m = FILT_8TAP_DPADD_S_H(vec0_m, vec1_m, vec2_m, vec3_m,       \
75                                    filt_h0, filt_h1, filt_h2, filt_h3);  \
76                                                                          \
77     hz_out_m = __msa_srari_h(hz_out_m, 7);                               \
78     hz_out_m = __msa_sat_s_h(hz_out_m, 7);                               \
79                                                                          \
80     hz_out_m;                                                            \
81 } )
82
83 #define HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3,                  \
84                                    mask0, mask1, mask2, mask3,              \
85                                    filt0, filt1, filt2, filt3,              \
86                                    out0, out1)                              \
87 {                                                                           \
88     v16i8 vec0_m, vec1_m, vec2_m, vec3_m,  vec4_m, vec5_m, vec6_m, vec7_m;  \
89     v8i16 res0_m, res1_m, res2_m, res3_m;                                   \
90                                                                             \
91     VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0_m, vec1_m);       \
92     DOTP_SB2_SH(vec0_m, vec1_m, filt0, filt0, res0_m, res1_m);              \
93     VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2_m, vec3_m);       \
94     DPADD_SB2_SH(vec2_m, vec3_m, filt1, filt1, res0_m, res1_m);             \
95     VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4_m, vec5_m);       \
96     DOTP_SB2_SH(vec4_m, vec5_m, filt2, filt2, res2_m, res3_m);              \
97     VSHF_B2_SB(src0, src1, src2, src3, mask3, mask3, vec6_m, vec7_m);       \
98     DPADD_SB2_SH(vec6_m, vec7_m, filt3, filt3, res2_m, res3_m);             \
99     ADDS_SH2_SH(res0_m, res2_m, res1_m, res3_m, out0, out1);                \
100 }
101
102 #define HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3,                    \
103                                    mask0, mask1, mask2, mask3,                \
104                                    filt0, filt1, filt2, filt3,                \
105                                    out0, out1, out2, out3)                    \
106 {                                                                             \
107     v16i8 vec0_m, vec1_m, vec2_m, vec3_m, vec4_m, vec5_m, vec6_m, vec7_m;     \
108     v8i16 res0_m, res1_m, res2_m, res3_m, res4_m, res5_m, res6_m, res7_m;     \
109                                                                               \
110     VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0_m, vec1_m);         \
111     VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2_m, vec3_m);         \
112     DOTP_SB4_SH(vec0_m, vec1_m, vec2_m, vec3_m, filt0, filt0, filt0, filt0,   \
113                 res0_m, res1_m, res2_m, res3_m);                              \
114     VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec0_m, vec1_m);         \
115     VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec2_m, vec3_m);         \
116     DOTP_SB4_SH(vec0_m, vec1_m, vec2_m, vec3_m, filt2, filt2, filt2, filt2,   \
117                 res4_m, res5_m, res6_m, res7_m);                              \
118     VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4_m, vec5_m);         \
119     VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6_m, vec7_m);         \
120     DPADD_SB4_SH(vec4_m, vec5_m, vec6_m, vec7_m, filt1, filt1, filt1, filt1,  \
121                  res0_m, res1_m, res2_m, res3_m);                             \
122     VSHF_B2_SB(src0, src0, src1, src1, mask3, mask3, vec4_m, vec5_m);         \
123     VSHF_B2_SB(src2, src2, src3, src3, mask3, mask3, vec6_m, vec7_m);         \
124     DPADD_SB4_SH(vec4_m, vec5_m, vec6_m, vec7_m, filt3, filt3, filt3, filt3,  \
125                  res4_m, res5_m, res6_m, res7_m);                             \
126     ADDS_SH4_SH(res0_m, res4_m, res1_m, res5_m, res2_m, res6_m, res3_m,       \
127                 res7_m, out0, out1, out2, out3);                              \
128 }
129
130 #define PCKEV_XORI128_AVG_ST_UB(in0, in1, dst, pdst)  \
131 {                                                     \
132     v16u8 tmp_m;                                      \
133                                                       \
134     tmp_m = PCKEV_XORI128_UB(in1, in0);               \
135     tmp_m = __msa_aver_u_b(tmp_m, (v16u8) dst);       \
136     ST_UB(tmp_m, (pdst));                             \
137 }
138
139 #define PCKEV_AVG_ST_UB(in0, in1, dst, pdst)                  \
140 {                                                             \
141     v16u8 tmp_m;                                              \
142                                                               \
143     tmp_m = (v16u8) __msa_pckev_b((v16i8) in0, (v16i8) in1);  \
144     tmp_m = __msa_aver_u_b(tmp_m, (v16u8) dst);               \
145     ST_UB(tmp_m, (pdst));                                     \
146 }
147
148 #define PCKEV_AVG_ST8x4_UB(in1, dst0, in2, dst1, in3, dst2, in4, dst3,  \
149                            pdst, stride)                                \
150 {                                                                       \
151     v16u8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                               \
152     uint8_t *pdst_m = (uint8_t *) (pdst);                               \
153                                                                         \
154     PCKEV_B2_UB(in2, in1, in4, in3, tmp0_m, tmp1_m);                    \
155     PCKEV_D2_UB(dst1, dst0, dst3, dst2, tmp2_m, tmp3_m);                \
156     AVER_UB2_UB(tmp0_m, tmp2_m, tmp1_m, tmp3_m, tmp0_m, tmp1_m);        \
157     ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                           \
158 }
159
160 static void common_hz_8t_4x4_msa(const uint8_t *src, int32_t src_stride,
161                                  uint8_t *dst, int32_t dst_stride,
162                                  const int8_t *filter)
163 {
164     v16u8 mask0, mask1, mask2, mask3, out;
165     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
166     v8i16 filt, out0, out1;
167
168     mask0 = LD_UB(&mc_filt_mask_arr[16]);
169     src -= 3;
170
171     /* rearranging filter */
172     filt = LD_SH(filter);
173     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
174
175     mask1 = mask0 + 2;
176     mask2 = mask0 + 4;
177     mask3 = mask0 + 6;
178
179     LD_SB4(src, src_stride, src0, src1, src2, src3);
180     XORI_B4_128_SB(src0, src1, src2, src3);
181     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
182                                mask3, filt0, filt1, filt2, filt3, out0, out1);
183     SRARI_H2_SH(out0, out1, 7);
184     SAT_SH2_SH(out0, out1, 7);
185     out = PCKEV_XORI128_UB(out0, out1);
186     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
187 }
188
189 static void common_hz_8t_4x8_msa(const uint8_t *src, int32_t src_stride,
190                                  uint8_t *dst, int32_t dst_stride,
191                                  const int8_t *filter)
192 {
193     v16i8 filt0, filt1, filt2, filt3;
194     v16i8 src0, src1, src2, src3;
195     v16u8 mask0, mask1, mask2, mask3, out;
196     v8i16 filt, out0, out1, out2, out3;
197
198     mask0 = LD_UB(&mc_filt_mask_arr[16]);
199     src -= 3;
200
201     /* rearranging filter */
202     filt = LD_SH(filter);
203     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
204
205     mask1 = mask0 + 2;
206     mask2 = mask0 + 4;
207     mask3 = mask0 + 6;
208
209     LD_SB4(src, src_stride, src0, src1, src2, src3);
210     XORI_B4_128_SB(src0, src1, src2, src3);
211     src += (4 * src_stride);
212     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
213                                mask3, filt0, filt1, filt2, filt3, out0, out1);
214     LD_SB4(src, src_stride, src0, src1, src2, src3);
215     XORI_B4_128_SB(src0, src1, src2, src3);
216     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
217                                mask3, filt0, filt1, filt2, filt3, out2, out3);
218     SRARI_H4_SH(out0, out1, out2, out3, 7);
219     SAT_SH4_SH(out0, out1, out2, out3, 7);
220     out = PCKEV_XORI128_UB(out0, out1);
221     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
222     dst += (4 * dst_stride);
223     out = PCKEV_XORI128_UB(out2, out3);
224     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
225 }
226
227 static void common_hz_8t_4x16_msa(const uint8_t *src, int32_t src_stride,
228                                   uint8_t *dst, int32_t dst_stride,
229                                   const int8_t *filter)
230 {
231     v16u8 mask0, mask1, mask2, mask3, out;
232     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
233     v8i16 filt, out0, out1, out2, out3;
234
235     mask0 = LD_UB(&mc_filt_mask_arr[16]);
236     src -= 3;
237
238     /* rearranging filter */
239     filt = LD_SH(filter);
240     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
241
242     mask1 = mask0 + 2;
243     mask2 = mask0 + 4;
244     mask3 = mask0 + 6;
245
246     LD_SB4(src, src_stride, src0, src1, src2, src3);
247     XORI_B4_128_SB(src0, src1, src2, src3);
248     src += (4 * src_stride);
249     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
250                                mask3, filt0, filt1, filt2, filt3, out0, out1);
251     LD_SB4(src, src_stride, src0, src1, src2, src3);
252     XORI_B4_128_SB(src0, src1, src2, src3);
253     src += (4 * src_stride);
254     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
255                                mask3, filt0, filt1, filt2, filt3, out2, out3);
256     SRARI_H4_SH(out0, out1, out2, out3, 7);
257     SAT_SH4_SH(out0, out1, out2, out3, 7);
258     out = PCKEV_XORI128_UB(out0, out1);
259     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
260     dst += (4 * dst_stride);
261     out = PCKEV_XORI128_UB(out2, out3);
262     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
263     dst += (4 * dst_stride);
264
265     LD_SB4(src, src_stride, src0, src1, src2, src3);
266     XORI_B4_128_SB(src0, src1, src2, src3);
267     src += (4 * src_stride);
268     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
269                                mask3, filt0, filt1, filt2, filt3, out0, out1);
270     LD_SB4(src, src_stride, src0, src1, src2, src3);
271     XORI_B4_128_SB(src0, src1, src2, src3);
272     src += (4 * src_stride);
273     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
274                                mask3, filt0, filt1, filt2, filt3, out2, out3);
275
276     SRARI_H4_SH(out0, out1, out2, out3, 7);
277     SAT_SH4_SH(out0, out1, out2, out3, 7);
278     out = PCKEV_XORI128_UB(out0, out1);
279     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
280     dst += (4 * dst_stride);
281     out = PCKEV_XORI128_UB(out2, out3);
282     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
283 }
284
285 static void common_hz_8t_4w_msa(const uint8_t *src, int32_t src_stride,
286                                 uint8_t *dst, int32_t dst_stride,
287                                 const int8_t *filter, int32_t height)
288 {
289     if (4 == height) {
290         common_hz_8t_4x4_msa(src, src_stride, dst, dst_stride, filter);
291     } else if (8 == height) {
292         common_hz_8t_4x8_msa(src, src_stride, dst, dst_stride, filter);
293     } else if (16 == height) {
294         common_hz_8t_4x16_msa(src, src_stride, dst, dst_stride, filter);
295     }
296 }
297
298 static void common_hz_8t_8x4_msa(const uint8_t *src, int32_t src_stride,
299                                  uint8_t *dst, int32_t dst_stride,
300                                  const int8_t *filter)
301 {
302     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
303     v16u8 mask0, mask1, mask2, mask3, tmp0, tmp1;
304     v8i16 filt, out0, out1, out2, out3;
305
306     mask0 = LD_UB(&mc_filt_mask_arr[0]);
307     src -= 3;
308
309     /* rearranging filter */
310     filt = LD_SH(filter);
311     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
312
313     mask1 = mask0 + 2;
314     mask2 = mask0 + 4;
315     mask3 = mask0 + 6;
316
317     LD_SB4(src, src_stride, src0, src1, src2, src3);
318     XORI_B4_128_SB(src0, src1, src2, src3);
319     HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
320                                mask3, filt0, filt1, filt2, filt3, out0, out1,
321                                out2, out3);
322     SRARI_H4_SH(out0, out1, out2, out3, 7);
323     SAT_SH4_SH(out0, out1, out2, out3, 7);
324     tmp0 = PCKEV_XORI128_UB(out0, out1);
325     tmp1 = PCKEV_XORI128_UB(out2, out3);
326     ST8x4_UB(tmp0, tmp1, dst, dst_stride);
327 }
328
329 static void common_hz_8t_8x8mult_msa(const uint8_t *src, int32_t src_stride,
330                                      uint8_t *dst, int32_t dst_stride,
331                                      const int8_t *filter, int32_t height)
332 {
333     uint32_t loop_cnt;
334     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
335     v16u8 mask0, mask1, mask2, mask3, tmp0, tmp1;
336     v8i16 filt, out0, out1, out2, out3;
337
338     mask0 = LD_UB(&mc_filt_mask_arr[0]);
339     src -= 3;
340
341     /* rearranging filter */
342     filt = LD_SH(filter);
343     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
344
345     mask1 = mask0 + 2;
346     mask2 = mask0 + 4;
347     mask3 = mask0 + 6;
348
349     for (loop_cnt = (height >> 2); loop_cnt--;) {
350         LD_SB4(src, src_stride, src0, src1, src2, src3);
351         XORI_B4_128_SB(src0, src1, src2, src3);
352         src += (4 * src_stride);
353         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
354                                    mask3, filt0, filt1, filt2, filt3, out0,
355                                    out1, out2, out3);
356         SRARI_H4_SH(out0, out1, out2, out3, 7);
357         SAT_SH4_SH(out0, out1, out2, out3, 7);
358         tmp0 = PCKEV_XORI128_UB(out0, out1);
359         tmp1 = PCKEV_XORI128_UB(out2, out3);
360         ST8x4_UB(tmp0, tmp1, dst, dst_stride);
361         dst += (4 * dst_stride);
362     }
363 }
364
365 static void common_hz_8t_8w_msa(const uint8_t *src, int32_t src_stride,
366                                 uint8_t *dst, int32_t dst_stride,
367                                 const int8_t *filter, int32_t height)
368 {
369     if (4 == height) {
370         common_hz_8t_8x4_msa(src, src_stride, dst, dst_stride, filter);
371     } else {
372         common_hz_8t_8x8mult_msa(src, src_stride, dst, dst_stride, filter,
373                                  height);
374     }
375 }
376
377 static void common_hz_8t_16w_msa(const uint8_t *src, int32_t src_stride,
378                                  uint8_t *dst, int32_t dst_stride,
379                                  const int8_t *filter, int32_t height)
380 {
381     uint32_t loop_cnt;
382     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
383     v16u8 mask0, mask1, mask2, mask3, out;
384     v8i16 filt, out0, out1, out2, out3;
385
386     mask0 = LD_UB(&mc_filt_mask_arr[0]);
387     src -= 3;
388
389     /* rearranging filter */
390     filt = LD_SH(filter);
391     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
392
393     mask1 = mask0 + 2;
394     mask2 = mask0 + 4;
395     mask3 = mask0 + 6;
396
397     for (loop_cnt = (height >> 1); loop_cnt--;) {
398         LD_SB2(src, src_stride, src0, src2);
399         LD_SB2(src + 8, src_stride, src1, src3);
400         XORI_B4_128_SB(src0, src1, src2, src3);
401         src += (2 * src_stride);
402         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
403                                    mask3, filt0, filt1, filt2, filt3, out0,
404                                    out1, out2, out3);
405         SRARI_H4_SH(out0, out1, out2, out3, 7);
406         SAT_SH4_SH(out0, out1, out2, out3, 7);
407         out = PCKEV_XORI128_UB(out0, out1);
408         ST_UB(out, dst);
409         dst += dst_stride;
410         out = PCKEV_XORI128_UB(out2, out3);
411         ST_UB(out, dst);
412         dst += dst_stride;
413     }
414 }
415
416 static void common_hz_8t_32w_msa(const uint8_t *src, int32_t src_stride,
417                                  uint8_t *dst, int32_t dst_stride,
418                                  const int8_t *filter, int32_t height)
419 {
420     uint32_t loop_cnt;
421     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
422     v16u8 mask0, mask1, mask2, mask3, out;
423     v8i16 filt, out0, out1, out2, out3;
424
425     mask0 = LD_UB(&mc_filt_mask_arr[0]);
426     src -= 3;
427
428     /* rearranging filter */
429     filt = LD_SH(filter);
430     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
431
432     mask1 = mask0 + 2;
433     mask2 = mask0 + 4;
434     mask3 = mask0 + 6;
435
436     for (loop_cnt = (height >> 1); loop_cnt--;) {
437         src0 = LD_SB(src);
438         src2 = LD_SB(src + 16);
439         src3 = LD_SB(src + 24);
440         src1 = __msa_sldi_b(src2, src0, 8);
441         src += src_stride;
442         XORI_B4_128_SB(src0, src1, src2, src3);
443         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
444                                    mask3, filt0, filt1, filt2, filt3, out0,
445                                    out1, out2, out3);
446         SRARI_H4_SH(out0, out1, out2, out3, 7);
447         SAT_SH4_SH(out0, out1, out2, out3, 7);
448
449         src0 = LD_SB(src);
450         src2 = LD_SB(src + 16);
451         src3 = LD_SB(src + 24);
452         src1 = __msa_sldi_b(src2, src0, 8);
453         src += src_stride;
454
455         out = PCKEV_XORI128_UB(out0, out1);
456         ST_UB(out, dst);
457         out = PCKEV_XORI128_UB(out2, out3);
458         ST_UB(out, dst + 16);
459         dst += dst_stride;
460
461         XORI_B4_128_SB(src0, src1, src2, src3);
462         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
463                                    mask3, filt0, filt1, filt2, filt3, out0,
464                                    out1, out2, out3);
465         SRARI_H4_SH(out0, out1, out2, out3, 7);
466         SAT_SH4_SH(out0, out1, out2, out3, 7);
467         out = PCKEV_XORI128_UB(out0, out1);
468         ST_UB(out, dst);
469         out = PCKEV_XORI128_UB(out2, out3);
470         ST_UB(out, dst + 16);
471         dst += dst_stride;
472     }
473 }
474
475 static void common_hz_8t_64w_msa(const uint8_t *src, int32_t src_stride,
476                                  uint8_t *dst, int32_t dst_stride,
477                                  const int8_t *filter, int32_t height)
478 {
479     int32_t loop_cnt;
480     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
481     v16u8 mask0, mask1, mask2, mask3, out;
482     v8i16 filt, out0, out1, out2, out3;
483
484     mask0 = LD_UB(&mc_filt_mask_arr[0]);
485     src -= 3;
486
487     /* rearranging filter */
488     filt = LD_SH(filter);
489     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
490
491     mask1 = mask0 + 2;
492     mask2 = mask0 + 4;
493     mask3 = mask0 + 6;
494
495     for (loop_cnt = height; loop_cnt--;) {
496         src0 = LD_SB(src);
497         src2 = LD_SB(src + 16);
498         src3 = LD_SB(src + 24);
499         src1 = __msa_sldi_b(src2, src0, 8);
500
501         XORI_B4_128_SB(src0, src1, src2, src3);
502         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
503                                    mask2, mask3, filt0, filt1, filt2, filt3,
504                                    out0, out1, out2, out3);
505         SRARI_H4_SH(out0, out1, out2, out3, 7);
506         SAT_SH4_SH(out0, out1, out2, out3, 7);
507         out = PCKEV_XORI128_UB(out0, out1);
508         ST_UB(out, dst);
509         out = PCKEV_XORI128_UB(out2, out3);
510         ST_UB(out, dst + 16);
511
512         src0 = LD_SB(src + 32);
513         src2 = LD_SB(src + 48);
514         src3 = LD_SB(src + 56);
515         src1 = __msa_sldi_b(src2, src0, 8);
516         src += src_stride;
517
518         XORI_B4_128_SB(src0, src1, src2, src3);
519         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
520                                    mask2, mask3, filt0, filt1, filt2, filt3,
521                                    out0, out1, out2, out3);
522         SRARI_H4_SH(out0, out1, out2, out3, 7);
523         SAT_SH4_SH(out0, out1, out2, out3, 7);
524         out = PCKEV_XORI128_UB(out0, out1);
525         ST_UB(out, dst + 32);
526         out = PCKEV_XORI128_UB(out2, out3);
527         ST_UB(out, dst + 48);
528         dst += dst_stride;
529     }
530 }
531
532 static void common_vt_8t_4w_msa(const uint8_t *src, int32_t src_stride,
533                                 uint8_t *dst, int32_t dst_stride,
534                                 const int8_t *filter, int32_t height)
535 {
536     uint32_t loop_cnt;
537     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
538     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
539     v16i8 src65_r, src87_r, src109_r, src2110, src4332, src6554, src8776;
540     v16i8 src10998, filt0, filt1, filt2, filt3;
541     v16u8 out;
542     v8i16 filt, out10, out32;
543
544     src -= (3 * src_stride);
545
546     filt = LD_SH(filter);
547     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
548
549     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
550     src += (7 * src_stride);
551
552     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r, src32_r,
553                src54_r, src21_r);
554     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
555     ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r, src2110,
556                src4332, src6554);
557     XORI_B3_128_SB(src2110, src4332, src6554);
558
559     for (loop_cnt = (height >> 2); loop_cnt--;) {
560         LD_SB4(src, src_stride, src7, src8, src9, src10);
561         src += (4 * src_stride);
562
563         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
564                    src87_r, src98_r, src109_r);
565         ILVR_D2_SB(src87_r, src76_r, src109_r, src98_r, src8776, src10998);
566         XORI_B2_128_SB(src8776, src10998);
567         out10 = FILT_8TAP_DPADD_S_H(src2110, src4332, src6554, src8776, filt0,
568                                     filt1, filt2, filt3);
569         out32 = FILT_8TAP_DPADD_S_H(src4332, src6554, src8776, src10998, filt0,
570                                     filt1, filt2, filt3);
571         SRARI_H2_SH(out10, out32, 7);
572         SAT_SH2_SH(out10, out32, 7);
573         out = PCKEV_XORI128_UB(out10, out32);
574         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
575         dst += (4 * dst_stride);
576
577         src2110 = src6554;
578         src4332 = src8776;
579         src6554 = src10998;
580         src6 = src10;
581     }
582 }
583
584 static void common_vt_8t_8w_msa(const uint8_t *src, int32_t src_stride,
585                                 uint8_t *dst, int32_t dst_stride,
586                                 const int8_t *filter, int32_t height)
587 {
588     uint32_t loop_cnt;
589     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
590     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
591     v16i8 src65_r, src87_r, src109_r, filt0, filt1, filt2, filt3;
592     v16u8 tmp0, tmp1;
593     v8i16 filt, out0_r, out1_r, out2_r, out3_r;
594
595     src -= (3 * src_stride);
596
597     filt = LD_SH(filter);
598     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
599
600     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
601     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
602     src += (7 * src_stride);
603     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r, src32_r,
604                src54_r, src21_r);
605     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
606
607     for (loop_cnt = (height >> 2); loop_cnt--;) {
608         LD_SB4(src, src_stride, src7, src8, src9, src10);
609         XORI_B4_128_SB(src7, src8, src9, src10);
610         src += (4 * src_stride);
611
612         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
613                    src87_r, src98_r, src109_r);
614         out0_r = FILT_8TAP_DPADD_S_H(src10_r, src32_r, src54_r, src76_r, filt0,
615                                      filt1, filt2, filt3);
616         out1_r = FILT_8TAP_DPADD_S_H(src21_r, src43_r, src65_r, src87_r, filt0,
617                                      filt1, filt2, filt3);
618         out2_r = FILT_8TAP_DPADD_S_H(src32_r, src54_r, src76_r, src98_r, filt0,
619                                      filt1, filt2, filt3);
620         out3_r = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r, filt0,
621                                      filt1, filt2, filt3);
622         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 7);
623         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
624         tmp0 = PCKEV_XORI128_UB(out0_r, out1_r);
625         tmp1 = PCKEV_XORI128_UB(out2_r, out3_r);
626         ST8x4_UB(tmp0, tmp1, dst, dst_stride);
627         dst += (4 * dst_stride);
628
629         src10_r = src54_r;
630         src32_r = src76_r;
631         src54_r = src98_r;
632         src21_r = src65_r;
633         src43_r = src87_r;
634         src65_r = src109_r;
635         src6 = src10;
636     }
637 }
638
639 static void common_vt_8t_16w_msa(const uint8_t *src, int32_t src_stride,
640                                  uint8_t *dst, int32_t dst_stride,
641                                  const int8_t *filter, int32_t height)
642 {
643     uint32_t loop_cnt;
644     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
645     v16i8 filt0, filt1, filt2, filt3;
646     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
647     v16i8 src65_r, src87_r, src109_r, src10_l, src32_l, src54_l, src76_l;
648     v16i8 src98_l, src21_l, src43_l, src65_l, src87_l, src109_l;
649     v16u8 tmp0, tmp1, tmp2, tmp3;
650     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
651
652     src -= (3 * src_stride);
653
654     filt = LD_SH(filter);
655     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
656
657     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
658     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
659     src += (7 * src_stride);
660     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r, src32_r,
661                src54_r, src21_r);
662     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
663     ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_l, src32_l,
664                src54_l, src21_l);
665     ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
666
667     for (loop_cnt = (height >> 2); loop_cnt--;) {
668         LD_SB4(src, src_stride, src7, src8, src9, src10);
669         XORI_B4_128_SB(src7, src8, src9, src10);
670         src += (4 * src_stride);
671
672         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
673                    src87_r, src98_r, src109_r);
674         ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_l,
675                    src87_l, src98_l, src109_l);
676         out0_r = FILT_8TAP_DPADD_S_H(src10_r, src32_r, src54_r, src76_r, filt0,
677                                      filt1, filt2, filt3);
678         out1_r = FILT_8TAP_DPADD_S_H(src21_r, src43_r, src65_r, src87_r, filt0,
679                                      filt1, filt2, filt3);
680         out2_r = FILT_8TAP_DPADD_S_H(src32_r, src54_r, src76_r, src98_r, filt0,
681                                      filt1, filt2, filt3);
682         out3_r = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r, filt0,
683                                      filt1, filt2, filt3);
684         out0_l = FILT_8TAP_DPADD_S_H(src10_l, src32_l, src54_l, src76_l, filt0,
685                                      filt1, filt2, filt3);
686         out1_l = FILT_8TAP_DPADD_S_H(src21_l, src43_l, src65_l, src87_l, filt0,
687                                      filt1, filt2, filt3);
688         out2_l = FILT_8TAP_DPADD_S_H(src32_l, src54_l, src76_l, src98_l, filt0,
689                                      filt1, filt2, filt3);
690         out3_l = FILT_8TAP_DPADD_S_H(src43_l, src65_l, src87_l, src109_l, filt0,
691                                      filt1, filt2, filt3);
692         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 7);
693         SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 7);
694         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
695         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
696         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
697                     out3_r, tmp0, tmp1, tmp2, tmp3);
698         XORI_B4_128_UB(tmp0, tmp1, tmp2, tmp3);
699         ST_UB4(tmp0, tmp1, tmp2, tmp3, dst, dst_stride);
700         dst += (4 * dst_stride);
701
702         src10_r = src54_r;
703         src32_r = src76_r;
704         src54_r = src98_r;
705         src21_r = src65_r;
706         src43_r = src87_r;
707         src65_r = src109_r;
708         src10_l = src54_l;
709         src32_l = src76_l;
710         src54_l = src98_l;
711         src21_l = src65_l;
712         src43_l = src87_l;
713         src65_l = src109_l;
714         src6 = src10;
715     }
716 }
717
718 static void common_vt_8t_16w_mult_msa(const uint8_t *src, int32_t src_stride,
719                                       uint8_t *dst, int32_t dst_stride,
720                                       const int8_t *filter, int32_t height,
721                                       int32_t width)
722 {
723     const uint8_t *src_tmp;
724     uint8_t *dst_tmp;
725     uint32_t loop_cnt, cnt;
726     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
727     v16i8 filt0, filt1, filt2, filt3;
728     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
729     v16i8 src65_r, src87_r, src109_r, src10_l, src32_l, src54_l, src76_l;
730     v16i8 src98_l, src21_l, src43_l, src65_l, src87_l, src109_l;
731     v16u8 tmp0, tmp1, tmp2, tmp3;
732     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
733
734     src -= (3 * src_stride);
735
736     filt = LD_SH(filter);
737     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
738
739     for (cnt = (width >> 4); cnt--;) {
740         src_tmp = src;
741         dst_tmp = dst;
742
743         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
744         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
745         src_tmp += (7 * src_stride);
746         ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r,
747                    src32_r, src54_r, src21_r);
748         ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
749         ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_l,
750                    src32_l, src54_l, src21_l);
751         ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
752
753         for (loop_cnt = (height >> 2); loop_cnt--;) {
754             LD_SB4(src_tmp, src_stride, src7, src8, src9, src10);
755             XORI_B4_128_SB(src7, src8, src9, src10);
756             src_tmp += (4 * src_stride);
757             ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
758                        src87_r, src98_r, src109_r);
759             ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_l,
760                        src87_l, src98_l, src109_l);
761             out0_r = FILT_8TAP_DPADD_S_H(src10_r, src32_r, src54_r, src76_r,
762                                          filt0, filt1, filt2, filt3);
763             out1_r = FILT_8TAP_DPADD_S_H(src21_r, src43_r, src65_r, src87_r,
764                                          filt0, filt1, filt2, filt3);
765             out2_r = FILT_8TAP_DPADD_S_H(src32_r, src54_r, src76_r, src98_r,
766                                          filt0, filt1, filt2, filt3);
767             out3_r = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r,
768                                          filt0, filt1, filt2, filt3);
769             out0_l = FILT_8TAP_DPADD_S_H(src10_l, src32_l, src54_l, src76_l,
770                                          filt0, filt1, filt2, filt3);
771             out1_l = FILT_8TAP_DPADD_S_H(src21_l, src43_l, src65_l, src87_l,
772                                          filt0, filt1, filt2, filt3);
773             out2_l = FILT_8TAP_DPADD_S_H(src32_l, src54_l, src76_l, src98_l,
774                                          filt0, filt1, filt2, filt3);
775             out3_l = FILT_8TAP_DPADD_S_H(src43_l, src65_l, src87_l, src109_l,
776                                          filt0, filt1, filt2, filt3);
777             SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 7);
778             SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 7);
779             SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
780             SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
781             PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
782                         out3_r, tmp0, tmp1, tmp2, tmp3);
783             XORI_B4_128_UB(tmp0, tmp1, tmp2, tmp3);
784             ST_UB4(tmp0, tmp1, tmp2, tmp3, dst_tmp, dst_stride);
785             dst_tmp += (4 * dst_stride);
786
787             src10_r = src54_r;
788             src32_r = src76_r;
789             src54_r = src98_r;
790             src21_r = src65_r;
791             src43_r = src87_r;
792             src65_r = src109_r;
793             src10_l = src54_l;
794             src32_l = src76_l;
795             src54_l = src98_l;
796             src21_l = src65_l;
797             src43_l = src87_l;
798             src65_l = src109_l;
799             src6 = src10;
800         }
801
802         src += 16;
803         dst += 16;
804     }
805 }
806
807 static void common_vt_8t_32w_msa(const uint8_t *src, int32_t src_stride,
808                                  uint8_t *dst, int32_t dst_stride,
809                                  const int8_t *filter, int32_t height)
810 {
811     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
812                               32);
813 }
814
815 static void common_vt_8t_64w_msa(const uint8_t *src, int32_t src_stride,
816                                  uint8_t *dst, int32_t dst_stride,
817                                  const int8_t *filter, int32_t height)
818 {
819     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
820                               64);
821 }
822
823 static void common_hv_8ht_8vt_4w_msa(const uint8_t *src, int32_t src_stride,
824                                      uint8_t *dst, int32_t dst_stride,
825                                      const int8_t *filter_horiz,
826                                      const int8_t *filter_vert,
827                                      int32_t height)
828 {
829     uint32_t loop_cnt;
830     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
831     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
832     v16u8 mask0, mask1, mask2, mask3, out;
833     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
834     v8i16 hz_out7, hz_out8, hz_out9, tmp0, tmp1, out0, out1, out2, out3, out4;
835     v8i16 filt, filt_vt0, filt_vt1, filt_vt2, filt_vt3;
836
837     mask0 = LD_UB(&mc_filt_mask_arr[16]);
838     src -= (3 + 3 * src_stride);
839
840     /* rearranging filter */
841     filt = LD_SH(filter_horiz);
842     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt_hz0, filt_hz1, filt_hz2, filt_hz3);
843
844     mask1 = mask0 + 2;
845     mask2 = mask0 + 4;
846     mask3 = mask0 + 6;
847
848     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
849     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
850     src += (7 * src_stride);
851
852     hz_out0 = HORIZ_8TAP_FILT(src0, src1, mask0, mask1, mask2, mask3, filt_hz0,
853                               filt_hz1, filt_hz2, filt_hz3);
854     hz_out2 = HORIZ_8TAP_FILT(src2, src3, mask0, mask1, mask2, mask3, filt_hz0,
855                               filt_hz1, filt_hz2, filt_hz3);
856     hz_out4 = HORIZ_8TAP_FILT(src4, src5, mask0, mask1, mask2, mask3, filt_hz0,
857                               filt_hz1, filt_hz2, filt_hz3);
858     hz_out5 = HORIZ_8TAP_FILT(src5, src6, mask0, mask1, mask2, mask3, filt_hz0,
859                               filt_hz1, filt_hz2, filt_hz3);
860     SLDI_B2_SH(hz_out2, hz_out4, hz_out0, hz_out2, hz_out1, hz_out3, 8);
861
862     filt = LD_SH(filter_vert);
863     SPLATI_H4_SH(filt, 0, 1, 2, 3, filt_vt0, filt_vt1, filt_vt2, filt_vt3);
864
865     ILVEV_B2_SH(hz_out0, hz_out1, hz_out2, hz_out3, out0, out1);
866     out2 = (v8i16) __msa_ilvev_b((v16i8) hz_out5, (v16i8) hz_out4);
867
868     for (loop_cnt = (height >> 2); loop_cnt--;) {
869         LD_SB4(src, src_stride, src7, src8, src9, src10);
870         XORI_B4_128_SB(src7, src8, src9, src10);
871         src += (4 * src_stride);
872
873         hz_out7 = HORIZ_8TAP_FILT(src7, src8, mask0, mask1, mask2, mask3,
874                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
875         hz_out6 = (v8i16) __msa_sldi_b((v16i8) hz_out7, (v16i8) hz_out5, 8);
876         out3 = (v8i16) __msa_ilvev_b((v16i8) hz_out7, (v16i8) hz_out6);
877         tmp0 = FILT_8TAP_DPADD_S_H(out0, out1, out2, out3, filt_vt0, filt_vt1,
878                                    filt_vt2, filt_vt3);
879
880         hz_out9 = HORIZ_8TAP_FILT(src9, src10, mask0, mask1, mask2, mask3,
881                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
882         hz_out8 = (v8i16) __msa_sldi_b((v16i8) hz_out9, (v16i8) hz_out7, 8);
883         out4 = (v8i16) __msa_ilvev_b((v16i8) hz_out9, (v16i8) hz_out8);
884         tmp1 = FILT_8TAP_DPADD_S_H(out1, out2, out3, out4, filt_vt0, filt_vt1,
885                                    filt_vt2, filt_vt3);
886         SRARI_H2_SH(tmp0, tmp1, 7);
887         SAT_SH2_SH(tmp0, tmp1, 7);
888         out = PCKEV_XORI128_UB(tmp0, tmp1);
889         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
890         dst += (4 * dst_stride);
891
892         hz_out5 = hz_out9;
893         out0 = out2;
894         out1 = out3;
895         out2 = out4;
896     }
897 }
898
899 static void common_hv_8ht_8vt_8w_msa(const uint8_t *src, int32_t src_stride,
900                                      uint8_t *dst, int32_t dst_stride,
901                                      const int8_t *filter_horiz,
902                                      const int8_t *filter_vert,
903                                      int32_t height)
904 {
905     uint32_t loop_cnt;
906     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
907     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
908     v16u8 mask0, mask1, mask2, mask3, vec0, vec1;
909     v8i16 filt, filt_vt0, filt_vt1, filt_vt2, filt_vt3;
910     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
911     v8i16 hz_out7, hz_out8, hz_out9, hz_out10, tmp0, tmp1, tmp2, tmp3;
912     v8i16 out0, out1, out2, out3, out4, out5, out6, out7, out8, out9;
913
914     mask0 = LD_UB(&mc_filt_mask_arr[0]);
915     src -= (3 + 3 * src_stride);
916
917     /* rearranging filter */
918     filt = LD_SH(filter_horiz);
919     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt_hz0, filt_hz1, filt_hz2, filt_hz3);
920
921     mask1 = mask0 + 2;
922     mask2 = mask0 + 4;
923     mask3 = mask0 + 6;
924
925     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
926     src += (7 * src_stride);
927
928     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
929     hz_out0 = HORIZ_8TAP_FILT(src0, src0, mask0, mask1, mask2, mask3, filt_hz0,
930                               filt_hz1, filt_hz2, filt_hz3);
931     hz_out1 = HORIZ_8TAP_FILT(src1, src1, mask0, mask1, mask2, mask3, filt_hz0,
932                               filt_hz1, filt_hz2, filt_hz3);
933     hz_out2 = HORIZ_8TAP_FILT(src2, src2, mask0, mask1, mask2, mask3, filt_hz0,
934                               filt_hz1, filt_hz2, filt_hz3);
935     hz_out3 = HORIZ_8TAP_FILT(src3, src3, mask0, mask1, mask2, mask3, filt_hz0,
936                               filt_hz1, filt_hz2, filt_hz3);
937     hz_out4 = HORIZ_8TAP_FILT(src4, src4, mask0, mask1, mask2, mask3, filt_hz0,
938                               filt_hz1, filt_hz2, filt_hz3);
939     hz_out5 = HORIZ_8TAP_FILT(src5, src5, mask0, mask1, mask2, mask3, filt_hz0,
940                               filt_hz1, filt_hz2, filt_hz3);
941     hz_out6 = HORIZ_8TAP_FILT(src6, src6, mask0, mask1, mask2, mask3, filt_hz0,
942                               filt_hz1, filt_hz2, filt_hz3);
943
944     filt = LD_SH(filter_vert);
945     SPLATI_H4_SH(filt, 0, 1, 2, 3, filt_vt0, filt_vt1, filt_vt2, filt_vt3);
946
947     ILVEV_B2_SH(hz_out0, hz_out1, hz_out2, hz_out3, out0, out1);
948     ILVEV_B2_SH(hz_out4, hz_out5, hz_out1, hz_out2, out2, out4);
949     ILVEV_B2_SH(hz_out3, hz_out4, hz_out5, hz_out6, out5, out6);
950
951     for (loop_cnt = (height >> 2); loop_cnt--;) {
952         LD_SB4(src, src_stride, src7, src8, src9, src10);
953         src += (4 * src_stride);
954
955         XORI_B4_128_SB(src7, src8, src9, src10);
956
957         hz_out7 = HORIZ_8TAP_FILT(src7, src7, mask0, mask1, mask2, mask3,
958                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
959         out3 = (v8i16) __msa_ilvev_b((v16i8) hz_out7, (v16i8) hz_out6);
960         tmp0 = FILT_8TAP_DPADD_S_H(out0, out1, out2, out3, filt_vt0, filt_vt1,
961                                    filt_vt2, filt_vt3);
962
963         hz_out8 = HORIZ_8TAP_FILT(src8, src8, mask0, mask1, mask2, mask3,
964                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
965         out7 = (v8i16) __msa_ilvev_b((v16i8) hz_out8, (v16i8) hz_out7);
966         tmp1 = FILT_8TAP_DPADD_S_H(out4, out5, out6, out7, filt_vt0, filt_vt1,
967                                    filt_vt2, filt_vt3);
968
969         hz_out9 = HORIZ_8TAP_FILT(src9, src9, mask0, mask1, mask2, mask3,
970                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
971         out8 = (v8i16) __msa_ilvev_b((v16i8) hz_out9, (v16i8) hz_out8);
972         tmp2 = FILT_8TAP_DPADD_S_H(out1, out2, out3, out8, filt_vt0,
973                                    filt_vt1, filt_vt2, filt_vt3);
974
975         hz_out10 = HORIZ_8TAP_FILT(src10, src10, mask0, mask1, mask2, mask3,
976                                    filt_hz0, filt_hz1, filt_hz2, filt_hz3);
977         out9 = (v8i16) __msa_ilvev_b((v16i8) hz_out10, (v16i8) hz_out9);
978         tmp3 = FILT_8TAP_DPADD_S_H(out5, out6, out7, out9, filt_vt0, filt_vt1,
979                                    filt_vt2, filt_vt3);
980         SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
981         SAT_SH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
982         vec0 = PCKEV_XORI128_UB(tmp0, tmp1);
983         vec1 = PCKEV_XORI128_UB(tmp2, tmp3);
984         ST8x4_UB(vec0, vec1, dst, dst_stride);
985         dst += (4 * dst_stride);
986
987         hz_out6 = hz_out10;
988         out0 = out2;
989         out1 = out3;
990         out2 = out8;
991         out4 = out6;
992         out5 = out7;
993         out6 = out9;
994     }
995 }
996
997 static void common_hv_8ht_8vt_16w_msa(const uint8_t *src, int32_t src_stride,
998                                       uint8_t *dst, int32_t dst_stride,
999                                       const int8_t *filter_horiz,
1000                                       const int8_t *filter_vert,
1001                                       int32_t height)
1002 {
1003     int32_t multiple8_cnt;
1004
1005     for (multiple8_cnt = 2; multiple8_cnt--;) {
1006         common_hv_8ht_8vt_8w_msa(src, src_stride, dst, dst_stride, filter_horiz,
1007                                  filter_vert, height);
1008
1009         src += 8;
1010         dst += 8;
1011     }
1012 }
1013
1014 static void common_hv_8ht_8vt_32w_msa(const uint8_t *src, int32_t src_stride,
1015                                       uint8_t *dst, int32_t dst_stride,
1016                                       const int8_t *filter_horiz,
1017                                       const int8_t *filter_vert,
1018                                       int32_t height)
1019 {
1020     int32_t multiple8_cnt;
1021
1022     for (multiple8_cnt = 4; multiple8_cnt--;) {
1023         common_hv_8ht_8vt_8w_msa(src, src_stride, dst, dst_stride, filter_horiz,
1024                                  filter_vert, height);
1025
1026         src += 8;
1027         dst += 8;
1028     }
1029 }
1030
1031 static void common_hv_8ht_8vt_64w_msa(const uint8_t *src, int32_t src_stride,
1032                                       uint8_t *dst, int32_t dst_stride,
1033                                       const int8_t *filter_horiz,
1034                                       const int8_t *filter_vert,
1035                                       int32_t height)
1036 {
1037     int32_t multiple8_cnt;
1038
1039     for (multiple8_cnt = 8; multiple8_cnt--;) {
1040         common_hv_8ht_8vt_8w_msa(src, src_stride, dst, dst_stride, filter_horiz,
1041                                  filter_vert, height);
1042
1043         src += 8;
1044         dst += 8;
1045     }
1046 }
1047
1048 static void common_hz_8t_and_aver_dst_4x4_msa(const uint8_t *src,
1049                                               int32_t src_stride,
1050                                               uint8_t *dst, int32_t dst_stride,
1051                                               const int8_t *filter)
1052 {
1053     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1054     v16u8 dst0, dst1, dst2, dst3, res2, res3;
1055     v16u8 mask0, mask1, mask2, mask3;
1056     v8i16 filt, res0, res1;
1057
1058     mask0 = LD_UB(&mc_filt_mask_arr[16]);
1059     src -= 3;
1060
1061     /* rearranging filter */
1062     filt = LD_SH(filter);
1063     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1064
1065     mask1 = mask0 + 2;
1066     mask2 = mask0 + 4;
1067     mask3 = mask0 + 6;
1068
1069     LD_SB4(src, src_stride, src0, src1, src2, src3);
1070     XORI_B4_128_SB(src0, src1, src2, src3);
1071     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
1072                                mask3, filt0, filt1, filt2, filt3, res0, res1);
1073     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1074     SRARI_H2_SH(res0, res1, 7);
1075     SAT_SH2_SH(res0, res1, 7);
1076     PCKEV_B2_UB(res0, res0, res1, res1, res2, res3);
1077     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
1078     XORI_B2_128_UB(res2, res3);
1079     AVER_UB2_UB(res2, dst0, res3, dst2, res2, res3);
1080     ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
1081 }
1082
1083 static void common_hz_8t_and_aver_dst_4x8_msa(const uint8_t *src,
1084                                               int32_t src_stride,
1085                                               uint8_t *dst, int32_t dst_stride,
1086                                               const int8_t *filter)
1087 {
1088     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1089     v16u8 mask0, mask1, mask2, mask3, res0, res1, res2, res3;
1090     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1091     v8i16 filt, vec0, vec1, vec2, vec3;
1092
1093     mask0 = LD_UB(&mc_filt_mask_arr[16]);
1094     src -= 3;
1095
1096     /* rearranging filter */
1097     filt = LD_SH(filter);
1098     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1099
1100     mask1 = mask0 + 2;
1101     mask2 = mask0 + 4;
1102     mask3 = mask0 + 6;
1103
1104     LD_SB4(src, src_stride, src0, src1, src2, src3);
1105     XORI_B4_128_SB(src0, src1, src2, src3);
1106     src += (4 * src_stride);
1107     LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
1108     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
1109                                mask3, filt0, filt1, filt2, filt3, vec0, vec1);
1110     LD_SB4(src, src_stride, src0, src1, src2, src3);
1111     XORI_B4_128_SB(src0, src1, src2, src3);
1112     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
1113                                mask3, filt0, filt1, filt2, filt3, vec2, vec3);
1114     SRARI_H4_SH(vec0, vec1, vec2, vec3, 7);
1115     SAT_SH4_SH(vec0, vec1, vec2, vec3, 7);
1116     PCKEV_B4_UB(vec0, vec0, vec1, vec1, vec2, vec2, vec3, vec3,
1117                 res0, res1, res2, res3);
1118     ILVR_D2_UB(res1, res0, res3, res2, res0, res2);
1119     XORI_B2_128_UB(res0, res2);
1120     ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6,
1121                dst0, dst2, dst4, dst6);
1122     ILVR_D2_UB(dst2, dst0, dst6, dst4, dst0, dst4);
1123     AVER_UB2_UB(res0, dst0, res2, dst4, res0, res2);
1124     ST4x8_UB(res0, res2, dst, dst_stride);
1125 }
1126
1127 static void common_hz_8t_and_aver_dst_4w_msa(const uint8_t *src,
1128                                              int32_t src_stride,
1129                                              uint8_t *dst, int32_t dst_stride,
1130                                              const int8_t *filter,
1131                                              int32_t height)
1132 {
1133     if (4 == height) {
1134         common_hz_8t_and_aver_dst_4x4_msa(src, src_stride, dst, dst_stride,
1135                                           filter);
1136     } else if (8 == height) {
1137         common_hz_8t_and_aver_dst_4x8_msa(src, src_stride, dst, dst_stride,
1138                                           filter);
1139     }
1140 }
1141
1142 static void common_hz_8t_and_aver_dst_8w_msa(const uint8_t *src,
1143                                              int32_t src_stride,
1144                                              uint8_t *dst, int32_t dst_stride,
1145                                              const int8_t *filter,
1146                                              int32_t height)
1147 {
1148     int32_t loop_cnt;
1149     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1150     v16u8 mask0, mask1, mask2, mask3, dst0, dst1, dst2, dst3;
1151     v8i16 filt, out0, out1, out2, out3;
1152
1153     mask0 = LD_UB(&mc_filt_mask_arr[0]);
1154     src -= 3;
1155
1156     /* rearranging filter */
1157     filt = LD_SH(filter);
1158     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1159
1160     mask1 = mask0 + 2;
1161     mask2 = mask0 + 4;
1162     mask3 = mask0 + 6;
1163
1164     for (loop_cnt = (height >> 2); loop_cnt--;) {
1165         LD_SB4(src, src_stride, src0, src1, src2, src3);
1166         XORI_B4_128_SB(src0, src1, src2, src3);
1167         src += (4 * src_stride);
1168         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
1169                                    mask3, filt0, filt1, filt2, filt3, out0,
1170                                    out1, out2, out3);
1171         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1172         SRARI_H4_SH(out0, out1, out2, out3, 7);
1173         SAT_SH4_SH(out0, out1, out2, out3, 7);
1174         CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
1175                                 dst, dst_stride);
1176         dst += (4 * dst_stride);
1177     }
1178 }
1179
1180 static void common_hz_8t_and_aver_dst_16w_msa(const uint8_t *src,
1181                                               int32_t src_stride,
1182                                               uint8_t *dst, int32_t dst_stride,
1183                                               const int8_t *filter,
1184                                               int32_t height)
1185 {
1186     int32_t loop_cnt;
1187     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1188     v16u8 mask0, mask1, mask2, mask3, dst0, dst1;
1189     v8i16 filt, out0, out1, out2, out3;
1190     v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1191     v8i16 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1192
1193     mask0 = LD_UB(&mc_filt_mask_arr[0]);
1194     src -= 3;
1195
1196     /* rearranging filter */
1197     filt = LD_SH(filter);
1198     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1199
1200     mask1 = mask0 + 2;
1201     mask2 = mask0 + 4;
1202     mask3 = mask0 + 6;
1203
1204     for (loop_cnt = height >> 1; loop_cnt--;) {
1205         LD_SB2(src, src_stride, src0, src2);
1206         LD_SB2(src + 8, src_stride, src1, src3);
1207         src += (2 * src_stride);
1208
1209         XORI_B4_128_SB(src0, src1, src2, src3);
1210         VSHF_B4_SH(src0, src0, mask0, mask1, mask2, mask3, vec0, vec4, vec8,
1211                    vec12);
1212         VSHF_B4_SH(src1, src1, mask0, mask1, mask2, mask3, vec1, vec5, vec9,
1213                    vec13);
1214         VSHF_B4_SH(src2, src2, mask0, mask1, mask2, mask3, vec2, vec6, vec10,
1215                    vec14);
1216         VSHF_B4_SH(src3, src3, mask0, mask1, mask2, mask3, vec3, vec7, vec11,
1217                    vec15);
1218         DOTP_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
1219                     vec1, vec2, vec3);
1220         DOTP_SB4_SH(vec8, vec9, vec10, vec11, filt2, filt2, filt2, filt2, vec8,
1221                     vec9, vec10, vec11);
1222         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1, vec0,
1223                      vec1, vec2, vec3);
1224         DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt3, filt3, filt3, filt3,
1225                      vec8, vec9, vec10, vec11);
1226         ADDS_SH4_SH(vec0, vec8, vec1, vec9, vec2, vec10, vec3, vec11, out0,
1227                     out1, out2, out3);
1228         LD_UB2(dst, dst_stride, dst0, dst1);
1229         SRARI_H4_SH(out0, out1, out2, out3, 7);
1230         SAT_SH4_SH(out0, out1, out2, out3, 7);
1231         PCKEV_XORI128_AVG_ST_UB(out1, out0, dst0, dst);
1232         dst += dst_stride;
1233         PCKEV_XORI128_AVG_ST_UB(out3, out2, dst1, dst);
1234         dst += dst_stride;
1235     }
1236 }
1237
1238 static void common_hz_8t_and_aver_dst_32w_msa(const uint8_t *src,
1239                                               int32_t src_stride,
1240                                               uint8_t *dst, int32_t dst_stride,
1241                                               const int8_t *filter,
1242                                               int32_t height)
1243 {
1244     uint32_t loop_cnt;
1245     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1246     v16u8 dst1, dst2, mask0, mask1, mask2, mask3;
1247     v8i16 filt, out0, out1, out2, out3;
1248     v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1249     v8i16 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1250
1251     mask0 = LD_UB(&mc_filt_mask_arr[0]);
1252     src -= 3;
1253
1254     /* rearranging filter */
1255     filt = LD_SH(filter);
1256     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1257
1258     mask1 = mask0 + 2;
1259     mask2 = mask0 + 4;
1260     mask3 = mask0 + 6;
1261
1262     for (loop_cnt = height; loop_cnt--;) {
1263         src0 = LD_SB(src);
1264         src2 = LD_SB(src + 16);
1265         src3 = LD_SB(src + 24);
1266         src1 = __msa_sldi_b(src2, src0, 8);
1267         src += src_stride;
1268
1269         XORI_B4_128_SB(src0, src1, src2, src3);
1270         VSHF_B4_SH(src0, src0, mask0, mask1, mask2, mask3, vec0, vec4, vec8,
1271                    vec12);
1272         VSHF_B4_SH(src1, src1, mask0, mask1, mask2, mask3, vec1, vec5, vec9,
1273                    vec13);
1274         VSHF_B4_SH(src2, src2, mask0, mask1, mask2, mask3, vec2, vec6, vec10,
1275                    vec14);
1276         VSHF_B4_SH(src3, src3, mask0, mask1, mask2, mask3, vec3, vec7, vec11,
1277                    vec15);
1278         DOTP_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
1279                     vec1, vec2, vec3);
1280         DOTP_SB4_SH(vec8, vec9, vec10, vec11, filt2, filt2, filt2, filt2, vec8,
1281                     vec9, vec10, vec11);
1282         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1, vec0,
1283                      vec1, vec2, vec3);
1284         DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt3, filt3, filt3, filt3,
1285                      vec8, vec9, vec10, vec11);
1286         ADDS_SH4_SH(vec0, vec8, vec1, vec9, vec2, vec10, vec3, vec11, out0,
1287                     out1, out2, out3);
1288         SRARI_H4_SH(out0, out1, out2, out3, 7);
1289         SAT_SH4_SH(out0, out1, out2, out3, 7);
1290         LD_UB2(dst, 16, dst1, dst2);
1291         PCKEV_XORI128_AVG_ST_UB(out1, out0, dst1, dst);
1292         PCKEV_XORI128_AVG_ST_UB(out3, out2, dst2, dst + 16);
1293         dst += dst_stride;
1294     }
1295 }
1296
1297 static void common_hz_8t_and_aver_dst_64w_msa(const uint8_t *src,
1298                                               int32_t src_stride,
1299                                               uint8_t *dst, int32_t dst_stride,
1300                                               const int8_t *filter,
1301                                               int32_t height)
1302 {
1303     uint32_t loop_cnt, cnt;
1304     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
1305     v16u8 dst1, dst2, mask0, mask1, mask2, mask3;
1306     v8i16 filt, out0, out1, out2, out3;
1307     v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1308     v8i16 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1309
1310     mask0 = LD_UB(&mc_filt_mask_arr[0]);
1311     src -= 3;
1312
1313     /* rearranging filter */
1314     filt = LD_SH(filter);
1315     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1316
1317     mask1 = mask0 + 2;
1318     mask2 = mask0 + 4;
1319     mask3 = mask0 + 6;
1320
1321     for (loop_cnt = height; loop_cnt--;) {
1322         for (cnt = 0; cnt < 2; ++cnt) {
1323             src0 = LD_SB(&src[cnt << 5]);
1324             src2 = LD_SB(&src[16 + (cnt << 5)]);
1325             src3 = LD_SB(&src[24 + (cnt << 5)]);
1326             src1 = __msa_sldi_b(src2, src0, 8);
1327
1328             XORI_B4_128_SB(src0, src1, src2, src3);
1329             VSHF_B4_SH(src0, src0, mask0, mask1, mask2, mask3, vec0, vec4, vec8,
1330                        vec12);
1331             VSHF_B4_SH(src1, src1, mask0, mask1, mask2, mask3, vec1, vec5, vec9,
1332                        vec13);
1333             VSHF_B4_SH(src2, src2, mask0, mask1, mask2, mask3, vec2, vec6,
1334                        vec10, vec14);
1335             VSHF_B4_SH(src3, src3, mask0, mask1, mask2, mask3, vec3, vec7,
1336                        vec11, vec15);
1337             DOTP_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1338                         vec0, vec1, vec2, vec3);
1339             DOTP_SB4_SH(vec8, vec9, vec10, vec11, filt2, filt2, filt2, filt2,
1340                         vec8, vec9, vec10, vec11);
1341             DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1,
1342                          vec0, vec1, vec2, vec3);
1343             DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt3, filt3, filt3, filt3,
1344                          vec8, vec9, vec10, vec11);
1345             ADDS_SH4_SH(vec0, vec8, vec1, vec9, vec2, vec10, vec3, vec11, out0,
1346                         out1, out2, out3);
1347             SRARI_H4_SH(out0, out1, out2, out3, 7);
1348             SAT_SH4_SH(out0, out1, out2, out3, 7);
1349             LD_UB2(&dst[cnt << 5], 16, dst1, dst2);
1350             PCKEV_XORI128_AVG_ST_UB(out1, out0, dst1, &dst[cnt << 5]);
1351             PCKEV_XORI128_AVG_ST_UB(out3, out2, dst2, &dst[16 + (cnt << 5)]);
1352         }
1353
1354         src += src_stride;
1355         dst += dst_stride;
1356     }
1357 }
1358
1359 static void common_vt_8t_and_aver_dst_4w_msa(const uint8_t *src,
1360                                              int32_t src_stride,
1361                                              uint8_t *dst, int32_t dst_stride,
1362                                              const int8_t *filter,
1363                                              int32_t height)
1364 {
1365     uint32_t loop_cnt;
1366     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1367     v16u8 dst0, dst1, dst2, dst3, out;
1368     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
1369     v16i8 src65_r, src87_r, src109_r, src2110, src4332, src6554, src8776;
1370     v16i8 src10998, filt0, filt1, filt2, filt3;
1371     v8i16 filt, out10, out32;
1372
1373     src -= (3 * src_stride);
1374
1375     filt = LD_SH(filter);
1376     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1377
1378     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
1379     src += (7 * src_stride);
1380
1381     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r, src32_r,
1382                src54_r, src21_r);
1383     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1384     ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r, src2110,
1385                src4332, src6554);
1386     XORI_B3_128_SB(src2110, src4332, src6554);
1387
1388     for (loop_cnt = (height >> 2); loop_cnt--;) {
1389         LD_SB4(src, src_stride, src7, src8, src9, src10);
1390         src += (4 * src_stride);
1391
1392         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1393         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
1394                    src87_r, src98_r, src109_r);
1395         ILVR_D2_SB(src87_r, src76_r, src109_r, src98_r, src8776, src10998);
1396         XORI_B2_128_SB(src8776, src10998);
1397         out10 = FILT_8TAP_DPADD_S_H(src2110, src4332, src6554, src8776, filt0,
1398                                     filt1, filt2, filt3);
1399         out32 = FILT_8TAP_DPADD_S_H(src4332, src6554, src8776, src10998, filt0,
1400                                     filt1, filt2, filt3);
1401         SRARI_H2_SH(out10, out32, 7);
1402         SAT_SH2_SH(out10, out32, 7);
1403         out = PCKEV_XORI128_UB(out10, out32);
1404         ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
1405
1406         dst0 = (v16u8) __msa_ilvr_d((v2i64) dst2, (v2i64) dst0);
1407         out = __msa_aver_u_b(out, dst0);
1408
1409         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
1410         dst += (4 * dst_stride);
1411
1412         src2110 = src6554;
1413         src4332 = src8776;
1414         src6554 = src10998;
1415         src6 = src10;
1416     }
1417 }
1418
1419 static void common_vt_8t_and_aver_dst_8w_msa(const uint8_t *src,
1420                                              int32_t src_stride,
1421                                              uint8_t *dst, int32_t dst_stride,
1422                                              const int8_t *filter,
1423                                              int32_t height)
1424 {
1425     uint32_t loop_cnt;
1426     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1427     v16u8 dst0, dst1, dst2, dst3;
1428     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
1429     v16i8 src65_r, src87_r, src109_r, filt0, filt1, filt2, filt3;
1430     v8i16 filt, out0, out1, out2, out3;
1431
1432     src -= (3 * src_stride);
1433
1434     filt = LD_SH(filter);
1435     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1436
1437     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
1438     src += (7 * src_stride);
1439
1440     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1441     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r, src32_r,
1442                src54_r, src21_r);
1443     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1444
1445     for (loop_cnt = (height >> 2); loop_cnt--;) {
1446         LD_SB4(src, src_stride, src7, src8, src9, src10);
1447         src += (4 * src_stride);
1448
1449         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1450         XORI_B4_128_SB(src7, src8, src9, src10);
1451         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
1452                    src87_r, src98_r, src109_r);
1453         out0 = FILT_8TAP_DPADD_S_H(src10_r, src32_r, src54_r, src76_r, filt0,
1454                                    filt1, filt2, filt3);
1455         out1 = FILT_8TAP_DPADD_S_H(src21_r, src43_r, src65_r, src87_r, filt0,
1456                                    filt1, filt2, filt3);
1457         out2 = FILT_8TAP_DPADD_S_H(src32_r, src54_r, src76_r, src98_r, filt0,
1458                                    filt1, filt2, filt3);
1459         out3 = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r, filt0,
1460                                    filt1, filt2, filt3);
1461         SRARI_H4_SH(out0, out1, out2, out3, 7);
1462         SAT_SH4_SH(out0, out1, out2, out3, 7);
1463         CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
1464                                 dst, dst_stride);
1465         dst += (4 * dst_stride);
1466
1467         src10_r = src54_r;
1468         src32_r = src76_r;
1469         src54_r = src98_r;
1470         src21_r = src65_r;
1471         src43_r = src87_r;
1472         src65_r = src109_r;
1473         src6 = src10;
1474     }
1475 }
1476
1477 static void common_vt_8t_and_aver_dst_16w_mult_msa(const uint8_t *src,
1478                                                    int32_t src_stride,
1479                                                    uint8_t *dst,
1480                                                    int32_t dst_stride,
1481                                                    const int8_t *filter,
1482                                                    int32_t height,
1483                                                    int32_t width)
1484 {
1485     const uint8_t *src_tmp;
1486     uint8_t *dst_tmp;
1487     uint32_t loop_cnt, cnt;
1488     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1489     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
1490     v16i8 src65_r, src87_r, src109_r, src10_l, src32_l, src54_l, src76_l;
1491     v16i8 src98_l, src21_l, src43_l, src65_l, src87_l, src109_l;
1492     v16i8 filt0, filt1, filt2, filt3;
1493     v16u8 dst0, dst1, dst2, dst3, tmp0, tmp1, tmp2, tmp3;
1494     v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l, filt;
1495
1496     src -= (3 * src_stride);
1497
1498     filt = LD_SH(filter);
1499     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1500
1501     for (cnt = (width >> 4); cnt--;) {
1502         src_tmp = src;
1503         dst_tmp = dst;
1504
1505         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
1506         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1507         src_tmp += (7 * src_stride);
1508
1509         ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_r,
1510                    src32_r, src54_r, src21_r);
1511         ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1512         ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1, src10_l,
1513                    src32_l, src54_l, src21_l);
1514         ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1515
1516         for (loop_cnt = (height >> 2); loop_cnt--;) {
1517             LD_SB4(src_tmp, src_stride, src7, src8, src9, src10);
1518             src_tmp += (4 * src_stride);
1519
1520             LD_UB4(dst_tmp, dst_stride, dst0, dst1, dst2, dst3);
1521             XORI_B4_128_SB(src7, src8, src9, src10);
1522             ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
1523                        src87_r, src98_r, src109_r);
1524             ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_l,
1525                        src87_l, src98_l, src109_l);
1526             out0_r = FILT_8TAP_DPADD_S_H(src10_r, src32_r, src54_r, src76_r,
1527                                          filt0, filt1, filt2, filt3);
1528             out1_r = FILT_8TAP_DPADD_S_H(src21_r, src43_r, src65_r, src87_r,
1529                                          filt0, filt1, filt2, filt3);
1530             out2_r = FILT_8TAP_DPADD_S_H(src32_r, src54_r, src76_r, src98_r,
1531                                          filt0, filt1, filt2, filt3);
1532             out3_r = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r,
1533                                          filt0, filt1, filt2, filt3);
1534             out0_l = FILT_8TAP_DPADD_S_H(src10_l, src32_l, src54_l, src76_l,
1535                                          filt0, filt1, filt2, filt3);
1536             out1_l = FILT_8TAP_DPADD_S_H(src21_l, src43_l, src65_l, src87_l,
1537                                          filt0, filt1, filt2, filt3);
1538             out2_l = FILT_8TAP_DPADD_S_H(src32_l, src54_l, src76_l, src98_l,
1539                                          filt0, filt1, filt2, filt3);
1540             out3_l = FILT_8TAP_DPADD_S_H(src43_l, src65_l, src87_l, src109_l,
1541                                          filt0, filt1, filt2, filt3);
1542             SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 7);
1543             SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 7);
1544             SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
1545             SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
1546             PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
1547                         out3_r, tmp0, tmp1, tmp2, tmp3);
1548             XORI_B4_128_UB(tmp0, tmp1, tmp2, tmp3);
1549             AVER_UB4_UB(tmp0, dst0, tmp1, dst1, tmp2, dst2, tmp3, dst3,
1550                         dst0, dst1, dst2, dst3);
1551             ST_UB4(dst0, dst1, dst2, dst3, dst_tmp, dst_stride);
1552             dst_tmp += (4 * dst_stride);
1553
1554             src10_r = src54_r;
1555             src32_r = src76_r;
1556             src54_r = src98_r;
1557             src21_r = src65_r;
1558             src43_r = src87_r;
1559             src65_r = src109_r;
1560             src10_l = src54_l;
1561             src32_l = src76_l;
1562             src54_l = src98_l;
1563             src21_l = src65_l;
1564             src43_l = src87_l;
1565             src65_l = src109_l;
1566             src6 = src10;
1567         }
1568
1569         src += 16;
1570         dst += 16;
1571     }
1572 }
1573
1574 static void common_vt_8t_and_aver_dst_16w_msa(const uint8_t *src,
1575                                               int32_t src_stride,
1576                                               uint8_t *dst, int32_t dst_stride,
1577                                               const int8_t *filter,
1578                                               int32_t height)
1579 {
1580     common_vt_8t_and_aver_dst_16w_mult_msa(src, src_stride, dst, dst_stride,
1581                                            filter, height, 16);
1582 }
1583
1584 static void common_vt_8t_and_aver_dst_32w_msa(const uint8_t *src,
1585                                               int32_t src_stride,
1586                                               uint8_t *dst, int32_t dst_stride,
1587                                               const int8_t *filter,
1588                                               int32_t height)
1589 {
1590     common_vt_8t_and_aver_dst_16w_mult_msa(src, src_stride, dst, dst_stride,
1591                                            filter, height, 32);
1592 }
1593
1594 static void common_vt_8t_and_aver_dst_64w_msa(const uint8_t *src,
1595                                               int32_t src_stride,
1596                                               uint8_t *dst, int32_t dst_stride,
1597                                               const int8_t *filter,
1598                                               int32_t height)
1599 {
1600     common_vt_8t_and_aver_dst_16w_mult_msa(src, src_stride, dst, dst_stride,
1601                                            filter, height, 64);
1602 }
1603
1604 static void common_hv_8ht_8vt_and_aver_dst_4w_msa(const uint8_t *src,
1605                                                   int32_t src_stride,
1606                                                   uint8_t *dst,
1607                                                   int32_t dst_stride,
1608                                                   const int8_t *filter_horiz,
1609                                                   const int8_t *filter_vert,
1610                                                   int32_t height)
1611 {
1612     uint32_t loop_cnt;
1613     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1614     v16u8 dst0, dst1, dst2, dst3, mask0, mask1, mask2, mask3, tmp0, tmp1;
1615     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
1616     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
1617     v8i16 hz_out7, hz_out8, hz_out9, res0, res1, vec0, vec1, vec2, vec3, vec4;
1618     v8i16 filt, filt_vt0, filt_vt1, filt_vt2, filt_vt3;
1619
1620     mask0 = LD_UB(&mc_filt_mask_arr[16]);
1621     src -= (3 + 3 * src_stride);
1622
1623     /* rearranging filter */
1624     filt = LD_SH(filter_horiz);
1625     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1626
1627     mask1 = mask0 + 2;
1628     mask2 = mask0 + 4;
1629     mask3 = mask0 + 6;
1630
1631     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
1632     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1633     src += (7 * src_stride);
1634
1635     hz_out0 = HORIZ_8TAP_FILT(src0, src1, mask0, mask1, mask2, mask3, filt_hz0,
1636                               filt_hz1, filt_hz2, filt_hz3);
1637     hz_out2 = HORIZ_8TAP_FILT(src2, src3, mask0, mask1, mask2, mask3, filt_hz0,
1638                               filt_hz1, filt_hz2, filt_hz3);
1639     hz_out4 = HORIZ_8TAP_FILT(src4, src5, mask0, mask1, mask2, mask3, filt_hz0,
1640                               filt_hz1, filt_hz2, filt_hz3);
1641     hz_out5 = HORIZ_8TAP_FILT(src5, src6, mask0, mask1, mask2, mask3, filt_hz0,
1642                               filt_hz1, filt_hz2, filt_hz3);
1643     SLDI_B2_SH(hz_out2, hz_out4, hz_out0, hz_out2, hz_out1, hz_out3, 8);
1644
1645     filt = LD_SH(filter_vert);
1646     SPLATI_H4_SH(filt, 0, 1, 2, 3, filt_vt0, filt_vt1, filt_vt2, filt_vt3);
1647
1648     ILVEV_B2_SH(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
1649     vec2 = (v8i16) __msa_ilvev_b((v16i8) hz_out5, (v16i8) hz_out4);
1650
1651     for (loop_cnt = (height >> 2); loop_cnt--;) {
1652         LD_SB4(src, src_stride, src7, src8, src9, src10);
1653         XORI_B4_128_SB(src7, src8, src9, src10);
1654         src += (4 * src_stride);
1655
1656         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1657         hz_out7 = HORIZ_8TAP_FILT(src7, src8, mask0, mask1, mask2, mask3,
1658                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1659         hz_out6 = (v8i16) __msa_sldi_b((v16i8) hz_out7, (v16i8) hz_out5, 8);
1660         vec3 = (v8i16) __msa_ilvev_b((v16i8) hz_out7, (v16i8) hz_out6);
1661         res0 = FILT_8TAP_DPADD_S_H(vec0, vec1, vec2, vec3, filt_vt0, filt_vt1,
1662                                    filt_vt2, filt_vt3);
1663
1664         hz_out9 = HORIZ_8TAP_FILT(src9, src10, mask0, mask1, mask2, mask3,
1665                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1666         hz_out8 = (v8i16) __msa_sldi_b((v16i8) hz_out9, (v16i8) hz_out7, 8);
1667         vec4 = (v8i16) __msa_ilvev_b((v16i8) hz_out9, (v16i8) hz_out8);
1668         res1 = FILT_8TAP_DPADD_S_H(vec1, vec2, vec3, vec4, filt_vt0, filt_vt1,
1669                                    filt_vt2, filt_vt3);
1670         ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
1671
1672         SRARI_H2_SH(res0, res1, 7);
1673         SAT_SH2_SH(res0, res1, 7);
1674         PCKEV_B2_UB(res0, res0, res1, res1, tmp0, tmp1);
1675         XORI_B2_128_UB(tmp0, tmp1);
1676         AVER_UB2_UB(tmp0, dst0, tmp1, dst2, tmp0, tmp1);
1677         ST4x4_UB(tmp0, tmp1, 0, 1, 0, 1, dst, dst_stride);
1678         dst += (4 * dst_stride);
1679
1680         hz_out5 = hz_out9;
1681         vec0 = vec2;
1682         vec1 = vec3;
1683         vec2 = vec4;
1684     }
1685 }
1686
1687 static void common_hv_8ht_8vt_and_aver_dst_8w_msa(const uint8_t *src,
1688                                                   int32_t src_stride,
1689                                                   uint8_t *dst,
1690                                                   int32_t dst_stride,
1691                                                   const int8_t *filter_horiz,
1692                                                   const int8_t *filter_vert,
1693                                                   int32_t height)
1694 {
1695     uint32_t loop_cnt;
1696     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1697     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
1698     v8i16 filt, filt_vt0, filt_vt1, filt_vt2, filt_vt3;
1699     v16u8 dst0, dst1, dst2, dst3, mask0, mask1, mask2, mask3;
1700     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
1701     v8i16 hz_out7, hz_out8, hz_out9, hz_out10, tmp0, tmp1, tmp2, tmp3;
1702     v8i16 out0, out1, out2, out3, out4, out5, out6, out7, out8, out9;
1703
1704     mask0 = LD_UB(&mc_filt_mask_arr[0]);
1705     src -= (3 + 3 * src_stride);
1706
1707     /* rearranging filter */
1708     filt = LD_SH(filter_horiz);
1709     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1710
1711     mask1 = mask0 + 2;
1712     mask2 = mask0 + 4;
1713     mask3 = mask0 + 6;
1714
1715     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
1716     src += (7 * src_stride);
1717
1718     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1719     hz_out0 = HORIZ_8TAP_FILT(src0, src0, mask0, mask1, mask2, mask3, filt_hz0,
1720                               filt_hz1, filt_hz2, filt_hz3);
1721     hz_out1 = HORIZ_8TAP_FILT(src1, src1, mask0, mask1, mask2, mask3, filt_hz0,
1722                               filt_hz1, filt_hz2, filt_hz3);
1723     hz_out2 = HORIZ_8TAP_FILT(src2, src2, mask0, mask1, mask2, mask3, filt_hz0,
1724                               filt_hz1, filt_hz2, filt_hz3);
1725     hz_out3 = HORIZ_8TAP_FILT(src3, src3, mask0, mask1, mask2, mask3, filt_hz0,
1726                               filt_hz1, filt_hz2, filt_hz3);
1727     hz_out4 = HORIZ_8TAP_FILT(src4, src4, mask0, mask1, mask2, mask3, filt_hz0,
1728                               filt_hz1, filt_hz2, filt_hz3);
1729     hz_out5 = HORIZ_8TAP_FILT(src5, src5, mask0, mask1, mask2, mask3, filt_hz0,
1730                               filt_hz1, filt_hz2, filt_hz3);
1731     hz_out6 = HORIZ_8TAP_FILT(src6, src6, mask0, mask1, mask2, mask3, filt_hz0,
1732                               filt_hz1, filt_hz2, filt_hz3);
1733
1734     filt = LD_SH(filter_vert);
1735     SPLATI_H4_SH(filt, 0, 1, 2, 3, filt_vt0, filt_vt1, filt_vt2, filt_vt3);
1736
1737     ILVEV_B2_SH(hz_out0, hz_out1, hz_out2, hz_out3, out0, out1);
1738     ILVEV_B2_SH(hz_out4, hz_out5, hz_out1, hz_out2, out2, out4);
1739     ILVEV_B2_SH(hz_out3, hz_out4, hz_out5, hz_out6, out5, out6);
1740
1741     for (loop_cnt = (height >> 2); loop_cnt--;) {
1742         LD_SB4(src, src_stride, src7, src8, src9, src10);
1743         XORI_B4_128_SB(src7, src8, src9, src10);
1744         src += (4 * src_stride);
1745
1746         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1747
1748         hz_out7 = HORIZ_8TAP_FILT(src7, src7, mask0, mask1, mask2, mask3,
1749                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1750         out3 = (v8i16) __msa_ilvev_b((v16i8) hz_out7, (v16i8) hz_out6);
1751         tmp0 = FILT_8TAP_DPADD_S_H(out0, out1, out2, out3, filt_vt0, filt_vt1,
1752                                    filt_vt2, filt_vt3);
1753
1754         hz_out8 = HORIZ_8TAP_FILT(src8, src8, mask0, mask1, mask2, mask3,
1755                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1756         out7 = (v8i16) __msa_ilvev_b((v16i8) hz_out8, (v16i8) hz_out7);
1757         tmp1 = FILT_8TAP_DPADD_S_H(out4, out5, out6, out7, filt_vt0, filt_vt1,
1758                                    filt_vt2, filt_vt3);
1759
1760         hz_out9 = HORIZ_8TAP_FILT(src9, src9, mask0, mask1, mask2, mask3,
1761                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1762         out8 = (v8i16) __msa_ilvev_b((v16i8) hz_out9, (v16i8) hz_out8);
1763         tmp2 = FILT_8TAP_DPADD_S_H(out1, out2, out3, out8, filt_vt0, filt_vt1,
1764                                    filt_vt2, filt_vt3);
1765
1766         hz_out10 = HORIZ_8TAP_FILT(src10, src10, mask0, mask1, mask2, mask3,
1767                                    filt_hz0, filt_hz1, filt_hz2, filt_hz3);
1768         out9 = (v8i16) __msa_ilvev_b((v16i8) hz_out10, (v16i8) hz_out9);
1769         tmp3 = FILT_8TAP_DPADD_S_H(out5, out6, out7, out9, filt_vt0, filt_vt1,
1770                                    filt_vt2, filt_vt3);
1771
1772         SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
1773         SAT_SH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
1774         CONVERT_UB_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst2, dst3,
1775                                 dst, dst_stride);
1776         dst += (4 * dst_stride);
1777
1778         hz_out6 = hz_out10;
1779         out0 = out2;
1780         out1 = out3;
1781         out2 = out8;
1782         out4 = out6;
1783         out5 = out7;
1784         out6 = out9;
1785     }
1786 }
1787
1788 static void common_hv_8ht_8vt_and_aver_dst_16w_msa(const uint8_t *src,
1789                                                    int32_t src_stride,
1790                                                    uint8_t *dst,
1791                                                    int32_t dst_stride,
1792                                                    const int8_t *filter_horiz,
1793                                                    const int8_t *filter_vert,
1794                                                    int32_t height)
1795 {
1796     int32_t multiple8_cnt;
1797
1798     for (multiple8_cnt = 2; multiple8_cnt--;) {
1799         common_hv_8ht_8vt_and_aver_dst_8w_msa(src, src_stride, dst, dst_stride,
1800                                               filter_horiz, filter_vert,
1801                                               height);
1802
1803         src += 8;
1804         dst += 8;
1805     }
1806 }
1807
1808 static void common_hv_8ht_8vt_and_aver_dst_32w_msa(const uint8_t *src,
1809                                                    int32_t src_stride,
1810                                                    uint8_t *dst,
1811                                                    int32_t dst_stride,
1812                                                    const int8_t *filter_horiz,
1813                                                    const int8_t *filter_vert,
1814                                                    int32_t height)
1815 {
1816     int32_t multiple8_cnt;
1817
1818     for (multiple8_cnt = 4; multiple8_cnt--;) {
1819         common_hv_8ht_8vt_and_aver_dst_8w_msa(src, src_stride, dst, dst_stride,
1820                                               filter_horiz, filter_vert,
1821                                               height);
1822
1823         src += 8;
1824         dst += 8;
1825     }
1826 }
1827
1828 static void common_hv_8ht_8vt_and_aver_dst_64w_msa(const uint8_t *src,
1829                                                    int32_t src_stride,
1830                                                    uint8_t *dst,
1831                                                    int32_t dst_stride,
1832                                                    const int8_t *filter_horiz,
1833                                                    const int8_t *filter_vert,
1834                                                    int32_t height)
1835 {
1836     int32_t multiple8_cnt;
1837
1838     for (multiple8_cnt = 8; multiple8_cnt--;) {
1839         common_hv_8ht_8vt_and_aver_dst_8w_msa(src, src_stride, dst, dst_stride,
1840                                               filter_horiz, filter_vert,
1841                                               height);
1842
1843         src += 8;
1844         dst += 8;
1845     }
1846 }
1847
1848 static void common_hz_2t_4x4_msa(const uint8_t *src, int32_t src_stride,
1849                                  uint8_t *dst, int32_t dst_stride,
1850                                  const int8_t *filter)
1851 {
1852     v16i8 src0, src1, src2, src3, mask;
1853     v16u8 filt0, vec0, vec1, res0, res1;
1854     v8u16 vec2, vec3, filt;
1855
1856     mask = LD_SB(&mc_filt_mask_arr[16]);
1857
1858     /* rearranging filter */
1859     filt = LD_UH(filter);
1860     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
1861
1862     LD_SB4(src, src_stride, src0, src1, src2, src3);
1863     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
1864     DOTP_UB2_UH(vec0, vec1, filt0, filt0, vec2, vec3);
1865     SRARI_H2_UH(vec2, vec3, 7);
1866     PCKEV_B2_UB(vec2, vec2, vec3, vec3, res0, res1);
1867     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
1868 }
1869
1870 static void common_hz_2t_4x8_msa(const uint8_t *src, int32_t src_stride,
1871                                  uint8_t *dst, int32_t dst_stride,
1872                                  const int8_t *filter)
1873 {
1874     v16u8 vec0, vec1, vec2, vec3, filt0;
1875     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
1876     v16i8 res0, res1, res2, res3;
1877     v8u16 vec4, vec5, vec6, vec7, filt;
1878
1879     mask = LD_SB(&mc_filt_mask_arr[16]);
1880
1881     /* rearranging filter */
1882     filt = LD_UH(filter);
1883     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
1884
1885     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
1886     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
1887     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, vec2, vec3);
1888     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1889                 vec4, vec5, vec6, vec7);
1890     SRARI_H4_UH(vec4, vec5, vec6, vec7, 7);
1891     PCKEV_B4_SB(vec4, vec4, vec5, vec5, vec6, vec6, vec7, vec7,
1892                 res0, res1, res2, res3);
1893     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
1894     dst += (4 * dst_stride);
1895     ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
1896 }
1897
1898 void ff_put_bilin_4h_msa(uint8_t *dst, ptrdiff_t dst_stride,
1899                          const uint8_t *src, ptrdiff_t src_stride,
1900                          int height, int mx, int my)
1901 {
1902     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
1903
1904     if (4 == height) {
1905         common_hz_2t_4x4_msa(src, src_stride, dst, dst_stride, filter);
1906     } else if (8 == height) {
1907         common_hz_2t_4x8_msa(src, src_stride, dst, dst_stride, filter);
1908     }
1909 }
1910
1911 static void common_hz_2t_8x4_msa(const uint8_t *src, int32_t src_stride,
1912                                  uint8_t *dst, int32_t dst_stride,
1913                                  const int8_t *filter)
1914 {
1915     v16u8 filt0;
1916     v16i8 src0, src1, src2, src3, mask;
1917     v8u16 vec0, vec1, vec2, vec3, filt;
1918
1919     mask = LD_SB(&mc_filt_mask_arr[0]);
1920
1921     /* rearranging filter */
1922     filt = LD_UH(filter);
1923     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
1924
1925     LD_SB4(src, src_stride, src0, src1, src2, src3);
1926     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
1927     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
1928     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1929                 vec0, vec1, vec2, vec3);
1930     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
1931     PCKEV_B2_SB(vec1, vec0, vec3, vec2, src0, src1);
1932     ST8x4_UB(src0, src1, dst, dst_stride);
1933 }
1934
1935 static void common_hz_2t_8x8mult_msa(const uint8_t *src, int32_t src_stride,
1936                                      uint8_t *dst, int32_t dst_stride,
1937                                      const int8_t *filter, int32_t height)
1938 {
1939     v16u8 filt0;
1940     v16i8 src0, src1, src2, src3, mask, out0, out1;
1941     v8u16 vec0, vec1, vec2, vec3, filt;
1942
1943     mask = LD_SB(&mc_filt_mask_arr[0]);
1944
1945     /* rearranging filter */
1946     filt = LD_UH(filter);
1947     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
1948
1949     LD_SB4(src, src_stride, src0, src1, src2, src3);
1950     src += (4 * src_stride);
1951
1952     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
1953     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
1954     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1955                 vec0, vec1, vec2, vec3);
1956     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
1957     LD_SB4(src, src_stride, src0, src1, src2, src3);
1958     src += (4 * src_stride);
1959
1960     PCKEV_B2_SB(vec1, vec0, vec3, vec2, out0, out1);
1961     ST8x4_UB(out0, out1, dst, dst_stride);
1962     dst += (4 * dst_stride);
1963
1964     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
1965     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
1966     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1967                 vec0, vec1, vec2, vec3);
1968     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
1969     PCKEV_B2_SB(vec1, vec0, vec3, vec2, out0, out1);
1970     ST8x4_UB(out0, out1, dst, dst_stride);
1971     dst += (4 * dst_stride);
1972
1973     if (16 == height) {
1974         LD_SB4(src, src_stride, src0, src1, src2, src3);
1975         src += (4 * src_stride);
1976
1977         VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
1978         VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
1979         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1980                     vec0, vec1, vec2, vec3);
1981         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
1982         LD_SB4(src, src_stride, src0, src1, src2, src3);
1983         src += (4 * src_stride);
1984
1985         PCKEV_B2_SB(vec1, vec0, vec3, vec2, out0, out1);
1986         ST8x4_UB(out0, out1, dst, dst_stride);
1987
1988         VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
1989         VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
1990         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
1991                     vec0, vec1, vec2, vec3);
1992         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
1993         PCKEV_B2_SB(vec1, vec0, vec3, vec2, out0, out1);
1994         ST8x4_UB(out0, out1, dst + 4 * dst_stride, dst_stride);
1995     }
1996 }
1997
1998 void ff_put_bilin_8h_msa(uint8_t *dst, ptrdiff_t dst_stride,
1999                          const uint8_t *src, ptrdiff_t src_stride,
2000                          int height, int mx, int my)
2001 {
2002     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
2003
2004     if (4 == height) {
2005         common_hz_2t_8x4_msa(src, src_stride, dst, dst_stride, filter);
2006     } else {
2007         common_hz_2t_8x8mult_msa(src, src_stride, dst, dst_stride, filter,
2008                                  height);
2009     }
2010 }
2011
2012 void ff_put_bilin_16h_msa(uint8_t *dst, ptrdiff_t dst_stride,
2013                           const uint8_t *src, ptrdiff_t src_stride,
2014                           int height, int mx, int my)
2015 {
2016     uint32_t loop_cnt;
2017     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
2018     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
2019     v16u8 filt0, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
2020     v8u16 out0, out1, out2, out3, out4, out5, out6, out7, filt;
2021
2022     mask = LD_SB(&mc_filt_mask_arr[0]);
2023
2024     loop_cnt = (height >> 2) - 1;
2025
2026     /* rearranging filter */
2027     filt = LD_UH(filter);
2028     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2029
2030     LD_SB4(src, src_stride, src0, src2, src4, src6);
2031     LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
2032     src += (4 * src_stride);
2033
2034     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
2035     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
2036     VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
2037     VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
2038     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2039                 out0, out1, out2, out3);
2040     DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
2041                 out4, out5, out6, out7);
2042     SRARI_H4_UH(out0, out1, out2, out3, 7);
2043     SRARI_H4_UH(out4, out5, out6, out7, 7);
2044     PCKEV_ST_SB(out0, out1, dst);
2045     dst += dst_stride;
2046     PCKEV_ST_SB(out2, out3, dst);
2047     dst += dst_stride;
2048     PCKEV_ST_SB(out4, out5, dst);
2049     dst += dst_stride;
2050     PCKEV_ST_SB(out6, out7, dst);
2051     dst += dst_stride;
2052
2053     for (; loop_cnt--;) {
2054         LD_SB4(src, src_stride, src0, src2, src4, src6);
2055         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
2056         src += (4 * src_stride);
2057
2058         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
2059         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
2060         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
2061         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
2062         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2063                     out0, out1, out2, out3);
2064         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
2065                     out4, out5, out6, out7);
2066         SRARI_H4_UH(out0, out1, out2, out3, 7);
2067         SRARI_H4_UH(out4, out5, out6, out7, 7);
2068         PCKEV_ST_SB(out0, out1, dst);
2069         dst += dst_stride;
2070         PCKEV_ST_SB(out2, out3, dst);
2071         dst += dst_stride;
2072         PCKEV_ST_SB(out4, out5, dst);
2073         dst += dst_stride;
2074         PCKEV_ST_SB(out6, out7, dst);
2075         dst += dst_stride;
2076     }
2077 }
2078
2079 void ff_put_bilin_32h_msa(uint8_t *dst, ptrdiff_t dst_stride,
2080                           const uint8_t *src, ptrdiff_t src_stride,
2081                           int height, int mx, int my)
2082 {
2083     uint32_t loop_cnt;
2084     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
2085     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
2086     v16u8 filt0, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
2087     v8u16 out0, out1, out2, out3, out4, out5, out6, out7, filt;
2088
2089     mask = LD_SB(&mc_filt_mask_arr[0]);
2090
2091     /* rearranging filter */
2092     filt = LD_UH(filter);
2093     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2094
2095     for (loop_cnt = height >> 1; loop_cnt--;) {
2096         src0 = LD_SB(src);
2097         src2 = LD_SB(src + 16);
2098         src3 = LD_SB(src + 24);
2099         src1 = __msa_sldi_b(src2, src0, 8);
2100         src += src_stride;
2101         src4 = LD_SB(src);
2102         src6 = LD_SB(src + 16);
2103         src7 = LD_SB(src + 24);
2104         src5 = __msa_sldi_b(src6, src4, 8);
2105         src += src_stride;
2106
2107         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
2108         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
2109         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
2110         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
2111         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2112                     out0, out1, out2, out3);
2113         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
2114                     out4, out5, out6, out7);
2115         SRARI_H4_UH(out0, out1, out2, out3, 7);
2116         SRARI_H4_UH(out4, out5, out6, out7, 7);
2117         PCKEV_ST_SB(out0, out1, dst);
2118         PCKEV_ST_SB(out2, out3, dst + 16);
2119         dst += dst_stride;
2120         PCKEV_ST_SB(out4, out5, dst);
2121         PCKEV_ST_SB(out6, out7, dst + 16);
2122         dst += dst_stride;
2123     }
2124 }
2125
2126 void ff_put_bilin_64h_msa(uint8_t *dst, ptrdiff_t dst_stride,
2127                           const uint8_t *src, ptrdiff_t src_stride,
2128                           int height, int mx, int my)
2129 {
2130     uint32_t loop_cnt;
2131     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
2132     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
2133     v16u8 filt0, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
2134     v8u16 out0, out1, out2, out3, out4, out5, out6, out7, filt;
2135
2136     mask = LD_SB(&mc_filt_mask_arr[0]);
2137
2138     /* rearranging filter */
2139     filt = LD_UH(filter);
2140     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2141
2142     for (loop_cnt = height; loop_cnt--;) {
2143         src0 = LD_SB(src);
2144         src2 = LD_SB(src + 16);
2145         src4 = LD_SB(src + 32);
2146         src6 = LD_SB(src + 48);
2147         src7 = LD_SB(src + 56);
2148         SLDI_B3_SB(src2, src4, src6, src0, src2, src4, src1, src3, src5, 8);
2149         src += src_stride;
2150
2151         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
2152         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
2153         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
2154         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
2155         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2156                     out0, out1, out2, out3);
2157         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
2158                     out4, out5, out6, out7);
2159         SRARI_H4_UH(out0, out1, out2, out3, 7);
2160         SRARI_H4_UH(out4, out5, out6, out7, 7);
2161         PCKEV_ST_SB(out0, out1, dst);
2162         PCKEV_ST_SB(out2, out3, dst + 16);
2163         PCKEV_ST_SB(out4, out5, dst + 32);
2164         PCKEV_ST_SB(out6, out7, dst + 48);
2165         dst += dst_stride;
2166     }
2167 }
2168
2169 static void common_vt_2t_4x4_msa(const uint8_t *src, int32_t src_stride,
2170                                  uint8_t *dst, int32_t dst_stride,
2171                                  const int8_t *filter)
2172 {
2173     v16i8 src0, src1, src2, src3, src4;
2174     v16i8 src10_r, src32_r, src21_r, src43_r, src2110, src4332;
2175     v16u8 filt0;
2176     v8i16 filt;
2177     v8u16 tmp0, tmp1;
2178
2179     filt = LD_SH(filter);
2180     filt0 = (v16u8) __msa_splati_h(filt, 0);
2181
2182     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
2183     src += (5 * src_stride);
2184
2185     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
2186                src10_r, src21_r, src32_r, src43_r);
2187     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
2188     DOTP_UB2_UH(src2110, src4332, filt0, filt0, tmp0, tmp1);
2189     SRARI_H2_UH(tmp0, tmp1, 7);
2190     SAT_UH2_UH(tmp0, tmp1, 7);
2191     src2110 = __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
2192     ST4x4_UB(src2110, src2110, 0, 1, 2, 3, dst, dst_stride);
2193 }
2194
2195 static void common_vt_2t_4x8_msa(const uint8_t *src, int32_t src_stride,
2196                                  uint8_t *dst, int32_t dst_stride,
2197                                  const int8_t *filter)
2198 {
2199     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
2200     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r;
2201     v16i8 src65_r, src87_r, src2110, src4332, src6554, src8776;
2202     v8u16 tmp0, tmp1, tmp2, tmp3;
2203     v16u8 filt0;
2204     v8i16 filt;
2205
2206     filt = LD_SH(filter);
2207     filt0 = (v16u8) __msa_splati_h(filt, 0);
2208
2209     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
2210     src += (8 * src_stride);
2211
2212     src8 = LD_SB(src);
2213     src += src_stride;
2214
2215     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
2216                src32_r, src43_r);
2217     ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
2218                src76_r, src87_r);
2219     ILVR_D4_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
2220                src87_r, src76_r, src2110, src4332, src6554, src8776);
2221     DOTP_UB4_UH(src2110, src4332, src6554, src8776, filt0, filt0, filt0, filt0,
2222                 tmp0, tmp1, tmp2, tmp3);
2223     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2224     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2225     PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, src2110, src4332);
2226     ST4x4_UB(src2110, src2110, 0, 1, 2, 3, dst, dst_stride);
2227     ST4x4_UB(src4332, src4332, 0, 1, 2, 3, dst + 4 * dst_stride, dst_stride);
2228 }
2229
2230 void ff_put_bilin_4v_msa(uint8_t *dst, ptrdiff_t dst_stride,
2231                          const uint8_t *src, ptrdiff_t src_stride,
2232                          int height, int mx, int my)
2233 {
2234     const int8_t *filter = vp9_bilinear_filters_msa[my - 1];
2235
2236     if (4 == height) {
2237         common_vt_2t_4x4_msa(src, src_stride, dst, dst_stride, filter);
2238     } else if (8 == height) {
2239         common_vt_2t_4x8_msa(src, src_stride, dst, dst_stride, filter);
2240     }
2241 }
2242
2243 static void common_vt_2t_8x4_msa(const uint8_t *src, int32_t src_stride,
2244                                  uint8_t *dst, int32_t dst_stride,
2245                                  const int8_t *filter)
2246 {
2247     v16u8 src0, src1, src2, src3, src4, vec0, vec1, vec2, vec3, filt0;
2248     v16i8 out0, out1;
2249     v8u16 tmp0, tmp1, tmp2, tmp3;
2250     v8i16 filt;
2251
2252     /* rearranging filter_y */
2253     filt = LD_SH(filter);
2254     filt0 = (v16u8) __msa_splati_h(filt, 0);
2255
2256     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
2257     ILVR_B2_UB(src1, src0, src2, src1, vec0, vec1);
2258     ILVR_B2_UB(src3, src2, src4, src3, vec2, vec3);
2259     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2260                 tmp0, tmp1, tmp2, tmp3);
2261     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2262     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2263     PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, out0, out1);
2264     ST8x4_UB(out0, out1, dst, dst_stride);
2265 }
2266
2267 static void common_vt_2t_8x8mult_msa(const uint8_t *src, int32_t src_stride,
2268                                      uint8_t *dst, int32_t dst_stride,
2269                                      const int8_t *filter, int32_t height)
2270 {
2271     uint32_t loop_cnt;
2272     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
2273     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, filt0;
2274     v16i8 out0, out1;
2275     v8u16 tmp0, tmp1, tmp2, tmp3;
2276     v8i16 filt;
2277
2278     /* rearranging filter_y */
2279     filt = LD_SH(filter);
2280     filt0 = (v16u8) __msa_splati_h(filt, 0);
2281
2282     src0 = LD_UB(src);
2283     src += src_stride;
2284
2285     for (loop_cnt = (height >> 3); loop_cnt--;) {
2286         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);
2287         src += (8 * src_stride);
2288
2289         ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
2290                    vec0, vec1, vec2, vec3);
2291         ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7,
2292                    vec4, vec5, vec6, vec7);
2293         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2294                     tmp0, tmp1, tmp2, tmp3);
2295         SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2296         SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2297         PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, out0, out1);
2298         ST8x4_UB(out0, out1, dst, dst_stride);
2299         dst += (4 * dst_stride);
2300
2301         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
2302                     tmp0, tmp1, tmp2, tmp3);
2303         SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2304         SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2305         PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, out0, out1);
2306         ST8x4_UB(out0, out1, dst, dst_stride);
2307         dst += (4 * dst_stride);
2308
2309         src0 = src8;
2310     }
2311 }
2312
2313 void ff_put_bilin_8v_msa(uint8_t *dst, ptrdiff_t dst_stride,
2314                          const uint8_t *src, ptrdiff_t src_stride,
2315                          int height, int mx, int my)
2316 {
2317     const int8_t *filter = vp9_bilinear_filters_msa[my - 1];
2318
2319     if (4 == height) {
2320         common_vt_2t_8x4_msa(src, src_stride, dst, dst_stride, filter);
2321     } else {
2322         common_vt_2t_8x8mult_msa(src, src_stride, dst, dst_stride, filter,
2323                                  height);
2324     }
2325 }
2326
2327 void ff_put_bilin_16v_msa(uint8_t *dst, ptrdiff_t dst_stride,
2328                           const uint8_t *src, ptrdiff_t src_stride,
2329                           int height, int mx, int my)
2330 {
2331     uint32_t loop_cnt;
2332     const int8_t *filter = vp9_bilinear_filters_msa[my - 1];
2333     v16u8 src0, src1, src2, src3, src4;
2334     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, filt0;
2335     v8u16 tmp0, tmp1, tmp2, tmp3;
2336     v8i16 filt;
2337
2338     /* rearranging filter_y */
2339     filt = LD_SH(filter);
2340     filt0 = (v16u8) __msa_splati_h(filt, 0);
2341
2342     src0 = LD_UB(src);
2343     src += src_stride;
2344
2345     for (loop_cnt = (height >> 2); loop_cnt--;) {
2346         LD_UB4(src, src_stride, src1, src2, src3, src4);
2347         src += (4 * src_stride);
2348
2349         ILVR_B2_UB(src1, src0, src2, src1, vec0, vec2);
2350         ILVL_B2_UB(src1, src0, src2, src1, vec1, vec3);
2351         DOTP_UB2_UH(vec0, vec1, filt0, filt0, tmp0, tmp1);
2352         SRARI_H2_UH(tmp0, tmp1, 7);
2353         SAT_UH2_UH(tmp0, tmp1, 7);
2354         PCKEV_ST_SB(tmp0, tmp1, dst);
2355         dst += dst_stride;
2356
2357         ILVR_B2_UB(src3, src2, src4, src3, vec4, vec6);
2358         ILVL_B2_UB(src3, src2, src4, src3, vec5, vec7);
2359         DOTP_UB2_UH(vec2, vec3, filt0, filt0, tmp2, tmp3);
2360         SRARI_H2_UH(tmp2, tmp3, 7);
2361         SAT_UH2_UH(tmp2, tmp3, 7);
2362         PCKEV_ST_SB(tmp2, tmp3, dst);
2363         dst += dst_stride;
2364
2365         DOTP_UB2_UH(vec4, vec5, filt0, filt0, tmp0, tmp1);
2366         SRARI_H2_UH(tmp0, tmp1, 7);
2367         SAT_UH2_UH(tmp0, tmp1, 7);
2368         PCKEV_ST_SB(tmp0, tmp1, dst);
2369         dst += dst_stride;
2370
2371         DOTP_UB2_UH(vec6, vec7, filt0, filt0, tmp2, tmp3);
2372         SRARI_H2_UH(tmp2, tmp3, 7);
2373         SAT_UH2_UH(tmp2, tmp3, 7);
2374         PCKEV_ST_SB(tmp2, tmp3, dst);
2375         dst += dst_stride;
2376
2377         src0 = src4;
2378     }
2379 }
2380
2381 void ff_put_bilin_32v_msa(uint8_t *dst, ptrdiff_t dst_stride,
2382                           const uint8_t *src, ptrdiff_t src_stride,
2383                           int height, int mx, int my)
2384 {
2385     uint32_t loop_cnt;
2386     const int8_t *filter = vp9_bilinear_filters_msa[my - 1];
2387     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
2388     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, filt0;
2389     v8u16 tmp0, tmp1, tmp2, tmp3;
2390     v8i16 filt;
2391
2392     /* rearranging filter_y */
2393     filt = LD_SH(filter);
2394     filt0 = (v16u8) __msa_splati_h(filt, 0);
2395
2396     src0 = LD_UB(src);
2397     src5 = LD_UB(src + 16);
2398     src += src_stride;
2399
2400     for (loop_cnt = (height >> 2); loop_cnt--;) {
2401         LD_UB4(src, src_stride, src1, src2, src3, src4);
2402         ILVR_B2_UB(src1, src0, src2, src1, vec0, vec2);
2403         ILVL_B2_UB(src1, src0, src2, src1, vec1, vec3);
2404
2405         LD_UB4(src + 16, src_stride, src6, src7, src8, src9);
2406         src += (4 * src_stride);
2407
2408         DOTP_UB2_UH(vec0, vec1, filt0, filt0, tmp0, tmp1);
2409         SRARI_H2_UH(tmp0, tmp1, 7);
2410         SAT_UH2_UH(tmp0, tmp1, 7);
2411         PCKEV_ST_SB(tmp0, tmp1, dst);
2412         DOTP_UB2_UH(vec2, vec3, filt0, filt0, tmp2, tmp3);
2413         SRARI_H2_UH(tmp2, tmp3, 7);
2414         SAT_UH2_UH(tmp2, tmp3, 7);
2415         PCKEV_ST_SB(tmp2, tmp3, dst + dst_stride);
2416
2417         ILVR_B2_UB(src3, src2, src4, src3, vec4, vec6);
2418         ILVL_B2_UB(src3, src2, src4, src3, vec5, vec7);
2419         DOTP_UB2_UH(vec4, vec5, filt0, filt0, tmp0, tmp1);
2420         SRARI_H2_UH(tmp0, tmp1, 7);
2421         SAT_UH2_UH(tmp0, tmp1, 7);
2422         PCKEV_ST_SB(tmp0, tmp1, dst + 2 * dst_stride);
2423
2424         DOTP_UB2_UH(vec6, vec7, filt0, filt0, tmp2, tmp3);
2425         SRARI_H2_UH(tmp2, tmp3, 7);
2426         SAT_UH2_UH(tmp2, tmp3, 7);
2427         PCKEV_ST_SB(tmp2, tmp3, dst + 3 * dst_stride);
2428
2429         ILVR_B2_UB(src6, src5, src7, src6, vec0, vec2);
2430         ILVL_B2_UB(src6, src5, src7, src6, vec1, vec3);
2431         DOTP_UB2_UH(vec0, vec1, filt0, filt0, tmp0, tmp1);
2432         SRARI_H2_UH(tmp0, tmp1, 7);
2433         SAT_UH2_UH(tmp0, tmp1, 7);
2434         PCKEV_ST_SB(tmp0, tmp1, dst + 16);
2435
2436         DOTP_UB2_UH(vec2, vec3, filt0, filt0, tmp2, tmp3);
2437         SRARI_H2_UH(tmp2, tmp3, 7);
2438         SAT_UH2_UH(tmp2, tmp3, 7);
2439         PCKEV_ST_SB(tmp2, tmp3, dst + 16 + dst_stride);
2440
2441         ILVR_B2_UB(src8, src7, src9, src8, vec4, vec6);
2442         ILVL_B2_UB(src8, src7, src9, src8, vec5, vec7);
2443         DOTP_UB2_UH(vec4, vec5, filt0, filt0, tmp0, tmp1);
2444         SRARI_H2_UH(tmp0, tmp1, 7);
2445         SAT_UH2_UH(tmp0, tmp1, 7);
2446         PCKEV_ST_SB(tmp0, tmp1, dst + 16 + 2 * dst_stride);
2447
2448         DOTP_UB2_UH(vec6, vec7, filt0, filt0, tmp2, tmp3);
2449         SRARI_H2_UH(tmp2, tmp3, 7);
2450         SAT_UH2_UH(tmp2, tmp3, 7);
2451         PCKEV_ST_SB(tmp2, tmp3, dst + 16 + 3 * dst_stride);
2452         dst += (4 * dst_stride);
2453
2454         src0 = src4;
2455         src5 = src9;
2456     }
2457 }
2458
2459 void ff_put_bilin_64v_msa(uint8_t *dst, ptrdiff_t dst_stride,
2460                           const uint8_t *src, ptrdiff_t src_stride,
2461                           int height, int mx, int my)
2462 {
2463     uint32_t loop_cnt;
2464     const int8_t *filter = vp9_bilinear_filters_msa[my - 1];
2465     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
2466     v16u8 src11, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, filt0;
2467     v8u16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2468     v8i16 filt;
2469
2470     /* rearranging filter_y */
2471     filt = LD_SH(filter);
2472     filt0 = (v16u8) __msa_splati_h(filt, 0);
2473
2474     LD_UB4(src, 16, src0, src3, src6, src9);
2475     src += src_stride;
2476
2477     for (loop_cnt = (height >> 1); loop_cnt--;) {
2478         LD_UB2(src, src_stride, src1, src2);
2479         LD_UB2(src + 16, src_stride, src4, src5);
2480         LD_UB2(src + 32, src_stride, src7, src8);
2481         LD_UB2(src + 48, src_stride, src10, src11);
2482         src += (2 * src_stride);
2483
2484         ILVR_B2_UB(src1, src0, src2, src1, vec0, vec2);
2485         ILVL_B2_UB(src1, src0, src2, src1, vec1, vec3);
2486         DOTP_UB2_UH(vec0, vec1, filt0, filt0, tmp0, tmp1);
2487         SRARI_H2_UH(tmp0, tmp1, 7);
2488         SAT_UH2_UH(tmp0, tmp1, 7);
2489         PCKEV_ST_SB(tmp0, tmp1, dst);
2490
2491         DOTP_UB2_UH(vec2, vec3, filt0, filt0, tmp2, tmp3);
2492         SRARI_H2_UH(tmp2, tmp3, 7);
2493         SAT_UH2_UH(tmp2, tmp3, 7);
2494         PCKEV_ST_SB(tmp2, tmp3, dst + dst_stride);
2495
2496         ILVR_B2_UB(src4, src3, src5, src4, vec4, vec6);
2497         ILVL_B2_UB(src4, src3, src5, src4, vec5, vec7);
2498         DOTP_UB2_UH(vec4, vec5, filt0, filt0, tmp4, tmp5);
2499         SRARI_H2_UH(tmp4, tmp5, 7);
2500         SAT_UH2_UH(tmp4, tmp5, 7);
2501         PCKEV_ST_SB(tmp4, tmp5, dst + 16);
2502
2503         DOTP_UB2_UH(vec6, vec7, filt0, filt0, tmp6, tmp7);
2504         SRARI_H2_UH(tmp6, tmp7, 7);
2505         SAT_UH2_UH(tmp6, tmp7, 7);
2506         PCKEV_ST_SB(tmp6, tmp7, dst + 16 + dst_stride);
2507
2508         ILVR_B2_UB(src7, src6, src8, src7, vec0, vec2);
2509         ILVL_B2_UB(src7, src6, src8, src7, vec1, vec3);
2510         DOTP_UB2_UH(vec0, vec1, filt0, filt0, tmp0, tmp1);
2511         SRARI_H2_UH(tmp0, tmp1, 7);
2512         SAT_UH2_UH(tmp0, tmp1, 7);
2513         PCKEV_ST_SB(tmp0, tmp1, dst + 32);
2514
2515         DOTP_UB2_UH(vec2, vec3, filt0, filt0, tmp2, tmp3);
2516         SRARI_H2_UH(tmp2, tmp3, 7);
2517         SAT_UH2_UH(tmp2, tmp3, 7);
2518         PCKEV_ST_SB(tmp2, tmp3, dst + 32 + dst_stride);
2519
2520         ILVR_B2_UB(src10, src9, src11, src10, vec4, vec6);
2521         ILVL_B2_UB(src10, src9, src11, src10, vec5, vec7);
2522         DOTP_UB2_UH(vec4, vec5, filt0, filt0, tmp4, tmp5);
2523         SRARI_H2_UH(tmp4, tmp5, 7);
2524         SAT_UH2_UH(tmp4, tmp5, 7);
2525         PCKEV_ST_SB(tmp4, tmp5, dst + 48);
2526
2527         DOTP_UB2_UH(vec6, vec7, filt0, filt0, tmp6, tmp7);
2528         SRARI_H2_UH(tmp6, tmp7, 7);
2529         SAT_UH2_UH(tmp6, tmp7, 7);
2530         PCKEV_ST_SB(tmp6, tmp7, dst + 48 + dst_stride);
2531         dst += (2 * dst_stride);
2532
2533         src0 = src2;
2534         src3 = src5;
2535         src6 = src8;
2536         src9 = src11;
2537     }
2538 }
2539
2540 static void common_hv_2ht_2vt_4x4_msa(const uint8_t *src, int32_t src_stride,
2541                                uint8_t *dst, int32_t dst_stride,
2542                                const int8_t *filter_horiz, const int8_t *filter_vert)
2543 {
2544     v16i8 src0, src1, src2, src3, src4, mask;
2545     v16u8 filt_vt, filt_hz, vec0, vec1, res0, res1;
2546     v8u16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, filt, tmp0, tmp1;
2547
2548     mask = LD_SB(&mc_filt_mask_arr[16]);
2549
2550     /* rearranging filter */
2551     filt = LD_UH(filter_horiz);
2552     filt_hz = (v16u8) __msa_splati_h((v8i16) filt, 0);
2553
2554     filt = LD_UH(filter_vert);
2555     filt_vt = (v16u8) __msa_splati_h((v8i16) filt, 0);
2556
2557     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
2558     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src1, mask, filt_hz, 7);
2559     hz_out2 = HORIZ_2TAP_FILT_UH(src2, src3, mask, filt_hz, 7);
2560     hz_out4 = HORIZ_2TAP_FILT_UH(src4, src4, mask, filt_hz, 7);
2561     hz_out1 = (v8u16) __msa_sldi_b((v16i8) hz_out2, (v16i8) hz_out0, 8);
2562     hz_out3 = (v8u16) __msa_pckod_d((v2i64) hz_out4, (v2i64) hz_out2);
2563
2564     ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
2565     DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp0, tmp1);
2566     SRARI_H2_UH(tmp0, tmp1, 7);
2567     SAT_UH2_UH(tmp0, tmp1, 7);
2568     PCKEV_B2_UB(tmp0, tmp0, tmp1, tmp1, res0, res1);
2569     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
2570 }
2571
2572 static void common_hv_2ht_2vt_4x8_msa(const uint8_t *src, int32_t src_stride,
2573                                uint8_t *dst, int32_t dst_stride,
2574                                const int8_t *filter_horiz, const int8_t *filter_vert)
2575 {
2576     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, mask;
2577     v16i8 res0, res1, res2, res3;
2578     v16u8 filt_hz, filt_vt, vec0, vec1, vec2, vec3;
2579     v8u16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
2580     v8u16 hz_out7, hz_out8, vec4, vec5, vec6, vec7, filt;
2581
2582     mask = LD_SB(&mc_filt_mask_arr[16]);
2583
2584     /* rearranging filter */
2585     filt = LD_UH(filter_horiz);
2586     filt_hz = (v16u8) __msa_splati_h((v8i16) filt, 0);
2587
2588     filt = LD_UH(filter_vert);
2589     filt_vt = (v16u8) __msa_splati_h((v8i16) filt, 0);
2590
2591     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
2592     src += (8 * src_stride);
2593     src8 = LD_SB(src);
2594
2595     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src1, mask, filt_hz, 7);
2596     hz_out2 = HORIZ_2TAP_FILT_UH(src2, src3, mask, filt_hz, 7);
2597     hz_out4 = HORIZ_2TAP_FILT_UH(src4, src5, mask, filt_hz, 7);
2598     hz_out6 = HORIZ_2TAP_FILT_UH(src6, src7, mask, filt_hz, 7);
2599     hz_out8 = HORIZ_2TAP_FILT_UH(src8, src8, mask, filt_hz, 7);
2600     SLDI_B3_UH(hz_out2, hz_out4, hz_out6, hz_out0, hz_out2, hz_out4, hz_out1,
2601                hz_out3, hz_out5, 8);
2602     hz_out7 = (v8u16) __msa_pckod_d((v2i64) hz_out8, (v2i64) hz_out6);
2603
2604     ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
2605     ILVEV_B2_UB(hz_out4, hz_out5, hz_out6, hz_out7, vec2, vec3);
2606     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt_vt, filt_vt, filt_vt, filt_vt,
2607                 vec4, vec5, vec6, vec7);
2608     SRARI_H4_UH(vec4, vec5, vec6, vec7, 7);
2609     SAT_UH4_UH(vec4, vec5, vec6, vec7, 7);
2610     PCKEV_B4_SB(vec4, vec4, vec5, vec5, vec6, vec6, vec7, vec7,
2611                 res0, res1, res2, res3);
2612     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
2613     dst += (4 * dst_stride);
2614     ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
2615 }
2616
2617 void ff_put_bilin_4hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
2618                           const uint8_t *src, ptrdiff_t src_stride,
2619                           int height, int mx, int my)
2620 {
2621     const int8_t *filter_horiz = vp9_bilinear_filters_msa[mx - 1];
2622     const int8_t *filter_vert = vp9_bilinear_filters_msa[my - 1];
2623
2624     if (4 == height) {
2625         common_hv_2ht_2vt_4x4_msa(src, src_stride, dst, dst_stride,
2626                                   filter_horiz, filter_vert);
2627     } else if (8 == height) {
2628         common_hv_2ht_2vt_4x8_msa(src, src_stride, dst, dst_stride,
2629                                   filter_horiz, filter_vert);
2630     }
2631 }
2632
2633 static void common_hv_2ht_2vt_8x4_msa(const uint8_t *src, int32_t src_stride,
2634                                uint8_t *dst, int32_t dst_stride,
2635                                const int8_t *filter_horiz, const int8_t *filter_vert)
2636 {
2637     v16i8 src0, src1, src2, src3, src4, mask, out0, out1;
2638     v16u8 filt_hz, filt_vt, vec0, vec1, vec2, vec3;
2639     v8u16 hz_out0, hz_out1, tmp0, tmp1, tmp2, tmp3;
2640     v8i16 filt;
2641
2642     mask = LD_SB(&mc_filt_mask_arr[0]);
2643
2644     /* rearranging filter */
2645     filt = LD_SH(filter_horiz);
2646     filt_hz = (v16u8) __msa_splati_h(filt, 0);
2647
2648     filt = LD_SH(filter_vert);
2649     filt_vt = (v16u8) __msa_splati_h(filt, 0);
2650
2651     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
2652
2653     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src0, mask, filt_hz, 7);
2654     hz_out1 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
2655     vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2656     tmp0 = __msa_dotp_u_h(vec0, filt_vt);
2657
2658     hz_out0 = HORIZ_2TAP_FILT_UH(src2, src2, mask, filt_hz, 7);
2659     vec1 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2660     tmp1 = __msa_dotp_u_h(vec1, filt_vt);
2661
2662     hz_out1 = HORIZ_2TAP_FILT_UH(src3, src3, mask, filt_hz, 7);
2663     vec2 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2664     tmp2 = __msa_dotp_u_h(vec2, filt_vt);
2665
2666     hz_out0 = HORIZ_2TAP_FILT_UH(src4, src4, mask, filt_hz, 7);
2667     vec3 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2668     tmp3 = __msa_dotp_u_h(vec3, filt_vt);
2669
2670     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2671     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
2672     PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, out0, out1);
2673     ST8x4_UB(out0, out1, dst, dst_stride);
2674 }
2675
2676 static void common_hv_2ht_2vt_8x8mult_msa(const uint8_t *src, int32_t src_stride,
2677                                    uint8_t *dst, int32_t dst_stride,
2678                                    const int8_t *filter_horiz, const int8_t *filter_vert,
2679                                    int32_t height)
2680 {
2681     uint32_t loop_cnt;
2682     v16i8 src0, src1, src2, src3, src4, mask, out0, out1;
2683     v16u8 filt_hz, filt_vt, vec0;
2684     v8u16 hz_out0, hz_out1, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
2685     v8i16 filt;
2686
2687     mask = LD_SB(&mc_filt_mask_arr[0]);
2688
2689     /* rearranging filter */
2690     filt = LD_SH(filter_horiz);
2691     filt_hz = (v16u8) __msa_splati_h(filt, 0);
2692
2693     filt = LD_SH(filter_vert);
2694     filt_vt = (v16u8) __msa_splati_h(filt, 0);
2695
2696     src0 = LD_SB(src);
2697     src += src_stride;
2698
2699     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src0, mask, filt_hz, 7);
2700
2701     for (loop_cnt = (height >> 3); loop_cnt--;) {
2702         LD_SB4(src, src_stride, src1, src2, src3, src4);
2703         src += (4 * src_stride);
2704
2705         hz_out1 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
2706         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2707         tmp1 = __msa_dotp_u_h(vec0, filt_vt);
2708
2709         hz_out0 = HORIZ_2TAP_FILT_UH(src2, src2, mask, filt_hz, 7);
2710         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2711         tmp2 = __msa_dotp_u_h(vec0, filt_vt);
2712
2713         SRARI_H2_UH(tmp1, tmp2, 7);
2714         SAT_UH2_UH(tmp1, tmp2, 7);
2715
2716         hz_out1 = HORIZ_2TAP_FILT_UH(src3, src3, mask, filt_hz, 7);
2717         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2718         tmp3 = __msa_dotp_u_h(vec0, filt_vt);
2719
2720         hz_out0 = HORIZ_2TAP_FILT_UH(src4, src4, mask, filt_hz, 7);
2721         LD_SB4(src, src_stride, src1, src2, src3, src4);
2722         src += (4 * src_stride);
2723         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2724         tmp4 = __msa_dotp_u_h(vec0, filt_vt);
2725
2726         SRARI_H2_UH(tmp3, tmp4, 7);
2727         SAT_UH2_UH(tmp3, tmp4, 7);
2728         PCKEV_B2_SB(tmp2, tmp1, tmp4, tmp3, out0, out1);
2729         ST8x4_UB(out0, out1, dst, dst_stride);
2730         dst += (4 * dst_stride);
2731
2732         hz_out1 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
2733         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2734         tmp5 = __msa_dotp_u_h(vec0, filt_vt);
2735
2736         hz_out0 = HORIZ_2TAP_FILT_UH(src2, src2, mask, filt_hz, 7);
2737         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2738         tmp6 = __msa_dotp_u_h(vec0, filt_vt);
2739
2740         hz_out1 = HORIZ_2TAP_FILT_UH(src3, src3, mask, filt_hz, 7);
2741         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
2742         tmp7 = __msa_dotp_u_h(vec0, filt_vt);
2743
2744         hz_out0 = HORIZ_2TAP_FILT_UH(src4, src4, mask, filt_hz, 7);
2745         vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out0, (v16i8) hz_out1);
2746         tmp8 = __msa_dotp_u_h(vec0, filt_vt);
2747
2748         SRARI_H4_UH(tmp5, tmp6, tmp7, tmp8, 7);
2749         SAT_UH4_UH(tmp5, tmp6, tmp7, tmp8, 7);
2750         PCKEV_B2_SB(tmp6, tmp5, tmp8, tmp7, out0, out1);
2751         ST8x4_UB(out0, out1, dst, dst_stride);
2752         dst += (4 * dst_stride);
2753     }
2754 }
2755
2756 void ff_put_bilin_8hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
2757                           const uint8_t *src, ptrdiff_t src_stride,
2758                           int height, int mx, int my)
2759 {
2760     const int8_t *filter_horiz = vp9_bilinear_filters_msa[mx - 1];
2761     const int8_t *filter_vert = vp9_bilinear_filters_msa[my - 1];
2762
2763     if (4 == height) {
2764         common_hv_2ht_2vt_8x4_msa(src, src_stride, dst, dst_stride,
2765                                   filter_horiz, filter_vert);
2766     } else {
2767         common_hv_2ht_2vt_8x8mult_msa(src, src_stride, dst, dst_stride,
2768                                       filter_horiz, filter_vert, height);
2769     }
2770 }
2771
2772 void ff_put_bilin_16hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
2773                            const uint8_t *src, ptrdiff_t src_stride,
2774                            int height, int mx, int my)
2775 {
2776     uint32_t loop_cnt;
2777     const int8_t *filter_horiz = vp9_bilinear_filters_msa[mx - 1];
2778     const int8_t *filter_vert = vp9_bilinear_filters_msa[my - 1];
2779     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
2780     v16u8 filt_hz, filt_vt, vec0, vec1;
2781     v8u16 tmp1, tmp2, hz_out0, hz_out1, hz_out2, hz_out3;
2782     v8i16 filt;
2783
2784     mask = LD_SB(&mc_filt_mask_arr[0]);
2785
2786     /* rearranging filter */
2787     filt = LD_SH(filter_horiz);
2788     filt_hz = (v16u8) __msa_splati_h(filt, 0);
2789
2790     filt = LD_SH(filter_vert);
2791     filt_vt = (v16u8) __msa_splati_h(filt, 0);
2792
2793     LD_SB2(src, 8, src0, src1);
2794     src += src_stride;
2795
2796     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src0, mask, filt_hz, 7);
2797     hz_out2 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
2798
2799
2800     for (loop_cnt = (height >> 2); loop_cnt--;) {
2801         LD_SB4(src, src_stride, src0, src2, src4, src6);
2802         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
2803         src += (4 * src_stride);
2804
2805         hz_out1 = HORIZ_2TAP_FILT_UH(src0, src0, mask, filt_hz, 7);
2806         hz_out3 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
2807         ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
2808         DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp1, tmp2);
2809         SRARI_H2_UH(tmp1, tmp2, 7);
2810         SAT_UH2_UH(tmp1, tmp2, 7);
2811         PCKEV_ST_SB(tmp1, tmp2, dst);
2812         dst += dst_stride;
2813
2814         hz_out0 = HORIZ_2TAP_FILT_UH(src2, src2, mask, filt_hz, 7);
2815         hz_out2 = HORIZ_2TAP_FILT_UH(src3, src3, mask, filt_hz, 7);
2816         ILVEV_B2_UB(hz_out1, hz_out0, hz_out3, hz_out2, vec0, vec1);
2817         DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp1, tmp2);
2818         SRARI_H2_UH(tmp1, tmp2, 7);
2819         SAT_UH2_UH(tmp1, tmp2, 7);
2820         PCKEV_ST_SB(tmp1, tmp2, dst);
2821         dst += dst_stride;
2822
2823         hz_out1 = HORIZ_2TAP_FILT_UH(src4, src4, mask, filt_hz, 7);
2824         hz_out3 = HORIZ_2TAP_FILT_UH(src5, src5, mask, filt_hz, 7);
2825         ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
2826         DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp1, tmp2);
2827         SRARI_H2_UH(tmp1, tmp2, 7);
2828         SAT_UH2_UH(tmp1, tmp2, 7);
2829         PCKEV_ST_SB(tmp1, tmp2, dst);
2830         dst += dst_stride;
2831
2832         hz_out0 = HORIZ_2TAP_FILT_UH(src6, src6, mask, filt_hz, 7);
2833         hz_out2 = HORIZ_2TAP_FILT_UH(src7, src7, mask, filt_hz, 7);
2834         ILVEV_B2_UB(hz_out1, hz_out0, hz_out3, hz_out2, vec0, vec1);
2835         DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp1, tmp2);
2836         SRARI_H2_UH(tmp1, tmp2, 7);
2837         SAT_UH2_UH(tmp1, tmp2, 7);
2838         PCKEV_ST_SB(tmp1, tmp2, dst);
2839         dst += dst_stride;
2840     }
2841 }
2842
2843 void ff_put_bilin_32hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
2844                            const uint8_t *src, ptrdiff_t src_stride,
2845                            int height, int mx, int my)
2846 {
2847     int32_t multiple8_cnt;
2848
2849     for (multiple8_cnt = 2; multiple8_cnt--;) {
2850         ff_put_bilin_16hv_msa(dst, dst_stride, src, src_stride, height, mx, my);
2851
2852         src += 16;
2853         dst += 16;
2854     }
2855 }
2856
2857 void ff_put_bilin_64hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
2858                            const uint8_t *src, ptrdiff_t src_stride,
2859                            int height, int mx, int my)
2860 {
2861     int32_t multiple8_cnt;
2862
2863     for (multiple8_cnt = 4; multiple8_cnt--;) {
2864         ff_put_bilin_16hv_msa(dst, dst_stride, src, src_stride, height, mx, my);
2865
2866         src += 16;
2867         dst += 16;
2868     }
2869 }
2870
2871 static void common_hz_2t_and_aver_dst_4x4_msa(const uint8_t *src,
2872                                               int32_t src_stride,
2873                                               uint8_t *dst, int32_t dst_stride,
2874                                               const int8_t *filter)
2875 {
2876     v16i8 src0, src1, src2, src3, mask;
2877     v16u8 filt0, dst0, dst1, dst2, dst3, vec0, vec1, res0, res1;
2878     v8u16 vec2, vec3, filt;
2879
2880     mask = LD_SB(&mc_filt_mask_arr[16]);
2881
2882     /* rearranging filter */
2883     filt = LD_UH(filter);
2884     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2885
2886     LD_SB4(src, src_stride, src0, src1, src2, src3);
2887     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
2888     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
2889     DOTP_UB2_UH(vec0, vec1, filt0, filt0, vec2, vec3);
2890     SRARI_H2_UH(vec2, vec3, 7);
2891     PCKEV_B2_UB(vec2, vec2, vec3, vec3, res0, res1);
2892     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
2893     AVER_UB2_UB(res0, dst0, res1, dst2, res0, res1);
2894     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
2895 }
2896
2897 static void common_hz_2t_and_aver_dst_4x8_msa(const uint8_t *src,
2898                                               int32_t src_stride,
2899                                               uint8_t *dst, int32_t dst_stride,
2900                                               const int8_t *filter)
2901 {
2902     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
2903     v16u8 filt0, vec0, vec1, vec2, vec3, res0, res1, res2, res3;
2904     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2905     v8u16 vec4, vec5, vec6, vec7, filt;
2906
2907     mask = LD_SB(&mc_filt_mask_arr[16]);
2908
2909     /* rearranging filter */
2910     filt = LD_UH(filter);
2911     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2912
2913     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
2914     LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
2915     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
2916     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, vec2, vec3);
2917     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec4, vec5,
2918                 vec6, vec7);
2919     SRARI_H4_UH(vec4, vec5, vec6, vec7, 7);
2920     PCKEV_B4_UB(vec4, vec4, vec5, vec5, vec6, vec6, vec7, vec7, res0, res1,
2921                 res2, res3);
2922     ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6, dst0, dst2,
2923                dst4, dst6);
2924     AVER_UB4_UB(res0, dst0, res1, dst2, res2, dst4, res3, dst6, res0, res1,
2925                 res2, res3);
2926     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
2927     dst += (4 * dst_stride);
2928     ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
2929 }
2930
2931 void ff_avg_bilin_4h_msa(uint8_t *dst, ptrdiff_t dst_stride,
2932                          const uint8_t *src, ptrdiff_t src_stride,
2933                          int height, int mx, int my)
2934 {
2935     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
2936
2937     if (4 == height) {
2938         common_hz_2t_and_aver_dst_4x4_msa(src, src_stride, dst, dst_stride,
2939                                           filter);
2940     } else if (8 == height) {
2941         common_hz_2t_and_aver_dst_4x8_msa(src, src_stride, dst, dst_stride,
2942                                           filter);
2943     }
2944 }
2945
2946 static void common_hz_2t_and_aver_dst_8x4_msa(const uint8_t *src,
2947                                               int32_t src_stride,
2948                                               uint8_t *dst, int32_t dst_stride,
2949                                               const int8_t *filter)
2950 {
2951     v16i8 src0, src1, src2, src3, mask;
2952     v16u8 filt0, dst0, dst1, dst2, dst3;
2953     v8u16 vec0, vec1, vec2, vec3, filt;
2954
2955     mask = LD_SB(&mc_filt_mask_arr[0]);
2956
2957     /* rearranging filter */
2958     filt = LD_UH(filter);
2959     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2960
2961     LD_SB4(src, src_stride, src0, src1, src2, src3);
2962     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
2963     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
2964     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
2965                 vec0, vec1, vec2, vec3);
2966     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
2967     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
2968     PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
2969                        dst, dst_stride);
2970 }
2971
2972 static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
2973                                                   int32_t src_stride,
2974                                                   uint8_t *dst,
2975                                                   int32_t dst_stride,
2976                                                   const int8_t *filter,
2977                                                   int32_t height)
2978 {
2979     v16i8 src0, src1, src2, src3, mask;
2980     v16u8 filt0, dst0, dst1, dst2, dst3;
2981     v8u16 vec0, vec1, vec2, vec3, filt;
2982
2983     mask = LD_SB(&mc_filt_mask_arr[0]);
2984
2985     /* rearranging filter */
2986     filt = LD_UH(filter);
2987     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
2988
2989     LD_SB4(src, src_stride, src0, src1, src2, src3);
2990     src += (4 * src_stride);
2991     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
2992     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
2993     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0, vec1,
2994                 vec2, vec3);
2995     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
2996     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
2997     LD_SB4(src, src_stride, src0, src1, src2, src3);
2998     src += (4 * src_stride);
2999     PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
3000                        dst, dst_stride);
3001     dst += (4 * dst_stride);
3002
3003     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
3004     VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
3005     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0, vec1,
3006                 vec2, vec3);
3007     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
3008     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3009     PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
3010                        dst, dst_stride);
3011     dst += (4 * dst_stride);
3012
3013     if (16 == height) {
3014         LD_SB4(src, src_stride, src0, src1, src2, src3);
3015         src += (4 * src_stride);
3016
3017         VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
3018         VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
3019         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
3020                     vec1, vec2, vec3);
3021         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
3022         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3023         LD_SB4(src, src_stride, src0, src1, src2, src3);
3024         PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
3025                            dst, dst_stride);
3026         dst += (4 * dst_stride);
3027
3028         VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
3029         VSHF_B2_UH(src2, src2, src3, src3, mask, mask, vec2, vec3);
3030         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
3031                     vec1, vec2, vec3);
3032         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
3033         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3034         PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
3035                            dst, dst_stride);
3036     }
3037 }
3038
3039 void ff_avg_bilin_8h_msa(uint8_t *dst, ptrdiff_t dst_stride,
3040                          const uint8_t *src, ptrdiff_t src_stride,
3041                          int height, int mx, int my)
3042 {
3043     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
3044
3045     if (4 == height) {
3046         common_hz_2t_and_aver_dst_8x4_msa(src, src_stride, dst, dst_stride,
3047                                           filter);
3048     } else {
3049         common_hz_2t_and_aver_dst_8x8mult_msa(src, src_stride, dst, dst_stride,
3050                                               filter, height);
3051     }
3052 }
3053
3054 void ff_avg_bilin_16h_msa(uint8_t *dst, ptrdiff_t dst_stride,
3055                           const uint8_t *src, ptrdiff_t src_stride,
3056                           int height, int mx, int my)
3057 {
3058     uint32_t loop_cnt;
3059     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
3060     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
3061     v16u8 filt0, dst0, dst1, dst2, dst3;
3062     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
3063     v8u16 res0, res1, res2, res3, res4, res5, res6, res7, filt;
3064
3065     mask = LD_SB(&mc_filt_mask_arr[0]);
3066
3067     /* rearranging filter */
3068     filt = LD_UH(filter);
3069     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
3070
3071     LD_SB4(src, src_stride, src0, src2, src4, src6);
3072     LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
3073     src += (4 * src_stride);
3074
3075     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
3076     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
3077     VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
3078     VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
3079     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, res0, res1,
3080                 res2, res3);
3081     DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0, res4, res5,
3082                 res6, res7);
3083     SRARI_H4_UH(res0, res1, res2, res3, 7);
3084     SRARI_H4_UH(res4, res5, res6, res7, 7);
3085     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3086     PCKEV_AVG_ST_UB(res1, res0, dst0, dst);
3087     dst += dst_stride;
3088     PCKEV_AVG_ST_UB(res3, res2, dst1, dst);
3089     dst += dst_stride;
3090     PCKEV_AVG_ST_UB(res5, res4, dst2, dst);
3091     dst += dst_stride;
3092     PCKEV_AVG_ST_UB(res7, res6, dst3, dst);
3093     dst += dst_stride;
3094
3095     for (loop_cnt = (height >> 2) - 1; loop_cnt--;) {
3096         LD_SB4(src, src_stride, src0, src2, src4, src6);
3097         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
3098         src += (4 * src_stride);
3099
3100         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
3101         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
3102         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
3103         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
3104         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, res0,
3105                     res1, res2, res3);
3106         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0, res4,
3107                     res5, res6, res7);
3108         SRARI_H4_UH(res0, res1, res2, res3, 7);
3109         SRARI_H4_UH(res4, res5, res6, res7, 7);
3110         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3111         PCKEV_AVG_ST_UB(res1, res0, dst0, dst);
3112         dst += dst_stride;
3113         PCKEV_AVG_ST_UB(res3, res2, dst1, dst);
3114         dst += dst_stride;
3115         PCKEV_AVG_ST_UB(res5, res4, dst2, dst);
3116         dst += dst_stride;
3117         PCKEV_AVG_ST_UB(res7, res6, dst3, dst);
3118         dst += dst_stride;
3119     }
3120 }
3121
3122 void ff_avg_bilin_32h_msa(uint8_t *dst, ptrdiff_t dst_stride,
3123                           const uint8_t *src, ptrdiff_t src_stride,
3124                           int height, int mx, int my)
3125 {
3126     uint32_t loop_cnt;
3127     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
3128     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
3129     v16u8 filt0, dst0, dst1, dst2, dst3;
3130     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
3131     v8u16 res0, res1, res2, res3, res4, res5, res6, res7, filt;
3132
3133     mask = LD_SB(&mc_filt_mask_arr[0]);
3134
3135     /* rearranging filter */
3136     filt = LD_UH(filter);
3137     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
3138
3139     for (loop_cnt = (height >> 1); loop_cnt--;) {
3140         src0 = LD_SB(src);
3141         src2 = LD_SB(src + 16);
3142         src3 = LD_SB(src + 24);
3143         src1 = __msa_sldi_b(src2, src0, 8);
3144         src += src_stride;
3145         src4 = LD_SB(src);
3146         src6 = LD_SB(src + 16);
3147         src7 = LD_SB(src + 24);
3148         src5 = __msa_sldi_b(src6, src4, 8);
3149         src += src_stride;
3150
3151         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
3152         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
3153         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
3154         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
3155         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
3156                     res0, res1, res2, res3);
3157         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
3158                     res4, res5, res6, res7);
3159         SRARI_H4_UH(res0, res1, res2, res3, 7);
3160         SRARI_H4_UH(res4, res5, res6, res7, 7);
3161         LD_UB2(dst, 16, dst0, dst1);
3162         PCKEV_AVG_ST_UB(res1, res0, dst0, dst);
3163         PCKEV_AVG_ST_UB(res3, res2, dst1, (dst + 16));
3164         dst += dst_stride;
3165         LD_UB2(dst, 16, dst2, dst3);
3166         PCKEV_AVG_ST_UB(res5, res4, dst2, dst);
3167         PCKEV_AVG_ST_UB(res7, res6, dst3, (dst + 16));
3168         dst += dst_stride;
3169     }
3170 }
3171
3172 void ff_avg_bilin_64h_msa(uint8_t *dst, ptrdiff_t dst_stride,
3173                           const uint8_t *src, ptrdiff_t src_stride,
3174                           int height, int mx, int my)
3175 {
3176     uint32_t loop_cnt;
3177     const int8_t *filter = vp9_bilinear_filters_msa[mx - 1];
3178     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
3179     v16u8 filt0, dst0, dst1, dst2, dst3;
3180     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
3181     v8u16 out0, out1, out2, out3, out4, out5, out6, out7, filt;
3182
3183     mask = LD_SB(&mc_filt_mask_arr[0]);
3184
3185     /* rearranging filter */
3186     filt = LD_UH(filter);
3187     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
3188
3189     for (loop_cnt = height; loop_cnt--;) {
3190         LD_SB4(src, 16, src0, src2, src4, src6);
3191         src7 = LD_SB(src + 56);
3192         SLDI_B3_SB(src2, src4, src6, src0, src2, src4, src1, src3, src5, 8);
3193         src += src_stride;
3194
3195         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, vec0, vec1);
3196         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, vec2, vec3);
3197         VSHF_B2_UB(src4, src4, src5, src5, mask, mask, vec4, vec5);
3198         VSHF_B2_UB(src6, src6, src7, src7, mask, mask, vec6, vec7);
3199         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
3200                     out0, out1, out2, out3);
3201         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
3202                     out4, out5, out6, out7);
3203         SRARI_H4_UH(out0, out1, out2, out3, 7);
3204         SRARI_H4_UH(out4, out5, out6, out7, 7);
3205         LD_UB4(dst, 16, dst0, dst1, dst2, dst3);
3206         PCKEV_AVG_ST_UB(out1, out0, dst0, dst);
3207         PCKEV_AVG_ST_UB(out3, out2, dst1, dst + 16);
3208         PCKEV_AVG_ST_UB(out5, out4, dst2, dst + 32);
3209         PCKEV_AVG_ST_UB(out7, out6, dst3, dst + 48);
3210         dst += dst_stride;
3211     }
3212 }
3213
3214 static void common_vt_2t_and_aver_dst_4x4_msa(const uint8_t *src,
3215                                               int32_t src_stride,
3216                                               uint8_t *dst, int32_t dst_stride,
3217                                               const int8_t *filter)
3218 {
3219     v16i8 src0, src1, src2, src3, src4;
3220     v16u8 dst0, dst1, dst2, dst3, out, filt0, src2110, src4332;
3221     v16i8 src10_r, src32_r, src21_r, src43_r;
3222     v8i16 filt;
3223     v8u16 tmp0, tmp1;
3224
3225     filt = LD_SH(filter);
3226     filt0 = (v16u8) __msa_splati_h(filt, 0);
3227
3228     LD_SB4(src, src_stride, src0, src1, src2, src3);
3229     src += (4 * src_stride);
3230
3231     src4 = LD_SB(src);
3232     src += src_stride;
3233
3234     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
3235     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
3236     dst0 = (v16u8) __msa_ilvr_d((v2i64) dst1, (v2i64) dst0);
3237     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
3238                src10_r, src21_r, src32_r, src43_r);
3239     ILVR_D2_UB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
3240     DOTP_UB2_UH(src2110, src4332, filt0, filt0, tmp0, tmp1);
3241     SRARI_H2_UH(tmp0, tmp1, 7);
3242     SAT_UH2_UH(tmp0, tmp1, 7);
3243
3244     out = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
3245     out = __msa_aver_u_b(out, dst0);
3246
3247     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
3248 }
3249
3250 static void common_vt_2t_and_aver_dst_4x8_msa(const uint8_t *src,
3251                                               int32_t src_stride,
3252                                               uint8_t *dst, int32_t dst_stride,
3253                                               const int8_t *filter)
3254 {
3255     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
3256     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src87_r;
3257     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
3258     v16u8 src2110, src4332, src6554, src8776, filt0;
3259     v8u16 tmp0, tmp1, tmp2, tmp3;
3260     v8i16 filt;
3261
3262     filt = LD_SH(filter);
3263     filt0 = (v16u8) __msa_splati_h(filt, 0);
3264
3265     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
3266     src += (8 * src_stride);
3267     src8 = LD_SB(src);
3268
3269     LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
3270     ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6, dst0, dst1,
3271                dst2, dst3);
3272     ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
3273     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
3274                src32_r, src43_r);
3275     ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
3276                src76_r, src87_r);
3277     ILVR_D4_UB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
3278                src87_r, src76_r, src2110, src4332, src6554, src8776);
3279     DOTP_UB4_UH(src2110, src4332, src6554, src8776, filt0, filt0, filt0, filt0,
3280                 tmp0, tmp1, tmp2, tmp3);
3281     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
3282     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);