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