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