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