0709b40ccf30075d5eb779b9fd1ea7b082319ba0
[ffmpeg.git] / libavcodec / mips / hevc_mc_bi_msa.c
1 /*
2  * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "libavutil/mips/generic_macros_msa.h"
22 #include "libavcodec/mips/hevcdsp_mips.h"
23 #include "libavcodec/mips/hevc_macros_msa.h"
24
25 #define HEVC_BI_RND_CLIP2(in0, in1, vec0, vec1, rnd_val, out0, out1)  \
26 {                                                                     \
27     ADDS_SH2_SH(vec0, in0, vec1, in1, out0, out1);                    \
28     SRARI_H2_SH(out0, out1, rnd_val);                                 \
29     CLIP_SH2_0_255(out0, out1);                                       \
30 }
31
32 #define HEVC_BI_RND_CLIP4(in0, in1, in2, in3,                      \
33                           vec0, vec1, vec2, vec3, rnd_val,         \
34                           out0, out1, out2, out3)                  \
35 {                                                                  \
36     HEVC_BI_RND_CLIP2(in0, in1, vec0, vec1, rnd_val, out0, out1);  \
37     HEVC_BI_RND_CLIP2(in2, in3, vec2, vec3, rnd_val, out2, out3);  \
38 }
39
40 static void hevc_bi_copy_4w_msa(uint8_t *src0_ptr,
41                                 int32_t src_stride,
42                                 int16_t *src1_ptr,
43                                 int32_t src2_stride,
44                                 uint8_t *dst,
45                                 int32_t dst_stride,
46                                 int32_t height)
47 {
48     v16i8 zero = { 0 };
49
50     if (2 == height) {
51         v16i8 src0, src1;
52         v8i16 dst0, in0, in1;
53
54         LD_SB2(src0_ptr, src_stride, src0, src1);
55         LD_SH2(src1_ptr, src2_stride, in0, in1);
56
57         src0 = (v16i8) __msa_ilvr_w((v4i32) src1, (v4i32) src0);
58         in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
59
60         dst0 = (v8i16) __msa_ilvr_b(zero, src0);
61         dst0 <<= 6;
62         dst0 += in0;
63         dst0 = __msa_srari_h(dst0, 7);
64         dst0 = CLIP_SH_0_255(dst0);
65
66         dst0 = (v8i16) __msa_pckev_b((v16i8) dst0, (v16i8) dst0);
67         ST4x2_UB(dst0, dst, dst_stride);
68     } else if (4 == height) {
69         v16i8 src0, src1, src2, src3;
70         v8i16 dst0, dst1;
71         v8i16 in0, in1, in2, in3;
72
73         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
74         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
75         ILVR_W2_SB(src1, src0, src3, src2, src0, src1);
76         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
77         ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
78
79         dst0 <<= 6;
80         dst1 <<= 6;
81         HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
82
83         dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
84         ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
85     } else if (0 == height % 8) {
86         uint32_t loop_cnt;
87         v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
88         v8i16 dst0, dst1, dst2, dst3;
89         v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
90
91         for (loop_cnt = (height >> 3); loop_cnt--;) {
92             LD_SB8(src0_ptr, src_stride,
93                    src0, src1, src2, src3, src4, src5, src6, src7);
94             src0_ptr += (8 * src_stride);
95
96             LD_SH8(src1_ptr, src2_stride,
97                    in0, in1, in2, in3, in4, in5, in6, in7);
98             src1_ptr += (8 * src2_stride);
99
100             ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
101             ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
102
103             ILVR_W4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
104                        src0, src1, src2, src3);
105             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
106                        dst0, dst1, dst2, dst3);
107
108             SLLI_4V(dst0, dst1, dst2, dst3, 6);
109             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
110                               dst0, dst1, dst2, dst3, 7,
111                               dst0, dst1, dst2, dst3);
112
113             PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
114             ST4x8_UB(dst0, dst1, dst, dst_stride);
115             dst += (8 * dst_stride);
116         }
117     }
118 }
119
120 static void hevc_bi_copy_6w_msa(uint8_t *src0_ptr,
121                                 int32_t src_stride,
122                                 int16_t *src1_ptr,
123                                 int32_t src2_stride,
124                                 uint8_t *dst,
125                                 int32_t dst_stride,
126                                 int32_t height)
127 {
128     uint32_t loop_cnt;
129     v16i8 zero = { 0 };
130     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
131     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
132     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
133
134     for (loop_cnt = (height >> 3); loop_cnt--;) {
135         LD_SB8(src0_ptr, src_stride,
136                src0, src1, src2, src3, src4, src5, src6, src7);
137         src0_ptr += (8 * src_stride);
138         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
139         src1_ptr += (8 * src2_stride);
140         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
141                    dst0, dst1, dst2, dst3);
142         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
143                    dst4, dst5, dst6, dst7);
144
145         SLLI_4V(dst0, dst1, dst2, dst3, 6);
146         SLLI_4V(dst4, dst5, dst6, dst7, 6);
147         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
148                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
149
150         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
151         ST6x4_UB(dst0, dst1, dst, dst_stride);
152         dst += (4 * dst_stride);
153
154         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
155                           dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
156
157         PCKEV_B2_SH(dst5, dst4, dst7, dst6, dst4, dst5);
158         ST6x4_UB(dst4, dst5, dst, dst_stride);
159         dst += (4 * dst_stride);
160     }
161 }
162
163 static void hevc_bi_copy_8w_msa(uint8_t *src0_ptr,
164                                 int32_t src_stride,
165                                 int16_t *src1_ptr,
166                                 int32_t src2_stride,
167                                 uint8_t *dst,
168                                 int32_t dst_stride,
169                                 int32_t height)
170 {
171     v16i8 zero = { 0 };
172
173     if (2 == height) {
174         v16i8 src0, src1;
175         v8i16 in0, in1;
176         v8i16 dst0, dst1;
177
178         LD_SB2(src0_ptr, src_stride, src0, src1);
179         LD_SH2(src1_ptr, src2_stride, in0, in1);
180         ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
181
182         dst0 <<= 6;
183         dst1 <<= 6;
184         HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
185
186         dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
187         ST8x2_UB(dst0, dst, dst_stride);
188     } else if (4 == height) {
189         v16i8 src0, src1, src2, src3;
190         v8i16 in0, in1, in2, in3;
191         v8i16 dst0, dst1, dst2, dst3;
192
193         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
194         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
195         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
196                    dst0, dst1, dst2, dst3);
197
198         SLLI_4V(dst0, dst1, dst2, dst3, 6);
199         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
200                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
201
202         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
203         ST8x4_UB(dst0, dst1, dst, dst_stride);
204     } else if (6 == height) {
205         v16i8 src0, src1, src2, src3, src4, src5;
206         v8i16 in0, in1, in2, in3, in4, in5;
207         v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
208
209         LD_SB6(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5);
210         LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
211         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
212                    dst0, dst1, dst2, dst3);
213         ILVR_B2_SH(zero, src4, zero, src5, dst4, dst5);
214
215         SLLI_4V(dst0, dst1, dst2, dst3, 6);
216         dst4 <<= 6;
217         dst5 <<= 6;
218         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
219                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
220         HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
221
222         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
223         dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
224         ST8x4_UB(dst0, dst1, dst, dst_stride);
225         dst += (4 * dst_stride);
226         ST8x2_UB(dst2, dst, dst_stride);
227     } else if (0 == height % 8) {
228         v16i8 src0, src1, src2, src3;
229         v8i16 in0, in1, in2, in3;
230         v8i16 dst0, dst1, dst2, dst3;
231         uint32_t loop_cnt;
232
233         for (loop_cnt = (height >> 3); loop_cnt--;) {
234             LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
235             src0_ptr += (4 * src_stride);
236             LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
237             src1_ptr += (4 * src2_stride);
238             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
239                        dst0, dst1, dst2, dst3);
240
241             SLLI_4V(dst0, dst1, dst2, dst3, 6);
242             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
243                               dst0, dst1, dst2, dst3, 7,
244                               dst0, dst1, dst2, dst3);
245
246             PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
247             ST8x4_UB(dst0, dst1, dst, dst_stride);
248             dst += (4 * dst_stride);
249
250             LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
251             src0_ptr += (4 * src_stride);
252             LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
253             src1_ptr += (4 * src2_stride);
254             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
255                        dst0, dst1, dst2, dst3);
256
257             SLLI_4V(dst0, dst1, dst2, dst3, 6);
258             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
259                               dst0, dst1, dst2, dst3, 7,
260                               dst0, dst1, dst2, dst3);
261
262             PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
263             ST8x4_UB(dst0, dst1, dst, dst_stride);
264             dst += (4 * dst_stride);
265         }
266     }
267 }
268
269 static void hevc_bi_copy_12w_msa(uint8_t *src0_ptr,
270                                  int32_t src_stride,
271                                  int16_t *src1_ptr,
272                                  int32_t src2_stride,
273                                  uint8_t *dst,
274                                  int32_t dst_stride,
275                                  int32_t height)
276 {
277     uint32_t loop_cnt;
278     v16i8 src0, src1, src2, src3;
279     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
280     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
281     v16i8 zero = { 0 };
282
283     for (loop_cnt = (16 >> 2); loop_cnt--;) {
284         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
285         src0_ptr += (4 * src_stride);
286
287         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
288         LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
289         src1_ptr += (4 * src2_stride);
290         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
291         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
292                    dst0, dst1, dst2, dst3);
293
294         SLLI_4V(dst0, dst1, dst2, dst3, 6);
295         ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
296         ILVR_B2_SH(zero, src0, zero, src1, dst4, dst5);
297         dst4 <<= 6;
298         dst5 <<= 6;
299         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
300                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
301         HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
302
303         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
304         dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
305         ST12x4_UB(dst0, dst1, dst2, dst, dst_stride);
306         dst += (4 * dst_stride);
307     }
308 }
309
310 static void hevc_bi_copy_16multx4mult_msa(uint8_t *src0_ptr,
311                                           int32_t src_stride,
312                                           int16_t *src1_ptr,
313                                           int32_t src2_stride,
314                                           uint8_t *dst,
315                                           int32_t dst_stride,
316                                           int32_t height,
317                                           int32_t width)
318 {
319     uint32_t loop_cnt;
320     uint32_t cnt;
321     uint8_t *src0_ptr_tmp;
322     int16_t *src1_ptr_tmp;
323     uint8_t *dst_tmp;
324     v16i8 zero = { 0 };
325
326     for (cnt = (width >> 4); cnt--;) {
327         src0_ptr_tmp = src0_ptr;
328         src1_ptr_tmp = src1_ptr;
329         dst_tmp = dst;
330
331         for (loop_cnt = (height >> 2); loop_cnt--;) {
332             v16i8 src0, src1, src2, src3;
333             v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
334             v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
335             v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
336
337             LD_SB4(src0_ptr_tmp, src_stride, src0, src1, src2, src3);
338             src0_ptr_tmp += (4 * src_stride);
339             LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
340             LD_SH4(src1_ptr_tmp + 8, src2_stride, in4, in5, in6, in7);
341             src1_ptr_tmp += (4 * src2_stride);
342
343             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
344                        dst0_r, dst1_r, dst2_r, dst3_r);
345             ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
346                        dst0_l, dst1_l, dst2_l, dst3_l);
347
348             SLLI_4V(dst0_r, dst1_r, dst2_r, dst3_r, 6);
349             SLLI_4V(dst0_l, dst1_l, dst2_l, dst3_l, 6);
350             HEVC_BI_RND_CLIP4(in0, in1, in4, in5,
351                               dst0_r, dst1_r, dst0_l, dst1_l, 7,
352                               dst0_r, dst1_r, dst0_l, dst1_l);
353
354             PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
355             ST_SH2(dst0_r, dst1_r, dst_tmp, dst_stride);
356             dst_tmp += (2 * dst_stride);
357
358             HEVC_BI_RND_CLIP4(in2, in3, in6, in7,
359                               dst2_r, dst3_r, dst2_l, dst3_l, 7,
360                               dst2_r, dst3_r, dst2_l, dst3_l);
361
362             PCKEV_B2_SH(dst2_l, dst2_r, dst3_l, dst3_r, dst2_r, dst3_r);
363             ST_SH2(dst2_r, dst3_r, dst_tmp, dst_stride);
364             dst_tmp += (2 * dst_stride);
365         }
366
367         src0_ptr += 16;
368         src1_ptr += 16;
369         dst += 16;
370     }
371 }
372
373 static void hevc_bi_copy_16w_msa(uint8_t *src0_ptr,
374                                  int32_t src_stride,
375                                  int16_t *src1_ptr,
376                                  int32_t src2_stride,
377                                  uint8_t *dst,
378                                  int32_t dst_stride,
379                                  int32_t height)
380 {
381     hevc_bi_copy_16multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
382                                   dst, dst_stride, height, 16);
383 }
384
385 static void hevc_bi_copy_24w_msa(uint8_t *src0_ptr,
386                                  int32_t src_stride,
387                                  int16_t *src1_ptr,
388                                  int32_t src2_stride,
389                                  uint8_t *dst,
390                                  int32_t dst_stride,
391                                  int32_t height)
392 {
393     hevc_bi_copy_16multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
394                                   dst, dst_stride, height, 16);
395
396     hevc_bi_copy_8w_msa(src0_ptr + 16, src_stride, src1_ptr + 16, src2_stride,
397                         dst + 16, dst_stride, height);
398 }
399
400 static void hevc_bi_copy_32w_msa(uint8_t *src0_ptr,
401                                  int32_t src_stride,
402                                  int16_t *src1_ptr,
403                                  int32_t src2_stride,
404                                  uint8_t *dst,
405                                  int32_t dst_stride,
406                                  int32_t height)
407 {
408     hevc_bi_copy_16multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
409                                   dst, dst_stride, height, 32);
410 }
411
412 static void hevc_bi_copy_48w_msa(uint8_t *src0_ptr,
413                                  int32_t src_stride,
414                                  int16_t *src1_ptr,
415                                  int32_t src2_stride,
416                                  uint8_t *dst,
417                                  int32_t dst_stride,
418                                  int32_t height)
419 {
420     hevc_bi_copy_16multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
421                                   dst, dst_stride, height, 48);
422 }
423
424 static void hevc_bi_copy_64w_msa(uint8_t *src0_ptr,
425                                  int32_t src_stride,
426                                  int16_t *src1_ptr,
427                                  int32_t src2_stride,
428                                  uint8_t *dst,
429                                  int32_t dst_stride,
430                                  int32_t height)
431 {
432     hevc_bi_copy_16multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
433                                   dst, dst_stride, height, 64);
434 }
435
436 static void hevc_hz_bi_8t_4w_msa(uint8_t *src0_ptr,
437                                  int32_t src_stride,
438                                  int16_t *src1_ptr,
439                                  int32_t src2_stride,
440                                  uint8_t *dst,
441                                  int32_t dst_stride,
442                                  const int8_t *filter,
443                                  int32_t height)
444 {
445     uint32_t loop_cnt;
446     v8i16 filt0, filt1, filt2, filt3;
447     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
448     v16i8 mask1, mask2, mask3;
449     v16i8 vec0, vec1, vec2, vec3;
450     v8i16 dst0, dst1, dst2, dst3;
451     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
452     v8i16 filter_vec, const_vec;
453     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
454
455     src0_ptr -= 3;
456
457     /* rearranging filter */
458     filter_vec = LD_SH(filter);
459     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
460
461     mask1 = mask0 + 2;
462     mask2 = mask0 + 4;
463     mask3 = mask0 + 6;
464
465     const_vec = __msa_ldi_h(128);
466     const_vec <<= 6;
467
468     for (loop_cnt = (height >> 3); loop_cnt--;) {
469         LD_SB8(src0_ptr, src_stride, src0, src1, src2, src3,
470                src4, src5, src6, src7);
471         src0_ptr += (8 * src_stride);
472         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
473         src1_ptr += (8 * src2_stride);
474
475         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
476         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
477         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
478
479         VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,
480                    vec0, vec1, vec2, vec3);
481         dst0 = const_vec;
482         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
483                      dst0, dst0, dst0, dst0);
484         VSHF_B4_SB(src2, src3, mask0, mask1, mask2, mask3,
485                    vec0, vec1, vec2, vec3);
486         dst1 = const_vec;
487         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
488                      dst1, dst1, dst1, dst1);
489         VSHF_B4_SB(src4, src5, mask0, mask1, mask2, mask3,
490                    vec0, vec1, vec2, vec3);
491         dst2 = const_vec;
492         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
493                      dst2, dst2, dst2, dst2);
494         VSHF_B4_SB(src6, src7, mask0, mask1, mask2, mask3,
495                    vec0, vec1, vec2, vec3);
496         dst3 = const_vec;
497         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
498                      dst3, dst3, dst3, dst3);
499
500         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
501                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
502
503         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
504         ST4x8_UB(dst0, dst1, dst, dst_stride);
505         dst += (8 * dst_stride);
506     }
507 }
508
509 static void hevc_hz_bi_8t_8w_msa(uint8_t *src0_ptr,
510                                  int32_t src_stride,
511                                  int16_t *src1_ptr,
512                                  int32_t src2_stride,
513                                  uint8_t *dst,
514                                  int32_t dst_stride,
515                                  const int8_t *filter,
516                                  int32_t height)
517 {
518     uint32_t loop_cnt;
519     v8i16 filt0, filt1, filt2, filt3;
520     v16i8 src0, src1, src2, src3;
521     v16i8 mask1, mask2, mask3;
522     v16i8 vec0, vec1, vec2, vec3;
523     v8i16 dst0, dst1, dst2, dst3;
524     v8i16 in0, in1, in2, in3;
525     v8i16 filter_vec, const_vec;
526     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
527
528     src0_ptr -= 3;
529
530     const_vec = __msa_ldi_h(128);
531     const_vec <<= 6;
532
533     filter_vec = LD_SH(filter);
534     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
535
536     mask1 = mask0 + 2;
537     mask2 = mask0 + 4;
538     mask3 = mask0 + 6;
539
540     for (loop_cnt = (height >> 2); loop_cnt--;) {
541         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
542         src0_ptr += (4 * src_stride);
543         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
544         src1_ptr += (4 * src2_stride);
545         XORI_B4_128_SB(src0, src1, src2, src3);
546
547         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
548                    vec0, vec1, vec2, vec3);
549         dst0 = const_vec;
550         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
551                      dst0, dst0, dst0, dst0);
552         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
553                    vec0, vec1, vec2, vec3);
554         dst1 = const_vec;
555         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
556                      dst1, dst1, dst1, dst1);
557         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
558                    vec0, vec1, vec2, vec3);
559         dst2 = const_vec;
560         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
561                      dst2, dst2, dst2, dst2);
562         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
563                    vec0, vec1, vec2, vec3);
564         dst3 = const_vec;
565         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
566                      dst3, dst3, dst3, dst3);
567
568         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
569                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
570
571         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
572         ST8x4_UB(dst0, dst1, dst, dst_stride);
573         dst += (4 * dst_stride);
574     }
575 }
576
577 static void hevc_hz_bi_8t_12w_msa(uint8_t *src0_ptr,
578                                   int32_t src_stride,
579                                   int16_t *src1_ptr,
580                                   int32_t src2_stride,
581                                   uint8_t *dst,
582                                   int32_t dst_stride,
583                                   const int8_t *filter,
584                                   int32_t height)
585 {
586     hevc_hz_bi_8t_8w_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
587                          dst, dst_stride, filter, height);
588     hevc_hz_bi_8t_4w_msa(src0_ptr + 8, src_stride, src1_ptr + 8, src2_stride,
589                          dst + 8, dst_stride, filter, height);
590 }
591
592 static void hevc_hz_bi_8t_16w_msa(uint8_t *src0_ptr,
593                                   int32_t src_stride,
594                                   int16_t *src1_ptr,
595                                   int32_t src2_stride,
596                                   uint8_t *dst,
597                                   int32_t dst_stride,
598                                   const int8_t *filter,
599                                   int32_t height)
600 {
601     uint32_t loop_cnt;
602     v16i8 src0, src1, src2, src3;
603     v8i16 filt0, filt1, filt2, filt3;
604     v16i8 mask1, mask2, mask3;
605     v16i8 vec0, vec1, vec2, vec3;
606     v8i16 dst0, dst1, dst2, dst3;
607     v8i16 in0, in1, in2, in3;
608     v8i16 filter_vec, const_vec;
609     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
610
611     src0_ptr -= 3;
612     const_vec = __msa_ldi_h(128);
613     const_vec <<= 6;
614
615     filter_vec = LD_SH(filter);
616     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
617
618     mask1 = mask0 + 2;
619     mask2 = mask0 + 4;
620     mask3 = mask0 + 6;
621
622     for (loop_cnt = (height >> 1); loop_cnt--;) {
623         LD_SB2(src0_ptr, 8, src0, src1);
624         src0_ptr += src_stride;
625         LD_SB2(src0_ptr, 8, src2, src3);
626         src0_ptr += src_stride;
627         LD_SH2(src1_ptr, 8, in0, in1);
628         src1_ptr += src2_stride;
629         LD_SH2(src1_ptr, 8, in2, in3);
630         src1_ptr += src2_stride;
631         XORI_B4_128_SB(src0, src1, src2, src3);
632
633         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
634                    vec0, vec1, vec2, vec3);
635         dst0 = const_vec;
636         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
637                      dst0, dst0, dst0, dst0);
638         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
639                    vec0, vec1, vec2, vec3);
640         dst1 = const_vec;
641         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
642                      dst1, dst1, dst1, dst1);
643         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
644                    vec0, vec1, vec2, vec3);
645         dst2 = const_vec;
646         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
647                      dst2, dst2, dst2, dst2);
648         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
649                    vec0, vec1, vec2, vec3);
650         dst3 = const_vec;
651         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
652                      dst3, dst3, dst3, dst3);
653
654         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
655                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
656
657         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
658         ST_SH2(dst0, dst1, dst, dst_stride);
659         dst += (2 * dst_stride);
660     }
661 }
662
663 static void hevc_hz_bi_8t_24w_msa(uint8_t *src0_ptr,
664                                   int32_t src_stride,
665                                   int16_t *src1_ptr,
666                                   int32_t src2_stride,
667                                   uint8_t *dst,
668                                   int32_t dst_stride,
669                                   const int8_t *filter,
670                                   int32_t height)
671 {
672     uint32_t loop_cnt;
673     uint64_t dst_val0;
674     v16i8 src0, src1, tmp0, tmp1;
675     v8i16 filt0, filt1, filt2, filt3;
676     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
677     v16i8 vec0, vec1, vec2, vec3;
678     v8i16 dst0, dst1, dst2;
679     v8i16 in0, in1, in2;
680     v8i16 filter_vec, const_vec;
681     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
682
683     src0_ptr = src0_ptr - 3;
684     const_vec = __msa_ldi_h(128);
685     const_vec <<= 6;
686
687     filter_vec = LD_SH(filter);
688     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
689
690     mask1 = mask0 + 2;
691     mask2 = mask0 + 4;
692     mask3 = mask0 + 6;
693     mask4 = mask0 + 8;
694     mask5 = mask0 + 10;
695     mask6 = mask0 + 12;
696     mask7 = mask0 + 14;
697
698     for (loop_cnt = height; loop_cnt--;) {
699         LD_SB2(src0_ptr, 16, src0, src1);
700         src0_ptr += src_stride;
701         LD_SH2(src1_ptr, 8, in0, in1);
702         in2 = LD_SH(src1_ptr + 16);
703         src1_ptr += src2_stride;
704         XORI_B2_128_SB(src0, src1);
705
706         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
707                    vec0, vec1, vec2, vec3);
708         dst0 = const_vec;
709         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
710                      dst0, dst0, dst0, dst0);
711         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
712                    vec0, vec1, vec2, vec3);
713         dst1 = const_vec;
714         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
715                      dst1, dst1, dst1, dst1);
716         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
717                    vec0, vec1, vec2, vec3);
718         dst2 = const_vec;
719         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
720                      dst2, dst2, dst2, dst2);
721
722         HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
723         dst2 = __msa_adds_s_h(dst2, in2);
724         dst2 = __msa_srari_h(dst2, 7);
725         dst2 = CLIP_SH_0_255(dst2);
726
727         PCKEV_B2_SB(dst1, dst0, dst2, dst2, tmp0, tmp1);
728         dst_val0 = __msa_copy_u_d((v2i64) tmp1, 0);
729         ST_SB(tmp0, dst);
730         SD(dst_val0, dst + 16);
731         dst += dst_stride;
732     }
733 }
734
735 static void hevc_hz_bi_8t_32w_msa(uint8_t *src0_ptr,
736                                   int32_t src_stride,
737                                   int16_t *src1_ptr,
738                                   int32_t src2_stride,
739                                   uint8_t *dst,
740                                   int32_t dst_stride,
741                                   const int8_t *filter,
742                                   int32_t height)
743 {
744     uint32_t loop_cnt;
745     v16i8 src0, src1, src2, tmp0, tmp1;
746     v8i16 filt0, filt1, filt2, filt3;
747     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
748     v16i8 vec0, vec1, vec2, vec3;
749     v8i16 dst0, dst1, dst2, dst3;
750     v8i16 in0, in1, in2, in3;
751     v8i16 filter_vec, const_vec;
752     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
753
754     src0_ptr -= 3;
755     const_vec = __msa_ldi_h(128);
756     const_vec <<= 6;
757
758     filter_vec = LD_SH(filter);
759     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
760
761     mask1 = mask0 + 2;
762     mask2 = mask0 + 4;
763     mask3 = mask0 + 6;
764     mask4 = mask0 + 8;
765     mask5 = mask0 + 10;
766     mask6 = mask0 + 12;
767     mask7 = mask0 + 14;
768
769     for (loop_cnt = height; loop_cnt--;) {
770         LD_SB2(src0_ptr, 16, src0, src1);
771         src2 = LD_SB(src0_ptr + 24);
772         src0_ptr += src_stride;
773         LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
774         src1_ptr += src2_stride;
775         XORI_B3_128_SB(src0, src1, src2);
776
777         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
778                    vec0, vec1, vec2, vec3);
779         dst0 = const_vec;
780         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
781                      dst0, dst0, dst0, dst0);
782         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
783                    vec0, vec1, vec2, vec3);
784         dst1 = const_vec;
785         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
786                      dst1, dst1, dst1, dst1);
787         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
788                    vec0, vec1, vec2, vec3);
789         dst2 = const_vec;
790         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
791                      dst2, dst2, dst2, dst2);
792         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
793                    vec0, vec1, vec2, vec3);
794         dst3 = const_vec;
795         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
796                      dst3, dst3, dst3, dst3);
797
798         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
799                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
800
801         PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
802         ST_SB2(tmp0, tmp1, dst, 16);
803         dst += dst_stride;
804     }
805 }
806
807 static void hevc_hz_bi_8t_48w_msa(uint8_t *src0_ptr,
808                                   int32_t src_stride,
809                                   int16_t *src1_ptr,
810                                   int32_t src2_stride,
811                                   uint8_t *dst,
812                                   int32_t dst_stride,
813                                   const int8_t *filter,
814                                   int32_t height)
815 {
816     uint32_t loop_cnt;
817     v16i8 src0, src1, src2, src3;
818     v16i8 tmp0, tmp1, tmp2;
819     v8i16 filt0, filt1, filt2, filt3;
820     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
821     v16i8 vec0, vec1, vec2, vec3;
822     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
823     v8i16 in0, in1, in2, in3, in4, in5;
824     v8i16 filter_vec, const_vec;
825     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
826
827     src0_ptr -= 3;
828
829     const_vec = __msa_ldi_h(128);
830     const_vec <<= 6;
831
832     filter_vec = LD_SH(filter);
833     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
834
835     mask1 = mask0 + 2;
836     mask2 = mask0 + 4;
837     mask3 = mask0 + 6;
838     mask4 = mask0 + 8;
839     mask5 = mask0 + 10;
840     mask6 = mask0 + 12;
841     mask7 = mask0 + 14;
842
843     for (loop_cnt = height; loop_cnt--;) {
844         LD_SB2(src0_ptr, 16, src0, src1);
845         XORI_B2_128_SB(src0, src1);
846         LD_SH2(src1_ptr, 8, in0, in1);
847
848         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
849                    vec0, vec1, vec2, vec3);
850         dst0 = const_vec;
851         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
852                      dst0, dst0, dst0, dst0);
853         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
854                    vec0, vec1, vec2, vec3);
855         dst1 = const_vec;
856         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
857                      dst1, dst1, dst1, dst1);
858
859         HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
860
861         tmp0 = __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
862         ST_SB(tmp0, dst);
863
864         LD_SB2(src0_ptr + 32, 8, src2, src3);
865         XORI_B2_128_SB(src2, src3);
866         src0_ptr += src_stride;
867
868         LD_SH2(src1_ptr + 16, 8, in2, in3);
869
870         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
871                    vec0, vec1, vec2, vec3);
872         dst2 = const_vec;
873         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
874                      dst2, dst2, dst2, dst2);
875         VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
876                    vec0, vec1, vec2, vec3);
877         dst3 = const_vec;
878         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
879                      dst3, dst3, dst3, dst3);
880
881         HEVC_BI_RND_CLIP2(in2, in3, dst2, dst3, 7, dst2, dst3);
882
883         tmp1 = __msa_pckev_b((v16i8) dst3, (v16i8) dst2);
884         ST_SB(tmp1, dst + 16);
885
886         LD_SH2(src1_ptr + 32, 8, in4, in5);
887         src1_ptr += src2_stride;
888
889         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
890                    vec0, vec1, vec2, vec3);
891         dst4 = const_vec;
892         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
893                      dst4, dst4, dst4, dst4);
894         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
895                    vec0, vec1, vec2, vec3);
896         dst5 = const_vec;
897         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
898                      dst5, dst5, dst5, dst5);
899
900         HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
901
902         tmp2 = __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
903         ST_SB(tmp2, dst + 32);
904         dst += dst_stride;
905     }
906 }
907
908 static void hevc_hz_bi_8t_64w_msa(uint8_t *src0_ptr,
909                                   int32_t src_stride,
910                                   int16_t *src1_ptr,
911                                   int32_t src2_stride,
912                                   uint8_t *dst,
913                                   int32_t dst_stride,
914                                   const int8_t *filter,
915                                   int32_t height)
916 {
917     uint8_t *src0_ptr_tmp;
918     uint8_t *dst_tmp;
919     int16_t *src1_ptr_tmp;
920     uint32_t loop_cnt;
921     uint32_t cnt;
922     v16i8 src0, src1, src2, tmp0, tmp1;
923     v8i16 filt0, filt1, filt2, filt3;
924     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
925     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
926     v16i8 vec0, vec1, vec2, vec3;
927     v8i16 dst0, dst1, dst2, dst3;
928     v8i16 in0, in1, in2, in3;
929     v8i16 filter_vec, const_vec;
930
931     src0_ptr -= 3;
932
933     const_vec = __msa_ldi_h(128);
934     const_vec <<= 6;
935
936     filter_vec = LD_SH(filter);
937     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
938
939     mask1 = mask0 + 2;
940     mask2 = mask0 + 4;
941     mask3 = mask0 + 6;
942     mask4 = mask0 + 8;
943     mask5 = mask0 + 10;
944     mask6 = mask0 + 12;
945     mask7 = mask0 + 14;
946
947     for (loop_cnt = height; loop_cnt--;) {
948         src0_ptr_tmp = src0_ptr;
949         dst_tmp = dst;
950         src1_ptr_tmp = src1_ptr;
951
952         for (cnt = 2; cnt--;) {
953             LD_SB2(src0_ptr_tmp, 16, src0, src1);
954             src2 = LD_SB(src0_ptr_tmp + 24);
955             src0_ptr_tmp += 32;
956             LD_SH4(src1_ptr_tmp, 8, in0, in1, in2, in3);
957             src1_ptr_tmp += 32;
958             XORI_B3_128_SB(src0, src1, src2);
959
960             VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
961                        vec0, vec1, vec2, vec3);
962             dst0 = const_vec;
963             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
964                          dst0, dst0, dst0, dst0);
965             VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
966                        vec0, vec1, vec2, vec3);
967             dst1 = const_vec;
968             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
969                          dst1, dst1, dst1, dst1);
970             VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
971                        vec0, vec1, vec2, vec3);
972             dst2 = const_vec;
973             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
974                          dst2, dst2, dst2, dst2);
975             VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
976                        vec0, vec1, vec2, vec3);
977             dst3 = const_vec;
978             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
979                          dst3, dst3, dst3, dst3);
980
981             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
982                               dst0, dst1, dst2, dst3, 7,
983                               dst0, dst1, dst2, dst3);
984
985             PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
986             ST_SB2(tmp0, tmp1, dst_tmp, 16);
987             dst_tmp += 32;
988         }
989
990         src1_ptr += src2_stride;
991         src0_ptr += src_stride;
992         dst += dst_stride;
993     }
994 }
995
996 static void hevc_vt_bi_8t_4w_msa(uint8_t *src0_ptr,
997                                  int32_t src_stride,
998                                  int16_t *src1_ptr,
999                                  int32_t src2_stride,
1000                                  uint8_t *dst,
1001                                  int32_t dst_stride,
1002                                  const int8_t *filter,
1003                                  int32_t height)
1004 {
1005     int32_t loop_cnt;
1006     v16i8 src0, src1, src2, src3, src4, src5;
1007     v16i8 src6, src7, src8, src9, src10;
1008     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
1009     v16i8 src11, src12, src13, src14;
1010     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1011     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1012     v16i8 src1110_r, src1211_r, src1312_r, src1413_r;
1013     v16i8 src2110, src4332, src6554, src8776, src10998;
1014     v16i8 src12111110, src14131312;
1015     v8i16 dst10, dst32, dst54, dst76;
1016     v8i16 filt0, filt1, filt2, filt3;
1017     v8i16 filter_vec, const_vec;
1018
1019     src0_ptr -= (3 * src_stride);
1020
1021     const_vec = __msa_ldi_h(128);
1022     const_vec <<= 6;
1023
1024     filter_vec = LD_SH(filter);
1025     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1026
1027     LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1028     src0_ptr += (7 * src_stride);
1029     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1030                src10_r, src32_r, src54_r, src21_r);
1031     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1032     ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
1033                src2110, src4332, src6554);
1034     XORI_B3_128_SB(src2110, src4332, src6554);
1035
1036     for (loop_cnt = (height >> 3); loop_cnt--;) {
1037         LD_SB8(src0_ptr, src_stride,
1038                src7, src8, src9, src10, src11, src12, src13, src14);
1039         src0_ptr += (8 * src_stride);
1040         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
1041         src1_ptr += (8 * src2_stride);
1042
1043         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
1044         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
1045         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1046                    src76_r, src87_r, src98_r, src109_r);
1047         ILVR_B4_SB(src11, src10, src12, src11, src13, src12, src14, src13,
1048                    src1110_r, src1211_r, src1312_r, src1413_r);
1049         ILVR_D4_SB(src87_r, src76_r, src109_r, src98_r, src1211_r, src1110_r,
1050                    src1413_r, src1312_r,
1051                    src8776, src10998, src12111110, src14131312);
1052         XORI_B4_128_SB(src8776, src10998, src12111110, src14131312);
1053
1054         dst10 = const_vec;
1055         DPADD_SB4_SH(src2110, src4332, src6554, src8776,
1056                      filt0, filt1, filt2, filt3, dst10, dst10, dst10, dst10);
1057         dst32 = const_vec;
1058         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
1059                      filt0, filt1, filt2, filt3, dst32, dst32, dst32, dst32);
1060         dst54 = const_vec;
1061         DPADD_SB4_SH(src6554, src8776, src10998, src12111110,
1062                      filt0, filt1, filt2, filt3, dst54, dst54, dst54, dst54);
1063         dst76 = const_vec;
1064         DPADD_SB4_SH(src8776, src10998, src12111110, src14131312,
1065                      filt0, filt1, filt2, filt3, dst76, dst76, dst76, dst76);
1066
1067         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1068                           dst10, dst32, dst54, dst76, 7,
1069                           dst10, dst32, dst54, dst76);
1070
1071         PCKEV_B2_SH(dst32, dst10, dst76, dst54, dst10, dst54);
1072         ST4x8_UB(dst10, dst54, dst, dst_stride);
1073         dst += (8 * dst_stride);
1074
1075         src2110 = src10998;
1076         src4332 = src12111110;
1077         src6554 = src14131312;
1078         src6 = src14;
1079     }
1080 }
1081
1082 static void hevc_vt_bi_8t_8w_msa(uint8_t *src0_ptr,
1083                                  int32_t src_stride,
1084                                  int16_t *src1_ptr,
1085                                  int32_t src2_stride,
1086                                  uint8_t *dst,
1087                                  int32_t dst_stride,
1088                                  const int8_t *filter,
1089                                  int32_t height)
1090 {
1091     int32_t loop_cnt;
1092     v16i8 src0, src1, src2, src3, src4, src5;
1093     v16i8 src6, src7, src8, src9, src10;
1094     v8i16 in0, in1, in2, in3;
1095     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1096     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1097     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
1098     v8i16 filt0, filt1, filt2, filt3;
1099     v8i16 filter_vec, const_vec;
1100
1101     src0_ptr -= (3 * src_stride);
1102     const_vec = __msa_ldi_h(128);
1103     const_vec <<= 6;
1104
1105     filter_vec = LD_SH(filter);
1106     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1107
1108     LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1109     src0_ptr += (7 * src_stride);
1110     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1111     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1112                src10_r, src32_r, src54_r, src21_r);
1113     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1114
1115     for (loop_cnt = (height >> 2); loop_cnt--;) {
1116         LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
1117         src0_ptr += (4 * src_stride);
1118         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1119         src1_ptr += (4 * src2_stride);
1120         XORI_B4_128_SB(src7, src8, src9, src10);
1121         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1122                    src76_r, src87_r, src98_r, src109_r);
1123
1124         dst0_r = const_vec;
1125         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1126                      filt0, filt1, filt2, filt3,
1127                      dst0_r, dst0_r, dst0_r, dst0_r);
1128         dst1_r = const_vec;
1129         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1130                      filt0, filt1, filt2, filt3,
1131                      dst1_r, dst1_r, dst1_r, dst1_r);
1132         dst2_r = const_vec;
1133         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1134                      filt0, filt1, filt2, filt3,
1135                      dst2_r, dst2_r, dst2_r, dst2_r);
1136         dst3_r = const_vec;
1137         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1138                      filt0, filt1, filt2, filt3,
1139                      dst3_r, dst3_r, dst3_r, dst3_r);
1140
1141         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1142                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
1143                           dst0_r, dst1_r, dst2_r, dst3_r);
1144
1145         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
1146         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
1147         dst += (4 * dst_stride);
1148
1149         src10_r = src54_r;
1150         src32_r = src76_r;
1151         src54_r = src98_r;
1152         src21_r = src65_r;
1153         src43_r = src87_r;
1154         src65_r = src109_r;
1155
1156         src6 = src10;
1157     }
1158 }
1159
1160 static void hevc_vt_bi_8t_12w_msa(uint8_t *src0_ptr,
1161                                   int32_t src_stride,
1162                                   int16_t *src1_ptr,
1163                                   int32_t src2_stride,
1164                                   uint8_t *dst,
1165                                   int32_t dst_stride,
1166                                   const int8_t *filter,
1167                                   int32_t height)
1168 {
1169     int32_t loop_cnt;
1170     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1171     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
1172     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1173     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1174     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
1175     v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
1176     v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
1177     v16i8 src2110, src4332, src6554, src8776, src10998;
1178     v8i16 dst0_l, dst1_l;
1179     v8i16 filt0, filt1, filt2, filt3;
1180     v8i16 filter_vec, const_vec;
1181
1182     src0_ptr -= (3 * src_stride);
1183     const_vec = __msa_ldi_h(128);
1184     const_vec <<= 6;
1185
1186     filter_vec = LD_SH(filter);
1187     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1188
1189     LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1190     src0_ptr += (7 * src_stride);
1191     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1192
1193     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1194                src10_r, src32_r, src54_r, src21_r);
1195     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1196     ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1197                src10_l, src32_l, src54_l, src21_l);
1198     ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1199     ILVR_D3_SB(src21_l, src10_l, src43_l, src32_l, src65_l, src54_l,
1200                src2110, src4332, src6554);
1201
1202     for (loop_cnt = (height >> 2); loop_cnt--;) {
1203         LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
1204         src0_ptr += (4 * src_stride);
1205         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1206         LD_SH4((src1_ptr + 8), src2_stride, in4, in5, in6, in7);
1207         src1_ptr += (4 * src2_stride);
1208
1209         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
1210         XORI_B4_128_SB(src7, src8, src9, src10);
1211         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1212                    src76_r, src87_r, src98_r, src109_r);
1213         ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1214                    src76_l, src87_l, src98_l, src109_l);
1215         ILVR_D2_SB(src87_l, src76_l, src109_l, src98_l, src8776, src10998);
1216
1217         dst0_r = const_vec;
1218         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1219                      filt0, filt1, filt2, filt3,
1220                      dst0_r, dst0_r, dst0_r, dst0_r);
1221         dst1_r = const_vec;
1222         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1223                      filt0, filt1, filt2, filt3,
1224                      dst1_r, dst1_r, dst1_r, dst1_r);
1225         dst2_r = const_vec;
1226         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1227                      filt0, filt1, filt2, filt3,
1228                      dst2_r, dst2_r, dst2_r, dst2_r);
1229         dst3_r = const_vec;
1230         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1231                      filt0, filt1, filt2, filt3,
1232                      dst3_r, dst3_r, dst3_r, dst3_r);
1233         dst0_l = const_vec;
1234         DPADD_SB4_SH(src2110, src4332, src6554, src8776,
1235                      filt0, filt1, filt2, filt3,
1236                      dst0_l, dst0_l, dst0_l, dst0_l);
1237         dst1_l = const_vec;
1238         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
1239                      filt0, filt1, filt2, filt3,
1240                      dst1_l, dst1_l, dst1_l, dst1_l);
1241
1242         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1243                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
1244                           dst0_r, dst1_r, dst2_r, dst3_r);
1245         HEVC_BI_RND_CLIP2(in4, in5, dst0_l, dst1_l, 7, dst0_l, dst1_l);
1246
1247
1248         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
1249         dst0_l = (v8i16) __msa_pckev_b((v16i8) dst1_l, (v16i8) dst0_l);
1250         ST12x4_UB(dst0_r, dst1_r, dst0_l, dst, dst_stride);
1251         dst += (4 * dst_stride);
1252
1253         src10_r = src54_r;
1254         src32_r = src76_r;
1255         src54_r = src98_r;
1256         src21_r = src65_r;
1257         src43_r = src87_r;
1258         src65_r = src109_r;
1259         src2110 = src6554;
1260         src4332 = src8776;
1261         src6554 = src10998;
1262         src6 = src10;
1263     }
1264 }
1265
1266 static void hevc_vt_bi_8t_16multx2mult_msa(uint8_t *src0_ptr,
1267                                            int32_t src_stride,
1268                                            int16_t *src1_ptr,
1269                                            int32_t src2_stride,
1270                                            uint8_t *dst,
1271                                            int32_t dst_stride,
1272                                            const int8_t *filter,
1273                                            int32_t height, int32_t width)
1274 {
1275     uint8_t *src0_ptr_tmp;
1276     int16_t *src1_ptr_tmp;
1277     uint8_t *dst_tmp;
1278     uint32_t loop_cnt;
1279     uint32_t cnt;
1280     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1281     v8i16 in0, in1, in2, in3;
1282     v16i8 src10_r, src32_r, src54_r, src76_r;
1283     v16i8 src21_r, src43_r, src65_r, src87_r;
1284     v8i16 dst0_r, dst1_r;
1285     v16i8 src10_l, src32_l, src54_l, src76_l;
1286     v16i8 src21_l, src43_l, src65_l, src87_l;
1287     v8i16 dst0_l, dst1_l;
1288     v8i16 filt0, filt1, filt2, filt3;
1289     v8i16 filter_vec, const_vec;
1290
1291     src0_ptr -= (3 * src_stride);
1292     const_vec = __msa_ldi_h(128);
1293     const_vec <<= 6;
1294
1295     filter_vec = LD_SH(filter);
1296     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1297
1298     for (cnt = (width >> 4); cnt--;) {
1299         src0_ptr_tmp = src0_ptr;
1300         src1_ptr_tmp = src1_ptr;
1301         dst_tmp = dst;
1302
1303         LD_SB7(src0_ptr_tmp, src_stride,
1304                src0, src1, src2, src3, src4, src5, src6);
1305         src0_ptr_tmp += (7 * src_stride);
1306         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1307
1308         ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1309                    src10_r, src32_r, src54_r, src21_r);
1310         ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1311         ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1312                    src10_l, src32_l, src54_l, src21_l);
1313         ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1314
1315         for (loop_cnt = (height >> 1); loop_cnt--;) {
1316             LD_SB2(src0_ptr_tmp, src_stride, src7, src8);
1317             src0_ptr_tmp += (2 * src_stride);
1318             LD_SH2(src1_ptr_tmp, src2_stride, in0, in1);
1319             LD_SH2((src1_ptr_tmp + 8), src2_stride, in2, in3);
1320             src1_ptr_tmp += (2 * src2_stride);
1321             XORI_B2_128_SB(src7, src8);
1322
1323             ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
1324             ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
1325
1326             dst0_r = const_vec;
1327             DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1328                          filt0, filt1, filt2, filt3,
1329                          dst0_r, dst0_r, dst0_r, dst0_r);
1330             dst1_r = const_vec;
1331             DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1332                          filt0, filt1, filt2, filt3,
1333                          dst1_r, dst1_r, dst1_r, dst1_r);
1334             dst0_l = const_vec;
1335             DPADD_SB4_SH(src10_l, src32_l, src54_l, src76_l,
1336                          filt0, filt1, filt2, filt3,
1337                          dst0_l, dst0_l, dst0_l, dst0_l);
1338             dst1_l = const_vec;
1339             DPADD_SB4_SH(src21_l, src43_l, src65_l, src87_l,
1340                          filt0, filt1, filt2, filt3,
1341                          dst1_l, dst1_l, dst1_l, dst1_l);
1342
1343             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1344                               dst0_r, dst1_r, dst0_l, dst1_l, 7,
1345                               dst0_r, dst1_r, dst0_l, dst1_l);
1346
1347             PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
1348             ST_SH2(dst0_r, dst1_r, dst_tmp, dst_stride);
1349             dst_tmp += (2 * dst_stride);
1350
1351             src10_r = src32_r;
1352             src32_r = src54_r;
1353             src54_r = src76_r;
1354             src21_r = src43_r;
1355             src43_r = src65_r;
1356             src65_r = src87_r;
1357             src10_l = src32_l;
1358             src32_l = src54_l;
1359             src54_l = src76_l;
1360             src21_l = src43_l;
1361             src43_l = src65_l;
1362             src65_l = src87_l;
1363             src6 = src8;
1364         }
1365
1366         src0_ptr += 16;
1367         src1_ptr += 16;
1368         dst += 16;
1369     }
1370 }
1371
1372 static void hevc_vt_bi_8t_16w_msa(uint8_t *src0_ptr,
1373                                   int32_t src_stride,
1374                                   int16_t *src1_ptr,
1375                                   int32_t src2_stride,
1376                                   uint8_t *dst,
1377                                   int32_t dst_stride,
1378                                   const int8_t *filter,
1379                                   int32_t height)
1380 {
1381     hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1382                                    dst, dst_stride, filter, height, 16);
1383 }
1384
1385 static void hevc_vt_bi_8t_24w_msa(uint8_t *src0_ptr,
1386                                   int32_t src_stride,
1387                                   int16_t *src1_ptr,
1388                                   int32_t src2_stride,
1389                                   uint8_t *dst,
1390                                   int32_t dst_stride,
1391                                   const int8_t *filter,
1392                                   int32_t height)
1393 {
1394     hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1395                                    dst, dst_stride, filter, height, 16);
1396     hevc_vt_bi_8t_8w_msa(src0_ptr + 16, src_stride, src1_ptr + 16, src2_stride,
1397                          dst + 16, dst_stride, filter, height);
1398 }
1399
1400 static void hevc_vt_bi_8t_32w_msa(uint8_t *src0_ptr,
1401                                   int32_t src_stride,
1402                                   int16_t *src1_ptr,
1403                                   int32_t src2_stride,
1404                                   uint8_t *dst,
1405                                   int32_t dst_stride,
1406                                   const int8_t *filter,
1407                                   int32_t height)
1408 {
1409     hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1410                                    dst, dst_stride, filter, height, 32);
1411 }
1412
1413 static void hevc_vt_bi_8t_48w_msa(uint8_t *src0_ptr,
1414                                   int32_t src_stride,
1415                                   int16_t *src1_ptr,
1416                                   int32_t src2_stride,
1417                                   uint8_t *dst,
1418                                   int32_t dst_stride,
1419                                   const int8_t *filter,
1420                                   int32_t height)
1421 {
1422     hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1423                                    dst, dst_stride, filter, height, 48);
1424 }
1425
1426 static void hevc_vt_bi_8t_64w_msa(uint8_t *src0_ptr,
1427                                   int32_t src_stride,
1428                                   int16_t *src1_ptr,
1429                                   int32_t src2_stride,
1430                                   uint8_t *dst,
1431                                   int32_t dst_stride,
1432                                   const int8_t *filter,
1433                                   int32_t height)
1434 {
1435     hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1436                                    dst, dst_stride, filter, height, 64);
1437 }
1438
1439 static void hevc_hv_bi_8t_4w_msa(uint8_t *src0_ptr,
1440                                  int32_t src_stride,
1441                                  int16_t *src1_ptr,
1442                                  int32_t src2_stride,
1443                                  uint8_t *dst,
1444                                  int32_t dst_stride,
1445                                  const int8_t *filter_x,
1446                                  const int8_t *filter_y,
1447                                  int32_t height)
1448 {
1449     uint32_t loop_cnt;
1450     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1451     v8i16 in0, in1;
1452     v8i16 filt0, filt1, filt2, filt3;
1453     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
1454     v16i8 mask1, mask2, mask3;
1455     v8i16 filter_vec, const_vec;
1456     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1457     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1458     v8i16 dst30, dst41, dst52, dst63, dst66, dst87;
1459     v4i32 dst0_r, dst1_r, in0_r, in0_l;
1460     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1461     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
1462     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1463     v8u16 mask4 = { 0, 4, 1, 5, 2, 6, 3, 7 };
1464
1465     src0_ptr -= ((3 * src_stride) + 3);
1466     filter_vec = LD_SH(filter_x);
1467     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1468
1469     filter_vec = LD_SH(filter_y);
1470     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
1471     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
1472
1473     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1474
1475     mask1 = mask0 + 2;
1476     mask2 = mask0 + 4;
1477     mask3 = mask0 + 6;
1478
1479     const_vec = __msa_ldi_h(128);
1480     const_vec <<= 6;
1481
1482     LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1483     src0_ptr += (7 * src_stride);
1484     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1485
1486     /* row 0 row 1 row 2 row 3 */
1487     VSHF_B4_SB(src0, src3, mask0, mask1, mask2, mask3, vec0, vec1, vec2, vec3);
1488     VSHF_B4_SB(src1, src4, mask0, mask1, mask2, mask3, vec4, vec5, vec6, vec7);
1489     VSHF_B4_SB(src2, src5, mask0, mask1, mask2, mask3,
1490                vec8, vec9, vec10, vec11);
1491     VSHF_B4_SB(src3, src6, mask0, mask1, mask2, mask3,
1492                vec12, vec13, vec14, vec15);
1493
1494     dst30 = const_vec;
1495     DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1496                  dst30, dst30, dst30, dst30);
1497     dst41 = const_vec;
1498     DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1499                  dst41, dst41, dst41, dst41);
1500     dst52 = const_vec;
1501     DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1502                  dst52, dst52, dst52, dst52);
1503     dst63 = const_vec;
1504     DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
1505                  dst63, dst63, dst63, dst63);
1506
1507     ILVR_H3_SH(dst41, dst30, dst52, dst41, dst63, dst52,
1508                dst10_r, dst21_r, dst32_r);
1509     dst43_r = __msa_ilvl_h(dst41, dst30);
1510     dst54_r = __msa_ilvl_h(dst52, dst41);
1511     dst65_r = __msa_ilvl_h(dst63, dst52);
1512     dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
1513
1514     for (loop_cnt = height >> 1; loop_cnt--;) {
1515         LD_SB2(src0_ptr, src_stride, src7, src8);
1516         src0_ptr += (2 * src_stride);
1517         LD_SH2(src1_ptr, src2_stride, in0, in1);
1518         src1_ptr += (2 * src2_stride);
1519
1520         in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
1521         XORI_B2_128_SB(src7, src8);
1522
1523         VSHF_B4_SB(src7, src8, mask0, mask1, mask2, mask3,
1524                    vec0, vec1, vec2, vec3);
1525         dst87 = const_vec;
1526         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1527                      dst87, dst87, dst87, dst87);
1528         dst76_r = __msa_ilvr_h(dst87, dst66);
1529         dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
1530                                 filt_h0, filt_h1, filt_h2, filt_h3);
1531         dst87_r = __msa_vshf_h((v8i16) mask4, dst87, dst87);
1532         dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
1533                                 filt_h0, filt_h1, filt_h2, filt_h3);
1534
1535         dst0_r >>= 6;
1536         dst1_r >>= 6;
1537         UNPCK_SH_SW(in0, in0_r, in0_l);
1538         dst0_r = __msa_adds_s_w(dst0_r, in0_r);
1539         dst1_r = __msa_adds_s_w(dst1_r, in0_l);
1540         SRARI_W2_SW(dst0_r, dst1_r, 7);
1541         dst0_r = CLIP_SW_0_255(dst0_r);
1542         dst1_r = CLIP_SW_0_255(dst1_r);
1543
1544         HEVC_PCK_SW_SB2(dst1_r, dst0_r, dst0_r);
1545         ST4x2_UB(dst0_r, dst, dst_stride);
1546         dst += (2 * dst_stride);
1547
1548         dst10_r = dst32_r;
1549         dst32_r = dst54_r;
1550         dst54_r = dst76_r;
1551         dst21_r = dst43_r;
1552         dst43_r = dst65_r;
1553         dst65_r = dst87_r;
1554         dst66 = (v8i16) __msa_splati_d((v2i64) dst87, 1);
1555     }
1556 }
1557
1558 static void hevc_hv_bi_8t_8multx2mult_msa(uint8_t *src0_ptr,
1559                                           int32_t src_stride,
1560                                           int16_t *src1_ptr,
1561                                           int32_t src2_stride,
1562                                           uint8_t *dst,
1563                                           int32_t dst_stride,
1564                                           const int8_t *filter_x,
1565                                           const int8_t *filter_y,
1566                                           int32_t height, int32_t width)
1567 {
1568     uint32_t loop_cnt;
1569     uint32_t cnt;
1570     uint8_t *src0_ptr_tmp;
1571     int16_t *src1_ptr_tmp;
1572     uint8_t *dst_tmp;
1573     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1574     v8i16 in0, in1;
1575     v4i32 in0_r, in0_l, in1_r, in1_l;
1576     v8i16 filt0, filt1, filt2, filt3;
1577     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
1578     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1579     v16i8 mask1, mask2, mask3;
1580     v8i16 filter_vec, const_vec;
1581     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1582     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1583     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
1584     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
1585     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1586     v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
1587     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
1588     v8i16 dst21_l, dst43_l, dst65_l, dst87_l;
1589
1590     src0_ptr -= ((3 * src_stride) + 3);
1591     const_vec = __msa_ldi_h(128);
1592     const_vec <<= 6;
1593
1594     filter_vec = LD_SH(filter_x);
1595     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1596
1597     filter_vec = LD_SH(filter_y);
1598     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
1599     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
1600     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1601
1602     mask1 = mask0 + 2;
1603     mask2 = mask0 + 4;
1604     mask3 = mask0 + 6;
1605
1606     for (cnt = width >> 3; cnt--;) {
1607         src0_ptr_tmp = src0_ptr;
1608         dst_tmp = dst;
1609         src1_ptr_tmp = src1_ptr;
1610
1611         LD_SB7(src0_ptr_tmp, src_stride,
1612                src0, src1, src2, src3, src4, src5, src6);
1613         src0_ptr_tmp += (7 * src_stride);
1614         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1615
1616         /* row 0 row 1 row 2 row 3 */
1617         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
1618                    vec0, vec1, vec2, vec3);
1619         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
1620                    vec4, vec5, vec6, vec7);
1621         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
1622                    vec8, vec9, vec10, vec11);
1623         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
1624                    vec12, vec13, vec14, vec15);
1625         dst0 = const_vec;
1626         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1627                      dst0, dst0, dst0, dst0);
1628         dst1 = const_vec;
1629         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1630                      dst1, dst1, dst1, dst1);
1631         dst2 = const_vec;
1632         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1633                      dst2, dst2, dst2, dst2);
1634         dst3 = const_vec;
1635         DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
1636                      dst3, dst3, dst3, dst3);
1637
1638         VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
1639                    vec0, vec1, vec2, vec3);
1640         VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
1641                    vec4, vec5, vec6, vec7);
1642         VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
1643                    vec8, vec9, vec10, vec11);
1644         dst4 = const_vec;
1645         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1646                      dst4, dst4, dst4, dst4);
1647         dst5 = const_vec;
1648         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1649                      dst5, dst5, dst5, dst5);
1650         dst6 = const_vec;
1651         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1652                      dst6, dst6, dst6, dst6);
1653
1654         ILVR_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
1655                    dst10_r, dst32_r, dst54_r, dst21_r);
1656         ILVR_H2_SH(dst4, dst3, dst6, dst5, dst43_r, dst65_r);
1657         ILVL_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
1658                    dst10_l, dst32_l, dst54_l, dst21_l);
1659         ILVL_H2_SH(dst4, dst3, dst6, dst5, dst43_l, dst65_l);
1660
1661         for (loop_cnt = height >> 1; loop_cnt--;) {
1662             /* row 7 */
1663             LD_SB2(src0_ptr_tmp, src_stride, src7, src8);
1664             XORI_B2_128_SB(src7, src8);
1665             src0_ptr_tmp += 2 * src_stride;
1666
1667             LD_SH2(src1_ptr_tmp, src2_stride, in0, in1);
1668             src1_ptr_tmp += (2 * src2_stride);
1669
1670             VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
1671                        vec0, vec1, vec2, vec3);
1672             dst7 = const_vec;
1673             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1674                          dst7, dst7, dst7, dst7);
1675
1676             ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
1677             dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
1678                                     filt_h0, filt_h1, filt_h2, filt_h3);
1679             dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l,
1680                                     filt_h0, filt_h1, filt_h2, filt_h3);
1681             dst0_r >>= 6;
1682             dst0_l >>= 6;
1683
1684             VSHF_B4_SB(src8, src8, mask0, mask1, mask2, mask3,
1685                        vec0, vec1, vec2, vec3);
1686             dst8 = const_vec;
1687             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1688                          dst8, dst8, dst8, dst8);
1689
1690             ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
1691             dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
1692                                     filt_h0, filt_h1, filt_h2, filt_h3);
1693             dst1_l = HEVC_FILT_8TAP(dst21_l, dst43_l, dst65_l, dst87_l,
1694                                     filt_h0, filt_h1, filt_h2, filt_h3);
1695             dst1_r >>= 6;
1696             dst1_l >>= 6;
1697
1698             UNPCK_SH_SW(in0, in0_r, in0_l);
1699             UNPCK_SH_SW(in1, in1_r, in1_l);
1700             in0_r = __msa_adds_s_w(in0_r, dst0_r);
1701             in0_l = __msa_adds_s_w(in0_l, dst0_l);
1702             in1_r = __msa_adds_s_w(in1_r, dst1_r);
1703             in1_l = __msa_adds_s_w(in1_l, dst1_l);
1704             SRARI_W4_SW(in0_r, in0_l, in1_r, in1_l, 7);
1705             in0_r = CLIP_SW_0_255(in0_r);
1706             in0_l = CLIP_SW_0_255(in0_l);
1707             in1_r = CLIP_SW_0_255(in1_r);
1708             in1_l = CLIP_SW_0_255(in1_l);
1709
1710             HEVC_PCK_SW_SB4(in0_l, in0_r, in1_l, in1_r, dst0_r);
1711             ST8x2_UB(dst0_r, dst_tmp, dst_stride);
1712             dst_tmp += (2 * dst_stride);
1713
1714             dst10_r = dst32_r;
1715             dst32_r = dst54_r;
1716             dst54_r = dst76_r;
1717             dst10_l = dst32_l;
1718             dst32_l = dst54_l;
1719             dst54_l = dst76_l;
1720             dst21_r = dst43_r;
1721             dst43_r = dst65_r;
1722             dst65_r = dst87_r;
1723             dst21_l = dst43_l;
1724             dst43_l = dst65_l;
1725             dst65_l = dst87_l;
1726             dst6 = dst8;
1727         }
1728
1729         src0_ptr += 8;
1730         dst += 8;
1731         src1_ptr += 8;
1732     }
1733 }
1734
1735 static void hevc_hv_bi_8t_8w_msa(uint8_t *src0_ptr,
1736                                  int32_t src_stride,
1737                                  int16_t *src1_ptr,
1738                                  int32_t src2_stride,
1739                                  uint8_t *dst,
1740                                  int32_t dst_stride,
1741                                  const int8_t *filter_x,
1742                                  const int8_t *filter_y,
1743                                  int32_t height)
1744 {
1745     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1746                                   dst, dst_stride, filter_x, filter_y,
1747                                   height, 8);
1748 }
1749
1750 static void hevc_hv_bi_8t_12w_msa(uint8_t *src0_ptr,
1751                                   int32_t src_stride,
1752                                   int16_t *src1_ptr,
1753                                   int32_t src2_stride,
1754                                   uint8_t *dst,
1755                                   int32_t dst_stride,
1756                                   const int8_t *filter_x,
1757                                   const int8_t *filter_y,
1758                                   int32_t height)
1759 {
1760     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1761                                   dst, dst_stride, filter_x, filter_y,
1762                                   height, 8);
1763
1764     hevc_hv_bi_8t_4w_msa(src0_ptr + 8, src_stride, src1_ptr + 8, src2_stride,
1765                          dst + 8, dst_stride, filter_x, filter_y, height);
1766 }
1767
1768 static void hevc_hv_bi_8t_16w_msa(uint8_t *src0_ptr,
1769                                   int32_t src_stride,
1770                                   int16_t *src1_ptr,
1771                                   int32_t src2_stride,
1772                                   uint8_t *dst,
1773                                   int32_t dst_stride,
1774                                   const int8_t *filter_x,
1775                                   const int8_t *filter_y,
1776                                   int32_t height)
1777 {
1778     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1779                                   dst, dst_stride, filter_x, filter_y,
1780                                   height, 16);
1781 }
1782
1783 static void hevc_hv_bi_8t_24w_msa(uint8_t *src0_ptr,
1784                                   int32_t src_stride,
1785                                   int16_t *src1_ptr,
1786                                   int32_t src2_stride,
1787                                   uint8_t *dst,
1788                                   int32_t dst_stride,
1789                                   const int8_t *filter_x,
1790                                   const int8_t *filter_y,
1791                                   int32_t height)
1792 {
1793     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1794                                   dst, dst_stride, filter_x, filter_y,
1795                                   height, 24);
1796 }
1797
1798 static void hevc_hv_bi_8t_32w_msa(uint8_t *src0_ptr,
1799                                   int32_t src_stride,
1800                                   int16_t *src1_ptr,
1801                                   int32_t src2_stride,
1802                                   uint8_t *dst,
1803                                   int32_t dst_stride,
1804                                   const int8_t *filter_x,
1805                                   const int8_t *filter_y,
1806                                   int32_t height)
1807 {
1808     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1809                                   dst, dst_stride, filter_x, filter_y,
1810                                   height, 32);
1811 }
1812
1813 static void hevc_hv_bi_8t_48w_msa(uint8_t *src0_ptr,
1814                                   int32_t src_stride,
1815                                   int16_t *src1_ptr,
1816                                   int32_t src2_stride,
1817                                   uint8_t *dst,
1818                                   int32_t dst_stride,
1819                                   const int8_t *filter_x,
1820                                   const int8_t *filter_y,
1821                                   int32_t height)
1822 {
1823     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1824                                   dst, dst_stride, filter_x, filter_y,
1825                                   height, 48);
1826 }
1827
1828 static void hevc_hv_bi_8t_64w_msa(uint8_t *src0_ptr,
1829                                   int32_t src_stride,
1830                                   int16_t *src1_ptr,
1831                                   int32_t src2_stride,
1832                                   uint8_t *dst,
1833                                   int32_t dst_stride,
1834                                   const int8_t *filter_x,
1835                                   const int8_t *filter_y,
1836                                   int32_t height)
1837 {
1838     hevc_hv_bi_8t_8multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1839                                   dst, dst_stride, filter_x, filter_y,
1840                                   height, 64);
1841 }
1842
1843 static void hevc_hz_bi_4t_4x2_msa(uint8_t *src0_ptr,
1844                                   int32_t src_stride,
1845                                   int16_t *src1_ptr,
1846                                   int32_t src2_stride,
1847                                   uint8_t *dst,
1848                                   int32_t dst_stride,
1849                                   const int8_t *filter,
1850                                   int32_t height)
1851 {
1852     v8i16 filt0, filt1;
1853     v16i8 src0, src1, dst0, vec0, vec1;
1854     v8i16 in0, in1;
1855     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1856     v16i8 mask1;
1857     v8i16 tmp0;
1858     v8i16 filter_vec, const_vec;
1859
1860     src0_ptr -= 1;
1861
1862     const_vec = __msa_ldi_h(128);
1863     const_vec <<= 6;
1864
1865     filter_vec = LD_SH(filter);
1866     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1867
1868     mask1 = mask0 + 2;
1869
1870     LD_SB2(src0_ptr, src_stride, src0, src1);
1871     LD_SH2(src1_ptr, src2_stride, in0, in1);
1872     in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
1873     XORI_B2_128_SB(src0, src1);
1874     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1875     tmp0 = const_vec;
1876     DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
1877
1878     tmp0 = __msa_adds_s_h(tmp0, in0);
1879     tmp0 = __msa_srari_h(tmp0, 7);
1880     tmp0 = CLIP_SH_0_255(tmp0);
1881     dst0 = __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
1882
1883     ST4x2_UB(dst0, dst, dst_stride);
1884 }
1885
1886 static void hevc_hz_bi_4t_4x4_msa(uint8_t *src0_ptr,
1887                                   int32_t src_stride,
1888                                   int16_t *src1_ptr,
1889                                   int32_t src2_stride,
1890                                   uint8_t *dst,
1891                                   int32_t dst_stride,
1892                                   const int8_t *filter,
1893                                   int32_t height)
1894 {
1895     v8i16 filt0, filt1;
1896     v16i8 src0, src1, src2, src3, dst0, vec0, vec1;
1897     v8i16 in0, in1, in2, in3;
1898     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1899     v16i8 mask1;
1900     v8i16 tmp0, tmp1;
1901     v8i16 filter_vec, const_vec;
1902
1903     src0_ptr -= 1;
1904
1905     const_vec = __msa_ldi_h(128);
1906     const_vec <<= 6;
1907
1908     filter_vec = LD_SH(filter);
1909     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1910
1911     mask1 = mask0 + 2;
1912
1913     LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
1914     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1915
1916     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
1917     XORI_B4_128_SB(src0, src1, src2, src3);
1918
1919     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1920     tmp0 = const_vec;
1921     DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
1922     VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
1923     tmp1 = const_vec;
1924     DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp1, tmp1);
1925     HEVC_BI_RND_CLIP2(in0, in1, tmp0, tmp1, 7, tmp0, tmp1);
1926     dst0 = __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
1927
1928     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
1929 }
1930
1931 static void hevc_hz_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
1932                                           int32_t src_stride,
1933                                           int16_t *src1_ptr,
1934                                           int32_t src2_stride,
1935                                           uint8_t *dst,
1936                                           int32_t dst_stride,
1937                                           const int8_t *filter,
1938                                           int32_t height)
1939 {
1940     uint32_t loop_cnt;
1941     v8i16 filt0, filt1;
1942     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
1943     v16i8 dst0, dst1;
1944     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
1945     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1946     v16i8 mask1, vec0, vec1;
1947     v8i16 tmp0, tmp1, tmp2, tmp3;
1948     v8i16 filter_vec, const_vec;
1949
1950     src0_ptr -= 1;
1951
1952     const_vec = __msa_ldi_h(128);
1953     const_vec <<= 6;
1954
1955     filter_vec = LD_SH(filter);
1956     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1957
1958     mask1 = mask0 + 2;
1959
1960     for (loop_cnt = (height >> 3); loop_cnt--;) {
1961         LD_SB8(src0_ptr, src_stride,
1962                src0, src1, src2, src3, src4, src5, src6, src7);
1963         src0_ptr += (8 * src_stride);
1964         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1965         src1_ptr += (4 * src2_stride);
1966         LD_SH4(src1_ptr, src2_stride, in4, in5, in6, in7);
1967         src1_ptr += (4 * src2_stride);
1968         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
1969         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
1970         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
1971
1972         VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1973         tmp0 = const_vec;
1974         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
1975         VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
1976         tmp1 = const_vec;
1977         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp1, tmp1);
1978         VSHF_B2_SB(src4, src5, src4, src5, mask0, mask1, vec0, vec1);
1979         tmp2 = const_vec;
1980         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp2, tmp2);
1981         VSHF_B2_SB(src6, src7, src6, src7, mask0, mask1, vec0, vec1);
1982         tmp3 = const_vec;
1983         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp3, tmp3);
1984
1985         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1986                           tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
1987
1988         PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
1989         ST4x8_UB(dst0, dst1, dst, dst_stride);
1990         dst += (8 * dst_stride);
1991     }
1992 }
1993
1994 static void hevc_hz_bi_4t_4w_msa(uint8_t *src0_ptr,
1995                                  int32_t src_stride,
1996                                  int16_t *src1_ptr,
1997                                  int32_t src2_stride,
1998                                  uint8_t *dst,
1999                                  int32_t dst_stride,
2000                                  const int8_t *filter,
2001                                  int32_t height)
2002 {
2003     if (2 == height) {
2004         hevc_hz_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2005                               dst, dst_stride, filter, height);
2006     } else if (4 == height) {
2007         hevc_hz_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2008                               dst, dst_stride, filter, height);
2009     } else if (8 == height || 16 == height) {
2010         hevc_hz_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
2011                                       src1_ptr, src2_stride,
2012                                       dst, dst_stride, filter, height);
2013     }
2014 }
2015
2016 static void hevc_hz_bi_4t_6w_msa(uint8_t *src0_ptr,
2017                                  int32_t src_stride,
2018                                  int16_t *src1_ptr,
2019                                  int32_t src2_stride,
2020                                  uint8_t *dst,
2021                                  int32_t dst_stride,
2022                                  const int8_t *filter,
2023                                  int32_t height)
2024 {
2025     uint32_t loop_cnt;
2026     v8i16 filt0, filt1;
2027     v16i8 src0, src1, src2, src3;
2028     v8i16 in0, in1, in2, in3;
2029     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2030     v16i8 mask1;
2031     v16i8 vec0, vec1;
2032     v8i16 dst0, dst1, dst2, dst3;
2033     v8i16 filter_vec, const_vec;
2034
2035     src0_ptr -= 1;
2036
2037     const_vec = __msa_ldi_h(128);
2038     const_vec <<= 6;
2039
2040     filter_vec = LD_SH(filter);
2041     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2042
2043     mask1 = mask0 + 2;
2044
2045     for (loop_cnt = (height >> 2); loop_cnt--;) {
2046         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2047         src0_ptr += (4 * src_stride);
2048         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2049         src1_ptr += (4 * src2_stride);
2050         XORI_B4_128_SB(src0, src1, src2, src3);
2051
2052         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2053         dst0 = const_vec;
2054         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2055         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2056         dst1 = const_vec;
2057         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2058         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2059         dst2 = const_vec;
2060         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2061         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2062         dst3 = const_vec;
2063         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2064
2065         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2066                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2067
2068         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2069         ST6x4_UB(dst0, dst1, dst, dst_stride);
2070         dst += (4 * dst_stride);
2071     }
2072 }
2073
2074 static void hevc_hz_bi_4t_8x2_msa(uint8_t *src0_ptr,
2075                                   int32_t src_stride,
2076                                   int16_t *src1_ptr,
2077                                   int32_t src2_stride,
2078                                   uint8_t *dst,
2079                                   int32_t dst_stride,
2080                                   const int8_t *filter,
2081                                   int32_t height)
2082 {
2083     v8i16 filt0, filt1;
2084     v16i8 src0, src1;
2085     v8i16 in0, in1;
2086     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2087     v16i8 mask1, vec0, vec1;
2088     v8i16 dst0, dst1;
2089     v8i16 filter_vec, const_vec;
2090
2091     src0_ptr -= 1;
2092
2093     const_vec = __msa_ldi_h(128);
2094     const_vec <<= 6;
2095
2096     filter_vec = LD_SH(filter);
2097     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2098
2099     mask1 = mask0 + 2;
2100
2101     LD_SB2(src0_ptr, src_stride, src0, src1);
2102     LD_SH2(src1_ptr, src2_stride, in0, in1);
2103     XORI_B2_128_SB(src0, src1);
2104
2105     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2106     dst0 = const_vec;
2107     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2108     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2109     dst1 = const_vec;
2110     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2111     HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
2112
2113     dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
2114     ST8x2_UB(dst0, dst, dst_stride);
2115 }
2116
2117 static void hevc_hz_bi_4t_8x6_msa(uint8_t *src0_ptr,
2118                                   int32_t src_stride,
2119                                   int16_t *src1_ptr,
2120                                   int32_t src2_stride,
2121                                   uint8_t *dst,
2122                                   int32_t dst_stride,
2123                                   const int8_t *filter,
2124                                   int32_t height)
2125 {
2126     v8i16 filt0, filt1;
2127     v16i8 src0, src1, src2, src3, src4, src5;
2128     v8i16 in0, in1, in2, in3, in4, in5;
2129     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2130     v16i8 mask1;
2131     v16i8 vec0, vec1;
2132     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2133     v8i16 filter_vec, const_vec;
2134
2135     src0_ptr -= 1;
2136
2137     const_vec = __msa_ldi_h(128);
2138     const_vec <<= 6;
2139
2140     filter_vec = LD_SH(filter);
2141     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2142
2143     mask1 = mask0 + 2;
2144
2145     LD_SB6(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5);
2146     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2147     src1_ptr += (4 * src2_stride);
2148     LD_SH2(src1_ptr, src2_stride, in4, in5);
2149     XORI_B6_128_SB(src0, src1, src2, src3, src4, src5);
2150
2151     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2152     dst0 = const_vec;
2153     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2154     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2155     dst1 = const_vec;
2156     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2157     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2158     dst2 = const_vec;
2159     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2160     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2161     dst3 = const_vec;
2162     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2163     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2164     dst4 = const_vec;
2165     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2166     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2167     dst5 = const_vec;
2168     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2169
2170     HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2171                       dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2172     HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2173
2174     PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2175     dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2176     ST8x4_UB(dst0, dst1, dst, dst_stride);
2177     dst += (4 * dst_stride);
2178     ST8x2_UB(dst2, dst, dst_stride);
2179 }
2180
2181 static void hevc_hz_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
2182                                           int32_t src_stride,
2183                                           int16_t *src1_ptr,
2184                                           int32_t src2_stride,
2185                                           uint8_t *dst,
2186                                           int32_t dst_stride,
2187                                           const int8_t *filter,
2188                                           int32_t height)
2189 {
2190     uint32_t loop_cnt;
2191     v8i16 filt0, filt1;
2192     v16i8 src0, src1, src2, src3;
2193     v8i16 in0, in1, in2, in3;
2194     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2195     v16i8 mask1;
2196     v16i8 vec0, vec1;
2197     v8i16 dst0, dst1, dst2, dst3;
2198     v8i16 filter_vec, const_vec;
2199
2200     src0_ptr -= 1;
2201
2202     const_vec = __msa_ldi_h(128);
2203     const_vec <<= 6;
2204
2205     filter_vec = LD_SH(filter);
2206     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2207
2208     mask1 = mask0 + 2;
2209
2210     for (loop_cnt = (height >> 2); loop_cnt--;) {
2211         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2212         src0_ptr += (4 * src_stride);
2213         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2214         src1_ptr += (4 * src2_stride);
2215         XORI_B4_128_SB(src0, src1, src2, src3);
2216
2217         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2218         dst0 = const_vec;
2219         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2220         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2221         dst1 = const_vec;
2222         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2223         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2224         dst2 = const_vec;
2225         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2226         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2227         dst3 = const_vec;
2228         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2229
2230         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2231                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2232
2233         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2234         ST8x4_UB(dst0, dst1, dst, dst_stride);
2235         dst += (4 * dst_stride);
2236     }
2237 }
2238
2239 static void hevc_hz_bi_4t_8w_msa(uint8_t *src0_ptr,
2240                                  int32_t src_stride,
2241                                  int16_t *src1_ptr,
2242                                  int32_t src2_stride,
2243                                  uint8_t *dst,
2244                                  int32_t dst_stride,
2245                                  const int8_t *filter,
2246                                  int32_t height)
2247 {
2248     if (2 == height) {
2249         hevc_hz_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2250                               dst, dst_stride, filter, height);
2251     } else if (6 == height) {
2252         hevc_hz_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2253                               dst, dst_stride, filter, height);
2254     } else if (0 == (height % 4)) {
2255         hevc_hz_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
2256                                       src1_ptr, src2_stride,
2257                                       dst, dst_stride, filter, height);
2258     }
2259 }
2260
2261 static void hevc_hz_bi_4t_12w_msa(uint8_t *src0_ptr,
2262                                   int32_t src_stride,
2263                                   int16_t *src1_ptr,
2264                                   int32_t src2_stride,
2265                                   uint8_t *dst,
2266                                   int32_t dst_stride,
2267                                   const int8_t *filter,
2268                                   int32_t height)
2269 {
2270     uint32_t loop_cnt;
2271     v8i16 filt0, filt1;
2272     v16i8 src0, src1, src2, src3;
2273     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2274     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2275     v16i8 mask2 = {
2276         8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
2277     };
2278     v16i8 mask1, mask3;
2279     v16i8 vec0, vec1;
2280     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2281     v8i16 filter_vec, const_vec;
2282
2283     src0_ptr -= 1;
2284
2285     const_vec = __msa_ldi_h(128);
2286     const_vec <<= 6;
2287
2288     filter_vec = LD_SH(filter);
2289     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2290
2291     mask1 = mask0 + 2;
2292     mask3 = mask2 + 2;
2293
2294     for (loop_cnt = (height >> 2); loop_cnt--;) {
2295         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2296         src0_ptr += (4 * src_stride);
2297         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2298         LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
2299         src1_ptr += (4 * src2_stride);
2300
2301         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
2302         XORI_B4_128_SB(src0, src1, src2, src3);
2303
2304         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2305         dst0 = const_vec;
2306         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2307         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2308         dst1 = const_vec;
2309         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2310         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2311         dst2 = const_vec;
2312         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2313         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2314         dst3 = const_vec;
2315         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2316         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2317         dst4 = const_vec;
2318         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2319         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
2320         dst5 = const_vec;
2321         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2322
2323         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2324                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2325         HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2326
2327         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2328         dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2329         ST12x4_UB(dst0, dst1, dst2, dst, dst_stride);
2330         dst += (4 * dst_stride);
2331     }
2332 }
2333
2334 static void hevc_hz_bi_4t_16w_msa(uint8_t *src0_ptr,
2335                                   int32_t src_stride,
2336                                   int16_t *src1_ptr,
2337                                   int32_t src2_stride,
2338                                   uint8_t *dst,
2339                                   int32_t dst_stride,
2340                                   const int8_t *filter,
2341                                   int32_t height)
2342 {
2343     uint32_t loop_cnt;
2344     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2345     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2346     v8i16 filt0, filt1;
2347     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2348     v16i8 mask1;
2349     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2350     v16i8 vec0, vec1;
2351     v8i16 filter_vec, const_vec;
2352
2353     src0_ptr -= 1;
2354
2355     const_vec = __msa_ldi_h(128);
2356     const_vec <<= 6;
2357
2358     filter_vec = LD_SH(filter);
2359     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2360
2361     mask1 = mask0 + 2;
2362
2363     for (loop_cnt = (height >> 2); loop_cnt--;) {
2364         LD_SB4(src0_ptr, src_stride, src0, src2, src4, src6);
2365         LD_SB4(src0_ptr + 8, src_stride, src1, src3, src5, src7);
2366         src0_ptr += (4 * src_stride);
2367         LD_SH4(src1_ptr, src2_stride, in0, in2, in4, in6);
2368         LD_SH4(src1_ptr + 8, src2_stride, in1, in3, in5, in7);
2369         src1_ptr += (4 * src2_stride);
2370         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2371
2372         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2373         dst0 = const_vec;
2374         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2375         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2376         dst1 = const_vec;
2377         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2378         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2379         dst2 = const_vec;
2380         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2381         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2382         dst3 = const_vec;
2383         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2384         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2385         dst4 = const_vec;
2386         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2387         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2388         dst5 = const_vec;
2389         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2390         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
2391         dst6 = const_vec;
2392         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
2393         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
2394         dst7 = const_vec;
2395         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
2396
2397         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2398                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2399         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
2400                           dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
2401
2402         PCKEV_B4_SH(dst1, dst0, dst3, dst2,
2403                     dst5, dst4, dst7, dst6, dst0, dst1, dst2, dst3);
2404         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
2405         dst += (4 * dst_stride);
2406     }
2407 }
2408
2409 static void hevc_hz_bi_4t_24w_msa(uint8_t *src0_ptr,
2410                                   int32_t src_stride,
2411                                   int16_t *src1_ptr,
2412                                   int32_t src2_stride,
2413                                   uint8_t *dst,
2414                                   int32_t dst_stride,
2415                                   const int8_t *filter,
2416                                   int32_t height)
2417 {
2418     int16_t *src1_ptr_tmp;
2419     uint8_t *dst_tmp;
2420     uint32_t loop_cnt;
2421     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2422     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2423     v8i16 filt0, filt1;
2424     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2425     v16i8 mask1, mask2, mask3;
2426     v16i8 vec0, vec1;
2427     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2428     v8i16 filter_vec, const_vec;
2429
2430     src0_ptr -= 1;
2431
2432     const_vec = __msa_ldi_h(128);
2433     const_vec <<= 6;
2434
2435     filter_vec = LD_SH(filter);
2436     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2437
2438     mask1 = mask0 + 2;
2439     mask2 = mask0 + 8;
2440     mask3 = mask0 + 10;
2441
2442     dst_tmp = dst + 16;
2443     src1_ptr_tmp = src1_ptr + 16;
2444
2445     for (loop_cnt = (height >> 2); loop_cnt--;) {
2446         LD_SB4(src0_ptr, src_stride, src0, src2, src4, src6);
2447         LD_SB4(src0_ptr + 16, src_stride, src1, src3, src5, src7);
2448         src0_ptr += (4 * src_stride);
2449         LD_SH4(src1_ptr, src2_stride, in0, in2, in4, in6);
2450         LD_SH4(src1_ptr + 8, src2_stride, in1, in3, in5, in7);
2451         src1_ptr += (4 * src2_stride);
2452         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2453
2454         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2455         dst0 = const_vec;
2456         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2457         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2458         dst1 = const_vec;
2459         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2460         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2461         dst2 = const_vec;
2462         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2463         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
2464         dst3 = const_vec;
2465         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2466         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2467         dst4 = const_vec;
2468         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2469         VSHF_B2_SB(src4, src5, src4, src5, mask2, mask3, vec0, vec1);
2470         dst5 = const_vec;
2471         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2472         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
2473         dst6 = const_vec;
2474         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
2475         VSHF_B2_SB(src6, src7, src6, src7, mask2, mask3, vec0, vec1);
2476         dst7 = const_vec;
2477         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
2478
2479         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2480                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2481         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
2482                           dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
2483
2484         PCKEV_B4_SH(dst1, dst0, dst3, dst2,
2485                     dst5, dst4, dst7, dst6, dst0, dst1, dst2, dst3);
2486         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
2487         dst += (4 * dst_stride);
2488
2489         LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
2490         src1_ptr_tmp += (4 * src2_stride);
2491
2492         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2493         dst0 = const_vec;
2494         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2495         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2496         dst1 = const_vec;
2497         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2498         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2499         dst2 = const_vec;
2500         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2501         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
2502         dst3 = const_vec;
2503         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2504
2505         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2506                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2507
2508         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2509         ST8x4_UB(dst0, dst1, dst_tmp, dst_stride);
2510         dst_tmp += (4 * dst_stride);
2511     }
2512 }
2513
2514 static void hevc_hz_bi_4t_32w_msa(uint8_t *src0_ptr,
2515                                   int32_t src_stride,
2516                                   int16_t *src1_ptr,
2517                                   int32_t src2_stride,
2518                                   uint8_t *dst,
2519                                   int32_t dst_stride,
2520                                   const int8_t *filter,
2521                                   int32_t height)
2522 {
2523     uint32_t loop_cnt;
2524     v16i8 src0, src1, src2;
2525     v8i16 in0, in1, in2, in3;
2526     v8i16 filt0, filt1;
2527     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2528     v16i8 mask1, mask2, mask3;
2529     v8i16 dst0, dst1, dst2, dst3;
2530     v16i8 vec0, vec1;
2531     v8i16 filter_vec, const_vec;
2532
2533     src0_ptr -= 1;
2534
2535     const_vec = __msa_ldi_h(128);
2536     const_vec <<= 6;
2537
2538     filter_vec = LD_SH(filter);
2539     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2540
2541     mask1 = mask0 + 2;
2542     mask2 = mask0 + 8;
2543     mask3 = mask0 + 10;
2544
2545     for (loop_cnt = (height >> 1); loop_cnt--;) {
2546         LD_SB2(src0_ptr, 16, src0, src1);
2547         src2 = LD_SB(src0_ptr + 24);
2548         src0_ptr += src_stride;
2549         LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
2550         src1_ptr += src2_stride;
2551         XORI_B3_128_SB(src0, src1, src2);
2552
2553         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2554         dst0 = const_vec;
2555         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2556         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2557         dst1 = const_vec;
2558         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2559         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2560         dst2 = const_vec;
2561         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2562         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2563         dst3 = const_vec;
2564         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2565
2566         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2567                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2568
2569         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2570         ST_SH2(dst0, dst1, dst, 16);
2571         dst += dst_stride;
2572
2573         LD_SB2(src0_ptr, 16, src0, src1);
2574         src2 = LD_SB(src0_ptr + 24);
2575         src0_ptr += src_stride;
2576         LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
2577         src1_ptr += src2_stride;
2578         XORI_B3_128_SB(src0, src1, src2);
2579
2580         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2581         dst0 = const_vec;
2582         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2583         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2584         dst1 = const_vec;
2585         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2586         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2587         dst2 = const_vec;
2588         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2589         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2590         dst3 = const_vec;
2591         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2592
2593         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2594                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2595
2596         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2597         ST_SH2(dst0, dst1, dst, 16);
2598         dst += dst_stride;
2599     }
2600 }
2601
2602 static void hevc_vt_bi_4t_4x2_msa(uint8_t *src0_ptr,
2603                                   int32_t src_stride,
2604                                   int16_t *src1_ptr,
2605                                   int32_t src2_stride,
2606                                   uint8_t *dst,
2607                                   int32_t dst_stride,
2608                                   const int8_t *filter,
2609                                   int32_t height)
2610 {
2611     v16i8 src0, src1, src2, src3, src4;
2612     v8i16 in0, in1;
2613     v16i8 src10_r, src32_r, src21_r, src43_r, src2110, src4332;
2614     v8i16 dst10;
2615     v8i16 filt0, filt1;
2616     v8i16 filter_vec, const_vec;
2617
2618     src0_ptr -= src_stride;
2619
2620     const_vec = __msa_ldi_h(128);
2621     const_vec <<= 6;
2622
2623     filter_vec = LD_SH(filter);
2624     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2625
2626     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2627     src0_ptr += (3 * src_stride);
2628
2629     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2630     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2631     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2632
2633     LD_SB2(src0_ptr, src_stride, src3, src4);
2634     LD_SH2(src1_ptr, src2_stride, in0, in1);
2635     in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
2636     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2637     src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_r, (v2i64) src32_r);
2638     src4332 = (v16i8) __msa_xori_b((v16u8) src4332, 128);
2639
2640     dst10 = const_vec;
2641     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2642     dst10 = __msa_adds_s_h(dst10, in0);
2643     dst10 = __msa_srari_h(dst10, 7);
2644     dst10 = CLIP_SH_0_255(dst10);
2645
2646     dst10 = (v8i16) __msa_pckev_b((v16i8) dst10, (v16i8) dst10);
2647     ST4x2_UB(dst10, dst, dst_stride);
2648 }
2649
2650 static void hevc_vt_bi_4t_4x4_msa(uint8_t *src0_ptr,
2651                                   int32_t src_stride,
2652                                   int16_t *src1_ptr,
2653                                   int32_t src2_stride,
2654                                   uint8_t *dst,
2655                                   int32_t dst_stride,
2656                                   const int8_t *filter,
2657                                   int32_t height)
2658 {
2659     v16i8 src0, src1, src2, src3, src4, src5, src6;
2660     v8i16 in0, in1, in2, in3;
2661     v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
2662     v16i8 src2110, src4332, src6554;
2663     v8i16 dst10, dst32;
2664     v8i16 filt0, filt1;
2665     v8i16 filter_vec, const_vec;
2666
2667     src0_ptr -= src_stride;
2668
2669     const_vec = __msa_ldi_h(128);
2670     const_vec <<= 6;
2671
2672     filter_vec = LD_SH(filter);
2673     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2674
2675     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2676     src0_ptr += (3 * src_stride);
2677     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2678     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2679     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2680
2681     LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
2682     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2683     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2684     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
2685                src32_r, src43_r, src54_r, src65_r);
2686     ILVR_D2_SB(src43_r, src32_r, src65_r, src54_r, src4332, src6554);
2687     XORI_B2_128_SB(src4332, src6554);
2688
2689     dst10 = const_vec;
2690     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2691     dst32 = const_vec;
2692     DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
2693     HEVC_BI_RND_CLIP2(in0, in1, dst10, dst32, 7, dst10, dst32);
2694
2695     dst10 = (v8i16) __msa_pckev_b((v16i8) dst32, (v16i8) dst10);
2696     ST4x4_UB(dst10, dst10, 0, 1, 2, 3, dst, dst_stride);
2697 }
2698
2699 static void hevc_vt_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
2700                                           int32_t src_stride,
2701                                           int16_t *src1_ptr,
2702                                           int32_t src2_stride,
2703                                           uint8_t *dst,
2704                                           int32_t dst_stride,
2705                                           const int8_t *filter,
2706                                           int32_t height)
2707 {
2708     int32_t loop_cnt;
2709     v16i8 src0, src1, src2, src3, src4, src5;
2710     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2711     v16i8 src6, src7, src8, src9;
2712     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
2713     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
2714     v16i8 src2110, src4332, src6554, src8776;
2715     v8i16 dst10, dst32, dst54, dst76;
2716     v8i16 filt0, filt1;
2717     v8i16 filter_vec, const_vec;
2718
2719     src0_ptr -= src_stride;
2720
2721     const_vec = __msa_ldi_h(128);
2722     const_vec <<= 6;
2723
2724     filter_vec = LD_SH(filter);
2725     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2726
2727     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2728     src0_ptr += (3 * src_stride);
2729     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2730     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2731     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2732
2733     for (loop_cnt = (height >> 3); loop_cnt--;) {
2734         LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
2735         src0_ptr += (6 * src_stride);
2736         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
2737         src1_ptr += (8 * src2_stride);
2738         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2739         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
2740         ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
2741                    src32_r, src43_r, src54_r, src65_r);
2742         ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
2743         ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
2744                    src4332, src6554, src8776);
2745         XORI_B3_128_SB(src4332, src6554, src8776);
2746
2747         dst10 = const_vec;
2748         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2749         dst32 = const_vec;
2750         DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
2751         dst54 = const_vec;
2752         DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
2753
2754         LD_SB2(src0_ptr, src_stride, src9, src2);
2755         src0_ptr += (2 * src_stride);
2756         ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
2757         src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
2758         src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2759         dst76 = const_vec;
2760         DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
2761
2762         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2763                           dst10, dst32, dst54, dst76, 7,
2764                           dst10, dst32, dst54, dst76);
2765
2766         PCKEV_B2_SH(dst32, dst10, dst76, dst54, dst10, dst54);
2767         ST4x8_UB(dst10, dst54, dst, dst_stride);
2768         dst += (8 * dst_stride);
2769     }
2770 }
2771
2772 static void hevc_vt_bi_4t_4w_msa(uint8_t *src0_ptr,
2773                                  int32_t src_stride,
2774                                  int16_t *src1_ptr,
2775                                  int32_t src2_stride,
2776                                  uint8_t *dst,
2777                                  int32_t dst_stride,
2778                                  const int8_t *filter,
2779                                  int32_t height)
2780 {
2781     if (2 == height) {
2782         hevc_vt_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2783                               dst, dst_stride, filter, height);
2784     } else if (4 == height) {
2785         hevc_vt_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2786                               dst, dst_stride, filter, height);
2787     } else {
2788         hevc_vt_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
2789                                       src1_ptr, src2_stride,
2790                                       dst, dst_stride, filter, height);
2791     }
2792 }
2793
2794 static void hevc_vt_bi_4t_6w_msa(uint8_t *src0_ptr,
2795                                  int32_t src_stride,
2796                                  int16_t *src1_ptr,
2797                                  int32_t src2_stride,
2798                                  uint8_t *dst,
2799                                  int32_t dst_stride,
2800                                  const int8_t *filter,
2801                                  int32_t height)
2802 {
2803     int32_t loop_cnt;
2804     v16i8 src0, src1, src2, src3, src4, src5;
2805     v8i16 in0, in1, in2, in3;
2806     v16i8 src10_r, src32_r, src21_r, src43_r;
2807     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2808     v8i16 filt0, filt1;
2809     v8i16 filter_vec, const_vec;
2810
2811     src0_ptr -= src_stride;
2812
2813     const_vec = __msa_ldi_h(128);
2814     const_vec <<= 6;
2815
2816     filter_vec = LD_SH(filter);
2817     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2818
2819     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2820     src0_ptr += (3 * src_stride);
2821     XORI_B3_128_SB(src0, src1, src2);
2822     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2823
2824     for (loop_cnt = (height >> 2); loop_cnt--;) {
2825         LD_SB2(src0_ptr, src_stride, src3, src4);
2826         src0_ptr += (2 * src_stride);
2827         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2828         src1_ptr += (4 * src2_stride);
2829         XORI_B2_128_SB(src3, src4);
2830         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2831
2832         dst0_r = const_vec;
2833         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2834         dst1_r = const_vec;
2835         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2836
2837         LD_SB2(src0_ptr, src_stride, src5, src2);
2838         src0_ptr += (2 * src_stride);
2839         XORI_B2_128_SB(src5, src2);
2840         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2841
2842         dst2_r = const_vec;
2843         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
2844         dst3_r = const_vec;
2845         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
2846
2847         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2848                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
2849                           dst0_r, dst1_r, dst2_r, dst3_r);
2850
2851         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
2852         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
2853         dst += (4 * dst_stride);
2854     }
2855 }
2856
2857 static void hevc_vt_bi_4t_8x2_msa(uint8_t *src0_ptr,
2858                                   int32_t src_stride,
2859                                   int16_t *src1_ptr,
2860                                   int32_t src2_stride,
2861                                   uint8_t *dst,
2862                                   int32_t dst_stride,
2863                                   const int8_t *filter,
2864                                   int32_t height)
2865 {
2866     v16i8 src0, src1, src2, src3, src4;
2867     v8i16 in0, in1, dst0_r, dst1_r;
2868     v16i8 src10_r, src32_r, src21_r, src43_r;
2869     v8i16 filt0, filt1;
2870     v8i16 filter_vec, const_vec;
2871
2872     src0_ptr -= src_stride;
2873
2874     const_vec = __msa_ldi_h(128);
2875     const_vec <<= 6;
2876
2877     filter_vec = LD_SH(filter);
2878     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2879
2880     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2881     src0_ptr += (3 * src_stride);
2882     XORI_B3_128_SB(src0, src1, src2);
2883     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2884
2885     LD_SB2(src0_ptr, src_stride, src3, src4);
2886     LD_SH2(src1_ptr, src2_stride, in0, in1);
2887     XORI_B2_128_SB(src3, src4);
2888     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2889
2890     dst0_r = const_vec;
2891     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2892     dst1_r = const_vec;
2893     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2894
2895     HEVC_BI_RND_CLIP2(in0, in1, dst0_r, dst1_r, 7, dst0_r, dst1_r);
2896     dst0_r = (v8i16) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst0_r);
2897
2898     ST8x2_UB(dst0_r, dst, dst_stride);
2899 }
2900
2901 static void hevc_vt_bi_4t_8x6_msa(uint8_t *src0_ptr,
2902                                   int32_t src_stride,
2903                                   int16_t *src1_ptr,
2904                                   int32_t src2_stride,
2905                                   uint8_t *dst,
2906                                   int32_t dst_stride,
2907                                   const int8_t *filter,
2908                                   int32_t height)
2909 {
2910     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
2911     v8i16 in0, in1, in2, in3, in4, in5;
2912     v16i8 src10_r, src32_r, src54_r, src76_r;
2913     v16i8 src21_r, src43_r, src65_r, src87_r;
2914     v8i16 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
2915     v8i16 filt0, filt1;
2916     v8i16 filter_vec, const_vec;
2917
2918     src0_ptr -= src_stride;
2919
2920     const_vec = __msa_ldi_h(128);
2921     const_vec <<= 6;
2922
2923     filter_vec = LD_SH(filter);
2924     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2925
2926     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2927     src0_ptr += (3 * src_stride);
2928     XORI_B3_128_SB(src0, src1, src2);
2929     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2930
2931     LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
2932     LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
2933     XORI_B6_128_SB(src3, src4, src5, src6, src7, src8);
2934     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
2935                src32_r, src43_r, src54_r, src65_r);
2936     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
2937
2938     dst0_r = const_vec;
2939     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2940     dst1_r = const_vec;
2941     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2942     dst2_r = const_vec;
2943     DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
2944     dst3_r = const_vec;
2945     DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
2946     dst4_r = const_vec;
2947     DPADD_SB2_SH(src54_r, src76_r, filt0, filt1, dst4_r, dst4_r);
2948     dst5_r = const_vec;
2949     DPADD_SB2_SH(src65_r, src87_r, filt0, filt1, dst5_r, dst5_r);
2950     HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2951                       dst0_r, dst1_r, dst2_r, dst3_r, 7,
2952                       dst0_r, dst1_r, dst2_r, dst3_r);
2953     HEVC_BI_RND_CLIP2(in4, in5, dst4_r, dst5_r, 7, dst4_r, dst5_r);
2954
2955     PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
2956     dst2_r = (v8i16) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst4_r);
2957     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
2958     dst += (4 * dst_stride);
2959     ST8x2_UB(dst2_r, dst, dst_stride);
2960 }
2961
2962 static void hevc_vt_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
2963                                           int32_t src_stride,
2964                                           int16_t *src1_ptr,
2965                                           int32_t src2_stride,
2966                                           uint8_t *dst,
2967                                           int32_t dst_stride,
2968                                           const int8_t *filter,
2969                                           int32_t height)
2970 {
2971     int32_t loop_cnt;
2972     v16i8 src0, src1, src2, src3, src4, src5;
2973     v8i16 in0, in1, in2, in3;
2974     v16i8 src10_r, src32_r, src21_r, src43_r;
2975     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2976     v8i16 filt0, filt1;
2977     v8i16 filter_vec, const_vec;
2978
2979     src0_ptr -= src_stride;
2980
2981     const_vec = __msa_ldi_h(128);
2982     const_vec <<= 6;
2983
2984     filter_vec = LD_SH(filter);
2985     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2986
2987     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2988     src0_ptr += (3 * src_stride);
2989     XORI_B3_128_SB(src0, src1, src2);
2990     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2991
2992     for (loop_cnt = (height >> 2); loop_cnt--;) {
2993         LD_SB2(src0_ptr, src_stride, src3, src4);
2994         src0_ptr += (2 * src_stride);
2995         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2996         src1_ptr += (4 * src2_stride);
2997         XORI_B2_128_SB(src3, src4);
2998         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2999
3000         dst0_r = const_vec;
3001         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3002         dst1_r = const_vec;
3003         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3004
3005         LD_SB2(src0_ptr, src_stride, src5, src2);
3006         src0_ptr += (2 * src_stride);
3007         XORI_B2_128_SB(src5, src2);
3008         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3009
3010         dst2_r = const_vec;
3011         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3012         dst3_r = const_vec;
3013         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3014         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3015                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
3016                           dst0_r, dst1_r, dst2_r, dst3_r);
3017
3018         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3019         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
3020         dst += (4 * dst_stride);
3021     }
3022 }
3023
3024 static void hevc_vt_bi_4t_8w_msa(uint8_t *src0_ptr,
3025                                  int32_t src_stride,
3026                                  int16_t *src1_ptr,
3027                                  int32_t src2_stride,
3028                                  uint8_t *dst,
3029                                  int32_t dst_stride,
3030                                  const int8_t *filter,
3031                                  int32_t height)
3032 {
3033     if (2 == height) {
3034         hevc_vt_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3035                               dst, dst_stride, filter, height);
3036     } else if (6 == height) {
3037         hevc_vt_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3038                               dst, dst_stride, filter, height);
3039     } else {
3040         hevc_vt_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
3041                                       src1_ptr, src2_stride,
3042                                       dst, dst_stride, filter, height);
3043     }
3044 }
3045
3046 static void hevc_vt_bi_4t_12w_msa(uint8_t *src0_ptr,
3047                                   int32_t src_stride,
3048                                   int16_t *src1_ptr,
3049                                   int32_t src2_stride,
3050                                   uint8_t *dst,
3051                                   int32_t dst_stride,
3052                                   const int8_t *filter,
3053                                   int32_t height)
3054 {
3055     int32_t loop_cnt;
3056     v16i8 src0, src1, src2, src3, src4, src5;
3057     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3058     v16i8 src10_r, src32_r, src21_r, src43_r;
3059     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3060     v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
3061     v16i8 src2110, src4332;
3062     v8i16 dst0_l, dst1_l, filt0, filt1;
3063     v8i16 filter_vec, const_vec;
3064
3065     src0_ptr -= (1 * src_stride);
3066
3067     const_vec = __msa_ldi_h(128);
3068     const_vec <<= 6;
3069
3070     filter_vec = LD_SH(filter);
3071     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3072
3073     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3074     src0_ptr += (3 * src_stride);
3075     XORI_B3_128_SB(src0, src1, src2);
3076     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3077     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3078     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
3079
3080     for (loop_cnt = (height >> 2); loop_cnt--;) {
3081         LD_SB2(src0_ptr, src_stride, src3, src4);
3082         src0_ptr += (2 * src_stride);
3083         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3084         LD_SH4((src1_ptr + 8), src2_stride, in4, in5, in6, in7);
3085         src1_ptr += (4 * src2_stride);
3086         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
3087         XORI_B2_128_SB(src3, src4);
3088
3089         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3090         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3091         src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
3092
3093         dst0_r = const_vec;
3094         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3095         dst1_r = const_vec;
3096         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3097         dst0_l = const_vec;
3098         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst0_l, dst0_l);
3099
3100         LD_SB2(src0_ptr, src_stride, src5, src2);
3101         src0_ptr += (2 * src_stride);
3102         XORI_B2_128_SB(src5, src2);
3103
3104         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3105         ILVL_B2_SB(src5, src4, src2, src5, src54_l, src65_l);
3106         src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
3107
3108         dst2_r = const_vec;
3109         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3110         dst3_r = const_vec;
3111         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3112         dst1_l = const_vec;
3113         DPADD_SB2_SH(src4332, src2110, filt0, filt1, dst1_l, dst1_l);
3114         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3115                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
3116                           dst0_r, dst1_r, dst2_r, dst3_r);
3117         HEVC_BI_RND_CLIP2(in4, in5, dst0_l, dst1_l, 7, dst0_l, dst1_l);
3118
3119         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3120         dst0_l = (v8i16) __msa_pckev_b((v16i8) dst1_l, (v16i8) dst0_l);
3121         ST12x4_UB(dst0_r, dst1_r, dst0_l, dst, dst_stride);
3122         dst += (4 * dst_stride);
3123     }
3124 }
3125
3126 static void hevc_vt_bi_4t_16w_msa(uint8_t *src0_ptr,
3127                                   int32_t src_stride,
3128                                   int16_t *src1_ptr,
3129                                   int32_t src2_stride,
3130                                   uint8_t *dst,
3131                                   int32_t dst_stride,
3132                                   const int8_t *filter,
3133                                   int32_t height)
3134 {
3135     int32_t loop_cnt;
3136     v16i8 src0, src1, src2, src3, src4, src5;
3137     v8i16 in0, in1, in2, in3;
3138     v16i8 src10_r, src32_r, src21_r, src43_r;
3139     v16i8 src10_l, src32_l, src21_l, src43_l;
3140     v8i16 dst0_r, dst1_r, dst0_l, dst1_l;
3141     v8i16 filt0, filt1;
3142     v8i16 filter_vec, const_vec;
3143
3144     src0_ptr -= src_stride;
3145
3146     const_vec = __msa_ldi_h(128);
3147     const_vec <<= 6;
3148
3149     filter_vec = LD_SH(filter);
3150     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3151
3152     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3153     src0_ptr += (3 * src_stride);
3154     XORI_B3_128_SB(src0, src1, src2);
3155     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3156     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3157
3158     for (loop_cnt = (height >> 2); loop_cnt--;) {
3159         LD_SB2(src0_ptr, src_stride, src3, src4);
3160         src0_ptr += (2 * src_stride);
3161         LD_SH2(src1_ptr, src2_stride, in0, in1);
3162         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3163         src1_ptr += (2 * src2_stride);
3164         XORI_B2_128_SB(src3, src4);
3165         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3166         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3167
3168         dst0_r = const_vec;
3169         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3170         dst1_r = const_vec;
3171         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3172         dst0_l = const_vec;
3173         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3174         dst1_l = const_vec;
3175         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3176         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3177                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3178                           dst0_r, dst1_r, dst0_l, dst1_l);
3179
3180         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3181         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3182         dst += (2 * dst_stride);
3183
3184         LD_SB2(src0_ptr, src_stride, src5, src2);
3185         src0_ptr += (2 * src_stride);
3186         LD_SH2(src1_ptr, src2_stride, in0, in1);
3187         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3188         src1_ptr += (2 * src2_stride);
3189         XORI_B2_128_SB(src5, src2);
3190         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3191         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3192
3193         dst0_r = const_vec;
3194         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3195         dst0_l = const_vec;
3196         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3197         dst1_r = const_vec;
3198         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3199         dst1_l = const_vec;
3200         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3201         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3202                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3203                           dst0_r, dst1_r, dst0_l, dst1_l);
3204
3205         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3206         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3207         dst += (2 * dst_stride);
3208     }
3209 }
3210
3211 static void hevc_vt_bi_4t_24w_msa(uint8_t *src0_ptr,
3212                                   int32_t src_stride,
3213                                   int16_t *src1_ptr,
3214                                   int32_t src2_stride,
3215                                   uint8_t *dst,
3216                                   int32_t dst_stride,
3217                                   const int8_t *filter,
3218                                   int32_t height)
3219 {
3220     uint32_t loop_cnt;
3221     v16i8 src0, src1, src2, src3, src4, src5;
3222     v16i8 src6, src7, src8, src9, src10, src11;
3223     v8i16 in0, in1, in2, in3, in4, in5;
3224     v16i8 src10_r, src32_r, src76_r, src98_r;
3225     v16i8 src21_r, src43_r, src87_r, src109_r;
3226     v16i8 src10_l, src32_l, src21_l, src43_l;
3227     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3228     v8i16 dst0_l, dst1_l;
3229     v8i16 filt0, filt1;
3230     v8i16 filter_vec, const_vec;
3231
3232     src0_ptr -= src_stride;
3233
3234     const_vec = __msa_ldi_h(128);
3235     const_vec <<= 6;
3236
3237     filter_vec = LD_SH(filter);
3238     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3239
3240     /* 16width */
3241     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3242     XORI_B3_128_SB(src0, src1, src2);
3243     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3244     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3245     /* 8width */
3246     LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3247     src0_ptr += (3 * src_stride);
3248     XORI_B3_128_SB(src6, src7, src8);
3249     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3250
3251     for (loop_cnt = (height >> 2); loop_cnt--;) {
3252         /* 16width */
3253         LD_SB2(src0_ptr, src_stride, src3, src4);
3254         LD_SH2(src1_ptr, src2_stride, in0, in1);
3255         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3256         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3257         src1_ptr += (2 * src2_stride);
3258         XORI_B2_128_SB(src3, src4);
3259         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3260         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3261         /* 8width */
3262         LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3263         src0_ptr += (2 * src_stride);
3264         XORI_B2_128_SB(src9, src10);
3265         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3266         /* 16width */
3267         dst0_r = const_vec;
3268         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3269         dst0_l = const_vec;
3270         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3271         dst1_r = const_vec;
3272         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3273         dst1_l = const_vec;
3274         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3275         /* 8width */
3276         dst2_r = const_vec;
3277         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3278         dst3_r = const_vec;
3279         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3280         /* 16width */
3281         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3282                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3283                           dst0_r, dst1_r, dst0_l, dst1_l);
3284
3285         HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3286
3287         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3288         dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3289         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3290         ST8x2_UB(dst2_r, dst + 16, dst_stride);
3291         dst += (2 * dst_stride);
3292
3293         /* 16width */
3294         LD_SB2(src0_ptr, src_stride, src5, src2);
3295         LD_SH2(src1_ptr, src2_stride, in0, in1);
3296         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3297         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3298         src1_ptr += (2 * src2_stride);
3299         XORI_B2_128_SB(src5, src2);
3300         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3301         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3302         /* 8width */
3303         LD_SB2(src0_ptr + 16, src_stride, src11, src8);
3304         src0_ptr += (2 * src_stride);
3305         XORI_B2_128_SB(src11, src8);
3306         ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
3307         /* 16width */
3308         dst0_r = const_vec;
3309         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3310         dst0_l = const_vec;
3311         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3312         dst1_r = const_vec;
3313         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3314         dst1_l = const_vec;
3315         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3316         /* 8width */
3317         dst2_r = const_vec;
3318         DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
3319         dst3_r = const_vec;
3320         DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
3321
3322         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3323                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3324                           dst0_r, dst1_r, dst0_l, dst1_l);
3325         HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3326
3327         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3328         dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3329         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3330         ST8x2_UB(dst2_r, dst + 16, dst_stride);
3331         dst += (2 * dst_stride);
3332     }
3333 }
3334
3335 static void hevc_vt_bi_4t_32w_msa(uint8_t *src0_ptr,
3336                                   int32_t src_stride,
3337                                   int16_t *src1_ptr,
3338                                   int32_t src2_stride,
3339                                   uint8_t *dst,
3340                                   int32_t dst_stride,
3341                                   const int8_t *filter,
3342                                   int32_t height)
3343 {
3344     uint32_t loop_cnt;
3345     uint8_t *dst_tmp = dst + 16;
3346     v16i8 src0, src1, src2, src3, src4, src6, src7, src8, src9, src10;
3347     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3348     v16i8 src10_r, src32_r, src76_r, src98_r;
3349     v16i8 src21_r, src43_r, src87_r, src109_r;
3350     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3351     v16i8 src10_l, src32_l, src76_l, src98_l;
3352     v16i8 src21_l, src43_l, src87_l, src109_l;
3353     v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
3354     v8i16 filt0, filt1;
3355     v8i16 filter_vec, const_vec;
3356
3357     src0_ptr -= src_stride;
3358
3359     const_vec = __msa_ldi_h(128);
3360     const_vec <<= 6;
3361
3362     filter_vec = LD_SH(filter);
3363     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3364
3365     /* 16width */
3366     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3367     XORI_B3_128_SB(src0, src1, src2);
3368     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3369     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3370
3371     /* next 16width */
3372     LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3373     src0_ptr += (3 * src_stride);
3374     XORI_B3_128_SB(src6, src7, src8);
3375     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3376     ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
3377
3378     for (loop_cnt = (height >> 1); loop_cnt--;) {
3379         /* 16width */
3380         LD_SB2(src0_ptr, src_stride, src3, src4);
3381         LD_SH2(src1_ptr, src2_stride, in0, in1);
3382         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3383         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3384         LD_SH2((src1_ptr + 24), src2_stride, in6, in7);
3385         src1_ptr += (2 * src2_stride);
3386         XORI_B2_128_SB(src3, src4);
3387         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3388         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3389         /* 16width */
3390         dst0_r = const_vec;
3391         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3392         dst0_l = const_vec;
3393         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3394         dst1_r = const_vec;
3395         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3396         dst1_l = const_vec;
3397         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3398         /* 16width */
3399         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3400                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3401                           dst0_r, dst1_r, dst0_l, dst1_l);
3402
3403         src10_r = src32_r;
3404         src21_r = src43_r;
3405         src10_l = src32_l;
3406         src21_l = src43_l;
3407         src2 = src4;
3408
3409         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3410         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3411         dst += (2 * dst_stride);
3412
3413         /* next 16width */
3414         LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3415         src0_ptr += (2 * src_stride);
3416         XORI_B2_128_SB(src9, src10);
3417         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3418         ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
3419         /* next 16width */
3420         dst2_r = const_vec;
3421         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3422         dst2_l = const_vec;
3423         DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, dst2_l, dst2_l);
3424         dst3_r = const_vec;
3425         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3426         dst3_l = const_vec;
3427         DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, dst3_l, dst3_l);
3428         /* next 16width */
3429         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
3430                           dst2_r, dst3_r, dst2_l, dst3_l, 7,
3431                           dst2_r, dst3_r, dst2_l, dst3_l);
3432
3433         PCKEV_B2_SH(dst2_l, dst2_r, dst3_l, dst3_r, dst2_r, dst3_r);
3434         ST_SH2(dst2_r, dst3_r, dst_tmp, dst_stride);
3435         dst_tmp += (2 * dst_stride);
3436
3437         src76_r = src98_r;
3438         src87_r = src109_r;
3439         src76_l = src98_l;
3440         src87_l = src109_l;
3441         src8 = src10;
3442     }
3443 }
3444
3445 static void hevc_hv_bi_4t_4x2_msa(uint8_t *src0_ptr,
3446                                   int32_t src_stride,
3447                                   int16_t *src1_ptr,
3448                                   int32_t src2_stride,
3449                                   uint8_t *dst,
3450                                   int32_t dst_stride,
3451                                   const int8_t *filter_x,
3452                                   const int8_t *filter_y,
3453                                   int32_t height)
3454 {
3455     v8i16 in0, in1;
3456     v16i8 src0, src1, src2, src3, src4;
3457     v8i16 filt0, filt1;
3458     v4i32 filt_h0, filt_h1;
3459     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3460     v16i8 mask1;
3461     v8i16 filter_vec, const_vec;
3462     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3463     v8i16 dst0, dst1, dst2, dst3, dst4;
3464     v4i32 dst0_r, dst1_r;
3465     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3466
3467     src0_ptr -= (src_stride + 1);
3468
3469     filter_vec = LD_SH(filter_x);
3470     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3471
3472     filter_vec = LD_SH(filter_y);
3473     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3474     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3475
3476     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3477
3478     mask1 = mask0 + 2;
3479
3480     const_vec = __msa_ldi_h(128);
3481     const_vec <<= 6;
3482
3483     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3484     src0_ptr += (3 * src_stride);
3485     XORI_B3_128_SB(src0, src1, src2);
3486
3487     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3488     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3489     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3490     dst0 = const_vec;
3491     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3492     dst1 = const_vec;
3493     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3494     dst2 = const_vec;
3495     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3496     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3497
3498     LD_SB2(src0_ptr, src_stride, src3, src4);
3499     LD_SH2(src1_ptr, src2_stride, in0, in1);
3500     in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
3501     XORI_B2_128_SB(src3, src4);
3502     /* row 3 */
3503     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3504     dst3 = const_vec;
3505     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3506     dst32_r = __msa_ilvr_h(dst3, dst2);
3507     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3508     dst0_r >>= 6;
3509     /* row 4 */
3510     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3511     dst4 = const_vec;
3512     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3513     dst43_r = __msa_ilvr_h(dst4, dst3);
3514     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3515     dst1_r >>= 6;
3516     dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
3517     dst0_r = (v4i32) __msa_adds_s_h((v8i16) dst0_r, in0);
3518     dst0_r = (v4i32) __msa_srari_h((v8i16) dst0_r, 7);
3519     dst0_r = (v4i32) CLIP_SH_0_255(dst0_r);
3520
3521     dst0_r = (v4i32) __msa_pckev_b((v16i8) dst0_r, (v16i8) dst0_r);
3522     ST4x2_UB(dst0_r, dst, dst_stride);
3523 }
3524
3525 static void hevc_hv_bi_4t_4x4_msa(uint8_t *src0_ptr,
3526                                   int32_t src_stride,
3527                                   int16_t *src1_ptr,
3528                                   int32_t src2_stride,
3529                                   uint8_t *dst,
3530                                   int32_t dst_stride,
3531                                   const int8_t *filter_x,
3532                                   const int8_t *filter_y,
3533                                   int32_t height)
3534 {
3535     v8i16 in0, in1, in2, in3;
3536     v16i8 src0, src1, src2, src3, src4, src5, src6;
3537     v8i16 filt0, filt1;
3538     v4i32 filt_h0, filt_h1;
3539     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3540     v16i8 mask1;
3541     v8i16 filter_vec, const_vec;
3542     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3543     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
3544     v8i16 dst0_r, dst1_r;
3545     v4i32 tmp0, tmp1, tmp2, tmp3;
3546     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3547
3548     src0_ptr -= (src_stride + 1);
3549
3550     filter_vec = LD_SH(filter_x);
3551     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3552
3553     filter_vec = LD_SH(filter_y);
3554     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3555     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3556
3557     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3558
3559     mask1 = mask0 + 2;
3560
3561     const_vec = __msa_ldi_h(128);
3562     const_vec <<= 6;
3563
3564     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3565     src0_ptr += (3 * src_stride);
3566     XORI_B3_128_SB(src0, src1, src2);
3567
3568     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3569     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3570     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3571     dst0 = const_vec;
3572     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3573     dst1 = const_vec;
3574     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3575     dst2 = const_vec;
3576     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3577     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3578
3579     LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
3580     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3581     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3582     XORI_B4_128_SB(src3, src4, src5, src6);
3583     /* row 3 */
3584     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3585     dst3 = const_vec;
3586     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3587     dst32_r = __msa_ilvr_h(dst3, dst2);
3588     tmp0 = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3589     tmp0 >>= 6;
3590     /* row 4 */
3591     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3592     dst4 = const_vec;
3593     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3594     dst43_r = __msa_ilvr_h(dst4, dst3);
3595     tmp1 = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3596     tmp1 >>= 6;
3597     /* row 5 */
3598     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3599     dst5 = const_vec;
3600     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3601     dst10_r = __msa_ilvr_h(dst5, dst4);
3602     tmp2 = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
3603     tmp2 >>= 6;
3604     /* row 6 */
3605     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3606     dst2 = const_vec;
3607     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3608     dst21_r = __msa_ilvr_h(dst2, dst5);
3609     tmp3 = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
3610     tmp3 >>= 6;
3611     PCKEV_H2_SH(tmp1, tmp0, tmp3, tmp2, dst0_r, dst1_r);
3612     HEVC_BI_RND_CLIP2(in0, in1, dst0_r, dst1_r, 7, dst0_r, dst1_r);
3613
3614     dst0_r = (v8i16) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst0_r);
3615     ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
3616     dst += (4 * dst_stride);
3617 }
3618
3619 static void hevc_hv_bi_4t_4multx8mult_msa(uint8_t *src0_ptr,
3620                                           int32_t src_stride,
3621                                           int16_t *src1_ptr,
3622                                           int32_t src2_stride,
3623                                           uint8_t *dst,
3624                                           int32_t dst_stride,
3625                                           const int8_t *filter_x,
3626                                           const int8_t *filter_y,
3627                                           int32_t height)
3628 {
3629     uint32_t loop_cnt;
3630     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3631     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
3632     v8i16 filt0, filt1;
3633     v4i32 filt_h0, filt_h1;
3634     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3635     v16i8 mask1;
3636     v8i16 filter_vec, const_vec;
3637     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3638     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9;
3639     v8i16 tmp0, tmp1, tmp2, tmp3;
3640     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
3641     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
3642     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
3643
3644     src0_ptr -= (src_stride + 1);
3645
3646     filter_vec = LD_SH(filter_x);
3647     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3648
3649     filter_vec = LD_SH(filter_y);
3650     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3651     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3652
3653     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3654
3655     mask1 = mask0 + 2;
3656
3657     const_vec = __msa_ldi_h(128);
3658     const_vec <<= 6;
3659
3660     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3661     src0_ptr += (3 * src_stride);
3662     XORI_B3_128_SB(src0, src1, src2);
3663
3664     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3665     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3666     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3667     dst0 = const_vec;
3668     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3669     dst1 = const_vec;
3670     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3671     dst2 = const_vec;
3672     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3673     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3674
3675     for (loop_cnt = height >> 3; loop_cnt--;) {
3676         LD_SB8(src0_ptr, src_stride,
3677                src3, src4, src5, src6, src7, src8, src9, src10);
3678         src0_ptr += (8 * src_stride);
3679         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
3680         src1_ptr += (8 * src2_stride);
3681         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3682         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
3683         XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
3684         /* row 3 */
3685         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3686         dst3 = const_vec;
3687         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3688         dst32_r = __msa_ilvr_h(dst3, dst2);
3689         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3690         dst0_r >>= 6;
3691         /* row 4 */
3692         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3693         dst4 = const_vec;
3694         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3695         dst43_r = __msa_ilvr_h(dst4, dst3);
3696         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3697         dst1_r >>= 6;
3698         /* row 5 */
3699         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3700         dst5 = const_vec;
3701         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3702         dst54_r = __msa_ilvr_h(dst5, dst4);
3703         dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
3704         dst2_r >>= 6;
3705         /* row 6 */
3706         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3707         dst6 = const_vec;
3708         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
3709         dst65_r = __msa_ilvr_h(dst6, dst5);
3710         dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
3711         dst3_r >>= 6;
3712         /* row 7 */
3713         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
3714         dst7 = const_vec;
3715         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
3716         dst76_r = __msa_ilvr_h(dst7, dst6);
3717         dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
3718         dst4_r >>= 6;
3719         /* row 8 */
3720         VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
3721         dst8 = const_vec;
3722         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
3723         dst87_r = __msa_ilvr_h(dst8, dst7);
3724         dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
3725         dst5_r >>= 6;
3726         /* row 9 */
3727         VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec0, vec1);
3728         dst9 = const_vec;
3729         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst9, dst9);
3730         dst10_r = __msa_ilvr_h(dst9, dst8);
3731         dst6_r = HEVC_FILT_4TAP(dst76_r, dst10_r, filt_h0, filt_h1);
3732         dst6_r >>= 6;
3733         /* row 10 */
3734         VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec0, vec1);
3735         dst2 = const_vec;
3736         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3737         dst21_r = __msa_ilvr_h(dst2, dst9);
3738         dst7_r = HEVC_FILT_4TAP(dst87_r, dst21_r, filt_h0, filt_h1);
3739         dst7_r >>= 6;
3740         PCKEV_H4_SH(dst1_r, dst0_r, dst3_r, dst2_r,
3741                     dst5_r, dst4_r, dst7_r, dst6_r, tmp0, tmp1, tmp2, tmp3);
3742         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3743                           tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
3744
3745         PCKEV_B2_SH(tmp1, tmp0, tmp3, tmp2, tmp0, tmp1);
3746         ST4x8_UB(tmp0, tmp1, dst, dst_stride);
3747         dst += (8 * dst_stride);
3748     }
3749 }
3750
3751 static void hevc_hv_bi_4t_4w_msa(uint8_t *src0_ptr,
3752                                  int32_t src_stride,
3753                                  int16_t *src1_ptr,
3754                                  int32_t src2_stride,
3755                                  uint8_t *dst,
3756                                  int32_t dst_stride,
3757                                  const int8_t *filter_x,
3758                                  const int8_t *filter_y,
3759                                  int32_t height)
3760 {
3761     if (2 == height) {
3762         hevc_hv_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3763                               dst, dst_stride, filter_x, filter_y, height);
3764     } else if (4 == he