avcodec/mips: MSA (MIPS-SIMD-Arch) optimizations for HEVC biw mc functions

This patch adds MSA (MIPS-SIMD-Arch) optimizations for HEVC biw mc functions (qpel as well as epel) in new file hevc_mc_biw_msa.c Adds new generic macros (needed for this patch) in libavutil/mips/generic_macros_msa.h

Shivraj Patil committed 11 years ago

Commit 88188f51 parent 12002894 files · +5744 −1Browse files

Showing the changes to libavcodec/mips (4 of 4 files). Show all

Unified · Split

4 files

libavcodec/mips/Makefile +2 −1
libavcodec/mips/hevc_mc_biw_msa.c +5572 −0
libavcodec/mips/hevcdsp_init_mips.c +83 −0
libavcodec/mips/hevcdsp_mips.h +87 −0

libavcodec/mips/Makefile+2−1

 MSA-OBJS-$(CONFIG_HEVC_DECODER)           += mips/hevcdsp_msa.o            \
                                              mips/hevc_mc_uni_msa.o        \
                                              mips/hevc_mc_uniw_msa.o       \
-                                             mips/hevc_mc_bi_msa.o
+                                             mips/hevc_mc_bi_msa.o         \
+                                             mips/hevc_mc_biw_msa.o
 MSA-OBJS-$(CONFIG_H264DSP)                += mips/h264dsp_msa.o
 LOONGSON3-OBJS-$(CONFIG_H264DSP)          += mips/h264dsp_mmi.o
 LOONGSON3-OBJS-$(CONFIG_H264CHROMA)       += mips/h264chroma_mmi.o

libavcodec/mips/hevc_mc_biw_msa.c+5572−0

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

573 more lines aren’t shown here.

libavcodec/mips/hevcdsp_init_mips.c+83−0

@@ -257,6 +257,89 @@ static av_cold void hevc_dsp_init_msa(HEVCDSPContext *c, · 256 unmodified lines
257	c->put_hevc_epel_bi[5][1][1] = ff_hevc_put_hevc_bi_epel_hv16_8_msa;	257	c->put_hevc_epel_bi[5][1][1] = ff_hevc_put_hevc_bi_epel_hv16_8_msa;
258	c->put_hevc_epel_bi[6][1][1] = ff_hevc_put_hevc_bi_epel_hv24_8_msa;	258	c->put_hevc_epel_bi[6][1][1] = ff_hevc_put_hevc_bi_epel_hv24_8_msa;
259	c->put_hevc_epel_bi[7][1][1] = ff_hevc_put_hevc_bi_epel_hv32_8_msa;	259	c->put_hevc_epel_bi[7][1][1] = ff_hevc_put_hevc_bi_epel_hv32_8_msa;
		260
		261	c->put_hevc_qpel_bi_w[1][0][0] =
		262	ff_hevc_put_hevc_bi_w_pel_pixels4_8_msa;
		263	c->put_hevc_qpel_bi_w[3][0][0] =
		264	ff_hevc_put_hevc_bi_w_pel_pixels8_8_msa;
		265	c->put_hevc_qpel_bi_w[4][0][0] =
		266	ff_hevc_put_hevc_bi_w_pel_pixels12_8_msa;
		267	c->put_hevc_qpel_bi_w[5][0][0] =
		268	ff_hevc_put_hevc_bi_w_pel_pixels16_8_msa;
		269	c->put_hevc_qpel_bi_w[6][0][0] =
		270	ff_hevc_put_hevc_bi_w_pel_pixels24_8_msa;
		271	c->put_hevc_qpel_bi_w[7][0][0] =
		272	ff_hevc_put_hevc_bi_w_pel_pixels32_8_msa;
		273	c->put_hevc_qpel_bi_w[8][0][0] =
		274	ff_hevc_put_hevc_bi_w_pel_pixels48_8_msa;
		275	c->put_hevc_qpel_bi_w[9][0][0] =
		276	ff_hevc_put_hevc_bi_w_pel_pixels64_8_msa;
		277
		278	c->put_hevc_qpel_bi_w[1][0][1] = ff_hevc_put_hevc_bi_w_qpel_h4_8_msa;
		279	c->put_hevc_qpel_bi_w[3][0][1] = ff_hevc_put_hevc_bi_w_qpel_h8_8_msa;
		280	c->put_hevc_qpel_bi_w[4][0][1] = ff_hevc_put_hevc_bi_w_qpel_h12_8_msa;
		281	c->put_hevc_qpel_bi_w[5][0][1] = ff_hevc_put_hevc_bi_w_qpel_h16_8_msa;
		282	c->put_hevc_qpel_bi_w[6][0][1] = ff_hevc_put_hevc_bi_w_qpel_h24_8_msa;
		283	c->put_hevc_qpel_bi_w[7][0][1] = ff_hevc_put_hevc_bi_w_qpel_h32_8_msa;
		284	c->put_hevc_qpel_bi_w[8][0][1] = ff_hevc_put_hevc_bi_w_qpel_h48_8_msa;
		285	c->put_hevc_qpel_bi_w[9][0][1] = ff_hevc_put_hevc_bi_w_qpel_h64_8_msa;
		286
		287	c->put_hevc_qpel_bi_w[1][1][0] = ff_hevc_put_hevc_bi_w_qpel_v4_8_msa;
		288	c->put_hevc_qpel_bi_w[3][1][0] = ff_hevc_put_hevc_bi_w_qpel_v8_8_msa;
		289	c->put_hevc_qpel_bi_w[4][1][0] = ff_hevc_put_hevc_bi_w_qpel_v12_8_msa;
		290	c->put_hevc_qpel_bi_w[5][1][0] = ff_hevc_put_hevc_bi_w_qpel_v16_8_msa;
		291	c->put_hevc_qpel_bi_w[6][1][0] = ff_hevc_put_hevc_bi_w_qpel_v24_8_msa;
		292	c->put_hevc_qpel_bi_w[7][1][0] = ff_hevc_put_hevc_bi_w_qpel_v32_8_msa;
		293	c->put_hevc_qpel_bi_w[8][1][0] = ff_hevc_put_hevc_bi_w_qpel_v48_8_msa;
		294	c->put_hevc_qpel_bi_w[9][1][0] = ff_hevc_put_hevc_bi_w_qpel_v64_8_msa;
		295
		296	c->put_hevc_qpel_bi_w[1][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv4_8_msa;
		297	c->put_hevc_qpel_bi_w[3][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv8_8_msa;
		298	c->put_hevc_qpel_bi_w[4][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv12_8_msa;
		299	c->put_hevc_qpel_bi_w[5][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv16_8_msa;
		300	c->put_hevc_qpel_bi_w[6][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv24_8_msa;
		301	c->put_hevc_qpel_bi_w[7][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv32_8_msa;
		302	c->put_hevc_qpel_bi_w[8][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv48_8_msa;
		303	c->put_hevc_qpel_bi_w[9][1][1] = ff_hevc_put_hevc_bi_w_qpel_hv64_8_msa;
		304
		305	c->put_hevc_epel_bi_w[1][0][0] =
		306	ff_hevc_put_hevc_bi_w_pel_pixels4_8_msa;
		307	c->put_hevc_epel_bi_w[2][0][0] =
		308	ff_hevc_put_hevc_bi_w_pel_pixels6_8_msa;
		309	c->put_hevc_epel_bi_w[3][0][0] =
		310	ff_hevc_put_hevc_bi_w_pel_pixels8_8_msa;
		311	c->put_hevc_epel_bi_w[4][0][0] =
		312	ff_hevc_put_hevc_bi_w_pel_pixels12_8_msa;
		313	c->put_hevc_epel_bi_w[5][0][0] =
		314	ff_hevc_put_hevc_bi_w_pel_pixels16_8_msa;
		315	c->put_hevc_epel_bi_w[6][0][0] =
		316	ff_hevc_put_hevc_bi_w_pel_pixels24_8_msa;
		317	c->put_hevc_epel_bi_w[7][0][0] =
		318	ff_hevc_put_hevc_bi_w_pel_pixels32_8_msa;
		319
		320	c->put_hevc_epel_bi_w[1][0][1] = ff_hevc_put_hevc_bi_w_epel_h4_8_msa;
		321	c->put_hevc_epel_bi_w[2][0][1] = ff_hevc_put_hevc_bi_w_epel_h6_8_msa;
		322	c->put_hevc_epel_bi_w[3][0][1] = ff_hevc_put_hevc_bi_w_epel_h8_8_msa;
		323	c->put_hevc_epel_bi_w[4][0][1] = ff_hevc_put_hevc_bi_w_epel_h12_8_msa;
		324	c->put_hevc_epel_bi_w[5][0][1] = ff_hevc_put_hevc_bi_w_epel_h16_8_msa;
		325	c->put_hevc_epel_bi_w[6][0][1] = ff_hevc_put_hevc_bi_w_epel_h24_8_msa;
		326	c->put_hevc_epel_bi_w[7][0][1] = ff_hevc_put_hevc_bi_w_epel_h32_8_msa;
		327
		328	c->put_hevc_epel_bi_w[1][1][0] = ff_hevc_put_hevc_bi_w_epel_v4_8_msa;
		329	c->put_hevc_epel_bi_w[2][1][0] = ff_hevc_put_hevc_bi_w_epel_v6_8_msa;
		330	c->put_hevc_epel_bi_w[3][1][0] = ff_hevc_put_hevc_bi_w_epel_v8_8_msa;
		331	c->put_hevc_epel_bi_w[4][1][0] = ff_hevc_put_hevc_bi_w_epel_v12_8_msa;
		332	c->put_hevc_epel_bi_w[5][1][0] = ff_hevc_put_hevc_bi_w_epel_v16_8_msa;
		333	c->put_hevc_epel_bi_w[6][1][0] = ff_hevc_put_hevc_bi_w_epel_v24_8_msa;
		334	c->put_hevc_epel_bi_w[7][1][0] = ff_hevc_put_hevc_bi_w_epel_v32_8_msa;
		335
		336	c->put_hevc_epel_bi_w[1][1][1] = ff_hevc_put_hevc_bi_w_epel_hv4_8_msa;
		337	c->put_hevc_epel_bi_w[2][1][1] = ff_hevc_put_hevc_bi_w_epel_hv6_8_msa;
		338	c->put_hevc_epel_bi_w[3][1][1] = ff_hevc_put_hevc_bi_w_epel_hv8_8_msa;
		339	c->put_hevc_epel_bi_w[4][1][1] = ff_hevc_put_hevc_bi_w_epel_hv12_8_msa;
		340	c->put_hevc_epel_bi_w[5][1][1] = ff_hevc_put_hevc_bi_w_epel_hv16_8_msa;
		341	c->put_hevc_epel_bi_w[6][1][1] = ff_hevc_put_hevc_bi_w_epel_hv24_8_msa;
		342	c->put_hevc_epel_bi_w[7][1][1] = ff_hevc_put_hevc_bi_w_epel_hv32_8_msa;
260	}	343	}
261	}	344	}
262	#endif // #if HAVE_MSA	345	#endif // #if HAVE_MSA

libavcodec/mips/hevcdsp_mips.h+87−0

@@ -280,3 +280,90 @@ BI_MC(epel, hv, 48); · 279 unmodified lines
280	BI_MC(epel, hv, 64);	280	BI_MC(epel, hv, 64);
281		281
282	#undef BI_MC	282	#undef BI_MC
		283
		284	#define BI_W_MC(PEL, DIR, WIDTH) \
		285	void ff_hevc_put_hevc_bi_w_##PEL##_##DIR####WIDTH##_8_msa(uint8_t *dst, \
		286	ptrdiff_t \
		287	dst_stride, \
		288	uint8_t *src, \
		289	ptrdiff_t \
		290	src_stride, \
		291	int16_t *src_16bit, \
		292	int height, \
		293	int denom, \
		294	int weight0, \
		295	int weight1, \
		296	int offset0, \
		297	int offset1, \
		298	intptr_t mx, \
		299	intptr_t my, \
		300	int width)
		301
		302	BI_W_MC(pel, pixels, 4);
		303	BI_W_MC(pel, pixels, 6);
		304	BI_W_MC(pel, pixels, 8);
		305	BI_W_MC(pel, pixels, 12);
		306	BI_W_MC(pel, pixels, 16);
		307	BI_W_MC(pel, pixels, 24);
		308	BI_W_MC(pel, pixels, 32);
		309	BI_W_MC(pel, pixels, 48);
		310	BI_W_MC(pel, pixels, 64);
		311
		312	BI_W_MC(qpel, h, 4);
		313	BI_W_MC(qpel, h, 8);
		314	BI_W_MC(qpel, h, 12);
		315	BI_W_MC(qpel, h, 16);
		316	BI_W_MC(qpel, h, 24);
		317	BI_W_MC(qpel, h, 32);
		318	BI_W_MC(qpel, h, 48);
		319	BI_W_MC(qpel, h, 64);
		320
		321	BI_W_MC(qpel, v, 4);
		322	BI_W_MC(qpel, v, 8);
		323	BI_W_MC(qpel, v, 12);
		324	BI_W_MC(qpel, v, 16);
		325	BI_W_MC(qpel, v, 24);
		326	BI_W_MC(qpel, v, 32);
		327	BI_W_MC(qpel, v, 48);
		328	BI_W_MC(qpel, v, 64);
		329
		330	BI_W_MC(qpel, hv, 4);
		331	BI_W_MC(qpel, hv, 8);
		332	BI_W_MC(qpel, hv, 12);
		333	BI_W_MC(qpel, hv, 16);
		334	BI_W_MC(qpel, hv, 24);
		335	BI_W_MC(qpel, hv, 32);
		336	BI_W_MC(qpel, hv, 48);
		337	BI_W_MC(qpel, hv, 64);
		338
		339	BI_W_MC(epel, h, 4);
		340	BI_W_MC(epel, h, 6);
		341	BI_W_MC(epel, h, 8);
		342	BI_W_MC(epel, h, 12);
		343	BI_W_MC(epel, h, 16);
		344	BI_W_MC(epel, h, 24);
		345	BI_W_MC(epel, h, 32);
		346	BI_W_MC(epel, h, 48);
		347	BI_W_MC(epel, h, 64);
		348
		349	BI_W_MC(epel, v, 4);
		350	BI_W_MC(epel, v, 6);
		351	BI_W_MC(epel, v, 8);
		352	BI_W_MC(epel, v, 12);
		353	BI_W_MC(epel, v, 16);
		354	BI_W_MC(epel, v, 24);
		355	BI_W_MC(epel, v, 32);
		356	BI_W_MC(epel, v, 48);
		357	BI_W_MC(epel, v, 64);
		358
		359	BI_W_MC(epel, hv, 4);
		360	BI_W_MC(epel, hv, 6);
		361	BI_W_MC(epel, hv, 8);
		362	BI_W_MC(epel, hv, 12);
		363	BI_W_MC(epel, hv, 16);
		364	BI_W_MC(epel, hv, 24);
		365	BI_W_MC(epel, hv, 32);
		366	BI_W_MC(epel, hv, 48);
		367	BI_W_MC(epel, hv, 64);
		368
		369	#undef BI_W_MC

avcodec/mips: MSA (MIPS-SIMD-Arch) optimizations for HEVC biw mc functions

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code