avcodec/mips: Improve avc bi-weighted mc msa functions
[ffmpeg.git] / libavcodec / mips / h264dsp_msa.c
1 /*
2  * Copyright (c) 2015 - 2017 Parag Salasakar (Parag.Salasakar@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 "h264dsp_mips.h"
23
24 static void avc_wgt_4x2_msa(uint8_t *data, int32_t stride,
25                             int32_t log2_denom, int32_t src_weight,
26                             int32_t offset_in)
27 {
28     uint32_t tp0, tp1, offset_val;
29     v16u8 zero = { 0 };
30     v16u8 src0 = { 0 };
31     v8i16 src0_r, tmp0, wgt, denom, offset;
32
33     offset_val = (unsigned) offset_in << log2_denom;
34
35     wgt = __msa_fill_h(src_weight);
36     offset = __msa_fill_h(offset_val);
37     denom = __msa_fill_h(log2_denom);
38
39     LW2(data, stride, tp0, tp1);
40     INSERT_W2_UB(tp0, tp1, src0);
41     src0_r = (v8i16) __msa_ilvr_b((v16i8) zero, (v16i8) src0);
42     tmp0 = wgt * src0_r;
43     tmp0 = __msa_adds_s_h(tmp0, offset);
44     tmp0 = __msa_maxi_s_h(tmp0, 0);
45     tmp0 = __msa_srlr_h(tmp0, denom);
46     tmp0 = (v8i16) __msa_sat_u_h((v8u16) tmp0, 7);
47     src0 = (v16u8) __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
48     ST4x2_UB(src0, data, stride);
49 }
50
51 static void avc_wgt_4x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
52                             int32_t src_weight, int32_t offset_in)
53 {
54     uint32_t tp0, tp1, tp2, tp3, offset_val;
55     v16u8 src0 = { 0 };
56     v8i16 src0_r, src1_r, tmp0, tmp1, wgt, denom, offset;
57
58     offset_val = (unsigned) offset_in << log2_denom;
59
60     wgt = __msa_fill_h(src_weight);
61     offset = __msa_fill_h(offset_val);
62     denom = __msa_fill_h(log2_denom);
63
64     LW4(data, stride, tp0, tp1, tp2, tp3);
65     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
66     UNPCK_UB_SH(src0, src0_r, src1_r);
67     MUL2(wgt, src0_r, wgt, src1_r, tmp0, tmp1);
68     ADDS_SH2_SH(tmp0, offset, tmp1, offset, tmp0, tmp1);
69     MAXI_SH2_SH(tmp0, tmp1, 0);
70     tmp0 = __msa_srlr_h(tmp0, denom);
71     tmp1 = __msa_srlr_h(tmp1, denom);
72     SAT_UH2_SH(tmp0, tmp1, 7);
73     src0 = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
74     ST4x4_UB(src0, src0, 0, 1, 2, 3, data, stride);
75 }
76
77 static void avc_wgt_4x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
78                             int32_t src_weight, int32_t offset_in)
79 {
80     uint32_t tp0, tp1, tp2, tp3, offset_val;
81     v16u8 src0 = { 0 }, src1 = { 0 };
82     v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
83     v8i16 wgt, denom, offset;
84
85     offset_val = (unsigned) offset_in << log2_denom;
86
87     wgt = __msa_fill_h(src_weight);
88     offset = __msa_fill_h(offset_val);
89     denom = __msa_fill_h(log2_denom);
90
91     LW4(data, stride, tp0, tp1, tp2, tp3);
92     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
93     LW4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
94     INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
95     UNPCK_UB_SH(src0, src0_r, src1_r);
96     UNPCK_UB_SH(src1, src2_r, src3_r);
97     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
98          tmp3);
99     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
100                 tmp1, tmp2, tmp3);
101     MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
102     SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
103     SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
104     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
105     ST4x8_UB(src0, src1, data, stride);
106 }
107
108 static void avc_wgt_8x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
109                             int32_t src_weight, int32_t offset_in)
110 {
111     uint32_t offset_val;
112     uint64_t tp0, tp1, tp2, tp3;
113     v16u8 src0 = { 0 }, src1 = { 0 };
114     v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
115     v8i16 wgt, denom, offset;
116
117     offset_val = (unsigned) offset_in << log2_denom;
118
119     wgt = __msa_fill_h(src_weight);
120     offset = __msa_fill_h(offset_val);
121     denom = __msa_fill_h(log2_denom);
122
123     LD4(data, stride, tp0, tp1, tp2, tp3);
124     INSERT_D2_UB(tp0, tp1, src0);
125     INSERT_D2_UB(tp2, tp3, src1);
126     UNPCK_UB_SH(src0, src0_r, src1_r);
127     UNPCK_UB_SH(src1, src2_r, src3_r);
128     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
129          tmp3);
130     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
131                 tmp1, tmp2, tmp3);
132     MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
133     SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
134     SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
135     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
136     ST8x4_UB(src0, src1, data, stride);
137 }
138
139 static void avc_wgt_8x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
140                             int32_t src_weight, int32_t offset_in)
141 {
142     uint32_t offset_val;
143     uint64_t tp0, tp1, tp2, tp3;
144     v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
145     v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
146     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
147     v8i16 wgt, denom, offset;
148
149     offset_val = (unsigned) offset_in << log2_denom;
150
151     wgt = __msa_fill_h(src_weight);
152     offset = __msa_fill_h(offset_val);
153     denom = __msa_fill_h(log2_denom);
154
155     LD4(data, stride, tp0, tp1, tp2, tp3);
156     INSERT_D2_UB(tp0, tp1, src0);
157     INSERT_D2_UB(tp2, tp3, src1);
158     LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
159     INSERT_D2_UB(tp0, tp1, src2);
160     INSERT_D2_UB(tp2, tp3, src3);
161     UNPCK_UB_SH(src0, src0_r, src1_r);
162     UNPCK_UB_SH(src1, src2_r, src3_r);
163     UNPCK_UB_SH(src2, src4_r, src5_r);
164     UNPCK_UB_SH(src3, src6_r, src7_r);
165     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
166          tmp3);
167     MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5, tmp6,
168          tmp7);
169     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
170                 tmp1, tmp2, tmp3);
171     ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
172                 tmp5, tmp6, tmp7);
173     MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
174     SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
175     SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
176     PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
177                 src2, src3);
178     ST8x8_UB(src0, src1, src2, src3, data, stride);
179 }
180
181 static void avc_wgt_8x16_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
182                              int32_t src_weight, int32_t offset_in)
183 {
184     uint32_t offset_val, cnt;
185     uint64_t tp0, tp1, tp2, tp3;
186     v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
187     v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
188     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
189     v8i16 wgt, denom, offset;
190
191     offset_val = (unsigned) offset_in << log2_denom;
192
193     wgt = __msa_fill_h(src_weight);
194     offset = __msa_fill_h(offset_val);
195     denom = __msa_fill_h(log2_denom);
196
197     for (cnt = 2; cnt--;) {
198         LD4(data, stride, tp0, tp1, tp2, tp3);
199         INSERT_D2_UB(tp0, tp1, src0);
200         INSERT_D2_UB(tp2, tp3, src1);
201         LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
202         INSERT_D2_UB(tp0, tp1, src2);
203         INSERT_D2_UB(tp2, tp3, src3);
204         UNPCK_UB_SH(src0, src0_r, src1_r);
205         UNPCK_UB_SH(src1, src2_r, src3_r);
206         UNPCK_UB_SH(src2, src4_r, src5_r);
207         UNPCK_UB_SH(src3, src6_r, src7_r);
208         MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1,
209              tmp2, tmp3);
210         MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5,
211              tmp6, tmp7);
212         ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
213                     tmp0, tmp1, tmp2, tmp3);
214         ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
215                     tmp4, tmp5, tmp6, tmp7);
216         MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
217         SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
218         SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
219         PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
220                     src2, src3);
221         ST8x8_UB(src0, src1, src2, src3, data, stride);
222         data += 8 * stride;
223     }
224 }
225
226 static void avc_biwgt_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
227                               int32_t log2_denom, int32_t src_weight,
228                               int32_t dst_weight, int32_t offset_in)
229 {
230     uint32_t tp0, tp1;
231     v16i8 src_wgt, dst_wgt, wgt, vec0;
232     v16u8 src0 = { 0 }, dst0 = { 0 };
233     v8i16 tmp0, denom, offset, max255 = __msa_ldi_h(255);
234
235     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
236     offset_in += (128 * (src_weight + dst_weight));
237
238     src_wgt = __msa_fill_b(src_weight);
239     dst_wgt = __msa_fill_b(dst_weight);
240     offset = __msa_fill_h(offset_in);
241     denom = __msa_fill_h(log2_denom + 1);
242
243     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
244
245     LW2(src, stride, tp0, tp1);
246     INSERT_W2_UB(tp0, tp1, src0);
247     LW2(dst, stride, tp0, tp1);
248     INSERT_W2_UB(tp0, tp1, dst0);
249     XORI_B2_128_UB(src0, dst0);
250     vec0 = (v16i8) __msa_ilvr_b((v16i8) dst0, (v16i8) src0);
251     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
252     tmp0 >>= denom;
253     tmp0 = __msa_maxi_s_h(tmp0, 0);
254     tmp0 = __msa_min_s_h(max255, tmp0);
255     dst0 = (v16u8) __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
256     ST4x2_UB(dst0, dst, stride);
257 }
258
259 static void avc_biwgt_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
260                               int32_t log2_denom, int32_t src_weight,
261                               int32_t dst_weight, int32_t offset_in)
262 {
263     uint32_t tp0, tp1, tp2, tp3;
264     v16i8 src_wgt, dst_wgt, wgt, vec0, vec1;
265     v16u8 src0, dst0;
266     v8i16 tmp0, tmp1, denom, offset;
267
268     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
269     offset_in += (128 * (src_weight + dst_weight));
270
271     src_wgt = __msa_fill_b(src_weight);
272     dst_wgt = __msa_fill_b(dst_weight);
273     offset = __msa_fill_h(offset_in);
274     denom = __msa_fill_h(log2_denom + 1);
275
276     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
277
278     LW4(src, stride, tp0, tp1, tp2, tp3);
279     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
280     LW4(dst, stride, tp0, tp1, tp2, tp3);
281     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
282     XORI_B2_128_UB(src0, dst0);
283     ILVRL_B2_SB(dst0, src0, vec0, vec1);
284     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
285     tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
286     tmp0 >>= denom;
287     tmp1 >>= denom;
288     CLIP_SH2_0_255(tmp0, tmp1);
289     dst0 = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
290     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, stride);
291 }
292
293 static void avc_biwgt_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
294                               int32_t log2_denom, int32_t src_weight,
295                               int32_t dst_weight, int32_t offset_in)
296 {
297     uint32_t tp0, tp1, tp2, tp3;
298     v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3;
299     v16u8 src0, src1, dst0, dst1;
300     v8i16 tmp0, tmp1, tmp2, tmp3, denom, offset;
301
302     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
303     offset_in += (128 * (src_weight + dst_weight));
304
305     src_wgt = __msa_fill_b(src_weight);
306     dst_wgt = __msa_fill_b(dst_weight);
307     offset = __msa_fill_h(offset_in);
308     denom = __msa_fill_h(log2_denom + 1);
309     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
310
311     LW4(src, stride, tp0, tp1, tp2, tp3);
312     src += 4 * stride;
313     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
314     LW4(src, stride, tp0, tp1, tp2, tp3);
315     INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
316     LW4(dst, stride, tp0, tp1, tp2, tp3);
317     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
318     LW4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
319     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
320     XORI_B4_128_UB(src0, src1, dst0, dst1);
321     ILVRL_B2_SB(dst0, src0, vec0, vec1);
322     ILVRL_B2_SB(dst1, src1, vec2, vec3);
323     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
324     tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
325     tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
326     tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
327     SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
328     CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
329     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
330     ST4x8_UB(dst0, dst1, dst, stride);
331 }
332
333 static void avc_biwgt_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
334                               int32_t log2_denom, int32_t src_weight,
335                               int32_t dst_weight, int32_t offset_in)
336 {
337     uint64_t tp0, tp1, tp2, tp3;
338     v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3;
339     v16u8 src0, src1, dst0, dst1;
340     v8i16 tmp0, tmp1, tmp2, tmp3, denom, offset;
341
342     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
343     offset_in += (128 * (src_weight + dst_weight));
344
345     src_wgt = __msa_fill_b(src_weight);
346     dst_wgt = __msa_fill_b(dst_weight);
347     offset = __msa_fill_h(offset_in);
348     denom = __msa_fill_h(log2_denom + 1);
349
350     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
351
352     LD4(src, stride, tp0, tp1, tp2, tp3);
353     INSERT_D2_UB(tp0, tp1, src0);
354     INSERT_D2_UB(tp2, tp3, src1);
355     LD4(dst, stride, tp0, tp1, tp2, tp3);
356     INSERT_D2_UB(tp0, tp1, dst0);
357     INSERT_D2_UB(tp2, tp3, dst1);
358     XORI_B4_128_UB(src0, src1, dst0, dst1);
359     ILVRL_B2_SB(dst0, src0, vec0, vec1);
360     ILVRL_B2_SB(dst1, src1, vec2, vec3);
361     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
362     tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
363     tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
364     tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
365     SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
366     CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
367     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
368     ST8x4_UB(dst0, dst1, dst, stride);
369 }
370
371 static void avc_biwgt_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
372                               int32_t log2_denom, int32_t src_weight,
373                               int32_t dst_weight, int32_t offset_in)
374 {
375     uint64_t tp0, tp1, tp2, tp3;
376     v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
377     v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
378     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom, offset;
379
380     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
381     offset_in += (128 * (src_weight + dst_weight));
382
383     src_wgt = __msa_fill_b(src_weight);
384     dst_wgt = __msa_fill_b(dst_weight);
385     offset = __msa_fill_h(offset_in);
386     denom = __msa_fill_h(log2_denom + 1);
387     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
388
389     LD4(src, stride, tp0, tp1, tp2, tp3);
390     INSERT_D2_UB(tp0, tp1, src0);
391     INSERT_D2_UB(tp2, tp3, src1);
392     LD4(src + 4 * stride, stride, tp0, tp1, tp2, tp3);
393     INSERT_D2_UB(tp0, tp1, src2);
394     INSERT_D2_UB(tp2, tp3, src3);
395     LD4(dst, stride, tp0, tp1, tp2, tp3);
396     INSERT_D2_UB(tp0, tp1, dst0);
397     INSERT_D2_UB(tp2, tp3, dst1);
398     LD4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
399     INSERT_D2_UB(tp0, tp1, dst2);
400     INSERT_D2_UB(tp2, tp3, dst3);
401     XORI_B8_128_UB(src0, src1, src2, src3, dst0, dst1, dst2, dst3);
402     ILVRL_B2_SB(dst0, src0, vec0, vec1);
403     ILVRL_B2_SB(dst1, src1, vec2, vec3);
404     ILVRL_B2_SB(dst2, src2, vec4, vec5);
405     ILVRL_B2_SB(dst3, src3, vec6, vec7);
406     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
407     tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
408     tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
409     tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
410     tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
411     tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
412     tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
413     tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
414     SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
415     SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
416     CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
417     CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
418     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
419     PCKEV_B2_UB(tmp5, tmp4, tmp7, tmp6, dst2, dst3);
420     ST8x8_UB(dst0, dst1, dst2, dst3, dst, stride);
421 }
422
423 static void avc_biwgt_8x16_msa(uint8_t *src, uint8_t *dst, int32_t stride,
424                                int32_t log2_denom, int32_t src_weight,
425                                int32_t dst_weight, int32_t offset_in)
426 {
427     uint8_t cnt;
428     uint64_t tp0, tp1, tp2, tp3;
429     v16i8 src_wgt, dst_wgt, wgt;
430     v16u8 src0, src1, src2, src3;
431     v16u8 dst0, dst1, dst2, dst3;
432     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
433     v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
434     v8i16 denom, offset;
435
436     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
437     offset_in += (128 * (src_weight + dst_weight));
438
439     src_wgt = __msa_fill_b(src_weight);
440     dst_wgt = __msa_fill_b(dst_weight);
441     offset = __msa_fill_h(offset_in);
442     denom = __msa_fill_h(log2_denom + 1);
443     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
444
445     for (cnt = 2; cnt--;) {
446         LD4(src, stride, tp0, tp1, tp2, tp3);
447         src += 4 * stride;
448         INSERT_D2_UB(tp0, tp1, src0);
449         INSERT_D2_UB(tp2, tp3, src1);
450         LD4(src, stride, tp0, tp1, tp2, tp3);
451         src += 4 * stride;
452         INSERT_D2_UB(tp0, tp1, src2);
453         INSERT_D2_UB(tp2, tp3, src3);
454         LD4(dst, stride, tp0, tp1, tp2, tp3);
455         INSERT_D2_UB(tp0, tp1, dst0);
456         INSERT_D2_UB(tp2, tp3, dst1);
457         LD4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
458         INSERT_D2_UB(tp0, tp1, dst2);
459         INSERT_D2_UB(tp2, tp3, dst3);
460         XORI_B4_128_UB(src0, src1, src2, src3);
461         XORI_B4_128_UB(dst0, dst1, dst2, dst3);
462         ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
463                    vec0, vec2, vec4, vec6);
464         ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
465                    vec1, vec3, vec5, vec7);
466
467         temp0 = __msa_dpadd_s_h(offset, wgt, vec0);
468         temp1 = __msa_dpadd_s_h(offset, wgt, vec1);
469         temp2 = __msa_dpadd_s_h(offset, wgt, vec2);
470         temp3 = __msa_dpadd_s_h(offset, wgt, vec3);
471         temp4 = __msa_dpadd_s_h(offset, wgt, vec4);
472         temp5 = __msa_dpadd_s_h(offset, wgt, vec5);
473         temp6 = __msa_dpadd_s_h(offset, wgt, vec6);
474         temp7 = __msa_dpadd_s_h(offset, wgt, vec7);
475
476         SRA_4V(temp0, temp1, temp2, temp3, denom);
477         SRA_4V(temp4, temp5, temp6, temp7, denom);
478         CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
479         CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
480         PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
481                     dst0, dst1, dst2, dst3);
482         ST8x8_UB(dst0, dst1, dst2, dst3, dst, stride);
483         dst += 8 * stride;
484     }
485 }
486
487 #define AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_or_q3_org_in, p0_or_q0_org_in,          \
488                                  q3_or_p3_org_in, p1_or_q1_org_in,          \
489                                  p2_or_q2_org_in, q1_or_p1_org_in,          \
490                                  p0_or_q0_out, p1_or_q1_out, p2_or_q2_out)  \
491 {                                                                           \
492     v8i16 threshold;                                                        \
493     v8i16 const3 = __msa_ldi_h(3);                                          \
494                                                                             \
495     threshold = (p0_or_q0_org_in) + (q3_or_p3_org_in);                      \
496     threshold += (p1_or_q1_org_in);                                         \
497                                                                             \
498     (p0_or_q0_out) = threshold << 1;                                        \
499     (p0_or_q0_out) += (p2_or_q2_org_in);                                    \
500     (p0_or_q0_out) += (q1_or_p1_org_in);                                    \
501     (p0_or_q0_out) = __msa_srari_h((p0_or_q0_out), 3);                      \
502                                                                             \
503     (p1_or_q1_out) = (p2_or_q2_org_in) + threshold;                         \
504     (p1_or_q1_out) = __msa_srari_h((p1_or_q1_out), 2);                      \
505                                                                             \
506     (p2_or_q2_out) = (p2_or_q2_org_in) * const3;                            \
507     (p2_or_q2_out) += (p3_or_q3_org_in);                                    \
508     (p2_or_q2_out) += (p3_or_q3_org_in);                                    \
509     (p2_or_q2_out) += threshold;                                            \
510     (p2_or_q2_out) = __msa_srari_h((p2_or_q2_out), 3);                      \
511 }
512
513 /* data[-u32_img_width] = (uint8_t)((2 * p1 + p0 + q1 + 2) >> 2); */
514 #define AVC_LPF_P0_OR_Q0(p0_or_q0_org_in, q1_or_p1_org_in,   \
515                          p1_or_q1_org_in, p0_or_q0_out)      \
516 {                                                            \
517     (p0_or_q0_out) = (p0_or_q0_org_in) + (q1_or_p1_org_in);  \
518     (p0_or_q0_out) += (p1_or_q1_org_in);                     \
519     (p0_or_q0_out) += (p1_or_q1_org_in);                     \
520     (p0_or_q0_out) = __msa_srari_h((p0_or_q0_out), 2);       \
521 }
522
523 #define AVC_LPF_P1_OR_Q1(p0_or_q0_org_in, q0_or_p0_org_in,    \
524                          p1_or_q1_org_in, p2_or_q2_org_in,    \
525                          negate_tc_in, tc_in, p1_or_q1_out)   \
526 {                                                             \
527     v8i16 clip3, temp;                                        \
528                                                               \
529     clip3 = (v8i16) __msa_aver_u_h((v8u16) p0_or_q0_org_in,   \
530                                    (v8u16) q0_or_p0_org_in);  \
531     temp = p1_or_q1_org_in << 1;                              \
532     clip3 = clip3 - temp;                                     \
533     clip3 = __msa_ave_s_h(p2_or_q2_org_in, clip3);            \
534     clip3 = CLIP_SH(clip3, negate_tc_in, tc_in);              \
535     p1_or_q1_out = p1_or_q1_org_in + clip3;                   \
536 }
537
538 #define AVC_LPF_P0Q0(q0_or_p0_org_in, p0_or_q0_org_in,          \
539                      p1_or_q1_org_in, q1_or_p1_org_in,          \
540                      negate_threshold_in, threshold_in,         \
541                      p0_or_q0_out, q0_or_p0_out)                \
542 {                                                               \
543     v8i16 q0_sub_p0, p1_sub_q1, delta;                          \
544                                                                 \
545     q0_sub_p0 = q0_or_p0_org_in - p0_or_q0_org_in;              \
546     p1_sub_q1 = p1_or_q1_org_in - q1_or_p1_org_in;              \
547     q0_sub_p0 <<= 2;                                            \
548     p1_sub_q1 += 4;                                             \
549     delta = q0_sub_p0 + p1_sub_q1;                              \
550     delta >>= 3;                                                \
551                                                                 \
552     delta = CLIP_SH(delta, negate_threshold_in, threshold_in);  \
553                                                                 \
554     p0_or_q0_out = p0_or_q0_org_in + delta;                     \
555     q0_or_p0_out = q0_or_p0_org_in - delta;                     \
556                                                                 \
557     CLIP_SH2_0_255(p0_or_q0_out, q0_or_p0_out);                 \
558 }
559
560 #define AVC_LPF_H_CHROMA_422(src, stride, tc_val, alpha, beta, res)      \
561 {                                                                        \
562     uint32_t load0, load1, load2, load3;                                 \
563     v16u8 src0 = { 0 };                                                  \
564     v16u8 src1 = { 0 };                                                  \
565     v16u8 src2 = { 0 };                                                  \
566     v16u8 src3 = { 0 };                                                  \
567     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;                            \
568     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;           \
569     v8i16 tc, q0_sub_p0, p1_sub_q1, delta;                               \
570     v8i16 res0_r, res1_r;                                                \
571     v16i8 zeros = { 0 };                                                 \
572     v16u8 res0, res1;                                                    \
573                                                                          \
574     LW4((src - 2), stride, load0, load1, load2, load3);                  \
575     src0 = (v16u8) __msa_insert_w((v4i32) src0, 0, load0);               \
576     src1 = (v16u8) __msa_insert_w((v4i32) src1, 0, load1);               \
577     src2 = (v16u8) __msa_insert_w((v4i32) src2, 0, load2);               \
578     src3 = (v16u8) __msa_insert_w((v4i32) src3, 0, load3);               \
579                                                                          \
580     TRANSPOSE4x4_UB_UB(src0, src1, src2, src3, src0, src1, src2, src3);  \
581                                                                          \
582     p0_asub_q0 = __msa_asub_u_b(src2, src1);                             \
583     p1_asub_p0 = __msa_asub_u_b(src1, src0);                             \
584     q1_asub_q0 = __msa_asub_u_b(src2, src3);                             \
585                                                                          \
586     tc = __msa_fill_h(tc_val);                                           \
587                                                                          \
588     is_less_than_alpha = (p0_asub_q0 < alpha);                           \
589     is_less_than_beta = (p1_asub_p0 < beta);                             \
590     is_less_than = is_less_than_alpha & is_less_than_beta;               \
591     is_less_than_beta = (q1_asub_q0 < beta);                             \
592     is_less_than = is_less_than_beta & is_less_than;                     \
593                                                                          \
594     ILVR_B2_SH(src2, src1, src0, src3, q0_sub_p0, p1_sub_q1);            \
595     HSUB_UB2_SH(q0_sub_p0, p1_sub_q1, q0_sub_p0, p1_sub_q1);             \
596                                                                          \
597     q0_sub_p0 <<= 2;                                                     \
598     delta = q0_sub_p0 + p1_sub_q1;                                       \
599     delta = __msa_srari_h(delta, 3);                                     \
600                                                                          \
601     delta = CLIP_SH(delta, -tc, tc);                                     \
602                                                                          \
603     ILVR_B2_SH(zeros, src1, zeros, src2, res0_r, res1_r);                \
604                                                                          \
605     res0_r += delta;                                                     \
606     res1_r -= delta;                                                     \
607                                                                          \
608     CLIP_SH2_0_255(res0_r, res1_r);                                      \
609     PCKEV_B2_UB(res0_r, res0_r, res1_r, res1_r, res0, res1);             \
610                                                                          \
611     res0 = __msa_bmnz_v(src1, res0, is_less_than);                       \
612     res1 = __msa_bmnz_v(src2, res1, is_less_than);                       \
613                                                                          \
614     res = (v16u8) __msa_ilvr_b((v16i8) res1, (v16i8) res0);              \
615 }
616
617 #define TRANSPOSE2x4_B_UB(in0, in1, out0, out1, out2, out3)  \
618 {                                                            \
619     v16i8 zero_m = { 0 };                                    \
620                                                              \
621     out0 = (v16u8) __msa_ilvr_b((v16i8) in1, (v16i8) in0);   \
622     out1 = (v16u8) __msa_sldi_b(zero_m, (v16i8) out0, 2);    \
623     SLDI_B2_0_UB(out1, out2, out2, out3, 2);                 \
624 }
625
626 #define AVC_LPF_H_2BYTE_CHROMA_422(src, stride, tc_val, alpha, beta, res)  \
627 {                                                                          \
628     uint32_t load0, load1;                                                 \
629     v16u8 src0 = { 0 };                                                    \
630     v16u8 src1 = { 0 };                                                    \
631     v16u8 src2 = { 0 };                                                    \
632     v16u8 src3 = { 0 };                                                    \
633     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;                              \
634     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;             \
635     v8i16 tc, q0_sub_p0, p1_sub_q1, delta, res0_r, res1_r;                 \
636     v16i8 zeros = { 0 };                                                   \
637     v16u8 res0, res1;                                                      \
638                                                                            \
639     load0 = LW(src - 2);                                                   \
640     load1 = LW(src - 2 + stride);                                          \
641                                                                            \
642     src0 = (v16u8) __msa_insert_w((v4i32) src0, 0, load0);                 \
643     src1 = (v16u8) __msa_insert_w((v4i32) src1, 0, load1);                 \
644                                                                            \
645     TRANSPOSE2x4_B_UB(src0, src1, src0, src1, src2, src3);                 \
646                                                                            \
647     p0_asub_q0 = __msa_asub_u_b(src2, src1);                               \
648     p1_asub_p0 = __msa_asub_u_b(src1, src0);                               \
649     q1_asub_q0 = __msa_asub_u_b(src2, src3);                               \
650                                                                            \
651     tc = __msa_fill_h(tc_val);                                             \
652                                                                            \
653     is_less_than_alpha = (p0_asub_q0 < alpha);                             \
654     is_less_than_beta = (p1_asub_p0 < beta);                               \
655     is_less_than = is_less_than_alpha & is_less_than_beta;                 \
656     is_less_than_beta = (q1_asub_q0 < beta);                               \
657     is_less_than = is_less_than_beta & is_less_than;                       \
658                                                                            \
659     ILVR_B2_SH(src2, src1, src0, src3, q0_sub_p0, p1_sub_q1);              \
660     HSUB_UB2_SH(q0_sub_p0, p1_sub_q1, q0_sub_p0, p1_sub_q1);               \
661                                                                            \
662     q0_sub_p0 <<= 2;                                                       \
663     delta = q0_sub_p0 + p1_sub_q1;                                         \
664     delta = __msa_srari_h(delta, 3);                                       \
665     delta = CLIP_SH(delta, -tc, tc);                                       \
666                                                                            \
667     ILVR_B2_SH(zeros, src1, zeros, src2, res0_r, res1_r);                  \
668                                                                            \
669     res0_r += delta;                                                       \
670     res1_r -= delta;                                                       \
671                                                                            \
672     CLIP_SH2_0_255(res0_r, res1_r);                                        \
673     PCKEV_B2_UB(res0_r, res0_r, res1_r, res1_r, res0, res1);               \
674                                                                            \
675     res0 = __msa_bmnz_v(src1, res0, is_less_than);                         \
676     res1 = __msa_bmnz_v(src2, res1, is_less_than);                         \
677                                                                            \
678     res = (v16u8) __msa_ilvr_b((v16i8) res1, (v16i8) res0);                \
679 }
680
681 static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data,
682                                                    uint8_t alpha_in,
683                                                    uint8_t beta_in,
684                                                    uint32_t img_width)
685 {
686     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
687     v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
688     v16u8 p1_org, p0_org, q0_org, q1_org;
689
690     LD_UB4(data - (img_width << 1), img_width, p1_org, p0_org, q0_org, q1_org);
691
692     p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
693     p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
694     q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
695
696     is_less_than_alpha = (p0_asub_q0 < alpha_in);
697     is_less_than_beta = (p1_asub_p0 < beta_in);
698     is_less_than = is_less_than_beta & is_less_than_alpha;
699     is_less_than_beta = (q1_asub_q0 < beta_in);
700     is_less_than = is_less_than_beta & is_less_than;
701
702     if (!__msa_test_bz_v(is_less_than)) {
703         v16u8 p2_asub_p0, q2_asub_q0, p0, q0, negate_is_less_than_beta;
704         v8i16 p0_r = { 0 };
705         v8i16 q0_r = { 0 };
706         v8i16 p0_l = { 0 };
707         v8i16 q0_l = { 0 };
708         v16i8 zero = { 0 };
709         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
710         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
711         v16u8 q2_org = LD_UB(data + (2 * img_width));
712         v16u8 p2_org = LD_UB(data - (3 * img_width));
713         v16u8 tmp_flag = (v16u8)__msa_fill_b((alpha_in >> 2) + 2);
714
715         UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
716         UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
717         UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
718
719         tmp_flag = (p0_asub_q0 < tmp_flag);
720
721         p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
722         is_less_than_beta = (p2_asub_p0 < beta_in);
723         is_less_than_beta = is_less_than_beta & tmp_flag;
724         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
725         is_less_than_beta = is_less_than_beta & is_less_than;
726         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
727
728         q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
729         q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
730
731         /* combine and store */
732         if (!__msa_test_bz_v(is_less_than_beta)) {
733             v8i16 p3_org_l, p3_org_r;
734             v16u8 p3_org = LD_UB(data - (img_width << 2));
735             v16u8 p2, p1;
736             v8i16 p2_r = { 0 };
737             v8i16 p2_l = { 0 };
738             v8i16 p1_r = { 0 };
739             v8i16 p1_l = { 0 };
740
741             ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
742             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
743                                      p2_r, q1_org_r, p0_r, p1_r, p2_r);
744
745             ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
746             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
747                                      p2_l, q1_org_l, p0_l, p1_l, p2_l);
748
749             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
750
751             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
752             p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
753             p2_org = __msa_bmnz_v(p2_org, p2, is_less_than_beta);
754
755             ST_UB(p1_org, data - (2 * img_width));
756             ST_UB(p2_org, data - (3 * img_width));
757         }
758
759         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
760         AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
761
762         /* combine */
763         p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
764         p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
765
766         ST_UB(p0_org, data - img_width);
767
768         /* if (tmpFlag && (unsigned)ABS(q2-q0) < thresholds->beta_in) */
769         q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
770         is_less_than_beta = (q2_asub_q0 < beta_in);
771         is_less_than_beta = is_less_than_beta & tmp_flag;
772         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
773         is_less_than_beta = is_less_than_beta & is_less_than;
774         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
775
776         /* combine and store */
777         if (!__msa_test_bz_v(is_less_than_beta)) {
778             v8i16 q3_org_r, q3_org_l;
779             v16u8 q3_org = LD_UB(data + (3 * img_width));
780             v16u8 q1, q2;
781             v8i16 q2_r = { 0 };
782             v8i16 q2_l = { 0 };
783             v8i16 q1_r = { 0 };
784             v8i16 q1_l = { 0 };
785
786             ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
787             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
788                                      q2_r, p1_org_r, q0_r, q1_r, q2_r);
789
790             ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
791             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
792                                      q2_l, p1_org_l, q0_l, q1_l, q2_l);
793
794             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
795             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
796             q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
797             q2_org = __msa_bmnz_v(q2_org, q2, is_less_than_beta);
798
799             ST_UB(q1_org, data + img_width);
800             ST_UB(q2_org, data + 2 * img_width);
801         }
802
803         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
804         AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
805
806         /* combine */
807         q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
808         q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
809
810         ST_UB(q0_org, data);
811     }
812 }
813
814 static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
815                                                    uint8_t alpha_in,
816                                                    uint8_t beta_in,
817                                                    uint32_t img_width)
818 {
819     uint8_t *src = data - 4;
820     v16u8 alpha, beta, p0_asub_q0;
821     v16u8 is_less_than_alpha, is_less_than, is_less_than_beta;
822     v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
823     v16u8 p1_asub_p0, q1_asub_q0;
824
825
826     {
827         v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
828         v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
829
830         LD_UB8(src, img_width, row0, row1, row2, row3, row4, row5, row6, row7);
831         LD_UB8(src + (8 * img_width), img_width,
832                row8, row9, row10, row11, row12, row13, row14, row15);
833
834         TRANSPOSE16x8_UB_UB(row0, row1, row2, row3,
835                             row4, row5, row6, row7,
836                             row8, row9, row10, row11,
837                             row12, row13, row14, row15,
838                             p3_org, p2_org, p1_org, p0_org,
839                             q0_org, q1_org, q2_org, q3_org);
840     }
841
842     p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
843     p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
844     q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
845
846     alpha = (v16u8) __msa_fill_b(alpha_in);
847     beta = (v16u8) __msa_fill_b(beta_in);
848
849     is_less_than_alpha = (p0_asub_q0 < alpha);
850     is_less_than_beta = (p1_asub_p0 < beta);
851     is_less_than = is_less_than_beta & is_less_than_alpha;
852     is_less_than_beta = (q1_asub_q0 < beta);
853     is_less_than = is_less_than_beta & is_less_than;
854
855     if (!__msa_test_bz_v(is_less_than)) {
856         v8i16 p0_r = { 0 };
857         v8i16 q0_r = { 0 };
858         v8i16 p0_l = { 0 };
859         v8i16 q0_l = { 0 };
860         v16i8 zero = { 0 };
861         v16u8 tmp_flag, p0, q0, p2_asub_p0, q2_asub_q0;
862         v16u8 negate_is_less_than_beta;
863         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
864         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
865
866         UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
867         UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
868         UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
869         UNPCK_UB_SH(q1_org, q1_org_r, q1_org_l);
870
871         tmp_flag = alpha >> 2;
872         tmp_flag = tmp_flag + 2;
873         tmp_flag = (p0_asub_q0 < tmp_flag);
874
875         p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
876         is_less_than_beta = (p2_asub_p0 < beta);
877         is_less_than_beta = tmp_flag & is_less_than_beta;
878         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
879         is_less_than_beta = is_less_than_beta & is_less_than;
880         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
881
882         if (!__msa_test_bz_v(is_less_than_beta)) {
883             v16u8 p2, p1;
884             v8i16 p3_org_r, p3_org_l;
885             v8i16 p2_l = { 0 };
886             v8i16 p2_r = { 0 };
887             v8i16 p1_l = { 0 };
888             v8i16 p1_r = { 0 };
889
890             ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
891             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
892                                      p2_r, q1_org_r, p0_r, p1_r, p2_r);
893
894             ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
895             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
896                                          p2_l, q1_org_l, p0_l, p1_l, p2_l);
897
898             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
899             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
900             p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
901             p2_org = __msa_bmnz_v(p2_org, p2, is_less_than_beta);
902         }
903
904         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
905         AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
906
907         p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
908         p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
909
910         q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
911         is_less_than_beta = (q2_asub_q0 < beta);
912
913         is_less_than_beta = is_less_than_beta & tmp_flag;
914         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
915
916         is_less_than_beta = is_less_than_beta & is_less_than;
917         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
918
919         if (!__msa_test_bz_v(is_less_than_beta)) {
920             v16u8 q1, q2;
921             v8i16 q3_org_r, q3_org_l;
922             v8i16 q1_l = { 0 };
923             v8i16 q1_r = { 0 };
924             v8i16 q2_l = { 0 };
925             v8i16 q2_r = { 0 };
926
927             ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
928             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
929                                      q2_r, p1_org_r, q0_r, q1_r, q2_r);
930
931             ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
932             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
933                                      q2_l, p1_org_l, q0_l, q1_l, q2_l);
934
935             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
936             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
937             q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
938             q2_org = __msa_bmnz_v(q2_org, q2, is_less_than_beta);
939         }
940
941         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
942         AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
943
944         q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
945         q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
946
947     {
948         v8i16 tp0, tp1, tp2, tp3, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
949
950         ILVRL_B2_SH(p1_org, p2_org, tp0, tp2);
951         ILVRL_B2_SH(q0_org, p0_org, tp1, tp3);
952         ILVRL_B2_SH(q2_org, q1_org, tmp2, tmp5);
953
954         ILVRL_H2_SH(tp1, tp0, tmp3, tmp4);
955         ILVRL_H2_SH(tp3, tp2, tmp6, tmp7);
956
957         src = data - 3;
958         ST4x4_UB(tmp3, tmp3, 0, 1, 2, 3, src, img_width);
959         ST2x4_UB(tmp2, 0, src + 4, img_width);
960         src += 4 * img_width;
961         ST4x4_UB(tmp4, tmp4, 0, 1, 2, 3, src, img_width);
962         ST2x4_UB(tmp2, 4, src + 4, img_width);
963         src += 4 * img_width;
964
965         ST4x4_UB(tmp6, tmp6, 0, 1, 2, 3, src, img_width);
966         ST2x4_UB(tmp5, 0, src + 4, img_width);
967         src += 4 * img_width;
968         ST4x4_UB(tmp7, tmp7, 0, 1, 2, 3, src, img_width);
969         ST2x4_UB(tmp5, 4, src + 4, img_width);
970     }
971     }
972 }
973
974 static void avc_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src, int32_t stride,
975                                                    int32_t alpha_in,
976                                                    int32_t beta_in)
977 {
978     uint64_t load0, load1;
979     uint32_t out0, out2;
980     uint16_t out1, out3;
981     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
982     v8u16 dst0_r, dst1_r, dst4_r, dst5_r;
983     v8u16 dst2_x_r, dst2_y_r, dst3_x_r, dst3_y_r;
984     v16u8 dst0, dst1, dst4, dst5, dst2_x, dst2_y, dst3_x, dst3_y;
985     v8i16 tmp0, tmp1, tmp2, tmp3;
986     v16u8 alpha, beta;
987     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, p2_asub_p0, q2_asub_q0;
988     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;
989     v16u8 is_less_than_beta1, is_less_than_beta2;
990     v16i8 src0 = { 0 };
991     v16i8 src1 = { 0 };
992     v16i8 src2 = { 0 };
993     v16i8 src3 = { 0 };
994     v16i8 src4 = { 0 };
995     v16i8 src5 = { 0 };
996     v16i8 src6 = { 0 };
997     v16i8 src7 = { 0 };
998     v16i8 zeros = { 0 };
999
1000     load0 = LD(src - 4);
1001     load1 = LD(src + stride - 4);
1002     src0 = (v16i8) __msa_insert_d((v2i64) src0, 0, load0);
1003     src1 = (v16i8) __msa_insert_d((v2i64) src1, 0, load1);
1004
1005     load0 = LD(src + (2 * stride) - 4);
1006     load1 = LD(src + (3 * stride) - 4);
1007     src2 = (v16i8) __msa_insert_d((v2i64) src2, 0, load0);
1008     src3 = (v16i8) __msa_insert_d((v2i64) src3, 0, load1);
1009
1010     load0 = LD(src + (4 * stride) - 4);
1011     load1 = LD(src + (5 * stride) - 4);
1012     src4 = (v16i8) __msa_insert_d((v2i64) src4, 0, load0);
1013     src5 = (v16i8) __msa_insert_d((v2i64) src5, 0, load1);
1014
1015     load0 = LD(src + (6 * stride) - 4);
1016     load1 = LD(src + (7 * stride) - 4);
1017     src6 = (v16i8) __msa_insert_d((v2i64) src6, 0, load0);
1018     src7 = (v16i8) __msa_insert_d((v2i64) src7, 0, load1);
1019
1020     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
1021                src0, src1, src2, src3);
1022
1023     ILVR_H2_SH(src1, src0, src3, src2, tmp0, tmp2);
1024     ILVL_H2_SH(src1, src0, src3, src2, tmp1, tmp3);
1025
1026     ILVR_W2_SB(tmp2, tmp0, tmp3, tmp1, src6, src3);
1027     ILVL_W2_SB(tmp2, tmp0, tmp3, tmp1, src1, src5);
1028     SLDI_B4_0_SB(src6, src1, src3, src5, src0, src2, src4, src7, 8);
1029
1030     p0_asub_q0 = __msa_asub_u_b((v16u8) src2, (v16u8) src3);
1031     p1_asub_p0 = __msa_asub_u_b((v16u8) src1, (v16u8) src2);
1032     q1_asub_q0 = __msa_asub_u_b((v16u8) src4, (v16u8) src3);
1033
1034     alpha = (v16u8) __msa_fill_b(alpha_in);
1035     beta = (v16u8) __msa_fill_b(beta_in);
1036
1037     is_less_than_alpha = (p0_asub_q0 < alpha);
1038     is_less_than_beta = (p1_asub_p0 < beta);
1039     is_less_than = is_less_than_alpha & is_less_than_beta;
1040     is_less_than_beta = (q1_asub_q0 < beta);
1041     is_less_than = is_less_than & is_less_than_beta;
1042
1043     alpha >>= 2;
1044     alpha += 2;
1045
1046     is_less_than_alpha = (p0_asub_q0 < alpha);
1047
1048     p2_asub_p0 = __msa_asub_u_b((v16u8) src0, (v16u8) src2);
1049     is_less_than_beta1 = (p2_asub_p0 < beta);
1050     q2_asub_q0 = __msa_asub_u_b((v16u8) src5, (v16u8) src3);
1051     is_less_than_beta2 = (q2_asub_q0 < beta);
1052
1053     ILVR_B4_UH(zeros, src0, zeros, src1, zeros, src2, zeros, src3,
1054                src0_r, src1_r, src2_r, src3_r);
1055     ILVR_B4_UH(zeros, src4, zeros, src5, zeros, src6, zeros, src7,
1056                src4_r, src5_r, src6_r, src7_r);
1057
1058     dst2_x_r = src1_r + src2_r + src3_r;
1059     dst2_x_r = src0_r + (2 * (dst2_x_r)) + src4_r;
1060     dst2_x_r = (v8u16) __msa_srari_h((v8i16) dst2_x_r, 3);
1061     dst1_r = src0_r + src1_r + src2_r + src3_r;
1062     dst1_r = (v8u16) __msa_srari_h((v8i16) dst1_r, 2);
1063
1064     dst0_r = (2 * src6_r) + (3 * src0_r);
1065     dst0_r += src1_r + src2_r + src3_r;
1066     dst0_r = (v8u16) __msa_srari_h((v8i16) dst0_r, 3);
1067     dst2_y_r = (2 * src1_r) + src2_r + src4_r;
1068     dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);
1069
1070     PCKEV_B2_UB(dst2_x_r, dst2_x_r, dst2_y_r, dst2_y_r, dst2_x, dst2_y);
1071     dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_beta1);
1072
1073     dst3_x_r = src2_r + src3_r + src4_r;
1074     dst3_x_r = src1_r + (2 * dst3_x_r) + src5_r;
1075     dst3_x_r = (v8u16) __msa_srari_h((v8i16) dst3_x_r, 3);
1076     dst4_r = src2_r + src3_r + src4_r + src5_r;
1077     dst4_r = (v8u16) __msa_srari_h((v8i16) dst4_r, 2);
1078
1079     dst5_r = (2 * src7_r) + (3 * src5_r);
1080     dst5_r += src4_r + src3_r + src2_r;
1081     dst5_r = (v8u16) __msa_srari_h((v8i16) dst5_r, 3);
1082     dst3_y_r = (2 * src4_r) + src3_r + src1_r;
1083     dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);
1084
1085     PCKEV_B2_UB(dst3_x_r, dst3_x_r, dst3_y_r, dst3_y_r, dst3_x, dst3_y);
1086     dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_beta2);
1087
1088     dst2_y_r = (2 * src1_r) + src2_r + src4_r;
1089     dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);
1090     dst3_y_r = (2 * src4_r) + src3_r + src1_r;
1091     dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);
1092
1093     PCKEV_B2_UB(dst2_y_r, dst2_y_r, dst3_y_r, dst3_y_r, dst2_y, dst3_y);
1094
1095     dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_alpha);
1096     dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_alpha);
1097     dst2_x = __msa_bmnz_v((v16u8) src2, dst2_x, is_less_than);
1098     dst3_x = __msa_bmnz_v((v16u8) src3, dst3_x, is_less_than);
1099
1100     is_less_than = is_less_than_alpha & is_less_than;
1101     dst1 = (v16u8) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst1_r);
1102     is_less_than_beta1 = is_less_than_beta1 & is_less_than;
1103     dst1 = __msa_bmnz_v((v16u8) src1, dst1, is_less_than_beta1);
1104
1105     dst0 = (v16u8) __msa_pckev_b((v16i8) dst0_r, (v16i8) dst0_r);
1106     dst0 = __msa_bmnz_v((v16u8) src0, dst0, is_less_than_beta1);
1107     dst4 = (v16u8) __msa_pckev_b((v16i8) dst4_r, (v16i8) dst4_r);
1108     is_less_than_beta2 = is_less_than_beta2 & is_less_than;
1109     dst4 = __msa_bmnz_v((v16u8) src4, dst4, is_less_than_beta2);
1110     dst5 = (v16u8) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst5_r);
1111     dst5 = __msa_bmnz_v((v16u8) src5, dst5, is_less_than_beta2);
1112
1113     ILVR_B2_UB(dst1, dst0, dst3_x, dst2_x, dst0, dst1);
1114     dst2_x = (v16u8) __msa_ilvr_b((v16i8) dst5, (v16i8) dst4);
1115     ILVRL_H2_SH(dst1, dst0, tmp0, tmp1);
1116     ILVRL_H2_SH(zeros, dst2_x, tmp2, tmp3);
1117
1118     ILVR_W2_UB(tmp2, tmp0, tmp3, tmp1, dst0, dst4);
1119     SLDI_B2_0_UB(dst0, dst4, dst1, dst5, 8);
1120     dst2_x = (v16u8) __msa_ilvl_w((v4i32) tmp2, (v4i32) tmp0);
1121     dst2_y = (v16u8) __msa_ilvl_w((v4i32) tmp3, (v4i32) tmp1);
1122     SLDI_B2_0_UB(dst2_x, dst2_y, dst3_x, dst3_y, 8);
1123
1124     out0 = __msa_copy_u_w((v4i32) dst0, 0);
1125     out1 = __msa_copy_u_h((v8i16) dst0, 2);
1126     out2 = __msa_copy_u_w((v4i32) dst1, 0);
1127     out3 = __msa_copy_u_h((v8i16) dst1, 2);
1128
1129     SW(out0, (src - 3));
1130     SH(out1, (src + 1));
1131     src += stride;
1132     SW(out2, (src - 3));
1133     SH(out3, (src + 1));
1134     src += stride;
1135
1136     out0 = __msa_copy_u_w((v4i32) dst2_x, 0);
1137     out1 = __msa_copy_u_h((v8i16) dst2_x, 2);
1138     out2 = __msa_copy_u_w((v4i32) dst3_x, 0);
1139     out3 = __msa_copy_u_h((v8i16) dst3_x, 2);
1140
1141     SW(out0, (src - 3));
1142     SH(out1, (src + 1));
1143     src += stride;
1144     SW(out2, (src - 3));
1145     SH(out3, (src + 1));
1146     src += stride;
1147
1148     out0 = __msa_copy_u_w((v4i32) dst4, 0);
1149     out1 = __msa_copy_u_h((v8i16) dst4, 2);
1150     out2 = __msa_copy_u_w((v4i32) dst5, 0);
1151     out3 = __msa_copy_u_h((v8i16) dst5, 2);
1152
1153     SW(out0, (src - 3));
1154     SH(out1, (src + 1));
1155     src += stride;
1156     SW(out2, (src - 3));
1157     SH(out3, (src + 1));
1158     src += stride;
1159
1160     out0 = __msa_copy_u_w((v4i32) dst2_y, 0);
1161     out1 = __msa_copy_u_h((v8i16) dst2_y, 2);
1162     out2 = __msa_copy_u_w((v4i32) dst3_y, 0);
1163     out3 = __msa_copy_u_h((v8i16) dst3_y, 2);
1164
1165     SW(out0, (src - 3));
1166     SH(out1, (src + 1));
1167     src += stride;
1168     SW(out2, (src - 3));
1169     SH(out3, (src + 1));
1170 }
1171
1172 static void avc_loopfilter_cb_or_cr_intra_edge_hor_msa(uint8_t *data_cb_or_cr,
1173                                                        uint8_t alpha_in,
1174                                                        uint8_t beta_in,
1175                                                        uint32_t img_width)
1176 {
1177     v16u8 alpha, beta;
1178     v16u8 is_less_than;
1179     v8i16 p0_or_q0, q0_or_p0;
1180     v16u8 p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org;
1181     v16i8 zero = { 0 };
1182     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1183     v16u8 is_less_than_alpha, is_less_than_beta;
1184     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1185
1186     alpha = (v16u8) __msa_fill_b(alpha_in);
1187     beta = (v16u8) __msa_fill_b(beta_in);
1188
1189     LD_UB4(data_cb_or_cr - (img_width << 1), img_width,
1190            p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org);
1191
1192     p0_asub_q0 = __msa_asub_u_b(p0_or_q0_org, q0_or_p0_org);
1193     p1_asub_p0 = __msa_asub_u_b(p1_or_q1_org, p0_or_q0_org);
1194     q1_asub_q0 = __msa_asub_u_b(q1_or_p1_org, q0_or_p0_org);
1195
1196     is_less_than_alpha = (p0_asub_q0 < alpha);
1197     is_less_than_beta = (p1_asub_p0 < beta);
1198     is_less_than = is_less_than_beta & is_less_than_alpha;
1199     is_less_than_beta = (q1_asub_q0 < beta);
1200     is_less_than = is_less_than_beta & is_less_than;
1201
1202     is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
1203
1204     if (!__msa_test_bz_v(is_less_than)) {
1205         ILVR_B4_SH(zero, p1_or_q1_org, zero, p0_or_q0_org, zero, q0_or_p0_org,
1206                    zero, q1_or_p1_org, p1_org_r, p0_org_r, q0_org_r, q1_org_r);
1207         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_or_q0);
1208         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_or_p0);
1209         PCKEV_B2_SH(zero, p0_or_q0, zero, q0_or_p0, p0_or_q0, q0_or_p0);
1210
1211         p0_or_q0_org =
1212             __msa_bmnz_v(p0_or_q0_org, (v16u8) p0_or_q0, is_less_than);
1213         q0_or_p0_org =
1214             __msa_bmnz_v(q0_or_p0_org, (v16u8) q0_or_p0, is_less_than);
1215
1216         ST_UB(q0_or_p0_org, data_cb_or_cr);
1217         ST_UB(p0_or_q0_org, data_cb_or_cr - img_width);
1218     }
1219 }
1220
1221 static void avc_loopfilter_cb_or_cr_intra_edge_ver_msa(uint8_t *data_cb_or_cr,
1222                                                        uint8_t alpha_in,
1223                                                        uint8_t beta_in,
1224                                                        uint32_t img_width)
1225 {
1226     v8i16 tmp1;
1227     v16u8 alpha, beta, is_less_than;
1228     v8i16 p0_or_q0, q0_or_p0;
1229     v16u8 p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org;
1230     v16i8 zero = { 0 };
1231     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1232     v16u8 is_less_than_alpha, is_less_than_beta;
1233     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1234
1235     {
1236         v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
1237
1238         LD_UB8((data_cb_or_cr - 2), img_width,
1239                row0, row1, row2, row3, row4, row5, row6, row7);
1240
1241         TRANSPOSE8x4_UB_UB(row0, row1, row2, row3, row4, row5, row6, row7,
1242                            p1_or_q1_org, p0_or_q0_org,
1243                            q0_or_p0_org, q1_or_p1_org);
1244     }
1245
1246     alpha = (v16u8) __msa_fill_b(alpha_in);
1247     beta = (v16u8) __msa_fill_b(beta_in);
1248
1249     p0_asub_q0 = __msa_asub_u_b(p0_or_q0_org, q0_or_p0_org);
1250     p1_asub_p0 = __msa_asub_u_b(p1_or_q1_org, p0_or_q0_org);
1251     q1_asub_q0 = __msa_asub_u_b(q1_or_p1_org, q0_or_p0_org);
1252
1253     is_less_than_alpha = (p0_asub_q0 < alpha);
1254     is_less_than_beta = (p1_asub_p0 < beta);
1255     is_less_than = is_less_than_beta & is_less_than_alpha;
1256     is_less_than_beta = (q1_asub_q0 < beta);
1257     is_less_than = is_less_than_beta & is_less_than;
1258     is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
1259
1260     if (!__msa_test_bz_v(is_less_than)) {
1261         ILVR_B4_SH(zero, p1_or_q1_org, zero, p0_or_q0_org, zero, q0_or_p0_org,
1262                    zero, q1_or_p1_org, p1_org_r, p0_org_r, q0_org_r, q1_org_r);
1263
1264         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_or_q0);
1265         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_or_p0);
1266
1267         /* convert 16 bit output into 8 bit output */
1268         PCKEV_B2_SH(zero, p0_or_q0, zero, q0_or_p0, p0_or_q0, q0_or_p0);
1269
1270         p0_or_q0_org =
1271             __msa_bmnz_v(p0_or_q0_org, (v16u8) p0_or_q0, is_less_than);
1272         q0_or_p0_org =
1273             __msa_bmnz_v(q0_or_p0_org, (v16u8) q0_or_p0, is_less_than);
1274         tmp1 = (v8i16) __msa_ilvr_b((v16i8) q0_or_p0_org, (v16i8) p0_or_q0_org);
1275
1276         data_cb_or_cr -= 1;
1277         ST2x4_UB(tmp1, 0, data_cb_or_cr, img_width);
1278         data_cb_or_cr += 4 * img_width;
1279         ST2x4_UB(tmp1, 4, data_cb_or_cr, img_width);
1280     }
1281 }
1282
1283 static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
1284                                                    uint8_t bs0, uint8_t bs1,
1285                                                    uint8_t bs2, uint8_t bs3,
1286                                                    uint8_t tc0, uint8_t tc1,
1287                                                    uint8_t tc2, uint8_t tc3,
1288                                                    uint8_t alpha_in,
1289                                                    uint8_t beta_in,
1290                                                    uint32_t img_width)
1291 {
1292     v16u8 tmp_vec, bs = { 0 };
1293
1294     tmp_vec = (v16u8) __msa_fill_b(bs0);
1295     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
1296     tmp_vec = (v16u8) __msa_fill_b(bs1);
1297     bs = (v16u8) __msa_insve_w((v4i32) bs, 1, (v4i32) tmp_vec);
1298     tmp_vec = (v16u8) __msa_fill_b(bs2);
1299     bs = (v16u8) __msa_insve_w((v4i32) bs, 2, (v4i32) tmp_vec);
1300     tmp_vec = (v16u8) __msa_fill_b(bs3);
1301     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
1302
1303     if (!__msa_test_bz_v(bs)) {
1304         uint8_t *src = data - 4;
1305         v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
1306         v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, alpha, beta;
1307         v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
1308         v16u8 is_bs_greater_than0;
1309         v16u8 tc = { 0 };
1310         v16i8 zero = { 0 };
1311
1312         tmp_vec = (v16u8) __msa_fill_b(tc0);
1313         tc = (v16u8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
1314         tmp_vec = (v16u8) __msa_fill_b(tc1);
1315         tc = (v16u8) __msa_insve_w((v4i32) tc, 1, (v4i32) tmp_vec);
1316         tmp_vec = (v16u8) __msa_fill_b(tc2);
1317         tc = (v16u8) __msa_insve_w((v4i32) tc, 2, (v4i32) tmp_vec);
1318         tmp_vec = (v16u8) __msa_fill_b(tc3);
1319         tc = (v16u8) __msa_insve_w((v4i32) tc, 3, (v4i32) tmp_vec);
1320
1321         is_bs_greater_than0 = (zero < bs);
1322
1323         {
1324             v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
1325             v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
1326
1327             LD_UB8(src, img_width,
1328                    row0, row1, row2, row3, row4, row5, row6, row7);
1329             src += (8 * img_width);
1330             LD_UB8(src, img_width,
1331                    row8, row9, row10, row11, row12, row13, row14, row15);
1332
1333             TRANSPOSE16x8_UB_UB(row0, row1, row2, row3, row4, row5, row6, row7,
1334                                 row8, row9, row10, row11,
1335                                 row12, row13, row14, row15,
1336                                 p3_org, p2_org, p1_org, p0_org,
1337                                 q0_org, q1_org, q2_org, q3_org);
1338         }
1339
1340         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1341         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1342         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1343
1344         alpha = (v16u8) __msa_fill_b(alpha_in);
1345         beta = (v16u8) __msa_fill_b(beta_in);
1346
1347         is_less_than_alpha = (p0_asub_q0 < alpha);
1348         is_less_than_beta = (p1_asub_p0 < beta);
1349         is_less_than = is_less_than_beta & is_less_than_alpha;
1350         is_less_than_beta = (q1_asub_q0 < beta);
1351         is_less_than = is_less_than_beta & is_less_than;
1352         is_less_than = is_less_than & is_bs_greater_than0;
1353
1354         if (!__msa_test_bz_v(is_less_than)) {
1355             v16i8 negate_tc, sign_negate_tc;
1356             v16u8 p0, q0, p2_asub_p0, q2_asub_q0;
1357             v8i16 tc_r, tc_l, negate_tc_r, i16_negatetc_l;
1358             v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1359             v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
1360             v8i16 p0_r, q0_r, p0_l, q0_l;
1361
1362             negate_tc = zero - (v16i8) tc;
1363             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
1364
1365             ILVRL_B2_SH(sign_negate_tc, negate_tc, negate_tc_r, i16_negatetc_l);
1366
1367             UNPCK_UB_SH(tc, tc_r, tc_l);
1368             UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
1369             UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
1370             UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
1371
1372             p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
1373             is_less_than_beta = (p2_asub_p0 < beta);
1374             is_less_than_beta = is_less_than_beta & is_less_than;
1375
1376             if (!__msa_test_bz_v(is_less_than_beta)) {
1377                 v16u8 p1;
1378                 v8i16 p1_r = { 0 };
1379                 v8i16 p1_l = { 0 };
1380                 v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
1381                 v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
1382
1383                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
1384                                  negate_tc_r, tc_r, p1_r);
1385                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
1386                                  i16_negatetc_l, tc_l, p1_l);
1387
1388                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
1389                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
1390
1391                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1392                 tc = tc + is_less_than_beta;
1393             }
1394
1395             q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
1396             is_less_than_beta = (q2_asub_q0 < beta);
1397             is_less_than_beta = is_less_than_beta & is_less_than;
1398
1399             q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
1400             q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
1401
1402             if (!__msa_test_bz_v(is_less_than_beta)) {
1403                 v16u8 q1;
1404                 v8i16 q1_r = { 0 };
1405                 v8i16 q1_l = { 0 };
1406                 v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
1407                 v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
1408
1409                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
1410                                  negate_tc_r, tc_r, q1_r);
1411                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
1412                                  i16_negatetc_l, tc_l, q1_l);
1413
1414                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
1415                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
1416
1417                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1418                 tc = tc + is_less_than_beta;
1419             }
1420
1421             {
1422                 v8i16 threshold_r, negate_thresh_r;
1423                 v8i16 threshold_l, negate_thresh_l;
1424                 v16i8 negate_thresh, sign_negate_thresh;
1425
1426                 negate_thresh = zero - (v16i8) tc;
1427                 sign_negate_thresh = __msa_clti_s_b(negate_thresh, 0);
1428
1429                 ILVR_B2_SH(zero, tc, sign_negate_thresh, negate_thresh,
1430                            threshold_r, negate_thresh_r);
1431
1432                 AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r,
1433                              negate_thresh_r, threshold_r, p0_r, q0_r);
1434
1435                 threshold_l = (v8i16) __msa_ilvl_b(zero, (v16i8) tc);
1436                 negate_thresh_l = (v8i16) __msa_ilvl_b(sign_negate_thresh,
1437                                                        negate_thresh);
1438
1439                 AVC_LPF_P0Q0(q0_org_l, p0_org_l, p1_org_l, q1_org_l,
1440                              negate_thresh_l, threshold_l, p0_l, q0_l);
1441             }
1442
1443             PCKEV_B2_UB(p0_l, p0_r, q0_l, q0_r, p0, q0);
1444
1445             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
1446             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
1447
1448         {
1449             v16i8 tp0, tp1, tp2, tp3;
1450             v8i16 tmp2, tmp5;
1451             v4i32 tmp3, tmp4, tmp6, tmp7;
1452             uint32_t out0, out2;
1453             uint16_t out1, out3;
1454
1455             src = data - 3;
1456
1457             ILVRL_B2_SB(p1_org, p2_org, tp0, tp2);
1458             ILVRL_B2_SB(q0_org, p0_org, tp1, tp3);
1459             ILVRL_B2_SH(q2_org, q1_org, tmp2, tmp5);
1460
1461             ILVRL_H2_SW(tp1, tp0, tmp3, tmp4);
1462             ILVRL_H2_SW(tp3, tp2, tmp6, tmp7);
1463
1464             out0 = __msa_copy_u_w(tmp3, 0);
1465             out1 = __msa_copy_u_h(tmp2, 0);
1466             out2 = __msa_copy_u_w(tmp3, 1);
1467             out3 = __msa_copy_u_h(tmp2, 1);
1468
1469             SW(out0, src);
1470             SH(out1, (src + 4));
1471             src += img_width;
1472             SW(out2, src);
1473             SH(out3, (src + 4));
1474
1475             out0 = __msa_copy_u_w(tmp3, 2);
1476             out1 = __msa_copy_u_h(tmp2, 2);
1477             out2 = __msa_copy_u_w(tmp3, 3);
1478             out3 = __msa_copy_u_h(tmp2, 3);
1479
1480             src += img_width;
1481             SW(out0, src);
1482             SH(out1, (src + 4));
1483             src += img_width;
1484             SW(out2, src);
1485             SH(out3, (src + 4));
1486
1487             out0 = __msa_copy_u_w(tmp4, 0);
1488             out1 = __msa_copy_u_h(tmp2, 4);
1489             out2 = __msa_copy_u_w(tmp4, 1);
1490             out3 = __msa_copy_u_h(tmp2, 5);
1491
1492             src += img_width;
1493             SW(out0, src);
1494             SH(out1, (src + 4));
1495             src += img_width;
1496             SW(out2, src);
1497             SH(out3, (src + 4));
1498
1499             out0 = __msa_copy_u_w(tmp4, 2);
1500             out1 = __msa_copy_u_h(tmp2, 6);
1501             out2 = __msa_copy_u_w(tmp4, 3);
1502             out3 = __msa_copy_u_h(tmp2, 7);
1503
1504             src += img_width;
1505             SW(out0, src);
1506             SH(out1, (src + 4));
1507             src += img_width;
1508             SW(out2, src);
1509             SH(out3, (src + 4));
1510
1511             out0 = __msa_copy_u_w(tmp6, 0);
1512             out1 = __msa_copy_u_h(tmp5, 0);
1513             out2 = __msa_copy_u_w(tmp6, 1);
1514             out3 = __msa_copy_u_h(tmp5, 1);
1515
1516             src += img_width;
1517             SW(out0, src);
1518             SH(out1, (src + 4));
1519             src += img_width;
1520             SW(out2, src);
1521             SH(out3, (src + 4));
1522
1523             out0 = __msa_copy_u_w(tmp6, 2);
1524             out1 = __msa_copy_u_h(tmp5, 2);
1525             out2 = __msa_copy_u_w(tmp6, 3);
1526             out3 = __msa_copy_u_h(tmp5, 3);
1527
1528             src += img_width;
1529             SW(out0, src);
1530             SH(out1, (src + 4));
1531             src += img_width;
1532             SW(out2, src);
1533             SH(out3, (src + 4));
1534
1535             out0 = __msa_copy_u_w(tmp7, 0);
1536             out1 = __msa_copy_u_h(tmp5, 4);
1537             out2 = __msa_copy_u_w(tmp7, 1);
1538             out3 = __msa_copy_u_h(tmp5, 5);
1539
1540             src += img_width;
1541             SW(out0, src);
1542             SH(out1, (src + 4));
1543             src += img_width;
1544             SW(out2, src);
1545             SH(out3, (src + 4));
1546
1547             out0 = __msa_copy_u_w(tmp7, 2);
1548             out1 = __msa_copy_u_h(tmp5, 6);
1549             out2 = __msa_copy_u_w(tmp7, 3);
1550             out3 = __msa_copy_u_h(tmp5, 7);
1551
1552             src += img_width;
1553             SW(out0, src);
1554             SH(out1, (src + 4));
1555             src += img_width;
1556             SW(out2, src);
1557             SH(out3, (src + 4));
1558         }
1559         }
1560     }
1561 }
1562
1563 static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
1564                                                    uint8_t bs0, uint8_t bs1,
1565                                                    uint8_t bs2, uint8_t bs3,
1566                                                    uint8_t tc0, uint8_t tc1,
1567                                                    uint8_t tc2, uint8_t tc3,
1568                                                    uint8_t alpha_in,
1569                                                    uint8_t beta_in,
1570                                                    uint32_t image_width)
1571 {
1572     v16u8 tmp_vec;
1573     v16u8 bs = { 0 };
1574
1575     tmp_vec = (v16u8) __msa_fill_b(bs0);
1576     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
1577     tmp_vec = (v16u8) __msa_fill_b(bs1);
1578     bs = (v16u8) __msa_insve_w((v4i32) bs, 1, (v4i32) tmp_vec);
1579     tmp_vec = (v16u8) __msa_fill_b(bs2);
1580     bs = (v16u8) __msa_insve_w((v4i32) bs, 2, (v4i32) tmp_vec);
1581     tmp_vec = (v16u8) __msa_fill_b(bs3);
1582     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
1583
1584     if (!__msa_test_bz_v(bs)) {
1585         v16u8 alpha, beta, is_less_than, is_less_than_beta;
1586         v16u8 p0, q0, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org;
1587         v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1588         v16u8 is_less_than_alpha, is_bs_greater_than0;
1589         v8i16 p0_r, q0_r, p0_l, q0_l;
1590         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1591         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
1592         v16i8 zero = { 0 };
1593         v16i8 tc = { 0 };
1594
1595         tmp_vec = (v16u8) __msa_fill_b(tc0);
1596         tc = (v16i8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
1597         tmp_vec = (v16u8) __msa_fill_b(tc1);
1598         tc = (v16i8) __msa_insve_w((v4i32) tc, 1, (v4i32) tmp_vec);
1599         tmp_vec = (v16u8) __msa_fill_b(tc2);
1600         tc = (v16i8) __msa_insve_w((v4i32) tc, 2, (v4i32) tmp_vec);
1601         tmp_vec = (v16u8) __msa_fill_b(tc3);
1602         tc = (v16i8) __msa_insve_w((v4i32) tc, 3, (v4i32) tmp_vec);
1603
1604         alpha = (v16u8) __msa_fill_b(alpha_in);
1605         beta = (v16u8) __msa_fill_b(beta_in);
1606
1607         LD_UB5(data - (3 * image_width), image_width,
1608                p2_org, p1_org, p0_org, q0_org, q1_org);
1609
1610         is_bs_greater_than0 = ((v16u8) zero < bs);
1611         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1612         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1613         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1614
1615         is_less_than_alpha = (p0_asub_q0 < alpha);
1616         is_less_than_beta = (p1_asub_p0 < beta);
1617         is_less_than = is_less_than_beta & is_less_than_alpha;
1618         is_less_than_beta = (q1_asub_q0 < beta);
1619         is_less_than = is_less_than_beta & is_less_than;
1620         is_less_than = is_less_than & is_bs_greater_than0;
1621
1622         if (!__msa_test_bz_v(is_less_than)) {
1623             v16i8 sign_negate_tc, negate_tc;
1624             v8i16 negate_tc_r, i16_negatetc_l, tc_l, tc_r;
1625             v16u8 p2_asub_p0, q2_asub_q0;
1626
1627             q2_org = LD_UB(data + (2 * image_width));
1628             negate_tc = zero - tc;
1629             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
1630
1631             ILVRL_B2_SH(sign_negate_tc, negate_tc, negate_tc_r, i16_negatetc_l);
1632
1633             UNPCK_UB_SH(tc, tc_r, tc_l);
1634             UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
1635             UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
1636             UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
1637
1638             p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
1639             is_less_than_beta = (p2_asub_p0 < beta);
1640             is_less_than_beta = is_less_than_beta & is_less_than;
1641
1642             if (!__msa_test_bz_v(is_less_than_beta)) {
1643                 v16u8 p1;
1644                 v8i16 p1_r = { 0 };
1645                 v8i16 p1_l = { 0 };
1646                 v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
1647                 v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
1648
1649                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
1650                                  negate_tc_r, tc_r, p1_r);
1651                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
1652                                  i16_negatetc_l, tc_l, p1_l);
1653
1654                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
1655                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
1656                 ST_UB(p1_org, data - (2 * image_width));
1657
1658                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1659                 tc = tc + (v16i8) is_less_than_beta;
1660             }
1661
1662             q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
1663             is_less_than_beta = (q2_asub_q0 < beta);
1664             is_less_than_beta = is_less_than_beta & is_less_than;
1665
1666             q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
1667             q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
1668
1669             if (!__msa_test_bz_v(is_less_than_beta)) {
1670                 v16u8 q1;
1671                 v8i16 q1_r = { 0 };
1672                 v8i16 q1_l = { 0 };
1673                 v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
1674                 v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
1675
1676                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
1677                                  negate_tc_r, tc_r, q1_r);
1678                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
1679                                  i16_negatetc_l, tc_l, q1_l);
1680
1681                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
1682                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
1683                 ST_UB(q1_org, data + image_width);
1684
1685                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1686                 tc = tc + (v16i8) is_less_than_beta;
1687             }
1688             {
1689                 v16i8 negate_thresh, sign_negate_thresh;
1690                 v8i16 threshold_r, threshold_l;
1691                 v8i16 negate_thresh_l, negate_thresh_r;
1692
1693                 negate_thresh = zero - tc;
1694                 sign_negate_thresh = __msa_clti_s_b(negate_thresh, 0);
1695
1696                 ILVR_B2_SH(zero, tc, sign_negate_thresh, negate_thresh,
1697                            threshold_r, negate_thresh_r);
1698                 AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r,
1699                              negate_thresh_r, threshold_r, p0_r, q0_r);
1700
1701                 threshold_l = (v8i16) __msa_ilvl_b(zero, tc);
1702                 negate_thresh_l = (v8i16) __msa_ilvl_b(sign_negate_thresh,
1703                                                        negate_thresh);
1704                 AVC_LPF_P0Q0(q0_org_l, p0_org_l, p1_org_l, q1_org_l,
1705                              negate_thresh_l, threshold_l, p0_l, q0_l);
1706             }
1707
1708             PCKEV_B2_UB(p0_l, p0_r, q0_l, q0_r, p0, q0);
1709
1710             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
1711             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
1712
1713             ST_UB(p0_org, (data - image_width));
1714             ST_UB(q0_org, data);
1715         }
1716     }
1717 }
1718
1719 static void avc_h_loop_filter_luma_mbaff_msa(uint8_t *in, int32_t stride,
1720                                              int32_t alpha_in, int32_t beta_in,
1721                                              int8_t *tc0)
1722 {
1723     uint8_t *data = in;
1724     uint32_t out0, out1, out2, out3;
1725     uint64_t load;
1726     uint32_t tc_val;
1727     v16u8 alpha, beta;
1728     v16i8 inp0 = { 0 };
1729     v16i8 inp1 = { 0 };
1730     v16i8 inp2 = { 0 };
1731     v16i8 inp3 = { 0 };
1732     v16i8 inp4 = { 0 };
1733     v16i8 inp5 = { 0 };
1734     v16i8 inp6 = { 0 };
1735     v16i8 inp7 = { 0 };
1736     v16i8 src0, src1, src2, src3;
1737     v8i16 src4, src5, src6, src7;
1738     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, p2_asub_p0, q2_asub_q0;
1739     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;
1740     v16u8 is_less_than_beta1, is_less_than_beta2;
1741     v8i16 tc, tc_orig_r, tc_plus1;
1742     v16u8 is_tc_orig1, is_tc_orig2, tc_orig = { 0 };
1743     v8i16 p0_ilvr_q0, p0_add_q0, q0_sub_p0, p1_sub_q1;
1744     v8u16 src2_r, src3_r;
1745     v8i16 p2_r, p1_r, q2_r, q1_r;
1746     v16u8 p2, q2, p0, q0;
1747     v4i32 dst0, dst1;
1748     v16i8 zeros = { 0 };
1749
1750     alpha = (v16u8) __msa_fill_b(alpha_in);
1751     beta = (v16u8) __msa_fill_b(beta_in);
1752
1753     if (tc0[0] < 0) {
1754         data += (2 * stride);
1755     } else {
1756         load = LD(data - 3);
1757         inp0 = (v16i8) __msa_insert_d((v2i64) inp0, 0, load);
1758         load = LD(data - 3 + stride);
1759         inp1 = (v16i8) __msa_insert_d((v2i64) inp1, 0, load);
1760         data += (2 * stride);
1761     }
1762
1763     if (tc0[1] < 0) {
1764         data += (2 * stride);
1765     } else {
1766         load = LD(data - 3);
1767         inp2 = (v16i8) __msa_insert_d((v2i64) inp2, 0, load);
1768         load = LD(data - 3 + stride);
1769         inp3 = (v16i8) __msa_insert_d((v2i64) inp3, 0, load);
1770         data += (2 * stride);
1771     }
1772
1773     if (tc0[2] < 0) {
1774         data += (2 * stride);
1775     } else {
1776         load = LD(data - 3);
1777         inp4 = (v16i8) __msa_insert_d((v2i64) inp4, 0, load);
1778         load = LD(data - 3 + stride);
1779         inp5 = (v16i8) __msa_insert_d((v2i64) inp5, 0, load);
1780         data += (2 * stride);
1781     }
1782
1783     if (tc0[3] < 0) {
1784         data += (2 * stride);
1785     } else {
1786         load = LD(data - 3);
1787         inp6 = (v16i8) __msa_insert_d((v2i64) inp6, 0, load);
1788         load = LD(data - 3 + stride);
1789         inp7 = (v16i8) __msa_insert_d((v2i64) inp7, 0, load);
1790         data += (2 * stride);
1791     }
1792
1793     ILVR_B4_SB(inp1, inp0, inp3, inp2, inp5, inp4, inp7, inp6,
1794                src0, src1, src2, src3);
1795
1796     ILVR_H2_SH(src1, src0, src3, src2, src4, src6);
1797     ILVL_H2_SH(src1, src0, src3, src2, src5, src7);
1798
1799     src0 = (v16i8) __msa_ilvr_w((v4i32) src6, (v4i32) src4);
1800     src1 = __msa_sldi_b(zeros, (v16i8) src0, 8);
1801     src2 = (v16i8) __msa_ilvl_w((v4i32) src6, (v4i32) src4);
1802     src3 = __msa_sldi_b(zeros, (v16i8) src2, 8);
1803     src4 = (v8i16) __msa_ilvr_w((v4i32) src7, (v4i32) src5);
1804     src5 = (v8i16) __msa_sldi_b(zeros, (v16i8) src4, 8);
1805
1806     p0_asub_q0 = __msa_asub_u_b((v16u8) src2, (v16u8) src3);
1807     p1_asub_p0 = __msa_asub_u_b((v16u8) src1, (v16u8) src2);
1808     q1_asub_q0 = __msa_asub_u_b((v16u8) src4, (v16u8) src3);
1809     p2_asub_p0 = __msa_asub_u_b((v16u8) src0, (v16u8) src2);
1810     q2_asub_q0 = __msa_asub_u_b((v16u8) src5, (v16u8) src3);
1811
1812     is_less_than_alpha = (p0_asub_q0 < alpha);
1813     is_less_than_beta = (p1_asub_p0 < beta);
1814     is_less_than = is_less_than_alpha & is_less_than_beta;
1815     is_less_than_beta = (q1_asub_q0 < beta);
1816     is_less_than = is_less_than_beta & is_less_than;
1817
1818     is_less_than_beta1 = (p2_asub_p0 < beta);
1819     is_less_than_beta2 = (q2_asub_q0 < beta);
1820
1821     p0_ilvr_q0 = (v8i16) __msa_ilvr_b((v16i8) src3, (v16i8) src2);
1822     p0_add_q0 = (v8i16) __msa_hadd_u_h((v16u8) p0_ilvr_q0, (v16u8) p0_ilvr_q0);
1823     p0_add_q0 = __msa_srari_h(p0_add_q0, 1);
1824
1825     ILVR_B2_SH(zeros, src0, zeros, src1, p2_r, p1_r);
1826     p2_r += p0_add_q0;
1827     p2_r >>= 1;
1828     p2_r -= p1_r;
1829     ILVR_B2_SH(zeros, src5, zeros, src4, q2_r, q1_r);
1830     q2_r += p0_add_q0;
1831     q2_r >>= 1;
1832     q2_r -= q1_r;
1833
1834     tc_val = LW(tc0);
1835     tc_orig = (v16u8) __msa_insert_w((v4i32) tc_orig, 0, tc_val);
1836     tc_orig = (v16u8) __msa_ilvr_b((v16i8) tc_orig, (v16i8) tc_orig);
1837     is_tc_orig1 = tc_orig;
1838     is_tc_orig2 = tc_orig;
1839     tc_orig_r = (v8i16) __msa_ilvr_b(zeros, (v16i8) tc_orig);
1840     tc = tc_orig_r;
1841
1842     p2_r = CLIP_SH(p2_r, -tc_orig_r, tc_orig_r);
1843     q2_r = CLIP_SH(q2_r, -tc_orig_r, tc_orig_r);
1844
1845     p2_r += p1_r;
1846     q2_r += q1_r;
1847
1848     PCKEV_B2_UB(p2_r, p2_r, q2_r, q2_r, p2, q2);
1849
1850     is_tc_orig1 = (zeros < is_tc_orig1);
1851     is_tc_orig2 = is_tc_orig1;
1852     is_tc_orig1 = is_less_than_beta1 & is_tc_orig1;
1853     is_tc_orig2 = is_less_than_beta2 & is_tc_orig2;
1854     is_tc_orig1 = is_less_than & is_tc_orig1;
1855     is_tc_orig2 = is_less_than & is_tc_orig2;
1856
1857     p2 = __msa_bmnz_v((v16u8) src1, p2, is_tc_orig1);
1858     q2 = __msa_bmnz_v((v16u8) src4, q2, is_tc_orig2);
1859
1860     q0_sub_p0 = __msa_hsub_u_h((v16u8) p0_ilvr_q0, (v16u8) p0_ilvr_q0);
1861     q0_sub_p0 <<= 2;
1862     p1_sub_q1 = p1_r - q1_r;
1863     q0_sub_p0 += p1_sub_q1;
1864     q0_sub_p0 = __msa_srari_h(q0_sub_p0, 3);
1865
1866     tc_plus1 = tc + 1;
1867     is_less_than_beta1 = (v16u8) __msa_ilvr_b((v16i8) is_less_than_beta1,
1868                                               (v16i8) is_less_than_beta1);
1869     tc = (v8i16) __msa_bmnz_v((v16u8) tc, (v16u8) tc_plus1, is_less_than_beta1);
1870     tc_plus1 = tc + 1;
1871     is_less_than_beta2 = (v16u8) __msa_ilvr_b((v16i8) is_less_than_beta2,
1872                                               (v16i8) is_less_than_beta2);
1873     tc = (v8i16) __msa_bmnz_v((v16u8) tc, (v16u8) tc_plus1, is_less_than_beta2);
1874
1875     q0_sub_p0 = CLIP_SH(q0_sub_p0, -tc, tc);
1876
1877     ILVR_B2_UH(zeros, src2, zeros, src3, src2_r, src3_r);
1878     src2_r += q0_sub_p0;
1879     src3_r -= q0_sub_p0;
1880
1881     src2_r = (v8u16) CLIP_SH_0_255(src2_r);
1882     src3_r = (v8u16) CLIP_SH_0_255(src3_r);
1883
1884     PCKEV_B2_UB(src2_r, src2_r, src3_r, src3_r, p0, q0);
1885
1886     p0 = __msa_bmnz_v((v16u8) src2, p0, is_less_than);
1887     q0 = __msa_bmnz_v((v16u8) src3, q0, is_less_than);
1888
1889     ILVR_B2_UB(p0, p2, q2, q0, p2, q2);
1890
1891     ILVRL_H2_SW(q2, p2, dst0, dst1);
1892
1893     data = in;
1894
1895     out0 = __msa_copy_u_w(dst0, 0);
1896     out1 = __msa_copy_u_w(dst0, 1);
1897     out2 = __msa_copy_u_w(dst0, 2);
1898     out3 = __msa_copy_u_w(dst0, 3);
1899
1900     if (tc0[0] < 0) {
1901         data += (2 * stride);
1902     } else {
1903         SW(out0, (data - 2));
1904         data += stride;
1905         SW(out1, (data - 2));
1906         data += stride;
1907     }
1908
1909     if (tc0[1] < 0) {
1910         data += (2 * stride);
1911     } else {
1912         SW(out2, (data - 2));
1913         data += stride;
1914         SW(out3, (data - 2));
1915         data += stride;
1916     }
1917
1918     out0 = __msa_copy_u_w(dst1, 0);
1919     out1 = __msa_copy_u_w(dst1, 1);
1920     out2 = __msa_copy_u_w(dst1, 2);
1921     out3 = __msa_copy_u_w(dst1, 3);
1922
1923     if (tc0[2] < 0) {
1924         data += (2 * stride);
1925     } else {
1926         SW(out0, (data - 2));
1927         data += stride;
1928         SW(out1, (data - 2));
1929         data += stride;
1930     }
1931
1932     if (tc0[3] >= 0) {
1933         SW(out2, (data - 2));
1934         data += stride;
1935         SW(out3, (data - 2));
1936     }
1937 }
1938
1939 static void avc_loopfilter_cb_or_cr_inter_edge_hor_msa(uint8_t *data,
1940                                                        uint8_t bs0, uint8_t bs1,
1941                                                        uint8_t bs2, uint8_t bs3,
1942                                                        uint8_t tc0, uint8_t tc1,
1943                                                        uint8_t tc2, uint8_t tc3,
1944                                                        uint8_t alpha_in,
1945                                                        uint8_t beta_in,
1946                                                        uint32_t img_width)
1947 {
1948     v16u8 alpha, beta;
1949     v8i16 tmp_vec;
1950     v8i16 bs = { 0 };
1951     v8i16 tc = { 0 };
1952     v16u8 p0, q0, p0_asub_q0, p1_asub_p0, q1_asub_q0;
1953     v16u8 is_less_than;
1954     v16u8 is_less_than_beta, is_less_than_alpha, is_bs_greater_than0;
1955     v8i16 p0_r, q0_r;
1956     v16u8 p1_org, p0_org, q0_org, q1_org;
1957     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1958     v16i8 negate_tc, sign_negate_tc;
1959     v8i16 tc_r, negate_tc_r;
1960     v16i8 zero = { 0 };
1961
1962     tmp_vec = (v8i16) __msa_fill_b(bs0);
1963     bs = __msa_insve_h(bs, 0, tmp_vec);
1964     tmp_vec = (v8i16) __msa_fill_b(bs1);
1965     bs = __msa_insve_h(bs, 1, tmp_vec);
1966     tmp_vec = (v8i16) __msa_fill_b(bs2);
1967     bs = __msa_insve_h(bs, 2, tmp_vec);
1968     tmp_vec = (v8i16) __msa_fill_b(bs3);
1969     bs = __msa_insve_h(bs, 3, tmp_vec);
1970
1971     if (!__msa_test_bz_v((v16u8) bs)) {
1972         tmp_vec = (v8i16) __msa_fill_b(tc0);
1973         tc = __msa_insve_h(tc, 0, tmp_vec);
1974         tmp_vec = (v8i16) __msa_fill_b(tc1);
1975         tc = __msa_insve_h(tc, 1, tmp_vec);
1976         tmp_vec = (v8i16) __msa_fill_b(tc2);
1977         tc = __msa_insve_h(tc, 2, tmp_vec);
1978         tmp_vec = (v8i16) __msa_fill_b(tc3);
1979         tc = __msa_insve_h(tc, 3, tmp_vec);
1980
1981         is_bs_greater_than0 = (v16u8) (zero < (v16i8) bs);
1982
1983         alpha = (v16u8) __msa_fill_b(alpha_in);
1984         beta = (v16u8) __msa_fill_b(beta_in);
1985
1986         LD_UB4(data - (img_width << 1), img_width,
1987                p1_org, p0_org, q0_org, q1_org);
1988
1989         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1990         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1991         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1992
1993         is_less_than_alpha = (p0_asub_q0 < alpha);
1994         is_less_than_beta = (p1_asub_p0 < beta);
1995         is_less_than = is_less_than_beta & is_less_than_alpha;
1996         is_less_than_beta = (q1_asub_q0 < beta);
1997         is_less_than = is_less_than_beta & is_less_than;
1998         is_less_than = is_less_than & is_bs_greater_than0;
1999
2000         is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
2001
2002         if (!__msa_test_bz_v(is_less_than)) {
2003             negate_tc = zero - (v16i8) tc;
2004             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
2005
2006             ILVR_B2_SH(zero, tc, sign_negate_tc, negate_tc, tc_r, negate_tc_r);
2007
2008             ILVR_B4_SH(zero, p1_org, zero, p0_org, zero, q0_org, zero, q1_org,
2009                        p1_org_r, p0_org_r, q0_org_r, q1_org_r);
2010
2011             AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r, negate_tc_r,
2012                          tc_r, p0_r, q0_r);
2013
2014             PCKEV_B2_UB(zero, p0_r, zero, q0_r, p0, q0);
2015
2016             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
2017             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
2018
2019             ST_UB(q0_org, data);
2020             ST_UB(p0_org, (data - img_width));
2021         }
2022     }
2023 }
2024
2025 static void avc_loopfilter_cb_or_cr_inter_edge_ver_msa(uint8_t *data,
2026                                                        uint8_t bs0, uint8_t bs1,
2027                                                        uint8_t bs2, uint8_t bs3,
2028                                                        uint8_t tc0, uint8_t tc1,
2029                                                        uint8_t tc2, uint8_t tc3,
2030                                                        uint8_t alpha_in,
2031                                                        uint8_t beta_in,
2032                                                        uint32_t img_width)
2033 {
2034     uint8_t *src;
2035     v16u8 alpha, beta;
2036     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
2037     v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
2038     v16u8 p0, q0;
2039     v8i16 p0_r = { 0 };
2040     v8i16 q0_r = { 0 };
2041     v16u8 p1_org, p0_org, q0_org, q1_org;
2042     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
2043     v16u8 is_bs_greater_than0;
2044     v8i16 tc_r, negate_tc_r;
2045     v16i8 negate_tc, sign_negate_tc;
2046     v16i8 zero = { 0 };
2047     v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
2048     v8i16 tmp1, tmp_vec, bs = { 0 };
2049     v8i16 tc = { 0 };
2050
2051     tmp_vec = (v8i16) __msa_fill_b(bs0);
2052     bs = __msa_insve_h(bs, 0, tmp_vec);
2053     tmp_vec = (v8i16) __msa_fill_b(bs1);
2054     bs = __msa_insve_h(bs, 1, tmp_vec);
2055     tmp_vec = (v8i16) __msa_fill_b(bs2);
2056     bs = __msa_insve_h(bs, 2, tmp_vec);
2057     tmp_vec = (v8i16) __msa_fill_b(bs3);
2058     bs = __msa_insve_h(bs, 3, tmp_vec);
2059
2060     if (!__msa_test_bz_v((v16u8) bs)) {
2061         tmp_vec = (v8i16) __msa_fill_b(tc0);
2062         tc = __msa_insve_h(tc, 0, tmp_vec);
2063         tmp_vec = (v8i16) __msa_fill_b(tc1);
2064         tc = __msa_insve_h(tc, 1, tmp_vec);
2065         tmp_vec = (v8i16) __msa_fill_b(tc2);
2066         tc = __msa_insve_h(tc, 2, tmp_vec);
2067         tmp_vec = (v8i16) __msa_fill_b(tc3);
2068         tc = __msa_insve_h(tc, 3, tmp_vec);
2069
2070         is_bs_greater_than0 = (v16u8) (zero < (v16i8) bs);
2071
2072         LD_UB8((data - 2), img_width,
2073                row0, row1, row2, row3, row4, row5, row6, row7);
2074
2075         TRANSPOSE8x4_UB_UB(row0, row1, row2, row3,
2076                            row4, row5, row6, row7,
2077                            p1_org, p0_org, q0_org, q1_org);
2078
2079         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
2080         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
2081         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
2082
2083         alpha = (v16u8) __msa_fill_b(alpha_in);
2084         beta = (v16u8) __msa_fill_b(beta_in);
2085
2086         is_less_than_alpha = (p0_asub_q0 < alpha);
2087         is_less_than_beta = (p1_asub_p0 < beta);
2088         is_less_than = is_less_than_beta & is_less_than_alpha;
2089         is_less_than_beta = (q1_asub_q0 < beta);
2090         is_less_than = is_less_than_beta & is_less_than;
2091         is_less_than = is_bs_greater_than0 & is_less_than;
2092
2093         is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
2094
2095         if (!__msa_test_bz_v(is_less_than)) {
2096             ILVR_B4_SH(zero, p1_org, zero, p0_org, zero, q0_org, zero, q1_org,
2097                        p1_org_r, p0_org_r, q0_org_r, q1_org_r);
2098
2099             negate_tc = zero - (v16i8) tc;
2100             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
2101
2102             ILVR_B2_SH(sign_negate_tc, negate_tc, zero, tc, negate_tc_r, tc_r);
2103
2104             AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r, negate_tc_r,
2105                          tc_r, p0_r, q0_r);
2106
2107             PCKEV_B2_UB(zero, p0_r, zero, q0_r, p0, q0);
2108
2109             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
2110             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
2111             tmp1 = (v8i16) __msa_ilvr_b((v16i8) q0_org, (v16i8) p0_org);
2112             src = data - 1;
2113             ST2x4_UB(tmp1, 0, src, img_width);
2114             src += 4 * img_width;
2115             ST2x4_UB(tmp1, 4, src, img_width);
2116         }
2117     }
2118 }
2119
2120 static void avc_h_loop_filter_chroma422_msa(uint8_t *src, int32_t stride,
2121                                             int32_t alpha_in, int32_t beta_in,
2122                                             int8_t *tc0)
2123 {
2124     int32_t col, tc_val;
2125     v16u8 alpha, beta, res;
2126
2127     alpha = (v16u8) __msa_fill_b(alpha_in);
2128     beta = (v16u8) __msa_fill_b(beta_in);
2129
2130     for (col = 0; col < 4; col++) {
2131         tc_val = (tc0[col] - 1) + 1;
2132
2133         if (tc_val <= 0) {
2134             src += (4 * stride);
2135             continue;
2136         }
2137
2138         AVC_LPF_H_CHROMA_422(src, stride, tc_val, alpha, beta, res);
2139         ST2x4_UB(res, 0, (src - 1), stride);
2140         src += (4 * stride);
2141     }
2142 }
2143
2144 static void avc_h_loop_filter_chroma422_mbaff_msa(uint8_t *src, int32_t stride,
2145                                                   int32_t alpha_in,
2146                                                   int32_t beta_in,
2147                                                   int8_t *tc0)
2148 {
2149     int32_t col, tc_val;
2150     int16_t out0, out1;
2151     v16u8 alpha, beta, res;
2152
2153     alpha = (v16u8) __msa_fill_b(alpha_in);
2154     beta = (v16u8) __msa_fill_b(beta_in);
2155
2156     for (col = 0; col < 4; col++) {
2157         tc_val = (tc0[col] - 1) + 1;
2158
2159         if (tc_val <= 0) {
2160             src += 4 * stride;
2161             continue;
2162         }
2163
2164         AVC_LPF_H_2BYTE_CHROMA_422(src, stride, tc_val, alpha, beta, res);
2165
2166         out0 = __msa_copy_s_h((v8i16) res, 0);
2167         out1 = __msa_copy_s_h((v8i16) res, 1);
2168
2169         SH(out0, (src - 1));
2170         src += stride;
2171         SH(out1, (src - 1));
2172         src += stride;
2173     }
2174 }
2175
2176 void ff_h264_h_lpf_luma_inter_msa(uint8_t *data, int img_width,
2177                                   int alpha, int beta, int8_t *tc)
2178 {
2179     uint8_t bs0 = 1;
2180     uint8_t bs1 = 1;
2181     uint8_t bs2 = 1;
2182     uint8_t bs3 = 1;
2183
2184     if (tc[0] < 0)
2185         bs0 = 0;
2186     if (tc[1] < 0)
2187         bs1 = 0;
2188     if (tc[2] < 0)
2189         bs2 = 0;
2190     if (tc[3] < 0)
2191         bs3 = 0;
2192
2193     avc_loopfilter_luma_inter_edge_ver_msa(data, bs0, bs1, bs2, bs3,
2194                                            tc[0], tc[1], tc[2], tc[3],
2195                                            alpha, beta, img_width);
2196 }
2197
2198 void ff_h264_v_lpf_luma_inter_msa(uint8_t *data, int img_width,
2199                                   int alpha, int beta, int8_t *tc)
2200 {
2201
2202     uint8_t bs0 = 1;
2203     uint8_t bs1 = 1;
2204     uint8_t bs2 = 1;
2205     uint8_t bs3 = 1;
2206
2207     if (tc[0] < 0)
2208         bs0 = 0;
2209     if (tc[1] < 0)
2210         bs1 = 0;
2211     if (tc[2] < 0)
2212         bs2 = 0;
2213     if (tc[3] < 0)
2214         bs3 = 0;
2215
2216     avc_loopfilter_luma_inter_edge_hor_msa(data, bs0, bs1, bs2, bs3,
2217                                            tc[0], tc[1], tc[2], tc[3],
2218                                            alpha, beta, img_width);
2219 }
2220
2221 void ff_h264_h_lpf_chroma_inter_msa(uint8_t *data, int img_width,
2222                                     int alpha, int beta, int8_t *tc)
2223 {
2224     uint8_t bs0 = 1;
2225     uint8_t bs1 = 1;
2226     uint8_t bs2 = 1;
2227     uint8_t bs3 = 1;
2228
2229     if (tc[0] < 0)
2230         bs0 = 0;
2231     if (tc[1] < 0)
2232         bs1 = 0;
2233     if (tc[2] < 0)
2234         bs2 = 0;
2235     if (tc[3] < 0)
2236         bs3 = 0;
2237
2238     avc_loopfilter_cb_or_cr_inter_edge_ver_msa(data, bs0, bs1, bs2, bs3,
2239                                                tc[0], tc[1], tc[2], tc[3],
2240                                                alpha, beta, img_width);
2241 }
2242
2243 void ff_h264_v_lpf_chroma_inter_msa(uint8_t *data, int img_width,
2244                                     int alpha, int beta, int8_t *tc)
2245 {
2246     uint8_t bs0 = 1;
2247     uint8_t bs1 = 1;
2248     uint8_t bs2 = 1;
2249     uint8_t bs3 = 1;
2250
2251     if (tc[0] < 0)
2252         bs0 = 0;
2253     if (tc[1] < 0)
2254         bs1 = 0;
2255     if (tc[2] < 0)
2256         bs2 = 0;
2257     if (tc[3] < 0)
2258         bs3 = 0;
2259
2260     avc_loopfilter_cb_or_cr_inter_edge_hor_msa(data, bs0, bs1, bs2, bs3,
2261                                                tc[0], tc[1], tc[2], tc[3],
2262                                                alpha, beta, img_width);
2263 }
2264
2265 void ff_h264_h_lpf_luma_intra_msa(uint8_t *data, int img_width,
2266                                   int alpha, int beta)
2267 {
2268     avc_loopfilter_luma_intra_edge_ver_msa(data, (uint8_t) alpha,
2269                                            (uint8_t) beta,
2270                                            (unsigned int) img_width);
2271 }
2272
2273 void ff_h264_v_lpf_luma_intra_msa(uint8_t *data, int img_width,
2274                                   int alpha, int beta)
2275 {
2276     avc_loopfilter_luma_intra_edge_hor_msa(data, (uint8_t) alpha,
2277                                            (uint8_t) beta,
2278                                            (unsigned int) img_width);
2279 }
2280
2281 void ff_h264_h_lpf_chroma_intra_msa(uint8_t *data, int img_width,
2282                                     int alpha, int beta)
2283 {
2284     avc_loopfilter_cb_or_cr_intra_edge_ver_msa(data, (uint8_t) alpha,
2285                                                (uint8_t) beta,
2286                                                (unsigned int) img_width);
2287 }
2288
2289 void ff_h264_v_lpf_chroma_intra_msa(uint8_t *data, int img_width,
2290                                     int alpha, int beta)
2291 {
2292     avc_loopfilter_cb_or_cr_intra_edge_hor_msa(data, (uint8_t) alpha,
2293                                                (uint8_t) beta,
2294                                                (unsigned int) img_width);
2295 }
2296
2297 void ff_h264_h_loop_filter_chroma422_msa(uint8_t *src,
2298                                          int32_t ystride,
2299                                          int32_t alpha, int32_t beta,
2300                                          int8_t *tc0)
2301 {
2302     avc_h_loop_filter_chroma422_msa(src, ystride, alpha, beta, tc0);
2303 }
2304
2305 void ff_h264_h_loop_filter_chroma422_mbaff_msa(uint8_t *src,
2306                                                int32_t ystride,
2307                                                int32_t alpha,
2308                                                int32_t beta,
2309                                                int8_t *tc0)
2310 {
2311     avc_h_loop_filter_chroma422_mbaff_msa(src, ystride, alpha, beta, tc0);
2312 }
2313
2314 void ff_h264_h_loop_filter_luma_mbaff_msa(uint8_t *src,
2315                                           int32_t ystride,
2316                                           int32_t alpha,
2317                                           int32_t beta,
2318                                           int8_t *tc0)
2319 {
2320     avc_h_loop_filter_luma_mbaff_msa(src, ystride, alpha, beta, tc0);
2321 }
2322
2323 void ff_h264_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src,
2324                                                 int32_t ystride,
2325                                                 int32_t alpha,
2326                                                 int32_t beta)
2327 {
2328     avc_h_loop_filter_luma_mbaff_intra_msa(src, ystride, alpha, beta);
2329 }
2330
2331 void ff_weight_h264_pixels16_8_msa(uint8_t *src, ptrdiff_t stride,
2332                                    int height, int log2_denom,
2333                                    int weight_src, int offset_in)
2334 {
2335     uint32_t offset_val;
2336     v16i8 zero = { 0 };
2337     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
2338     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2339     v8i16 src0_l, src1_l, src2_l, src3_l, src0_r, src1_r, src2_r, src3_r;
2340     v8i16 src4_l, src5_l, src6_l, src7_l, src4_r, src5_r, src6_r, src7_r;
2341     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2342     v8i16 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
2343     v8i16 wgt, denom, offset;
2344
2345     offset_val = (unsigned) offset_in << log2_denom;
2346
2347     wgt = __msa_fill_h(weight_src);
2348     offset = __msa_fill_h(offset_val);
2349     denom = __msa_fill_h(log2_denom);
2350
2351     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2352     ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r, src1_r,
2353                src2_r, src3_r);
2354     ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l, src1_l,
2355                src2_l, src3_l);
2356     ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r, src5_r,
2357                src6_r, src7_r);
2358     ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l, src5_l,
2359                src6_l, src7_l);
2360     MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1, tmp2,
2361          tmp3);
2362     MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5, tmp6,
2363          tmp7);
2364     MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9, tmp10,
2365          tmp11);
2366     MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
2367          tmp14, tmp15);
2368     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
2369                 tmp1, tmp2, tmp3);
2370     ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
2371                 tmp5, tmp6, tmp7);
2372     ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset, tmp8,
2373                 tmp9, tmp10, tmp11);
2374     ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
2375                 tmp12, tmp13, tmp14, tmp15);
2376     MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
2377     MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
2378     SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
2379     SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
2380     SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
2381     SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
2382     PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2383                 dst2, dst3);
2384     PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2385                 dst5, dst6, dst7);
2386     ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
2387     src += 8 * stride;
2388
2389     if (16 == height) {
2390         LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2391         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r,
2392                    src1_r, src2_r, src3_r);
2393         ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l,
2394                    src1_l, src2_l, src3_l);
2395         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r,
2396                    src5_r, src6_r, src7_r);
2397         ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l,
2398                    src5_l, src6_l, src7_l);
2399         MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1,
2400              tmp2, tmp3);
2401         MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5,
2402              tmp6, tmp7);
2403         MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9,
2404              tmp10, tmp11);
2405         MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
2406              tmp14, tmp15);
2407         ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
2408                     tmp0, tmp1, tmp2, tmp3);
2409         ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
2410                     tmp4, tmp5, tmp6, tmp7);
2411         ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset,
2412                     tmp8, tmp9, tmp10, tmp11);
2413         ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
2414                     tmp12, tmp13, tmp14, tmp15);
2415         MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
2416         MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
2417         SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
2418         SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
2419         SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
2420         SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
2421         PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2422                     dst2, dst3);
2423         PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2424                     dst5, dst6, dst7);
2425         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
2426     }
2427 }
2428
2429 void ff_weight_h264_pixels8_8_msa(uint8_t *src, ptrdiff_t stride,
2430                                   int height, int log2_denom,
2431                                   int weight_src, int offset)
2432 {
2433     if (4 == height) {
2434         avc_wgt_8x4_msa(src, stride, log2_denom, weight_src, offset);
2435     } else if (8 == height) {
2436         avc_wgt_8x8_msa(src, stride, log2_denom, weight_src, offset);
2437     } else {
2438         avc_wgt_8x16_msa(src, stride, log2_denom, weight_src, offset);
2439     }
2440 }
2441
2442 void ff_weight_h264_pixels4_8_msa(uint8_t *src, ptrdiff_t stride,
2443                                   int height, int log2_denom,
2444                                   int weight_src, int offset)
2445 {
2446     if (2 == height) {
2447         avc_wgt_4x2_msa(src, stride, log2_denom, weight_src, offset);
2448     } else if (4 == height) {
2449         avc_wgt_4x4_msa(src, stride, log2_denom, weight_src, offset);
2450     } else {
2451         avc_wgt_4x8_msa(src, stride, log2_denom, weight_src, offset);
2452     }
2453 }
2454
2455 void ff_biweight_h264_pixels16_8_msa(uint8_t *dst, uint8_t *src,
2456                                      ptrdiff_t stride, int height,
2457                                      int log2_denom, int weight_dst,
2458                                      int weight_src, int offset_in)
2459 {
2460     v16i8 src_wgt, dst_wgt, wgt;
2461     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
2462     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2463     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
2464     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
2465     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2466     v8i16 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
2467     v8i16 denom, offset;
2468
2469     offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
2470     offset_in += (128 * (weight_src + weight_dst));
2471
2472     src_wgt = __msa_fill_b(weight_src);
2473     dst_wgt = __msa_fill_b(weight_dst);
2474     offset = __msa_fill_h(offset_in);
2475     denom = __msa_fill_h(log2_denom + 1);
2476
2477     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
2478
2479     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2480     src += 8 * stride;
2481     LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
2482     XORI_B8_128_UB(src0, src1, src2, src3, src4, src5, src6, src7);
2483     XORI_B8_128_UB(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
2484     ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec0, vec2, vec4,
2485                vec6);
2486     ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec1, vec3, vec5,
2487                vec7);
2488     ILVR_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec8, vec10,
2489                vec12, vec14);
2490     ILVL_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec9, vec11,
2491                vec13, vec15);
2492     tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
2493     tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
2494     tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
2495     tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
2496     tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
2497     tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
2498     tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
2499     tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
2500     tmp8 = __msa_dpadd_s_h(offset, wgt, vec8);
2501     tmp9 = __msa_dpadd_s_h(offset, wgt, vec9);
2502     tmp10 = __msa_dpadd_s_h(offset, wgt, vec10);
2503     tmp11 = __msa_dpadd_s_h(offset, wgt, vec11);
2504     tmp12 = __msa_dpadd_s_h(offset, wgt, vec12);
2505     tmp13 = __msa_dpadd_s_h(offset, wgt, vec13);
2506     tmp14 = __msa_dpadd_s_h(offset, wgt, vec14);
2507     tmp15 = __msa_dpadd_s_h(offset, wgt, vec15);
2508     SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
2509     SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
2510     SRA_4V(tmp8, tmp9, tmp10, tmp11, denom);
2511     SRA_4V(tmp12, tmp13, tmp14, tmp15, denom);
2512     CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
2513     CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
2514     CLIP_SH4_0_255(tmp8, tmp9, tmp10, tmp11);
2515     CLIP_SH4_0_255(tmp12, tmp13, tmp14, tmp15);
2516     PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2517                 dst2, dst3);
2518     PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2519                 dst5, dst6, dst7);
2520     ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
2521     dst += 8 * stride;
2522
2523     if (16 == height) {
2524         LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2525         LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
2526         XORI_B8_128_UB(src0, src1, src2, src3, src4, src5, src6, src7);
2527         XORI_B8_128_UB(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
2528         ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec0, vec2,
2529                    vec4, vec6);
2530         ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec1, vec3,
2531                    vec5, vec7);
2532         ILVR_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec8, vec10,
2533                    vec12, vec14);
2534         ILVL_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec9, vec11,
2535                    vec13, vec15);
2536         tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
2537         tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
2538         tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
2539         tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
2540         tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
2541         tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
2542         tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
2543         tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
2544         tmp8 = __msa_dpadd_s_h(offset, wgt, vec8);
2545         tmp9 = __msa_dpadd_s_h(offset, wgt, vec9);
2546         tmp10 = __msa_dpadd_s_h(offset, wgt, vec10);
2547         tmp11 = __msa_dpadd_s_h(offset, wgt, vec11);
2548         tmp12 = __msa_dpadd_s_h(offset, wgt, vec12);
2549         tmp13 = __msa_dpadd_s_h(offset, wgt, vec13);
2550         tmp14 = __msa_dpadd_s_h(offset, wgt, vec14);
2551         tmp15 = __msa_dpadd_s_h(offset, wgt, vec15);
2552         SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
2553         SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
2554         SRA_4V(tmp8, tmp9, tmp10, tmp11, denom);
2555         SRA_4V(tmp12, tmp13, tmp14, tmp15, denom);
2556         CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
2557         CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
2558         CLIP_SH4_0_255(tmp8, tmp9, tmp10, tmp11);
2559         CLIP_SH4_0_255(tmp12, tmp13, tmp14, tmp15);
2560         PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2561                     dst2, dst3);
2562         PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2563                     dst5, dst6, dst7);
2564         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
2565     }
2566 }
2567
2568 void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
2569                                     ptrdiff_t stride, int height,
2570                                     int log2_denom, int weight_dst,
2571                                     int weight_src, int offset)
2572 {
2573     if (4 == height) {
2574         avc_biwgt_8x4_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2575                           offset);
2576     } else if (8 == height) {
2577         avc_biwgt_8x8_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2578                           offset);
2579     } else {
2580         avc_biwgt_8x16_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2581                            offset);
2582     }
2583 }
2584
2585 void ff_biweight_h264_pixels4_8_msa(uint8_t *dst, uint8_t *src,
2586                                     ptrdiff_t stride, int height,
2587                                     int log2_denom, int weight_dst,
2588                                     int weight_src, int offset)
2589 {
2590     if (2 == height) {
2591         avc_biwgt_4x2_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2592                           offset);
2593     } else if (4 == height) {
2594         avc_biwgt_4x4_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2595                           offset);
2596     } else {
2597         avc_biwgt_4x8_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
2598                           offset);
2599     }
2600 }