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