FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevcdsp_msa.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/mips/generic_macros_msa.h"
22 #include "libavcodec/mips/hevcdsp_mips.h"
23 #include "libavcodec/mips/hevc_macros_msa.h"
24 
25 static void hevc_copy_4w_msa(uint8_t *src, int32_t src_stride,
26  int16_t *dst, int32_t dst_stride,
27  int32_t height)
28 {
29  v16i8 zero = { 0 };
30 
31  if (2 == height) {
32  v16i8 src0, src1;
33  v8i16 in0;
34 
35  LD_SB2(src, src_stride, src0, src1);
36 
37  src0 = (v16i8) __msa_ilvr_w((v4i32) src1, (v4i32) src0);
38  in0 = (v8i16) __msa_ilvr_b(zero, src0);
39  in0 <<= 6;
40  ST8x2_UB(in0, dst, 2 * dst_stride);
41  } else if (4 == height) {
42  v16i8 src0, src1, src2, src3;
43  v8i16 in0, in1;
44 
45  LD_SB4(src, src_stride, src0, src1, src2, src3);
46 
47  ILVR_W2_SB(src1, src0, src3, src2, src0, src1);
48  ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
49  in0 <<= 6;
50  in1 <<= 6;
51  ST8x4_UB(in0, in1, dst, 2 * dst_stride);
52  } else if (0 == height % 8) {
53  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
54  v8i16 in0, in1, in2, in3;
55  uint32_t loop_cnt;
56 
57  for (loop_cnt = (height >> 3); loop_cnt--;) {
58  LD_SB8(src, src_stride,
59  src0, src1, src2, src3, src4, src5, src6, src7);
60  src += (8 * src_stride);
61 
62  ILVR_W4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
63  src0, src1, src2, src3);
64  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
65  in0, in1, in2, in3);
66  SLLI_4V(in0, in1, in2, in3, 6);
67  ST8x8_UB(in0, in1, in2, in3, dst, 2 * dst_stride);
68  dst += (8 * dst_stride);
69  }
70  }
71 }
72 
73 static void hevc_copy_6w_msa(uint8_t *src, int32_t src_stride,
74  int16_t *dst, int32_t dst_stride,
75  int32_t height)
76 {
77  uint32_t loop_cnt;
78  v16i8 zero = { 0 };
79  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
80  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
81 
82  for (loop_cnt = (height >> 3); loop_cnt--;) {
83  LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
84  src += (8 * src_stride);
85 
86  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
87  in0, in1, in2, in3);
88  ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
89  in4, in5, in6, in7);
90  SLLI_4V(in0, in1, in2, in3, 6);
91  SLLI_4V(in4, in5, in6, in7, 6);
92  ST12x8_UB(in0, in1, in2, in3, in4, in5, in6, in7, dst, 2 * dst_stride);
93  dst += (8 * dst_stride);
94  }
95 }
96 
97 static void hevc_copy_8w_msa(uint8_t *src, int32_t src_stride,
98  int16_t *dst, int32_t dst_stride,
99  int32_t height)
100 {
101  v16i8 zero = { 0 };
102 
103  if (2 == height) {
104  v16i8 src0, src1;
105  v8i16 in0, in1;
106 
107  LD_SB2(src, src_stride, src0, src1);
108 
109  ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
110  in0 <<= 6;
111  in1 <<= 6;
112  ST_SH2(in0, in1, dst, dst_stride);
113  } else if (4 == height) {
114  v16i8 src0, src1, src2, src3;
115  v8i16 in0, in1, in2, in3;
116 
117  LD_SB4(src, src_stride, src0, src1, src2, src3);
118 
119  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
120  in0, in1, in2, in3);
121  SLLI_4V(in0, in1, in2, in3, 6);
122  ST_SH4(in0, in1, in2, in3, dst, dst_stride);
123  } else if (6 == height) {
124  v16i8 src0, src1, src2, src3, src4, src5;
125  v8i16 in0, in1, in2, in3, in4, in5;
126 
127  LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
128 
129  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
130  in0, in1, in2, in3);
131  ILVR_B2_SH(zero, src4, zero, src5, in4, in5);
132  SLLI_4V(in0, in1, in2, in3, 6);
133  in4 <<= 6;
134  in5 <<= 6;
135  ST_SH6(in0, in1, in2, in3, in4, in5, dst, dst_stride);
136  } else if (0 == height % 8) {
137  uint32_t loop_cnt;
138  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
139  v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
140 
141  for (loop_cnt = (height >> 3); loop_cnt--;) {
142  LD_SB8(src, src_stride,
143  src0, src1, src2, src3, src4, src5, src6, src7);
144  src += (8 * src_stride);
145 
146  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
147  in0, in1, in2, in3);
148  ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
149  in4, in5, in6, in7);
150  SLLI_4V(in0, in1, in2, in3, 6);
151  SLLI_4V(in4, in5, in6, in7, 6);
152  ST_SH8(in0, in1, in2, in3, in4, in5, in6, in7, dst, dst_stride);
153  dst += (8 * dst_stride);
154  }
155  }
156 }
157 
158 static void hevc_copy_12w_msa(uint8_t *src, int32_t src_stride,
159  int16_t *dst, int32_t dst_stride,
160  int32_t height)
161 {
162  uint32_t loop_cnt;
163  v16i8 zero = { 0 };
164  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
165  v8i16 in0, in1, in0_r, in1_r, in2_r, in3_r;
166 
167  for (loop_cnt = (height >> 3); loop_cnt--;) {
168  LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
169  src += (8 * src_stride);
170 
171  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
172  in0_r, in1_r, in2_r, in3_r);
173  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
174  ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
175  ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
176  in0 <<= 6;
177  in1 <<= 6;
178  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
179  ST8x4_UB(in0, in1, dst + 8, 2 * dst_stride);
180  dst += (4 * dst_stride);
181 
182  ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
183  in0_r, in1_r, in2_r, in3_r);
184  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
185  ILVL_W2_SB(src5, src4, src7, src6, src0, src1);
186  ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
187  in0 <<= 6;
188  in1 <<= 6;
189  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
190  ST8x4_UB(in0, in1, dst + 8, 2 * dst_stride);
191  dst += (4 * dst_stride);
192  }
193 }
194 
195 static void hevc_copy_16multx8mult_msa(uint8_t *src,
196  int32_t src_stride,
197  int16_t *dst,
198  int32_t dst_stride,
199  int32_t height,
200  int32_t width)
201 {
202  uint8_t *src_tmp;
203  int16_t *dst_tmp;
204  uint32_t loop_cnt, cnt;
205  v16i8 zero = { 0 };
206  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
207  v8i16 in0_r, in1_r, in2_r, in3_r;
208  v8i16 in0_l, in1_l, in2_l, in3_l;
209 
210  for (cnt = (width >> 4); cnt--;) {
211  src_tmp = src;
212  dst_tmp = dst;
213 
214  for (loop_cnt = (height >> 3); loop_cnt--;) {
215  LD_SB8(src_tmp, src_stride,
216  src0, src1, src2, src3, src4, src5, src6, src7);
217  src_tmp += (8 * src_stride);
218 
219  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
220  in0_r, in1_r, in2_r, in3_r);
221  ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
222  in0_l, in1_l, in2_l, in3_l);
223  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
224  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
225  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
226  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
227  dst_tmp += (4 * dst_stride);
228 
229  ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
230  in0_r, in1_r, in2_r, in3_r);
231  ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
232  in0_l, in1_l, in2_l, in3_l);
233  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
234  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
235  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
236  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
237  dst_tmp += (4 * dst_stride);
238  }
239 
240  src += 16;
241  dst += 16;
242  }
243 }
244 
245 static void hevc_copy_16w_msa(uint8_t *src, int32_t src_stride,
246  int16_t *dst, int32_t dst_stride,
247  int32_t height)
248 {
249  v16i8 zero = { 0 };
250 
251  if (4 == height) {
252  v16i8 src0, src1, src2, src3;
253  v8i16 in0_r, in1_r, in2_r, in3_r;
254  v8i16 in0_l, in1_l, in2_l, in3_l;
255 
256  LD_SB4(src, src_stride, src0, src1, src2, src3);
257 
258  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
259  in0_r, in1_r, in2_r, in3_r);
260  ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
261  in0_l, in1_l, in2_l, in3_l);
262  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
263  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
264  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
265  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
266  } else if (12 == height) {
267  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
268  v16i8 src8, src9, src10, src11;
269  v8i16 in0_r, in1_r, in2_r, in3_r;
270  v8i16 in0_l, in1_l, in2_l, in3_l;
271 
272  LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
273  src += (8 * src_stride);
274  LD_SB4(src, src_stride, src8, src9, src10, src11);
275 
276  ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
277  in0_r, in1_r, in2_r, in3_r);
278  ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
279  in0_l, in1_l, in2_l, in3_l);
280  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
281  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
282  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
283  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
284  dst += (4 * dst_stride);
285 
286  ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
287  in0_r, in1_r, in2_r, in3_r);
288  ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
289  in0_l, in1_l, in2_l, in3_l);
290  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
291  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
292  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
293  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
294  dst += (4 * dst_stride);
295 
296  ILVR_B4_SH(zero, src8, zero, src9, zero, src10, zero, src11,
297  in0_r, in1_r, in2_r, in3_r);
298  ILVL_B4_SH(zero, src8, zero, src9, zero, src10, zero, src11,
299  in0_l, in1_l, in2_l, in3_l);
300  SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
301  SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
302  ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
303  ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
304  } else if (0 == (height % 8)) {
305  hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride,
306  height, 16);
307  }
308 }
309 
310 static void hevc_copy_24w_msa(uint8_t *src, int32_t src_stride,
311  int16_t *dst, int32_t dst_stride,
312  int32_t height)
313 {
314  hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
315  hevc_copy_8w_msa(src + 16, src_stride, dst + 16, dst_stride, height);
316 }
317 
318 static void hevc_copy_32w_msa(uint8_t *src, int32_t src_stride,
319  int16_t *dst, int32_t dst_stride,
320  int32_t height)
321 {
322  hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 32);
323 }
324 
325 static void hevc_copy_48w_msa(uint8_t *src, int32_t src_stride,
326  int16_t *dst, int32_t dst_stride,
327  int32_t height)
328 {
329  hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 48);
330 }
331 
332 static void hevc_copy_64w_msa(uint8_t *src, int32_t src_stride,
333  int16_t *dst, int32_t dst_stride,
334  int32_t height)
335 {
336  hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 64);
337 }
338 
339 static void hevc_hz_8t_4w_msa(uint8_t *src, int32_t src_stride,
340  int16_t *dst, int32_t dst_stride,
341  const int8_t *filter, int32_t height)
342 {
343  uint32_t loop_cnt;
344  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
345  v8i16 filt0, filt1, filt2, filt3;
346  v16i8 mask1, mask2, mask3;
347  v16i8 vec0, vec1, vec2, vec3;
348  v8i16 dst0, dst1, dst2, dst3;
349  v8i16 filter_vec, const_vec;
350  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
351 
352  src -= 3;
353  const_vec = __msa_ldi_h(128);
354  const_vec <<= 6;
355 
356  filter_vec = LD_SH(filter);
357  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
358 
359  mask1 = mask0 + 2;
360  mask2 = mask0 + 4;
361  mask3 = mask0 + 6;
362 
363  for (loop_cnt = (height >> 3); loop_cnt--;) {
364  LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
365  src += (8 * src_stride);
366  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
367 
368  VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,
369  vec0, vec1, vec2, vec3);
370  dst0 = const_vec;
371  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
372  dst0, dst0, dst0, dst0);
373  VSHF_B4_SB(src2, src3, mask0, mask1, mask2, mask3,
374  vec0, vec1, vec2, vec3);
375  dst1 = const_vec;
376  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
377  dst1, dst1, dst1, dst1);
378  VSHF_B4_SB(src4, src5, mask0, mask1, mask2, mask3,
379  vec0, vec1, vec2, vec3);
380  dst2 = const_vec;
381  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
382  dst2, dst2, dst2, dst2);
383  VSHF_B4_SB(src6, src7, mask0, mask1, mask2, mask3,
384  vec0, vec1, vec2, vec3);
385  dst3 = const_vec;
386  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
387  dst3, dst3, dst3, dst3);
388 
389  ST8x8_UB(dst0, dst1, dst2, dst3, dst, 2 * dst_stride);
390  dst += (8 * dst_stride);
391  }
392 }
393 
394 static void hevc_hz_8t_8w_msa(uint8_t *src, int32_t src_stride,
395  int16_t *dst, int32_t dst_stride,
396  const int8_t *filter, int32_t height)
397 {
398  uint32_t loop_cnt;
399  v16i8 src0, src1, src2, src3;
400  v8i16 filt0, filt1, filt2, filt3;
401  v16i8 mask1, mask2, mask3;
402  v16i8 vec0, vec1, vec2, vec3;
403  v8i16 dst0, dst1, dst2, dst3;
404  v8i16 filter_vec, const_vec;
405  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
406 
407  src -= 3;
408  const_vec = __msa_ldi_h(128);
409  const_vec <<= 6;
410 
411  filter_vec = LD_SH(filter);
412  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
413 
414  mask1 = mask0 + 2;
415  mask2 = mask0 + 4;
416  mask3 = mask0 + 6;
417 
418  for (loop_cnt = (height >> 2); loop_cnt--;) {
419  LD_SB4(src, src_stride, src0, src1, src2, src3);
420  src += (4 * src_stride);
421  XORI_B4_128_SB(src0, src1, src2, src3);
422 
423  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
424  vec0, vec1, vec2, vec3);
425  dst0 = const_vec;
426  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
427  dst0, dst0, dst0, dst0);
428  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
429  vec0, vec1, vec2, vec3);
430  dst1 = const_vec;
431  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
432  dst1, dst1, dst1, dst1);
433  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
434  vec0, vec1, vec2, vec3);
435  dst2 = const_vec;
436  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
437  dst2, dst2, dst2, dst2);
438  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
439  vec0, vec1, vec2, vec3);
440  dst3 = const_vec;
441  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
442  dst3, dst3, dst3, dst3);
443 
444  ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
445  dst += (4 * dst_stride);
446  }
447 }
448 
449 static void hevc_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
450  int16_t *dst, int32_t dst_stride,
451  const int8_t *filter, int32_t height)
452 {
453  hevc_hz_8t_8w_msa(src, src_stride, dst, dst_stride, filter, height);
454  hevc_hz_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride, filter, height);
455 }
456 
457 static void hevc_hz_8t_16w_msa(uint8_t *src, int32_t src_stride,
458  int16_t *dst, int32_t dst_stride,
459  const int8_t *filter, int32_t height)
460 {
461  uint32_t loop_cnt;
462  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
463  v8i16 filt0, filt1, filt2, filt3;
464  v16i8 mask1, mask2, mask3;
465  v16i8 vec0, vec1, vec2, vec3;
466  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
467  v8i16 filter_vec, const_vec;
468  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
469 
470  src -= 3;
471  const_vec = __msa_ldi_h(128);
472  const_vec <<= 6;
473 
474  filter_vec = LD_SH(filter);
475  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
476 
477  mask1 = mask0 + 2;
478  mask2 = mask0 + 4;
479  mask3 = mask0 + 6;
480 
481  for (loop_cnt = (height >> 2); loop_cnt--;) {
482  LD_SB4(src, src_stride, src0, src2, src4, src6);
483  LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
484  src += (4 * src_stride);
485  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
486 
487  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
488  vec0, vec1, vec2, vec3);
489  dst0 = const_vec;
490  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
491  dst0, dst0, dst0, dst0);
492  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
493  vec0, vec1, vec2, vec3);
494  dst1 = const_vec;
495  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
496  dst1, dst1, dst1, dst1);
497  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
498  vec0, vec1, vec2, vec3);
499  dst2 = const_vec;
500  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
501  dst2, dst2, dst2, dst2);
502  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
503  vec0, vec1, vec2, vec3);
504  dst3 = const_vec;
505  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
506  dst3, dst3, dst3, dst3);
507  VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
508  vec0, vec1, vec2, vec3);
509  dst4 = const_vec;
510  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
511  dst4, dst4, dst4, dst4);
512  VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
513  vec0, vec1, vec2, vec3);
514  dst5 = const_vec;
515  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
516  dst5, dst5, dst5, dst5);
517  VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
518  vec0, vec1, vec2, vec3);
519  dst6 = const_vec;
520  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
521  dst6, dst6, dst6, dst6);
522  VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
523  vec0, vec1, vec2, vec3);
524  dst7 = const_vec;
525  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
526  dst7, dst7, dst7, dst7);
527 
528  ST_SH4(dst0, dst2, dst4, dst6, dst, dst_stride);
529  ST_SH4(dst1, dst3, dst5, dst7, dst + 8, dst_stride);
530  dst += (4 * dst_stride);
531  }
532 }
533 
534 static void hevc_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
535  int16_t *dst, int32_t dst_stride,
536  const int8_t *filter, int32_t height)
537 {
538  uint32_t loop_cnt;
539  v16i8 src0, src1, src2, src3;
540  v8i16 filt0, filt1, filt2, filt3;
541  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
542  v16i8 vec0, vec1, vec2, vec3;
543  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
544  v8i16 filter_vec, const_vec;
545  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
546 
547  src -= 3;
548  filter_vec = LD_SH(filter);
549  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
550 
551  mask1 = mask0 + 2;
552  mask2 = mask0 + 4;
553  mask3 = mask0 + 6;
554  mask4 = mask0 + 8;
555  mask5 = mask0 + 10;
556  mask6 = mask0 + 12;
557  mask7 = mask0 + 14;
558 
559  const_vec = __msa_ldi_h(128);
560  const_vec <<= 6;
561 
562  for (loop_cnt = (height >> 1); loop_cnt--;) {
563  LD_SB2(src, 16, src0, src1);
564  src += src_stride;
565  LD_SB2(src, 16, src2, src3);
566  src += src_stride;
567  XORI_B4_128_SB(src0, src1, src2, src3);
568 
569  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
570  vec0, vec1, vec2, vec3);
571  dst0 = const_vec;
572  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
573  dst0, dst0, dst0, dst0);
574  VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
575  vec0, vec1, vec2, vec3);
576  dst1 = const_vec;
577  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
578  dst1, dst1, dst1, dst1);
579  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
580  vec0, vec1, vec2, vec3);
581  dst2 = const_vec;
582  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
583  dst2, dst2, dst2, dst2);
584  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
585  vec0, vec1, vec2, vec3);
586  dst3 = const_vec;
587  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
588  dst3, dst3, dst3, dst3);
589  VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
590  vec0, vec1, vec2, vec3);
591  dst4 = const_vec;
592  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
593  dst4, dst4, dst4, dst4);
594  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
595  vec0, vec1, vec2, vec3);
596  dst5 = const_vec;
597  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
598  dst5, dst5, dst5, dst5);
599 
600  ST_SH2(dst0, dst1, dst, 8);
601  ST_SH(dst2, dst + 16);
602  dst += dst_stride;
603  ST_SH2(dst3, dst4, dst, 8);
604  ST_SH(dst5, dst + 16);
605  dst += dst_stride;
606  }
607 }
608 
609 static void hevc_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
610  int16_t *dst, int32_t dst_stride,
611  const int8_t *filter, int32_t height)
612 {
613  uint32_t loop_cnt;
614  v16i8 src0, src1, src2;
615  v8i16 filt0, filt1, filt2, filt3;
616  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
617  v16i8 vec0, vec1, vec2, vec3;
618  v8i16 dst0, dst1, dst2, dst3;
619  v8i16 filter_vec, const_vec;
620  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
621 
622  src -= 3;
623  filter_vec = LD_SH(filter);
624  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
625 
626  mask1 = mask0 + 2;
627  mask2 = mask0 + 4;
628  mask3 = mask0 + 6;
629  mask4 = mask0 + 8;
630  mask5 = mask0 + 10;
631  mask6 = mask0 + 12;
632  mask7 = mask0 + 14;
633 
634  const_vec = __msa_ldi_h(128);
635  const_vec <<= 6;
636 
637  for (loop_cnt = height; loop_cnt--;) {
638  LD_SB2(src, 16, src0, src1);
639  src2 = LD_SB(src + 24);
640  src += src_stride;
641  XORI_B3_128_SB(src0, src1, src2);
642 
643  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
644  vec0, vec1, vec2, vec3);
645  dst0 = const_vec;
646  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
647  dst0, dst0, dst0, dst0);
648  VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
649  vec0, vec1, vec2, vec3);
650  dst1 = const_vec;
651  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
652  dst1, dst1, dst1, dst1);
653  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
654  vec0, vec1, vec2, vec3);
655  dst2 = const_vec;
656  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
657  dst2, dst2, dst2, dst2);
658  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
659  vec0, vec1, vec2, vec3);
660  dst3 = const_vec;
661  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
662  dst3, dst3, dst3, dst3);
663 
664  ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
665  dst += dst_stride;
666  }
667 }
668 
669 static void hevc_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
670  int16_t *dst, int32_t dst_stride,
671  const int8_t *filter, int32_t height)
672 {
673  uint32_t loop_cnt;
674  v16i8 src0, src1, src2, src3;
675  v8i16 filt0, filt1, filt2, filt3;
676  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
677  v16i8 vec0, vec1, vec2, vec3;
678  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
679  v8i16 filter_vec, const_vec;
680  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
681 
682  src -= 3;
683  filter_vec = LD_SH(filter);
684  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
685 
686  mask1 = mask0 + 2;
687  mask2 = mask0 + 4;
688  mask3 = mask0 + 6;
689  mask4 = mask0 + 8;
690  mask5 = mask0 + 10;
691  mask6 = mask0 + 12;
692  mask7 = mask0 + 14;
693 
694  const_vec = __msa_ldi_h(128);
695  const_vec <<= 6;
696 
697  for (loop_cnt = height; loop_cnt--;) {
698  LD_SB3(src, 16, src0, src1, src2);
699  src3 = LD_SB(src + 40);
700  src += src_stride;
701  XORI_B4_128_SB(src0, src1, src2, src3);
702 
703  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
704  vec0, vec1, vec2, vec3);
705  dst0 = const_vec;
706  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
707  dst0, dst0, dst0, dst0);
708  VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
709  vec0, vec1, vec2, vec3);
710  dst1 = const_vec;
711  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
712  dst1, dst1, dst1, dst1);
713  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
714  vec0, vec1, vec2, vec3);
715  dst2 = const_vec;
716  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
717  dst2, dst2, dst2, dst2);
718  VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
719  vec0, vec1, vec2, vec3);
720  dst3 = const_vec;
721  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
722  dst3, dst3, dst3, dst3);
723  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
724  vec0, vec1, vec2, vec3);
725  dst4 = const_vec;
726  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
727  dst4, dst4, dst4, dst4);
728  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
729  vec0, vec1, vec2, vec3);
730  dst5 = const_vec;
731  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
732  dst5, dst5, dst5, dst5);
733 
734  ST_SH6(dst0, dst1, dst2, dst3, dst4, dst5, dst, 8);
735  dst += dst_stride;
736  }
737 }
738 
739 static void hevc_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
740  int16_t *dst, int32_t dst_stride,
741  const int8_t *filter, int32_t height)
742 {
743  uint32_t loop_cnt;
744  v16i8 src0, src1, src2, src3, src4;
745  v8i16 filt0, filt1, filt2, filt3;
746  v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
747  v16i8 vec0, vec1, vec2, vec3;
748  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
749  v8i16 filter_vec, const_vec;
750  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
751 
752  src -= 3;
753 
754  filter_vec = LD_SH(filter);
755  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
756 
757  mask1 = mask0 + 2;
758  mask2 = mask0 + 4;
759  mask3 = mask0 + 6;
760  mask4 = mask0 + 8;
761  mask5 = mask0 + 10;
762  mask6 = mask0 + 12;
763  mask7 = mask0 + 14;
764 
765  const_vec = __msa_ldi_h(128);
766  const_vec <<= 6;
767 
768  for (loop_cnt = height; loop_cnt--;) {
769  LD_SB4(src, 16, src0, src1, src2, src3);
770  src4 = LD_SB(src + 56);
771  src += src_stride;
772  XORI_B5_128_SB(src0, src1, src2, src3, src4);
773 
774  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
775  vec0, vec1, vec2, vec3);
776  dst0 = const_vec;
777  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
778  dst0, dst0, dst0, dst0);
779  ST_SH(dst0, dst);
780 
781  VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
782  vec0, vec1, vec2, vec3);
783  dst1 = const_vec;
784  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
785  dst1, dst1, dst1, dst1);
786  ST_SH(dst1, dst + 8);
787 
788  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
789  vec0, vec1, vec2, vec3);
790  dst2 = const_vec;
791  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
792  dst2, dst2, dst2, dst2);
793  ST_SH(dst2, dst + 16);
794 
795  VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
796  vec0, vec1, vec2, vec3);
797  dst3 = const_vec;
798  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
799  dst3, dst3, dst3, dst3);
800  ST_SH(dst3, dst + 24);
801 
802  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
803  vec0, vec1, vec2, vec3);
804  dst4 = const_vec;
805  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
806  dst4, dst4, dst4, dst4);
807  ST_SH(dst4, dst + 32);
808 
809  VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
810  vec0, vec1, vec2, vec3);
811  dst5 = const_vec;
812  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
813  dst5, dst5, dst5, dst5);
814  ST_SH(dst5, dst + 40);
815 
816  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
817  vec0, vec1, vec2, vec3);
818  dst6 = const_vec;
819  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
820  dst6, dst6, dst6, dst6);
821  ST_SH(dst6, dst + 48);
822 
823  VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
824  vec0, vec1, vec2, vec3);
825  dst7 = const_vec;
826  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
827  dst7, dst7, dst7, dst7);
828  ST_SH(dst7, dst + 56);
829  dst += dst_stride;
830  }
831 }
832 
833 static void hevc_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
834  int16_t *dst, int32_t dst_stride,
835  const int8_t *filter, int32_t height)
836 {
837  int32_t loop_cnt;
838  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
839  v16i8 src9, src10, src11, src12, src13, src14;
840  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
841  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
842  v16i8 src1110_r, src1211_r, src1312_r, src1413_r;
843  v16i8 src2110, src4332, src6554, src8776, src10998;
844  v16i8 src12111110, src14131312;
845  v8i16 dst10, dst32, dst54, dst76;
846  v8i16 filt0, filt1, filt2, filt3;
847  v8i16 filter_vec, const_vec;
848 
849  src -= (3 * src_stride);
850 
851  const_vec = __msa_ldi_h(128);
852  const_vec <<= 6;
853 
854  filter_vec = LD_SH(filter);
855  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
856 
857  LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
858  src += (7 * src_stride);
859  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
860  src10_r, src32_r, src54_r, src21_r);
861  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
862  ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
863  src2110, src4332, src6554);
864  XORI_B3_128_SB(src2110, src4332, src6554);
865 
866  for (loop_cnt = (height >> 3); loop_cnt--;) {
867  LD_SB8(src, src_stride,
868  src7, src8, src9, src10, src11, src12, src13, src14);
869  src += (8 * src_stride);
870 
871  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
872  src76_r, src87_r, src98_r, src109_r);
873  ILVR_B4_SB(src11, src10, src12, src11, src13, src12, src14, src13,
874  src1110_r, src1211_r, src1312_r, src1413_r);
875  ILVR_D4_SB(src87_r, src76_r, src109_r, src98_r,
876  src1211_r, src1110_r, src1413_r, src1312_r,
877  src8776, src10998, src12111110, src14131312);
878  XORI_B4_128_SB(src8776, src10998, src12111110, src14131312);
879 
880  dst10 = const_vec;
881  DPADD_SB4_SH(src2110, src4332, src6554, src8776,
882  filt0, filt1, filt2, filt3, dst10, dst10, dst10, dst10);
883  dst32 = const_vec;
884  DPADD_SB4_SH(src4332, src6554, src8776, src10998,
885  filt0, filt1, filt2, filt3, dst32, dst32, dst32, dst32);
886  dst54 = const_vec;
887  DPADD_SB4_SH(src6554, src8776, src10998, src12111110,
888  filt0, filt1, filt2, filt3, dst54, dst54, dst54, dst54);
889  dst76 = const_vec;
890  DPADD_SB4_SH(src8776, src10998, src12111110, src14131312,
891  filt0, filt1, filt2, filt3, dst76, dst76, dst76, dst76);
892 
893  ST8x8_UB(dst10, dst32, dst54, dst76, dst, 2 * dst_stride);
894  dst += (8 * dst_stride);
895 
896  src2110 = src10998;
897  src4332 = src12111110;
898  src6554 = src14131312;
899  src6 = src14;
900  }
901 }
902 
903 static void hevc_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
904  int16_t *dst, int32_t dst_stride,
905  const int8_t *filter, int32_t height)
906 {
907  int32_t loop_cnt;
908  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
909  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
910  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
911  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
912  v8i16 filter_vec, const_vec;
913  v8i16 filt0, filt1, filt2, filt3;
914 
915  src -= (3 * src_stride);
916  const_vec = __msa_ldi_h(128);
917  const_vec <<= 6;
918 
919  filter_vec = LD_SH(filter);
920  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
921 
922  LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
923  src += (7 * src_stride);
924  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
925  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
926  src10_r, src32_r, src54_r, src21_r);
927  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
928 
929  for (loop_cnt = (height >> 2); loop_cnt--;) {
930  LD_SB4(src, src_stride, src7, src8, src9, src10);
931  src += (4 * src_stride);
932  XORI_B4_128_SB(src7, src8, src9, src10);
933  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
934  src76_r, src87_r, src98_r, src109_r);
935 
936  dst0_r = const_vec;
937  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
938  filt0, filt1, filt2, filt3,
939  dst0_r, dst0_r, dst0_r, dst0_r);
940  dst1_r = const_vec;
941  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
942  filt0, filt1, filt2, filt3,
943  dst1_r, dst1_r, dst1_r, dst1_r);
944  dst2_r = const_vec;
945  DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
946  filt0, filt1, filt2, filt3,
947  dst2_r, dst2_r, dst2_r, dst2_r);
948  dst3_r = const_vec;
949  DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
950  filt0, filt1, filt2, filt3,
951  dst3_r, dst3_r, dst3_r, dst3_r);
952 
953  ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
954  dst += (4 * dst_stride);
955 
956  src10_r = src54_r;
957  src32_r = src76_r;
958  src54_r = src98_r;
959  src21_r = src65_r;
960  src43_r = src87_r;
961  src65_r = src109_r;
962  src6 = src10;
963  }
964 }
965 
966 static void hevc_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
967  int16_t *dst, int32_t dst_stride,
968  const int8_t *filter, int32_t height)
969 {
970  int32_t loop_cnt;
971  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
972  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
973  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
974  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
975  v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
976  v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
977  v16i8 src2110, src4332, src6554, src8776, src10998;
978  v8i16 dst0_l, dst1_l;
979  v8i16 filter_vec, const_vec;
980  v8i16 filt0, filt1, filt2, filt3;
981 
982  src -= (3 * src_stride);
983  const_vec = __msa_ldi_h(128);
984  const_vec <<= 6;
985 
986  filter_vec = LD_SH(filter);
987  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
988 
989  LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
990  src += (7 * src_stride);
991  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
992  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
993  src10_r, src32_r, src54_r, src21_r);
994  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
995  ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
996  src10_l, src32_l, src54_l, src21_l);
997  ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
998  ILVR_D3_SB(src21_l, src10_l, src43_l, src32_l, src65_l, src54_l,
999  src2110, src4332, src6554);
1000 
1001  for (loop_cnt = (height >> 2); loop_cnt--;) {
1002  LD_SB4(src, src_stride, src7, src8, src9, src10);
1003  src += (4 * src_stride);
1004  XORI_B4_128_SB(src7, src8, src9, src10);
1005  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1006  src76_r, src87_r, src98_r, src109_r);
1007  ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1008  src76_l, src87_l, src98_l, src109_l);
1009  ILVR_D2_SB(src87_l, src76_l, src109_l, src98_l, src8776, src10998);
1010 
1011  dst0_r = const_vec;
1012  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1013  filt0, filt1, filt2, filt3,
1014  dst0_r, dst0_r, dst0_r, dst0_r);
1015  dst1_r = const_vec;
1016  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1017  filt0, filt1, filt2, filt3,
1018  dst1_r, dst1_r, dst1_r, dst1_r);
1019  dst2_r = const_vec;
1020  DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1021  filt0, filt1, filt2, filt3,
1022  dst2_r, dst2_r, dst2_r, dst2_r);
1023  dst3_r = const_vec;
1024  DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1025  filt0, filt1, filt2, filt3,
1026  dst3_r, dst3_r, dst3_r, dst3_r);
1027  dst0_l = const_vec;
1028  DPADD_SB4_SH(src2110, src4332, src6554, src8776,
1029  filt0, filt1, filt2, filt3,
1030  dst0_l, dst0_l, dst0_l, dst0_l);
1031  dst1_l = const_vec;
1032  DPADD_SB4_SH(src4332, src6554, src8776, src10998,
1033  filt0, filt1, filt2, filt3,
1034  dst1_l, dst1_l, dst1_l, dst1_l);
1035 
1036  ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
1037  ST8x4_UB(dst0_l, dst1_l, dst + 8, 2 * dst_stride);
1038  dst += (4 * dst_stride);
1039 
1040  src10_r = src54_r;
1041  src32_r = src76_r;
1042  src54_r = src98_r;
1043  src21_r = src65_r;
1044  src43_r = src87_r;
1045  src65_r = src109_r;
1046  src2110 = src6554;
1047  src4332 = src8776;
1048  src6554 = src10998;
1049  src6 = src10;
1050  }
1051 }
1052 
1053 static void hevc_vt_8t_16multx4mult_msa(uint8_t *src,
1054  int32_t src_stride,
1055  int16_t *dst,
1056  int32_t dst_stride,
1057  const int8_t *filter,
1058  int32_t height,
1059  int32_t width)
1060 {
1061  uint8_t *src_tmp;
1062  int16_t *dst_tmp;
1063  int32_t loop_cnt, cnt;
1064  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
1065  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
1066  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
1067  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
1068  v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
1069  v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
1070  v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
1071  v8i16 filter_vec, const_vec;
1072  v8i16 filt0, filt1, filt2, filt3;
1073 
1074  src -= (3 * src_stride);
1075  const_vec = __msa_ldi_h(128);
1076  const_vec <<= 6;
1077 
1078  filter_vec = LD_SH(filter);
1079  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1080 
1081  for (cnt = width >> 4; cnt--;) {
1082  src_tmp = src;
1083  dst_tmp = dst;
1084 
1085  LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
1086  src_tmp += (7 * src_stride);
1087  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1088  ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1089  src10_r, src32_r, src54_r, src21_r);
1090  ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
1091  ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
1092  src10_l, src32_l, src54_l, src21_l);
1093  ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
1094 
1095  for (loop_cnt = (height >> 2); loop_cnt--;) {
1096  LD_SB4(src_tmp, src_stride, src7, src8, src9, src10);
1097  src_tmp += (4 * src_stride);
1098  XORI_B4_128_SB(src7, src8, src9, src10);
1099  ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1100  src76_r, src87_r, src98_r, src109_r);
1101  ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
1102  src76_l, src87_l, src98_l, src109_l);
1103 
1104  dst0_r = const_vec;
1105  DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
1106  filt0, filt1, filt2, filt3,
1107  dst0_r, dst0_r, dst0_r, dst0_r);
1108  dst1_r = const_vec;
1109  DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
1110  filt0, filt1, filt2, filt3,
1111  dst1_r, dst1_r, dst1_r, dst1_r);
1112  dst2_r = const_vec;
1113  DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
1114  filt0, filt1, filt2, filt3,
1115  dst2_r, dst2_r, dst2_r, dst2_r);
1116  dst3_r = const_vec;
1117  DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
1118  filt0, filt1, filt2, filt3,
1119  dst3_r, dst3_r, dst3_r, dst3_r);
1120  dst0_l = const_vec;
1121  DPADD_SB4_SH(src10_l, src32_l, src54_l, src76_l,
1122  filt0, filt1, filt2, filt3,
1123  dst0_l, dst0_l, dst0_l, dst0_l);
1124  dst1_l = const_vec;
1125  DPADD_SB4_SH(src21_l, src43_l, src65_l, src87_l,
1126  filt0, filt1, filt2, filt3,
1127  dst1_l, dst1_l, dst1_l, dst1_l);
1128  dst2_l = const_vec;
1129  DPADD_SB4_SH(src32_l, src54_l, src76_l, src98_l,
1130  filt0, filt1, filt2, filt3,
1131  dst2_l, dst2_l, dst2_l, dst2_l);
1132  dst3_l = const_vec;
1133  DPADD_SB4_SH(src43_l, src65_l, src87_l, src109_l,
1134  filt0, filt1, filt2, filt3,
1135  dst3_l, dst3_l, dst3_l, dst3_l);
1136 
1137  ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst_tmp, dst_stride);
1138  ST_SH4(dst0_l, dst1_l, dst2_l, dst3_l, dst_tmp + 8, dst_stride);
1139  dst_tmp += (4 * dst_stride);
1140 
1141  src10_r = src54_r;
1142  src32_r = src76_r;
1143  src54_r = src98_r;
1144  src21_r = src65_r;
1145  src43_r = src87_r;
1146  src65_r = src109_r;
1147  src10_l = src54_l;
1148  src32_l = src76_l;
1149  src54_l = src98_l;
1150  src21_l = src65_l;
1151  src43_l = src87_l;
1152  src65_l = src109_l;
1153  src6 = src10;
1154  }
1155 
1156  src += 16;
1157  dst += 16;
1158  }
1159 }
1160 
1161 static void hevc_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
1162  int16_t *dst, int32_t dst_stride,
1163  const int8_t *filter, int32_t height)
1164 {
1165  hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
1166  filter, height, 16);
1167 }
1168 
1169 static void hevc_vt_8t_24w_msa(uint8_t *src, int32_t src_stride,
1170  int16_t *dst, int32_t dst_stride,
1171  const int8_t *filter, int32_t height)
1172 {
1173  hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
1174  filter, height, 16);
1175  hevc_vt_8t_8w_msa(src + 16, src_stride, dst + 16, dst_stride,
1176  filter, height);
1177 }
1178 
1179 static void hevc_vt_8t_32w_msa(uint8_t *src, int32_t src_stride,
1180  int16_t *dst, int32_t dst_stride,
1181  const int8_t *filter, int32_t height)
1182 {
1183  hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
1184  filter, height, 32);
1185 }
1186 
1187 static void hevc_vt_8t_48w_msa(uint8_t *src, int32_t src_stride,
1188  int16_t *dst, int32_t dst_stride,
1189  const int8_t *filter, int32_t height)
1190 {
1191  hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
1192  filter, height, 48);
1193 }
1194 
1195 static void hevc_vt_8t_64w_msa(uint8_t *src, int32_t src_stride,
1196  int16_t *dst, int32_t dst_stride,
1197  const int8_t *filter, int32_t height)
1198 {
1199  hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
1200  filter, height, 64);
1201 }
1202 
1203 static void hevc_hv_8t_4w_msa(uint8_t *src, int32_t src_stride,
1204  int16_t *dst, int32_t dst_stride,
1205  const int8_t *filter_x, const int8_t *filter_y,
1206  int32_t height)
1207 {
1208  uint32_t loop_cnt;
1209  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1210  v8i16 filt0, filt1, filt2, filt3;
1211  v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
1212  v16i8 mask1, mask2, mask3;
1213  v8i16 filter_vec, const_vec;
1214  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1215  v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1216  v8i16 dst30, dst41, dst52, dst63, dst66, dst87;
1217  v4i32 dst0_r, dst1_r;
1218  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1219  v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
1220  v16i8 mask0 = {
1221  0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20
1222  };
1223  v8u16 mask4 = { 0, 4, 1, 5, 2, 6, 3, 7 };
1224 
1225  src -= ((3 * src_stride) + 3);
1226  filter_vec = LD_SH(filter_x);
1227  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1228 
1229  filter_vec = LD_SH(filter_y);
1230  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
1231  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
1232 
1233  SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1234 
1235  mask1 = mask0 + 2;
1236  mask2 = mask0 + 4;
1237  mask3 = mask0 + 6;
1238 
1239  const_vec = __msa_ldi_h(128);
1240  const_vec <<= 6;
1241 
1242  LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
1243  src += (7 * src_stride);
1244  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1245 
1246  VSHF_B4_SB(src0, src3, mask0, mask1, mask2, mask3, vec0, vec1, vec2, vec3);
1247  VSHF_B4_SB(src1, src4, mask0, mask1, mask2, mask3, vec4, vec5, vec6, vec7);
1248  VSHF_B4_SB(src2, src5, mask0, mask1, mask2, mask3,
1249  vec8, vec9, vec10, vec11);
1250  VSHF_B4_SB(src3, src6, mask0, mask1, mask2, mask3,
1251  vec12, vec13, vec14, vec15);
1252  dst30 = const_vec;
1253  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1254  dst30, dst30, dst30, dst30);
1255  dst41 = const_vec;
1256  DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1257  dst41, dst41, dst41, dst41);
1258  dst52 = const_vec;
1259  DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1260  dst52, dst52, dst52, dst52);
1261  dst63 = const_vec;
1262  DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
1263  dst63, dst63, dst63, dst63);
1264 
1265  ILVR_H3_SH(dst41, dst30, dst52, dst41, dst63, dst52,
1266  dst10_r, dst21_r, dst32_r);
1267  dst43_r = __msa_ilvl_h(dst41, dst30);
1268  dst54_r = __msa_ilvl_h(dst52, dst41);
1269  dst65_r = __msa_ilvl_h(dst63, dst52);
1270  dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
1271 
1272  for (loop_cnt = height >> 1; loop_cnt--;) {
1273  LD_SB2(src, src_stride, src7, src8);
1274  src += (2 * src_stride);
1275  XORI_B2_128_SB(src7, src8);
1276 
1277  VSHF_B4_SB(src7, src8, mask0, mask1, mask2, mask3,
1278  vec0, vec1, vec2, vec3);
1279  dst87 = const_vec;
1280  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1281  dst87, dst87, dst87, dst87);
1282  dst76_r = __msa_ilvr_h(dst87, dst66);
1283  dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
1284  filt_h0, filt_h1, filt_h2, filt_h3);
1285  dst87_r = __msa_vshf_h((v8i16) mask4, dst87, dst87);
1286  dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
1287  filt_h0, filt_h1, filt_h2, filt_h3);
1288  dst0_r >>= 6;
1289  dst1_r >>= 6;
1290 
1291  dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
1292  ST8x2_UB(dst0_r, dst, (2 * dst_stride));
1293  dst += (2 * dst_stride);
1294 
1295  dst10_r = dst32_r;
1296  dst32_r = dst54_r;
1297  dst54_r = dst76_r;
1298  dst21_r = dst43_r;
1299  dst43_r = dst65_r;
1300  dst65_r = dst87_r;
1301  dst66 = (v8i16) __msa_splati_d((v2i64) dst87, 1);
1302  }
1303 }
1304 
1305 static void hevc_hv_8t_8multx2mult_msa(uint8_t *src,
1306  int32_t src_stride,
1307  int16_t *dst,
1308  int32_t dst_stride,
1309  const int8_t *filter_x,
1310  const int8_t *filter_y,
1311  int32_t height, int32_t width)
1312 {
1313  uint32_t loop_cnt, cnt;
1314  uint8_t *src_tmp;
1315  int16_t *dst_tmp;
1316  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1317  v8i16 filt0, filt1, filt2, filt3;
1318  v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
1319  v16i8 mask1, mask2, mask3;
1320  v8i16 filter_vec, const_vec;
1321  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
1322  v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
1323  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
1324  v4i32 dst0_r, dst0_l;
1325  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
1326  v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
1327  v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
1328  v8i16 dst21_l, dst43_l, dst65_l, dst87_l;
1329  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1330 
1331  src -= ((3 * src_stride) + 3);
1332  filter_vec = LD_SH(filter_x);
1333  SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
1334 
1335  filter_vec = LD_SH(filter_y);
1336  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
1337  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
1338 
1339  SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
1340 
1341  mask1 = mask0 + 2;
1342  mask2 = mask0 + 4;
1343  mask3 = mask0 + 6;
1344 
1345  const_vec = __msa_ldi_h(128);
1346  const_vec <<= 6;
1347 
1348  for (cnt = width >> 3; cnt--;) {
1349  src_tmp = src;
1350  dst_tmp = dst;
1351 
1352  LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
1353  src_tmp += (7 * src_stride);
1354  XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
1355 
1356  /* row 0 row 1 row 2 row 3 */
1357  VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
1358  vec0, vec1, vec2, vec3);
1359  VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
1360  vec4, vec5, vec6, vec7);
1361  VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
1362  vec8, vec9, vec10, vec11);
1363  VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
1364  vec12, vec13, vec14, vec15);
1365  dst0 = const_vec;
1366  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1367  dst0, dst0, dst0, dst0);
1368  dst1 = const_vec;
1369  DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1370  dst1, dst1, dst1, dst1);
1371  dst2 = const_vec;
1372  DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1373  dst2, dst2, dst2, dst2);
1374  dst3 = const_vec;
1375  DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
1376  dst3, dst3, dst3, dst3);
1377 
1378  /* row 4 row 5 row 6 */
1379  VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
1380  vec0, vec1, vec2, vec3);
1381  VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
1382  vec4, vec5, vec6, vec7);
1383  VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
1384  vec8, vec9, vec10, vec11);
1385  dst4 = const_vec;
1386  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1387  dst4, dst4, dst4, dst4);
1388  dst5 = const_vec;
1389  DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
1390  dst5, dst5, dst5, dst5);
1391  dst6 = const_vec;
1392  DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
1393  dst6, dst6, dst6, dst6);
1394 
1395  ILVR_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
1396  dst10_r, dst32_r, dst54_r, dst21_r);
1397  ILVR_H2_SH(dst4, dst3, dst6, dst5, dst43_r, dst65_r);
1398  ILVL_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
1399  dst10_l, dst32_l, dst54_l, dst21_l);
1400  ILVL_H2_SH(dst4, dst3, dst6, dst5, dst43_l, dst65_l);
1401 
1402  for (loop_cnt = height >> 1; loop_cnt--;) {
1403  LD_SB2(src_tmp, src_stride, src7, src8);
1404  XORI_B2_128_SB(src7, src8);
1405  src_tmp += 2 * src_stride;
1406 
1407  VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
1408  vec0, vec1, vec2, vec3);
1409  dst7 = const_vec;
1410  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1411  dst7, dst7, dst7, dst7);
1412 
1413  ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
1414  dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
1415  filt_h0, filt_h1, filt_h2, filt_h3);
1416  dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l,
1417  filt_h0, filt_h1, filt_h2, filt_h3);
1418  dst0_r >>= 6;
1419  dst0_l >>= 6;
1420 
1421  dst0_r = (v4i32) __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
1422  ST_SW(dst0_r, dst_tmp);
1423  dst_tmp += dst_stride;
1424 
1425  VSHF_B4_SB(src8, src8, mask0, mask1, mask2, mask3,
1426  vec0, vec1, vec2, vec3);
1427  dst8 = const_vec;
1428  DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
1429  dst8, dst8, dst8, dst8);
1430 
1431  ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
1432  dst6 = dst8;
1433  dst0_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
1434  filt_h0, filt_h1, filt_h2, filt_h3);
1435  dst0_l = HEVC_FILT_8TAP(dst21_l, dst43_l, dst65_l, dst87_l,
1436  filt_h0, filt_h1, filt_h2, filt_h3);
1437  dst0_r >>= 6;
1438  dst0_l >>= 6;
1439 
1440  dst0_r = (v4i32) __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
1441  ST_SW(dst0_r, dst_tmp);
1442  dst_tmp += dst_stride;
1443 
1444  dst10_r = dst32_r;
1445  dst32_r = dst54_r;
1446  dst54_r = dst76_r;
1447  dst10_l = dst32_l;
1448  dst32_l = dst54_l;
1449  dst54_l = dst76_l;
1450  dst21_r = dst43_r;
1451  dst43_r = dst65_r;
1452  dst65_r = dst87_r;
1453  dst21_l = dst43_l;
1454  dst43_l = dst65_l;
1455  dst65_l = dst87_l;
1456  }
1457 
1458  src += 8;
1459  dst += 8;
1460  }
1461 }
1462 
1463 static void hevc_hv_8t_8w_msa(uint8_t *src, int32_t src_stride,
1464  int16_t *dst, int32_t dst_stride,
1465  const int8_t *filter_x, const int8_t *filter_y,
1466  int32_t height)
1467 {
1468  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1469  filter_x, filter_y, height, 8);
1470 }
1471 
1472 static void hevc_hv_8t_12w_msa(uint8_t *src, int32_t src_stride,
1473  int16_t *dst, int32_t dst_stride,
1474  const int8_t *filter_x, const int8_t *filter_y,
1475  int32_t height)
1476 {
1477  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1478  filter_x, filter_y, height, 8);
1479 
1480  hevc_hv_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
1481  filter_x, filter_y, height);
1482 }
1483 
1484 static void hevc_hv_8t_16w_msa(uint8_t *src, int32_t src_stride,
1485  int16_t *dst, int32_t dst_stride,
1486  const int8_t *filter_x, const int8_t *filter_y,
1487  int32_t height)
1488 {
1489  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1490  filter_x, filter_y, height, 16);
1491 }
1492 
1493 static void hevc_hv_8t_24w_msa(uint8_t *src, int32_t src_stride,
1494  int16_t *dst, int32_t dst_stride,
1495  const int8_t *filter_x, const int8_t *filter_y,
1496  int32_t height)
1497 {
1498  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1499  filter_x, filter_y, height, 24);
1500 }
1501 
1502 static void hevc_hv_8t_32w_msa(uint8_t *src, int32_t src_stride,
1503  int16_t *dst, int32_t dst_stride,
1504  const int8_t *filter_x, const int8_t *filter_y,
1505  int32_t height)
1506 {
1507  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1508  filter_x, filter_y, height, 32);
1509 }
1510 
1511 static void hevc_hv_8t_48w_msa(uint8_t *src, int32_t src_stride,
1512  int16_t *dst, int32_t dst_stride,
1513  const int8_t *filter_x, const int8_t *filter_y,
1514  int32_t height)
1515 {
1516  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1517  filter_x, filter_y, height, 48);
1518 }
1519 
1520 static void hevc_hv_8t_64w_msa(uint8_t *src, int32_t src_stride,
1521  int16_t *dst, int32_t dst_stride,
1522  const int8_t *filter_x, const int8_t *filter_y,
1523  int32_t height)
1524 {
1525  hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
1526  filter_x, filter_y, height, 64);
1527 }
1528 
1529 static void hevc_hz_4t_4x2_msa(uint8_t *src,
1530  int32_t src_stride,
1531  int16_t *dst,
1532  int32_t dst_stride,
1533  const int8_t *filter)
1534 {
1535  v8i16 filt0, filt1;
1536  v16i8 src0, src1;
1537  v16i8 mask1, vec0, vec1;
1538  v8i16 dst0;
1539  v8i16 filter_vec, const_vec;
1540  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1541 
1542  src -= 1;
1543 
1544  filter_vec = LD_SH(filter);
1545  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1546 
1547  mask1 = mask0 + 2;
1548 
1549  const_vec = __msa_ldi_h(128);
1550  const_vec <<= 6;
1551 
1552  LD_SB2(src, src_stride, src0, src1);
1553  XORI_B2_128_SB(src0, src1);
1554 
1555  VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1556  dst0 = const_vec;
1557  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1558 
1559  ST8x2_UB(dst0, dst, 2 * dst_stride);
1560 }
1561 
1562 static void hevc_hz_4t_4x4_msa(uint8_t *src,
1563  int32_t src_stride,
1564  int16_t *dst,
1565  int32_t dst_stride,
1566  const int8_t *filter)
1567 {
1568  v8i16 filt0, filt1;
1569  v16i8 src0, src1, src2, src3;
1570  v16i8 mask1, vec0, vec1;
1571  v8i16 dst0, dst1;
1572  v8i16 filter_vec, const_vec;
1573  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1574 
1575  src -= 1;
1576 
1577  filter_vec = LD_SH(filter);
1578  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1579 
1580  mask1 = mask0 + 2;
1581 
1582  const_vec = __msa_ldi_h(128);
1583  const_vec <<= 6;
1584 
1585  LD_SB4(src, src_stride, src0, src1, src2, src3);
1586  XORI_B4_128_SB(src0, src1, src2, src3);
1587 
1588  VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1589  dst0 = const_vec;
1590  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1591 
1592  VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
1593  dst1 = const_vec;
1594  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1595 
1596  ST8x4_UB(dst0, dst1, dst, 2 * dst_stride);
1597 }
1598 
1599 static void hevc_hz_4t_4x8multiple_msa(uint8_t *src,
1600  int32_t src_stride,
1601  int16_t *dst,
1602  int32_t dst_stride,
1603  const int8_t *filter,
1604  int32_t height)
1605 {
1606  uint32_t loop_cnt;
1607  v8i16 filt0, filt1;
1608  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
1609  v16i8 mask1, vec0, vec1;
1610  v8i16 dst0, dst1, dst2, dst3;
1611  v8i16 filter_vec, const_vec;
1612  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
1613 
1614  src -= 1;
1615 
1616  filter_vec = LD_SH(filter);
1617  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1618 
1619  mask1 = mask0 + 2;
1620 
1621  const_vec = __msa_ldi_h(128);
1622  const_vec <<= 6;
1623 
1624  for (loop_cnt = (height >> 3); loop_cnt--;) {
1625  LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
1626  src += (8 * src_stride);
1627 
1628  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
1629 
1630  VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
1631  dst0 = const_vec;
1632  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1633  VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
1634  dst1 = const_vec;
1635  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1636  VSHF_B2_SB(src4, src5, src4, src5, mask0, mask1, vec0, vec1);
1637  dst2 = const_vec;
1638  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
1639  VSHF_B2_SB(src6, src7, src6, src7, mask0, mask1, vec0, vec1);
1640  dst3 = const_vec;
1641  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
1642 
1643  ST8x8_UB(dst0, dst1, dst2, dst3, dst, 2 * dst_stride);
1644  dst += (8 * dst_stride);
1645  }
1646 }
1647 
1648 static void hevc_hz_4t_4w_msa(uint8_t *src,
1649  int32_t src_stride,
1650  int16_t *dst,
1651  int32_t dst_stride,
1652  const int8_t *filter,
1653  int32_t height)
1654 {
1655  if (2 == height) {
1656  hevc_hz_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
1657  } else if (4 == height) {
1658  hevc_hz_4t_4x4_msa(src, src_stride, dst, dst_stride, filter);
1659  } else if (0 == height % 8) {
1660  hevc_hz_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
1661  filter, height);
1662  }
1663 }
1664 
1665 static void hevc_hz_4t_6w_msa(uint8_t *src,
1666  int32_t src_stride,
1667  int16_t *dst,
1668  int32_t dst_stride,
1669  const int8_t *filter,
1670  int32_t height)
1671 {
1672  uint32_t loop_cnt;
1673  uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
1674  uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
1675  v8i16 filt0, filt1, dst0, dst1, dst2, dst3;
1676  v16i8 src0, src1, src2, src3;
1677  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1678  v16i8 mask1;
1679  v16i8 vec0, vec1;
1680  v8i16 filter_vec, const_vec;
1681 
1682  src -= 1;
1683 
1684  filter_vec = LD_SH(filter);
1685  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1686 
1687  mask1 = mask0 + 2;
1688 
1689  const_vec = __msa_ldi_h(128);
1690  const_vec <<= 6;
1691 
1692  for (loop_cnt = (height >> 2); loop_cnt--;) {
1693  LD_SB4(src, src_stride, src0, src1, src2, src3);
1694  src += (4 * src_stride);
1695 
1696  XORI_B4_128_SB(src0, src1, src2, src3);
1697 
1698  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
1699  dst0 = const_vec;
1700  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1701  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
1702  dst1 = const_vec;
1703  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1704  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
1705  dst2 = const_vec;
1706  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
1707  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
1708  dst3 = const_vec;
1709  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
1710 
1711  dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
1712  dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
1713  dst_val2 = __msa_copy_u_d((v2i64) dst2, 0);
1714  dst_val3 = __msa_copy_u_d((v2i64) dst3, 0);
1715 
1716  dst_val_int0 = __msa_copy_u_w((v4i32) dst0, 2);
1717  dst_val_int1 = __msa_copy_u_w((v4i32) dst1, 2);
1718  dst_val_int2 = __msa_copy_u_w((v4i32) dst2, 2);
1719  dst_val_int3 = __msa_copy_u_w((v4i32) dst3, 2);
1720 
1721  SD(dst_val0, dst);
1722  SW(dst_val_int0, dst + 4);
1723  dst += dst_stride;
1724  SD(dst_val1, dst);
1725  SW(dst_val_int1, dst + 4);
1726  dst += dst_stride;
1727  SD(dst_val2, dst);
1728  SW(dst_val_int2, dst + 4);
1729  dst += dst_stride;
1730  SD(dst_val3, dst);
1731  SW(dst_val_int3, dst + 4);
1732  dst += dst_stride;
1733  }
1734 }
1735 
1736 static void hevc_hz_4t_8x2multiple_msa(uint8_t *src,
1737  int32_t src_stride,
1738  int16_t *dst,
1739  int32_t dst_stride,
1740  const int8_t *filter,
1741  int32_t height)
1742 {
1743  uint32_t loop_cnt;
1744  v8i16 filt0, filt1, dst0, dst1;
1745  v16i8 src0, src1;
1746  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1747  v16i8 mask1;
1748  v16i8 vec0, vec1;
1749  v8i16 filter_vec, const_vec;
1750 
1751  src -= 1;
1752 
1753  filter_vec = LD_SH(filter);
1754  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1755 
1756  mask1 = mask0 + 2;
1757 
1758  const_vec = __msa_ldi_h(128);
1759  const_vec <<= 6;
1760 
1761  for (loop_cnt = (height >> 1); loop_cnt--;) {
1762  LD_SB2(src, src_stride, src0, src1);
1763  src += (2 * src_stride);
1764 
1765  XORI_B2_128_SB(src0, src1);
1766 
1767  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
1768  dst0 = const_vec;
1769  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1770 
1771  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
1772  dst1 = const_vec;
1773  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1774 
1775  ST_SH2(dst0, dst1, dst, dst_stride);
1776  dst += (2 * dst_stride);
1777  }
1778 }
1779 
1780 static void hevc_hz_4t_8x4multiple_msa(uint8_t *src,
1781  int32_t src_stride,
1782  int16_t *dst,
1783  int32_t dst_stride,
1784  const int8_t *filter,
1785  int32_t height)
1786 {
1787  uint32_t loop_cnt;
1788  v8i16 filt0, filt1;
1789  v16i8 src0, src1, src2, src3;
1790  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1791  v16i8 mask1;
1792  v16i8 vec0, vec1;
1793  v8i16 dst0, dst1, dst2, dst3;
1794  v8i16 filter_vec, const_vec;
1795 
1796  src -= 1;
1797 
1798  filter_vec = LD_SH(filter);
1799  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1800 
1801  mask1 = mask0 + 2;
1802 
1803  const_vec = __msa_ldi_h(128);
1804  const_vec <<= 6;
1805 
1806  for (loop_cnt = (height >> 2); loop_cnt--;) {
1807  LD_SB4(src, src_stride, src0, src1, src2, src3);
1808  src += (4 * src_stride);
1809 
1810  XORI_B4_128_SB(src0, src1, src2, src3);
1811 
1812  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
1813  dst0 = const_vec;
1814  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1815 
1816  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
1817  dst1 = const_vec;
1818  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1819 
1820  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
1821  dst2 = const_vec;
1822  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
1823 
1824  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
1825  dst3 = const_vec;
1826  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
1827 
1828  ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
1829  dst += (4 * dst_stride);
1830  }
1831 }
1832 
1833 static void hevc_hz_4t_8w_msa(uint8_t *src,
1834  int32_t src_stride,
1835  int16_t *dst,
1836  int32_t dst_stride,
1837  const int8_t *filter,
1838  int32_t height)
1839 {
1840  if (2 == height || 6 == height) {
1841  hevc_hz_4t_8x2multiple_msa(src, src_stride, dst, dst_stride,
1842  filter, height);
1843  } else {
1844  hevc_hz_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
1845  filter, height);
1846  }
1847 }
1848 
1849 static void hevc_hz_4t_12w_msa(uint8_t *src,
1850  int32_t src_stride,
1851  int16_t *dst,
1852  int32_t dst_stride,
1853  const int8_t *filter,
1854  int32_t height)
1855 {
1856  uint32_t loop_cnt;
1857  v8i16 filt0, filt1;
1858  v16i8 src0, src1, src2, src3;
1859  v16i8 mask1;
1860  v16i8 vec0, vec1;
1861  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
1862  v8i16 filter_vec, const_vec;
1863  v16i8 mask3;
1864  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1865  v16i8 mask2 = {
1866  8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
1867  };
1868 
1869  src -= 1;
1870 
1871  filter_vec = LD_SH(filter);
1872  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1873 
1874  mask1 = mask0 + 2;
1875  mask3 = mask2 + 2;
1876 
1877  const_vec = __msa_ldi_h(128);
1878  const_vec <<= 6;
1879 
1880  for (loop_cnt = (height >> 2); loop_cnt--;) {
1881  LD_SB4(src, src_stride, src0, src1, src2, src3);
1882  src += (4 * src_stride);
1883  XORI_B4_128_SB(src0, src1, src2, src3);
1884 
1885  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
1886  dst0 = const_vec;
1887  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1888  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
1889  dst1 = const_vec;
1890  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1891  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
1892  dst2 = const_vec;
1893  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
1894  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
1895  dst3 = const_vec;
1896  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
1897  VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
1898  dst4 = const_vec;
1899  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
1900  VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
1901  dst5 = const_vec;
1902  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
1903 
1904  ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
1905  ST8x4_UB(dst4, dst5, dst + 8, 2 * dst_stride);
1906  dst += (4 * dst_stride);
1907  }
1908 }
1909 
1910 static void hevc_hz_4t_16w_msa(uint8_t *src,
1911  int32_t src_stride,
1912  int16_t *dst,
1913  int32_t dst_stride,
1914  const int8_t *filter,
1915  int32_t height)
1916 {
1917  uint32_t loop_cnt;
1918  v16i8 src0, src1, src2, src3;
1919  v16i8 src4, src5, src6, src7;
1920  v8i16 filt0, filt1;
1921  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1922  v16i8 mask1;
1923  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1924  v16i8 vec0, vec1;
1925  v8i16 filter_vec, const_vec;
1926 
1927  src -= 1;
1928 
1929  filter_vec = LD_SH(filter);
1930  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
1931 
1932  mask1 = mask0 + 2;
1933 
1934  const_vec = __msa_ldi_h(128);
1935  const_vec <<= 6;
1936 
1937  for (loop_cnt = (height >> 2); loop_cnt--;) {
1938  LD_SB4(src, src_stride, src0, src2, src4, src6);
1939  LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
1940  src += (4 * src_stride);
1941 
1942  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
1943 
1944  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
1945  dst0 = const_vec;
1946  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
1947 
1948  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
1949  dst1 = const_vec;
1950  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
1951 
1952  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
1953  dst2 = const_vec;
1954  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
1955 
1956  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
1957  dst3 = const_vec;
1958  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
1959 
1960  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
1961  dst4 = const_vec;
1962  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
1963 
1964  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
1965  dst5 = const_vec;
1966  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
1967 
1968  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
1969  dst6 = const_vec;
1970  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
1971 
1972  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
1973  dst7 = const_vec;
1974  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
1975 
1976  ST_SH4(dst0, dst2, dst4, dst6, dst, dst_stride);
1977  ST_SH4(dst1, dst3, dst5, dst7, dst + 8, dst_stride);
1978  dst += (4 * dst_stride);
1979  }
1980 }
1981 
1982 static void hevc_hz_4t_24w_msa(uint8_t *src,
1983  int32_t src_stride,
1984  int16_t *dst,
1985  int32_t dst_stride,
1986  const int8_t *filter,
1987  int32_t height)
1988 {
1989  uint32_t loop_cnt;
1990  int16_t *dst_tmp = dst + 16;
1991  v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
1992  v8i16 filt0, filt1;
1993  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
1994  v16i8 mask1, mask00, mask11;
1995  v16i8 vec0, vec1;
1996  v8i16 dst0, dst1, dst2, dst3;
1997  v8i16 filter_vec, const_vec;
1998 
1999  src -= 1;
2000 
2001  filter_vec = LD_SH(filter);
2002  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2003 
2004  mask1 = mask0 + 2;
2005  mask00 = mask0 + 8;
2006  mask11 = mask0 + 10;
2007 
2008  const_vec = __msa_ldi_h(128);
2009  const_vec <<= 6;
2010 
2011  for (loop_cnt = (height >> 2); loop_cnt--;) {
2012  /* 16 width */
2013  LD_SB4(src, src_stride, src0, src2, src4, src6);
2014  LD_SB4(src + 16, src_stride, src1, src3, src5, src7);
2015  src += (4 * src_stride);
2016 
2017  XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2018 
2019  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2020  dst0 = const_vec;
2021  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2022 
2023  VSHF_B2_SB(src0, src1, src0, src1, mask00, mask11, vec0, vec1);
2024  dst1 = const_vec;
2025  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2026 
2027  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2028  dst2 = const_vec;
2029  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2030 
2031  VSHF_B2_SB(src2, src3, src2, src3, mask00, mask11, vec0, vec1);
2032  dst3 = const_vec;
2033  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2034 
2035  ST_SH2(dst0, dst1, dst, 8);
2036  dst += dst_stride;
2037  ST_SH2(dst2, dst3, dst, 8);
2038  dst += dst_stride;
2039 
2040  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2041  dst0 = const_vec;
2042  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2043 
2044  VSHF_B2_SB(src4, src5, src4, src5, mask00, mask11, vec0, vec1);
2045  dst1 = const_vec;
2046  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2047 
2048  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
2049  dst2 = const_vec;
2050  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2051 
2052  VSHF_B2_SB(src6, src7, src6, src7, mask00, mask11, vec0, vec1);
2053  dst3 = const_vec;
2054  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2055 
2056  ST_SH2(dst0, dst1, dst, 8);
2057  dst += dst_stride;
2058  ST_SH2(dst2, dst3, dst, 8);
2059  dst += dst_stride;
2060 
2061  /* 8 width */
2062  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2063  dst0 = const_vec;
2064  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2065 
2066  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2067  dst1 = const_vec;
2068  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2069 
2070  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2071  dst2 = const_vec;
2072  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2073 
2074  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
2075  dst3 = const_vec;
2076  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2077 
2078  ST_SH4(dst0, dst1, dst2, dst3, dst_tmp, dst_stride);
2079  dst_tmp += (4 * dst_stride);
2080  }
2081 }
2082 
2083 static void hevc_hz_4t_32w_msa(uint8_t *src,
2084  int32_t src_stride,
2085  int16_t *dst,
2086  int32_t dst_stride,
2087  const int8_t *filter,
2088  int32_t height)
2089 {
2090  uint32_t loop_cnt;
2091  v16i8 src0, src1, src2;
2092  v8i16 filt0, filt1;
2093  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2094  v16i8 mask1, mask2, mask3;
2095  v8i16 dst0, dst1, dst2, dst3;
2096  v16i8 vec0, vec1;
2097  v8i16 filter_vec, const_vec;
2098 
2099  src -= 1;
2100 
2101  filter_vec = LD_SH(filter);
2102  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2103 
2104  const_vec = __msa_ldi_h(128);
2105  const_vec <<= 6;
2106 
2107  mask1 = mask0 + 2;
2108  mask2 = mask0 + 8;
2109  mask3 = mask0 + 10;
2110 
2111  for (loop_cnt = (height >> 1); loop_cnt--;) {
2112  LD_SB2(src, 16, src0, src1);
2113  src2 = LD_SB(src + 24);
2114  src += src_stride;
2115 
2116  XORI_B3_128_SB(src0, src1, src2);
2117 
2118  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2119  dst0 = const_vec;
2120  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2121 
2122  VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2123  dst1 = const_vec;
2124  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2125 
2126  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2127  dst2 = const_vec;
2128  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2129 
2130  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2131  dst3 = const_vec;
2132  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2133 
2134  ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
2135  dst += dst_stride;
2136 
2137  LD_SB2(src, 16, src0, src1);
2138  src2 = LD_SB(src + 24);
2139  src += src_stride;
2140 
2141  XORI_B3_128_SB(src0, src1, src2);
2142 
2143  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2144  dst0 = const_vec;
2145  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2146 
2147  VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2148  dst1 = const_vec;
2149  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2150 
2151  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2152  dst2 = const_vec;
2153  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2154 
2155  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2156  dst3 = const_vec;
2157  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2158 
2159  ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
2160  dst += dst_stride;
2161  }
2162 }
2163 
2164 static void hevc_vt_4t_4x2_msa(uint8_t *src,
2165  int32_t src_stride,
2166  int16_t *dst,
2167  int32_t dst_stride,
2168  const int8_t *filter)
2169 {
2170  v16i8 src0, src1, src2, src3, src4;
2171  v16i8 src10_r, src32_r, src21_r, src43_r;
2172  v16i8 src2110, src4332;
2173  v8i16 dst10;
2174  v8i16 filt0, filt1;
2175  v8i16 filter_vec, const_vec;
2176 
2177  src -= src_stride;
2178 
2179  const_vec = __msa_ldi_h(128);
2180  const_vec <<= 6;
2181 
2182  filter_vec = LD_SH(filter);
2183  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2184 
2185  LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
2186  ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
2187  src10_r, src21_r, src32_r, src43_r);
2188 
2189  ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
2190  XORI_B2_128_SB(src2110, src4332);
2191  dst10 = const_vec;
2192  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2193 
2194  ST8x2_UB(dst10, dst, 2 * dst_stride);
2195 }
2196 
2197 static void hevc_vt_4t_4x4_msa(uint8_t *src,
2198  int32_t src_stride,
2199  int16_t *dst,
2200  int32_t dst_stride,
2201  const int8_t *filter,
2202  int32_t height)
2203 {
2204  v16i8 src0, src1, src2, src3, src4, src5, src6;
2205  v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
2206  v16i8 src2110, src4332, src6554;
2207  v8i16 dst10, dst32;
2208  v8i16 filt0, filt1;
2209  v8i16 filter_vec, const_vec;
2210 
2211  src -= src_stride;
2212 
2213  const_vec = __msa_ldi_h(128);
2214  const_vec <<= 6;
2215 
2216  filter_vec = LD_SH(filter);
2217  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2218 
2219  LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
2220  ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
2221  src10_r, src21_r, src32_r, src43_r);
2222  ILVR_B2_SB(src5, src4, src6, src5, src54_r, src65_r);
2223  ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
2224  src2110, src4332, src6554);
2225  XORI_B3_128_SB(src2110, src4332, src6554);
2226  dst10 = const_vec;
2227  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2228  dst32 = const_vec;
2229  DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
2230 
2231  ST8x4_UB(dst10, dst32, dst, 2 * dst_stride);
2232 }
2233 
2234 static void hevc_vt_4t_4x8multiple_msa(uint8_t *src,
2235  int32_t src_stride,
2236  int16_t *dst,
2237  int32_t dst_stride,
2238  const int8_t *filter,
2239  int32_t height)
2240 {
2241  int32_t loop_cnt;
2242  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
2243  v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
2244  v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
2245  v16i8 src2110, src4332, src6554, src8776;
2246  v8i16 dst10, dst32, dst54, dst76;
2247  v8i16 filt0, filt1;
2248  v8i16 filter_vec, const_vec;
2249 
2250  src -= src_stride;
2251  const_vec = __msa_ldi_h(128);
2252  const_vec <<= 6;
2253 
2254  filter_vec = LD_SH(filter);
2255  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2256 
2257  LD_SB3(src, src_stride, src0, src1, src2);
2258  src += (3 * src_stride);
2259 
2260  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2261  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2262  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2263 
2264  for (loop_cnt = (height >> 3); loop_cnt--;) {
2265  LD_SB6(src, src_stride, src3, src4, src5, src6, src7, src8);
2266  src += (6 * src_stride);
2267 
2268  ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
2269  src32_r, src43_r, src54_r, src65_r);
2270  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
2271  ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
2272  src4332, src6554, src8776);
2273  XORI_B3_128_SB(src4332, src6554, src8776);
2274 
2275  dst10 = const_vec;
2276  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2277  dst32 = const_vec;
2278  DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
2279  dst54 = const_vec;
2280  DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
2281 
2282  LD_SB2(src, src_stride, src9, src2);
2283  src += (2 * src_stride);
2284  ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
2285  src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
2286  src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2287  dst76 = const_vec;
2288  DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
2289 
2290  ST8x8_UB(dst10, dst32, dst54, dst76, dst, 2 * dst_stride);
2291  dst += (8 * dst_stride);
2292  }
2293 }
2294 
2295 static void hevc_vt_4t_4w_msa(uint8_t *src,
2296  int32_t src_stride,
2297  int16_t *dst,
2298  int32_t dst_stride,
2299  const int8_t *filter,
2300  int32_t height)
2301 {
2302  if (2 == height) {
2303  hevc_vt_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
2304  } else if (4 == height) {
2305  hevc_vt_4t_4x4_msa(src, src_stride, dst, dst_stride, filter, height);
2306  } else if (0 == (height % 8)) {
2307  hevc_vt_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
2308  filter, height);
2309  }
2310 }
2311 
2312 static void hevc_vt_4t_6w_msa(uint8_t *src,
2313  int32_t src_stride,
2314  int16_t *dst,
2315  int32_t dst_stride,
2316  const int8_t *filter,
2317  int32_t height)
2318 {
2319  int32_t loop_cnt;
2320  uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
2321  uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
2322  v16i8 src0, src1, src2, src3, src4;
2323  v16i8 src10_r, src32_r, src21_r, src43_r;
2324  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2325  v8i16 filt0, filt1;
2326  v8i16 filter_vec, const_vec;
2327 
2328  src -= src_stride;
2329  const_vec = __msa_ldi_h(128);
2330  const_vec <<= 6;
2331 
2332  filter_vec = LD_SH(filter);
2333  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2334 
2335  LD_SB3(src, src_stride, src0, src1, src2);
2336  src += (3 * src_stride);
2337  XORI_B3_128_SB(src0, src1, src2);
2338  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2339 
2340  for (loop_cnt = (height >> 2); loop_cnt--;) {
2341  LD_SB2(src, src_stride, src3, src4);
2342  src += (2 * src_stride);
2343  XORI_B2_128_SB(src3, src4);
2344  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2345 
2346  dst0_r = const_vec;
2347  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2348  dst1_r = const_vec;
2349  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2350 
2351  LD_SB2(src, src_stride, src1, src2);
2352  src += (2 * src_stride);
2353  XORI_B2_128_SB(src1, src2);
2354  ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
2355 
2356  dst2_r = const_vec;
2357  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
2358  dst3_r = const_vec;
2359  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
2360 
2361  dst_val0 = __msa_copy_u_d((v2i64) dst0_r, 0);
2362  dst_val1 = __msa_copy_u_d((v2i64) dst1_r, 0);
2363  dst_val2 = __msa_copy_u_d((v2i64) dst2_r, 0);
2364  dst_val3 = __msa_copy_u_d((v2i64) dst3_r, 0);
2365 
2366  dst_val_int0 = __msa_copy_u_w((v4i32) dst0_r, 2);
2367  dst_val_int1 = __msa_copy_u_w((v4i32) dst1_r, 2);
2368  dst_val_int2 = __msa_copy_u_w((v4i32) dst2_r, 2);
2369  dst_val_int3 = __msa_copy_u_w((v4i32) dst3_r, 2);
2370 
2371  SD(dst_val0, dst);
2372  SW(dst_val_int0, dst + 4);
2373  dst += dst_stride;
2374  SD(dst_val1, dst);
2375  SW(dst_val_int1, dst + 4);
2376  dst += dst_stride;
2377  SD(dst_val2, dst);
2378  SW(dst_val_int2, dst + 4);
2379  dst += dst_stride;
2380  SD(dst_val3, dst);
2381  SW(dst_val_int3, dst + 4);
2382  dst += dst_stride;
2383  }
2384 }
2385 
2386 static void hevc_vt_4t_8x2_msa(uint8_t *src,
2387  int32_t src_stride,
2388  int16_t *dst,
2389  int32_t dst_stride,
2390  const int8_t *filter)
2391 {
2392  v16i8 src0, src1, src2, src3, src4;
2393  v16i8 src10_r, src32_r, src21_r, src43_r;
2394  v8i16 dst0_r, dst1_r;
2395  v8i16 filt0, filt1;
2396  v8i16 filter_vec, const_vec;
2397 
2398  src -= src_stride;
2399  const_vec = __msa_ldi_h(128);
2400  const_vec <<= 6;
2401 
2402  filter_vec = LD_SH(filter);
2403  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2404 
2405  LD_SB3(src, src_stride, src0, src1, src2);
2406  src += (3 * src_stride);
2407  XORI_B3_128_SB(src0, src1, src2);
2408  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2409 
2410  LD_SB2(src, src_stride, src3, src4);
2411  XORI_B2_128_SB(src3, src4);
2412  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2413  dst0_r = const_vec;
2414  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2415  dst1_r = const_vec;
2416  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2417 
2418  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2419 }
2420 
2421 static void hevc_vt_4t_8x6_msa(uint8_t *src,
2422  int32_t src_stride,
2423  int16_t *dst,
2424  int32_t dst_stride,
2425  const int8_t *filter)
2426 {
2427  v16i8 src0, src1, src2, src3, src4;
2428  v16i8 src10_r, src32_r, src21_r, src43_r;
2429  v8i16 dst0_r, dst1_r;
2430  v8i16 filt0, filt1;
2431  v8i16 filter_vec, const_vec;
2432 
2433  src -= src_stride;
2434  const_vec = __msa_ldi_h(128);
2435  const_vec <<= 6;
2436 
2437  filter_vec = LD_SH(filter);
2438  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2439 
2440  LD_SB3(src, src_stride, src0, src1, src2);
2441  src += (3 * src_stride);
2442  XORI_B3_128_SB(src0, src1, src2);
2443  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2444 
2445  LD_SB2(src, src_stride, src3, src4);
2446  src += (2 * src_stride);
2447  XORI_B2_128_SB(src3, src4);
2448 
2449  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2450  dst0_r = const_vec;
2451  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2452  dst1_r = const_vec;
2453  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2454 
2455  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2456  dst += (2 * dst_stride);
2457 
2458  LD_SB2(src, src_stride, src1, src2);
2459  src += (2 * src_stride);
2460  XORI_B2_128_SB(src1, src2);
2461 
2462  ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
2463  dst0_r = const_vec;
2464  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
2465  dst1_r = const_vec;
2466  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
2467 
2468  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2469  dst += (2 * dst_stride);
2470 
2471  LD_SB2(src, src_stride, src3, src4);
2472  XORI_B2_128_SB(src3, src4);
2473 
2474  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2475  dst0_r = const_vec;
2476  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2477  dst1_r = const_vec;
2478  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2479 
2480  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2481 }
2482 
2483 static void hevc_vt_4t_8x4multiple_msa(uint8_t *src,
2484  int32_t src_stride,
2485  int16_t *dst,
2486  int32_t dst_stride,
2487  const int8_t *filter,
2488  int32_t height)
2489 {
2490  int32_t loop_cnt;
2491  v16i8 src0, src1, src2, src3, src4, src5;
2492  v16i8 src10_r, src32_r, src21_r, src43_r;
2493  v8i16 dst0_r, dst1_r;
2494  v8i16 filt0, filt1;
2495  v8i16 filter_vec, const_vec;
2496 
2497  src -= src_stride;
2498  const_vec = __msa_ldi_h(128);
2499  const_vec <<= 6;
2500 
2501  filter_vec = LD_SH(filter);
2502  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2503 
2504  LD_SB3(src, src_stride, src0, src1, src2);
2505  src += (3 * src_stride);
2506  XORI_B3_128_SB(src0, src1, src2);
2507  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2508 
2509  for (loop_cnt = (height >> 2); loop_cnt--;) {
2510  LD_SB2(src, src_stride, src3, src4);
2511  src += (2 * src_stride);
2512  XORI_B2_128_SB(src3, src4);
2513  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2514  dst0_r = const_vec;
2515  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2516  dst1_r = const_vec;
2517  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2518 
2519  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2520  dst += (2 * dst_stride);
2521 
2522  LD_SB2(src, src_stride, src5, src2);
2523  src += (2 * src_stride);
2524  XORI_B2_128_SB(src5, src2);
2525  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2526  dst0_r = const_vec;
2527  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
2528  dst1_r = const_vec;
2529  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
2530 
2531  ST_SH2(dst0_r, dst1_r, dst, dst_stride);
2532  dst += (2 * dst_stride);
2533  }
2534 }
2535 
2536 static void hevc_vt_4t_8w_msa(uint8_t *src,
2537  int32_t src_stride,
2538  int16_t *dst,
2539  int32_t dst_stride,
2540  const int8_t *filter,
2541  int32_t height)
2542 {
2543  if (2 == height) {
2544  hevc_vt_4t_8x2_msa(src, src_stride, dst, dst_stride, filter);
2545  } else if (6 == height) {
2546  hevc_vt_4t_8x6_msa(src, src_stride, dst, dst_stride, filter);
2547  } else {
2548  hevc_vt_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
2549  filter, height);
2550  }
2551 }
2552 
2553 static void hevc_vt_4t_12w_msa(uint8_t *src,
2554  int32_t src_stride,
2555  int16_t *dst,
2556  int32_t dst_stride,
2557  const int8_t *filter,
2558  int32_t height)
2559 {
2560  int32_t loop_cnt;
2561  v16i8 src0, src1, src2, src3, src4, src5;
2562  v16i8 src10_r, src32_r, src21_r, src43_r;
2563  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2564  v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
2565  v16i8 src2110, src4332;
2566  v8i16 dst0_l, dst1_l;
2567  v8i16 filt0, filt1;
2568  v8i16 filter_vec, const_vec;
2569 
2570  src -= (1 * src_stride);
2571  const_vec = __msa_ldi_h(128);
2572  const_vec <<= 6;
2573 
2574  filter_vec = LD_SH(filter);
2575  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2576 
2577  LD_SB3(src, src_stride, src0, src1, src2);
2578  src += (3 * src_stride);
2579  XORI_B3_128_SB(src0, src1, src2);
2580  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2581  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
2582  src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
2583 
2584  for (loop_cnt = (height >> 2); loop_cnt--;) {
2585  LD_SB2(src, src_stride, src3, src4);
2586  src += (2 * src_stride);
2587  XORI_B2_128_SB(src3, src4);
2588  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2589  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
2590  src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
2591  dst0_r = const_vec;
2592  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2593  dst1_r = const_vec;
2594  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2595  dst0_l = const_vec;
2596  DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst0_l, dst0_l);
2597 
2598  LD_SB2(src, src_stride, src5, src2);
2599  src += (2 * src_stride);
2600  XORI_B2_128_SB(src5, src2);
2601  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2602  ILVL_B2_SB(src5, src4, src2, src5, src54_l, src65_l);
2603  src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
2604  dst2_r = const_vec;
2605  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
2606  dst3_r = const_vec;
2607  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
2608  dst1_l = const_vec;
2609  DPADD_SB2_SH(src4332, src2110, filt0, filt1, dst1_l, dst1_l);
2610 
2611  ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
2612  ST8x4_UB(dst0_l, dst1_l, dst + 8, (2 * dst_stride));
2613  dst += (4 * dst_stride);
2614  }
2615 }
2616 
2617 static void hevc_vt_4t_16w_msa(uint8_t *src,
2618  int32_t src_stride,
2619  int16_t *dst,
2620  int32_t dst_stride,
2621  const int8_t *filter,
2622  int32_t height)
2623 {
2624  int32_t loop_cnt;
2625  v16i8 src0, src1, src2, src3, src4, src5;
2626  v16i8 src10_r, src32_r, src21_r, src43_r;
2627  v16i8 src10_l, src32_l, src21_l, src43_l;
2628  v8i16 dst0_r, dst1_r, dst0_l, dst1_l;
2629  v8i16 filt0, filt1;
2630  v8i16 filter_vec, const_vec;
2631 
2632  src -= src_stride;
2633  const_vec = __msa_ldi_h(128);
2634  const_vec <<= 6;
2635 
2636  filter_vec = LD_SH(filter);
2637  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2638 
2639  LD_SB3(src, src_stride, src0, src1, src2);
2640  src += (3 * src_stride);
2641  XORI_B3_128_SB(src0, src1, src2);
2642  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2643  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
2644 
2645  for (loop_cnt = (height >> 2); loop_cnt--;) {
2646  LD_SB2(src, src_stride, src3, src4);
2647  src += (2 * src_stride);
2648  XORI_B2_128_SB(src3, src4);
2649  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2650  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
2651  dst0_r = const_vec;
2652  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2653  dst0_l = const_vec;
2654  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
2655  dst1_r = const_vec;
2656  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2657  dst1_l = const_vec;
2658  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
2659  ST_SH2(dst0_r, dst0_l, dst, 8);
2660  dst += dst_stride;
2661  ST_SH2(dst1_r, dst1_l, dst, 8);
2662  dst += dst_stride;
2663 
2664  LD_SB2(src, src_stride, src5, src2);
2665  src += (2 * src_stride);
2666  XORI_B2_128_SB(src5, src2);
2667  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2668  ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
2669  dst0_r = const_vec;
2670  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
2671  dst0_l = const_vec;
2672  DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
2673  dst1_r = const_vec;
2674  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
2675  dst1_l = const_vec;
2676  DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
2677  ST_SH2(dst0_r, dst0_l, dst, 8);
2678  dst += dst_stride;
2679  ST_SH2(dst1_r, dst1_l, dst, 8);
2680  dst += dst_stride;
2681  }
2682 }
2683 
2684 static void hevc_vt_4t_24w_msa(uint8_t *src,
2685  int32_t src_stride,
2686  int16_t *dst,
2687  int32_t dst_stride,
2688  const int8_t *filter,
2689  int32_t height)
2690 {
2691  int32_t loop_cnt;
2692  v16i8 src0, src1, src2, src3, src4, src5;
2693  v16i8 src6, src7, src8, src9, src10, src11;
2694  v16i8 src10_r, src32_r, src76_r, src98_r;
2695  v16i8 src21_r, src43_r, src87_r, src109_r;
2696  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2697  v16i8 src10_l, src32_l, src21_l, src43_l;
2698  v8i16 dst0_l, dst1_l;
2699  v8i16 filt0, filt1;
2700  v8i16 filter_vec, const_vec;
2701 
2702  src -= src_stride;
2703  const_vec = __msa_ldi_h(128);
2704  const_vec <<= 6;
2705 
2706  filter_vec = LD_SH(filter);
2707  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2708 
2709  LD_SB3(src, src_stride, src0, src1, src2);
2710  XORI_B3_128_SB(src0, src1, src2);
2711  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2712  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
2713 
2714  LD_SB3(src + 16, src_stride, src6, src7, src8);
2715  src += (3 * src_stride);
2716  XORI_B3_128_SB(src6, src7, src8);
2717  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
2718 
2719  for (loop_cnt = (height >> 2); loop_cnt--;) {
2720  LD_SB2(src, src_stride, src3, src4);
2721  XORI_B2_128_SB(src3, src4);
2722  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2723  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
2724 
2725  LD_SB2(src + 16, src_stride, src9, src10);
2726  src += (2 * src_stride);
2727  XORI_B2_128_SB(src9, src10);
2728  ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
2729 
2730  dst0_r = const_vec;
2731  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2732  dst0_l = const_vec;
2733  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
2734  dst1_r = const_vec;
2735  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2736  dst1_l = const_vec;
2737  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
2738  dst2_r = const_vec;
2739  DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
2740  dst3_r = const_vec;
2741  DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
2742 
2743  ST_SH2(dst0_r, dst0_l, dst, 8);
2744  ST_SH(dst2_r, dst + 16);
2745  dst += dst_stride;
2746  ST_SH2(dst1_r, dst1_l, dst, 8);
2747  ST_SH(dst3_r, dst + 16);
2748  dst += dst_stride;
2749 
2750  LD_SB2(src, src_stride, src5, src2);
2751  XORI_B2_128_SB(src5, src2);
2752  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2753  ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
2754 
2755  LD_SB2(src + 16, src_stride, src11, src8);
2756  src += (2 * src_stride);
2757  XORI_B2_128_SB(src11, src8);
2758  ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
2759 
2760  dst0_r = const_vec;
2761  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
2762  dst0_l = const_vec;
2763  DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
2764  dst1_r = const_vec;
2765  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
2766  dst1_l = const_vec;
2767  DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
2768  dst2_r = const_vec;
2769  DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
2770  dst3_r = const_vec;
2771  DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
2772 
2773  ST_SH2(dst0_r, dst0_l, dst, 8);
2774  ST_SH(dst2_r, dst + 16);
2775  dst += dst_stride;
2776  ST_SH2(dst1_r, dst1_l, dst, 8);
2777  ST_SH(dst3_r, dst + 16);
2778  dst += dst_stride;
2779  }
2780 }
2781 
2782 static void hevc_vt_4t_32w_msa(uint8_t *src,
2783  int32_t src_stride,
2784  int16_t *dst,
2785  int32_t dst_stride,
2786  const int8_t *filter,
2787  int32_t height)
2788 {
2789  int32_t loop_cnt;
2790  v16i8 src0, src1, src2, src3, src4, src5;
2791  v16i8 src6, src7, src8, src9, src10, src11;
2792  v16i8 src10_r, src32_r, src76_r, src98_r;
2793  v16i8 src21_r, src43_r, src87_r, src109_r;
2794  v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
2795  v16i8 src10_l, src32_l, src76_l, src98_l;
2796  v16i8 src21_l, src43_l, src87_l, src109_l;
2797  v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
2798  v8i16 filt0, filt1;
2799  v8i16 filter_vec, const_vec;
2800 
2801  src -= src_stride;
2802  const_vec = __msa_ldi_h(128);
2803  const_vec <<= 6;
2804 
2805  filter_vec = LD_SH(filter);
2806  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2807 
2808  LD_SB3(src, src_stride, src0, src1, src2);
2809  XORI_B3_128_SB(src0, src1, src2);
2810  ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2811  ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
2812 
2813  LD_SB3(src + 16, src_stride, src6, src7, src8);
2814  src += (3 * src_stride);
2815  XORI_B3_128_SB(src6, src7, src8);
2816  ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
2817  ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
2818 
2819  for (loop_cnt = (height >> 2); loop_cnt--;) {
2820  LD_SB2(src, src_stride, src3, src4);
2821  XORI_B2_128_SB(src3, src4);
2822  ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2823  ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
2824 
2825  LD_SB2(src + 16, src_stride, src9, src10);
2826  src += (2 * src_stride);
2827  XORI_B2_128_SB(src9, src10);
2828  ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
2829  ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
2830 
2831  dst0_r = const_vec;
2832  DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
2833  dst0_l = const_vec;
2834  DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
2835  dst1_r = const_vec;
2836  DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
2837  dst1_l = const_vec;
2838  DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
2839  dst2_r = const_vec;
2840  DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
2841  dst2_l = const_vec;
2842  DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, dst2_l, dst2_l);
2843  dst3_r = const_vec;
2844  DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
2845  dst3_l = const_vec;
2846  DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, dst3_l, dst3_l);
2847 
2848  ST_SH4(dst0_r, dst0_l, dst2_r, dst2_l, dst, 8);
2849  dst += dst_stride;
2850  ST_SH4(dst1_r, dst1_l, dst3_r, dst3_l, dst, 8);
2851  dst += dst_stride;
2852 
2853  LD_SB2(src, src_stride, src5, src2);
2854  XORI_B2_128_SB(src5, src2);
2855  ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
2856  ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
2857 
2858  LD_SB2(src + 16, src_stride, src11, src8);
2859  src += (2 * src_stride);
2860  XORI_B2_128_SB(src11, src8);
2861  ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
2862  ILVL_B2_SB(src11, src10, src8, src11, src76_l, src87_l);
2863 
2864  dst0_r = const_vec;
2865  DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
2866  dst0_l = const_vec;
2867  DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
2868  dst1_r = const_vec;
2869  DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
2870  dst1_l = const_vec;
2871  DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
2872  dst2_r = const_vec;
2873  DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
2874  dst2_l = const_vec;
2875  DPADD_SB2_SH(src98_l, src76_l, filt0, filt1, dst2_l, dst2_l);
2876  dst3_r = const_vec;
2877  DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
2878  dst3_l = const_vec;
2879  DPADD_SB2_SH(src109_l, src87_l, filt0, filt1, dst3_l, dst3_l);
2880 
2881  ST_SH4(dst0_r, dst0_l, dst2_r, dst2_l, dst, 8);
2882  dst += dst_stride;
2883  ST_SH4(dst1_r, dst1_l, dst3_r, dst3_l, dst, 8);
2884  dst += dst_stride;
2885  }
2886 }
2887 
2888 static void hevc_hv_4t_4x2_msa(uint8_t *src,
2889  int32_t src_stride,
2890  int16_t *dst,
2891  int32_t dst_stride,
2892  const int8_t *filter_x,
2893  const int8_t *filter_y)
2894 {
2895  v16i8 src0, src1, src2, src3, src4;
2896  v8i16 filt0, filt1;
2897  v4i32 filt_h0, filt_h1;
2898  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2899  v16i8 mask1;
2900  v8i16 filter_vec, const_vec;
2901  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
2902  v8i16 dst0, dst1, dst2, dst3, dst4;
2903  v4i32 dst0_r, dst1_r;
2904  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
2905 
2906  src -= (src_stride + 1);
2907  filter_vec = LD_SH(filter_x);
2908  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2909 
2910  filter_vec = LD_SH(filter_y);
2911  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
2912  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
2913 
2914  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
2915 
2916  mask1 = mask0 + 2;
2917 
2918  const_vec = __msa_ldi_h(128);
2919  const_vec <<= 6;
2920 
2921  LD_SB3(src, src_stride, src0, src1, src2);
2922  src += (3 * src_stride);
2923  XORI_B3_128_SB(src0, src1, src2);
2924 
2925  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2926  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
2927  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
2928 
2929  dst0 = const_vec;
2930  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2931  dst1 = const_vec;
2932  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
2933  dst2 = const_vec;
2934  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
2935  ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
2936 
2937  LD_SB2(src, src_stride, src3, src4);
2938  XORI_B2_128_SB(src3, src4);
2939 
2940  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2941  dst3 = const_vec;
2942  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2943 
2944  dst32_r = __msa_ilvr_h(dst3, dst2);
2945  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
2946  dst0_r >>= 6;
2947 
2948  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2949  dst4 = const_vec;
2950  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2951 
2952  dst43_r = __msa_ilvr_h(dst4, dst3);
2953  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
2954  dst1_r >>= 6;
2955 
2956  dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
2957  ST8x2_UB(dst0_r, dst, 2 * dst_stride);
2958 }
2959 
2960 static void hevc_hv_4t_4x4_msa(uint8_t *src,
2961  int32_t src_stride,
2962  int16_t *dst,
2963  int32_t dst_stride,
2964  const int8_t *filter_x,
2965  const int8_t *filter_y)
2966 {
2967  v16i8 src0, src1, src2, src3, src4, src5, src6;
2968  v8i16 filt0, filt1;
2969  v4i32 filt_h0, filt_h1;
2970  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2971  v16i8 mask1;
2972  v8i16 filter_vec, const_vec;
2973  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
2974  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2975  v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
2976  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
2977 
2978  src -= (src_stride + 1);
2979 
2980  filter_vec = LD_SH(filter_x);
2981  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2982 
2983  filter_vec = LD_SH(filter_y);
2984  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
2985  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
2986 
2987  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
2988 
2989  mask1 = mask0 + 2;
2990 
2991  const_vec = __msa_ldi_h(128);
2992  const_vec <<= 6;
2993 
2994  LD_SB3(src, src_stride, src0, src1, src2);
2995  src += (3 * src_stride);
2996 
2997  XORI_B3_128_SB(src0, src1, src2);
2998 
2999  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3000  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3001  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3002 
3003  dst0 = const_vec;
3004  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3005  dst1 = const_vec;
3006  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3007  dst2 = const_vec;
3008  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3009 
3010  ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3011 
3012  LD_SB4(src, src_stride, src3, src4, src5, src6);
3013  XORI_B4_128_SB(src3, src4, src5, src6);
3014 
3015  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3016  dst3 = const_vec;
3017  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3018 
3019  dst32_r = __msa_ilvr_h(dst3, dst2);
3020  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3021  dst0_r >>= 6;
3022 
3023  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3024  dst4 = const_vec;
3025  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3026 
3027  dst43_r = __msa_ilvr_h(dst4, dst3);
3028  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3029  dst1_r >>= 6;
3030 
3031  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3032  dst5 = const_vec;
3033  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3034 
3035  dst10_r = __msa_ilvr_h(dst5, dst4);
3036  dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
3037  dst2_r >>= 6;
3038 
3039  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3040  dst2 = const_vec;
3041  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3042 
3043  dst21_r = __msa_ilvr_h(dst2, dst5);
3044  dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
3045  dst3_r >>= 6;
3046 
3047  PCKEV_H2_SW(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3048  ST8x4_UB(dst0_r, dst1_r, dst, 2 * dst_stride);
3049 }
3050 
3051 
3052 static void hevc_hv_4t_4multx8mult_msa(uint8_t *src,
3053  int32_t src_stride,
3054  int16_t *dst,
3055  int32_t dst_stride,
3056  const int8_t *filter_x,
3057  const int8_t *filter_y,
3058  int32_t height)
3059 {
3060  uint32_t loop_cnt;
3061  v16i8 src0, src1, src2, src3, src4, src5, src6;
3062  v16i8 src7, src8, src9, src10;
3063  v8i16 filt0, filt1;
3064  v4i32 filt_h0, filt_h1;
3065  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3066  v16i8 mask1;
3067  v8i16 filter_vec, const_vec;
3068  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3069  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9;
3070  v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
3071  v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
3072  v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
3073 
3074  src -= (src_stride + 1);
3075  filter_vec = LD_SH(filter_x);
3076  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3077 
3078  filter_vec = LD_SH(filter_y);
3079  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3080  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3081 
3082  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3083 
3084  mask1 = mask0 + 2;
3085 
3086  const_vec = __msa_ldi_h(128);
3087  const_vec <<= 6;
3088 
3089  LD_SB3(src, src_stride, src0, src1, src2);
3090  src += (3 * src_stride);
3091  XORI_B3_128_SB(src0, src1, src2);
3092 
3093  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3094  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3095  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3096 
3097  dst0 = const_vec;
3098  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3099  dst1 = const_vec;
3100  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3101  dst2 = const_vec;
3102  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3103 
3104  ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3105 
3106  for (loop_cnt = height >> 3; loop_cnt--;) {
3107  LD_SB8(src, src_stride,
3108  src3, src4, src5, src6, src7, src8, src9, src10);
3109  src += (8 * src_stride);
3110  XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
3111 
3112  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3113  dst3 = const_vec;
3114  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3115 
3116  dst32_r = __msa_ilvr_h(dst3, dst2);
3117  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3118  dst0_r >>= 6;
3119 
3120  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3121  dst4 = const_vec;
3122  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3123 
3124  dst43_r = __msa_ilvr_h(dst4, dst3);
3125  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3126  dst1_r >>= 6;
3127 
3128  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3129  dst5 = const_vec;
3130  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3131 
3132  dst54_r = __msa_ilvr_h(dst5, dst4);
3133  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
3134  dst2_r >>= 6;
3135 
3136  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3137  dst6 = const_vec;
3138  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
3139 
3140  dst65_r = __msa_ilvr_h(dst6, dst5);
3141  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
3142  dst3_r >>= 6;
3143 
3144  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
3145  dst7 = const_vec;
3146  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
3147 
3148  dst76_r = __msa_ilvr_h(dst7, dst6);
3149  dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
3150  dst4_r >>= 6;
3151 
3152  VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
3153  dst8 = const_vec;
3154  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
3155 
3156  dst87_r = __msa_ilvr_h(dst8, dst7);
3157  dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
3158  dst5_r >>= 6;
3159 
3160  VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec0, vec1);
3161  dst9 = const_vec;
3162  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst9, dst9);
3163 
3164  dst10_r = __msa_ilvr_h(dst9, dst8);
3165  dst6_r = HEVC_FILT_4TAP(dst76_r, dst10_r, filt_h0, filt_h1);
3166  dst6_r >>= 6;
3167 
3168  VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec0, vec1);
3169  dst2 = const_vec;
3170  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3171 
3172  dst21_r = __msa_ilvr_h(dst2, dst9);
3173  dst7_r = HEVC_FILT_4TAP(dst87_r, dst21_r, filt_h0, filt_h1);
3174  dst7_r >>= 6;
3175 
3176  PCKEV_H4_SW(dst1_r, dst0_r, dst3_r, dst2_r,
3177  dst5_r, dst4_r, dst7_r, dst6_r,
3178  dst0_r, dst1_r, dst2_r, dst3_r);
3179  ST8x8_UB(dst0_r, dst1_r, dst2_r, dst3_r, dst, 2 * dst_stride);
3180  dst += (8 * dst_stride);
3181  }
3182 }
3183 
3184 static void hevc_hv_4t_4w_msa(uint8_t *src,
3185  int32_t src_stride,
3186  int16_t *dst,
3187  int32_t dst_stride,
3188  const int8_t *filter_x,
3189  const int8_t *filter_y,
3190  int32_t height)
3191 {
3192  if (2 == height) {
3193  hevc_hv_4t_4x2_msa(src, src_stride, dst, dst_stride,
3194  filter_x, filter_y);
3195  } else if (4 == height) {
3196  hevc_hv_4t_4x4_msa(src, src_stride, dst, dst_stride,
3197  filter_x, filter_y);
3198  } else if (0 == (height % 8)) {
3199  hevc_hv_4t_4multx8mult_msa(src, src_stride, dst, dst_stride,
3200  filter_x, filter_y, height);
3201  }
3202 }
3203 
3204 static void hevc_hv_4t_6w_msa(uint8_t *src,
3205  int32_t src_stride,
3206  int16_t *dst,
3207  int32_t dst_stride,
3208  const int8_t *filter_x,
3209  const int8_t *filter_y,
3210  int32_t height)
3211 {
3212  uint32_t loop_cnt;
3213  uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
3214  uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
3215  v16i8 src0, src1, src2, src3, src4, src5, src6;
3216  v8i16 filt0, filt1;
3217  v4i32 filt_h0, filt_h1;
3218  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3219  v16i8 mask1;
3220  v8i16 filter_vec, const_vec;
3221  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3222  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
3223  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
3224  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3225  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
3226 
3227  src -= (src_stride + 1);
3228  filter_vec = LD_SH(filter_x);
3229  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3230 
3231  filter_vec = LD_SH(filter_y);
3232  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3233  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3234 
3235  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3236 
3237  mask1 = mask0 + 2;
3238 
3239  const_vec = __msa_ldi_h(128);
3240  const_vec <<= 6;
3241 
3242  LD_SB3(src, src_stride, src0, src1, src2);
3243  src += (3 * src_stride);
3244  XORI_B3_128_SB(src0, src1, src2);
3245 
3246  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3247  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3248  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3249 
3250  dst0 = const_vec;
3251  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3252  dst1 = const_vec;
3253  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3254  dst2 = const_vec;
3255  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3256 
3257  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
3258  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
3259 
3260  for (loop_cnt = height >> 2; loop_cnt--;) {
3261  LD_SB4(src, src_stride, src3, src4, src5, src6);
3262  src += (4 * src_stride);
3263  XORI_B4_128_SB(src3, src4, src5, src6);
3264 
3265  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3266  dst3 = const_vec;
3267  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3268 
3269  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
3270  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3271  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
3272  dst0_r >>= 6;
3273  dst0_l >>= 6;
3274 
3275  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3276  dst4 = const_vec;
3277  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3278 
3279  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
3280  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3281  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
3282  dst1_r >>= 6;
3283  dst1_l >>= 6;
3284 
3285  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3286  dst5 = const_vec;
3287  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3288 
3289  ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
3290  dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
3291  dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
3292  dst2_r >>= 6;
3293  dst2_l >>= 6;
3294 
3295  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3296  dst2 = const_vec;
3297  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3298 
3299  ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
3300  dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
3301  dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
3302  dst3_r >>= 6;
3303  dst3_l >>= 6;
3304 
3305  PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
3306  dst2_l, dst2_r, dst3_l, dst3_r,
3307  dst0_r, dst1_r, dst2_r, dst3_r);
3308 
3309  dst_val0 = __msa_copy_u_d((v2i64) dst0_r, 0);
3310  dst_val1 = __msa_copy_u_d((v2i64) dst1_r, 0);
3311  dst_val2 = __msa_copy_u_d((v2i64) dst2_r, 0);
3312  dst_val3 = __msa_copy_u_d((v2i64) dst3_r, 0);
3313 
3314  dst_val_int0 = __msa_copy_u_w((v4i32) dst0_r, 2);
3315  dst_val_int1 = __msa_copy_u_w((v4i32) dst1_r, 2);
3316  dst_val_int2 = __msa_copy_u_w((v4i32) dst2_r, 2);
3317  dst_val_int3 = __msa_copy_u_w((v4i32) dst3_r, 2);
3318 
3319  SD(dst_val0, dst);
3320  SW(dst_val_int0, dst + 4);
3321  dst += dst_stride;
3322  SD(dst_val1, dst);
3323  SW(dst_val_int1, dst + 4);
3324  dst += dst_stride;
3325  SD(dst_val2, dst);
3326  SW(dst_val_int2, dst + 4);
3327  dst += dst_stride;
3328  SD(dst_val3, dst);
3329  SW(dst_val_int3, dst + 4);
3330  dst += dst_stride;
3331 
3332  }
3333 }
3334 
3335 static void hevc_hv_4t_8x2_msa(uint8_t *src,
3336  int32_t src_stride,
3337  int16_t *dst,
3338  int32_t dst_stride,
3339  const int8_t *filter_x,
3340  const int8_t *filter_y,
3341  int32_t height)
3342 {
3343  v16i8 src0, src1, src2, src3, src4;
3344  v8i16 filt0, filt1;
3345  v4i32 filt_h0, filt_h1;
3346  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3347  v16i8 mask1;
3348  v8i16 filter_vec, const_vec;
3349  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3350  v8i16 dst0, dst1, dst2, dst3, dst4;
3351  v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
3352  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3353  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
3354 
3355  src -= (src_stride + 1);
3356 
3357  filter_vec = LD_SH(filter_x);
3358  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3359 
3360  filter_vec = LD_SH(filter_y);
3361  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3362  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3363 
3364  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3365 
3366  mask1 = mask0 + 2;
3367 
3368  const_vec = __msa_ldi_h(128);
3369  const_vec <<= 6;
3370 
3371  LD_SB3(src, src_stride, src0, src1, src2);
3372  src += (3 * src_stride);
3373  XORI_B3_128_SB(src0, src1, src2);
3374 
3375  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3376  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3377  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3378 
3379  dst0 = const_vec;
3380  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3381  dst1 = const_vec;
3382  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3383  dst2 = const_vec;
3384  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3385 
3386  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
3387  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
3388 
3389  LD_SB2(src, src_stride, src3, src4);
3390  src += (2 * src_stride);
3391  XORI_B2_128_SB(src3, src4);
3392 
3393  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3394  dst3 = const_vec;
3395  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3396 
3397  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
3398  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3399  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
3400  dst0_r >>= 6;
3401  dst0_l >>= 6;
3402 
3403  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3404  dst4 = const_vec;
3405  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3406 
3407  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
3408  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3409  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
3410  dst1_r >>= 6;
3411  dst1_l >>= 6;
3412 
3413  PCKEV_H2_SW(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3414  ST_SW2(dst0_r, dst1_r, dst, dst_stride);
3415 }
3416 
3417 static void hevc_hv_4t_8x6_msa(uint8_t *src,
3418  int32_t src_stride,
3419  int16_t *dst,
3420  int32_t dst_stride,
3421  const int8_t *filter_x,
3422  const int8_t *filter_y,
3423  int32_t height)
3424 {
3425  v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
3426  v8i16 filt0, filt1;
3427  v4i32 filt_h0, filt_h1;
3428  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3429  v16i8 mask1;
3430  v8i16 filter_vec, const_vec;
3431  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3432  v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
3433  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
3434  v4i32 dst4_r, dst4_l, dst5_r, dst5_l;
3435  v8i16 dst10_r, dst32_r, dst10_l, dst32_l;
3436  v8i16 dst21_r, dst43_r, dst21_l, dst43_l;
3437  v8i16 dst54_r, dst54_l, dst65_r, dst65_l;
3438  v8i16 dst76_r, dst76_l, dst87_r, dst87_l;
3439 
3440  src -= (src_stride + 1);
3441 
3442  filter_vec = LD_SH(filter_x);
3443  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3444 
3445  filter_vec = LD_SH(filter_y);
3446  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3447  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3448 
3449  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3450 
3451  mask1 = mask0 + 2;
3452 
3453  const_vec = __msa_ldi_h(128);
3454  const_vec <<= 6;
3455 
3456  LD_SB3(src, src_stride, src0, src1, src2);
3457  src += (3 * src_stride);
3458 
3459  XORI_B3_128_SB(src0, src1, src2);
3460 
3461  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3462  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3463  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3464 
3465  dst0 = const_vec;
3466  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3467  dst1 = const_vec;
3468  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3469  dst2 = const_vec;
3470  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3471 
3472  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
3473  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
3474 
3475  LD_SB2(src, src_stride, src3, src4);
3476  src += (2 * src_stride);
3477 
3478  XORI_B2_128_SB(src3, src4);
3479 
3480  /* row 3 */
3481  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3482  dst3 = const_vec;
3483  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3484 
3485  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
3486  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3487 
3488  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
3489 
3490  dst0_r >>= 6;
3491  dst0_l >>= 6;
3492 
3493  /* row 4 */
3494  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3495  dst4 = const_vec;
3496  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3497 
3498  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
3499  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3500  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
3501  dst1_r >>= 6;
3502  dst1_l >>= 6;
3503 
3504  LD_SB2(src, src_stride, src5, src6);
3505  src += (2 * src_stride);
3506 
3507  XORI_B2_128_SB(src5, src6);
3508 
3509  /* row 5 */
3510  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3511  dst5 = const_vec;
3512  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3513 
3514  ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
3515  dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
3516  dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
3517  dst2_r >>= 6;
3518  dst2_l >>= 6;
3519 
3520  /* row 6 */
3521  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3522  dst6 = const_vec;
3523  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
3524 
3525  ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
3526  dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
3527  dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
3528  dst3_r >>= 6;
3529  dst3_l >>= 6;
3530 
3531  LD_SB2(src, src_stride, src7, src8);
3532 
3533  XORI_B2_128_SB(src7, src8);
3534 
3535  /* row 7 */
3536  VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
3537  dst7 = const_vec;
3538  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
3539 
3540  ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
3541  dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
3542  dst4_l = HEVC_FILT_4TAP(dst54_l, dst76_l, filt_h0, filt_h1);
3543  dst4_r >>= 6;
3544  dst4_l >>= 6;
3545 
3546  /* row 8 */
3547  VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
3548  dst8 = const_vec;
3549  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
3550 
3551  ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
3552  dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
3553  dst5_l = HEVC_FILT_4TAP(dst65_l, dst87_l, filt_h0, filt_h1);
3554  dst5_r >>= 6;
3555  dst5_l >>= 6;
3556 
3557  PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
3558  dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r, dst2_r, dst3_r);
3559  PCKEV_H2_SW(dst4_l, dst4_r, dst5_l, dst5_r, dst4_r, dst5_r);
3560 
3561  ST_SW2(dst0_r, dst1_r, dst, dst_stride);
3562  dst += (2 * dst_stride);
3563  ST_SW2(dst2_r, dst3_r, dst, dst_stride);
3564  dst += (2 * dst_stride);
3565  ST_SW2(dst4_r, dst5_r, dst, dst_stride);
3566 }
3567 
3568 static void hevc_hv_4t_8multx4mult_msa(uint8_t *src,
3569  int32_t src_stride,
3570  int16_t *dst,
3571  int32_t dst_stride,
3572  const int8_t *filter_x,
3573  const int8_t *filter_y,
3574  int32_t height,
3575  int32_t width)
3576 {
3577  uint32_t loop_cnt, cnt;
3578  uint8_t *src_tmp;
3579  int16_t *dst_tmp;
3580  v16i8 src0, src1, src2, src3, src4, src5, src6;
3581  v8i16 filt0, filt1;
3582  v4i32 filt_h0, filt_h1;
3583  v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3584  v16i8 mask1;
3585  v8i16 filter_vec, const_vec;
3586  v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3587  v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
3588  v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
3589  v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3590  v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
3591 
3592  src -= (src_stride + 1);
3593 
3594  filter_vec = LD_SH(filter_x);
3595  SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3596 
3597  filter_vec = LD_SH(filter_y);
3598  vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3599  filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3600 
3601  SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3602 
3603  mask1 = mask0 + 2;
3604 
3605  const_vec = __msa_ldi_h(128);
3606  const_vec <<= 6;
3607 
3608  for (cnt = width >> 3; cnt--;) {
3609  src_tmp = src;
3610  dst_tmp = dst;
3611 
3612  LD_SB3(src_tmp, src_stride, src0, src1, src2);
3613  src_tmp += (3 * src_stride);
3614 
3615  XORI_B3_128_SB(src0, src1, src2);
3616 
3617  VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3618  VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3619  VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3620 
3621  dst0 = const_vec;
3622  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3623  dst1 = const_vec;
3624  DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3625  dst2 = const_vec;
3626  DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3627 
3628  ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
3629  ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
3630 
3631  for (loop_cnt = height >> 2; loop_cnt--;) {
3632  LD_SB4(src_tmp, src_stride, src3, src4, src5, src6);
3633  src_tmp += (4 * src_stride);
3634  XORI_B4_128_SB(src3, src4, src5, src6);
3635 
3636  VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3637  dst3 = const_vec;
3638  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3639 
3640  ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
3641  dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3642  dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
3643 
3644  dst0_r >>= 6;
3645  dst0_l >>= 6;
3646 
3647  /* row 4 */
3648  VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3649  dst4 = const_vec;
3650  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3651 
3652  ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
3653  dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3654  dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
3655  dst1_r >>= 6;
3656  dst1_l >>= 6;
3657 
3658  /* row 5 */
3659  VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3660  dst5 = const_vec;
3661  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3662 
3663  ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
3664  dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
3665  dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
3666 
3667  dst2_r >>= 6;
3668  dst2_l >>= 6;
3669 
3670  /* row 6 */
3671  VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3672  dst2 = const_vec;
3673  DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3674 
3675  ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
3676  dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
3677  dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
3678 
3679  dst3_r >>= 6;
3680  dst3_l >>= 6;
3681 
3682  PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
3683  dst2_l, dst2_r, dst3_l, dst3_r,
3684  dst0_r, dst1_r, dst2_r, dst3_r);
3685 
3686  ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
3687  dst_tmp += (2 * dst_stride);
3688  ST_SW2(dst2_r, dst3_r, dst_tmp, dst_stride);
3689  dst_tmp += (2 * dst_stride);
3690  }
3691 
3692  src += 8;
3693  dst += 8;
3694  }
3695 }
3696 
3697 static void hevc_hv_4t_8w_msa(uint8_t *src,
3698  int32_t src_stride,
3699  int16_t *dst,
3700  int32_t dst_stride,
3701  const int8_t *filter_x,
3702  const int8_t *filter_y,
3703  int32_t height)
3704 {
3705 
3706  if (2 == height) {
3707  hevc_hv_4t_8x2_msa(src, src_stride, dst, dst_stride,
3708  filter_x, filter_y, height);
3709  } else if (6 == height) {
3710  hevc_hv_4t_8x6_msa(src, src_stride, dst, dst_stride,
3711  filter_x, filter_y, height);
3712  } else if (0 == (height % 4)) {
3713  hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
3714  filter_x, filter_y, height, 8);
3715  }
3716 }
3717 
3718 static void hevc_hv_4t_12w_msa(uint8_t *src,
3719  int32_t src_stride,
3720  int16_t *dst,
3721  int32_t dst_stride,
3722  const int8_t *filter_x,
3723  const int8_t *filter_y,
3724  int32_t height)
3725 {
3726  hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
3727  filter_x, filter_y, height, 8);
3728 
3729  hevc_hv_4t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
3730  filter_x, filter_y, height);
3731 
3732 }
3733 
3734 static void hevc_hv_4t_16w_msa(uint8_t *src,
3735  int32_t src_stride,
3736  int16_t *dst,
3737  int32_t dst_stride,
3738  const int8_t *filter_x,
3739  const int8_t *filter_y,
3740  int32_t height)
3741 {
3742  hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
3743  filter_x, filter_y, height, 16);
3744 }
3745 
3746 static void hevc_hv_4t_24w_msa(uint8_t *src,
3747  int32_t src_stride,
3748  int16_t *dst,
3749  int32_t dst_stride,
3750  const int8_t *filter_x,
3751  const int8_t *filter_y,
3752  int32_t height)
3753 {
3754  hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
3755  filter_x, filter_y, height, 24);
3756 }
3757 
3758 static void hevc_hv_4t_32w_msa(uint8_t *src,
3759  int32_t src_stride,
3760  int16_t *dst,
3761  int32_t dst_stride,
3762  const int8_t *filter_x,
3763  const int8_t *filter_y,
3764  int32_t height)
3765 {
3766  hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
3767  filter_x, filter_y, height, 32);
3768 }
3769 
3770 #define MC_COPY(WIDTH) \
3771 void ff_hevc_put_hevc_pel_pixels##WIDTH##_8_msa(int16_t *dst, \
3772  uint8_t *src, \
3773  ptrdiff_t src_stride, \
3774  int height, \
3775  intptr_t mx, \
3776  intptr_t my, \
3777  int width) \
3778 { \
3779  hevc_copy_##WIDTH##w_msa(src, src_stride, dst, MAX_PB_SIZE, height); \
3780 }
3781 
3782 MC_COPY(4);
3783 MC_COPY(6);
3784 MC_COPY(8);
3785 MC_COPY(12);
3786 MC_COPY(16);
3787 MC_COPY(24);
3788 MC_COPY(32);
3789 MC_COPY(48);
3790 MC_COPY(64);
3791 
3792 #undef MC_COPY
3793 
3794 #define MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR) \
3795 void ff_hevc_put_hevc_##PEL##_##DIR##WIDTH##_8_msa(int16_t *dst, \
3796  uint8_t *src, \
3797  ptrdiff_t src_stride, \
3798  int height, \
3799  intptr_t mx, \
3800  intptr_t my, \
3801  int width) \
3802 { \
3803  const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1]; \
3804  \
3805  hevc_##DIR1##_##TAP##t_##WIDTH##w_msa(src, src_stride, dst, \
3806  MAX_PB_SIZE, filter, height); \
3807 }
3808 
3809 MC(qpel, h, 4, 8, hz, mx);
3810 MC(qpel, h, 8, 8, hz, mx);
3811 MC(qpel, h, 12, 8, hz, mx);
3812 MC(qpel, h, 16, 8, hz, mx);
3813 MC(qpel, h, 24, 8, hz, mx);
3814 MC(qpel, h, 32, 8, hz, mx);
3815 MC(qpel, h, 48, 8, hz, mx);
3816 MC(qpel, h, 64, 8, hz, mx);
3817 
3818 MC(qpel, v, 4, 8, vt, my);
3819 MC(qpel, v, 8, 8, vt, my);
3820 MC(qpel, v, 12, 8, vt, my);
3821 MC(qpel, v, 16, 8, vt, my);
3822 MC(qpel, v, 24, 8, vt, my);
3823 MC(qpel, v, 32, 8, vt, my);
3824 MC(qpel, v, 48, 8, vt, my);
3825 MC(qpel, v, 64, 8, vt, my);
3826 
3827 MC(epel, h, 4, 4, hz, mx);
3828 MC(epel, h, 6, 4, hz, mx);
3829 MC(epel, h, 8, 4, hz, mx);
3830 MC(epel, h, 12, 4, hz, mx);
3831 MC(epel, h, 16, 4, hz, mx);
3832 MC(epel, h, 24, 4, hz, mx);
3833 MC(epel, h, 32, 4, hz, mx);
3834 
3835 MC(epel, v, 4, 4, vt, my);
3836 MC(epel, v, 6, 4, vt, my);
3837 MC(epel, v, 8, 4, vt, my);
3838 MC(epel, v, 12, 4, vt, my);
3839 MC(epel, v, 16, 4, vt, my);
3840 MC(epel, v, 24, 4, vt, my);
3841 MC(epel, v, 32, 4, vt, my);
3842 
3843 #undef MC
3844 
3845 #define MC_HV(PEL, DIR, WIDTH, TAP, DIR1) \
3846 void ff_hevc_put_hevc_##PEL##_##DIR##WIDTH##_8_msa(int16_t *dst, \
3847  uint8_t *src, \
3848  ptrdiff_t src_stride, \
3849  int height, \
3850  intptr_t mx, \
3851  intptr_t my, \
3852  int width) \
3853 { \
3854  const int8_t *filter_x = ff_hevc_##PEL##_filters[mx - 1]; \
3855  const int8_t *filter_y = ff_hevc_##PEL##_filters[my - 1]; \
3856  \
3857  hevc_##DIR1##_##TAP##t_##WIDTH##w_msa(src, src_stride, dst, MAX_PB_SIZE, \
3858  filter_x, filter_y, height); \
3859 }
3860 
3861 MC_HV(qpel, hv, 4, 8, hv);
3862 MC_HV(qpel, hv, 8, 8, hv);
3863 MC_HV(qpel, hv, 12, 8, hv);
3864 MC_HV(qpel, hv, 16, 8, hv);
3865 MC_HV(qpel, hv, 24, 8, hv);
3866 MC_HV(qpel, hv, 32, 8, hv);
3867 MC_HV(qpel, hv, 48, 8, hv);
3868 MC_HV(qpel, hv, 64, 8, hv);
3869 
3870 MC_HV(epel, hv, 4, 4, hv);
3871 MC_HV(epel, hv, 6, 4, hv);
3872 MC_HV(epel, hv, 8, 4, hv);
3873 MC_HV(epel, hv, 12, 4, hv);
3874 MC_HV(epel, hv, 16, 4, hv);
3875 MC_HV(epel, hv, 24, 4, hv);
3876 MC_HV(epel, hv, 32, 4, hv);
3877 
3878 #undef MC_HV
VSHF_B4_SB
#define VSHF_B4_SB(...)
Definition: generic_macros_msa.h:897
XORI_B5_128_SB
#define XORI_B5_128_SB(...)
Definition: generic_macros_msa.h:2018
XORI_B8_128_SB
#define XORI_B8_128_SB(...)
Definition: generic_macros_msa.h:2039
h
h
Definition: vp9dsp_template.c:2093
hevc_hz_4t_16w_msa
static void hevc_hz_4t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1910
hevc_hz_8t_8w_msa
static void hevc_hz_8t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:394
hevc_vt_8t_12w_msa
static void hevc_vt_8t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:966
hevc_hv_4t_4x2_msa
static void hevc_hv_4t_4x2_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevcdsp_msa.c:2888
hevc_hz_4t_4x4_msa
static void hevc_hz_4t_4x4_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter)
Definition: hevcdsp_msa.c:1562
hevc_hv_8t_64w_msa
static void hevc_hv_8t_64w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1520
hevc_copy_24w_msa
static void hevc_copy_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:310
hevc_hz_8t_16w_msa
static void hevc_hz_8t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:457
hevc_hz_4t_6w_msa
static void hevc_hz_4t_6w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1665
hevc_hz_4t_4w_msa
static void hevc_hz_4t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1648
ILVR_H4_SH
#define ILVR_H4_SH(...)
Definition: generic_macros_msa.h:1604
XORI_B2_128_SB
#define XORI_B2_128_SB(...)
Definition: generic_macros_msa.h:1994
SD
#define SD
Definition: ccaption_dec.c:647
LD_SB
#define LD_SB(...)
Definition: generic_macros_msa.h:32
hevc_hv_8t_8multx2mult_msa
static void hevc_hv_8t_8multx2mult_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height, int32_t width)
Definition: hevcdsp_msa.c:1305
XORI_B3_128_SB
#define XORI_B3_128_SB(...)
Definition: generic_macros_msa.h:2002
hevc_copy_32w_msa
static void hevc_copy_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:318
ILVR_W4_SB
#define ILVR_W4_SB(...)
Definition: generic_macros_msa.h:1622
DPADD_SB4_SH
#define DPADD_SB4_SH(...)
Definition: generic_macros_msa.h:1058
ILVR_B2_SB
#define ILVR_B2_SB(...)
Definition: generic_macros_msa.h:1536
SPLATI_H2_SH
#define SPLATI_H2_SH(...)
Definition: generic_macros_msa.h:1815
ILVL_H2_SH
#define ILVL_H2_SH(...)
Definition: generic_macros_msa.h:1490
hevc_copy_16multx8mult_msa
static void hevc_copy_16multx8mult_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height, int32_t width)
Definition: hevcdsp_msa.c:195
hevc_vt_4t_6w_msa
static void hevc_vt_4t_6w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2312
ILVR_H3_SH
#define ILVR_H3_SH(...)
Definition: generic_macros_msa.h:1596
LD_SB2
#define LD_SB2(...)
Definition: generic_macros_msa.h:308
hevc_vt_4t_12w_msa
static void hevc_vt_4t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2553
hevc_copy_8w_msa
static void hevc_copy_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:97
ILVL_H4_SH
#define ILVL_H4_SH(...)
Definition: generic_macros_msa.h:1499
hevc_hz_8t_12w_msa
static void hevc_hz_8t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:449
VSHF_B2_SB
#define VSHF_B2_SB(...)
Definition: generic_macros_msa.h:879
hevc_hv_4t_8x2_msa
static void hevc_hv_4t_8x2_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3335
hevc_hv_8t_24w_msa
static void hevc_hv_8t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1493
ILVR_D2_SB
#define ILVR_D2_SB(...)
Definition: generic_macros_msa.h:1640
uint8_t
uint8_t
Definition: audio_convert.c:194
ST_SH2
#define ST_SH2(...)
Definition: generic_macros_msa.h:478
hevc_vt_8t_32w_msa
static void hevc_vt_8t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1179
hevc_hv_4t_32w_msa
static void hevc_hv_4t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3758
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:82
SPLATI_H4_SH
#define SPLATI_H4_SH(...)
Definition: generic_macros_msa.h:1833
ILVL_B2_SB
#define ILVL_B2_SB(...)
Definition: generic_macros_msa.h:1461
hevc_vt_4t_8w_msa
static void hevc_vt_4t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2536
hevc_vt_4t_4w_msa
static void hevc_vt_4t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2295
LD_SH
#define LD_SH(...)
Definition: generic_macros_msa.h:36
ILVRL_H2_SH
#define ILVRL_H2_SH(...)
Definition: generic_macros_msa.h:1685
MC_HV
#define MC_HV(PEL, DIR, WIDTH, TAP, DIR1)
Definition: hevcdsp_msa.c:3845
ILVR_D3_SB
#define ILVR_D3_SB(...)
Definition: generic_macros_msa.h:1648
ILVR_D4_SB
#define ILVR_D4_SB(...)
Definition: generic_macros_msa.h:1656
LD_SB8
#define LD_SB8(...)
Definition: generic_macros_msa.h:358
MC_COPY
#define MC_COPY(WIDTH)
Definition: hevcdsp_msa.c:3770
hevc_vt_8t_8w_msa
static void hevc_vt_8t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:903
hevc_copy_48w_msa
static void hevc_copy_48w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:325
ST_SW
#define ST_SW(...)
Definition: generic_macros_msa.h:52
ST_SH6
#define ST_SH6(...)
Definition: generic_macros_msa.h:492
hevc_copy_64w_msa
static void hevc_copy_64w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:332
hevc_macros_msa.h
hevc_hv_4t_4multx8mult_msa
static void hevc_hv_4t_4multx8mult_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3052
ST8x2_UB
#define ST8x2_UB(in, pdst, stride)
Definition: generic_macros_msa.h:663
hevc_hv_8t_12w_msa
static void hevc_hv_8t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1472
hevc_vt_8t_48w_msa
static void hevc_vt_8t_48w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1187
hevc_hv_4t_6w_msa
static void hevc_hv_4t_6w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3204
generic_macros_msa.h
XORI_B7_128_SB
#define XORI_B7_128_SB(...)
Definition: generic_macros_msa.h:2032
hevc_hv_8t_4w_msa
static void hevc_hv_8t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1203
zero
#define zero
Definition: regdef.h:64
ILVR_B2_SH
#define ILVR_B2_SH(...)
Definition: generic_macros_msa.h:1538
hevc_vt_4t_8x2_msa
static void hevc_vt_4t_8x2_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter)
Definition: hevcdsp_msa.c:2386
hevcdsp_mips.h
XORI_B4_128_SB
#define XORI_B4_128_SB(...)
Definition: generic_macros_msa.h:2010
ILVR_W2_SB
#define ILVR_W2_SB(...)
Definition: generic_macros_msa.h:1613
hevc_vt_4t_8x4multiple_msa
static void hevc_vt_4t_8x4multiple_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2483
hevc_vt_8t_16multx4mult_msa
static void hevc_vt_8t_16multx4mult_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height, int32_t width)
Definition: hevcdsp_msa.c:1053
DPADD_SB2_SH
#define DPADD_SB2_SH(...)
Definition: generic_macros_msa.h:1050
MC
#define MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR)
Definition: hevcdsp_msa.c:3794
hevc_hv_4t_4x4_msa
static void hevc_hv_4t_4x4_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y)
Definition: hevcdsp_msa.c:2960
hevc_vt_4t_32w_msa
static void hevc_vt_4t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2782
hevc_hz_4t_4x8multiple_msa
static void hevc_hz_4t_4x8multiple_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1599
SPLATI_W4_SW
#define SPLATI_W4_SW(...)
Definition: generic_macros_msa.h:1860
hevc_vt_8t_24w_msa
static void hevc_vt_8t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1169
PCKEV_H2_SW
#define PCKEV_H2_SW(...)
Definition: generic_macros_msa.h:1919
int32_t
int32_t
Definition: audio_convert.c:194
hevc_hz_4t_12w_msa
static void hevc_hz_4t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1849
LD_SB3
#define LD_SB3(...)
Definition: generic_macros_msa.h:316
ILVL_B4_SH
#define ILVL_B4_SH(...)
Definition: generic_macros_msa.h:1474
hevc_hv_4t_4w_msa
static void hevc_hv_4t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3184
hevc_vt_4t_4x4_msa
static void hevc_vt_4t_4x4_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2197
hevc_hz_4t_8w_msa
static void hevc_hz_4t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1833
LD_SB4
#define LD_SB4(...)
Definition: generic_macros_msa.h:324
src
#define src
Definition: vp9dsp.c:530
hevc_hv_8t_8w_msa
static void hevc_hv_8t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1463
HEVC_FILT_8TAP
#define HEVC_FILT_8TAP(in0, in1, in2, in3,filt0, filt1, filt2, filt3)
Definition: hevc_macros_msa.h:61
hevc_copy_16w_msa
static void hevc_copy_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:245
ST_SW2
#define ST_SW2(in0, in1, pdst, stride)
Definition: generic_macros_msa.h:508
hevc_copy_4w_msa
static void hevc_copy_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:25
hevc_hv_4t_8w_msa
static void hevc_hv_4t_8w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3697
hevc_hv_4t_24w_msa
static void hevc_hv_4t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3746
src1
#define src1
Definition: h264pred.c:139
ILVL_B4_SB
#define ILVL_B4_SB(...)
Definition: generic_macros_msa.h:1472
hevc_vt_4t_24w_msa
static void hevc_vt_4t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2684
hevc_vt_4t_4x8multiple_msa
static void hevc_vt_4t_4x8multiple_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2234
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
hevc_hz_4t_32w_msa
static void hevc_hz_4t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2083
ST_SH
#define ST_SH(...)
Definition: generic_macros_msa.h:48
ILVR_B4_SH
#define ILVR_B4_SH(...)
Definition: generic_macros_msa.h:1559
hevc_vt_8t_16w_msa
static void hevc_vt_8t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1161
hevc_hv_4t_16w_msa
static void hevc_hv_4t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3734
src0
#define src0
Definition: h264pred.c:138
hevc_copy_12w_msa
static void hevc_copy_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:158
hevc_hz_4t_24w_msa
static void hevc_hz_4t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1982
ST12x8_UB
#define ST12x8_UB(in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride)
Definition: generic_macros_msa.h:725
SW
#define SW(val, pdst)
Definition: generic_macros_msa.h:203
hevc_hz_4t_8x2multiple_msa
static void hevc_hz_4t_8x2multiple_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1736
SLLI_4V
#define SLLI_4V(in0, in1, in2, in3, shift)
Definition: generic_macros_msa.h:2074
hevc_hv_8t_16w_msa
static void hevc_hv_8t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1484
LD_SB7
#define LD_SB7(...)
Definition: generic_macros_msa.h:349
hevc_hv_4t_8x6_msa
static void hevc_hv_4t_8x6_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3417
LD_SB5
#define LD_SB5(...)
Definition: generic_macros_msa.h:332
ILVL_W2_SB
#define ILVL_W2_SB(...)
Definition: generic_macros_msa.h:1517
HEVC_FILT_4TAP
#define HEVC_FILT_4TAP(in0, in1, filt0, filt1)
Definition: hevc_macros_msa.h:72
hevc_hz_8t_24w_msa
static void hevc_hz_8t_24w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:534
hevc_vt_8t_4w_msa
static void hevc_vt_8t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:833
PCKEV_H4_SW
#define PCKEV_H4_SW(...)
Definition: generic_macros_msa.h:1928
ST_SH8
#define ST_SH8(...)
Definition: generic_macros_msa.h:499
LD_SB6
#define LD_SB6(...)
Definition: generic_macros_msa.h:340
hevc_hz_8t_64w_msa
static void hevc_hz_8t_64w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:739
ST8x4_UB
#define ST8x4_UB(in0, in1, pdst, stride)
Definition: generic_macros_msa.h:687
hevc_vt_8t_64w_msa
static void hevc_vt_8t_64w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1195
ILVR_H2_SH
#define ILVR_H2_SH(...)
Definition: generic_macros_msa.h:1588
ST8x8_UB
#define ST8x8_UB(in0, in1, in2, in3, pdst, stride)
Definition: generic_macros_msa.h:699
hevc_hz_8t_32w_msa
static void hevc_hz_8t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:609
hevc_vt_4t_16w_msa
static void hevc_vt_4t_16w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:2617
hevc_hv_8t_48w_msa
static void hevc_hv_8t_48w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1511
hevc_vt_4t_4x2_msa
static void hevc_vt_4t_4x2_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter)
Definition: hevcdsp_msa.c:2164
hevc_hv_4t_8multx4mult_msa
static void hevc_hv_4t_8multx4mult_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height, int32_t width)
Definition: hevcdsp_msa.c:3568
hevc_hv_8t_32w_msa
static void hevc_hv_8t_32w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:1502
hevc_hz_8t_4w_msa
static void hevc_hz_8t_4w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:339
hevc_hz_8t_48w_msa
static void hevc_hz_8t_48w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:669
hevc_hz_4t_8x4multiple_msa
static void hevc_hz_4t_8x4multiple_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter, int32_t height)
Definition: hevcdsp_msa.c:1780
ILVR_B4_SB
#define ILVR_B4_SB(...)
Definition: generic_macros_msa.h:1557
SPLATI_W2_SW
#define SPLATI_W2_SW(...)
Definition: generic_macros_msa.h:1852
hevc_hz_4t_4x2_msa
static void hevc_hz_4t_4x2_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter)
Definition: hevcdsp_msa.c:1529
hevc_vt_4t_8x6_msa
static void hevc_vt_4t_8x6_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter)
Definition: hevcdsp_msa.c:2421
ST_SH4
#define ST_SH4(...)
Definition: generic_macros_msa.h:485
hevc_hv_4t_12w_msa
static void hevc_hv_4t_12w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, const int8_t *filter_x, const int8_t *filter_y, int32_t height)
Definition: hevcdsp_msa.c:3718
hevc_copy_6w_msa
static void hevc_copy_6w_msa(uint8_t *src, int32_t src_stride, int16_t *dst, int32_t dst_stride, int32_t height)
Definition: hevcdsp_msa.c:73
width
static int width
Definition: demuxing_decoding.c:39
Generated on Mon Feb 15 2016 15:20:40 for FFmpeg by   doxygen 1.8.6