FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevc_mc_bi_msa.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 - 2017 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 static const uint8_t ff_hevc_mask_arr[16 * 2] __attribute__((aligned(0x40))) = {
26  /* 8 width cases */
27  0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
28  0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20
29 };
30 
31 #define HEVC_BI_RND_CLIP2(in0, in1, vec0, vec1, rnd_val, out0, out1) \
32 { \
33  ADDS_SH2_SH(vec0, in0, vec1, in1, out0, out1); \
34  SRARI_H2_SH(out0, out1, rnd_val); \
35  CLIP_SH2_0_255(out0, out1); \
36 }
37 
38 #define HEVC_BI_RND_CLIP4(in0, in1, in2, in3, \
39  vec0, vec1, vec2, vec3, rnd_val, \
40  out0, out1, out2, out3) \
41 { \
42  HEVC_BI_RND_CLIP2(in0, in1, vec0, vec1, rnd_val, out0, out1); \
43  HEVC_BI_RND_CLIP2(in2, in3, vec2, vec3, rnd_val, out2, out3); \
44 }
45 
46 #define HEVC_BI_RND_CLIP2_MAX_SATU(in0, in1, vec0, vec1, rnd_val, \
47  out0, out1) \
48 { \
49  ADDS_SH2_SH(vec0, in0, vec1, in1, out0, out1); \
50  SRARI_H2_SH(out0, out1, rnd_val); \
51  CLIP_SH2_0_255_MAX_SATU(out0, out1); \
52 }
53 
54 #define HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, vec0, vec1, vec2, \
55  vec3, rnd_val, out0, out1, out2, out3) \
56 { \
57  HEVC_BI_RND_CLIP2_MAX_SATU(in0, in1, vec0, vec1, rnd_val, out0, out1); \
58  HEVC_BI_RND_CLIP2_MAX_SATU(in2, in3, vec2, vec3, rnd_val, out2, out3); \
59 }
60 
61 static void hevc_bi_copy_4w_msa(uint8_t *src0_ptr,
62  int32_t src_stride,
63  int16_t *src1_ptr,
64  int32_t src2_stride,
65  uint8_t *dst,
66  int32_t dst_stride,
67  int32_t height)
68 {
69  uint32_t loop_cnt, tp0, tp1, tp2, tp3;
70  uint64_t tpd0, tpd1, tpd2, tpd3;
71  v16i8 src0 = { 0 }, src1 = { 0 };
72  v16i8 zero = { 0 };
73  v8i16 in0 = { 0 }, in1 = { 0 }, in2 = { 0 }, in3 = { 0 };
74  v8i16 dst0, dst1, dst2, dst3;
75 
76  if (2 == height) {
77  LW2(src0_ptr, src_stride, tp0, tp1);
78  INSERT_W2_SB(tp0, tp1, src0);
79  LD2(src1_ptr, src2_stride, tpd0, tpd1);
80  INSERT_D2_SH(tpd0, tpd1, in0);
81 
82  dst0 = (v8i16) __msa_ilvr_b(zero, src0);
83  dst0 <<= 6;
84  dst0 += in0;
85  dst0 = __msa_srari_h(dst0, 7);
86  dst0 = CLIP_SH_0_255_MAX_SATU(dst0);
87 
88  dst0 = (v8i16) __msa_pckev_b((v16i8) dst0, (v16i8) dst0);
89  ST4x2_UB(dst0, dst, dst_stride);
90  } else if (4 == height) {
91  LW4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
92  INSERT_W4_SB(tp0, tp1, tp2, tp3, src0);
93  LD4(src1_ptr, src2_stride, tpd0, tpd1, tpd2, tpd3);
94  INSERT_D2_SH(tpd0, tpd1, in0);
95  INSERT_D2_SH(tpd2, tpd3, in1);
96  ILVRL_B2_SH(zero, src0, dst0, dst1);
97  SLLI_2V(dst0, dst1, 6);
98  HEVC_BI_RND_CLIP2_MAX_SATU(in0, in1, dst0, dst1, 7, dst0, dst1);
99  dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
100  ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
101  } else if (0 == height % 8) {
102  for (loop_cnt = (height >> 3); loop_cnt--;) {
103  LW4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
104  src0_ptr += 4 * src_stride;
105  INSERT_W4_SB(tp0, tp1, tp2, tp3, src0);
106  LW4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
107  src0_ptr += 4 * src_stride;
108  INSERT_W4_SB(tp0, tp1, tp2, tp3, src1);
109  LD4(src1_ptr, src2_stride, tpd0, tpd1, tpd2, tpd3);
110  src1_ptr += (4 * src2_stride);
111  INSERT_D2_SH(tpd0, tpd1, in0);
112  INSERT_D2_SH(tpd2, tpd3, in1);
113  LD4(src1_ptr, src2_stride, tpd0, tpd1, tpd2, tpd3);
114  src1_ptr += (4 * src2_stride);
115  INSERT_D2_SH(tpd0, tpd1, in2);
116  INSERT_D2_SH(tpd2, tpd3, in3);
117  ILVRL_B2_SH(zero, src0, dst0, dst1);
118  ILVRL_B2_SH(zero, src1, dst2, dst3);
119  SLLI_4V(dst0, dst1, dst2, dst3, 6);
120  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2,
121  dst3, 7, dst0, dst1, dst2, dst3);
122  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
123  ST4x8_UB(dst0, dst1, dst, dst_stride);
124  dst += (8 * dst_stride);
125  }
126  }
127 }
128 
129 static void hevc_bi_copy_6w_msa(uint8_t *src0_ptr,
130  int32_t src_stride,
131  int16_t *src1_ptr,
132  int32_t src2_stride,
133  uint8_t *dst,
134  int32_t dst_stride,
135  int32_t height)
136 {
137  uint32_t loop_cnt;
138  uint64_t tp0, tp1, tp2, tp3;
139  v16u8 out0, out1, out2, out3;
140  v16i8 zero = { 0 };
141  v16i8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
142  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
143  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
144 
145  for (loop_cnt = (height >> 3); loop_cnt--;) {
146  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
147  src0_ptr += (4 * src_stride);
148  INSERT_D2_SB(tp0, tp1, src0);
149  INSERT_D2_SB(tp2, tp3, src1);
150  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
151  src0_ptr += (4 * src_stride);
152  INSERT_D2_SB(tp0, tp1, src2);
153  INSERT_D2_SB(tp2, tp3, src3);
154  LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
155  src1_ptr += (8 * src2_stride);
156  ILVRL_B2_SH(zero, src0, dst0, dst1);
157  ILVRL_B2_SH(zero, src1, dst2, dst3);
158  ILVRL_B2_SH(zero, src2, dst4, dst5);
159  ILVRL_B2_SH(zero, src3, dst6, dst7);
160  SLLI_4V(dst0, dst1, dst2, dst3, 6);
161  SLLI_4V(dst4, dst5, dst6, dst7, 6);
162  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
163  7, dst0, dst1, dst2, dst3);
164  HEVC_BI_RND_CLIP4_MAX_SATU(in4, in5, in6, in7, dst4, dst5, dst6, dst7,
165  7, dst4, dst5, dst6, dst7);
166  PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
167  PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
168  ST6x4_UB(out0, out1, dst, dst_stride);
169  dst += (4 * dst_stride);
170  ST6x4_UB(out2, out3, dst, dst_stride);
171  dst += (4 * dst_stride);
172  }
173 }
174 
175 static void hevc_bi_copy_8w_msa(uint8_t *src0_ptr,
176  int32_t src_stride,
177  int16_t *src1_ptr,
178  int32_t src2_stride,
179  uint8_t *dst,
180  int32_t dst_stride,
181  int32_t height)
182 {
183  uint64_t tp0, tp1, tp2, tp3;
184  v16u8 out0, out1, out2, out3;
185  v16i8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
186  v16i8 zero = { 0 };
187  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
188  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
189 
190  if (2 == height) {
191  LD2(src0_ptr, src_stride, tp0, tp1);
192  INSERT_D2_SB(tp0, tp1, src0);
193  LD_SH2(src1_ptr, src2_stride, in0, in1);
194  ILVRL_B2_SH(zero, src0, dst0, dst1);
195  SLLI_2V(dst0, dst1, 6);
196  HEVC_BI_RND_CLIP2_MAX_SATU(in0, in1, dst0, dst1, 7, dst0, dst1);
197  out0 = (v16u8) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
198  ST8x2_UB(out0, dst, dst_stride);
199  } else if (4 == height) {
200  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
201  INSERT_D2_SB(tp0, tp1, src0);
202  INSERT_D2_SB(tp2, tp3, src1);
203  ILVRL_B2_SH(zero, src0, dst0, dst1);
204  ILVRL_B2_SH(zero, src1, dst2, dst3);
205  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
206  SLLI_4V(dst0, dst1, dst2, dst3, 6);
207  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
208  7, dst0, dst1, dst2, dst3);
209  PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
210  ST8x4_UB(out0, out1, dst, dst_stride);
211  } else if (6 == height) {
212  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
213  src0_ptr += 4 * src_stride;
214  INSERT_D2_SB(tp0, tp1, src0);
215  INSERT_D2_SB(tp2, tp3, src1);
216  LD2(src0_ptr, src_stride, tp0, tp1);
217  INSERT_D2_SB(tp0, tp1, src2);
218  ILVRL_B2_SH(zero, src0, dst0, dst1);
219  ILVRL_B2_SH(zero, src1, dst2, dst3);
220  ILVRL_B2_SH(zero, src2, dst4, dst5);
221  LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
222  SLLI_4V(dst0, dst1, dst2, dst3, 6);
223  SLLI_2V(dst4, dst5, 6);
224  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
225  7, dst0, dst1, dst2, dst3);
226  HEVC_BI_RND_CLIP2_MAX_SATU(in4, in5, dst4, dst5, 7, dst4, dst5);
227  PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
228  ST8x4_UB(out0, out1, dst, dst_stride);
229  dst += (4 * dst_stride);
230  ST8x2_UB(out2, dst, dst_stride);
231  } else if (0 == height % 8) {
232  uint32_t loop_cnt;
233 
234  for (loop_cnt = (height >> 3); loop_cnt--;) {
235  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
236  src0_ptr += 4 * src_stride;
237  INSERT_D2_SB(tp0, tp1, src0);
238  INSERT_D2_SB(tp2, tp3, src1);
239  LD4(src0_ptr, src_stride, tp0, tp1, tp2, tp3);
240  src0_ptr += 4 * src_stride;
241  INSERT_D2_SB(tp0, tp1, src2);
242  INSERT_D2_SB(tp2, tp3, src3);
243  ILVRL_B2_SH(zero, src0, dst0, dst1);
244  ILVRL_B2_SH(zero, src1, dst2, dst3);
245  ILVRL_B2_SH(zero, src2, dst4, dst5);
246  ILVRL_B2_SH(zero, src3, dst6, dst7);
247  LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6,
248  in7);
249  src1_ptr += (8 * src2_stride);
250  SLLI_4V(dst0, dst1, dst2, dst3, 6);
251  SLLI_4V(dst4, dst5, dst6, dst7, 6);
252  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2,
253  dst3, 7, dst0, dst1, dst2, dst3);
254  HEVC_BI_RND_CLIP4_MAX_SATU(in4, in5, in6, in7, dst4, dst5, dst6,
255  dst7, 7, dst4, dst5, dst6, dst7);
256  PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
257  PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
258  ST8x8_UB(out0, out1, out2, out3, dst, dst_stride);
259  dst += (8 * dst_stride);
260  }
261  }
262 }
263 
264 static void hevc_bi_copy_12w_msa(uint8_t *src0_ptr,
265  int32_t src_stride,
266  int16_t *src1_ptr,
267  int32_t src2_stride,
268  uint8_t *dst,
269  int32_t dst_stride,
270  int32_t height)
271 {
272  uint32_t loop_cnt;
273  v16i8 zero = { 0 };
274  v16u8 out0, out1, out2;
275  v16i8 src0, src1, src2, src3;
276  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
277  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
278 
279  for (loop_cnt = 4; loop_cnt--;) {
280  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
281  src0_ptr += (4 * src_stride);
282 
283  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
284  LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
285  src1_ptr += (4 * src2_stride);
286  ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
287  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, dst0, dst1,
288  dst2, dst3);
289  SLLI_4V(dst0, dst1, dst2, dst3, 6);
290  ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
291  ILVR_B2_SH(zero, src0, zero, src1, dst4, dst5);
292  SLLI_2V(dst4, dst5, 6);
293  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
294  7, dst0, dst1, dst2, dst3);
295  HEVC_BI_RND_CLIP2_MAX_SATU(in4, in5, dst4, dst5, 7, dst4, dst5);
296  PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
297  ST12x4_UB(out0, out1, out2, dst, dst_stride);
298  dst += (4 * dst_stride);
299  }
300 }
301 
302 static void hevc_bi_copy_16w_msa(uint8_t *src0_ptr,
303  int32_t src_stride,
304  int16_t *src1_ptr,
305  int32_t src2_stride,
306  uint8_t *dst,
307  int32_t dst_stride,
308  int32_t height)
309 {
310  uint32_t loop_cnt;
311  v16u8 out0, out1, out2, out3;
312  v16i8 src0, src1, src2, src3;
313  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
314  v8i16 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
315  v16i8 zero = { 0 };
316 
317  for (loop_cnt = (height >> 2); loop_cnt--;) {
318  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
319  src0_ptr += (4 * src_stride);
320  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
321  LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
322  src1_ptr += (4 * src2_stride);
323  ILVRL_B2_SH(zero, src0, dst0_r, dst0_l);
324  ILVRL_B2_SH(zero, src1, dst1_r, dst1_l);
325  ILVRL_B2_SH(zero, src2, dst2_r, dst2_l);
326  ILVRL_B2_SH(zero, src3, dst3_r, dst3_l);
327  SLLI_4V(dst0_r, dst1_r, dst2_r, dst3_r, 6);
328  SLLI_4V(dst0_l, dst1_l, dst2_l, dst3_l, 6);
329  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in4, in5, dst0_r, dst1_r, dst0_l,
330  dst1_l, 7, dst0_r, dst1_r, dst0_l, dst1_l);
331  HEVC_BI_RND_CLIP4_MAX_SATU(in2, in3, in6, in7, dst2_r, dst3_r, dst2_l,
332  dst3_l, 7, dst2_r, dst3_r, dst2_l, dst3_l);
333  PCKEV_B2_UB(dst0_l, dst0_r, dst1_l, dst1_r, out0, out1);
334  PCKEV_B2_UB(dst2_l, dst2_r, dst3_l, dst3_r, out2, out3);
335  ST_UB4(out0, out1, out2, out3, dst, dst_stride);
336  dst += (4 * dst_stride);
337  }
338 }
339 
340 static void hevc_bi_copy_24w_msa(uint8_t *src0_ptr,
341  int32_t src_stride,
342  int16_t *src1_ptr,
343  int32_t src2_stride,
344  uint8_t *dst,
345  int32_t dst_stride,
346  int32_t height)
347 {
348  uint32_t loop_cnt;
349  v16u8 out0, out1, out2, out3, out4, out5;
350  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, zero = { 0 };
351  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9, dst10;
352  v8i16 in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, dst11;
353 
354  for (loop_cnt = 8; loop_cnt--;) {
355  LD_SB4(src0_ptr, src_stride, src0, src1, src4, src5);
356  LD_SB4(src0_ptr + 16, src_stride, src2, src3, src6, src7);
357  src0_ptr += (4 * src_stride);
358  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
359  LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
360  LD_SH4(src1_ptr + 16, src2_stride, in8, in9, in10, in11);
361  src1_ptr += (4 * src2_stride);
362 
363  ILVRL_B2_SH(zero, src0, dst0, dst1);
364  ILVRL_B2_SH(zero, src1, dst2, dst3);
365  ILVR_B2_SH(zero, src2, zero, src3, dst4, dst5);
366  ILVRL_B2_SH(zero, src4, dst6, dst7);
367  ILVRL_B2_SH(zero, src5, dst8, dst9);
368  ILVR_B2_SH(zero, src6, zero, src7, dst10, dst11);
369  SLLI_4V(dst0, dst1, dst2, dst3, 6);
370  SLLI_4V(dst4, dst5, dst6, dst7, 6);
371  SLLI_4V(dst8, dst9, dst10, dst11, 6);
372  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in4, in1, in5, dst0, dst1, dst2, dst3,
373  7, dst0, dst1, dst2, dst3);
374  HEVC_BI_RND_CLIP4_MAX_SATU(in8, in9, in2, in6, dst4, dst5, dst6, dst7,
375  7, dst4, dst5, dst6, dst7);
376  HEVC_BI_RND_CLIP4_MAX_SATU(in3, in7, in10, in11, dst8, dst9, dst10,
377  dst11, 7, dst8, dst9, dst10, dst11);
378  PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
379  PCKEV_B3_UB(dst7, dst6, dst9, dst8, dst11, dst10, out3, out4, out5);
380  ST_UB4(out0, out1, out3, out4, dst, dst_stride);
381  ST8x4_UB(out2, out5, dst + 16, dst_stride);
382  dst += (4 * dst_stride);
383  }
384 }
385 
386 static void hevc_bi_copy_32w_msa(uint8_t *src0_ptr,
387  int32_t src_stride,
388  int16_t *src1_ptr,
389  int32_t src2_stride,
390  uint8_t *dst,
391  int32_t dst_stride,
392  int32_t height)
393 {
394  uint32_t loop_cnt;
395  v16u8 out0, out1, out2, out3;
396  v16i8 src0, src1, src2, src3;
397  v16i8 zero = { 0 };
398  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
399  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
400 
401  for (loop_cnt = (height >> 1); loop_cnt--;) {
402  LD_SB2(src0_ptr, 16, src0, src1);
403  src0_ptr += src_stride;
404  LD_SB2(src0_ptr, 16, src2, src3);
405  src0_ptr += src_stride;
406  LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
407  src1_ptr += src2_stride;
408  LD_SH4(src1_ptr, 8, in4, in5, in6, in7);
409  src1_ptr += src2_stride;
410 
411  ILVRL_B2_SH(zero, src0, dst0, dst1);
412  ILVRL_B2_SH(zero, src1, dst2, dst3);
413  ILVRL_B2_SH(zero, src2, dst4, dst5);
414  ILVRL_B2_SH(zero, src3, dst6, dst7);
415  SLLI_4V(dst0, dst1, dst2, dst3, 6);
416  SLLI_4V(dst4, dst5, dst6, dst7, 6);
417  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
418  7, dst0, dst1, dst2, dst3);
419  HEVC_BI_RND_CLIP4_MAX_SATU(in4, in5, in6, in7, dst4, dst5, dst6, dst7,
420  7, dst4, dst5, dst6, dst7);
421  PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
422  PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
423  ST_UB2(out0, out1, dst, 16);
424  dst += dst_stride;
425  ST_UB2(out2, out3, dst, 16);
426  dst += dst_stride;
427  }
428 }
429 
430 static void hevc_bi_copy_48w_msa(uint8_t *src0_ptr,
431  int32_t src_stride,
432  int16_t *src1_ptr,
433  int32_t src2_stride,
434  uint8_t *dst,
435  int32_t dst_stride,
436  int32_t height)
437 {
438  uint32_t loop_cnt;
439  v16u8 out0, out1, out2, out3, out4, out5;
440  v16i8 src0, src1, src2, src3, src4, src5;
441  v16i8 zero = { 0 };
442  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9, dst10;
443  v8i16 in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, dst11;
444 
445  for (loop_cnt = (height >> 1); loop_cnt--;) {
446  LD_SB3(src0_ptr, 16, src0, src1, src2);
447  src0_ptr += src_stride;
448  LD_SB3(src0_ptr, 16, src3, src4, src5);
449  src0_ptr += src_stride;
450 
451  LD_SH6(src1_ptr, 8, in0, in1, in2, in3, in4, in5);
452  src1_ptr += src2_stride;
453  LD_SH6(src1_ptr, 8, in6, in7, in8, in9, in10, in11);
454  src1_ptr += src2_stride;
455 
456  ILVRL_B2_SH(zero, src0, dst0, dst1);
457  ILVRL_B2_SH(zero, src1, dst2, dst3);
458  ILVRL_B2_SH(zero, src2, dst4, dst5);
459  ILVRL_B2_SH(zero, src3, dst6, dst7);
460  ILVRL_B2_SH(zero, src4, dst8, dst9);
461  ILVRL_B2_SH(zero, src5, dst10, dst11);
462 
463  SLLI_4V(dst0, dst1, dst2, dst3, 6);
464  SLLI_4V(dst4, dst5, dst6, dst7, 6);
465  SLLI_4V(dst8, dst9, dst10, dst11, 6);
466 
467  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
468  7, dst0, dst1, dst2, dst3);
469  HEVC_BI_RND_CLIP4_MAX_SATU(in4, in5, in6, in7, dst4, dst5, dst6, dst7,
470  7, dst4, dst5, dst6, dst7);
471  HEVC_BI_RND_CLIP4_MAX_SATU(in8, in9, in10, in11, dst8, dst9, dst10,
472  dst11, 7, dst8, dst9, dst10, dst11);
473  PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
474  PCKEV_B3_UB(dst7, dst6, dst9, dst8, dst11, dst10, out3, out4, out5);
475  ST_UB2(out0, out1, dst, 16);
476  ST_UB(out2, dst + 32);
477  dst += dst_stride;
478  ST_UB2(out3, out4, dst, 16);
479  ST_UB(out5, dst + 32);
480  dst += dst_stride;
481  }
482 }
483 
484 static void hevc_bi_copy_64w_msa(uint8_t *src0_ptr,
485  int32_t src_stride,
486  int16_t *src1_ptr,
487  int32_t src2_stride,
488  uint8_t *dst,
489  int32_t dst_stride,
490  int32_t height)
491 {
492  uint32_t loop_cnt;
493  v16u8 out0, out1, out2, out3;
494  v16i8 src0, src1, src2, src3;
495  v16i8 zero = { 0 };
496  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
497  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
498 
499  for (loop_cnt = height; loop_cnt--;) {
500  LD_SB4(src0_ptr, 16, src0, src1, src2, src3);
501  src0_ptr += src_stride;
502  LD_SH8(src1_ptr, 8, in0, in1, in2, in3, in4, in5, in6, in7);
503  src1_ptr += src2_stride;
504 
505  ILVRL_B2_SH(zero, src0, dst0, dst1);
506  ILVRL_B2_SH(zero, src1, dst2, dst3);
507  ILVRL_B2_SH(zero, src2, dst4, dst5);
508  ILVRL_B2_SH(zero, src3, dst6, dst7);
509  SLLI_4V(dst0, dst1, dst2, dst3, 6);
510  SLLI_4V(dst4, dst5, dst6, dst7, 6);
511  HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, dst0, dst1, dst2, dst3,
512  7, dst0, dst1, dst2, dst3);
513  HEVC_BI_RND_CLIP4_MAX_SATU(in4, in5, in6, in7, dst4, dst5, dst6, dst7,
514  7, dst4, dst5, dst6, dst7);
515  PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
516  PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
517 
518  ST_UB4(out0, out1, out2, out3, dst, 16);
519  dst += dst_stride;
520  }
521 }
522 
523 static void hevc_hz_bi_8t_4w_msa(uint8_t *src0_ptr,
524  int32_t src_stride,
525  int16_t *src1_ptr,
526  int32_t src2_stride,
527  uint8_t *dst,
528  int32_t dst_stride,
529  const int8_t *filter,
530  int32_t height)
531 {
532  uint32_t loop_cnt;
533  v8i16 filt0, filt1, filt2, filt3;
534  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
535  v16i8 mask1, mask2, mask3;
536  v16i8 vec0, vec1, vec2, vec3;
537  v8i16 dst0, dst1, dst2, dst3;
538  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
539  v8i16 filter_vec, const_vec;
540  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[16]);
541 
542  src0_ptr -= 3;
543 
544  /* rearranging filter */
545  filter_vec = LD_SH(filter);
546  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
547 
548  mask1 = mask0 + 2;
549  mask2 = mask0 + 4;
550  mask3 = mask0 + 6;
551 
552  const_vec = __msa_ldi_h(128);
553  const_vec <<= 6;
554 
555  for (loop_cnt = (height >> 3); loop_cnt--;) {
556  LD_SB8(src0_ptr, src_stride, src0, src1, src2, src3,
557  src4, src5, src6, src7);
558  src0_ptr += (8 * src_stride);
559  LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
560  src1_ptr += (8 * src2_stride);
561 
562  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
563  ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
564  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
565 
566  dst0 = const_vec;
567  dst1 = const_vec;
568  dst2 = const_vec;
569  dst3 = const_vec;
570  VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
571  VSHF_B2_SB(src4, src5, src6, src7, mask0, mask0, vec2, vec3);
572  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
573  dst1, dst2, dst3);
574  VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec0, vec1);
575  VSHF_B2_SB(src4, src5, src6, src7, mask1, mask1, vec2, vec3);
576  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
577  dst1, dst2, dst3);
578  VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec0, vec1);
579  VSHF_B2_SB(src4, src5, src6, src7, mask2, mask2, vec2, vec3);
580  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
581  dst1, dst2, dst3);
582  VSHF_B2_SB(src0, src1, src2, src3, mask3, mask3, vec0, vec1);
583  VSHF_B2_SB(src4, src5, src6, src7, mask3, mask3, vec2, vec3);
584  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
585  dst1, dst2, dst3);
586 
587  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
588  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
589 
590  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
591  ST4x8_UB(dst0, dst1, dst, dst_stride);
592  dst += (8 * dst_stride);
593  }
594 }
595 
596 static void hevc_hz_bi_8t_8w_msa(uint8_t *src0_ptr,
597  int32_t src_stride,
598  int16_t *src1_ptr,
599  int32_t src2_stride,
600  uint8_t *dst,
601  int32_t dst_stride,
602  const int8_t *filter,
603  int32_t height)
604 {
605  uint32_t loop_cnt;
606  v8i16 filt0, filt1, filt2, filt3;
607  v16i8 src0, src1, src2, src3;
608  v16i8 mask1, mask2, mask3;
609  v16i8 vec0, vec1, vec2, vec3;
610  v8i16 dst0, dst1, dst2, dst3;
611  v8i16 in0, in1, in2, in3;
612  v8i16 filter_vec, const_vec;
613  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
614 
615  src0_ptr -= 3;
616 
617  const_vec = __msa_ldi_h(128);
618  const_vec <<= 6;
619 
620  filter_vec = LD_SH(filter);
621  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
622 
623  mask1 = mask0 + 2;
624  mask2 = mask0 + 4;
625  mask3 = mask0 + 6;
626 
627  for (loop_cnt = (height >> 2); loop_cnt--;) {
628  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
629  src0_ptr += (4 * src_stride);
630  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
631  src1_ptr += (4 * src2_stride);
632  XORI_B4_128_SB(src0, src1, src2, src3);
633 
634  dst0 = const_vec;
635  dst1 = const_vec;
636  dst2 = const_vec;
637  dst3 = const_vec;
638  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
639  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
640  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
641  dst1, dst2, dst3);
642  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
643  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
644  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
645  dst1, dst2, dst3);
646  VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec0, vec1);
647  VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec2, vec3);
648  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
649  dst1, dst2, dst3);
650  VSHF_B2_SB(src0, src0, src1, src1, mask3, mask3, vec0, vec1);
651  VSHF_B2_SB(src2, src2, src3, src3, mask3, mask3, vec2, vec3);
652  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
653  dst1, dst2, dst3);
654 
655  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
656  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
657 
658  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
659  ST8x4_UB(dst0, dst1, dst, dst_stride);
660  dst += (4 * dst_stride);
661  }
662 }
663 
664 static void hevc_hz_bi_8t_12w_msa(uint8_t *src0_ptr,
665  int32_t src_stride,
666  int16_t *src1_ptr,
667  int32_t src2_stride,
668  uint8_t *dst,
669  int32_t dst_stride,
670  const int8_t *filter,
671  int32_t height)
672 {
673  uint32_t loop_cnt;
674  int32_t tmp0, tmp1;
675  int64_t tmp2, tmp3;
676  v16i8 src0, src1, src2, src3;
677  v16i8 vec0, vec1, vec2;
678  v8i16 filt0, filt1, filt2, filt3;
679  v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
680  v8i16 dst0, dst1, dst2;
681  v8i16 in0, in1, in2, in3;
682  v8i16 filter_vec, const_vec;
683 
684  src0_ptr -= 3;
685  const_vec = __msa_ldi_h(128);
686  const_vec <<= 6;
687 
688  filter_vec = LD_SH(filter);
689  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
690 
691  mask0 = LD_SB(ff_hevc_mask_arr);
692  mask1 = mask0 + 2;
693  mask2 = mask0 + 4;
694  mask3 = mask0 + 6;
695  mask4 = LD_SB(&ff_hevc_mask_arr[16]);
696  mask5 = mask4 + 2;
697  mask6 = mask4 + 4;
698  mask7 = mask4 + 6;
699 
700  for (loop_cnt = 8; loop_cnt--;) {
701  LD_SB2(src0_ptr, 8, src0, src1);
702  src0_ptr += src_stride;
703  LD_SB2(src0_ptr, 8, src2, src3);
704  src0_ptr += src_stride;
705  LD_SH2(src1_ptr, 8, in0, in1);
706  src1_ptr += src2_stride;
707  LD_SH2(src1_ptr, 8, in2, in3);
708  src1_ptr += src2_stride;
709  XORI_B4_128_SB(src0, src1, src2, src3);
710 
711  dst0 = const_vec;
712  dst1 = const_vec;
713  dst2 = const_vec;
714 
715  VSHF_B3_SB(src0, src0, src1, src3, src2, src2, mask0, mask4, mask0,
716  vec0, vec1, vec2);
717  DPADD_SB2_SH(vec0, vec1, filt0, filt0, dst0, dst1);
718  dst2 = __msa_dpadd_s_h(dst2, vec2, (v16i8) filt0);
719  VSHF_B3_SB(src0, src0, src1, src3, src2, src2, mask1, mask5, mask1,
720  vec0, vec1, vec2);
721  DPADD_SB2_SH(vec0, vec1, filt1, filt1, dst0, dst1);
722  dst2 = __msa_dpadd_s_h(dst2, vec2, (v16i8) filt1);
723  VSHF_B3_SB(src0, src0, src1, src3, src2, src2, mask2, mask6, mask2,
724  vec0, vec1, vec2);
725  DPADD_SB2_SH(vec0, vec1, filt2, filt2, dst0, dst1);
726  dst2 = __msa_dpadd_s_h(dst2, vec2, (v16i8) filt2);
727  VSHF_B3_SB(src0, src0, src1, src3, src2, src2, mask3, mask7, mask3,
728  vec0, vec1, vec2);
729  DPADD_SB2_SH(vec0, vec1, filt3, filt3, dst0, dst1);
730  dst2 = __msa_dpadd_s_h(dst2, vec2, (v16i8) filt3);
731 
732  in1 = (v8i16) __msa_pckev_d((v2i64) in3, (v2i64) in1);
733  HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
734  dst2 = __msa_adds_s_h(in2, dst2);
735  dst2 = __msa_srari_h(dst2, 7);
736  dst2 = CLIP_SH_0_255(dst2);
737  PCKEV_B2_SH(dst1, dst0, dst2, dst2, dst0, dst1);
738 
739  tmp2 = __msa_copy_s_d((v2i64) dst0, 0);
740  tmp0 = __msa_copy_s_w((v4i32) dst0, 2);
741  tmp3 = __msa_copy_s_d((v2i64) dst1, 0);
742  tmp1 = __msa_copy_s_w((v4i32) dst0, 3);
743  SD(tmp2, dst);
744  SW(tmp0, dst + 8);
745  dst += dst_stride;
746  SD(tmp3, dst);
747  SW(tmp1, dst + 8);
748  dst += dst_stride;
749  }
750 }
751 
752 static void hevc_hz_bi_8t_16w_msa(uint8_t *src0_ptr,
753  int32_t src_stride,
754  int16_t *src1_ptr,
755  int32_t src2_stride,
756  uint8_t *dst,
757  int32_t dst_stride,
758  const int8_t *filter,
759  int32_t height)
760 {
761  uint32_t loop_cnt;
762  v16i8 src0, src1, src2, src3;
763  v8i16 filt0, filt1, filt2, filt3;
764  v16i8 mask1, mask2, mask3;
765  v16i8 vec0, vec1, vec2, vec3;
766  v8i16 dst0, dst1, dst2, dst3;
767  v8i16 in0, in1, in2, in3;
768  v8i16 filter_vec, const_vec;
769  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
770 
771  src0_ptr -= 3;
772  const_vec = __msa_ldi_h(128);
773  const_vec <<= 6;
774 
775  filter_vec = LD_SH(filter);
776  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
777 
778  mask1 = mask0 + 2;
779  mask2 = mask0 + 4;
780  mask3 = mask0 + 6;
781 
782  for (loop_cnt = (height >> 1); loop_cnt--;) {
783  LD_SB2(src0_ptr, 8, src0, src1);
784  src0_ptr += src_stride;
785  LD_SB2(src0_ptr, 8, src2, src3);
786  src0_ptr += src_stride;
787  LD_SH2(src1_ptr, 8, in0, in1);
788  src1_ptr += src2_stride;
789  LD_SH2(src1_ptr, 8, in2, in3);
790  src1_ptr += src2_stride;
791  XORI_B4_128_SB(src0, src1, src2, src3);
792 
793  dst0 = const_vec;
794  dst1 = const_vec;
795  dst2 = const_vec;
796  dst3 = const_vec;
797  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
798  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
799  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
800  dst1, dst2, dst3);
801  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
802  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
803  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
804  dst1, dst2, dst3);
805  VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec0, vec1);
806  VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec2, vec3);
807  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
808  dst1, dst2, dst3);
809  VSHF_B2_SB(src0, src0, src1, src1, mask3, mask3, vec0, vec1);
810  VSHF_B2_SB(src2, src2, src3, src3, mask3, mask3, vec2, vec3);
811  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
812  dst1, dst2, dst3);
813 
814  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
815  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
816 
817  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
818  ST_SH2(dst0, dst1, dst, dst_stride);
819  dst += (2 * dst_stride);
820  }
821 }
822 
823 static void hevc_hz_bi_8t_24w_msa(uint8_t *src0_ptr,
824  int32_t src_stride,
825  int16_t *src1_ptr,
826  int32_t src2_stride,
827  uint8_t *dst,
828  int32_t dst_stride,
829  const int8_t *filter,
830  int32_t height)
831 {
832  uint32_t loop_cnt;
833  uint64_t dst_val0;
834  v16i8 src0, src1, tmp0, tmp1;
835  v8i16 filt0, filt1, filt2, filt3;
836  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
837  v16i8 vec0, vec1, vec2, vec3;
838  v8i16 dst0, dst1, dst2;
839  v8i16 in0, in1, in2;
840  v8i16 filter_vec, const_vec;
841  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
842 
843  src0_ptr = src0_ptr - 3;
844  const_vec = __msa_ldi_h(128);
845  const_vec <<= 6;
846 
847  filter_vec = LD_SH(filter);
848  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
849 
850  mask1 = mask0 + 2;
851  mask2 = mask0 + 4;
852  mask3 = mask0 + 6;
853  mask4 = mask0 + 8;
854  mask5 = mask0 + 10;
855  mask6 = mask0 + 12;
856  mask7 = mask0 + 14;
857 
858  for (loop_cnt = height; loop_cnt--;) {
859  LD_SB2(src0_ptr, 16, src0, src1);
860  src0_ptr += src_stride;
861  LD_SH2(src1_ptr, 8, in0, in1);
862  in2 = LD_SH(src1_ptr + 16);
863  src1_ptr += src2_stride;
864  XORI_B2_128_SB(src0, src1);
865 
866  dst0 = const_vec;
867  dst1 = const_vec;
868  dst2 = const_vec;
869  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask4, vec0, vec1);
870  VSHF_B2_SB(src1, src1, src0, src0, mask0, mask1, vec2, vec3);
871  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt1, dst0,
872  dst1, dst2, dst0);
873  VSHF_B2_SB(src0, src1, src1, src1, mask5, mask1, vec0, vec1);
874  VSHF_B2_SB(src0, src0, src0, src1, mask2, mask6, vec2, vec3);
875  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt2, filt2, dst1,
876  dst2, dst0, dst1);
877  VSHF_B2_SB(src1, src1, src0, src0, mask2, mask3, vec0, vec1);
878  VSHF_B2_SB(src0, src1, src1, src1, mask7, mask3, vec2, vec3);
879  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt3, filt3, filt3, dst2,
880  dst0, dst1, dst2);
881 
882  HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
883  dst2 = __msa_adds_s_h(dst2, in2);
884  dst2 = __msa_srari_h(dst2, 7);
885  dst2 = CLIP_SH_0_255(dst2);
886 
887  PCKEV_B2_SB(dst1, dst0, dst2, dst2, tmp0, tmp1);
888  dst_val0 = __msa_copy_u_d((v2i64) tmp1, 0);
889  ST_SB(tmp0, dst);
890  SD(dst_val0, dst + 16);
891  dst += dst_stride;
892  }
893 }
894 
895 static void hevc_hz_bi_8t_32w_msa(uint8_t *src0_ptr,
896  int32_t src_stride,
897  int16_t *src1_ptr,
898  int32_t src2_stride,
899  uint8_t *dst,
900  int32_t dst_stride,
901  const int8_t *filter,
902  int32_t height)
903 {
904  uint32_t loop_cnt;
905  v16i8 src0, src1, src2, tmp0, tmp1;
906  v8i16 filt0, filt1, filt2, filt3;
907  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
908  v16i8 vec0, vec1, vec2, vec3;
909  v8i16 dst0, dst1, dst2, dst3;
910  v8i16 in0, in1, in2, in3;
911  v8i16 filter_vec, const_vec;
912  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
913 
914  src0_ptr -= 3;
915  const_vec = __msa_ldi_h(128);
916  const_vec <<= 6;
917 
918  filter_vec = LD_SH(filter);
919  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
920 
921  mask1 = mask0 + 2;
922  mask2 = mask0 + 4;
923  mask3 = mask0 + 6;
924  mask4 = mask0 + 8;
925  mask5 = mask0 + 10;
926  mask6 = mask0 + 12;
927  mask7 = mask0 + 14;
928 
929  for (loop_cnt = height; loop_cnt--;) {
930  LD_SB2(src0_ptr, 16, src0, src1);
931  src2 = LD_SB(src0_ptr + 24);
932  src0_ptr += src_stride;
933  LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
934  src1_ptr += src2_stride;
935  XORI_B3_128_SB(src0, src1, src2);
936 
937  dst0 = const_vec;
938  dst1 = const_vec;
939  dst2 = const_vec;
940  dst3 = const_vec;
941  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask4, vec0, vec1);
942  VSHF_B2_SB(src1, src1, src2, src2, mask0, mask0, vec2, vec3);
943  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
944  dst1, dst2, dst3);
945  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask5, vec0, vec1);
946  VSHF_B2_SB(src1, src1, src2, src2, mask1, mask1, vec2, vec3);
947  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
948  dst1, dst2, dst3);
949  VSHF_B2_SB(src0, src0, src0, src1, mask2, mask6, vec0, vec1);
950  VSHF_B2_SB(src1, src1, src2, src2, mask2, mask2, vec2, vec3);
951  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
952  dst1, dst2, dst3);
953  VSHF_B2_SB(src0, src0, src0, src1, mask3, mask7, vec0, vec1);
954  VSHF_B2_SB(src1, src1, src2, src2, mask3, mask3, vec2, vec3);
955  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
956  dst1, dst2, dst3);
957 
958  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
959  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
960 
961  PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
962  ST_SB2(tmp0, tmp1, dst, 16);
963  dst += dst_stride;
964  }
965 }
966 
967 static void hevc_hz_bi_8t_48w_msa(uint8_t *src0_ptr,
968  int32_t src_stride,
969  int16_t *src1_ptr,
970  int32_t src2_stride,
971  uint8_t *dst,
972  int32_t dst_stride,
973  const int8_t *filter,
974  int32_t height)
975 {
976  uint32_t loop_cnt;
977  v16i8 src0, src1, src2, src3;
978  v16i8 tmp0, tmp1, tmp2;
979  v8i16 filt0, filt1, filt2, filt3;
980  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
981  v16i8 vec0, vec1, vec2, vec3;
982  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
983  v8i16 in0, in1, in2, in3, in4, in5;
984  v8i16 filter_vec, const_vec;
985  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
986 
987  src0_ptr -= 3;
988 
989  const_vec = __msa_ldi_h(128);
990  const_vec <<= 6;
991 
992  filter_vec = LD_SH(filter);
993  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
994 
995  mask1 = mask0 + 2;
996  mask2 = mask0 + 4;
997  mask3 = mask0 + 6;
998  mask4 = mask0 + 8;
999  mask5 = mask0 + 10;
1000  mask6 = mask0 + 12;
1001  mask7 = mask0 + 14;
1002 
1003  for (loop_cnt = 64; loop_cnt--;) {
1004  LD_SB3(src0_ptr, 16, src0, src1, src2);
1005  src3 = LD_SB(src0_ptr + 40);
1006  src0_ptr += src_stride;
1007  LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
1008  XORI_B4_128_SB(src0, src1, src2, src3);
1009 
1010  dst0 = const_vec;
1011  dst1 = const_vec;
1012  dst2 = const_vec;
1013  dst3 = const_vec;
1014 
1015  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask4, vec0, vec1);
1016  VSHF_B2_SB(src1, src1, src1, src2, mask0, mask4, vec2, vec3);
1017  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
1018  dst1, dst2, dst3);
1019  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask5, vec0, vec1);
1020  VSHF_B2_SB(src1, src1, src1, src2, mask1, mask5, vec2, vec3);
1021  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
1022  dst1, dst2, dst3);
1023  VSHF_B2_SB(src0, src0, src0, src1, mask2, mask6, vec0, vec1);
1024  VSHF_B2_SB(src1, src1, src1, src2, mask2, mask6, vec2, vec3);
1025  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
1026  dst1, dst2, dst3);
1027  VSHF_B2_SB(src0, src0, src0, src1, mask3, mask7, vec0, vec1);
1028  VSHF_B2_SB(src1, src1, src1, src2, mask3, mask7, vec2, vec3);
1029  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
1030  dst1, dst2, dst3);
1031  HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
1032  HEVC_BI_RND_CLIP2(in2, in3, dst2, dst3, 7, dst2, dst3);
1033  PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
1034  ST_SB(tmp0, dst);
1035  ST_SB(tmp1, dst + 16);
1036 
1037  LD_SH2(src1_ptr + 32, 8, in4, in5);
1038  src1_ptr += src2_stride;
1039 
1040  dst4 = const_vec;
1041  dst5 = const_vec;
1042  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec0, vec1);
1043  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
1044  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt1, filt1, dst4,
1045  dst5, dst4, dst5);
1046  VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec0, vec1);
1047  VSHF_B2_SB(src2, src2, src3, src3, mask3, mask3, vec2, vec3);
1048  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt3, filt3, dst4,
1049  dst5, dst4, dst5);
1050 
1051  HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
1052 
1053  tmp2 = __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
1054  ST_SB(tmp2, dst + 32);
1055  dst += dst_stride;
1056  }
1057 }
1058 
1059 static void hevc_hz_bi_8t_64w_msa(uint8_t *src0_ptr,
1060  int32_t src_stride,
1061  int16_t *src1_ptr,
1062  int32_t src2_stride,
1063  uint8_t *dst,
1064  int32_t dst_stride,
1065  const int8_t *filter,
1066  int32_t height)
1067 {
1068  uint32_t loop_cnt;
1069  v16i8 src0, src1, src2, src3, src4, src5, tmp0, tmp1;
1070  v8i16 filt0, filt1, filt2, filt3;
1071  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
1072  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
1073  v16i8 vec0, vec1, vec2, vec3;
1074  v8i16 dst0, dst1, dst2, dst3;
1075  v8i16 in0, in1, in2, in3;
1076  v8i16 filter_vec, const_vec;
1077 
1078  src0_ptr -= 3;
1079 
1080  const_vec = __msa_ldi_h(128);
1081  const_vec <<= 6;
1082 
1083  filter_vec = LD_SH(filter);
1084  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1085 
1086  mask1 = mask0 + 2;
1087  mask2 = mask0 + 4;
1088  mask3 = mask0 + 6;
1089  mask4 = mask0 + 8;
1090  mask5 = mask0 + 10;
1091  mask6 = mask0 + 12;
1092  mask7 = mask0 + 14;
1093 
1094  for (loop_cnt = height; loop_cnt--;) {
1095  LD_SB2(src0_ptr, 16, src0, src1);
1096  src2 = LD_SB(src0_ptr + 24);
1097  LD_SB2(src0_ptr + 32, 16, src3, src4);
1098  src5 = LD_SB(src0_ptr + 56);
1099  LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
1100  XORI_B3_128_SB(src0, src1, src2);
1101 
1102  dst0 = const_vec;
1103  dst1 = const_vec;
1104  dst2 = const_vec;
1105  dst3 = const_vec;
1106 
1107  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask4, vec0, vec1);
1108  VSHF_B2_SB(src1, src1, src2, src2, mask0, mask0, vec2, vec3);
1109  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
1110  dst1, dst2, dst3);
1111  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask5, vec0, vec1);
1112  VSHF_B2_SB(src1, src1, src2, src2, mask1, mask1, vec2, vec3);
1113  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
1114  dst1, dst2, dst3);
1115  VSHF_B2_SB(src0, src0, src0, src1, mask2, mask6, vec0, vec1);
1116  VSHF_B2_SB(src1, src1, src2, src2, mask2, mask2, vec2, vec3);
1117  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
1118  dst1, dst2, dst3);
1119  VSHF_B2_SB(src0, src0, src0, src1, mask3, mask7, vec0, vec1);
1120  VSHF_B2_SB(src1, src1, src2, src2, mask3, mask3, vec2, vec3);
1121  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
1122  dst1, dst2, dst3);
1123 
1124  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1125  dst0, dst1, dst2, dst3, 7,
1126  dst0, dst1, dst2, dst3);
1127 
1128  PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
1129  ST_SB2(tmp0, tmp1, dst, 16);
1130 
1131  src0 = src3;
1132  src1 = src4;
1133  src2 = src5;
1134 
1135  LD_SH4(src1_ptr + 32, 8, in0, in1, in2, in3);
1136  XORI_B3_128_SB(src0, src1, src2);
1137 
1138  dst0 = const_vec;
1139  dst1 = const_vec;
1140  dst2 = const_vec;
1141  dst3 = const_vec;
1142  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask4, vec0, vec1);
1143  VSHF_B2_SB(src1, src1, src2, src2, mask0, mask0, vec2, vec3);
1144  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
1145  dst1, dst2, dst3);
1146  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask5, vec0, vec1);
1147  VSHF_B2_SB(src1, src1, src2, src2, mask1, mask1, vec2, vec3);
1148  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
1149  dst1, dst2, dst3);
1150  VSHF_B2_SB(src0, src0, src0, src1, mask2, mask6, vec0, vec1);
1151  VSHF_B2_SB(src1, src1, src2, src2, mask2, mask2, vec2, vec3);
1152  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt2, filt2, filt2, filt2, dst0,
1153  dst1, dst2, dst3);
1154  VSHF_B2_SB(src0, src0, src0, src1, mask3, mask7, vec0, vec1);
1155  VSHF_B2_SB(src1, src1, src2, src2, mask3, mask3, vec2, vec3);
1156  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt3, filt3, filt3, filt3, dst0,
1157  dst1, dst2, dst3);
1158  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1159  dst0, dst1, dst2, dst3, 7,
1160  dst0, dst1, dst2, dst3);
1161  PCKEV_B2_SB(dst1, dst0, dst3, dst2, tmp0, tmp1);
1162  ST_SB2(tmp0, tmp1, dst + 32, 16);
1163  src1_ptr += src2_stride;
1164  src0_ptr += src_stride;
1165  dst += dst_stride;
1166  }
1167 }
1168 
1169 static void hevc_vt_bi_8t_4w_msa(uint8_t *src0_ptr,
1170  int32_t src_stride,
1171  int16_t *src1_ptr,
1172  int32_t src2_stride,
1173  uint8_t *dst,
1174  int32_t dst_stride,
1175  const int8_t *filter,
1176  int32_t height)
1177 {
1178  int32_t loop_cnt;
1179  v16i8 src0, src1, src2, src3, src4, src5;
1180  v16i8 src6, src7, src8, src9, src10;
1181  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
1182  v16i8 src11, src12, src13, src14;
1183  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1184  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1185  v16i8 src1110_r, src1211_r, src1312_r, src1413_r;
1186  v16i8 src2110, src4332, src6554, src8776, src10998;
1187  v16i8 src12111110, src14131312;
1188  v8i16 dst10, dst32, dst54, dst76;
1189  v8i16 filt0, filt1, filt2, filt3;
1190  v8i16 filter_vec, const_vec;
1191 
1192  src0_ptr -= (3 * src_stride);
1193 
1194  const_vec = __msa_ldi_h(128);
1195  const_vec <<= 6;
1196 
1197  filter_vec = LD_SH(filter);
1198  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1199 
1200  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1201  src0_ptr += (7 * src_stride);
1202  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1203  src10_r, src32_r, src54_r, src21_r);
1204  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1205  ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
1206  src2110, src4332, src6554);
1207  XORI_B3_128_SB(src2110, src4332, src6554);
1208 
1209  for (loop_cnt = (height >> 3); loop_cnt--;) {
1210  LD_SB8(src0_ptr, src_stride,
1211  src7, src8, src9, src10, src11, src12, src13, src14);
1212  src0_ptr += (8 * src_stride);
1213  LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
1214  src1_ptr += (8 * src2_stride);
1215 
1216  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
1217  ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
1218  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1219  src76_r, src87_r, src98_r, src109_r);
1220  ILVR_B4_SB(src11, src10, src12, src11, src13, src12, src14, src13,
1221  src1110_r, src1211_r, src1312_r, src1413_r);
1222  ILVR_D4_SB(src87_r, src76_r, src109_r, src98_r, src1211_r, src1110_r,
1223  src1413_r, src1312_r,
1224  src8776, src10998, src12111110, src14131312);
1225  XORI_B4_128_SB(src8776, src10998, src12111110, src14131312);
1226 
1227  dst10 = const_vec;
1228  DPADD_SB4_SH(src2110, src4332, src6554, src8776,
1229  filt0, filt1, filt2, filt3, dst10, dst10, dst10, dst10);
1230  dst32 = const_vec;
1231  DPADD_SB4_SH(src4332, src6554, src8776, src10998,
1232  filt0, filt1, filt2, filt3, dst32, dst32, dst32, dst32);
1233  dst54 = const_vec;
1234  DPADD_SB4_SH(src6554, src8776, src10998, src12111110,
1235  filt0, filt1, filt2, filt3, dst54, dst54, dst54, dst54);
1236  dst76 = const_vec;
1237  DPADD_SB4_SH(src8776, src10998, src12111110, src14131312,
1238  filt0, filt1, filt2, filt3, dst76, dst76, dst76, dst76);
1239 
1240  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1241  dst10, dst32, dst54, dst76, 7,
1242  dst10, dst32, dst54, dst76);
1243 
1244  PCKEV_B2_SH(dst32, dst10, dst76, dst54, dst10, dst54);
1245  ST4x8_UB(dst10, dst54, dst, dst_stride);
1246  dst += (8 * dst_stride);
1247 
1248  src2110 = src10998;
1249  src4332 = src12111110;
1250  src6554 = src14131312;
1251  src6 = src14;
1252  }
1253 }
1254 
1255 static void hevc_vt_bi_8t_8w_msa(uint8_t *src0_ptr,
1256  int32_t src_stride,
1257  int16_t *src1_ptr,
1258  int32_t src2_stride,
1259  uint8_t *dst,
1260  int32_t dst_stride,
1261  const int8_t *filter,
1262  int32_t height)
1263 {
1264  int32_t loop_cnt;
1265  v16i8 src0, src1, src2, src3, src4, src5;
1266  v16i8 src6, src7, src8, src9, src10;
1267  v8i16 in0, in1, in2, in3;
1268  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1269  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1270  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
1271  v8i16 filt0, filt1, filt2, filt3;
1272  v8i16 filter_vec, const_vec;
1273 
1274  src0_ptr -= (3 * src_stride);
1275  const_vec = __msa_ldi_h(128);
1276  const_vec <<= 6;
1277 
1278  filter_vec = LD_SH(filter);
1279  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1280 
1281  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1282  src0_ptr += (7 * src_stride);
1283  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1284  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1285  src10_r, src32_r, src54_r, src21_r);
1286  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1287 
1288  for (loop_cnt = (height >> 2); loop_cnt--;) {
1289  LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
1290  src0_ptr += (4 * src_stride);
1291  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1292  src1_ptr += (4 * src2_stride);
1293  XORI_B4_128_SB(src7, src8, src9, src10);
1294  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1295  src76_r, src87_r, src98_r, src109_r);
1296 
1297  dst0_r = const_vec;
1298  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1299  filt0, filt1, filt2, filt3,
1300  dst0_r, dst0_r, dst0_r, dst0_r);
1301  dst1_r = const_vec;
1302  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1303  filt0, filt1, filt2, filt3,
1304  dst1_r, dst1_r, dst1_r, dst1_r);
1305  dst2_r = const_vec;
1306  DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1307  filt0, filt1, filt2, filt3,
1308  dst2_r, dst2_r, dst2_r, dst2_r);
1309  dst3_r = const_vec;
1310  DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1311  filt0, filt1, filt2, filt3,
1312  dst3_r, dst3_r, dst3_r, dst3_r);
1313 
1314  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1315  dst0_r, dst1_r, dst2_r, dst3_r, 7,
1316  dst0_r, dst1_r, dst2_r, dst3_r);
1317 
1318  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
1319  ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
1320  dst += (4 * dst_stride);
1321 
1322  src10_r = src54_r;
1323  src32_r = src76_r;
1324  src54_r = src98_r;
1325  src21_r = src65_r;
1326  src43_r = src87_r;
1327  src65_r = src109_r;
1328 
1329  src6 = src10;
1330  }
1331 }
1332 
1333 static void hevc_vt_bi_8t_12w_msa(uint8_t *src0_ptr,
1334  int32_t src_stride,
1335  int16_t *src1_ptr,
1336  int32_t src2_stride,
1337  uint8_t *dst,
1338  int32_t dst_stride,
1339  const int8_t *filter,
1340  int32_t height)
1341 {
1342  int32_t loop_cnt;
1343  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1344  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
1345  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1346  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1347  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
1348  v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
1349  v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
1350  v16i8 src2110, src4332, src6554, src8776, src10998;
1351  v8i16 dst0_l, dst1_l;
1352  v8i16 filt0, filt1, filt2, filt3;
1353  v8i16 filter_vec, const_vec;
1354 
1355  src0_ptr -= (3 * src_stride);
1356  const_vec = __msa_ldi_h(128);
1357  const_vec <<= 6;
1358 
1359  filter_vec = LD_SH(filter);
1360  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1361 
1362  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1363  src0_ptr += (7 * src_stride);
1364  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1365 
1366  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1367  src10_r, src32_r, src54_r, src21_r);
1368  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1369  ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1370  src10_l, src32_l, src54_l, src21_l);
1371  ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1372  ILVR_D3_SB(src21_l, src10_l, src43_l, src32_l, src65_l, src54_l,
1373  src2110, src4332, src6554);
1374 
1375  for (loop_cnt = (height >> 2); loop_cnt--;) {
1376  LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
1377  src0_ptr += (4 * src_stride);
1378  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
1379  LD_SH4((src1_ptr + 8), src2_stride, in4, in5, in6, in7);
1380  src1_ptr += (4 * src2_stride);
1381 
1382  ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
1383  XORI_B4_128_SB(src7, src8, src9, src10);
1384  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1385  src76_r, src87_r, src98_r, src109_r);
1386  ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1387  src76_l, src87_l, src98_l, src109_l);
1388  ILVR_D2_SB(src87_l, src76_l, src109_l, src98_l, src8776, src10998);
1389 
1390  dst0_r = const_vec;
1391  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1392  filt0, filt1, filt2, filt3,
1393  dst0_r, dst0_r, dst0_r, dst0_r);
1394  dst1_r = const_vec;
1395  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1396  filt0, filt1, filt2, filt3,
1397  dst1_r, dst1_r, dst1_r, dst1_r);
1398  dst2_r = const_vec;
1399  DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1400  filt0, filt1, filt2, filt3,
1401  dst2_r, dst2_r, dst2_r, dst2_r);
1402  dst3_r = const_vec;
1403  DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1404  filt0, filt1, filt2, filt3,
1405  dst3_r, dst3_r, dst3_r, dst3_r);
1406  dst0_l = const_vec;
1407  DPADD_SB4_SH(src2110, src4332, src6554, src8776,
1408  filt0, filt1, filt2, filt3,
1409  dst0_l, dst0_l, dst0_l, dst0_l);
1410  dst1_l = const_vec;
1411  DPADD_SB4_SH(src4332, src6554, src8776, src10998,
1412  filt0, filt1, filt2, filt3,
1413  dst1_l, dst1_l, dst1_l, dst1_l);
1414 
1415  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1416  dst0_r, dst1_r, dst2_r, dst3_r, 7,
1417  dst0_r, dst1_r, dst2_r, dst3_r);
1418  HEVC_BI_RND_CLIP2(in4, in5, dst0_l, dst1_l, 7, dst0_l, dst1_l);
1419 
1420 
1421  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
1422  dst0_l = (v8i16) __msa_pckev_b((v16i8) dst1_l, (v16i8) dst0_l);
1423  ST12x4_UB(dst0_r, dst1_r, dst0_l, dst, dst_stride);
1424  dst += (4 * dst_stride);
1425 
1426  src10_r = src54_r;
1427  src32_r = src76_r;
1428  src54_r = src98_r;
1429  src21_r = src65_r;
1430  src43_r = src87_r;
1431  src65_r = src109_r;
1432  src2110 = src6554;
1433  src4332 = src8776;
1434  src6554 = src10998;
1435  src6 = src10;
1436  }
1437 }
1438 
1439 static void hevc_vt_bi_8t_16multx2mult_msa(uint8_t *src0_ptr,
1440  int32_t src_stride,
1441  int16_t *src1_ptr,
1442  int32_t src2_stride,
1443  uint8_t *dst,
1444  int32_t dst_stride,
1445  const int8_t *filter,
1446  int32_t height, int32_t width)
1447 {
1448  uint8_t *src0_ptr_tmp;
1449  int16_t *src1_ptr_tmp;
1450  uint8_t *dst_tmp;
1451  uint32_t loop_cnt;
1452  uint32_t cnt;
1453  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1454  v8i16 in0, in1, in2, in3;
1455  v16i8 src10_r, src32_r, src54_r, src76_r;
1456  v16i8 src21_r, src43_r, src65_r, src87_r;
1457  v8i16 dst0_r, dst1_r;
1458  v16i8 src10_l, src32_l, src54_l, src76_l;
1459  v16i8 src21_l, src43_l, src65_l, src87_l;
1460  v8i16 dst0_l, dst1_l;
1461  v8i16 filt0, filt1, filt2, filt3;
1462  v8i16 filter_vec, const_vec;
1463 
1464  src0_ptr -= (3 * src_stride);
1465  const_vec = __msa_ldi_h(128);
1466  const_vec <<= 6;
1467 
1468  filter_vec = LD_SH(filter);
1469  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1470 
1471  for (cnt = (width >> 4); cnt--;) {
1472  src0_ptr_tmp = src0_ptr;
1473  src1_ptr_tmp = src1_ptr;
1474  dst_tmp = dst;
1475 
1476  LD_SB7(src0_ptr_tmp, src_stride,
1477  src0, src1, src2, src3, src4, src5, src6);
1478  src0_ptr_tmp += (7 * src_stride);
1479  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1480 
1481  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1482  src10_r, src32_r, src54_r, src21_r);
1483  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1484  ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1485  src10_l, src32_l, src54_l, src21_l);
1486  ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1487 
1488  for (loop_cnt = (height >> 1); loop_cnt--;) {
1489  LD_SB2(src0_ptr_tmp, src_stride, src7, src8);
1490  src0_ptr_tmp += (2 * src_stride);
1491  LD_SH2(src1_ptr_tmp, src2_stride, in0, in1);
1492  LD_SH2((src1_ptr_tmp + 8), src2_stride, in2, in3);
1493  src1_ptr_tmp += (2 * src2_stride);
1494  XORI_B2_128_SB(src7, src8);
1495 
1496  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
1497  ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
1498 
1499  dst0_r = const_vec;
1500  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1501  filt0, filt1, filt2, filt3,
1502  dst0_r, dst0_r, dst0_r, dst0_r);
1503  dst1_r = const_vec;
1504  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1505  filt0, filt1, filt2, filt3,
1506  dst1_r, dst1_r, dst1_r, dst1_r);
1507  dst0_l = const_vec;
1508  DPADD_SB4_SH(src10_l, src32_l, src54_l, src76_l,
1509  filt0, filt1, filt2, filt3,
1510  dst0_l, dst0_l, dst0_l, dst0_l);
1511  dst1_l = const_vec;
1512  DPADD_SB4_SH(src21_l, src43_l, src65_l, src87_l,
1513  filt0, filt1, filt2, filt3,
1514  dst1_l, dst1_l, dst1_l, dst1_l);
1515 
1516  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
1517  dst0_r, dst1_r, dst0_l, dst1_l, 7,
1518  dst0_r, dst1_r, dst0_l, dst1_l);
1519 
1520  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
1521  ST_SH2(dst0_r, dst1_r, dst_tmp, dst_stride);
1522  dst_tmp += (2 * dst_stride);
1523 
1524  src10_r = src32_r;
1525  src32_r = src54_r;
1526  src54_r = src76_r;
1527  src21_r = src43_r;
1528  src43_r = src65_r;
1529  src65_r = src87_r;
1530  src10_l = src32_l;
1531  src32_l = src54_l;
1532  src54_l = src76_l;
1533  src21_l = src43_l;
1534  src43_l = src65_l;
1535  src65_l = src87_l;
1536  src6 = src8;
1537  }
1538 
1539  src0_ptr += 16;
1540  src1_ptr += 16;
1541  dst += 16;
1542  }
1543 }
1544 
1545 static void hevc_vt_bi_8t_16w_msa(uint8_t *src0_ptr,
1546  int32_t src_stride,
1547  int16_t *src1_ptr,
1548  int32_t src2_stride,
1549  uint8_t *dst,
1550  int32_t dst_stride,
1551  const int8_t *filter,
1552  int32_t height)
1553 {
1554  hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1555  dst, dst_stride, filter, height, 16);
1556 }
1557 
1558 static void hevc_vt_bi_8t_24w_msa(uint8_t *src0_ptr,
1559  int32_t src_stride,
1560  int16_t *src1_ptr,
1561  int32_t src2_stride,
1562  uint8_t *dst,
1563  int32_t dst_stride,
1564  const int8_t *filter,
1565  int32_t height)
1566 {
1567  hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1568  dst, dst_stride, filter, height, 16);
1569  hevc_vt_bi_8t_8w_msa(src0_ptr + 16, src_stride, src1_ptr + 16, src2_stride,
1570  dst + 16, dst_stride, filter, height);
1571 }
1572 
1573 static void hevc_vt_bi_8t_32w_msa(uint8_t *src0_ptr,
1574  int32_t src_stride,
1575  int16_t *src1_ptr,
1576  int32_t src2_stride,
1577  uint8_t *dst,
1578  int32_t dst_stride,
1579  const int8_t *filter,
1580  int32_t height)
1581 {
1582  hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1583  dst, dst_stride, filter, height, 32);
1584 }
1585 
1586 static void hevc_vt_bi_8t_48w_msa(uint8_t *src0_ptr,
1587  int32_t src_stride,
1588  int16_t *src1_ptr,
1589  int32_t src2_stride,
1590  uint8_t *dst,
1591  int32_t dst_stride,
1592  const int8_t *filter,
1593  int32_t height)
1594 {
1595  hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1596  dst, dst_stride, filter, height, 48);
1597 }
1598 
1599 static void hevc_vt_bi_8t_64w_msa(uint8_t *src0_ptr,
1600  int32_t src_stride,
1601  int16_t *src1_ptr,
1602  int32_t src2_stride,
1603  uint8_t *dst,
1604  int32_t dst_stride,
1605  const int8_t *filter,
1606  int32_t height)
1607 {
1608  hevc_vt_bi_8t_16multx2mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1609  dst, dst_stride, filter, height, 64);
1610 }
1611 
1612 static void hevc_hv_bi_8t_4w_msa(uint8_t *src0_ptr,
1613  int32_t src_stride,
1614  int16_t *src1_ptr,
1615  int32_t src2_stride,
1616  uint8_t *dst,
1617  int32_t dst_stride,
1618  const int8_t *filter_x,
1619  const int8_t *filter_y,
1620  int32_t height)
1621 {
1622  uint32_t loop_cnt;
1623  uint64_t tp0, tp1;
1624  v16u8 out;
1625  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1626  v8i16 in0 = { 0 }, in1 = { 0 };
1627  v8i16 filt0, filt1, filt2, filt3;
1628  v8i16 filt_h0, filt_h1, filt_h2, filt_h3;
1629  v16i8 mask1, mask2, mask3;
1630  v8i16 filter_vec, const_vec;
1631  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1632  v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1633  v8i16 out0, out1;
1634  v8i16 dst30, dst41, dst52, dst63, dst66, dst97, dst108;
1635  v8i16 dst10, dst32, dst54, dst76, dst98, dst21, dst43, dst65, dst87, dst109;
1636  v4i32 dst0, dst1, dst2, dst3;
1637  v16i8 mask0 = LD_SB(ff_hevc_mask_arr + 16);
1638 
1639  src0_ptr -= ((3 * src_stride) + 3);
1640  filter_vec = LD_SH(filter_x);
1641  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1642 
1643  filter_vec = LD_SH(filter_y);
1644  UNPCK_R_SB_SH(filter_vec, filter_vec);
1645 
1646  SPLATI_W4_SH(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1647 
1648  mask1 = mask0 + 2;
1649  mask2 = mask0 + 4;
1650  mask3 = mask0 + 6;
1651 
1652  const_vec = __msa_ldi_h(128);
1653  const_vec <<= 6;
1654 
1655  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
1656  src0_ptr += (7 * src_stride);
1657  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1658 
1659  /* row 0 row 1 row 2 row 3 */
1660  VSHF_B4_SB(src0, src3, mask0, mask1, mask2, mask3, vec0, vec1, vec2, vec3);
1661  VSHF_B4_SB(src1, src4, mask0, mask1, mask2, mask3, vec4, vec5, vec6, vec7);
1662  VSHF_B4_SB(src2, src5, mask0, mask1, mask2, mask3,
1663  vec8, vec9, vec10, vec11);
1664  VSHF_B4_SB(src3, src6, mask0, mask1, mask2, mask3,
1665  vec12, vec13, vec14, vec15);
1666 
1667  dst30 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1668  filt3);
1669  dst41 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1670  filt3);
1671  dst52 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
1672  filt3);
1673  dst63 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2,
1674  filt3);
1675 
1676  ILVRL_H2_SH(dst41, dst30, dst10, dst43);
1677  ILVRL_H2_SH(dst52, dst41, dst21, dst54);
1678  ILVRL_H2_SH(dst63, dst52, dst32, dst65);
1679 
1680  dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
1681 
1682  for (loop_cnt = height >> 2; loop_cnt--;) {
1683  LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
1684  src0_ptr += (4 * src_stride);
1685  XORI_B4_128_SB(src7, src8, src9, src10);
1686 
1687  LD2(src1_ptr, src2_stride, tp0, tp1);
1688  INSERT_D2_SH(tp0, tp1, in0);
1689  src1_ptr += (2 * src2_stride);
1690  LD2(src1_ptr, src2_stride, tp0, tp1);
1691  INSERT_D2_SH(tp0, tp1, in1);
1692  src1_ptr += (2 * src2_stride);
1693 
1694  VSHF_B4_SB(src7, src9, mask0, mask1, mask2, mask3,
1695  vec0, vec1, vec2, vec3);
1696  VSHF_B4_SB(src8, src10, mask0, mask1, mask2, mask3,
1697  vec4, vec5, vec6, vec7);
1698  dst97 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1699  filt3);
1700  dst108 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1701  filt3);
1702 
1703  dst76 = __msa_ilvr_h(dst97, dst66);
1704  ILVRL_H2_SH(dst108, dst97, dst87, dst109);
1705  dst66 = (v8i16) __msa_splati_d((v2i64) dst97, 1);
1706  dst98 = __msa_ilvr_h(dst66, dst108);
1707 
1708  dst0 = HEVC_FILT_8TAP(dst10, dst32, dst54, dst76, filt_h0, filt_h1,
1709  filt_h2, filt_h3);
1710  dst1 = HEVC_FILT_8TAP(dst21, dst43, dst65, dst87, filt_h0, filt_h1,
1711  filt_h2, filt_h3);
1712  dst2 = HEVC_FILT_8TAP(dst32, dst54, dst76, dst98, filt_h0, filt_h1,
1713  filt_h2, filt_h3);
1714  dst3 = HEVC_FILT_8TAP(dst43, dst65, dst87, dst109, filt_h0, filt_h1,
1715  filt_h2, filt_h3);
1716 
1717  SRA_4V(dst0, dst1, dst2, dst3, 6);
1718  PCKEV_H2_SH(dst1, dst0, dst3, dst2, out0, out1);
1719  ADDS_SH2_SH(out0, in0, out1, in1, out0, out1);
1720  ADDS_SH2_SH(out0, const_vec, out1, const_vec, out0, out1);
1721  SRARI_H2_SH(out0, out1, 7);
1722  CLIP_SH2_0_255_MAX_SATU(out0, out1);
1723  out = (v16u8) __msa_pckev_b((v16i8) out1, (v16i8) out0);
1724  ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
1725  dst += (4 * dst_stride);
1726 
1727  dst10 = dst54;
1728  dst32 = dst76;
1729  dst54 = dst98;
1730  dst21 = dst65;
1731  dst43 = dst87;
1732  dst65 = dst109;
1733  dst66 = (v8i16) __msa_splati_d((v2i64) dst108, 1);
1734  }
1735 }
1736 
1737 static void hevc_hv_bi_8t_8multx1mult_msa(uint8_t *src0_ptr,
1738  int32_t src_stride,
1739  int16_t *src1_ptr,
1740  int32_t src2_stride,
1741  uint8_t *dst,
1742  int32_t dst_stride,
1743  const int8_t *filter_x,
1744  const int8_t *filter_y,
1745  int32_t height, int32_t width)
1746 {
1747  uint32_t loop_cnt;
1748  uint32_t cnt;
1749  uint8_t *src0_ptr_tmp;
1750  int16_t *src1_ptr_tmp;
1751  uint8_t *dst_tmp;
1752  v16u8 out;
1753  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
1754  v8i16 in0, tmp;
1755  v8i16 filt0, filt1, filt2, filt3;
1756  v8i16 filt_h0, filt_h1, filt_h2, filt_h3;
1757  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
1758  v16i8 mask1, mask2, mask3;
1759  v8i16 filter_vec, const_vec;
1760  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1761  v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1762  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1763  v4i32 dst0_r, dst0_l;
1764  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1765  v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
1766 
1767  src0_ptr -= ((3 * src_stride) + 3);
1768  const_vec = __msa_ldi_h(128);
1769  const_vec <<= 6;
1770 
1771  filter_vec = LD_SH(filter_x);
1772  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1773 
1774  filter_vec = LD_SH(filter_y);
1775  UNPCK_R_SB_SH(filter_vec, filter_vec);
1776 
1777  SPLATI_W4_SH(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1778 
1779  mask1 = mask0 + 2;
1780  mask2 = mask0 + 4;
1781  mask3 = mask0 + 6;
1782 
1783  for (cnt = width >> 3; cnt--;) {
1784  src0_ptr_tmp = src0_ptr;
1785  dst_tmp = dst;
1786  src1_ptr_tmp = src1_ptr;
1787 
1788  LD_SB7(src0_ptr_tmp, src_stride,
1789  src0, src1, src2, src3, src4, src5, src6);
1790  src0_ptr_tmp += (7 * src_stride);
1791  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1792 
1793  /* row 0 row 1 row 2 row 3 */
1794  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
1795  vec0, vec1, vec2, vec3);
1796  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
1797  vec4, vec5, vec6, vec7);
1798  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
1799  vec8, vec9, vec10, vec11);
1800  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
1801  vec12, vec13, vec14, vec15);
1802  dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1803  filt3);
1804  dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1805  filt3);
1806  dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
1807  filt3);
1808  dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
1809  filt2, filt3);
1810 
1811  VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
1812  vec0, vec1, vec2, vec3);
1813  VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
1814  vec4, vec5, vec6, vec7);
1815  VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
1816  vec8, vec9, vec10, vec11);
1817  dst4 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1818  filt3);
1819  dst5 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1820  filt3);
1821  dst6 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
1822  filt3);
1823 
1824  for (loop_cnt = height; loop_cnt--;) {
1825  src7 = LD_SB(src0_ptr_tmp);
1826  src7 = (v16i8) __msa_xori_b((v16u8) src7, 128);
1827  src0_ptr_tmp += src_stride;
1828 
1829  in0 = LD_SH(src1_ptr_tmp);
1830  src1_ptr_tmp += src2_stride;
1831 
1832  VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
1833  vec0, vec1, vec2, vec3);
1834  dst7 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1,
1835  filt2, filt3);
1836  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
1837  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
1838  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
1839  ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
1840  dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
1841  filt_h0, filt_h1, filt_h2, filt_h3);
1842  dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l,
1843  filt_h0, filt_h1, filt_h2, filt_h3);
1844  dst0_r >>= 6;
1845  dst0_l >>= 6;
1846 
1847  tmp = __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
1848  ADDS_SH2_SH(tmp, in0, tmp, const_vec, tmp, tmp);
1849  tmp = __msa_srari_h(tmp, 7);
1850  tmp = CLIP_SH_0_255_MAX_SATU(tmp);
1851  out = (v16u8) __msa_pckev_b((v16i8) tmp, (v16i8) tmp);
1852  ST8x1_UB(out, dst_tmp);
1853  dst_tmp += dst_stride;
1854 
1855  dst0 = dst1;
1856  dst1 = dst2;
1857  dst2 = dst3;
1858  dst3 = dst4;
1859  dst4 = dst5;
1860  dst5 = dst6;
1861  dst6 = dst7;
1862  }
1863 
1864  src0_ptr += 8;
1865  dst += 8;
1866  src1_ptr += 8;
1867  }
1868 }
1869 
1870 static void hevc_hv_bi_8t_8w_msa(uint8_t *src0_ptr,
1871  int32_t src_stride,
1872  int16_t *src1_ptr,
1873  int32_t src2_stride,
1874  uint8_t *dst,
1875  int32_t dst_stride,
1876  const int8_t *filter_x,
1877  const int8_t *filter_y,
1878  int32_t height)
1879 {
1880  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
1881  dst, dst_stride, filter_x, filter_y,
1882  height, 8);
1883 }
1884 
1885 static void hevc_hv_bi_8t_12w_msa(uint8_t *src0_ptr,
1886  int32_t src_stride,
1887  int16_t *src1_ptr,
1888  int32_t src2_stride,
1889  uint8_t *dst,
1890  int32_t dst_stride,
1891  const int8_t *filter_x,
1892  const int8_t *filter_y,
1893  int32_t height)
1894 {
1895  uint32_t loop_cnt;
1896  uint8_t *src0_ptr_tmp, *dst_tmp;
1897  int16_t *src1_ptr_tmp;
1898  uint64_t tp0, tp1;
1899  v16u8 out;
1900  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1901  v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
1902  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1903  v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1904  v8i16 in0, in1 = { 0 }, out0, out1, tmp, filter_vec, const_vec;
1905  v8i16 filt0, filt1, filt2, filt3, filt_h0, filt_h1, filt_h2, filt_h3;
1906  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1907  v8i16 dst30, dst41, dst52, dst63, dst66, dst97, dst108;
1908  v8i16 dst10, dst32, dst54, dst76, dst98, dst21, dst43, dst65, dst87, dst109;
1909  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1910  v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
1911  v4i32 dst0_r, dst0_l, tmp0, tmp1, tmp2, tmp3;
1912 
1913  src0_ptr -= ((3 * src_stride) + 3);
1914 
1915  const_vec = __msa_ldi_h(128);
1916  const_vec <<= 6;
1917 
1918  filter_vec = LD_SH(filter_x);
1919  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1920 
1921  filter_vec = LD_SH(filter_y);
1922  UNPCK_R_SB_SH(filter_vec, filter_vec);
1923 
1924  SPLATI_W4_SH(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1925 
1926  mask0 = LD_SB(ff_hevc_mask_arr);
1927  mask1 = mask0 + 2;
1928  mask2 = mask0 + 4;
1929  mask3 = mask0 + 6;
1930 
1931  src0_ptr_tmp = src0_ptr;
1932  dst_tmp = dst;
1933  src1_ptr_tmp = src1_ptr;
1934 
1935  LD_SB7(src0_ptr_tmp, src_stride, src0, src1, src2, src3, src4, src5,
1936  src6);
1937  src0_ptr_tmp += (7 * src_stride);
1938  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1939 
1940  /* row 0 row 1 row 2 row 3 */
1941  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3, vec0, vec1, vec2,
1942  vec3);
1943  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3, vec4, vec5, vec6,
1944  vec7);
1945  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3, vec8, vec9, vec10,
1946  vec11);
1947  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3, vec12, vec13, vec14,
1948  vec15);
1949  dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1950  filt3);
1951  dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1952  filt3);
1953  dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
1954  filt3);
1955  dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
1956  filt2, filt3);
1957  VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3, vec0, vec1, vec2,
1958  vec3);
1959  VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3, vec4, vec5, vec6,
1960  vec7);
1961  VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3, vec8, vec9, vec10,
1962  vec11);
1963  dst4 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
1964  filt3);
1965  dst5 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
1966  filt3);
1967  dst6 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
1968  filt3);
1969 
1970  for (loop_cnt = 16; loop_cnt--;) {
1971  src7 = LD_SB(src0_ptr_tmp);
1972  src7 = (v16i8) __msa_xori_b((v16u8) src7, 128);
1973  src0_ptr_tmp += src_stride;
1974 
1975  in0 = LD_SH(src1_ptr_tmp);
1976  src1_ptr_tmp += src2_stride;
1977 
1978  VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3, vec0, vec1, vec2,
1979  vec3);
1980  dst7 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1,
1981  filt2, filt3);
1982  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
1983  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
1984  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
1985  ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
1986  dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r, filt_h0,
1987  filt_h1, filt_h2, filt_h3);
1988  dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l, filt_h0,
1989  filt_h1, filt_h2, filt_h3);
1990  dst0_r >>= 6;
1991  dst0_l >>= 6;
1992 
1993  tmp = __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
1994  ADDS_SH2_SH(tmp, in0, tmp, const_vec, tmp, tmp);
1995  tmp = __msa_srari_h(tmp, 7);
1996  tmp = CLIP_SH_0_255_MAX_SATU(tmp);
1997  out = (v16u8) __msa_pckev_b((v16i8) tmp, (v16i8) tmp);
1998  ST8x1_UB(out, dst_tmp);
1999  dst_tmp += dst_stride;
2000 
2001  dst0 = dst1;
2002  dst1 = dst2;
2003  dst2 = dst3;
2004  dst3 = dst4;
2005  dst4 = dst5;
2006  dst5 = dst6;
2007  dst6 = dst7;
2008  }
2009 
2010  src0_ptr += 8;
2011  dst += 8;
2012  src1_ptr += 8;
2013 
2014  mask4 = LD_SB(ff_hevc_mask_arr + 16);
2015  mask5 = mask4 + 2;
2016  mask6 = mask4 + 4;
2017  mask7 = mask4 + 6;
2018 
2019  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
2020  src0_ptr += (7 * src_stride);
2021  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
2022 
2023  /* row 0 row 1 row 2 row 3 */
2024  VSHF_B4_SB(src0, src3, mask4, mask5, mask6, mask7, vec0, vec1, vec2, vec3);
2025  VSHF_B4_SB(src1, src4, mask4, mask5, mask6, mask7, vec4, vec5, vec6, vec7);
2026  VSHF_B4_SB(src2, src5, mask4, mask5, mask6, mask7,
2027  vec8, vec9, vec10, vec11);
2028  VSHF_B4_SB(src3, src6, mask4, mask5, mask6, mask7,
2029  vec12, vec13, vec14, vec15);
2030  dst30 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
2031  filt3);
2032  dst41 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
2033  filt3);
2034  dst52 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
2035  filt3);
2036  dst63 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2,
2037  filt3);
2038 
2039  ILVRL_H2_SH(dst41, dst30, dst10, dst43);
2040  ILVRL_H2_SH(dst52, dst41, dst21, dst54);
2041  ILVRL_H2_SH(dst63, dst52, dst32, dst65);
2042 
2043  dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
2044 
2045  for (loop_cnt = 4; loop_cnt--;) {
2046  LD_SB4(src0_ptr, src_stride, src7, src8, src9, src10);
2047  src0_ptr += (4 * src_stride);
2048  XORI_B4_128_SB(src7, src8, src9, src10);
2049 
2050  LD2(src1_ptr, src2_stride, tp0, tp1);
2051  INSERT_D2_SH(tp0, tp1, in0);
2052  src1_ptr += (2 * src2_stride);
2053  LD2(src1_ptr, src2_stride, tp0, tp1);
2054  INSERT_D2_SH(tp0, tp1, in1);
2055  src1_ptr += (2 * src2_stride);
2056 
2057  VSHF_B4_SB(src7, src9, mask4, mask5, mask6, mask7, vec0, vec1, vec2,
2058  vec3);
2059  VSHF_B4_SB(src8, src10, mask4, mask5, mask6, mask7, vec4, vec5, vec6,
2060  vec7);
2061  dst97 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
2062  filt3);
2063  dst108 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
2064  filt3);
2065 
2066  dst76 = __msa_ilvr_h(dst97, dst66);
2067  ILVRL_H2_SH(dst108, dst97, dst87, dst109);
2068  dst66 = (v8i16) __msa_splati_d((v2i64) dst97, 1);
2069  dst98 = __msa_ilvr_h(dst66, dst108);
2070 
2071  tmp0 = HEVC_FILT_8TAP(dst10, dst32, dst54, dst76, filt_h0, filt_h1,
2072  filt_h2, filt_h3);
2073  tmp1 = HEVC_FILT_8TAP(dst21, dst43, dst65, dst87, filt_h0, filt_h1,
2074  filt_h2, filt_h3);
2075  tmp2 = HEVC_FILT_8TAP(dst32, dst54, dst76, dst98, filt_h0, filt_h1,
2076  filt_h2, filt_h3);
2077  tmp3 = HEVC_FILT_8TAP(dst43, dst65, dst87, dst109, filt_h0, filt_h1,
2078  filt_h2, filt_h3);
2079  SRA_4V(tmp0, tmp1, tmp2, tmp3, 6);
2080  PCKEV_H2_SH(tmp1, tmp0, tmp3, tmp2, out0, out1);
2081  ADDS_SH2_SH(out0, in0, out1, in1, out0, out1);
2082  ADDS_SH2_SH(out0, const_vec, out1, const_vec, out0, out1);
2083  SRARI_H2_SH(out0, out1, 7);
2084  CLIP_SH2_0_255_MAX_SATU(out0, out1);
2085  out = (v16u8) __msa_pckev_b((v16i8) out1, (v16i8) out0);
2086  ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
2087  dst += (4 * dst_stride);
2088 
2089  dst10 = dst54;
2090  dst32 = dst76;
2091  dst54 = dst98;
2092  dst21 = dst65;
2093  dst43 = dst87;
2094  dst65 = dst109;
2095  dst66 = (v8i16) __msa_splati_d((v2i64) dst108, 1);
2096  }
2097 }
2098 
2099 static void hevc_hv_bi_8t_16w_msa(uint8_t *src0_ptr,
2100  int32_t src_stride,
2101  int16_t *src1_ptr,
2102  int32_t src2_stride,
2103  uint8_t *dst,
2104  int32_t dst_stride,
2105  const int8_t *filter_x,
2106  const int8_t *filter_y,
2107  int32_t height)
2108 {
2109  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2110  dst, dst_stride, filter_x, filter_y,
2111  height, 16);
2112 }
2113 
2114 static void hevc_hv_bi_8t_24w_msa(uint8_t *src0_ptr,
2115  int32_t src_stride,
2116  int16_t *src1_ptr,
2117  int32_t src2_stride,
2118  uint8_t *dst,
2119  int32_t dst_stride,
2120  const int8_t *filter_x,
2121  const int8_t *filter_y,
2122  int32_t height)
2123 {
2124  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2125  dst, dst_stride, filter_x, filter_y,
2126  height, 24);
2127 }
2128 
2129 static void hevc_hv_bi_8t_32w_msa(uint8_t *src0_ptr,
2130  int32_t src_stride,
2131  int16_t *src1_ptr,
2132  int32_t src2_stride,
2133  uint8_t *dst,
2134  int32_t dst_stride,
2135  const int8_t *filter_x,
2136  const int8_t *filter_y,
2137  int32_t height)
2138 {
2139  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2140  dst, dst_stride, filter_x, filter_y,
2141  height, 32);
2142 }
2143 
2144 static void hevc_hv_bi_8t_48w_msa(uint8_t *src0_ptr,
2145  int32_t src_stride,
2146  int16_t *src1_ptr,
2147  int32_t src2_stride,
2148  uint8_t *dst,
2149  int32_t dst_stride,
2150  const int8_t *filter_x,
2151  const int8_t *filter_y,
2152  int32_t height)
2153 {
2154  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2155  dst, dst_stride, filter_x, filter_y,
2156  height, 48);
2157 }
2158 
2159 static void hevc_hv_bi_8t_64w_msa(uint8_t *src0_ptr,
2160  int32_t src_stride,
2161  int16_t *src1_ptr,
2162  int32_t src2_stride,
2163  uint8_t *dst,
2164  int32_t dst_stride,
2165  const int8_t *filter_x,
2166  const int8_t *filter_y,
2167  int32_t height)
2168 {
2169  hevc_hv_bi_8t_8multx1mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2170  dst, dst_stride, filter_x, filter_y,
2171  height, 64);
2172 }
2173 
2174 static void hevc_hz_bi_4t_4x2_msa(uint8_t *src0_ptr,
2175  int32_t src_stride,
2176  int16_t *src1_ptr,
2177  int32_t src2_stride,
2178  uint8_t *dst,
2179  int32_t dst_stride,
2180  const int8_t *filter,
2181  int32_t height)
2182 {
2183  v8i16 filt0, filt1;
2184  v16i8 src0, src1, dst0, vec0, vec1;
2185  v8i16 in0, in1;
2186  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[16]);
2187  v16i8 mask1;
2188  v8i16 tmp0;
2189  v8i16 filter_vec, const_vec;
2190 
2191  src0_ptr -= 1;
2192 
2193  const_vec = __msa_ldi_h(128);
2194  const_vec <<= 6;
2195 
2196  filter_vec = LD_SH(filter);
2197  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2198 
2199  mask1 = mask0 + 2;
2200 
2201  LD_SB2(src0_ptr, src_stride, src0, src1);
2202  LD_SH2(src1_ptr, src2_stride, in0, in1);
2203  in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
2204  XORI_B2_128_SB(src0, src1);
2205  VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
2206  tmp0 = const_vec;
2207  DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
2208 
2209  tmp0 = __msa_adds_s_h(tmp0, in0);
2210  tmp0 = __msa_srari_h(tmp0, 7);
2211  tmp0 = CLIP_SH_0_255(tmp0);
2212  dst0 = __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
2213 
2214  ST4x2_UB(dst0, dst, dst_stride);
2215 }
2216 
2217 static void hevc_hz_bi_4t_4x4_msa(uint8_t *src0_ptr,
2218  int32_t src_stride,
2219  int16_t *src1_ptr,
2220  int32_t src2_stride,
2221  uint8_t *dst,
2222  int32_t dst_stride,
2223  const int8_t *filter,
2224  int32_t height)
2225 {
2226  v8i16 filt0, filt1;
2227  v16i8 src0, src1, src2, src3, dst0, vec0, vec1;
2228  v8i16 in0, in1, in2, in3;
2229  v16i8 vec2, vec3;
2230  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[16]);
2231  v16i8 mask1;
2232  v8i16 tmp0, tmp1;
2233  v8i16 filter_vec, const_vec;
2234 
2235  src0_ptr -= 1;
2236 
2237  const_vec = __msa_ldi_h(128);
2238  const_vec <<= 6;
2239 
2240  filter_vec = LD_SH(filter);
2241  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2242 
2243  mask1 = mask0 + 2;
2244 
2245  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2246  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2247 
2248  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2249  XORI_B4_128_SB(src0, src1, src2, src3);
2250 
2251  tmp0 = const_vec;
2252  tmp1 = const_vec;
2253  VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
2254  VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
2255  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt1, filt1, tmp0, tmp1,
2256  tmp0, tmp1);
2257  HEVC_BI_RND_CLIP2(in0, in1, tmp0, tmp1, 7, tmp0, tmp1);
2258  dst0 = __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
2259 
2260  ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
2261 }
2262 
2263 static void hevc_hz_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
2264  int32_t src_stride,
2265  int16_t *src1_ptr,
2266  int32_t src2_stride,
2267  uint8_t *dst,
2268  int32_t dst_stride,
2269  const int8_t *filter,
2270  int32_t height)
2271 {
2272  uint32_t loop_cnt;
2273  v8i16 filt0, filt1;
2274  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2275  v16i8 dst0, dst1;
2276  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2277  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[16]);
2278  v16i8 mask1, vec0, vec1, vec2, vec3;
2279  v8i16 tmp0, tmp1, tmp2, tmp3;
2280  v8i16 filter_vec, const_vec;
2281 
2282  src0_ptr -= 1;
2283 
2284  const_vec = __msa_ldi_h(128);
2285  const_vec <<= 6;
2286 
2287  filter_vec = LD_SH(filter);
2288  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2289 
2290  mask1 = mask0 + 2;
2291 
2292  for (loop_cnt = (height >> 3); loop_cnt--;) {
2293  LD_SB8(src0_ptr, src_stride,
2294  src0, src1, src2, src3, src4, src5, src6, src7);
2295  src0_ptr += (8 * src_stride);
2296  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2297  src1_ptr += (4 * src2_stride);
2298  LD_SH4(src1_ptr, src2_stride, in4, in5, in6, in7);
2299  src1_ptr += (4 * src2_stride);
2300  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2301  ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
2302  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2303 
2304  tmp0 = const_vec;
2305  tmp1 = const_vec;
2306  tmp2 = const_vec;
2307  tmp3 = const_vec;
2308  VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
2309  VSHF_B2_SB(src4, src5, src6, src7, mask0, mask0, vec2, vec3);
2310  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, tmp0,
2311  tmp1, tmp2, tmp3);
2312  VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec0, vec1);
2313  VSHF_B2_SB(src4, src5, src6, src7, mask1, mask1, vec2, vec3);
2314  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, tmp0,
2315  tmp1, tmp2, tmp3);
2316 
2317  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2318  tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
2319 
2320  PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
2321  ST4x8_UB(dst0, dst1, dst, dst_stride);
2322  dst += (8 * dst_stride);
2323  }
2324 }
2325 
2326 static void hevc_hz_bi_4t_4w_msa(uint8_t *src0_ptr,
2327  int32_t src_stride,
2328  int16_t *src1_ptr,
2329  int32_t src2_stride,
2330  uint8_t *dst,
2331  int32_t dst_stride,
2332  const int8_t *filter,
2333  int32_t height)
2334 {
2335  if (2 == height) {
2336  hevc_hz_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2337  dst, dst_stride, filter, height);
2338  } else if (4 == height) {
2339  hevc_hz_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2340  dst, dst_stride, filter, height);
2341  } else if (8 == height || 16 == height) {
2342  hevc_hz_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
2343  src1_ptr, src2_stride,
2344  dst, dst_stride, filter, height);
2345  }
2346 }
2347 
2348 static void hevc_hz_bi_4t_6w_msa(uint8_t *src0_ptr,
2349  int32_t src_stride,
2350  int16_t *src1_ptr,
2351  int32_t src2_stride,
2352  uint8_t *dst,
2353  int32_t dst_stride,
2354  const int8_t *filter,
2355  int32_t height)
2356 {
2357  uint32_t loop_cnt;
2358  v8i16 filt0, filt1;
2359  v16i8 src0, src1, src2, src3;
2360  v8i16 in0, in1, in2, in3;
2361  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2362  v16i8 mask1;
2363  v16i8 vec0, vec1, vec2, vec3;
2364  v8i16 dst0, dst1, dst2, dst3;
2365  v8i16 filter_vec, const_vec;
2366 
2367  src0_ptr -= 1;
2368 
2369  const_vec = __msa_ldi_h(128);
2370  const_vec <<= 6;
2371 
2372  filter_vec = LD_SH(filter);
2373  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2374 
2375  mask1 = mask0 + 2;
2376 
2377  for (loop_cnt = (height >> 2); loop_cnt--;) {
2378  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2379  src0_ptr += (4 * src_stride);
2380  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2381  src1_ptr += (4 * src2_stride);
2382  XORI_B4_128_SB(src0, src1, src2, src3);
2383 
2384  dst0 = const_vec;
2385  dst1 = const_vec;
2386  dst2 = const_vec;
2387  dst3 = const_vec;
2388  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2389  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
2390  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2391  dst1, dst2, dst3);
2392  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
2393  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
2394  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2395  dst1, dst2, dst3);
2396 
2397  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2398  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2399 
2400  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2401  ST6x4_UB(dst0, dst1, dst, dst_stride);
2402  dst += (4 * dst_stride);
2403  }
2404 }
2405 
2406 static void hevc_hz_bi_4t_8x2_msa(uint8_t *src0_ptr,
2407  int32_t src_stride,
2408  int16_t *src1_ptr,
2409  int32_t src2_stride,
2410  uint8_t *dst,
2411  int32_t dst_stride,
2412  const int8_t *filter,
2413  int32_t height)
2414 {
2415  v8i16 filt0, filt1;
2416  v16i8 src0, src1;
2417  v8i16 in0, in1;
2418  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2419  v16i8 mask1, vec0, vec1, vec2, vec3;
2420  v8i16 dst0, dst1;
2421  v8i16 filter_vec, const_vec;
2422 
2423  src0_ptr -= 1;
2424 
2425  const_vec = __msa_ldi_h(128);
2426  const_vec <<= 6;
2427 
2428  filter_vec = LD_SH(filter);
2429  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2430 
2431  mask1 = mask0 + 2;
2432 
2433  LD_SB2(src0_ptr, src_stride, src0, src1);
2434  LD_SH2(src1_ptr, src2_stride, in0, in1);
2435  XORI_B2_128_SB(src0, src1);
2436 
2437  dst0 = const_vec;
2438  dst1 = const_vec;
2439  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2440  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec2, vec3);
2441  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt1, filt1, dst0, dst1,
2442  dst0, dst1);
2443  HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
2444 
2445  dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
2446  ST8x2_UB(dst0, dst, dst_stride);
2447 }
2448 
2449 static void hevc_hz_bi_4t_8x6_msa(uint8_t *src0_ptr,
2450  int32_t src_stride,
2451  int16_t *src1_ptr,
2452  int32_t src2_stride,
2453  uint8_t *dst,
2454  int32_t dst_stride,
2455  const int8_t *filter,
2456  int32_t height)
2457 {
2458  v8i16 filt0, filt1;
2459  v16i8 src0, src1, src2, src3, src4, src5;
2460  v8i16 in0, in1, in2, in3, in4, in5;
2461  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2462  v16i8 mask1;
2463  v16i8 vec0, vec1, vec2, vec3;
2464  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2465  v8i16 filter_vec, const_vec;
2466 
2467  src0_ptr -= 1;
2468 
2469  const_vec = __msa_ldi_h(128);
2470  const_vec <<= 6;
2471 
2472  filter_vec = LD_SH(filter);
2473  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2474 
2475  mask1 = mask0 + 2;
2476 
2477  LD_SB6(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5);
2478  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2479  src1_ptr += (4 * src2_stride);
2480  LD_SH2(src1_ptr, src2_stride, in4, in5);
2481  XORI_B6_128_SB(src0, src1, src2, src3, src4, src5);
2482 
2483  dst0 = const_vec;
2484  dst1 = const_vec;
2485  dst2 = const_vec;
2486  dst3 = const_vec;
2487  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2488  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
2489  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0, dst1,
2490  dst2, dst3);
2491  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
2492  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
2493  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0, dst1,
2494  dst2, dst3);
2495  dst4 = const_vec;
2496  dst5 = const_vec;
2497 
2498  VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec1);
2499  VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec2, vec3);
2500  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt1, filt1, dst4, dst5,
2501  dst4, dst5);
2502 
2503  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2504  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2505  HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2506 
2507  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2508  dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2509  ST8x4_UB(dst0, dst1, dst, dst_stride);
2510  dst += (4 * dst_stride);
2511  ST8x2_UB(dst2, dst, dst_stride);
2512 }
2513 
2514 static void hevc_hz_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
2515  int32_t src_stride,
2516  int16_t *src1_ptr,
2517  int32_t src2_stride,
2518  uint8_t *dst,
2519  int32_t dst_stride,
2520  const int8_t *filter,
2521  int32_t height)
2522 {
2523  uint32_t loop_cnt;
2524  v8i16 filt0, filt1;
2525  v16i8 src0, src1, src2, src3;
2526  v8i16 in0, in1, in2, in3;
2527  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
2528  v16i8 mask1;
2529  v16i8 vec0, vec1, vec2, vec3;
2530  v8i16 dst0, dst1, dst2, dst3;
2531  v8i16 filter_vec, const_vec;
2532 
2533  src0_ptr -= 1;
2534 
2535  const_vec = __msa_ldi_h(128);
2536  const_vec <<= 6;
2537 
2538  filter_vec = LD_SH(filter);
2539  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2540 
2541  mask1 = mask0 + 2;
2542 
2543  for (loop_cnt = (height >> 2); loop_cnt--;) {
2544  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2545  src0_ptr += (4 * src_stride);
2546  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2547  src1_ptr += (4 * src2_stride);
2548  XORI_B4_128_SB(src0, src1, src2, src3);
2549 
2550  dst0 = const_vec;
2551  dst1 = const_vec;
2552  dst2 = const_vec;
2553  dst3 = const_vec;
2554  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2555  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
2556  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2557  dst1, dst2, dst3);
2558  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
2559  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
2560  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2561  dst1, dst2, dst3);
2562 
2563  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2564  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2565 
2566  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2567  ST8x4_UB(dst0, dst1, dst, dst_stride);
2568  dst += (4 * dst_stride);
2569  }
2570 }
2571 
2572 static void hevc_hz_bi_4t_8w_msa(uint8_t *src0_ptr,
2573  int32_t src_stride,
2574  int16_t *src1_ptr,
2575  int32_t src2_stride,
2576  uint8_t *dst,
2577  int32_t dst_stride,
2578  const int8_t *filter,
2579  int32_t height)
2580 {
2581  if (2 == height) {
2582  hevc_hz_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2583  dst, dst_stride, filter, height);
2584  } else if (6 == height) {
2585  hevc_hz_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2586  dst, dst_stride, filter, height);
2587  } else if (0 == (height % 4)) {
2588  hevc_hz_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
2589  src1_ptr, src2_stride,
2590  dst, dst_stride, filter, height);
2591  }
2592 }
2593 
2594 static void hevc_hz_bi_4t_12w_msa(uint8_t *src0_ptr,
2595  int32_t src_stride,
2596  int16_t *src1_ptr,
2597  int32_t src2_stride,
2598  uint8_t *dst,
2599  int32_t dst_stride,
2600  const int8_t *filter,
2601  int32_t height)
2602 {
2603  uint32_t loop_cnt;
2604  v8i16 filt0, filt1;
2605  v16i8 src0, src1, src2, src3;
2606  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2607  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2608  v16i8 mask2 = {
2609  8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
2610  };
2611  v16i8 mask1, mask3;
2612  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
2613  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2614  v8i16 filter_vec, const_vec;
2615 
2616  src0_ptr -= 1;
2617 
2618  const_vec = __msa_ldi_h(128);
2619  const_vec <<= 6;
2620 
2621  filter_vec = LD_SH(filter);
2622  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2623 
2624  mask1 = mask0 + 2;
2625  mask3 = mask2 + 2;
2626 
2627  for (loop_cnt = (height >> 2); loop_cnt--;) {
2628  LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2629  src0_ptr += (4 * src_stride);
2630  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2631  LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
2632  src1_ptr += (4 * src2_stride);
2633 
2634  ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
2635  XORI_B4_128_SB(src0, src1, src2, src3);
2636 
2637  dst0 = const_vec;
2638  dst1 = const_vec;
2639  dst2 = const_vec;
2640  dst3 = const_vec;
2641  dst4 = const_vec;
2642  dst5 = const_vec;
2643  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2644  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
2645  VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
2646  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2647  dst1, dst2, dst3);
2648  DPADD_SB2_SH(vec4, vec5, filt0, filt0, dst4, dst5);
2649  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
2650  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
2651  VSHF_B2_SB(src0, src1, src2, src3, mask3, mask3, vec4, vec5);
2652  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2653  dst1, dst2, dst3);
2654  DPADD_SB2_SH(vec4, vec5, filt1, filt1, dst4, dst5);
2655 
2656  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2657  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2658  HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2659 
2660  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2661  dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2662  ST12x4_UB(dst0, dst1, dst2, dst, dst_stride);
2663  dst += (4 * dst_stride);
2664  }
2665 }
2666 
2667 static void hevc_hz_bi_4t_16w_msa(uint8_t *src0_ptr,
2668  int32_t src_stride,
2669  int16_t *src1_ptr,
2670  int32_t src2_stride,
2671  uint8_t *dst,
2672  int32_t dst_stride,
2673  const int8_t *filter,
2674  int32_t height)
2675 {
2676  uint32_t loop_cnt;
2677  v16i8 src0, src1, src2, src3, vec0, vec1, vec2, vec3;
2678  v8i16 in0, in1, in2, in3, dst0, dst1, dst2, dst3;
2679  v8i16 filt0, filt1;
2680  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2681  v16i8 mask1;
2682  v8i16 filter_vec, const_vec;
2683 
2684  src0_ptr -= 1;
2685 
2686  const_vec = __msa_ldi_h(128);
2687  const_vec <<= 6;
2688 
2689  filter_vec = LD_SH(filter);
2690  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2691 
2692  mask1 = mask0 + 2;
2693 
2694  for (loop_cnt = (height >> 1); loop_cnt--;) {
2695  LD_SB2(src0_ptr, src_stride, src0, src2);
2696  LD_SB2(src0_ptr + 8, src_stride, src1, src3);
2697  src0_ptr += (2 * src_stride);
2698  LD_SH2(src1_ptr, src2_stride, in0, in2);
2699  LD_SH2(src1_ptr + 8, src2_stride, in1, in3);
2700  src1_ptr += (2 * src2_stride);
2701 
2702  XORI_B4_128_SB(src0, src1, src2, src3);
2703 
2704  dst0 = const_vec;
2705  dst1 = const_vec;
2706  dst2 = const_vec;
2707  dst3 = const_vec;
2708 
2709  VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
2710  VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
2711  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2712  dst1, dst2, dst3);
2713  VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec0, vec1);
2714  VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec2, vec3);
2715  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2716  dst1, dst2, dst3);
2717 
2718  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2719  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2720 
2721  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2722  ST_SH2(dst0, dst1, dst, dst_stride);
2723  dst += (2 * dst_stride);
2724  }
2725 }
2726 
2727 static void hevc_hz_bi_4t_24w_msa(uint8_t *src0_ptr,
2728  int32_t src_stride,
2729  int16_t *src1_ptr,
2730  int32_t src2_stride,
2731  uint8_t *dst,
2732  int32_t dst_stride,
2733  const int8_t *filter,
2734  int32_t height)
2735 {
2736  int16_t *src1_ptr_tmp;
2737  uint8_t *dst_tmp;
2738  uint32_t loop_cnt;
2739  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2740  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2741  v8i16 filt0, filt1;
2742  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2743  v16i8 mask1, mask2, mask3;
2744  v16i8 vec0, vec1, vec2, vec3;
2745  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2746  v8i16 filter_vec, const_vec;
2747 
2748  src0_ptr -= 1;
2749 
2750  const_vec = __msa_ldi_h(128);
2751  const_vec <<= 6;
2752 
2753  filter_vec = LD_SH(filter);
2754  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2755 
2756  mask1 = mask0 + 2;
2757  mask2 = mask0 + 8;
2758  mask3 = mask0 + 10;
2759 
2760  dst_tmp = dst + 16;
2761  src1_ptr_tmp = src1_ptr + 16;
2762 
2763  for (loop_cnt = (height >> 2); loop_cnt--;) {
2764  LD_SB4(src0_ptr, src_stride, src0, src2, src4, src6);
2765  LD_SB4(src0_ptr + 16, src_stride, src1, src3, src5, src7);
2766  src0_ptr += (4 * src_stride);
2767  LD_SH4(src1_ptr, src2_stride, in0, in2, in4, in6);
2768  LD_SH4(src1_ptr + 8, src2_stride, in1, in3, in5, in7);
2769  src1_ptr += (4 * src2_stride);
2770  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2771 
2772  dst0 = const_vec;
2773  dst1 = const_vec;
2774  dst2 = const_vec;
2775  dst3 = const_vec;
2776  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask2, vec0, vec1);
2777  VSHF_B2_SB(src2, src2, src2, src3, mask0, mask2, vec2, vec3);
2778  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2779  dst1, dst2, dst3);
2780  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask3, vec0, vec1);
2781  VSHF_B2_SB(src2, src2, src2, src3, mask1, mask3, vec2, vec3);
2782  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2783  dst1, dst2, dst3);
2784 
2785  dst4 = const_vec;
2786  dst5 = const_vec;
2787  dst6 = const_vec;
2788  dst7 = const_vec;
2789  VSHF_B2_SB(src4, src4, src4, src5, mask0, mask2, vec0, vec1);
2790  VSHF_B2_SB(src6, src6, src6, src7, mask0, mask2, vec2, vec3);
2791  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst4,
2792  dst5, dst6, dst7);
2793  VSHF_B2_SB(src4, src4, src4, src5, mask1, mask3, vec0, vec1);
2794  VSHF_B2_SB(src6, src6, src6, src7, mask1, mask3, vec2, vec3);
2795  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst4,
2796  dst5, dst6, dst7);
2797 
2798  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2799  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2800  HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
2801  dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
2802 
2803  PCKEV_B4_SH(dst1, dst0, dst3, dst2,
2804  dst5, dst4, dst7, dst6, dst0, dst1, dst2, dst3);
2805  ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
2806  dst += (4 * dst_stride);
2807 
2808  LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
2809  src1_ptr_tmp += (4 * src2_stride);
2810 
2811  dst0 = const_vec;
2812  dst1 = const_vec;
2813  dst2 = const_vec;
2814  dst3 = const_vec;
2815  VSHF_B2_SB(src1, src1, src3, src3, mask0, mask0, vec0, vec1);
2816  VSHF_B2_SB(src5, src5, src7, src7, mask0, mask0, vec2, vec3);
2817  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2818  dst1, dst2, dst3);
2819  VSHF_B2_SB(src1, src1, src3, src3, mask1, mask1, vec0, vec1);
2820  VSHF_B2_SB(src5, src5, src7, src7, mask1, mask1, vec2, vec3);
2821  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2822  dst1, dst2, dst3);
2823 
2824  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2825  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2826 
2827  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2828  ST8x4_UB(dst0, dst1, dst_tmp, dst_stride);
2829  dst_tmp += (4 * dst_stride);
2830  }
2831 }
2832 
2833 static void hevc_hz_bi_4t_32w_msa(uint8_t *src0_ptr,
2834  int32_t src_stride,
2835  int16_t *src1_ptr,
2836  int32_t src2_stride,
2837  uint8_t *dst,
2838  int32_t dst_stride,
2839  const int8_t *filter,
2840  int32_t height)
2841 {
2842  uint32_t loop_cnt;
2843  v16i8 src0, src1, src2;
2844  v8i16 in0, in1, in2, in3;
2845  v8i16 filt0, filt1;
2846  v16i8 mask0 = LD_SB(&ff_hevc_mask_arr[0]);
2847  v16i8 mask1, mask2, mask3;
2848  v8i16 dst0, dst1, dst2, dst3;
2849  v16i8 vec0, vec1, vec2, vec3;
2850  v8i16 filter_vec, const_vec;
2851 
2852  src0_ptr -= 1;
2853 
2854  const_vec = __msa_ldi_h(128);
2855  const_vec <<= 6;
2856 
2857  filter_vec = LD_SH(filter);
2858  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2859 
2860  mask1 = mask0 + 2;
2861  mask2 = mask0 + 8;
2862  mask3 = mask0 + 10;
2863 
2864  for (loop_cnt = height; loop_cnt--;) {
2865  LD_SB2(src0_ptr, 16, src0, src1);
2866  src2 = LD_SB(src0_ptr + 24);
2867  src0_ptr += src_stride;
2868  LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
2869  src1_ptr += src2_stride;
2870  XORI_B3_128_SB(src0, src1, src2);
2871 
2872  dst0 = const_vec;
2873  dst1 = const_vec;
2874  dst2 = const_vec;
2875  dst3 = const_vec;
2876  VSHF_B2_SB(src0, src0, src0, src1, mask0, mask2, vec0, vec1);
2877  VSHF_B2_SB(src1, src1, src2, src2, mask0, mask0, vec2, vec3);
2878  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, dst0,
2879  dst1, dst2, dst3);
2880  VSHF_B2_SB(src0, src0, src0, src1, mask1, mask3, vec0, vec1);
2881  VSHF_B2_SB(src1, src1, src2, src2, mask1, mask1, vec2, vec3);
2882  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt1, filt1, filt1, filt1, dst0,
2883  dst1, dst2, dst3);
2884 
2885  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2886  dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2887 
2888  PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2889  ST_SH2(dst0, dst1, dst, 16);
2890  dst += dst_stride;
2891  }
2892 }
2893 
2894 static void hevc_vt_bi_4t_4x2_msa(uint8_t *src0_ptr,
2895  int32_t src_stride,
2896  int16_t *src1_ptr,
2897  int32_t src2_stride,
2898  uint8_t *dst,
2899  int32_t dst_stride,
2900  const int8_t *filter,
2901  int32_t height)
2902 {
2903  v16i8 src0, src1, src2, src3, src4;
2904  v8i16 in0, in1;
2905  v16i8 src10_r, src32_r, src21_r, src43_r, src2110, src4332;
2906  v8i16 dst10;
2907  v8i16 filt0, filt1;
2908  v8i16 filter_vec, const_vec;
2909 
2910  src0_ptr -= src_stride;
2911 
2912  const_vec = __msa_ldi_h(128);
2913  const_vec <<= 6;
2914 
2915  filter_vec = LD_SH(filter);
2916  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2917 
2918  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2919  src0_ptr += (3 * src_stride);
2920 
2921  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2922  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2923  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2924 
2925  LD_SB2(src0_ptr, src_stride, src3, src4);
2926  LD_SH2(src1_ptr, src2_stride, in0, in1);
2927  in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
2928  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2929  src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_r, (v2i64) src32_r);
2930  src4332 = (v16i8) __msa_xori_b((v16u8) src4332, 128);
2931 
2932  dst10 = const_vec;
2933  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2934  dst10 = __msa_adds_s_h(dst10, in0);
2935  dst10 = __msa_srari_h(dst10, 7);
2936  dst10 = CLIP_SH_0_255(dst10);
2937 
2938  dst10 = (v8i16) __msa_pckev_b((v16i8) dst10, (v16i8) dst10);
2939  ST4x2_UB(dst10, dst, dst_stride);
2940 }
2941 
2942 static void hevc_vt_bi_4t_4x4_msa(uint8_t *src0_ptr,
2943  int32_t src_stride,
2944  int16_t *src1_ptr,
2945  int32_t src2_stride,
2946  uint8_t *dst,
2947  int32_t dst_stride,
2948  const int8_t *filter,
2949  int32_t height)
2950 {
2951  v16i8 src0, src1, src2, src3, src4, src5, src6;
2952  v8i16 in0, in1, in2, in3;
2953  v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
2954  v16i8 src2110, src4332, src6554;
2955  v8i16 dst10, dst32;
2956  v8i16 filt0, filt1;
2957  v8i16 filter_vec, const_vec;
2958 
2959  src0_ptr -= src_stride;
2960 
2961  const_vec = __msa_ldi_h(128);
2962  const_vec <<= 6;
2963 
2964  filter_vec = LD_SH(filter);
2965  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2966 
2967  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2968  src0_ptr += (3 * src_stride);
2969  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2970  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2971  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2972 
2973  LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
2974  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2975  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2976  ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
2977  src32_r, src43_r, src54_r, src65_r);
2978  ILVR_D2_SB(src43_r, src32_r, src65_r, src54_r, src4332, src6554);
2979  XORI_B2_128_SB(src4332, src6554);
2980 
2981  dst10 = const_vec;
2982  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2983  dst32 = const_vec;
2984  DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
2985  HEVC_BI_RND_CLIP2(in0, in1, dst10, dst32, 7, dst10, dst32);
2986 
2987  dst10 = (v8i16) __msa_pckev_b((v16i8) dst32, (v16i8) dst10);
2988  ST4x4_UB(dst10, dst10, 0, 1, 2, 3, dst, dst_stride);
2989 }
2990 
2991 static void hevc_vt_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
2992  int32_t src_stride,
2993  int16_t *src1_ptr,
2994  int32_t src2_stride,
2995  uint8_t *dst,
2996  int32_t dst_stride,
2997  const int8_t *filter,
2998  int32_t height)
2999 {
3000  int32_t loop_cnt;
3001  v16i8 src0, src1, src2, src3, src4, src5;
3002  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3003  v16i8 src6, src7, src8, src9;
3004  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
3005  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
3006  v16i8 src2110, src4332, src6554, src8776;
3007  v8i16 dst10, dst32, dst54, dst76;
3008  v8i16 filt0, filt1;
3009  v8i16 filter_vec, const_vec;
3010 
3011  src0_ptr -= src_stride;
3012 
3013  const_vec = __msa_ldi_h(128);
3014  const_vec <<= 6;
3015 
3016  filter_vec = LD_SH(filter);
3017  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3018 
3019  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3020  src0_ptr += (3 * src_stride);
3021  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3022  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
3023  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
3024 
3025  for (loop_cnt = (height >> 3); loop_cnt--;) {
3026  LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
3027  src0_ptr += (6 * src_stride);
3028  LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
3029  src1_ptr += (8 * src2_stride);
3030  ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3031  ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
3032  ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
3033  src32_r, src43_r, src54_r, src65_r);
3034  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3035  ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
3036  src4332, src6554, src8776);
3037  XORI_B3_128_SB(src4332, src6554, src8776);
3038 
3039  dst10 = const_vec;
3040  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
3041  dst32 = const_vec;
3042  DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
3043  dst54 = const_vec;
3044  DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
3045 
3046  LD_SB2(src0_ptr, src_stride, src9, src2);
3047  src0_ptr += (2 * src_stride);
3048  ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
3049  src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
3050  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
3051  dst76 = const_vec;
3052  DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
3053 
3054  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3055  dst10, dst32, dst54, dst76, 7,
3056  dst10, dst32, dst54, dst76);
3057 
3058  PCKEV_B2_SH(dst32, dst10, dst76, dst54, dst10, dst54);
3059  ST4x8_UB(dst10, dst54, dst, dst_stride);
3060  dst += (8 * dst_stride);
3061  }
3062 }
3063 
3064 static void hevc_vt_bi_4t_4w_msa(uint8_t *src0_ptr,
3065  int32_t src_stride,
3066  int16_t *src1_ptr,
3067  int32_t src2_stride,
3068  uint8_t *dst,
3069  int32_t dst_stride,
3070  const int8_t *filter,
3071  int32_t height)
3072 {
3073  if (2 == height) {
3074  hevc_vt_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3075  dst, dst_stride, filter, height);
3076  } else if (4 == height) {
3077  hevc_vt_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3078  dst, dst_stride, filter, height);
3079  } else {
3080  hevc_vt_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
3081  src1_ptr, src2_stride,
3082  dst, dst_stride, filter, height);
3083  }
3084 }
3085 
3086 static void hevc_vt_bi_4t_6w_msa(uint8_t *src0_ptr,
3087  int32_t src_stride,
3088  int16_t *src1_ptr,
3089  int32_t src2_stride,
3090  uint8_t *dst,
3091  int32_t dst_stride,
3092  const int8_t *filter,
3093  int32_t height)
3094 {
3095  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
3096  v8i16 in0, in1, in2, in3;
3097  v16i8 src10_r, src32_r, src21_r, src43_r, src54_r, src65_r;
3098  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3099  v8i16 filt0, filt1;
3100  v8i16 filter_vec, const_vec;
3101 
3102  src0_ptr -= src_stride;
3103 
3104  const_vec = __msa_ldi_h(128);
3105  const_vec <<= 6;
3106 
3107  filter_vec = LD_SH(filter);
3108  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3109 
3110  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3111  src0_ptr += (3 * src_stride);
3112  LD_SB2(src0_ptr, src_stride, src3, src4);
3113  src0_ptr += (2 * src_stride);
3114  LD_SB2(src0_ptr, src_stride, src5, src6);
3115  src0_ptr += (2 * src_stride);
3116  LD_SB2(src0_ptr, src_stride, src7, src8);
3117  src0_ptr += (2 * src_stride);
3118  LD_SB2(src0_ptr, src_stride, src9, src10);
3119  src0_ptr += (2 * src_stride);
3120 
3121  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3122  src1_ptr += (4 * src2_stride);
3123 
3124  XORI_B3_128_SB(src0, src1, src2);
3125  XORI_B2_128_SB(src3, src4);
3126  XORI_B2_128_SB(src5, src6);
3127  XORI_B2_128_SB(src7, src8);
3128  XORI_B2_128_SB(src9, src10);
3129 
3130  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3131  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3132 
3133  dst0_r = const_vec;
3134  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3135  dst1_r = const_vec;
3136  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3137 
3138  ILVR_B2_SB(src5, src4, src6, src5, src54_r, src65_r);
3139 
3140  dst2_r = const_vec;
3141  DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
3142  dst3_r = const_vec;
3143  DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
3144 
3145  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3146  dst0_r, dst1_r, dst2_r, dst3_r, 7,
3147  dst0_r, dst1_r, dst2_r, dst3_r);
3148 
3149  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3150  ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
3151  dst += (4 * dst_stride);
3152 
3153  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3154  src1_ptr += (4 * src2_stride);
3155  ILVR_B2_SB(src7, src6, src8, src7, src32_r, src43_r);
3156 
3157  dst0_r = const_vec;
3158  DPADD_SB2_SH(src54_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3159  dst1_r = const_vec;
3160  DPADD_SB2_SH(src65_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3161 
3162  ILVR_B2_SB(src9, src8, src10, src9, src54_r, src65_r);
3163 
3164  dst2_r = const_vec;
3165  DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
3166  dst3_r = const_vec;
3167  DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
3168 
3169  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3170  dst0_r, dst1_r, dst2_r, dst3_r, 7,
3171  dst0_r, dst1_r, dst2_r, dst3_r);
3172 
3173  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3174  ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
3175  dst += (4 * dst_stride);
3176 }
3177 
3178 static void hevc_vt_bi_4t_8x2_msa(uint8_t *src0_ptr,
3179  int32_t src_stride,
3180  int16_t *src1_ptr,
3181  int32_t src2_stride,
3182  uint8_t *dst,
3183  int32_t dst_stride,
3184  const int8_t *filter,
3185  int32_t height)
3186 {
3187  v16i8 src0, src1, src2, src3, src4;
3188  v8i16 in0, in1, dst0_r, dst1_r;
3189  v16i8 src10_r, src32_r, src21_r, src43_r;
3190  v8i16 filt0, filt1;
3191  v8i16 filter_vec, const_vec;
3192 
3193  src0_ptr -= src_stride;
3194 
3195  const_vec = __msa_ldi_h(128);
3196  const_vec <<= 6;
3197 
3198  filter_vec = LD_SH(filter);
3199  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3200 
3201  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3202  src0_ptr += (3 * src_stride);
3203  XORI_B3_128_SB(src0, src1, src2);
3204  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3205 
3206  LD_SB2(src0_ptr, src_stride, src3, src4);
3207  LD_SH2(src1_ptr, src2_stride, in0, in1);
3208  XORI_B2_128_SB(src3, src4);
3209  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3210 
3211  dst0_r = const_vec;
3212  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3213  dst1_r = const_vec;
3214  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3215 
3216  HEVC_BI_RND_CLIP2(in0, in1, dst0_r, dst1_r, 7, dst0_r, dst1_r);
3217  dst0_r = (v8i16) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst0_r);
3218 
3219  ST8x2_UB(dst0_r, dst, dst_stride);
3220 }
3221 
3222 static void hevc_vt_bi_4t_8x6_msa(uint8_t *src0_ptr,
3223  int32_t src_stride,
3224  int16_t *src1_ptr,
3225  int32_t src2_stride,
3226  uint8_t *dst,
3227  int32_t dst_stride,
3228  const int8_t *filter,
3229  int32_t height)
3230 {
3231  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
3232  v8i16 in0, in1, in2, in3, in4, in5;
3233  v16i8 src10_r, src32_r, src54_r, src76_r;
3234  v16i8 src21_r, src43_r, src65_r, src87_r;
3235  v8i16 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
3236  v8i16 filt0, filt1;
3237  v8i16 filter_vec, const_vec;
3238 
3239  src0_ptr -= src_stride;
3240 
3241  const_vec = __msa_ldi_h(128);
3242  const_vec <<= 6;
3243 
3244  filter_vec = LD_SH(filter);
3245  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3246 
3247  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3248  src0_ptr += (3 * src_stride);
3249  XORI_B3_128_SB(src0, src1, src2);
3250  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3251 
3252  LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
3253  LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
3254  XORI_B6_128_SB(src3, src4, src5, src6, src7, src8);
3255  ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
3256  src32_r, src43_r, src54_r, src65_r);
3257  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3258 
3259  dst0_r = const_vec;
3260  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3261  dst1_r = const_vec;
3262  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3263  dst2_r = const_vec;
3264  DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
3265  dst3_r = const_vec;
3266  DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
3267  dst4_r = const_vec;
3268  DPADD_SB2_SH(src54_r, src76_r, filt0, filt1, dst4_r, dst4_r);
3269  dst5_r = const_vec;
3270  DPADD_SB2_SH(src65_r, src87_r, filt0, filt1, dst5_r, dst5_r);
3271  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3272  dst0_r, dst1_r, dst2_r, dst3_r, 7,
3273  dst0_r, dst1_r, dst2_r, dst3_r);
3274  HEVC_BI_RND_CLIP2(in4, in5, dst4_r, dst5_r, 7, dst4_r, dst5_r);
3275 
3276  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3277  dst2_r = (v8i16) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst4_r);
3278  ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
3279  dst += (4 * dst_stride);
3280  ST8x2_UB(dst2_r, dst, dst_stride);
3281 }
3282 
3283 static void hevc_vt_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
3284  int32_t src_stride,
3285  int16_t *src1_ptr,
3286  int32_t src2_stride,
3287  uint8_t *dst,
3288  int32_t dst_stride,
3289  const int8_t *filter,
3290  int32_t height)
3291 {
3292  int32_t loop_cnt;
3293  v16i8 src0, src1, src2, src3, src4, src5;
3294  v8i16 in0, in1, in2, in3;
3295  v16i8 src10_r, src32_r, src21_r, src43_r;
3296  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3297  v8i16 filt0, filt1;
3298  v8i16 filter_vec, const_vec;
3299 
3300  src0_ptr -= src_stride;
3301 
3302  const_vec = __msa_ldi_h(128);
3303  const_vec <<= 6;
3304 
3305  filter_vec = LD_SH(filter);
3306  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3307 
3308  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3309  src0_ptr += (3 * src_stride);
3310  XORI_B3_128_SB(src0, src1, src2);
3311  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3312 
3313  for (loop_cnt = (height >> 2); loop_cnt--;) {
3314  LD_SB2(src0_ptr, src_stride, src3, src4);
3315  src0_ptr += (2 * src_stride);
3316  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3317  src1_ptr += (4 * src2_stride);
3318  XORI_B2_128_SB(src3, src4);
3319  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3320 
3321  dst0_r = const_vec;
3322  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3323  dst1_r = const_vec;
3324  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3325 
3326  LD_SB2(src0_ptr, src_stride, src5, src2);
3327  src0_ptr += (2 * src_stride);
3328  XORI_B2_128_SB(src5, src2);
3329  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3330 
3331  dst2_r = const_vec;
3332  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3333  dst3_r = const_vec;
3334  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3335  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3336  dst0_r, dst1_r, dst2_r, dst3_r, 7,
3337  dst0_r, dst1_r, dst2_r, dst3_r);
3338 
3339  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3340  ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
3341  dst += (4 * dst_stride);
3342  }
3343 }
3344 
3345 static void hevc_vt_bi_4t_8w_msa(uint8_t *src0_ptr,
3346  int32_t src_stride,
3347  int16_t *src1_ptr,
3348  int32_t src2_stride,
3349  uint8_t *dst,
3350  int32_t dst_stride,
3351  const int8_t *filter,
3352  int32_t height)
3353 {
3354  if (2 == height) {
3355  hevc_vt_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3356  dst, dst_stride, filter, height);
3357  } else if (6 == height) {
3358  hevc_vt_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3359  dst, dst_stride, filter, height);
3360  } else {
3361  hevc_vt_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
3362  src1_ptr, src2_stride,
3363  dst, dst_stride, filter, height);
3364  }
3365 }
3366 
3367 static void hevc_vt_bi_4t_12w_msa(uint8_t *src0_ptr,
3368  int32_t src_stride,
3369  int16_t *src1_ptr,
3370  int32_t src2_stride,
3371  uint8_t *dst,
3372  int32_t dst_stride,
3373  const int8_t *filter,
3374  int32_t height)
3375 {
3376  int32_t loop_cnt;
3377  v16i8 src0, src1, src2, src3, src4, src5, src6;
3378  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3379  v16i8 src10_r, src32_r, src21_r, src43_r, src54_r, src65_r;
3380  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3381  v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
3382  v16i8 src2110, src4332, src6554;
3383  v8i16 dst0_l, dst1_l, filt0, filt1;
3384  v8i16 filter_vec, const_vec;
3385 
3386  src0_ptr -= (1 * src_stride);
3387 
3388  const_vec = __msa_ldi_h(128);
3389  const_vec <<= 6;
3390 
3391  filter_vec = LD_SH(filter);
3392  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3393 
3394  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3395  src0_ptr += (3 * src_stride);
3396  XORI_B3_128_SB(src0, src1, src2);
3397  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3398  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3399  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
3400 
3401  for (loop_cnt = (height >> 2); loop_cnt--;) {
3402  LD_SB2(src0_ptr, src_stride, src3, src4);
3403  src0_ptr += (2 * src_stride);
3404  LD_SB2(src0_ptr, src_stride, src5, src6);
3405  src0_ptr += (2 * src_stride);
3406  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3407  LD_SH4((src1_ptr + 8), src2_stride, in4, in5, in6, in7);
3408  src1_ptr += (4 * src2_stride);
3409  ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
3410  XORI_B2_128_SB(src3, src4);
3411  XORI_B2_128_SB(src5, src6);
3412 
3413  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3414  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3415  src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
3416  ILVR_B2_SB(src5, src4, src6, src5, src54_r, src65_r);
3417  ILVL_B2_SB(src5, src4, src6, src5, src54_l, src65_l);
3418  src6554 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
3419 
3420  dst0_r = const_vec;
3421  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3422  dst1_r = const_vec;
3423  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3424  dst0_l = const_vec;
3425  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst0_l, dst0_l);
3426  dst2_r = const_vec;
3427  DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
3428  dst3_r = const_vec;
3429  DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
3430  dst1_l = const_vec;
3431  DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst1_l, dst1_l);
3432  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3433  dst0_r, dst1_r, dst2_r, dst3_r, 7,
3434  dst0_r, dst1_r, dst2_r, dst3_r);
3435  HEVC_BI_RND_CLIP2(in4, in5, dst0_l, dst1_l, 7, dst0_l, dst1_l);
3436 
3437  PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3438  dst0_l = (v8i16) __msa_pckev_b((v16i8) dst1_l, (v16i8) dst0_l);
3439  ST12x4_UB(dst0_r, dst1_r, dst0_l, dst, dst_stride);
3440  dst += (4 * dst_stride);
3441 
3442  src2 = src6;
3443  src10_r = src54_r;
3444  src21_r = src65_r;
3445  src2110 = src6554;
3446  }
3447 }
3448 
3449 static void hevc_vt_bi_4t_16w_msa(uint8_t *src0_ptr,
3450  int32_t src_stride,
3451  int16_t *src1_ptr,
3452  int32_t src2_stride,
3453  uint8_t *dst,
3454  int32_t dst_stride,
3455  const int8_t *filter,
3456  int32_t height)
3457 {
3458  int32_t loop_cnt;
3459  v16i8 src0, src1, src2, src3, src4, src5;
3460  v8i16 in0, in1, in2, in3;
3461  v16i8 src10_r, src32_r, src21_r, src43_r;
3462  v16i8 src10_l, src32_l, src21_l, src43_l;
3463  v8i16 dst0_r, dst1_r, dst0_l, dst1_l;
3464  v8i16 filt0, filt1;
3465  v8i16 filter_vec, const_vec;
3466 
3467  src0_ptr -= src_stride;
3468 
3469  const_vec = __msa_ldi_h(128);
3470  const_vec <<= 6;
3471 
3472  filter_vec = LD_SH(filter);
3473  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3474 
3475  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3476  src0_ptr += (3 * src_stride);
3477  XORI_B3_128_SB(src0, src1, src2);
3478  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3479  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3480 
3481  for (loop_cnt = (height >> 2); loop_cnt--;) {
3482  LD_SB2(src0_ptr, src_stride, src3, src4);
3483  src0_ptr += (2 * src_stride);
3484  LD_SH2(src1_ptr, src2_stride, in0, in1);
3485  LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3486  src1_ptr += (2 * src2_stride);
3487  XORI_B2_128_SB(src3, src4);
3488  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3489  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3490 
3491  dst0_r = const_vec;
3492  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3493  dst1_r = const_vec;
3494  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3495  dst0_l = const_vec;
3496  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3497  dst1_l = const_vec;
3498  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3499  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3500  dst0_r, dst1_r, dst0_l, dst1_l, 7,
3501  dst0_r, dst1_r, dst0_l, dst1_l);
3502 
3503  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3504  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3505  dst += (2 * dst_stride);
3506 
3507  LD_SB2(src0_ptr, src_stride, src5, src2);
3508  src0_ptr += (2 * src_stride);
3509  LD_SH2(src1_ptr, src2_stride, in0, in1);
3510  LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3511  src1_ptr += (2 * src2_stride);
3512  XORI_B2_128_SB(src5, src2);
3513  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3514  ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3515 
3516  dst0_r = const_vec;
3517  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3518  dst0_l = const_vec;
3519  DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3520  dst1_r = const_vec;
3521  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3522  dst1_l = const_vec;
3523  DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3524  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3525  dst0_r, dst1_r, dst0_l, dst1_l, 7,
3526  dst0_r, dst1_r, dst0_l, dst1_l);
3527 
3528  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3529  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3530  dst += (2 * dst_stride);
3531  }
3532 }
3533 
3534 static void hevc_vt_bi_4t_24w_msa(uint8_t *src0_ptr,
3535  int32_t src_stride,
3536  int16_t *src1_ptr,
3537  int32_t src2_stride,
3538  uint8_t *dst,
3539  int32_t dst_stride,
3540  const int8_t *filter,
3541  int32_t height)
3542 {
3543  uint32_t loop_cnt;
3544  v16i8 src0, src1, src2, src3, src4, src5;
3545  v16i8 src6, src7, src8, src9, src10, src11;
3546  v8i16 in0, in1, in2, in3, in4, in5;
3547  v16i8 src10_r, src32_r, src76_r, src98_r;
3548  v16i8 src21_r, src43_r, src87_r, src109_r;
3549  v16i8 src10_l, src32_l, src21_l, src43_l;
3550  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3551  v8i16 dst0_l, dst1_l;
3552  v8i16 filt0, filt1;
3553  v8i16 filter_vec, const_vec;
3554 
3555  src0_ptr -= src_stride;
3556 
3557  const_vec = __msa_ldi_h(128);
3558  const_vec <<= 6;
3559 
3560  filter_vec = LD_SH(filter);
3561  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3562 
3563  /* 16width */
3564  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3565  XORI_B3_128_SB(src0, src1, src2);
3566  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3567  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3568  /* 8width */
3569  LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3570  src0_ptr += (3 * src_stride);
3571  XORI_B3_128_SB(src6, src7, src8);
3572  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3573 
3574  for (loop_cnt = (height >> 2); loop_cnt--;) {
3575  /* 16width */
3576  LD_SB2(src0_ptr, src_stride, src3, src4);
3577  LD_SH2(src1_ptr, src2_stride, in0, in1);
3578  LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3579  LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3580  src1_ptr += (2 * src2_stride);
3581  XORI_B2_128_SB(src3, src4);
3582  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3583  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3584  /* 8width */
3585  LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3586  src0_ptr += (2 * src_stride);
3587  XORI_B2_128_SB(src9, src10);
3588  ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3589  /* 16width */
3590  dst0_r = const_vec;
3591  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3592  dst0_l = const_vec;
3593  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3594  dst1_r = const_vec;
3595  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3596  dst1_l = const_vec;
3597  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3598  /* 8width */
3599  dst2_r = const_vec;
3600  DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3601  dst3_r = const_vec;
3602  DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3603  /* 16width */
3604  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3605  dst0_r, dst1_r, dst0_l, dst1_l, 7,
3606  dst0_r, dst1_r, dst0_l, dst1_l);
3607 
3608  HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3609 
3610  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3611  dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3612  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3613  ST8x2_UB(dst2_r, dst + 16, dst_stride);
3614  dst += (2 * dst_stride);
3615 
3616  /* 16width */
3617  LD_SB2(src0_ptr, src_stride, src5, src2);
3618  LD_SH2(src1_ptr, src2_stride, in0, in1);
3619  LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3620  LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3621  src1_ptr += (2 * src2_stride);
3622  XORI_B2_128_SB(src5, src2);
3623  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3624  ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3625  /* 8width */
3626  LD_SB2(src0_ptr + 16, src_stride, src11, src8);
3627  src0_ptr += (2 * src_stride);
3628  XORI_B2_128_SB(src11, src8);
3629  ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
3630  /* 16width */
3631  dst0_r = const_vec;
3632  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3633  dst0_l = const_vec;
3634  DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3635  dst1_r = const_vec;
3636  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3637  dst1_l = const_vec;
3638  DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3639  /* 8width */
3640  dst2_r = const_vec;
3641  DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
3642  dst3_r = const_vec;
3643  DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
3644 
3645  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3646  dst0_r, dst1_r, dst0_l, dst1_l, 7,
3647  dst0_r, dst1_r, dst0_l, dst1_l);
3648  HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3649 
3650  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3651  dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3652  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3653  ST8x2_UB(dst2_r, dst + 16, dst_stride);
3654  dst += (2 * dst_stride);
3655  }
3656 }
3657 
3658 static void hevc_vt_bi_4t_32w_msa(uint8_t *src0_ptr,
3659  int32_t src_stride,
3660  int16_t *src1_ptr,
3661  int32_t src2_stride,
3662  uint8_t *dst,
3663  int32_t dst_stride,
3664  const int8_t *filter,
3665  int32_t height)
3666 {
3667  uint32_t loop_cnt;
3668  uint8_t *dst_tmp = dst + 16;
3669  v16i8 src0, src1, src2, src3, src4, src6, src7, src8, src9, src10;
3670  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3671  v16i8 src10_r, src32_r, src76_r, src98_r;
3672  v16i8 src21_r, src43_r, src87_r, src109_r;
3673  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3674  v16i8 src10_l, src32_l, src76_l, src98_l;
3675  v16i8 src21_l, src43_l, src87_l, src109_l;
3676  v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
3677  v8i16 filt0, filt1;
3678  v8i16 filter_vec, const_vec;
3679 
3680  src0_ptr -= src_stride;
3681 
3682  const_vec = __msa_ldi_h(128);
3683  const_vec <<= 6;
3684 
3685  filter_vec = LD_SH(filter);
3686  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3687 
3688  /* 16width */
3689  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3690  XORI_B3_128_SB(src0, src1, src2);
3691  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3692  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3693 
3694  /* next 16width */
3695  LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3696  src0_ptr += (3 * src_stride);
3697  XORI_B3_128_SB(src6, src7, src8);
3698  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3699  ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
3700 
3701  for (loop_cnt = (height >> 1); loop_cnt--;) {
3702  /* 16width */
3703  LD_SB2(src0_ptr, src_stride, src3, src4);
3704  LD_SH2(src1_ptr, src2_stride, in0, in1);
3705  LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3706  LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3707  LD_SH2((src1_ptr + 24), src2_stride, in6, in7);
3708  src1_ptr += (2 * src2_stride);
3709  XORI_B2_128_SB(src3, src4);
3710  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3711  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3712  /* 16width */
3713  dst0_r = const_vec;
3714  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3715  dst0_l = const_vec;
3716  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3717  dst1_r = const_vec;
3718  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3719  dst1_l = const_vec;
3720  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3721  /* 16width */
3722  HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3723  dst0_r, dst1_r, dst0_l, dst1_l, 7,
3724  dst0_r, dst1_r, dst0_l, dst1_l);
3725 
3726  src10_r = src32_r;
3727  src21_r = src43_r;
3728  src10_l = src32_l;
3729  src21_l = src43_l;
3730  src2 = src4;
3731 
3732  PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3733  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3734  dst += (2 * dst_stride);
3735 
3736  /* next 16width */
3737  LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3738  src0_ptr += (2 * src_stride);
3739  XORI_B2_128_SB(src9, src10);
3740  ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3741  ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
3742  /* next 16width */
3743  dst2_r = const_vec;
3744  DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3745  dst2_l = const_vec;
3746  DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, dst2_l, dst2_l);
3747  dst3_r = const_vec;
3748  DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3749  dst3_l = const_vec;
3750  DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, dst3_l, dst3_l);
3751  /* next 16width */
3752  HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
3753  dst2_r, dst3_r, dst2_l, dst3_l, 7,
3754  dst2_r, dst3_r, dst2_l, dst3_l);
3755 
3756  PCKEV_B2_SH(dst2_l, dst2_r, dst3_l, dst3_r, dst2_r, dst3_r);
3757  ST_SH2(dst2_r, dst3_r, dst_tmp, dst_stride);
3758  dst_tmp += (2 * dst_stride);
3759 
3760  src76_r = src98_r;
3761  src87_r = src109_r;
3762  src76_l = src98_l;
3763  src87_l = src109_l;
3764  src8 = src10;
3765  }
3766 }
3767 
3768 static void hevc_hv_bi_4t_4x2_msa(uint8_t *src0_ptr,
3769  int32_t src_stride,
3770  int16_t *src1_ptr,
3771  int32_t src2_stride,
3772  uint8_t *dst,
3773  int32_t dst_stride,
3774  const int8_t *filter_x,
3775  const int8_t *filter_y)
3776 {
3777  uint64_t tp0, tp1;
3778  v16u8 out;
3779  v8i16 in0 = { 0 };
3780  v16i8 src0, src1, src2, src3, src4;
3781  v8i16 filt0, filt1;
3782  v8i16 filt_h0, filt_h1;
3783  v16i8 mask0 = LD_SB(ff_hevc_mask_arr + 16);
3784  v16i8 mask1;
3785  v8i16 filter_vec, const_vec;
3786  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3787  v8i16 dst20, dst31, dst42, dst10, dst32, dst21, dst43, tmp;
3788  v4i32 dst0, dst1;
3789 
3790  src0_ptr -= (src_stride + 1);
3791 
3792  filter_vec = LD_SH(filter_x);
3793  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3794 
3795  filter_vec = LD_SH(filter_y);
3796  UNPCK_R_SB_SH(filter_vec, filter_vec);
3797 
3798  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
3799 
3800  mask1 = mask0 + 2;
3801 
3802  const_vec = __msa_ldi_h(128);
3803  const_vec <<= 6;
3804 
3805  LD_SB5(src0_ptr, src_stride, src0, src1, src2, src3, src4);
3806  XORI_B5_128_SB(src0, src1, src2, src3, src4);
3807 
3808  LD2(src1_ptr, src2_stride, tp0, tp1);
3809  INSERT_D2_SH(tp0, tp1, in0);
3810  in0 = __msa_adds_s_h(in0, const_vec);
3811 
3812  VSHF_B2_SB(src0, src2, src0, src2, mask0, mask1, vec0, vec1);
3813  VSHF_B2_SB(src1, src3, src1, src3, mask0, mask1, vec2, vec3);
3814  VSHF_B2_SB(src2, src4, src2, src4, mask0, mask1, vec4, vec5);
3815 
3816  dst20 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
3817  dst31 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
3818  dst42 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
3819 
3820  ILVRL_H2_SH(dst31, dst20, dst10, dst32);
3821  ILVRL_H2_SH(dst42, dst31, dst21, dst43);
3822 
3823  dst0 = HEVC_FILT_4TAP(dst10, dst32, filt_h0, filt_h1);
3824  dst1 = HEVC_FILT_4TAP(dst21, dst43, filt_h0, filt_h1);
3825  dst0 >>= 6;
3826  dst1 >>= 6;
3827  tmp = __msa_pckev_h((v8i16) dst1, (v8i16) dst0);
3828  tmp = __msa_adds_s_h(tmp, in0);
3829  tmp = __msa_srari_h(tmp, 7);
3830  tmp = CLIP_SH_0_255_MAX_SATU(tmp);
3831  out = (v16u8) __msa_pckev_b((v16i8) tmp, (v16i8) tmp);
3832  ST4x2_UB(out, dst, dst_stride);
3833 }
3834 
3835 static void hevc_hv_bi_4t_4x4_msa(uint8_t *src0_ptr,
3836  int32_t src_stride,
3837  int16_t *src1_ptr,
3838  int32_t src2_stride,
3839  uint8_t *dst,
3840  int32_t dst_stride,
3841  const int8_t *filter_x,
3842  const int8_t *filter_y)
3843 {
3844  uint64_t tp0, tp1;
3845  v16u8 out;
3846  v16i8 src0, src1, src2, src3, src4, src5, src6;
3847  v8i16 filt0, filt1;
3848  v8i16 filt_h0, filt_h1;
3849  v16i8 mask0 = LD_SB(ff_hevc_mask_arr + 16);
3850  v16i8 mask1;
3851  v8i16 filter_vec, const_vec;
3852  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
3853  v8i16 tmp0, tmp1;
3854  v8i16 in0 = { 0 }, in1 = { 0 };
3855  v8i16 dst30, dst41, dst52, dst63;
3856  v8i16 dst10, dst32, dst54, dst21, dst43, dst65;
3857  v4i32 dst0, dst1, dst2, dst3;
3858 
3859  src0_ptr -= (src_stride + 1);
3860 
3861  filter_vec = LD_SH(filter_x);
3862  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3863 
3864  filter_vec = LD_SH(filter_y);
3865  UNPCK_R_SB_SH(filter_vec, filter_vec);
3866 
3867  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
3868 
3869  mask1 = mask0 + 2;
3870 
3871  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
3872  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
3873 
3874  const_vec = __msa_ldi_h(128);
3875  const_vec <<= 6;
3876 
3877  LD2(src1_ptr, src2_stride, tp0, tp1);
3878  src1_ptr += 2 * src2_stride;
3879  INSERT_D2_SH(tp0, tp1, in0);
3880  LD2(src1_ptr, src2_stride, tp0, tp1);
3881  INSERT_D2_SH(tp0, tp1, in1);
3882 
3883  ADDS_SH2_SH(in0, const_vec, in1, const_vec, in0, in1);
3884 
3885  VSHF_B2_SB(src0, src3, src0, src3, mask0, mask1, vec0, vec1);
3886  VSHF_B2_SB(src1, src4, src1, src4, mask0, mask1, vec2, vec3);
3887  VSHF_B2_SB(src2, src5, src2, src5, mask0, mask1, vec4, vec5);
3888  VSHF_B2_SB(src3, src6, src3, src6, mask0, mask1, vec6, vec7);
3889 
3890  dst30 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
3891  dst41 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
3892  dst52 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
3893  dst63 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
3894 
3895  ILVRL_H2_SH(dst41, dst30, dst10, dst43);
3896  ILVRL_H2_SH(dst52, dst41, dst21, dst54);
3897  ILVRL_H2_SH(dst63, dst52, dst32, dst65);
3898  dst0 = HEVC_FILT_4TAP(dst10, dst32, filt_h0, filt_h1);
3899  dst1 = HEVC_FILT_4TAP(dst21, dst43, filt_h0, filt_h1);
3900  dst2 = HEVC_FILT_4TAP(dst32, dst54, filt_h0, filt_h1);
3901  dst3 = HEVC_FILT_4TAP(dst43, dst65, filt_h0, filt_h1);
3902  SRA_4V(dst0, dst1, dst2, dst3, 6);
3903  PCKEV_H2_SH(dst1, dst0, dst3, dst2, tmp0, tmp1);
3904  ADDS_SH2_SH(tmp0, in0, tmp1, in1, tmp0, tmp1);
3905  SRARI_H2_SH(tmp0, tmp1, 7);
3906  CLIP_SH2_0_255_MAX_SATU(tmp0, tmp1);
3907  out = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
3908  ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
3909 }
3910 
3911 static void hevc_hv_bi_4t_4multx8mult_msa(uint8_t *src0_ptr,
3912  int32_t src_stride,
3913  int16_t *src1_ptr,
3914  int32_t src2_stride,
3915  uint8_t *dst,
3916  int32_t dst_stride,
3917  const int8_t *filter_x,
3918  const int8_t *filter_y,
3919  int32_t height)
3920 {
3921  uint32_t loop_cnt;
3922  uint64_t tp0, tp1;
3923  v16u8 out0, out1;
3924  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
3925  v8i16 filt0, filt1;
3926  v8i16 filt_h0, filt_h1;
3927  v16i8 mask0 = LD_SB(ff_hevc_mask_arr + 16);
3928  v16i8 mask1;
3929  v8i16 filter_vec, const_vec;
3930  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
3931  v8i16 tmp0, tmp1, tmp2, tmp3;
3932  v8i16 dst10, dst21, dst22, dst73, dst84, dst95, dst106;
3933  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
3934  v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
3935  v8i16 dst98_r, dst109_r;
3936  v8i16 in0 = { 0 }, in1 = { 0 }, in2 = { 0 }, in3 = { 0 };
3937  v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
3938 
3939  src0_ptr -= (src_stride + 1);
3940 
3941  filter_vec = LD_SH(filter_x);
3942  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3943 
3944  filter_vec = LD_SH(filter_y);
3945  UNPCK_R_SB_SH(filter_vec, filter_vec);
3946 
3947  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
3948 
3949  mask1 = mask0 + 2;
3950 
3951  const_vec = __msa_ldi_h(128);
3952  const_vec <<= 6;
3953 
3954  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3955  src0_ptr += (3 * src_stride);
3956  XORI_B3_128_SB(src0, src1, src2);
3957 
3958  VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
3959  VSHF_B2_SB(src1, src2, src1, src2, mask0, mask1, vec2, vec3);
3960  dst10 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
3961  dst21 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
3962  ILVRL_H2_SH(dst21, dst10, dst10_r, dst21_r);
3963  dst22 = (v8i16) __msa_splati_d((v2i64) dst21, 1);
3964 
3965 
3966  for (loop_cnt = height >> 3; loop_cnt--;) {
3967  LD_SB8(src0_ptr, src_stride,
3968  src3, src4, src5, src6, src7, src8, src9, src10);
3969  src0_ptr += (8 * src_stride);
3970  XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
3971  VSHF_B2_SB(src3, src7, src3, src7, mask0, mask1, vec0, vec1);
3972  VSHF_B2_SB(src4, src8, src4, src8, mask0, mask1, vec2, vec3);
3973  VSHF_B2_SB(src5, src9, src5, src9, mask0, mask1, vec4, vec5);
3974  VSHF_B2_SB(src6, src10, src6, src10, mask0, mask1, vec6, vec7);
3975 
3976  dst73 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
3977  dst84 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
3978  dst95 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
3979  dst106 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
3980 
3981  dst32_r = __msa_ilvr_h(dst73, dst22);
3982  ILVRL_H2_SH(dst84, dst73, dst43_r, dst87_r);
3983  ILVRL_H2_SH(dst95, dst84, dst54_r, dst98_r);
3984  ILVRL_H2_SH(dst106, dst95, dst65_r, dst109_r);
3985  dst22 = (v8i16) __msa_splati_d((v2i64) dst73, 1);
3986  dst76_r = __msa_ilvr_h(dst22, dst106);
3987 
3988  LD2(src1_ptr, src2_stride, tp0, tp1);
3989  src1_ptr += 2 * src2_stride;
3990  INSERT_D2_SH(tp0, tp1, in0);
3991  LD2(src1_ptr, src2_stride, tp0, tp1);
3992  src1_ptr += 2 * src2_stride;
3993  INSERT_D2_SH(tp0, tp1, in1);
3994 
3995  LD2(src1_ptr, src2_stride, tp0, tp1);
3996  src1_ptr += 2 * src2_stride;
3997  INSERT_D2_SH(tp0, tp1, in2);
3998  LD2(src1_ptr, src2_stride, tp0, tp1);
3999  src1_ptr += 2 * src2_stride;
4000  INSERT_D2_SH(tp0, tp1, in3);
4001 
4002  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3,
4003  const_vec, in0, in1, in2, in3);
4004  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4005  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4006  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4007  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4008  dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4009  dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4010  dst6_r = HEVC_FILT_4TAP(dst76_r, dst98_r, filt_h0, filt_h1);
4011  dst7_r = HEVC_FILT_4TAP(dst87_r, dst109_r, filt_h0, filt_h1);
4012  SRA_4V(dst0_r, dst1_r, dst2_r, dst3_r, 6);
4013  SRA_4V(dst4_r, dst5_r, dst6_r, dst7_r, 6);
4014  PCKEV_H4_SH(dst1_r, dst0_r, dst3_r, dst2_r,
4015  dst5_r, dst4_r, dst7_r, dst6_r, tmp0, tmp1, tmp2, tmp3);
4016  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3, tmp0, tmp1,
4017  tmp2, tmp3);
4018  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4019  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4020  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4021  ST4x8_UB(out0, out1, dst, dst_stride);
4022  dst += (8 * dst_stride);
4023 
4024  dst10_r = dst98_r;
4025  dst21_r = dst109_r;
4026  dst22 = (v8i16) __msa_splati_d((v2i64) dst106, 1);
4027  }
4028 }
4029 
4030 static void hevc_hv_bi_4t_4w_msa(uint8_t *src0_ptr,
4031  int32_t src_stride,
4032  int16_t *src1_ptr,
4033  int32_t src2_stride,
4034  uint8_t *dst,
4035  int32_t dst_stride,
4036  const int8_t *filter_x,
4037  const int8_t *filter_y,
4038  int32_t height)
4039 {
4040  if (2 == height) {
4041  hevc_hv_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4042  dst, dst_stride, filter_x, filter_y);
4043  } else if (4 == height) {
4044  hevc_hv_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4045  dst, dst_stride, filter_x, filter_y);
4046  } else if (0 == (height % 8)) {
4047  hevc_hv_bi_4t_4multx8mult_msa(src0_ptr, src_stride,
4048  src1_ptr, src2_stride,
4049  dst, dst_stride,
4050  filter_x, filter_y, height);
4051  }
4052 }
4053 
4054 static void hevc_hv_bi_4t_6w_msa(uint8_t *src0_ptr,
4055  int32_t src_stride,
4056  int16_t *src1_ptr,
4057  int32_t src2_stride,
4058  uint8_t *dst,
4059  int32_t dst_stride,
4060  const int8_t *filter_x,
4061  const int8_t *filter_y,
4062  int32_t height)
4063 {
4064  uint32_t tpw0, tpw1, tpw2, tpw3;
4065  uint64_t tp0, tp1;
4066  v16u8 out0, out1, out2;
4067  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
4068  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
4069  v8i16 filt0, filt1;
4070  v8i16 filt_h0, filt_h1;
4071  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
4072  v16i8 mask1;
4073  v8i16 filter_vec, const_vec;
4074  v8i16 dsth0, dsth1, dsth2, dsth3, dsth4, dsth5, dsth6, dsth7, dsth8, dsth9;
4075  v8i16 dsth10, tmp4, tmp5;
4076  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4077  v4i32 dst4_r, dst5_r, dst6_r, dst7_r;
4078  v8i16 tmp0, tmp1, tmp2, tmp3;
4079  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4080  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4081  v8i16 dst54_r, dst76_r, dst98_r, dst65_r, dst87_r, dst109_r;
4082  v8i16 dst54_l, dst76_l, dst98_l, dst65_l, dst87_l, dst109_l;
4083  v8i16 dst1021_l, dst3243_l, dst5465_l, dst7687_l, dst98109_l;
4084  v8i16 in0 = { 0 }, in1 = { 0 }, in2 = { 0 }, in3 = { 0 };
4085  v8i16 in4 = { 0 }, in5 = { 0 };
4086 
4087  src0_ptr -= (src_stride + 1);
4088 
4089  filter_vec = LD_SH(filter_x);
4090  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4091 
4092  filter_vec = LD_SH(filter_y);
4093  UNPCK_R_SB_SH(filter_vec, filter_vec);
4094 
4095  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4096 
4097  mask1 = mask0 + 2;
4098 
4099  const_vec = __msa_ldi_h(128);
4100  const_vec <<= 6;
4101 
4102  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
4103  src0_ptr += (3 * src_stride);
4104  XORI_B3_128_SB(src0, src1, src2);
4105 
4106  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4107  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4108  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4109 
4110  dsth0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4111  dsth1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4112  dsth2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4113 
4114  ILVRL_H2_SH(dsth1, dsth0, dst10_r, dst10_l);
4115  ILVRL_H2_SH(dsth2, dsth1, dst21_r, dst21_l);
4116 
4117  LD_SB8(src0_ptr, src_stride,
4118  src3, src4, src5, src6, src7, src8, src9, src10);
4119  XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
4120 
4121  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4122  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec2, vec3);
4123  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec4, vec5);
4124  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec6, vec7);
4125 
4126  dsth3 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4127  dsth4 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4128  dsth5 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4129  dsth6 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4130 
4131  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
4132  VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec2, vec3);
4133  VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec4, vec5);
4134  VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec6, vec7);
4135 
4136  dsth7 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4137  dsth8 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4138  dsth9 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4139  dsth10 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4140 
4141  ILVRL_H2_SH(dsth3, dsth2, dst32_r, dst32_l);
4142  ILVRL_H2_SH(dsth4, dsth3, dst43_r, dst43_l);
4143  ILVRL_H2_SH(dsth5, dsth4, dst54_r, dst54_l);
4144  ILVRL_H2_SH(dsth6, dsth5, dst65_r, dst65_l);
4145  ILVRL_H2_SH(dsth7, dsth6, dst76_r, dst76_l);
4146  ILVRL_H2_SH(dsth8, dsth7, dst87_r, dst87_l);
4147  ILVRL_H2_SH(dsth9, dsth8, dst98_r, dst98_l);
4148  ILVRL_H2_SH(dsth10, dsth9, dst109_r, dst109_l);
4149  PCKEV_D2_SH(dst21_l, dst10_l, dst43_l, dst32_l, dst1021_l, dst3243_l);
4150  PCKEV_D2_SH(dst65_l, dst54_l, dst87_l, dst76_l, dst5465_l, dst7687_l);
4151  dst98109_l = (v8i16) __msa_pckev_d((v2i64) dst109_l, (v2i64) dst98_l);
4152 
4153  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4154  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4155  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4156  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4157  dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4158  dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4159  dst6_r = HEVC_FILT_4TAP(dst76_r, dst98_r, filt_h0, filt_h1);
4160  dst7_r = HEVC_FILT_4TAP(dst87_r, dst109_r, filt_h0, filt_h1);
4161  dst0_l = HEVC_FILT_4TAP(dst1021_l, dst3243_l, filt_h0, filt_h1);
4162  dst1_l = HEVC_FILT_4TAP(dst3243_l, dst5465_l, filt_h0, filt_h1);
4163  dst2_l = HEVC_FILT_4TAP(dst5465_l, dst7687_l, filt_h0, filt_h1);
4164  dst3_l = HEVC_FILT_4TAP(dst7687_l, dst98109_l, filt_h0, filt_h1);
4165  SRA_4V(dst0_r, dst1_r, dst2_r, dst3_r, 6);
4166  SRA_4V(dst4_r, dst5_r, dst6_r, dst7_r, 6);
4167  SRA_4V(dst0_l, dst1_l, dst2_l, dst3_l, 6);
4168  PCKEV_H2_SH(dst1_r, dst0_r, dst3_r, dst2_r, tmp0, tmp1);
4169  PCKEV_H2_SH(dst5_r, dst4_r, dst7_r, dst6_r, tmp2, tmp3);
4170  PCKEV_H2_SH(dst1_l, dst0_l, dst3_l, dst2_l, tmp4, tmp5);
4171 
4172  LD2(src1_ptr, src2_stride, tp0, tp1);
4173  INSERT_D2_SH(tp0, tp1, in0);
4174  LD2(src1_ptr + 2 * src2_stride, src2_stride, tp0, tp1);
4175  INSERT_D2_SH(tp0, tp1, in1);
4176 
4177  LD2(src1_ptr + 4 * src2_stride, src2_stride, tp0, tp1);
4178  INSERT_D2_SH(tp0, tp1, in2);
4179  LD2(src1_ptr + 6 * src2_stride, src2_stride, tp0, tp1);
4180  INSERT_D2_SH(tp0, tp1, in3);
4181 
4182  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3, const_vec,
4183  in0, in1, in2, in3);
4184  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3, tmp0, tmp1, tmp2,
4185  tmp3);
4186  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4187  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4188  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4189  ST4x8_UB(out0, out1, dst, dst_stride);
4190 
4191  LW4(src1_ptr + 4, src2_stride, tpw0, tpw1, tpw2, tpw3);
4192  src1_ptr += (4 * src2_stride);
4193  INSERT_W4_SH(tpw0, tpw1, tpw2, tpw3, in4);
4194  LW4(src1_ptr + 4, src2_stride, tpw0, tpw1, tpw2, tpw3);
4195  INSERT_W4_SH(tpw0, tpw1, tpw2, tpw3, in5);
4196  ADDS_SH2_SH(in4, const_vec, in5, const_vec, in4, in5);
4197  ADDS_SH2_SH(in4, tmp4, in5, tmp5, tmp4, tmp5);
4198  SRARI_H2_SH(tmp4, tmp5, 7);
4199  CLIP_SH2_0_255_MAX_SATU(tmp4, tmp5);
4200  out2 = (v16u8) __msa_pckev_b((v16i8) tmp5, (v16i8) tmp4);
4201  ST2x4_UB(out2, 0, dst + 4, dst_stride);
4202  dst += 4 * dst_stride;
4203  ST2x4_UB(out2, 4, dst + 4, dst_stride);
4204 }
4205 
4206 static void hevc_hv_bi_4t_8x2_msa(uint8_t *src0_ptr,
4207  int32_t src_stride,
4208  int16_t *src1_ptr,
4209  int32_t src2_stride,
4210  uint8_t *dst,
4211  int32_t dst_stride,
4212  const int8_t *filter_x,
4213  const int8_t *filter_y)
4214 {
4215  v16u8 out;
4216  v16i8 src0, src1, src2, src3, src4;
4217  v8i16 filt0, filt1;
4218  v8i16 filt_h0, filt_h1;
4219  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
4220  v16i8 mask1;
4221  v8i16 filter_vec, const_vec;
4222  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
4223  v8i16 dst0, dst1, dst2, dst3, dst4;
4224  v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
4225  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4226  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4227  v8i16 tmp0, tmp1;
4228  v8i16 in0, in1;
4229 
4230  src0_ptr -= (src_stride + 1);
4231 
4232  filter_vec = LD_SH(filter_x);
4233  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4234 
4235  filter_vec = LD_SH(filter_y);
4236  UNPCK_R_SB_SH(filter_vec, filter_vec);
4237 
4238  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4239 
4240  mask1 = mask0 + 2;
4241 
4242  const_vec = __msa_ldi_h(128);
4243  const_vec <<= 6;
4244 
4245  LD_SB5(src0_ptr, src_stride, src0, src1, src2, src3, src4);
4246  XORI_B5_128_SB(src0, src1, src2, src3, src4);
4247 
4248  LD_SH2(src1_ptr, src2_stride, in0, in1);
4249  ADDS_SH2_SH(in0, const_vec, in1, const_vec, in0, in1);
4250 
4251  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4252  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4253  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4254  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec6, vec7);
4255  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec8, vec9);
4256 
4257  dst0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4258  dst1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4259  dst2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4260  dst3 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4261  dst4 = HEVC_FILT_4TAP_SH(vec8, vec9, filt0, filt1);
4262 
4263  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4264  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4265  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4266  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4267  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4268  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4269  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4270  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4271  SRA_4V(dst0_r, dst0_l, dst1_r, dst1_l, 6);
4272  PCKEV_H2_SH(dst0_l, dst0_r, dst1_l, dst1_r, tmp0, tmp1);
4273  ADDS_SH2_SH(in0, tmp0, in1, tmp1, tmp0, tmp1);
4274  SRARI_H2_SH(tmp0, tmp1, 7);
4275  CLIP_SH2_0_255_MAX_SATU(tmp0, tmp1);
4276  out = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
4277  ST8x2_UB(out, dst, dst_stride);
4278 }
4279 
4280 static void hevc_hv_bi_4t_8multx4_msa(uint8_t *src0_ptr,
4281  int32_t src_stride,
4282  int16_t *src1_ptr,
4283  int32_t src2_stride,
4284  uint8_t *dst,
4285  int32_t dst_stride,
4286  const int8_t *filter_x,
4287  const int8_t *filter_y,
4288  int32_t width8mult)
4289 {
4290  uint32_t cnt;
4291  v16u8 out0, out1;
4292  v16i8 src0, src1, src2, src3, src4, src5, src6, mask0, mask1;
4293  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
4294  v8i16 filt0, filt1, filt_h0, filt_h1, filter_vec, const_vec;
4295  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, tmp0, tmp1, tmp2, tmp3;
4296  v8i16 in0, in1, in2, in3;
4297  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4298  v8i16 dst10_r, dst32_r, dst54_r, dst21_r, dst43_r, dst65_r;
4299  v8i16 dst10_l, dst32_l, dst54_l, dst21_l, dst43_l, dst65_l;
4300 
4301  src0_ptr -= (src_stride + 1);
4302 
4303  filter_vec = LD_SH(filter_x);
4304  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4305 
4306  filter_vec = LD_SH(filter_y);
4307  UNPCK_R_SB_SH(filter_vec, filter_vec);
4308 
4309  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4310 
4311  mask0 = LD_SB(ff_hevc_mask_arr);
4312  mask1 = mask0 + 2;
4313 
4314  const_vec = __msa_ldi_h(128);
4315  const_vec <<= 6;
4316 
4317  for (cnt = width8mult; cnt--;) {
4318  LD_SB7(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5, src6);
4319  src0_ptr += 8;
4320  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
4321 
4322  LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
4323  src1_ptr += 8;
4324  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3,
4325  const_vec, in0, in1, in2, in3);
4326 
4327  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4328  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4329  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4330 
4331  dst0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4332  dst1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4333  dst2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4334 
4335  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4336  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4337 
4338  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4339  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec2, vec3);
4340  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec4, vec5);
4341  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec6, vec7);
4342 
4343  dst3 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4344  dst4 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4345  dst5 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4346  dst6 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4347 
4348  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4349  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4350  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
4351  ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
4352 
4353  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4354  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4355  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4356  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4357  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4358  dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
4359  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4360  dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
4361 
4362  SRA_4V(dst0_r, dst0_l, dst1_r, dst1_l, 6);
4363  SRA_4V(dst2_r, dst2_l, dst3_r, dst3_l, 6);
4364  PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst2_l, dst2_r, dst3_l,
4365  dst3_r, tmp0, tmp1, tmp2, tmp3);
4366  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3,
4367  tmp0, tmp1, tmp2, tmp3);
4368  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4369  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4370  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4371  ST8x4_UB(out0, out1, dst, dst_stride);
4372  dst += 8;
4373  }
4374 }
4375 
4376 static void hevc_hv_bi_4t_8x6_msa(uint8_t *src0_ptr,
4377  int32_t src_stride,
4378  int16_t *src1_ptr,
4379  int32_t src2_stride,
4380  uint8_t *dst,
4381  int32_t dst_stride,
4382  const int8_t *filter_x,
4383  const int8_t *filter_y)
4384 {
4385  v16u8 out0, out1, out2;
4386  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
4387  v8i16 in0, in1, in2, in3, in4, in5;
4388  v8i16 filt0, filt1;
4389  v8i16 filt_h0, filt_h1;
4390  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
4391  v16i8 mask1;
4392  v8i16 filter_vec, const_vec;
4393  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
4394  v16i8 vec10, vec11, vec12, vec13, vec14, vec15, vec16, vec17;
4395  v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
4396  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
4397  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4398  v4i32 dst4_r, dst4_l, dst5_r, dst5_l;
4399  v8i16 dst10_r, dst32_r, dst10_l, dst32_l;
4400  v8i16 dst21_r, dst43_r, dst21_l, dst43_l;
4401  v8i16 dst54_r, dst54_l, dst65_r, dst65_l;
4402  v8i16 dst76_r, dst76_l, dst87_r, dst87_l;
4403 
4404  src0_ptr -= (src_stride + 1);
4405 
4406  filter_vec = LD_SH(filter_x);
4407  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4408 
4409  filter_vec = LD_SH(filter_y);
4410  UNPCK_R_SB_SH(filter_vec, filter_vec);
4411 
4412  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4413 
4414  mask1 = mask0 + 2;
4415 
4416  const_vec = __msa_ldi_h(128);
4417  const_vec <<= 6;
4418 
4419  LD_SB5(src0_ptr, src_stride, src0, src1, src2, src3, src4);
4420  src0_ptr += (5 * src_stride);
4421  LD_SB4(src0_ptr, src_stride, src5, src6, src7, src8);
4422 
4423  XORI_B5_128_SB(src0, src1, src2, src3, src4);
4424  XORI_B4_128_SB(src5, src6, src7, src8);
4425 
4426  LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
4427  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3, const_vec,
4428  in0, in1, in2, in3);
4429  ADDS_SH2_SH(in4, const_vec, in5, const_vec, in4, in5);
4430 
4431  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4432  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4433  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4434  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec6, vec7);
4435  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec8, vec9);
4436  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec10, vec11);
4437  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec12, vec13);
4438  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec14, vec15);
4439  VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec16, vec17);
4440 
4441  dst0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4442  dst1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4443  dst2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4444  dst3 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4445  dst4 = HEVC_FILT_4TAP_SH(vec8, vec9, filt0, filt1);
4446  dst5 = HEVC_FILT_4TAP_SH(vec10, vec11, filt0, filt1);
4447  dst6 = HEVC_FILT_4TAP_SH(vec12, vec13, filt0, filt1);
4448  dst7 = HEVC_FILT_4TAP_SH(vec14, vec15, filt0, filt1);
4449  dst8 = HEVC_FILT_4TAP_SH(vec16, vec17, filt0, filt1);
4450 
4451  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4452  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4453  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4454  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4455  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
4456  ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
4457  ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
4458  ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
4459 
4460  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4461  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4462  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4463  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4464  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4465  dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
4466  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4467  dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
4468  dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4469  dst4_l = HEVC_FILT_4TAP(dst54_l, dst76_l, filt_h0, filt_h1);
4470  dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4471  dst5_l = HEVC_FILT_4TAP(dst65_l, dst87_l, filt_h0, filt_h1);
4472 
4473  SRA_4V(dst0_r, dst0_l, dst1_r, dst1_l, 6);
4474  SRA_4V(dst2_r, dst2_l, dst3_r, dst3_l, 6);
4475  SRA_4V(dst4_r, dst4_l, dst5_r, dst5_l, 6);
4476  PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst2_l, dst2_r, dst3_l, dst3_r,
4477  tmp0, tmp1, tmp2, tmp3);
4478  PCKEV_H2_SH(dst4_l, dst4_r, dst5_l, dst5_r, tmp4, tmp5);
4479  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3,
4480  tmp0, tmp1, tmp2, tmp3);
4481  ADDS_SH2_SH(in4, tmp4, in5, tmp5, tmp4, tmp5);
4482  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4483  SRARI_H2_SH(tmp4, tmp5, 7);
4484  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4485  CLIP_SH2_0_255_MAX_SATU(tmp4, tmp5);
4486  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4487  out2 = (v16u8) __msa_pckev_b((v16i8) tmp5, (v16i8) tmp4);
4488  ST8x4_UB(out0, out1, dst, dst_stride);
4489  dst += (4 * dst_stride);
4490  ST8x2_UB(out2, dst, dst_stride);
4491 }
4492 
4493 static void hevc_hv_bi_4t_8multx4mult_msa(uint8_t *src0_ptr,
4494  int32_t src_stride,
4495  int16_t *src1_ptr,
4496  int32_t src2_stride,
4497  uint8_t *dst,
4498  int32_t dst_stride,
4499  const int8_t *filter_x,
4500  const int8_t *filter_y,
4501  int32_t height,
4502  int32_t width)
4503 {
4504  uint32_t loop_cnt, cnt;
4505  uint8_t *src0_ptr_tmp;
4506  int16_t *src1_ptr_tmp;
4507  uint8_t *dst_tmp;
4508  v16u8 out0, out1;
4509  v16i8 src0, src1, src2, src3, src4, src5, src6;
4510  v8i16 in0, in1, in2, in3;
4511  v8i16 filt0, filt1;
4512  v8i16 filt_h0, filt_h1;
4513  v16i8 mask0 = LD_SB(ff_hevc_mask_arr);
4514  v16i8 mask1;
4515  v8i16 filter_vec, const_vec;
4516  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
4517  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
4518  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4519  v8i16 tmp0, tmp1, tmp2, tmp3;
4520  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4521  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4522  v8i16 dst54_r, dst54_l, dst65_r, dst65_l, dst6;
4523 
4524  src0_ptr -= (src_stride + 1);
4525 
4526  filter_vec = LD_SH(filter_x);
4527  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4528 
4529  filter_vec = LD_SH(filter_y);
4530  UNPCK_R_SB_SH(filter_vec, filter_vec);
4531 
4532  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4533 
4534  mask1 = mask0 + 2;
4535 
4536  const_vec = __msa_ldi_h(128);
4537  const_vec <<= 6;
4538 
4539  for (cnt = width >> 3; cnt--;) {
4540  src0_ptr_tmp = src0_ptr;
4541  dst_tmp = dst;
4542  src1_ptr_tmp = src1_ptr;
4543 
4544  LD_SB3(src0_ptr_tmp, src_stride, src0, src1, src2);
4545  src0_ptr_tmp += (3 * src_stride);
4546  XORI_B3_128_SB(src0, src1, src2);
4547 
4548  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4549  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4550  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4551 
4552  dst0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4553  dst1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4554  dst2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4555 
4556  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4557  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4558 
4559  for (loop_cnt = height >> 2; loop_cnt--;) {
4560  LD_SB4(src0_ptr_tmp, src_stride, src3, src4, src5, src6);
4561  src0_ptr_tmp += (4 * src_stride);
4562  LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
4563  src1_ptr_tmp += (4 * src2_stride);
4564  XORI_B4_128_SB(src3, src4, src5, src6);
4565 
4566  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3,
4567  const_vec, in0, in1, in2, in3);
4568 
4569  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4570  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec2, vec3);
4571  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec4, vec5);
4572  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec6, vec7);
4573 
4574  dst3 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4575  dst4 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4576  dst5 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4577  dst6 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4578 
4579  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4580  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4581  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
4582  ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
4583 
4584  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4585  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4586  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4587  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4588  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4589  dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
4590  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4591  dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
4592 
4593  SRA_4V(dst0_r, dst0_l, dst1_r, dst1_l, 6);
4594  SRA_4V(dst2_r, dst2_l, dst3_r, dst3_l, 6);
4595  PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst2_l, dst2_r, dst3_l,
4596  dst3_r, tmp0, tmp1, tmp2, tmp3);
4597  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3,
4598  tmp0, tmp1, tmp2, tmp3);
4599  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4600  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4601  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4602  ST8x4_UB(out0, out1, dst_tmp, dst_stride);
4603  dst_tmp += (4 * dst_stride);
4604 
4605  dst10_r = dst54_r;
4606  dst10_l = dst54_l;
4607  dst21_r = dst65_r;
4608  dst21_l = dst65_l;
4609  dst2 = dst6;
4610  }
4611 
4612  src0_ptr += 8;
4613  dst += 8;
4614  src1_ptr += 8;
4615  }
4616 }
4617 
4618 static void hevc_hv_bi_4t_8w_msa(uint8_t *src0_ptr,
4619  int32_t src_stride,
4620  int16_t *src1_ptr,
4621  int32_t src2_stride,
4622  uint8_t *dst,
4623  int32_t dst_stride,
4624  const int8_t *filter_x,
4625  const int8_t *filter_y,
4626  int32_t height)
4627 {
4628  if (2 == height) {
4629  hevc_hv_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4630  dst, dst_stride, filter_x, filter_y);
4631  } else if (4 == height) {
4632  hevc_hv_bi_4t_8multx4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4633  dst, dst_stride, filter_x, filter_y, 1);
4634  } else if (6 == height) {
4635  hevc_hv_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4636  dst, dst_stride, filter_x, filter_y);
4637  } else {
4638  hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride,
4639  src1_ptr, src2_stride,
4640  dst, dst_stride,
4641  filter_x, filter_y, height, 8);
4642  }
4643 }
4644 
4645 static void hevc_hv_bi_4t_12w_msa(uint8_t *src0_ptr,
4646  int32_t src_stride,
4647  int16_t *src1_ptr,
4648  int32_t src2_stride,
4649  uint8_t *dst,
4650  int32_t dst_stride,
4651  const int8_t *filter_x,
4652  const int8_t *filter_y,
4653  int32_t height)
4654 {
4655  uint32_t loop_cnt;
4656  uint64_t tp0, tp1;
4657  uint8_t *src0_ptr_tmp, *dst_tmp;
4658  int16_t *src1_ptr_tmp;
4659  v16u8 out0, out1;
4660  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
4661  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
4662  v16i8 mask0, mask1, mask2, mask3;
4663  v8i16 filt0, filt1, filt_h0, filt_h1, filter_vec, tmp0, tmp1, tmp2, tmp3;
4664  v8i16 dsth0, dsth1, dsth2, dsth3, dsth4, dsth5, dsth6, const_vec;
4665  v8i16 dst10, dst21, dst22, dst73, dst84, dst95, dst106;
4666  v8i16 dst76_r, dst98_r, dst87_r, dst109_r;
4667  v8i16 in0 = { 0 }, in1 = { 0 }, in2 = { 0 }, in3 = { 0 };
4668  v8i16 dst10_r, dst32_r, dst54_r, dst21_r, dst43_r, dst65_r;
4669  v8i16 dst10_l, dst32_l, dst54_l, dst21_l, dst43_l, dst65_l;
4670  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4671  v4i32 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
4672 
4673  src0_ptr -= (src_stride + 1);
4674 
4675  filter_vec = LD_SH(filter_x);
4676  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4677 
4678  filter_vec = LD_SH(filter_y);
4679  UNPCK_R_SB_SH(filter_vec, filter_vec);
4680 
4681  SPLATI_W2_SH(filter_vec, 0, filt_h0, filt_h1);
4682 
4683  mask0 = LD_SB(ff_hevc_mask_arr);
4684  mask1 = mask0 + 2;
4685 
4686  const_vec = __msa_ldi_h(128);
4687  const_vec <<= 6;
4688 
4689  src0_ptr_tmp = src0_ptr;
4690  dst_tmp = dst;
4691  src1_ptr_tmp = src1_ptr;
4692 
4693  LD_SB3(src0_ptr_tmp, src_stride, src0, src1, src2);
4694  src0_ptr_tmp += (3 * src_stride);
4695 
4696  XORI_B3_128_SB(src0, src1, src2);
4697 
4698  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4699  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4700  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4701 
4702  dsth0 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4703  dsth1 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4704  dsth2 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4705 
4706  ILVRL_H2_SH(dsth1, dsth0, dst10_r, dst10_l);
4707  ILVRL_H2_SH(dsth2, dsth1, dst21_r, dst21_l);
4708 
4709  for (loop_cnt = 4; loop_cnt--;) {
4710  LD_SB4(src0_ptr_tmp, src_stride, src3, src4, src5, src6);
4711  src0_ptr_tmp += (4 * src_stride);
4712  XORI_B4_128_SB(src3, src4, src5, src6);
4713 
4714  LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
4715  src1_ptr_tmp += (4 * src2_stride);
4716  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3,
4717  const_vec, in0, in1, in2, in3);
4718 
4719  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4720  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec2, vec3);
4721  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec4, vec5);
4722  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec6, vec7);
4723 
4724  dsth3 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4725  dsth4 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4726  dsth5 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4727  dsth6 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4728 
4729  ILVRL_H2_SH(dsth3, dsth2, dst32_r, dst32_l);
4730  ILVRL_H2_SH(dsth4, dsth3, dst43_r, dst43_l);
4731  ILVRL_H2_SH(dsth5, dsth4, dst54_r, dst54_l);
4732  ILVRL_H2_SH(dsth6, dsth5, dst65_r, dst65_l);
4733 
4734  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4735  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4736  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4737  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4738  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4739  dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
4740  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4741  dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
4742 
4743  SRA_4V(dst0_r, dst0_l, dst1_r, dst1_l, 6);
4744  SRA_4V(dst2_r, dst2_l, dst3_r, dst3_l, 6);
4745  PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst2_l, dst2_r, dst3_l,
4746  dst3_r, tmp0, tmp1, tmp2, tmp3);
4747  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3,
4748  tmp0, tmp1, tmp2, tmp3);
4749  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4750  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4751  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4752  ST8x4_UB(out0, out1, dst_tmp, dst_stride);
4753  dst_tmp += (4 * dst_stride);
4754 
4755  dst10_r = dst54_r;
4756  dst10_l = dst54_l;
4757  dst21_r = dst65_r;
4758  dst21_l = dst65_l;
4759  dsth2 = dsth6;
4760  }
4761 
4762  src0_ptr += 8;
4763  dst += 8;
4764  src1_ptr += 8;
4765 
4766  mask2 = LD_SB(ff_hevc_mask_arr + 16);
4767  mask3 = mask2 + 2;
4768 
4769  LD_SB3(src0_ptr, src_stride, src0, src1, src2);
4770  src0_ptr += (3 * src_stride);
4771  XORI_B3_128_SB(src0, src1, src2);
4772  VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
4773  VSHF_B2_SB(src1, src2, src1, src2, mask2, mask3, vec2, vec3);
4774 
4775  dst10 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4776  dst21 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4777 
4778  ILVRL_H2_SH(dst21, dst10, dst10_r, dst21_r);
4779  dst22 = (v8i16) __msa_splati_d((v2i64) dst21, 1);
4780 
4781  for (loop_cnt = 2; loop_cnt--;) {
4782  LD_SB8(src0_ptr, src_stride,
4783  src3, src4, src5, src6, src7, src8, src9, src10);
4784  src0_ptr += (8 * src_stride);
4785  XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
4786  VSHF_B2_SB(src3, src7, src3, src7, mask2, mask3, vec0, vec1);
4787  VSHF_B2_SB(src4, src8, src4, src8, mask2, mask3, vec2, vec3);
4788  VSHF_B2_SB(src5, src9, src5, src9, mask2, mask3, vec4, vec5);
4789  VSHF_B2_SB(src6, src10, src6, src10, mask2, mask3, vec6, vec7);
4790 
4791  dst73 = HEVC_FILT_4TAP_SH(vec0, vec1, filt0, filt1);
4792  dst84 = HEVC_FILT_4TAP_SH(vec2, vec3, filt0, filt1);
4793  dst95 = HEVC_FILT_4TAP_SH(vec4, vec5, filt0, filt1);
4794  dst106 = HEVC_FILT_4TAP_SH(vec6, vec7, filt0, filt1);
4795 
4796  dst32_r = __msa_ilvr_h(dst73, dst22);
4797  ILVRL_H2_SH(dst84, dst73, dst43_r, dst87_r);
4798  ILVRL_H2_SH(dst95, dst84, dst54_r, dst98_r);
4799  ILVRL_H2_SH(dst106, dst95, dst65_r, dst109_r);
4800  dst22 = (v8i16) __msa_splati_d((v2i64) dst73, 1);
4801  dst76_r = __msa_ilvr_h(dst22, dst106);
4802 
4803  LD2(src1_ptr, src2_stride, tp0, tp1);
4804  src1_ptr += 2 * src2_stride;
4805  INSERT_D2_SH(tp0, tp1, in0);
4806  LD2(src1_ptr, src2_stride, tp0, tp1);
4807  src1_ptr += 2 * src2_stride;
4808  INSERT_D2_SH(tp0, tp1, in1);
4809 
4810  LD2(src1_ptr, src2_stride, tp0, tp1);
4811  src1_ptr += 2 * src2_stride;
4812  INSERT_D2_SH(tp0, tp1, in2);
4813  LD2(src1_ptr, src2_stride, tp0, tp1);
4814  src1_ptr += 2 * src2_stride;
4815  INSERT_D2_SH(tp0, tp1, in3);
4816 
4817  ADDS_SH4_SH(in0, const_vec, in1, const_vec, in2, const_vec, in3,
4818  const_vec, in0, in1, in2, in3);
4819 
4820  dst0 = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4821  dst1 = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4822  dst2 = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4823  dst3 = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4824  dst4 = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4825  dst5 = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4826  dst6 = HEVC_FILT_4TAP(dst76_r, dst98_r, filt_h0, filt_h1);
4827  dst7 = HEVC_FILT_4TAP(dst87_r, dst109_r, filt_h0, filt_h1);
4828 
4829  SRA_4V(dst0, dst1, dst2, dst3, 6);
4830  SRA_4V(dst4, dst5, dst6, dst7, 6);
4831  PCKEV_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6,
4832  tmp0, tmp1, tmp2, tmp3);
4833  ADDS_SH4_SH(in0, tmp0, in1, tmp1, in2, tmp2, in3, tmp3,
4834  tmp0, tmp1, tmp2, tmp3);
4835  SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
4836  CLIP_SH4_0_255_MAX_SATU(tmp0, tmp1, tmp2, tmp3);
4837  PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, out0, out1);
4838  ST4x8_UB(out0, out1, dst, dst_stride);
4839  dst += (8 * dst_stride);
4840 
4841  dst10_r = dst98_r;
4842  dst21_r = dst109_r;
4843  dst22 = (v8i16) __msa_splati_d((v2i64) dst106, 1);
4844  }
4845 }
4846 
4847 static void hevc_hv_bi_4t_16w_msa(uint8_t *src0_ptr,
4848  int32_t src_stride,
4849  int16_t *src1_ptr,
4850  int32_t src2_stride,
4851  uint8_t *dst,
4852  int32_t dst_stride,
4853  const int8_t *filter_x,
4854  const int8_t *filter_y,
4855  int32_t height)
4856 {
4857  if (4 == height) {
4858  hevc_hv_bi_4t_8multx4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4859  dst, dst_stride, filter_x, filter_y, 2);
4860  } else {
4861  hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr,
4862  src2_stride, dst, dst_stride, filter_x,
4863  filter_y, height, 16);
4864  }
4865 }
4866 
4867 static void hevc_hv_bi_4t_24w_msa(uint8_t *src0_ptr,
4868  int32_t src_stride,
4869  int16_t *src1_ptr,
4870  int32_t src2_stride,
4871  uint8_t *dst,
4872  int32_t dst_stride,
4873  const int8_t *filter_x,
4874  const int8_t *filter_y,
4875  int32_t height)
4876 {
4877  hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4878  dst, dst_stride, filter_x, filter_y,
4879  height, 24);
4880 }
4881 
4882 static void hevc_hv_bi_4t_32w_msa(uint8_t *src0_ptr,
4883  int32_t src_stride,
4884  int16_t *src1_ptr,
4885  int32_t src2_stride,
4886  uint8_t *dst,
4887  int32_t dst_stride,
4888  const int8_t *filter_x,
4889  const int8_t *filter_y,
4890  int32_t height)
4891 {
4892  hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4893  dst, dst_stride, filter_x, filter_y,
4894  height, 32);
4895 }
4896 
4897 #define BI_MC_COPY(WIDTH) \
4898 void ff_hevc_put_hevc_bi_pel_pixels##WIDTH##_8_msa(uint8_t *dst, \
4899  ptrdiff_t dst_stride, \
4900  uint8_t *src, \
4901  ptrdiff_t src_stride, \
4902  int16_t *src_16bit, \
4903  int height, \
4904  intptr_t mx, \
4905  intptr_t my, \
4906  int width) \
4907 { \
4908  hevc_bi_copy_##WIDTH##w_msa(src, src_stride, src_16bit, MAX_PB_SIZE, \
4909  dst, dst_stride, height); \
4910 }
4911 
4912 BI_MC_COPY(4);
4913 BI_MC_COPY(6);
4914 BI_MC_COPY(8);
4915 BI_MC_COPY(12);
4916 BI_MC_COPY(16);
4917 BI_MC_COPY(24);
4918 BI_MC_COPY(32);
4919 BI_MC_COPY(48);
4920 BI_MC_COPY(64);
4921 
4922 #undef BI_MC_COPY
4923 
4924 #define BI_MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR) \
4925 void ff_hevc_put_hevc_bi_##PEL##_##DIR##WIDTH##_8_msa(uint8_t *dst, \
4926  ptrdiff_t dst_stride, \
4927  uint8_t *src, \
4928  ptrdiff_t src_stride, \
4929  int16_t *src_16bit, \
4930  int height, \
4931  intptr_t mx, \
4932  intptr_t my, \
4933  int width) \
4934 { \
4935  const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1]; \
4936  \
4937  hevc_##DIR1##_bi_##TAP##t_##WIDTH##w_msa(src, src_stride, src_16bit, \
4938  MAX_PB_SIZE, dst, dst_stride, \
4939  filter, height); \
4940 }
4941 
4942 BI_MC(qpel, h, 4, 8, hz, mx);
4943 BI_MC(qpel, h, 8, 8, hz, mx);
4944 BI_MC(qpel, h, 12, 8, hz, mx);
4945 BI_MC(qpel, h, 16, 8, hz, mx);
4946 BI_MC(qpel, h, 24, 8, hz, mx);
4947 BI_MC(qpel, h, 32, 8, hz, mx);
4948 BI_MC(qpel, h, 48, 8, hz, mx);
4949 BI_MC(qpel, h, 64, 8, hz, mx);
4950 
4951 BI_MC(qpel, v, 4, 8, vt, my);
4952 BI_MC(qpel, v, 8, 8, vt, my);
4953 BI_MC(qpel, v, 12, 8, vt, my);
4954 BI_MC(qpel, v, 16, 8, vt, my);
4955 BI_MC(qpel, v, 24, 8, vt, my);
4956 BI_MC(qpel, v, 32, 8, vt, my);
4957 BI_MC(qpel, v, 48, 8, vt, my);
4958 BI_MC(qpel, v, 64, 8, vt, my);
4959 
4960 BI_MC(epel, h, 4, 4, hz, mx);
4961 BI_MC(epel, h, 8, 4, hz, mx);
4962 BI_MC(epel, h, 6, 4, hz, mx);
4963 BI_MC(epel, h, 12, 4, hz, mx);
4964 BI_MC(epel, h, 16, 4, hz, mx);
4965 BI_MC(epel, h, 24, 4, hz, mx);
4966 BI_MC(epel, h, 32, 4, hz, mx);
4967 
4968 BI_MC(epel, v, 4, 4, vt, my);
4969 BI_MC(epel, v, 8, 4, vt, my);
4970 BI_MC(epel, v, 6, 4, vt, my);
4971 BI_MC(epel, v, 12, 4, vt, my);
4972 BI_MC(epel, v, 16, 4, vt, my);
4973 BI_MC(epel, v, 24, 4, vt, my);
4974 BI_MC(epel, v, 32, 4, vt, my);
4975 
4976 #undef BI_MC
4977 
4978 #define BI_MC_HV(PEL, WIDTH, TAP) \
4979 void ff_hevc_put_hevc_bi_##PEL##_hv##WIDTH##_8_msa(uint8_t *dst, \
4980  ptrdiff_t dst_stride, \
4981  uint8_t *src, \
4982  ptrdiff_t src_stride, \
4983  int16_t *src_16bit, \
4984  int height, \
4985  intptr_t mx, \
4986  intptr_t my, \
4987  int width) \
4988 { \
4989  const int8_t *filter_x = ff_hevc_##PEL##_filters[mx - 1]; \
4990  const int8_t *filter_y = ff_hevc_##PEL##_filters[my - 1]; \
4991  \
4992  hevc_hv_bi_##TAP##t_##WIDTH##w_msa(src, src_stride, src_16bit, \
4993  MAX_PB_SIZE, dst, dst_stride, \
4994  filter_x, filter_y, height); \
4995 }
4996 
4997 BI_MC_HV(qpel, 4, 8);
4998 BI_MC_HV(qpel, 8, 8);
4999 BI_MC_HV(qpel, 12, 8);
5000 BI_MC_HV(qpel, 16, 8);
5001 BI_MC_HV(qpel, 24, 8);
5002 BI_MC_HV(qpel, 32, 8);
5003 BI_MC_HV(qpel, 48, 8);
5004 BI_MC_HV(qpel, 64, 8);
5005 
5006 BI_MC_HV(epel, 4, 4);
5007 BI_MC_HV(epel, 8, 4);
5008 BI_MC_HV(epel, 6, 4);
5009 BI_MC_HV(epel, 12, 4);
5010 BI_MC_HV(epel, 16, 4);
5011 BI_MC_HV(epel, 24, 4);
5012 BI_MC_HV(epel, 32, 4);
5013 
5014 #undef BI_MC_HV
VSHF_B4_SB
#define VSHF_B4_SB(...)
Definition: generic_macros_msa.h:778
hevc_vt_bi_8t_32w_msa
static void hevc_vt_bi_8t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1573
HEVC_BI_RND_CLIP2
#define HEVC_BI_RND_CLIP2(in0, in1, vec0, vec1, rnd_val, out0, out1)
Definition: hevc_mc_bi_msa.c:31
XORI_B5_128_SB
#define XORI_B5_128_SB(...)
Definition: generic_macros_msa.h:1977
XORI_B8_128_SB
#define XORI_B8_128_SB(...)
Definition: generic_macros_msa.h:1998
hevc_hz_bi_4t_16w_msa
static void hevc_hz_bi_4t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2667
hevc_vt_bi_4t_8x4multiple_msa
static void hevc_vt_bi_4t_8x4multiple_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3283
hevc_bi_copy_8w_msa
static void hevc_bi_copy_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:175
hevc_hz_bi_4t_24w_msa
static void hevc_hz_bi_4t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2727
h
h
Definition: vp9dsp_template.c:2038
hevc_hz_bi_4t_4x8multiple_msa
static void hevc_hz_bi_4t_4x8multiple_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2263
ILVRL_B2_SH
#define ILVRL_B2_SH(...)
Definition: generic_macros_msa.h:1616
hevc_hv_bi_4t_16w_msa
static void hevc_hv_bi_4t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4847
PCKEV_B2_SH
#define PCKEV_B2_SH(...)
Definition: generic_macros_msa.h:1839
hevc_hv_bi_4t_8w_msa
static void hevc_hv_bi_4t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4618
hevc_hv_bi_4t_4x2_msa
static void hevc_hv_bi_4t_4x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevc_mc_bi_msa.c:3768
XORI_B2_128_SB
#define XORI_B2_128_SB(...)
Definition: generic_macros_msa.h:1953
hevc_hz_bi_8t_16w_msa
static void hevc_hz_bi_8t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:752
SD
#define SD
Definition: ccaption_dec.c:819
hevc_vt_bi_4t_8w_msa
static void hevc_vt_bi_4t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3345
hevc_hv_bi_8t_4w_msa
static void hevc_hv_bi_8t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:1612
LD_SB
#define LD_SB(...)
Definition: generic_macros_msa.h:32
hevc_hz_bi_4t_8w_msa
static void hevc_hz_bi_4t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2572
ST_SB
#define ST_SB(...)
Definition: generic_macros_msa.h:40
XORI_B3_128_SB
#define XORI_B3_128_SB(...)
Definition: generic_macros_msa.h:1961
hevc_vt_bi_8t_24w_msa
static void hevc_vt_bi_8t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1558
hevc_bi_copy_6w_msa
static void hevc_bi_copy_6w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:129
hevc_bi_copy_32w_msa
static void hevc_bi_copy_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:386
hevc_hv_bi_8t_8multx1mult_msa
static void hevc_hv_bi_8t_8multx1mult_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height, int32_t width)
Definition: hevc_mc_bi_msa.c:1737
ST_SB2
#define ST_SB2(...)
Definition: generic_macros_msa.h:372
PCKEV_B3_UB
#define PCKEV_B3_UB(...)
Definition: generic_macros_msa.h:1847
hevc_hv_bi_4t_6w_msa
static void hevc_hv_bi_4t_6w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4054
UNPCK_R_SB_SH
#define UNPCK_R_SB_SH(in, out)
Definition: generic_macros_msa.h:2274
hevc_hv_bi_8t_16w_msa
static void hevc_hv_bi_8t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:2099
DPADD_SB4_SH
#define DPADD_SB4_SH(...)
Definition: generic_macros_msa.h:939
ILVR_B2_SB
#define ILVR_B2_SB(...)
Definition: generic_macros_msa.h:1457
SPLATI_H2_SH
#define SPLATI_H2_SH(...)
Definition: generic_macros_msa.h:1774
hevc_hv_bi_4t_4multx8mult_msa
static void hevc_hv_bi_4t_4multx8mult_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:3911
hevc_hz_bi_4t_4x4_msa
static void hevc_hz_bi_4t_4x4_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2217
LD_SB2
#define LD_SB2(...)
Definition: generic_macros_msa.h:275
hevc_hz_bi_4t_12w_msa
static void hevc_hz_bi_4t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2594
ST4x4_UB
#define ST4x4_UB(in0, in1, idx0, idx1, idx2, idx3, pdst, stride)
Definition: generic_macros_msa.h:463
hevc_hv_bi_4t_8x6_msa
static void hevc_hv_bi_4t_8x6_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevc_mc_bi_msa.c:4376
hevc_vt_bi_8t_16multx2mult_msa
static void hevc_vt_bi_8t_16multx2mult_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height, int32_t width)
Definition: hevc_mc_bi_msa.c:1439
VSHF_B2_SB
#define VSHF_B2_SB(...)
Definition: generic_macros_msa.h:760
SRA_4V
#define SRA_4V(in0, in1, in2, in3, shift)
Definition: generic_macros_msa.h:2057
filter
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
hevc_hz_bi_8t_64w_msa
static void hevc_hz_bi_8t_64w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1059
hevc_hv_bi_4t_8multx4_msa
static void hevc_hv_bi_4t_8multx4_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t width8mult)
Definition: hevc_mc_bi_msa.c:4280
ILVR_D2_SB
#define ILVR_D2_SB(...)
Definition: generic_macros_msa.h:1562
hevc_vt_bi_8t_12w_msa
static void hevc_vt_bi_8t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1333
uint8_t
uint8_t
Definition: audio_convert.c:194
LD4
#define LD4(psrc, stride, out0, out1, out2, out3)
Definition: generic_macros_msa.h:225
ST_SH2
#define ST_SH2(...)
Definition: generic_macros_msa.h:374
BI_MC_HV
#define BI_MC_HV(PEL, WIDTH, TAP)
Definition: hevc_mc_bi_msa.c:4978
hevc_hz_bi_4t_8x4multiple_msa
static void hevc_hz_bi_4t_8x4multiple_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2514
hevc_vt_bi_4t_16w_msa
static void hevc_vt_bi_4t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3449
SPLATI_W2_SH
#define SPLATI_W2_SH(...)
Definition: generic_macros_msa.h:1810
hevc_hv_bi_4t_4x4_msa
static void hevc_hv_bi_4t_4x4_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevc_mc_bi_msa.c:3835
SRARI_H4_SH
#define SRARI_H4_SH(...)
Definition: generic_macros_msa.h:2185
CLIP_SH_0_255
#define CLIP_SH_0_255(in)
Definition: generic_macros_msa.h:1036
SPLATI_H4_SH
#define SPLATI_H4_SH(...)
Definition: generic_macros_msa.h:1792
hevc_bi_copy_16w_msa
static void hevc_bi_copy_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:302
ff_hevc_mask_arr
static const uint8_t ff_hevc_mask_arr[16 *2]
Definition: hevc_mc_bi_msa.c:25
ILVL_B2_SB
#define ILVL_B2_SB(...)
Definition: generic_macros_msa.h:1382
height
#define height
LD_SH
#define LD_SH(...)
Definition: generic_macros_msa.h:34
ILVRL_H2_SH
#define ILVRL_H2_SH(...)
Definition: generic_macros_msa.h:1626
hevc_hv_bi_4t_24w_msa
static void hevc_hv_bi_4t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4867
CLIP_SH4_0_255_MAX_SATU
#define CLIP_SH4_0_255_MAX_SATU(in0, in1, in2, in3)
Definition: generic_macros_msa.h:1069
ILVR_D3_SB
#define ILVR_D3_SB(...)
Definition: generic_macros_msa.h:1570
ILVR_D4_SB
#define ILVR_D4_SB(...)
Definition: generic_macros_msa.h:1578
hevc_hz_bi_8t_4w_msa
static void hevc_hz_bi_8t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:523
LD_SB8
#define LD_SB8(...)
Definition: generic_macros_msa.h:332
PCKEV_B2_SB
#define PCKEV_B2_SB(...)
Definition: generic_macros_msa.h:1837
hevc_bi_copy_64w_msa
static void hevc_bi_copy_64w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:484
HEVC_BI_RND_CLIP4
#define HEVC_BI_RND_CLIP4(in0, in1, in2, in3,vec0, vec1, vec2, vec3, rnd_val,out0, out1, out2, out3)
Definition: hevc_mc_bi_msa.c:38
aligned
static int aligned(int val)
Definition: dashdec.c:178
hevc_macros_msa.h
ST8x2_UB
#define ST8x2_UB(in, pdst, stride)
Definition: generic_macros_msa.h:544
hevc_vt_bi_8t_16w_msa
static void hevc_vt_bi_8t_16w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1545
hevc_vt_bi_4t_24w_msa
static void hevc_vt_bi_4t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3534
CLIP_SH_0_255_MAX_SATU
#define CLIP_SH_0_255_MAX_SATU(in)
Definition: generic_macros_msa.h:1056
generic_macros_msa.h
XORI_B7_128_SB
#define XORI_B7_128_SB(...)
Definition: generic_macros_msa.h:1991
zero
#define zero
Definition: regdef.h:64
LW2
#define LW2(psrc, stride, out0, out1)
Definition: generic_macros_msa.h:207
hevc_hz_bi_4t_8x2_msa
static void hevc_hz_bi_4t_8x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2406
ADDS_SH2_SH
#define ADDS_SH2_SH(...)
Definition: generic_macros_msa.h:2015
ILVR_B2_SH
#define ILVR_B2_SH(...)
Definition: generic_macros_msa.h:1459
hevcdsp_mips.h
hevc_hv_bi_8t_64w_msa
static void hevc_hv_bi_8t_64w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:2159
XORI_B4_128_SB
#define XORI_B4_128_SB(...)
Definition: generic_macros_msa.h:1969
hevc_bi_copy_48w_msa
static void hevc_bi_copy_48w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:430
hevc_hv_bi_8t_32w_msa
static void hevc_hv_bi_8t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:2129
hevc_vt_bi_8t_4w_msa
static void hevc_vt_bi_8t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1169
SPLATI_W4_SH
#define SPLATI_W4_SH(...)
Definition: generic_macros_msa.h:1818
LD_SH8
#define LD_SH8(...)
Definition: generic_macros_msa.h:334
hevc_vt_bi_8t_64w_msa
static void hevc_vt_bi_8t_64w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1599
DPADD_SB2_SH
#define DPADD_SB2_SH(...)
Definition: generic_macros_msa.h:931
SRARI_H2_SH
#define SRARI_H2_SH(...)
Definition: generic_macros_msa.h:2177
hevc_hz_bi_8t_8w_msa
static void hevc_hz_bi_8t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:596
hevc_hz_bi_4t_8x6_msa
static void hevc_hz_bi_4t_8x6_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2449
hevc_vt_bi_4t_8x6_msa
static void hevc_vt_bi_4t_8x6_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3222
hevc_vt_bi_4t_32w_msa
static void hevc_vt_bi_4t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3658
width
#define width
PCKEV_D2_SH
#define PCKEV_D2_SH(...)
Definition: generic_macros_msa.h:1907
PCKEV_B4_SH
#define PCKEV_B4_SH(...)
Definition: generic_macros_msa.h:1858
INSERT_D2_SH
#define INSERT_D2_SH(...)
Definition: generic_macros_msa.h:1290
LD_SH2
#define LD_SH2(...)
Definition: generic_macros_msa.h:277
int32_t
int32_t
Definition: audio_convert.c:194
PCKEV_H2_SH
#define PCKEV_H2_SH(...)
Definition: generic_macros_msa.h:1877
LD_SB3
#define LD_SB3(...)
Definition: generic_macros_msa.h:286
ST_UB
#define ST_UB(...)
Definition: generic_macros_msa.h:39
BI_MC
#define BI_MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR)
Definition: hevc_mc_bi_msa.c:4924
LD_SB4
#define LD_SB4(...)
Definition: generic_macros_msa.h:294
ST2x4_UB
#define ST2x4_UB(in, stidx, pdst, stride)
Definition: generic_macros_msa.h:415
INSERT_W4_SH
#define INSERT_W4_SH(...)
Definition: generic_macros_msa.h:1274
hevc_bi_copy_4w_msa
static void hevc_bi_copy_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:61
HEVC_FILT_8TAP
#define HEVC_FILT_8TAP(in0, in1, in2, in3,filt0, filt1, filt2, filt3)
Definition: hevc_macros_msa.h:35
ST_UB2
#define ST_UB2(...)
Definition: generic_macros_msa.h:371
hevc_hv_bi_8t_8w_msa
static void hevc_hv_bi_8t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:1870
ST_UB4
#define ST_UB4(...)
Definition: generic_macros_msa.h:382
hevc_hz_bi_4t_32w_msa
static void hevc_hz_bi_4t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2833
hevc_hz_bi_4t_4x2_msa
static void hevc_hz_bi_4t_4x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2174
src1
#define src1
Definition: h264pred.c:139
hevc_hv_bi_4t_4w_msa
static void hevc_hv_bi_4t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4030
ILVL_B4_SB
#define ILVL_B4_SB(...)
Definition: generic_macros_msa.h:1393
hevc_vt_bi_4t_8x2_msa
static void hevc_vt_bi_4t_8x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3178
BI_MC_COPY
#define BI_MC_COPY(WIDTH)
Definition: hevc_mc_bi_msa.c:4897
LD_SH6
#define LD_SH6(...)
Definition: generic_macros_msa.h:314
hevc_vt_bi_8t_48w_msa
static void hevc_vt_bi_8t_48w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1586
HEVC_BI_RND_CLIP4_MAX_SATU
#define HEVC_BI_RND_CLIP4_MAX_SATU(in0, in1, in2, in3, vec0, vec1, vec2,vec3,rnd_val, out0, out1, out2, out3)
Definition: hevc_mc_bi_msa.c:54
ILVR_B4_SH
#define ILVR_B4_SH(...)
Definition: generic_macros_msa.h:1481
HEVC_FILT_8TAP_SH
#define HEVC_FILT_8TAP_SH(in0, in1, in2, in3,filt0, filt1, filt2, filt3)
Definition: hevc_macros_msa.h:24
hevc_hz_bi_8t_32w_msa
static void hevc_hz_bi_8t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:895
hevc_bi_copy_12w_msa
static void hevc_bi_copy_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:264
hevc_hz_bi_4t_6w_msa
static void hevc_hz_bi_4t_6w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2348
src0
#define src0
Definition: h264pred.c:138
hevc_hz_bi_8t_12w_msa
static void hevc_hz_bi_8t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:664
hevc_hz_bi_4t_4w_msa
static void hevc_hz_bi_4t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2326
INSERT_W2_SB
#define INSERT_W2_SB(...)
Definition: generic_macros_msa.h:1263
SW
#define SW(val, pdst)
Definition: generic_macros_msa.h:164
SLLI_4V
#define SLLI_4V(in0, in1, in2, in3, shift)
Definition: generic_macros_msa.h:2039
ST4x8_UB
#define ST4x8_UB(in0, in1, pdst, stride)
Definition: generic_macros_msa.h:475
ST6x4_UB
#define ST6x4_UB(in0, in1, pdst, stride)
Definition: generic_macros_msa.h:496
LD_SB7
#define LD_SB7(...)
Definition: generic_macros_msa.h:323
LD_SB5
#define LD_SB5(...)
Definition: generic_macros_msa.h:304
hevc_hz_bi_8t_48w_msa
static void hevc_hz_bi_8t_48w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:967
ILVL_W2_SB
#define ILVL_W2_SB(...)
Definition: generic_macros_msa.h:1438
HEVC_FILT_4TAP
#define HEVC_FILT_4TAP(in0, in1, filt0, filt1)
Definition: hevc_macros_msa.h:55
LW4
#define LW4(psrc, stride, out0, out1, out2, out3)
Definition: generic_macros_msa.h:199
LD_SB6
#define LD_SB6(...)
Definition: generic_macros_msa.h:312
hevc_hv_bi_4t_32w_msa
static void hevc_hv_bi_4t_32w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4882
hevc_vt_bi_4t_4x4_msa
static void hevc_vt_bi_4t_4x4_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2942
hevc_vt_bi_4t_4x8multiple_msa
static void hevc_vt_bi_4t_4x8multiple_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2991
hevc_vt_bi_8t_8w_msa
static void hevc_vt_bi_8t_8w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:1255
ST8x4_UB
#define ST8x4_UB(in0, in1, pdst, stride)
Definition: generic_macros_msa.h:568
ST8x8_UB
#define ST8x8_UB(in0, in1, in2, in3, pdst, stride)
Definition: generic_macros_msa.h:580
INSERT_D2_SB
#define INSERT_D2_SB(...)
Definition: generic_macros_msa.h:1289
LD_SH4
#define LD_SH4(...)
Definition: generic_macros_msa.h:296
hevc_vt_bi_4t_12w_msa
static void hevc_vt_bi_4t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3367
XORI_B6_128_SB
#define XORI_B6_128_SB(...)
Definition: generic_macros_msa.h:1984
hevc_vt_bi_4t_4x2_msa
static void hevc_vt_bi_4t_4x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:2894
hevc_vt_bi_4t_6w_msa
static void hevc_vt_bi_4t_6w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3086
hevc_hv_bi_8t_24w_msa
static void hevc_hv_bi_8t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:2114
ST12x4_UB
#define ST12x4_UB(in0, in1, in2, pdst, stride)
Definition: generic_macros_msa.h:587
hevc_hz_bi_8t_24w_msa
static void hevc_hz_bi_8t_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:823
ILVR_B4_SB
#define ILVR_B4_SB(...)
Definition: generic_macros_msa.h:1479
out
FILE * out
Definition: movenc.c:54
HEVC_BI_RND_CLIP2_MAX_SATU
#define HEVC_BI_RND_CLIP2_MAX_SATU(in0, in1, vec0, vec1, rnd_val,out0, out1)
Definition: hevc_mc_bi_msa.c:46
hevc_hv_bi_8t_48w_msa
static void hevc_hv_bi_8t_48w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:2144
hevc_hv_bi_4t_12w_msa
static void hevc_hv_bi_4t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:4645
hevc_hv_bi_8t_12w_msa
static void hevc_hv_bi_8t_12w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevc_mc_bi_msa.c:1885
ST8x1_UB
#define ST8x1_UB(in, pdst)
Definition: generic_macros_msa.h:530
SLLI_2V
#define SLLI_2V(in0, in1, shift)
Definition: generic_macros_msa.h:2034
PCKEV_H4_SH
#define PCKEV_H4_SH(...)
Definition: generic_macros_msa.h:1886
ST4x2_UB
#define ST4x2_UB(in, pdst, stride)
Definition: generic_macros_msa.h:439
INSERT_W4_SB
#define INSERT_W4_SB(...)
Definition: generic_macros_msa.h:1273
hevc_hv_bi_4t_8x2_msa
static void hevc_hv_bi_4t_8x2_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevc_mc_bi_msa.c:4206
LD2
#define LD2(psrc, stride, out0, out1)
Definition: generic_macros_msa.h:220
ILVR_D2_SH
#define ILVR_D2_SH(...)
Definition: generic_macros_msa.h:1563
PCKEV_B2_UB
#define PCKEV_B2_UB(...)
Definition: generic_macros_msa.h:1838
ST_SH4
#define ST_SH4(...)
Definition: generic_macros_msa.h:384
CLIP_SH2_0_255_MAX_SATU
#define CLIP_SH2_0_255_MAX_SATU(in0, in1)
Definition: generic_macros_msa.h:1064
HEVC_FILT_4TAP_SH
#define HEVC_FILT_4TAP_SH(in0, in1, filt0, filt1)
Definition: hevc_macros_msa.h:46
ADDS_SH4_SH
#define ADDS_SH4_SH(...)
Definition: generic_macros_msa.h:2024
hevc_hv_bi_4t_8multx4mult_msa
static void hevc_hv_bi_4t_8multx4mult_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height, int32_t width)
Definition: hevc_mc_bi_msa.c:4493
hevc_bi_copy_24w_msa
static void hevc_bi_copy_24w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, int32_t height)
Definition: hevc_mc_bi_msa.c:340
hevc_vt_bi_4t_4w_msa
static void hevc_vt_bi_4t_4w_msa(uint8_t *src0_ptr, int32_t src_stride, int16_t *src1_ptr, int32_t src2_stride, uint8_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevc_mc_bi_msa.c:3064
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
VSHF_B3_SB
#define VSHF_B3_SB(...)
Definition: generic_macros_msa.h:770
Generated on Thu Dec 13 2018 19:21:12 for FFmpeg by   doxygen 1.8.6