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