WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/mips/hevc_mc_bi_msa.c

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/mips/hevc_mc_bi_msa.c – Rev 6147