自学教程：C++ vis_faligndata函数代码示例

voidmlib_v_ImageNot_na(    mlib_u8 *sa,    mlib_u8 *da,    mlib_s32 size){/* end points in dst */	mlib_u8 *dend;/* 8-byte aligned start points in dst */	mlib_d64 *dp;/* 8-byte aligned start point in src */	mlib_d64 *sp;/* 8-byte source data */	mlib_d64 s0, s1;/* offset of address in dst */	mlib_s32 j;/* edge mask */	mlib_s32 emask;/* prepare the destination addresses */	dp = (mlib_d64 *)((mlib_addr)da & (~7));	j = (mlib_addr)dp - (mlib_addr)da;	dend = da + size - 1;/* prepare the source address */	sp = (mlib_d64 *)vis_alignaddr(sa, j);/* generate edge mask for the start point */	emask = vis_edge8(da, dend);	s1 = vis_ld_d64_nf(sp);	if (emask != 0xff) {		s0 = s1;		s1 = vis_ld_d64_nf(sp + 1);		s0 = vis_faligndata(s0, s1);		vis_pst_8(vis_fnot(s0), dp++, emask);		sp++;		j += 8;	}#pragma pipeloop(0)	for (; j <= (size - 8); j += 8) {		s0 = s1;		s1 = vis_ld_d64_nf(sp + 1);		(*dp++) = vis_fnot(vis_faligndata(s0, s1));		sp++;	}	if (j < size) {		s0 = vis_faligndata(s1, vis_ld_d64_nf(sp + 1));		emask = vis_edge8(dp, dend);		vis_pst_8(vis_fnot(s0), dp, emask);	}}

voidmlib_ImageLineXor8000(    const mlib_u8 *src,    mlib_u8 *dst,    mlib_s32 size){	mlib_u8 *dend;	mlib_d64 *dptr;	mlib_d64 *sptr;	mlib_d64 s0, s1;	mlib_d64 mask8000 = vis_to_double_dup(0x80008000);	mlib_s32 j;	mlib_s32 emask;/* prepare the destination addresses */	dptr = (mlib_d64 *)((mlib_addr)dst & (~7));	j = (mlib_addr)dptr - (mlib_addr)dst;	dend = (mlib_u8 *)dst + size - 1;/* prepare the source address */	sptr = (mlib_d64 *)VIS_ALIGNADDR(src, j);/* generate edge mask for the start point */	emask = vis_edge8(dst, dend);	s1 = vis_ld_d64_nf(sptr);	if (emask != 0xff) {		s0 = s1;		s1 = vis_ld_d64_nf(sptr + 1);		s0 = vis_fxor(vis_faligndata(s0, s1), mask8000);		vis_pst_8(s0, dptr++, emask);		sptr++;		j += 8;	}#pragma pipeloop(0)	for (; j <= (size - 16); j += 8) {		s0 = s1;		s1 = sptr[1];		(*dptr++) = vis_fxor(vis_faligndata(s0, s1), mask8000);		sptr++;	}	if (j <= (size - 8)) {		s0 = s1;		s1 = vis_ld_d64_nf(sptr + 1);		(*dptr++) = vis_fxor(vis_faligndata(s0, s1), mask8000);		sptr++;		j += 8;	}	if (j < size) {		s0 = vis_fxor(vis_faligndata(s1, vis_ld_d64_nf(sptr + 1)),		    mask8000);		emask = vis_edge8(dptr, dend);		vis_pst_8(s0, dptr, emask);	}}

mlib_status__mlib_VideoColorSplit3_S16(	mlib_s16 *color1,	mlib_s16 *color2,	mlib_s16 *color3,	const mlib_s16 *colors,	mlib_s32 n){	mlib_d64 *sp = (mlib_d64 *)colors;	mlib_d64 *dp0 = (mlib_d64 *)color1;	mlib_d64 *dp1 = (mlib_d64 *)color2;	mlib_d64 *dp2 = (mlib_d64 *)color3;	mlib_d64 sd0, sd1, sd2, dd0, dd1, dd2, dd3;	mlib_s32 i;	vis_write_gsr(4);	vis_write_bmask(0x02CE13DF, 0);#pragma pipeloop(0)#pragma unroll(4)	for (i = 0; i <= (n - 4); i += 4) {		sd0 = sp[0];		sd1 = sp[1];		sd2 = sp[2];		dd1 = vis_fpmerge(vis_read_lo(sd0), vis_read_hi(sd2));		dd0 = vis_fpmerge(vis_read_hi(sd0), vis_read_lo(sd1));		(*dp0++) = vis_bshuffle(dd0, dd1);		dd2 = vis_fpmerge(vis_read_hi(sd1), vis_read_lo(sd2));		dd3 = vis_faligndata(dd0, dd2);		(*dp1++) = vis_bshuffle(dd3, dd3);		(*dp2++) = vis_bshuffle(dd1, dd2);		sp += 3;	}/* * last 4 pixels */	if (i < n) {		mlib_s32 emask = 0xF0 >> (n & 3);		mlib_d64 st0, st1, st2;		sd0 = sp[0];		sd1 = vis_ld_d64_nf(sp + 1);		sd2 = vis_ld_d64_nf(sp + 2);		dd1 = vis_fpmerge(vis_read_lo(sd0), vis_read_hi(sd2));		dd0 = vis_fpmerge(vis_read_hi(sd0), vis_read_lo(sd1));		st0 = vis_bshuffle(dd0, dd1);		dd2 = vis_fpmerge(vis_read_hi(sd1), vis_read_lo(sd2));		dd3 = vis_faligndata(dd0, dd2);		st1 = vis_bshuffle(dd3, dd3);		st2 = vis_bshuffle(dd1, dd2);		vis_pst_16(st0, dp0, emask);		vis_pst_16(st1, dp1, emask);		vis_pst_16(st2, dp2, emask);	}

void mlib_v_ImageLookUpSI_S32_S16_4_DstOff2_D1(mlib_s32 *src,                                               mlib_s16 *dst,                                               mlib_s32 xsize,                                               mlib_s16 **table){  mlib_s32 *sp;              /* pointer to source data */  mlib_s32 s0, s1;           /* source data */  mlib_s16 *dl;              /* pointer to start of destination */  mlib_d64 *dp;              /* aligned pointer to destination */  mlib_d64 t0, t1, t2, t3;   /* destination data */  mlib_d64 acc;              /* destination data */  mlib_s32 i;                /* loop variable */  mlib_s16 *tab0 = &table[0][(mlib_u32)2147483648];  mlib_s16 *tab1 = &table[1][(mlib_u32)2147483648];  mlib_s16 *tab2 = &table[2][(mlib_u32)2147483648];  mlib_s16 *tab3 = &table[3][(mlib_u32)2147483648];  sp   = src;  dl   = dst;  dp   = (mlib_d64 *) dl;  vis_alignaddr((void *) 0, 6);  s0 = *sp++;  if (xsize >= 1) {    s1 = *sp++;#pragma pipeloop(0)    for(i = 0; i <= xsize - 2; i++) {      t3 = vis_ld_u16_i(tab1, ((mlib_addr)2*s1));      t2 = vis_ld_u16_i(tab0, ((mlib_addr)2*s1));      t1 = vis_ld_u16_i(tab3, ((mlib_addr)2*s0));      t0 = vis_ld_u16_i(tab2, ((mlib_addr)2*s0));      acc = vis_faligndata(t3, acc);      acc = vis_faligndata(t2, acc);      acc = vis_faligndata(t1, acc);      acc = vis_faligndata(t0, acc);      s0 = s1;      s1 = *sp++;      *dp++ = acc;    }    t3 = vis_ld_u16_i(tab1, ((mlib_addr)2*s1));    t2 = vis_ld_u16_i(tab0, ((mlib_addr)2*s1));    t1 = vis_ld_u16_i(tab3, ((mlib_addr)2*s0));    t0 = vis_ld_u16_i(tab2, ((mlib_addr)2*s0));    acc = vis_faligndata(t3, acc);    acc = vis_faligndata(t2, acc);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    s0 = s1;    *dp++ = acc;  }  dl = (mlib_s16*)dp;  dl[0] = tab2[s0];  dl[1] = tab3[s0];}

mlib_status__mlib_VideoColorSplit2_S16(	mlib_s16 *color1,	mlib_s16 *color2,	const mlib_s16 *colors,	mlib_s32 n){	mlib_d64 *sp = (mlib_d64 *)colors;	mlib_d64 *dp0 = (mlib_d64 *)color1;	mlib_d64 *dp1 = (mlib_d64 *)color2;	mlib_d64 sd0, sd1, dd0, dd1, dd2, dd3;	mlib_s32 i;	vis_write_gsr64(((mlib_u64)0x014589cd << 32) | 2);/* * 8-pixels loop */	sd0 = sp[0];	sd1 = vis_ld_d64_nf(sp + 1);	dd0 = vis_faligndata(sd0, sd1);	dd1 = vis_faligndata(sd1, sd0);	dd2 = vis_bshuffle(sd0, sd1);	dd3 = vis_bshuffle(dd0, dd1);	sd0 = vis_ld_d64_nf(sp + 2);	sd1 = vis_ld_d64_nf(sp + 3);	dd0 = vis_faligndata(sd0, sd1);	dd1 = vis_faligndata(sd1, sd0);#pragma pipeloop(0)	for (i = 0; i < (n / 4); i++) {		(*dp0++) = dd2;		(*dp1++) = dd3;		dd2 = vis_bshuffle(sd0, sd1);		dd3 = vis_bshuffle(dd0, dd1);		sd0 = vis_ld_d64_nf(sp + 4);		sd1 = vis_ld_d64_nf(sp + 5);		dd0 = vis_faligndata(sd0, sd1);		dd1 = vis_faligndata(sd1, sd0);		sp += 2;	}/* * last 8 pixels */	if (n & 3) {		mlib_s32 emask = 0xF0 >> (n & 3);		sd0 = sp[0];		sd1 = vis_ld_d64_nf(sp + 1);		dd0 = vis_faligndata(sd0, sd1);		dd1 = vis_faligndata(sd1, sd0);		dd2 = vis_bshuffle(sd0, sd1);		dd3 = vis_bshuffle(dd0, dd1);		vis_pst_16(dd2, (mlib_f32 *)dp0, emask);		vis_pst_16(dd3, (mlib_f32 *)dp1, emask);	}

voidmlib_v_ImageColorRGB2Mono_U8_A8D2X8(    const mlib_u8 *src,    mlib_s32 slb,    mlib_u8 *dst,    mlib_s32 dlb,    mlib_s32 xsize,    mlib_s32 ysize,    const mlib_d64 *weight){    mlib_d64 *sp, *dp;    mlib_d64 *sl, *dl;    mlib_d64 sd0, sd1, sd2, sd3;    mlib_d64 dd;    mlib_d64 rgdd0, bdd0, rgdd1, bdd1, ddt;    mlib_f32 d32, e32, alpha, gamma, beta;    mlib_s32 i, j;    mlib_s32 mask0 = 0x0369147a;    mlib_s32 mask1 = 0x258b258b;    sp = sl = (mlib_d64 *)src;    dp = dl = (mlib_d64 *)dst;    /* prepare the weight */    alpha = vis_to_float(weight[0] * 8192);    beta = vis_to_float(weight[1] * 8192);    gamma = vis_to_float(weight[2] * 8192);    vis_write_gsr((2 << 3) + 4);    for (j = 0; j < ysize; j++) {#pragma pipeloop(0)        for (i = 0; i < xsize / 8; i++) {            sd0 = (*sp++);            sd1 = (*sp++);            sd2 = (*sp++);            sd3 = vis_faligndata(sd2, sd2);            sd2 = vis_faligndata(sd1, sd2);            CHANNELSEPARATE_U8_AL(sd0, sd1, sd2, sd3, rgdd0, bdd0,                                  rgdd1, bdd1);            CHANNELWEIGHT_U8(rgdd0, bdd0, rgdd1, bdd1, dd);            (*dp++) = dd;        }        sp = sl = (mlib_d64 *)((mlib_u8 *)sl + slb);        dp = dl = (mlib_d64 *)((mlib_u8 *)dl + dlb);    }}

void mlib_v_ImageLookUpSI_S16_U16_4_DstOff0_D1(const mlib_s16 *src,                                               mlib_u16       *dst,                                               mlib_s32       xsize,                                               const mlib_u16 **table){  mlib_s16 *sp;              /* pointer to source data */  mlib_s32 s0;               /* source data */  mlib_u16 *dl;              /* pointer to start of destination */  mlib_d64 *dp;              /* aligned pointer to destination */  mlib_d64 t0, t1, t2, t3;   /* destination data */  mlib_d64 acc;              /* destination data */  mlib_s32 i;                /* loop variable */  const mlib_u16 *tab0 = &table[0][32768];  const mlib_u16 *tab1 = &table[1][32768];  const mlib_u16 *tab2 = &table[2][32768];  const mlib_u16 *tab3 = &table[3][32768];  sp   = (void *)src;  dl   = dst;  dp   = (mlib_d64 *) dl;  vis_alignaddr((void *) 0, 6);  if (xsize >= 1) {    s0 = (*sp++) << 1;#pragma pipeloop(0)    for(i = 0; i <= xsize - 2; i++) {      t3 = VIS_LD_U16_I(tab3, s0);      t2 = VIS_LD_U16_I(tab2, s0);      t1 = VIS_LD_U16_I(tab1, s0);      t0 = VIS_LD_U16_I(tab0, s0);      acc = vis_faligndata(t3, acc);      acc = vis_faligndata(t2, acc);      acc = vis_faligndata(t1, acc);      acc = vis_faligndata(t0, acc);      s0 = (*sp++) << 1;      *dp++ = acc;    }    t3 = VIS_LD_U16_I(tab3, s0);    t2 = VIS_LD_U16_I(tab2, s0);    t1 = VIS_LD_U16_I(tab1, s0);    t0 = VIS_LD_U16_I(tab0, s0);    acc = vis_faligndata(t3, acc);    acc = vis_faligndata(t2, acc);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    *dp++ = acc;  }}

static void FUNC(    m3) (    FUNC_M_ARG){	mlib_s32 i;	mlib_d64 k0 = pkern[0];	mlib_d64 k1 = pkern[1];	mlib_d64 k2 = pkern[2];	mlib_d64 a0, a1, a2, aa, sum;	mlib_d64 *perror = vis_alignaddr(perror1, 0);	a0 = (*perror++);	for (i = 0; i < sw; i++) {		aa = (*perror++);		a1 = vis_faligndata(a0, aa);		a2 = vis_faligndata(a1, vis_faligndata(aa, aa));		sum = vis_fpadd16(buffd[i], FMUL_16x16(k0, a0));		sum = vis_fpadd16(sum, FMUL_16x16(k1, a1));		buffd[i] = vis_fpadd16(sum, FMUL_16x16(k2, a2));		a0 = aa;	}}

voidmlib_v_ImageLookUp_U8_U8_124_SrcOff0_D1(    const mlib_u8 *src,    mlib_u8 *dst,    mlib_s32 xsize,    const mlib_u8 *table0,    const mlib_u8 *table1,    const mlib_u8 *table2,    const mlib_u8 *table3){/* aligned pointer to source data */	mlib_u32 *sa;/* pointer to source data */	mlib_u8 *sp;/* source data */	mlib_u32 s0, s1;/* pointer to start of destination */	mlib_u8 *dl;/* pointer to end of destination */	mlib_u8 *dend;/* aligned pointer to destination */	mlib_d64 *dp;/* destination data */	mlib_d64 t0, t1, t2;/* destination data */	mlib_d64 t3, t4, t5;/* destination data */	mlib_d64 t6, t7, acc0, acc1;/* edge mask */	mlib_s32 emask;/* loop variable */	mlib_s32 i, num;	sa = (mlib_u32 *)src;	dl = dst;	dp = (mlib_d64 *)dl;	dend = dl + xsize - 1;	vis_alignaddr((void *)0, 7);	if (xsize >= 8) {		s0 = sa[0];		s1 = sa[1];		sa += 2;		vis_write_bmask(0x012389ab, 0);#pragma pipeloop(0)		for (i = 0; i <= xsize - 16; i += 8, sa += 2) {			t7 = VIS_LD_U8_I(table3, s1 & 0xFF);			t6 = VIS_LD_U8_I(table2, (s1 >> 8) & 0xFF);			t5 = VIS_LD_U8_I(table1, (s1 >> 16) & 0xFF);			t4 = VIS_LD_U8_I(table0, s1 >> 24);			t3 = VIS_LD_U8_I(table3, s0 & 0xFF);			t2 = VIS_LD_U8_I(table2, (s0 >> 8) & 0xFF);			t1 = VIS_LD_U8_I(table1, (s0 >> 16) & 0xFF);			t0 = VIS_LD_U8_I(table0, s0 >> 24);			acc1 = vis_faligndata(t7, acc1);			acc1 = vis_faligndata(t6, acc1);			acc1 = vis_faligndata(t5, acc1);			acc1 = vis_faligndata(t4, acc1);			acc0 = vis_faligndata(t3, acc0);			acc0 = vis_faligndata(t2, acc0);			acc0 = vis_faligndata(t1, acc0);			acc0 = vis_faligndata(t0, acc0);			s0 = sa[0];			s1 = sa[1];			(*dp++) = vis_bshuffle(acc0, acc1);		}		t7 = VIS_LD_U8_I(table3, s1 & 0xFF);		t6 = VIS_LD_U8_I(table2, (s1 >> 8) & 0xFF);		t5 = VIS_LD_U8_I(table1, (s1 >> 16) & 0xFF);		t4 = VIS_LD_U8_I(table0, s1 >> 24);		t3 = VIS_LD_U8_I(table3, s0 & 0xFF);		t2 = VIS_LD_U8_I(table2, (s0 >> 8) & 0xFF);		t1 = VIS_LD_U8_I(table1, (s0 >> 16) & 0xFF);		t0 = VIS_LD_U8_I(table0, s0 >> 24);		acc1 = vis_faligndata(t7, acc1);		acc1 = vis_faligndata(t6, acc1);		acc1 = vis_faligndata(t5, acc1);		acc1 = vis_faligndata(t4, acc1);		acc0 = vis_faligndata(t3, acc0);		acc0 = vis_faligndata(t2, acc0);		acc0 = vis_faligndata(t1, acc0);		acc0 = vis_faligndata(t0, acc0);		(*dp++) = vis_bshuffle(acc0, acc1);	}

mlib_status__mlib_VectorConvert_S32_S16_Mod(	mlib_s32 *z,	const mlib_s16 *x,	mlib_s32 n){	mlib_s32 i;	const mlib_s16 *src = x;	mlib_s32 *dst = z;	mlib_d64 *ddsrc, *ddst;	mlib_s32 len_64, even_length, rest_64, length = n;	mlib_d64 dd1, dd2, dd3, dd4;	mlib_f32 two_16_ones = vis_to_float(0x10001);	if (length < 16) {		EXPAND(mlib_s16, mlib_s32);	}	while ((mlib_addr)dst & 7) {		(*dst++) = (*src++);		length--;	}	ddsrc = (mlib_d64 *)vis_alignaddr((void *)src, 0);	ddst = (mlib_d64 *)dst;	rest_64 = length & 3;	len_64 = length >> 2;	even_length = len_64 << 2;	dd2 = ddsrc[0];	if (!((mlib_addr)(src) & 7)) {/* * Source vector is 64-bit aligned. We can process it without * vis_faligndata. * Peeling of 1 iteration. */		if (i = (len_64 & 1)) {			dd3 = (*ddsrc++);/* * Now obtaining of the 4*32 - signed objects */			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_hi(dd3));			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_lo(dd3));		}#pragma pipeloop(1)#pragma unroll(1)		for (; i < len_64; i += 2) {			dd3 = (*ddsrc++);			dd4 = (*ddsrc++);/* * Now obtaining of the 4*32 - signed objects */			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_hi(dd3));			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_lo(dd3));/* * Now obtaining of the 4*32 - signed objects */			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_hi(dd4));			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_lo(dd4));		}	} else {/* * Source vector is not 64-bit aligned. Use vis_faligndata. * Peeling of 1 iteration. */		i = 1;		if ((len_64 & 1)) {			i++;			dd1 = dd2;			dd2 = vis_ld_d64_nf(ddsrc + 1);			dd3 = vis_faligndata(dd1, dd2);/* * Now obtaining of the 4*32 - signed objects */			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_hi(dd3));			(*ddst++) =				vis_fmuld8ulx16(two_16_ones, vis_read_lo(dd3));		}/* * Now loop with step == 2. */#pragma pipeloop(1)#pragma unroll(1)		for (; i <= len_64; i += 2) {			dd1 = dd2;//.........这里部分代码省略.........

mlib_status__mlib_VectorConvert_S32_S8_Mod(	mlib_s32 *z,	const mlib_s8 *x,	mlib_s32 n){	mlib_s8 *psrc = (mlib_s8 *)x;	mlib_s32 *pdst = (mlib_s32 *)z;	mlib_f32 fone = vis_to_float(0x10001);	mlib_d64 *dpsrc, dsrc0, dsrc1, dsrc, dst0, dst1, dst2, dst3, done =		vis_to_double_dup(0x1000100);	mlib_s32 i = 0;	if (n <= 0)		return (MLIB_FAILURE);	if ((mlib_addr)pdst & 7) {		(*pdst++) = (*psrc++);		i = 1;	}	dpsrc = (mlib_d64 *)vis_alignaddr(psrc, 0);	dsrc = vis_ld_d64_nf(dpsrc);	vis_write_bmask(0x00012223, 0);	if ((mlib_addr)psrc & 7) {		dsrc1 = vis_ld_d64_nf(dpsrc + 1);		dsrc = vis_faligndata(dsrc, dsrc1);#pragma pipeloop(1)#pragma unroll(1)		for (; i <= (n - 8); i += 8) {			dst1 = vis_fpmerge(vis_read_hi(dsrc),				vis_read_hi(dsrc));			dst1 = vis_fmul8sux16(dst1, done);			dst0 = vis_bshuffle(dst1, dst1);			dst1 = vis_fmuld8ulx16(fone, vis_read_lo(dst1));			dst3 = vis_fpmerge(vis_read_lo(dsrc),				vis_read_lo(dsrc));			dst3 = vis_fmul8sux16(dst3, done);			dst2 = vis_fmuld8ulx16(fone, vis_read_hi(dst3));			dst3 = vis_fmuld8ulx16(fone, vis_read_lo(dst3));			dsrc0 = dsrc1;			dsrc1 = vis_ld_d64_nf(dpsrc + 2);			dsrc = vis_faligndata(dsrc0, dsrc1);			((mlib_d64 *)pdst)[0] = dst0;			((mlib_d64 *)pdst)[1] = dst1;			((mlib_d64 *)pdst)[2] = dst2;			((mlib_d64 *)pdst)[3] = dst3;			pdst += 8;			psrc += 8;			dpsrc++;		}	} else {#pragma pipeloop(1)#pragma unroll(1)		for (; i <= (n - 8); i += 8) {			dst1 = vis_fpmerge(vis_read_hi(dsrc),				vis_read_hi(dsrc));			dst1 = vis_fmul8sux16(dst1, done);			dst0 = vis_bshuffle(dst1, dst1);			dst1 = vis_fmuld8ulx16(fone, vis_read_lo(dst1));			dst3 = vis_fpmerge(vis_read_lo(dsrc),				vis_read_lo(dsrc));			dst3 = vis_fmul8sux16(dst3, done);			dst2 = vis_bshuffle(dst3, dst3);			dst3 = vis_fmuld8ulx16(fone, vis_read_lo(dst3));			dsrc = vis_ld_d64_nf(dpsrc + 1);			((mlib_d64 *)pdst)[0] = dst0;			((mlib_d64 *)pdst)[1] = dst1;			((mlib_d64 *)pdst)[2] = dst2;			((mlib_d64 *)pdst)[3] = dst3;			pdst += 8;			psrc += 8;			dpsrc++;		}	}	for (; i < n; i++)		(*pdst++) = (*psrc++);	return (MLIB_SUCCESS);}

mlib_status__mlib_VectorConvert_S16_S8_Mod(	mlib_s16 *z,	const mlib_s8 *x,	mlib_s32 n){	mlib_s32 i;	const mlib_s8 *src = x;	mlib_s16 *dst = z;	mlib_d64 *ddsrc, *ddst;	mlib_d64 four_16_ones = vis_to_double_dup(0x01000100);	mlib_f32 fzero = vis_fzeros();	mlib_s32 len_64, even_length, rest_64, length = n, off;	mlib_d64 dd0, dd1, dd2, dd4, dd5, dd6, dd7;	if (length < 16) {		EXPAND(mlib_s8, mlib_s16);	}	while ((mlib_addr)dst & 7) {		(*dst++) = (*src++);		length--;	}	ddsrc = (mlib_d64 *)vis_alignaddr((void *)src, 0);	ddst = (mlib_d64 *)dst;	rest_64 = length & 7;	len_64 = length >> 3;	even_length = len_64 << 3;	dd2 = ddsrc[0];	off = (mlib_addr)src & 7;	if (!off) {/* * Both vectors are 64-bit aligned. *//* * Peeling of 1 iteration. */		if (i = (len_64 & 1)) {			dd1 = (*ddsrc++);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_hi(dd1),				fzero), four_16_ones);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_lo(dd1),				fzero), four_16_ones);		}#pragma pipeloop(0)#pragma unroll(4)		for (; i < len_64; i += 2) {			dd1 = (*ddsrc++);			dd2 = (*ddsrc++);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_hi(dd1),				fzero), four_16_ones);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_lo(dd1),				fzero), four_16_ones);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_hi(dd2),				fzero), four_16_ones);			(*ddst++) =				vis_fmul8sux16(vis_fpmerge(vis_read_lo(dd2),				fzero), four_16_ones);		}	} else {/* * Source vector is not 64-bit aligned. * Peeling of 1 iteration. Then loop with step==2. */		vis_alignaddr((void *)0, 1);		vis_write_bmask(0x11111111 * off, 0x04152637);		i = 1;		if (len_64 & 1) {			dd1 = dd2;			dd2 = vis_ld_d64_nf(ddsrc + 1); i++;			dd4 = vis_bshuffle(dd1, dd2);			dd5 = vis_faligndata(dd4, dd4);			(*ddst++) = vis_fmul8sux16(dd4, four_16_ones);			(*ddst++) = vis_fmul8sux16(dd5, four_16_ones);		}#pragma pipeloop(0)#pragma unroll(4)		for (; i <= len_64; i += 2) {			dd0 = dd2;			dd1 = vis_ld_d64_nf(ddsrc + i);			dd2 = vis_ld_d64_nf(ddsrc + i + 1);			dd4 = vis_bshuffle(dd0, dd1);			dd6 = vis_bshuffle(dd1, dd2);			dd5 = vis_faligndata(dd4, dd4);			dd7 = vis_faligndata(dd6, dd6);			(*ddst++) = vis_fmul8sux16(dd4, four_16_ones);			(*ddst++) = vis_fmul8sux16(dd5, four_16_ones);//.........这里部分代码省略.........

mlib_status__mlib_VectorConvert_S32_U8_Mod(	mlib_s32 *z,	const mlib_u8 *x,	mlib_s32 n){	mlib_u8 *psrc = (mlib_u8 *)x;	mlib_s32 *pdst = (mlib_s32 *)z;	mlib_f32 fzero = vis_fzero(), fone1 = vis_to_float(0x100), fone2 =		vis_to_float(0x10001);	mlib_d64 *dpsrc, dsrc0, dsrc1, dsrc, dst0, dst1, dst2, dst3;	mlib_s32 i = 0, off;	if (n <= 0)		return (MLIB_FAILURE);	if ((mlib_addr)pdst & 7) {		(*pdst++) = (*psrc++);		i = 1;	}	dpsrc = (mlib_d64 *)vis_alignaddr(psrc, 0);	dsrc = dpsrc[0];	off = (mlib_addr)psrc & 7;	if (off) {		dsrc1 = dsrc;		vis_alignaddr((void *)0, 7);		vis_write_bmask(0x11111111 * off, 0x40516273);#pragma pipeloop(0)#pragma unroll(2)		for (; i <= (n - 8); i += 8) {			dsrc0 = dsrc1;			dsrc1 = vis_ld_d64_nf(dpsrc + 1);			dsrc = vis_bshuffle(dsrc0, dsrc1);			dst0 = vis_fmuld8ulx16(vis_read_hi(dsrc), fone2);			dst1 = vis_fmuld8ulx16(vis_read_lo(dsrc), fone2);			dsrc = vis_faligndata(dsrc, dsrc);			dst2 = vis_fmuld8ulx16(vis_read_hi(dsrc), fone2);			dst3 = vis_fmuld8ulx16(vis_read_lo(dsrc), fone2);			((mlib_d64 *)pdst)[0] = dst0;			((mlib_d64 *)pdst)[1] = dst1;			((mlib_d64 *)pdst)[2] = dst2;			((mlib_d64 *)pdst)[3] = dst3;			pdst += 8;			psrc += 8;			dpsrc++;		}	} else {#pragma pipeloop(1)#pragma unroll(1)		for (; i <= (n - 8); i += 8) {			dst1 = vis_fmul8x16al(vis_read_hi(dsrc), fone1);			dst0 = vis_fpmerge(fzero, vis_read_hi(dst1));			dst1 = vis_fpmerge(fzero, vis_read_lo(dst1));			dst3 = vis_fpmerge(vis_read_lo(dsrc),				vis_read_lo(dsrc));			dst2 = vis_fmuld8ulx16(vis_read_hi(dst3), fone2);			dst3 = vis_fmuld8ulx16(vis_read_lo(dst3), fone2);			dsrc = vis_ld_d64_nf(dpsrc + 1);			((mlib_d64 *)pdst)[0] = dst0;			((mlib_d64 *)pdst)[1] = dst1;			((mlib_d64 *)pdst)[2] = dst2;			((mlib_d64 *)pdst)[3] = dst3;			pdst += 8;			psrc += 8;			dpsrc++;		}	}	for (; i < n; i++)		(*pdst++) = (*psrc++);	return (MLIB_SUCCESS);}

void mlib_v_ImageLookUpSI_S16_U16_3_D1(const mlib_s16 *src,                                       mlib_u16       *dst,                                       mlib_s32       xsize,                                       const mlib_u16 **table){  mlib_s16 *sp;              /* pointer to source data */  mlib_u16 *dl;              /* pointer to start of destination */  mlib_d64 *dp;              /* aligned pointer to destination */  mlib_d64 t0, t1, t2, t3;   /* destination data */  mlib_d64 acc0, acc1, acc2; /* destination data */  mlib_s32 i;                /* loop variable */  const mlib_u16 *tab0 = &table[0][32768];  const mlib_u16 *tab1 = &table[1][32768];  const mlib_u16 *tab2 = &table[2][32768];  mlib_s32 s00, s01, s02, s03;  sp   = (void *)src;  dl   = dst;  dp   = (mlib_d64 *) dl;  vis_alignaddr((void *) 0, 6);  i = 0;  if (xsize >= 4) {    s00 = (sp[0] << 1);    s01 = (sp[1] << 1);    s02 = (sp[2] << 1);    s03 = (sp[3] << 1);    sp += 4;#pragma pipeloop(0)    for(i = 0; i <= xsize - 8; i+=4, sp+=4) {      t3 = VIS_LD_U16_I(tab0, s01);      t2 = VIS_LD_U16_I(tab2, s00);      t1 = VIS_LD_U16_I(tab1, s00);      t0 = VIS_LD_U16_I(tab0, s00);      acc0 = vis_faligndata(t3, acc0);      acc0 = vis_faligndata(t2, acc0);      acc0 = vis_faligndata(t1, acc0);      acc0 = vis_faligndata(t0, acc0);      t3 = VIS_LD_U16_I(tab1, s02);      t2 = VIS_LD_U16_I(tab0, s02);      t1 = VIS_LD_U16_I(tab2, s01);      t0 = VIS_LD_U16_I(tab1, s01);      acc1 = vis_faligndata(t3, acc1);      acc1 = vis_faligndata(t2, acc1);      acc1 = vis_faligndata(t1, acc1);      acc1 = vis_faligndata(t0, acc1);      t3 = VIS_LD_U16_I(tab2, s03);      t2 = VIS_LD_U16_I(tab1, s03);      t1 = VIS_LD_U16_I(tab0, s03);      t0 = VIS_LD_U16_I(tab2, s02);      acc2 = vis_faligndata(t3, acc2);      acc2 = vis_faligndata(t2, acc2);      acc2 = vis_faligndata(t1, acc2);      acc2 = vis_faligndata(t0, acc2);      s00 = (sp[0] << 1);      s01 = (sp[1] << 1);      s02 = (sp[2] << 1);      s03 = (sp[3] << 1);      *dp++ = acc0;      *dp++ = acc1;      *dp++ = acc2;    }    t3 = VIS_LD_U16_I(tab0, s01);    t2 = VIS_LD_U16_I(tab2, s00);    t1 = VIS_LD_U16_I(tab1, s00);    t0 = VIS_LD_U16_I(tab0, s00);    acc0 = vis_faligndata(t3, acc0);    acc0 = vis_faligndata(t2, acc0);    acc0 = vis_faligndata(t1, acc0);    acc0 = vis_faligndata(t0, acc0);    t3 = VIS_LD_U16_I(tab1, s02);    t2 = VIS_LD_U16_I(tab0, s02);    t1 = VIS_LD_U16_I(tab2, s01);    t0 = VIS_LD_U16_I(tab1, s01);    acc1 = vis_faligndata(t3, acc1);    acc1 = vis_faligndata(t2, acc1);    acc1 = vis_faligndata(t1, acc1);    acc1 = vis_faligndata(t0, acc1);    t3 = VIS_LD_U16_I(tab2, s03);    t2 = VIS_LD_U16_I(tab1, s03);    t1 = VIS_LD_U16_I(tab0, s03);    t0 = VIS_LD_U16_I(tab2, s02);    acc2 = vis_faligndata(t3, acc2);    acc2 = vis_faligndata(t2, acc2);    acc2 = vis_faligndata(t1, acc2);    acc2 = vis_faligndata(t0, acc2);    *dp++ = acc0;    *dp++ = acc1;    *dp++ = acc2;    i += 4;  }  dl = (mlib_u16*)dp;#pragma pipeloop(0)//.........这里部分代码省略.........

voidmlib_v_VideoColorYUV2RGB444_all_align(	mlib_u8 *rgb,	const mlib_u8 *y,	const mlib_u8 *u,	const mlib_u8 *v,	mlib_s32 size){	mlib_u8 *dend;	mlib_f32 *sf0, *sf1, *sf2, *pfd, fzero = vis_fzeros();	mlib_s32 i, n, m, emask;	mlib_d64 *buff2, pbuff_arr2[BUFF_SIZE + 4];	mlib_d64 tmp_arr64[2];	mlib_d64 k01 = vis_to_double_dup(0x0000f375);	mlib_d64 k02 = vis_to_double_dup(0x3317e5fa);	mlib_d64 k11 = vis_to_double_dup(0xf3754097);	mlib_d64 k12 = vis_to_double_dup(0xe5fa0000);	mlib_d64 k21 = vis_to_double_dup(0x40970000);	mlib_d64 k22 = vis_to_double_dup(0x00003317);	mlib_d64 c_0 = vis_to_double_dup(0xe42010f4);	mlib_d64 c_1 = vis_to_double_dup(0x10f4dd60);	mlib_d64 c_2 = vis_to_double_dup(0xdd60e420);	mlib_d64 k_0 = vis_to_double_dup(0x25432543);	do {/* loop on buffer size */		if (size > 2 * BUFF_SIZE) {			n = 2 * BUFF_SIZE;		} else {			n = size;		}		m = n >> 2;		buff2 = pbuff_arr2;		sf0 = (mlib_f32 *)y;		sf1 = (mlib_f32 *)u;		sf2 = (mlib_f32 *)v;		dend = rgb + 3 * n - 1;		pfd = (mlib_f32 *)rgb;#pragma pipeloop(0)		for (i = 0; i < m; i++) {			mlib_d64 s00, s01, s02, s10, s11, s12, s20, s21, s22,				s_0;			mlib_f32 x0, x1, x2;			mlib_d64 d_0235, d_xx14, d_23xx, d_0145;			x0 = (*sf0++);			x1 = (*sf1++);			x2 = (*sf2++);			s_0 = vis_fmul8x16(x0, k_0);			s01 = vis_fmul8x16(x1, k01);			s11 = vis_fmul8x16(x1, k11);			s21 = vis_fmul8x16(x1, k21);			s02 = vis_fmul8x16(x2, k02);			s12 = vis_fmul8x16(x2, k12);			s22 = vis_fmul8x16(x2, k22);			s00 = vis_fpadd16(s_0, s01);			s10 = vis_fpadd16(s_0, s11);			s20 = vis_fpadd16(s_0, s21);			s02 = vis_fpadd16(s02, c_0);			s12 = vis_fpadd16(s12, c_1);			s22 = vis_fpadd16(s22, c_2);			s00 = vis_fpadd16(s00, s02);			s10 = vis_fpadd16(s10, s12);			s20 = vis_fpadd16(s20, s22);			d_0235 = vis_fpmerge(vis_fpack16(s00),				vis_fpack16(s10));			d_xx14 = vis_freg_pair(fzero, vis_fpack16(s20));/* * merge buff values to 3-channel array */			d_23xx = vis_faligndata(d_0235, d_0235);			d_0145 = vis_bshuffle(d_0235, d_xx14);			pfd[0] = vis_read_hi(d_0145);			pfd[1] = vis_read_hi(d_23xx);			pfd[2] = vis_read_lo(d_0145);			buff2 += 2;			pfd += 3;		}		if ((mlib_u8 *)pfd <= dend) {			mlib_d64 d_0235, d_xx14, d_23xx, d_0145;			mlib_f32 *tmp_arr32 = (mlib_f32 *)tmp_arr64;			mlib_d64 s00, s01, s02, s10, s11, s12, s20, s21, s22,				s_0;			mlib_f32 x0, x1, x2;			x0 = (*sf0++);//.........这里部分代码省略.........

void mlib_v_ImageLookUpSI_U16_U8_2_DstA8D1(const mlib_u16 *src,                                           mlib_u8        *dst,                                           mlib_s32       xsize,                                           const mlib_u8  **table){  mlib_u16 *sp;                        /* pointer to source data */  mlib_s32 s0, s1, s2, s3;             /* source data */  mlib_u16 *dl;                        /* pointer to start of destination */  mlib_u16 *dend;                      /* pointer to end of destination */  mlib_d64 *dp;                        /* aligned pointer to destination */  mlib_d64 t0, t1, t2;                 /* destination data */  mlib_d64 t3, t4, t5;                 /* destination data */  mlib_d64 t6, t7, acc;                /* destination data */  mlib_s32 emask;                      /* edge mask */  mlib_s32 i, num;                     /* loop variable */  const mlib_u8 *tab0 = &table[0][0];  const mlib_u8 *tab1 = &table[1][0];  sp = (void *)src;  dl = (mlib_u16 *) dst;  dp = (mlib_d64 *) dl;  dend = dl + xsize - 1;  vis_alignaddr((void *)0, 7);  if (xsize >= 4) {    s0 = sp[0];    s1 = sp[1];    s2 = sp[2];    s3 = sp[3];    sp += 4;#pragma pipeloop(0)    for (i = 0; i <= xsize - 8; i += 4, sp += 4) {      t7 = VIS_LD_U8_I(tab1, s3);      t6 = VIS_LD_U8_I(tab0, s3);      t5 = VIS_LD_U8_I(tab1, s2);      t4 = VIS_LD_U8_I(tab0, s2);      t3 = VIS_LD_U8_I(tab1, s1);      t2 = VIS_LD_U8_I(tab0, s1);      t1 = VIS_LD_U8_I(tab1, s0);      t0 = VIS_LD_U8_I(tab0, s0);      acc = vis_faligndata(t7, acc);      acc = vis_faligndata(t6, acc);      acc = vis_faligndata(t5, acc);      acc = vis_faligndata(t4, acc);      acc = vis_faligndata(t3, acc);      acc = vis_faligndata(t2, acc);      acc = vis_faligndata(t1, acc);      acc = vis_faligndata(t0, acc);      s0 = sp[0];      s1 = sp[1];      s2 = sp[2];      s3 = sp[3];      *dp++ = acc;    }    t7 = VIS_LD_U8_I(tab1, s3);    t6 = VIS_LD_U8_I(tab0, s3);    t5 = VIS_LD_U8_I(tab1, s2);    t4 = VIS_LD_U8_I(tab0, s2);    t3 = VIS_LD_U8_I(tab1, s1);    t2 = VIS_LD_U8_I(tab0, s1);    t1 = VIS_LD_U8_I(tab1, s0);    t0 = VIS_LD_U8_I(tab0, s0);    acc = vis_faligndata(t7, acc);    acc = vis_faligndata(t6, acc);    acc = vis_faligndata(t5, acc);    acc = vis_faligndata(t4, acc);    acc = vis_faligndata(t3, acc);    acc = vis_faligndata(t2, acc);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    *dp++ = acc;  }  if ((mlib_addr) dp <= (mlib_addr) dend) {    num = (mlib_u16 *) dend - (mlib_u16 *) dp;    sp += num;    num++;#pragma pipeloop(0)    for (i = 0; i < num; i++) {      s0 = (mlib_s32) * sp;      sp--;      t0 = VIS_LD_U8_I(tab1, s0);      acc = vis_faligndata(t0, acc);      t0 = VIS_LD_U8_I(tab0, s0);      acc = vis_faligndata(t0, acc);    }    emask = vis_edge16(dp, dend);    vis_pst_16(acc, dp, emask);  }}

void mlib_v_ImageLookUpSI_S16_U16_2_DstA8D1(const mlib_s16 *src,                                            mlib_u16       *dst,                                            mlib_s32       xsize,                                            const mlib_u16 **table){  mlib_s16 *sp;              /* pointer to source data */  mlib_s32 s0, s1;           /* source data */  mlib_u16 *dl;              /* pointer to start of destination */  mlib_d64 *dp;              /* aligned pointer to destination */  mlib_d64 t0, t1, t2;       /* destination data */  mlib_d64 t3, acc;          /* destination data */  mlib_s32 i;                /* loop variable */  const mlib_u16 *tab0 = &table[0][32768];  const mlib_u16 *tab1 = &table[1][32768];  sp   = (void *)src;  dl   = dst;  dp   = (mlib_d64 *) dl;  vis_alignaddr((void *) 0, 6);  if (xsize >= 2) {    s0 = (sp[0] << 1);    s1 = (sp[1] << 1);    sp += 2;#pragma pipeloop(0)    for(i = 0; i <= xsize - 4; i+=2, sp+=2) {      t3 = VIS_LD_U16_I(tab1, s1);      t2 = VIS_LD_U16_I(tab0, s1);      t1 = VIS_LD_U16_I(tab1, s0);      t0 = VIS_LD_U16_I(tab0, s0);      acc = vis_faligndata(t3, acc);      acc = vis_faligndata(t2, acc);      acc = vis_faligndata(t1, acc);      acc = vis_faligndata(t0, acc);      s0 = (sp[0] << 1);      s1 = (sp[1] << 1);      *dp++ = acc;    }    t3 = VIS_LD_U16_I(tab1, s1);    t2 = VIS_LD_U16_I(tab0, s1);    t1 = VIS_LD_U16_I(tab1, s0);    t0 = VIS_LD_U16_I(tab0, s0);    acc = vis_faligndata(t3, acc);    acc = vis_faligndata(t2, acc);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    *dp++ = acc;  }  if ((xsize & 1) != 0) {    s0 = (sp[0] << 1);    t1 = VIS_LD_U16_I(tab1, s0);    t0 = VIS_LD_U16_I(tab0, s0);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    *(mlib_f32*)dp = vis_read_hi(acc);  }}

voidmlib_v_ImageLookUpSI_S32_S16_2_D1(    const mlib_s32 *src,    mlib_s16 *dst,    mlib_s32 xsize,    const mlib_s16 **table){    /* pointer to source data */    mlib_s32 *sp;    /* source data */    mlib_s32 s0, s1, s2;    /* pointer to start of destination */    mlib_s16 *dl;    /* aligned pointer to destination */    mlib_d64 *dp;    /* destination data */    mlib_d64 t0, t1, t2;    /* destination data */    mlib_d64 t3, acc;    /* loop variable */    mlib_s32 i;    const mlib_s16 *tab0 = &table[0][(mlib_u32)2147483648u];    const mlib_s16 *tab1 = &table[1][(mlib_u32)2147483648u];    sp = (void *)src;    dl = dst;    vis_alignaddr((void *)0, 6);    s0 = (*sp++);    (*dl++) = tab0[s0];    dp = (mlib_d64 *)dl;    xsize--;    if (xsize >= 2) {        s1 = sp[0];        s2 = sp[1];        sp += 2;#pragma pipeloop(0)        for (i = 0; i <= xsize - 4; i += 2, sp += 2) {            t3 = VIS_LD_U16_I(tab0, ((mlib_addr)2 * s2));            t2 = VIS_LD_U16_I(tab1, ((mlib_addr)2 * s1));            t1 = VIS_LD_U16_I(tab0, ((mlib_addr)2 * s1));            t0 = VIS_LD_U16_I(tab1, ((mlib_addr)2 * s0));            acc = vis_faligndata(t3, acc);            acc = vis_faligndata(t2, acc);            acc = vis_faligndata(t1, acc);            acc = vis_faligndata(t0, acc);            s0 = s2;            s1 = sp[0];            s2 = sp[1];            (*dp++) = acc;        }        t3 = VIS_LD_U16_I(tab0, ((mlib_addr)2 * s2));        t2 = VIS_LD_U16_I(tab1, ((mlib_addr)2 * s1));        t1 = VIS_LD_U16_I(tab0, ((mlib_addr)2 * s1));        t0 = VIS_LD_U16_I(tab1, ((mlib_addr)2 * s0));        acc = vis_faligndata(t3, acc);        acc = vis_faligndata(t2, acc);        acc = vis_faligndata(t1, acc);        acc = vis_faligndata(t0, acc);        s0 = s2;        (*dp++) = acc;    }    dl = (mlib_s16 *)dp;    if ((xsize & 1) != 0) {        s1 = sp[0];        t1 = VIS_LD_U16_I(tab0, ((mlib_addr)2 * s1));        t0 = VIS_LD_U16_I(tab1, ((mlib_addr)2 * s0));        acc = vis_faligndata(t1, acc);        acc = vis_faligndata(t0, acc);        *(mlib_f32 *)dp = vis_read_hi(acc);        s0 = s1;        dl += 2;    }    *dl = tab1[s0];}

void mlib_v_ImageLookUpSI_U16_U8_4_DstOff3_D1(const mlib_u16 *src,                                              mlib_u8        *dst,                                              mlib_s32       xsize,                                              const mlib_u8  **table){  mlib_u16 *sp;                        /* pointer to source data */  mlib_s32 s0, s1, s2;                 /* source data */  mlib_u8 *dl;                         /* pointer to start of destination */  mlib_d64 *dp;                        /* aligned pointer to destination */  mlib_d64 t0, t1, t2;                 /* destination data */  mlib_d64 t3, t4, t5;                 /* destination data */  mlib_d64 t6, t7, acc;                /* destination data */  mlib_s32 i;                          /* loop variable */  const mlib_u8 *tab0 = &table[0][0];  const mlib_u8 *tab1 = &table[1][0];  const mlib_u8 *tab2 = &table[2][0];  const mlib_u8 *tab3 = &table[3][0];  sp = (void *)src;  dl = dst;  dp = (mlib_d64 *) dl;  vis_alignaddr((void *)0, 7);  s0 = *sp++;  if (xsize >= 2) {    s1 = sp[0];    s2 = sp[1];    sp += 2;#pragma pipeloop(0)    for (i = 0; i <= xsize - 4; i += 2, sp += 2) {      t7 = VIS_LD_U8_I(tab2, s2);      t6 = VIS_LD_U8_I(tab1, s2);      t5 = VIS_LD_U8_I(tab0, s2);      t4 = VIS_LD_U8_I(tab3, s1);      t3 = VIS_LD_U8_I(tab2, s1);      t2 = VIS_LD_U8_I(tab1, s1);      t1 = VIS_LD_U8_I(tab0, s1);      t0 = VIS_LD_U8_I(tab3, s0);      acc = vis_faligndata(t7, acc);      acc = vis_faligndata(t6, acc);      acc = vis_faligndata(t5, acc);      acc = vis_faligndata(t4, acc);      acc = vis_faligndata(t3, acc);      acc = vis_faligndata(t2, acc);      acc = vis_faligndata(t1, acc);      acc = vis_faligndata(t0, acc);      s0 = s2;      s1 = sp[0];      s2 = sp[1];      *dp++ = acc;    }    t7 = VIS_LD_U8_I(tab2, s2);    t6 = VIS_LD_U8_I(tab1, s2);    t5 = VIS_LD_U8_I(tab0, s2);    t4 = VIS_LD_U8_I(tab3, s1);    t3 = VIS_LD_U8_I(tab2, s1);    t2 = VIS_LD_U8_I(tab1, s1);    t1 = VIS_LD_U8_I(tab0, s1);    t0 = VIS_LD_U8_I(tab3, s0);    acc = vis_faligndata(t7, acc);    acc = vis_faligndata(t6, acc);    acc = vis_faligndata(t5, acc);    acc = vis_faligndata(t4, acc);    acc = vis_faligndata(t3, acc);    acc = vis_faligndata(t2, acc);    acc = vis_faligndata(t1, acc);    acc = vis_faligndata(t0, acc);    s0 = s2;    *dp++ = acc;  }  dl = (mlib_u8 *) dp;  if ((xsize & 1) != 0) {    s1 = sp[0];    t7 = VIS_LD_U8_I(tab2, s1);    t6 = VIS_LD_U8_I(tab1, s1);    t5 = VIS_LD_U8_I(tab0, s1);    t4 = VIS_LD_U8_I(tab3, s0);    acc = vis_faligndata(t7, acc);    acc = vis_faligndata(t6, acc);    acc = vis_faligndata(t5, acc);    acc = vis_faligndata(t4, acc);    *(mlib_f32 *) dl = vis_read_hi(acc);    dl += 4;    s0 = s1;  }  dl[0] = tab3[s0];}

mlib_status__mlib_VectorConjRev_S16C_S16C_Sat(	mlib_s16 *zz,	const mlib_s16 *xx,	mlib_s32 n){	mlib_s16 *x = (mlib_s16 *)xx, *z = (mlib_s16 *)zz;	mlib_s16 *src = (mlib_s16 *)x, *dst = (mlib_s16 *)&z[2 * n];	mlib_d64 *dsrc, *ddst;	mlib_d64 d1, d2, d3, d4, dl, dh, d_rest;	mlib_d64 dlog0 = vis_to_double_dup(0x0000ffff), dtwo =		vis_to_double(0, 2);	mlib_f32 f_two = vis_to_float(0x20002);	mlib_s16 c;	mlib_s32 i, rest_64, len_64, even_length, odd = 0, length =		(mlib_s32)n * 2;	mlib_s32 re_part;	CHECK(x, z);	if ((n < 16)) {		CONJREVC(mlib_s16,			MLIB_S16_MAX,			MLIB_S16_MIN);	}	while (((mlib_addr)dst) & 7) {		if ((c = src[1]) == MLIB_S16_MIN)			*--dst = MLIB_S16_MAX;		else			*--dst = -c;		length -= 2;		src += 2;		if (((mlib_addr)dst) & 7) {			*--dst = src[-2];		} else {			re_part = src[-2];			odd = 1;			break;		}	}	vis_write_gsr(15 << 3);	ddst = (mlib_d64 *)dst;	rest_64 = length & 3;	len_64 = length >> 2;	even_length = len_64 << 2;	if (!odd) {/* * Aligning loop finished with imaginary part. The following processing * starts with real part. */		if (!((mlib_addr)src & 7)) {/* * Src address is 8-byte aligned. */			dsrc = (mlib_d64 *)src;#pragma pipeloop(0)			for (i = 0; i < len_64; i++) {				d3 = (*dsrc++);				CONJ16;				*--ddst = d4;			}		} else {			dsrc = (mlib_d64 *)vis_alignaddr(src, 0);			d2 = (*dsrc++);#pragma pipeloop(0)			for (i = 0; i < len_64; i++) {				d1 = d2;				d2 = (*dsrc++);				d3 = vis_faligndata(d1, d2);				CONJ16;				*--ddst = d4;			}		}	} else {/* * Aligning loop finished with real part. Th following processing * starts with imaginary part. */		if (!((mlib_addr)src & 7)) {/* * Src address is 8-byte aligned. */			dsrc = (mlib_d64 *)vis_alignaddr(src, 2);			d_rest = vis_to_double((re_part << 16), 0);//.........这里部分代码省略.........

mlib_status__mlib_VectorConjRev_S8C_S8C_Sat(	mlib_s8 *zz,	const mlib_s8 *xx,	mlib_s32 n){	const mlib_s8 *x = xx;	mlib_s8 *z = zz;	mlib_s8 *src = (mlib_s8 *)x, *dst = z + 2 * (n);	mlib_d64 *dsrc, *ddst;	mlib_d64 d1, d2, d3, d4, dl, dh, d_rest;	mlib_d64 dcntr0 = vis_to_double_dup(0x00800080);	mlib_d64 dxor0 = vis_to_double_dup(0x007f007f);	mlib_d64 done = vis_to_double_dup(1);	mlib_s8 c;	mlib_s32 i, rest_64, len_64, even_length, odd = 0, length =		(mlib_s32)n * 2;	mlib_s32 re_part;	mlib_f32 f_null = vis_to_float(0);	CHECK(x, z);	if (n < 8) {		CONJREVC(mlib_s8,			MLIB_S8_MAX,			MLIB_S8_MIN);	}	while (((mlib_addr)dst) & 7) {		if ((c = src[1]) == MLIB_S8_MIN)			*--dst = MLIB_S8_MAX;		else			*--dst = -c;		length -= 2;		src += 2;		if (((mlib_addr)dst) & 7) {			*--dst = src[-2];		} else {			re_part = src[-2];			odd = 1;			break;		}	}	vis_write_gsr(7 << 3);	ddst = (mlib_d64 *)dst;	rest_64 = length & 7;	len_64 = length >> 3;	even_length = len_64 << 3;	if (!odd) {/* * Aligning loop finished with imaginary part. The following processing * starts with real part. */		if (!((mlib_addr)src & 7)) {/* * Src address is 8-byte aligned. */			dsrc = (mlib_d64 *)src;#pragma pipeloop(0)			for (i = 0; i < len_64; i++) {				d3 = (*dsrc++);				CONJ8;				*--ddst = d4;			}		} else {			dsrc = (mlib_d64 *)vis_alignaddr(src, 0);			d2 = (*dsrc++);#pragma pipeloop(0)			for (i = 0; i < len_64; i++) {				d1 = d2;				d2 = (*dsrc++);				d3 = vis_faligndata(d1, d2);				CONJ8;				*--ddst = d4;			}		}	} else {/* * Aligning loop finished with real part. Th following processing * starts with imaginary part. */		if (!((mlib_addr)src & 7)) {/* * Src address is 8-byte aligned. *///.........这里部分代码省略.........

voidmlib_v_ImageColorRGB2Mono_U8_D1(    const mlib_u8 *src,    mlib_u8 *dst,    mlib_s32 dsize,    const mlib_d64 *weight){    mlib_u8 *dst_end;    mlib_d64 dd, d0, d1, d2, d3;    mlib_d64 rgdd0, bdd0, rgdd1, bdd1, ddt;    mlib_d64 *src_all, *dp;    mlib_f32 d32, e32, alpha, gamma, beta;    mlib_d64 sd0, sd1, sd2;    mlib_s32 i, emask;    mlib_s32 off;    mlib_s32 mask0 = 0x0369147a;    mlib_s32 mask1 = 0x258b258b;    mlib_s32 mask2 = 0x47ad58be;    mlib_s32 mask3 = 0x69cf69cf;    /* prepare the weight */    alpha = vis_to_float(weight[0] * 8192);    beta = vis_to_float(weight[1] * 8192);    gamma = vis_to_float(weight[2] * 8192);    vis_write_gsr(2 << 3);    dp = (mlib_d64 *)((mlib_addr)dst & (~7));    off = (mlib_addr)dp - (mlib_addr)dst;    dst_end = dst + (dsize - 1);    emask = vis_edge8(dst, dst_end);    src_all = vis_alignaddr((void *)src, (3 * off));    d0 = (*src_all++);    d1 = (*src_all++);    d2 = (*src_all++);    d3 = (*src_all++);    sd0 = vis_faligndata(d0, d1);    sd1 = vis_faligndata(d1, d2);    sd2 = vis_faligndata(d2, d3);    CHANNELSEPARATE_U8(sd0, sd1, sd2, rgdd0, bdd0, rgdd1, bdd1);    CHANNELWEIGHT_U8(rgdd0, bdd0, rgdd1, bdd1, dd);    vis_pst_8(dd, dp, emask);    dp++;#pragma pipeloop(0)    for (i = 8 + off; i <= (dsize - 8); i += 8) {        d0 = d3;        d1 = (*src_all++);        d2 = (*src_all++);        d3 = (*src_all++);        sd0 = vis_faligndata(d0, d1);        sd1 = vis_faligndata(d1, d2);        sd2 = vis_faligndata(d2, d3);        CHANNELSEPARATE_U8(sd0, sd1, sd2, rgdd0, bdd0, rgdd1, bdd1);        CHANNELWEIGHT_U8(rgdd0, bdd0, rgdd1, bdd1, dd);        (*dp++) = dd;    }    if ((mlib_addr)dp <= (mlib_addr)dst_end) {        emask = vis_edge8(dp, dst_end);        d0 = d3;        d1 = (*src_all++);        d2 = (*src_all++);        d3 = (*src_all++);        sd0 = vis_faligndata(d0, d1);        sd1 = vis_faligndata(d1, d2);        sd2 = vis_faligndata(d2, d3);        CHANNELSEPARATE_U8(sd0, sd1, sd2, rgdd0, bdd0, rgdd1, bdd1);        CHANNELWEIGHT_U8(rgdd0, bdd0, rgdd1, bdd1, dd);        vis_pst_8(dd, dp, emask);    }}

static mlib_statusmlib_v_VideoColorYUV2RGB444_nonalign(	mlib_u8 *rgb,	const mlib_u8 *y,	const mlib_u8 *u,	const mlib_u8 *v,	mlib_s32 width,	mlib_s32 height,	mlib_s32 rgb_stride,	mlib_s32 yuv_stride){/* all. pointer to y, u, v */	mlib_d64 *spy, *dfu, *dfv;/* y data */	mlib_d64 dy0, dy1, dy3;	mlib_d64 du, dv, du0, du1, dv0, dv1;/* (1.1644, 1.5966)*8192 */	mlib_f32 k12 = vis_to_float(0x25433317);/* (-.3920, -.8132)*8192 */	mlib_f32 k34 = vis_to_float(0xf375e5fa);/* 2.0184*8192 */	mlib_f32 k5 = vis_to_float(0x1004097);	mlib_d64 k_222_9952 = vis_to_double_dup(0x1be01be0);	mlib_d64 k_135_6352 = vis_to_double_dup(0x10f410f4);	mlib_d64 k_276_9856 = vis_to_double_dup(0x22a022a0);	mlib_d64 u_3920_hi, u_20184_hi, v_15966_hi, v_8132_hi;	mlib_d64 u_3920_lo, u_20184_lo, v_15966_lo, v_8132_lo;	mlib_d64 y_11644_hi, y_11644_lo;	mlib_d64 r_hi, r_lo, g_hi, g_lo, b_hi, b_lo;	mlib_d64 red, green, blue, *ddp, dd0, dd1, dd2;/* loop variable */	mlib_s32 i, j;	mlib_d64 *buf, BUFF[16 * 1024];	mlib_u8 *tmp, *dp;	if (width * 3 > 16 * 1024) {		tmp = __mlib_malloc(width * 3 * sizeof (mlib_u8) + 7);		if (tmp == NULL)			return (MLIB_FAILURE);		buf = (mlib_d64 *)((mlib_addr)(tmp + 7) & ~7);	} else {		buf = (mlib_d64 *)BUFF;	}	dp = (mlib_u8 *)buf;	ddp = (mlib_d64 *)dp;	for (j = 0; j < height; j++) {		dfu = (mlib_d64 *)vis_alignaddr((void *)u, 0);		du0 = (*dfu++);		du1 = vis_ld_d64_nf(dfu); dfu++;		du = vis_faligndata(du0, du1);		du0 = du1;		dfv = (mlib_d64 *)vis_alignaddr((void *)v, 0);		dv0 = (*dfv++);		dv1 = vis_ld_d64_nf(dfv); dfv++;		dv = vis_faligndata(dv0, dv1);		dv0 = dv1;/* U*(-0.3920); */		u_3920_hi = vis_fmul8x16au(vis_read_hi(du), k34);/* V*(-0.8132); */		v_8132_hi = vis_fmul8x16al(vis_read_hi(dv), k34);/* U*(-0.3920); */		u_3920_lo = vis_fmul8x16au(vis_read_lo(du), k34);/* V*(-0.8132); */		v_8132_lo = vis_fmul8x16al(vis_read_lo(dv), k34);		spy = (mlib_d64 *)vis_alignaddr((void *)y, 0);		dy0 = (*spy++);		dy3 = vis_ld_d64_nf(spy); spy++;		dy1 = vis_faligndata(dy0, dy3);		dy0 = dy3;/* U*2.0184 */		u_20184_hi = vis_fmul8x16al(vis_read_hi(du), k5);		g_hi = vis_fpadd16(u_3920_hi, v_8132_hi);		u_20184_lo = vis_fmul8x16al(vis_read_lo(du), k5);		g_hi = vis_fpadd16(g_hi, k_135_6352);/* V*1.5966 */		v_15966_hi = vis_fmul8x16al(vis_read_hi(dv), k12);		g_lo = vis_fpadd16(u_3920_lo, v_8132_lo);		v_15966_lo = vis_fmul8x16al(vis_read_lo(dv), k12);		g_lo = vis_fpadd16(g_lo, k_135_6352);		vis_alignaddr((void *)u, 0);		du1 = vis_ld_d64_nf(dfu); dfu++;		du = vis_faligndata(du0, du1);		du0 = du1;//.........这里部分代码省略.........

voidmlib_v_ImageLookUpSI_U16_S16_2_D1(    const mlib_u16 *src,    mlib_s16 *dst,    mlib_s32 xsize,    const mlib_s16 **table){/* pointer to source data */	mlib_u16 *sp;/* source data */	mlib_s32 s0, s1, s2;/* pointer to start of destination */	mlib_s16 *dl;/* aligned pointer to destination */	mlib_d64 *dp;/* destination data */	mlib_d64 t0, t1, t2;/* destination data */	mlib_d64 t3, acc0;/* loop variable */	mlib_s32 i;	const mlib_s16 *tab0 = &table[0][0];	const mlib_s16 *tab1 = &table[1][0];/* destination data */	mlib_d64 acc1;	sp = (void *)src;	dl = dst;	vis_alignaddr((void *)0, 6);	s0 = (*sp++);	(*dl++) = tab0[s0];	dp = (mlib_d64 *)dl;	xsize--;	s0 <<= 1;	if (xsize >= 2) {		s1 = (sp[0] << 1);		s2 = (sp[1] << 1);		sp += 2;		vis_write_bmask(0x012389ab, 0);#pragma pipeloop(0)		for (i = 0; i <= xsize - 4; i += 2, sp += 2) {			t3 = VIS_LD_U16_I(tab0, s2);			t2 = VIS_LD_U16_I(tab1, s1);			t1 = VIS_LD_U16_I(tab0, s1);			t0 = VIS_LD_U16_I(tab1, s0);			acc1 = vis_faligndata(t3, acc1);			acc1 = vis_faligndata(t2, acc1);			acc0 = vis_faligndata(t1, acc0);			acc0 = vis_faligndata(t0, acc0);			s0 = s2;			s1 = (sp[0] << 1);			s2 = (sp[1] << 1);			(*dp++) = vis_bshuffle(acc0, acc1);		}		t3 = VIS_LD_U16_I(tab0, s2);		t2 = VIS_LD_U16_I(tab1, s1);		t1 = VIS_LD_U16_I(tab0, s1);		t0 = VIS_LD_U16_I(tab1, s0);		acc1 = vis_faligndata(t3, acc1);		acc1 = vis_faligndata(t2, acc1);		acc0 = vis_faligndata(t1, acc0);		acc0 = vis_faligndata(t0, acc0);		s0 = s2;		(*dp++) = vis_bshuffle(acc0, acc1);	}	dl = (mlib_s16 *)dp;	if ((xsize & 1) != 0) {		s1 = (sp[0] << 1);		t1 = VIS_LD_U16_I(tab0, s1);		t0 = VIS_LD_U16_I(tab1, s0);		acc0 = vis_faligndata(t1, acc0);		acc0 = vis_faligndata(t0, acc0);		*(mlib_f32 *)dp = vis_read_hi(acc0);		s0 = s1;		dl += 2;	}	s0 >>= 1;	*dl = tab1[s0];}

mlib_status__mlib_VectorConvert_S16_U8_Mod(	mlib_s16 *z,	const mlib_u8 *x,	mlib_s32 n){	mlib_s32 i;	const mlib_u8 *src = x;	mlib_s16 *dst = z;	mlib_d64 *ddsrc, *ddst;	mlib_s32 len_64, even_length, rest_64, length = n;	mlib_f32 fzero = vis_fzeros();	mlib_d64 dd1, dd2, dd3, dd4;	mlib_f32 fm = vis_to_float(0x100);	if (length < 16) {		EXPAND(mlib_u8, mlib_s16);	}	while ((mlib_addr)dst & 7) {		(*dst++) = (*src++);		length--;	}	ddsrc = (mlib_d64 *)vis_alignaddr((void *)src, 0);	ddst = (mlib_d64 *)dst;	rest_64 = length & 7;	len_64 = length >> 3;	even_length = len_64 << 3;	dd2 = ddsrc[0];	if (!((mlib_addr)src & 7)) {/* * Both vectors are 64-bit aligned. We can process without * vis_faligndata * Peeling the 1 iteration. Then loop with step==2. */		if (i = (len_64 & 1)) {			dd1 = (*ddsrc++);			(*ddst++) = vis_fpmerge(fzero, vis_read_hi(dd1));			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd1));		}#pragma pipeloop(1)#pragma unroll(1)		for (; i < len_64; i += 2) {			dd1 = (*ddsrc++);			dd2 = (*ddsrc++);			(*ddst++) = vis_fmul8x16al(vis_read_hi(dd1), fm);			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd1));			(*ddst++) = vis_fmul8x16al(vis_read_hi(dd2), fm);			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd2));		}	} else {/* * Source vector is not 64-bit aligned. Use vis_faligndata. * Peeling the 1 iteration. Then loop with step==2. */		i = 1;		if (len_64 & 1) {			dd1 = dd2;			dd2 = vis_ld_d64_nf(ddsrc + 1); i++;			dd3 = vis_faligndata(dd1, dd2);			(*ddst++) = vis_fpmerge(fzero, vis_read_hi(dd3));			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd3));		}#pragma pipeloop(0)#pragma unroll(2)		for (; i <= len_64; i += 2) {			dd1 = dd2;			dd2 = vis_ld_d64_nf(ddsrc + i);			dd3 = vis_faligndata(dd1, dd2);			dd1 = dd2;			dd2 = vis_ld_d64_nf(ddsrc + i + 1);			dd4 = vis_faligndata(dd1, dd2);			(*ddst++) = vis_fmul8x16al(vis_read_hi(dd3), fm);			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd3));			(*ddst++) = vis_fmul8x16al(vis_read_hi(dd4), fm);			(*ddst++) = vis_fpmerge(fzero, vis_read_lo(dd4));		}	}	for (i = 0; i < rest_64; i++)		dst[even_length + i] = src[even_length + i];	return (MLIB_SUCCESS);}

mlib_status__mlib_VideoInterpX_U8_U8(	mlib_u8 *curr_block,	const mlib_u8 *ref_block,	mlib_s32 width,	mlib_s32 height,	mlib_s32 frame_stride,	mlib_s32 field_stride){	mlib_d64 s0, s1, s2, s3, s4, s5, s6, s7, d0, d1, d2, d3, *sd, *dd;	mlib_d64 dzero = vis_fzero();	const mlib_f32 fm1 = vis_to_float(0x100);	mlib_f32 fzero = vis_read_hi(dzero);	mlib_d64 rounder = vis_fone();	mlib_s32 y;	vis_write_gsr((6 << 3) + ((mlib_u32)ref_block & 7));	dd = (mlib_d64 *)curr_block;	sd = (mlib_d64 *)((mlib_addr)ref_block & ~7);	if (width == 8) {		y = height >> 2;		if (((mlib_s32)(ref_block + 1) & 7)) {			do {				s0 = sd[0];				s1 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d0 = vis_faligndata(s0, s1);				s2 = sd[0];				s3 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d1 = vis_faligndata(s2, s3);				s4 = sd[0];				s5 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d2 = vis_faligndata(s4, s5);				s6 = sd[0];				s7 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d3 = vis_faligndata(s6, s7);				vis_alignaddr((void *)(ref_block + 1), 0);				s0 = vis_faligndata(s0, s1);				s1 = vis_faligndata(s2, s3);				s2 = vis_faligndata(s4, s5);				s3 = vis_faligndata(s6, s7);				MLIB_V_VIDEOINTERP(d0, d0, s0);				MLIB_V_VIDEOINTERP(d1, d1, s1);				MLIB_V_VIDEOINTERP(d2, d2, s2);				MLIB_V_VIDEOINTERP4(d3, d3, s3);				*dd = d0;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d1;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d2;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d3;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				vis_alignaddr((void *)ref_block, 0);			} while (--y);		} else {			do {				s0 = sd[0];				s1 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d0 = vis_faligndata(s0, s1);				s2 = sd[0];				s3 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d1 = vis_faligndata(s2, s3);				s4 = sd[0];				s5 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d2 = vis_faligndata(s4, s5);				s6 = sd[0];				s7 = sd[1];				sd = (mlib_d64 *)((mlib_u8 *)sd + field_stride);				d3 = vis_faligndata(s6, s7);				MLIB_V_VIDEOINTERP4(d0, d0, s1);				MLIB_V_VIDEOINTERP4(d1, d1, s3);				MLIB_V_VIDEOINTERP4(d2, d2, s5);				MLIB_V_VIDEOINTERP4(d3, d3, s7);				*dd = d0;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d1;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d2;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);				*dd = d3;				dd = (mlib_d64 *)((mlib_u8 *)dd + field_stride);			} while (--y);		}	} else {

voidmlib_v_ImageLookUpSI_U16_S16_4_DstOff3_D1(    const mlib_u16 *src,    mlib_s16 *dst,    mlib_s32 xsize,    const mlib_s16 **table){/* pointer to source data */	mlib_u16 *sp;/* source data */	mlib_s32 s0, s1;/* pointer to start of destination */	mlib_s16 *dl;/* aligned pointer to destination */	mlib_d64 *dp;/* destination data */	mlib_d64 t0, t1, t2, t3;/* destination data */	mlib_d64 acc0;/* loop variable */	mlib_s32 i;	const mlib_s16 *tab0 = &table[0][0];	const mlib_s16 *tab1 = &table[1][0];	const mlib_s16 *tab2 = &table[2][0];	const mlib_s16 *tab3 = &table[3][0];/* destination data */	mlib_d64 acc1;	sp = (void *)src;	dl = dst;	dp = (mlib_d64 *)dl;	vis_alignaddr((void *)0, 6);	s0 = ((*sp++)) << 1;	if (xsize >= 1) {		s1 = ((*sp++)) << 1;		vis_write_bmask(0x012389ab, 0);#pragma pipeloop(0)		for (i = 0; i <= xsize - 2; i++) {			t3 = VIS_LD_U16_I(tab2, s1);			t2 = VIS_LD_U16_I(tab1, s1);			t1 = VIS_LD_U16_I(tab0, s1);			t0 = VIS_LD_U16_I(tab3, s0);			acc1 = vis_faligndata(t3, acc1);			acc1 = vis_faligndata(t2, acc1);			acc0 = vis_faligndata(t1, acc0);			acc0 = vis_faligndata(t0, acc0);			s0 = s1;			s1 = ((*sp++)) << 1;			(*dp++) = vis_bshuffle(acc0, acc1);		}		t3 = VIS_LD_U16_I(tab2, s1);		t2 = VIS_LD_U16_I(tab1, s1);		t1 = VIS_LD_U16_I(tab0, s1);		t0 = VIS_LD_U16_I(tab3, s0);		acc1 = vis_faligndata(t3, acc1);		acc1 = vis_faligndata(t2, acc1);		acc0 = vis_faligndata(t1, acc0);		acc0 = vis_faligndata(t0, acc0);		s0 = s1;		(*dp++) = vis_bshuffle(acc0, acc1);	}	dl = (mlib_s16 *)dp;	s0 >>= 1;	dl[0] = tab3[s0];}