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