tdeinterlaceyuy2.cpp

the De-interlace video processing developed with C++ enviroment in Motion adaptive in 3D and Bi-indi

					t17 = (abs(nxt2pn[x] - srcpn[x]) < mthreshC);
					t18 = (abs(srcp[x] - prv2p[x]) < mthreshC);
					t19 = (abs(nxtp[x] - prvp[x]) < mthreshC);
					if (t6 && ((t1 && t2 && ((t3 && t4 && t14 && t15) || (t5 && t18))) || 
							(t3 && t4 && t7 && t19) || 
							(t5 && t18 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t1 && t8 && t12) || (t2 && t9 && t13))) ||
							(t7 && t19 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t3 && t10 && t16) || (t4 && t11 && t17)))))
						maskw[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskw[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskw[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskw[x] = 10;
					else if (abs(prvp[x]-srcpp[x])<4 && abs(prvp[x]-srcpn[x])<4) maskw[x] = 120;
					else if (abs(srcp[x]-srcpp[x])<4 && abs(srcp[x]-srcpn[x])<4) maskw[x] = 110;
					else maskw[x] = 60;
				}
				prv2pp += prv2_pitch;
				prv2p += prv2_pitch;
				prv2pn += prv2_pitch;
				prvpp += prv_pitch;
				prvp += prv_pitch;
				prvpn += prv_pitch;
				srcpp += src_pitch;
				srcp += src_pitch;
				srcpn += src_pitch;
				nxtpp += nxt_pitch;
				nxtp += nxt_pitch;
				nxtpn += nxt_pitch;
				nxt2pp += nxt2_pitch;
				nxt2p += nxt2_pitch;
				nxt2pn += nxt2_pitch;
				maskw += mask_pitch;
			}
		}
		else
		{
			for (y=1; y<Height-1; y+=2)
			{
				for (x=0; x<Width; ++x)
				{
					t1 = (abs(srcpp[x] - prvpp[x]) < mthreshL);
					t2 = (abs(srcpn[x] - prvpn[x]) < mthreshL);
					t3 = (abs(srcpp[x] - nxtpp[x]) < mthreshL);
					t4 = (abs(srcpn[x] - nxtpn[x]) < mthreshL);
					t5 = (abs(prvp[x] - prv2p[x]) < mthreshL);
					t6 = (abs(srcp[x] - prvp[x]) < mthreshL);
					t7 = (abs(srcp[x] - nxtp[x]) < mthreshL);
					t8 = (abs(prvpp[x] - prv2pp[x]) < mthreshL);
					t9 = (abs(prvpn[x] - prv2pn[x]) < mthreshL);
					t10 = (abs(nxtpp[x] - nxt2pp[x]) < mthreshL);
					t11 = (abs(nxtpn[x] - nxt2pn[x]) < mthreshL);
					t12 = (abs(srcpp[x] - prv2pp[x]) < mthreshL);
					t13 = (abs(srcpn[x] - prv2pn[x]) < mthreshL);
					t14 = (abs(nxtpp[x] - prvpp[x]) < mthreshL);
					t15 = (abs(nxtpn[x] - prvpn[x]) < mthreshL);
					t16 = (abs(nxt2pp[x] - srcpp[x]) < mthreshL);
					t17 = (abs(nxt2pn[x] - srcpn[x]) < mthreshL);
					t18 = (abs(srcp[x] - prv2p[x]) < mthreshL);
					t19 = (abs(nxtp[x] - prvp[x]) < mthreshL);
					if (t6 && ((t1 && t2 && ((t3 && t4 && t14 && t15) || (t5 && t18))) || 
							(t3 && t4 && t7 && t19) || 
							(t5 && t18 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t1 && t8 && t12) || (t2 && t9 && t13))) ||
							(t7 && t19 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t3 && t10 && t16) || (t4 && t11 && t17)))))
						maskw[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskw[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskw[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskw[x] = 10;
					else if (abs(prvp[x]-srcpp[x])<4 && abs(prvp[x]-srcpn[x])<4) maskw[x] = 120;
					else if (abs(srcp[x]-srcpp[x])<4 && abs(srcp[x]-srcpn[x])<4) maskw[x] = 110;
					else maskw[x] = 60;
					++x;
					t1 = (abs(srcpp[x] - prvpp[x]) < mthreshC);
					t2 = (abs(srcpn[x] - prvpn[x]) < mthreshC);
					t3 = (abs(srcpp[x] - nxtpp[x]) < mthreshC);
					t4 = (abs(srcpn[x] - nxtpn[x]) < mthreshC);
					t5 = (abs(prvp[x] - prv2p[x]) < mthreshC);
					t6 = (abs(srcp[x] - prvp[x]) < mthreshC);
					t7 = (abs(srcp[x] - nxtp[x]) < mthreshC);
					t8 = (abs(prvpp[x] - prv2pp[x]) < mthreshC);
					t9 = (abs(prvpn[x] - prv2pn[x]) < mthreshC);
					t10 = (abs(nxtpp[x] - nxt2pp[x]) < mthreshC);
					t11 = (abs(nxtpn[x] - nxt2pn[x]) < mthreshC);
					t12 = (abs(srcpp[x] - prv2pp[x]) < mthreshC);
					t13 = (abs(srcpn[x] - prv2pn[x]) < mthreshC);
					t14 = (abs(nxtpp[x] - prvpp[x]) < mthreshC);
					t15 = (abs(nxtpn[x] - prvpn[x]) < mthreshC);
					t16 = (abs(nxt2pp[x] - srcpp[x]) < mthreshC);
					t17 = (abs(nxt2pn[x] - srcpn[x]) < mthreshC);
					t18 = (abs(srcp[x] - prv2p[x]) < mthreshC);
					t19 = (abs(nxtp[x] - prvp[x]) < mthreshC);
					if (t6 && ((t1 && t2 && ((t3 && t4 && t14 && t15) || (t5 && t18))) || 
							(t3 && t4 && t7 && t19) || 
							(t5 && t18 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t1 && t8 && t12) || (t2 && t9 && t13))) ||
							(t7 && t19 && ((t1 && t3 && t14) || (t2 && t4 && t15) || (t3 && t10 && t16) || (t4 && t11 && t17)))))
						maskw[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskw[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskw[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskw[x] = 10;
					else if (abs(prvp[x]-srcpp[x])<4 && abs(prvp[x]-srcpn[x])<4) maskw[x] = 120;
					else if (abs(srcp[x]-srcpp[x])<4 && abs(srcp[x]-srcpn[x])<4) maskw[x] = 110;
					else maskw[x] = 60;
				}
				prv2pp += prv2_pitch;
				prv2p += prv2_pitch;
				prv2pn += prv2_pitch;
				prvpp += prv_pitch;
				prvp += prv_pitch;
				prvpn += prv_pitch;
				srcpp += src_pitch;
				srcp += src_pitch;
				srcpn += src_pitch;
				nxtpp += nxt_pitch;
				nxtp += nxt_pitch;
				nxtpn += nxt_pitch;
				nxt2pp += nxt2_pitch;
				nxt2p += nxt2_pitch;
				nxt2pn += nxt2_pitch;
				maskw += mask_pitch;
			}
		}
	}
}

void TDeinterlace::linkFULL_YUY2(PVideoFrame &mask) 
{
	unsigned char *maskp = mask->GetWritePtr();
	int mask_pitch = mask->GetPitch();
	int mask_pitch2 = mask_pitch<<1;
	int Height = mask->GetHeight();
	int Width = mask->GetRowSize();
	maskp += mask_pitch*field;
	int x, y;
	for (y=field; y<Height; y+=2)
	{
		for (x=0; x<Width; x+=4)
		{
			if ((maskp[x] == 0x3C && maskp[x+2] == 0x3C) ||
				  maskp[x+1] == 0x3C || maskp[x+3] == 0x3C)
			{
				maskp[x] = maskp[x+1] = 0x3C;
				maskp[x+2] = maskp[x+3] = 0x3C;
			}
		}
		maskp += mask_pitch2;
	}
}

void TDeinterlace::linkYtoUV_YUY2(PVideoFrame &mask) 
{
	unsigned char *maskp = mask->GetWritePtr();
	int mask_pitch = mask->GetPitch();
	int mask_pitch2 = mask_pitch<<1;
	int Height = mask->GetHeight();
	int Width = mask->GetRowSize();
	maskp += mask_pitch*field;
	int x, y;
	for (y=field; y<Height; y+=2)
	{
		for (x=0; x<Width; x+=4)
		{
			if (maskp[x] == 0x3C && maskp[x+2] == 0x3C)
			{
				maskp[x+1] = maskp[x+3] = 0x3C;
			}
		}
		maskp += mask_pitch2;
	}
}

void TDeinterlace::linkUVtoY_YUY2(PVideoFrame &mask) 
{
	unsigned char *maskp = mask->GetWritePtr();
	int mask_pitch = mask->GetPitch();
	int mask_pitch2 = mask_pitch<<1;
	int Height = mask->GetHeight();
	int Width = mask->GetRowSize();
	maskp += mask_pitch*field;
	int x, y;
	for (y=field; y<Height; y+=2)
	{
		for (x=0; x<Width; x+=4)
		{
			if (maskp[x+1] == 0x3C || maskp[x+3] == 0x3C)
			{
				maskp[x] = maskp[x+2] = 0x3C;
			}
		}
		maskp += mask_pitch2;
	}
}

void TDeinterlace::denoiseYUY2(PVideoFrame &mask) 
{
	unsigned char *maskp = mask->GetWritePtr();
	int mask_pitch = mask->GetPitch();
	int mask_pitch2 = mask_pitch<<1;
	int Height = mask->GetHeight();
	int Width = mask->GetRowSize();
	maskp += mask_pitch*(2+field);
	unsigned char *maskpp = maskp - mask_pitch2;
	unsigned char *maskpn = maskp + mask_pitch2;
	int sum, xhi, v, x, y;
	for (y=2; y<Height-2; y+=2)
	{
		for (x=4; x<Width-4; ++x)
		{
			if (maskp[x] == 0x3C)
			{
				for (sum=0,v=x-2,xhi=x+3; v<xhi && sum<2; v+=2)
				{
					if (maskpp[v] == 0x3C) ++sum;
					if (maskp[v] == 0x3C) ++sum;
					if (maskpn[v] == 0x3C) ++sum;
				}
				if (sum < 2) maskp[x] = (maskp[x-2] == maskp[x+2]) ? maskp[x-2] :
								(maskpp[x] == maskpn[x]) ? maskpp[x] : maskp[x-2];
			}
			++x;
			if (maskp[x] == 0x3C)
			{
				for (sum=0,v=x-4,xhi=x+5; v<xhi && sum<2; v+=4)
				{
					if (maskpp[v] == 0x3C) ++sum;
					if (maskp[v] == 0x3C) ++sum;
					if (maskpn[v] == 0x3C) ++sum;
				}
				if (sum < 2) maskp[x] = (maskp[x-4] == maskp[x+4]) ? maskp[x-4] :
								(maskpp[x] == maskpn[x]) ? maskpp[x] : maskp[x-4];
			}
		}
		maskpp += mask_pitch2;
		maskp += mask_pitch2;
		maskpn += mask_pitch2;
	}
}

bool TDeinterlace::checkCombedYUY2(PVideoFrame &src, IScriptEnvironment *env) 
{
	const unsigned char *srcp = src->GetReadPtr();
	int src_pitch = src->GetPitch();
	int Width = src->GetRowSize();
	int Height = src->GetHeight();
	const unsigned char *srcpp = srcp - src_pitch;
	const unsigned char *srcppp = srcpp - src_pitch;
	const unsigned char *srcpn = srcp + src_pitch;
	const unsigned char *srcpnn = srcpn + src_pitch;
	PVideoFrame cmask = env->NewVideoFrame(vi);
	unsigned char *cmkp = cmask->GetWritePtr();
	unsigned char *cmk_saved = cmkp;
	unsigned char *cmkpp, *cmkpn;
	int cmk_pitch = cmask->GetPitch();
	int inc = chroma ? 1 : 2;
	int xblocks = ((Width+xhalf)>>xshift) + 1;
	int xblocks4 = xblocks<<2;
	int yblocks = ((Height+yhalf)>>yshift) + 1;
	int arraysize = (xblocks*yblocks)<<2;
	int x, y, sFirst, sSecond, temp1, temp2, box1, box2;
	memset(cmkp,0,Height*cmk_pitch);
	for (x=0; x<Width; x+=inc)
	{
		sFirst = srcp[x] - srcpn[x];
		if (sFirst > cthresh || sFirst < -cthresh)
		{
			sFirst = abs(srcpnn[x]+(srcp[x]<<2)+srcpnn[x]-(3*(srcpn[x]+srcpn[x])));
			if (sFirst > cthresh6) cmkp[x] = 0x3C;
		}
	}
	srcppp += src_pitch;
	srcpp += src_pitch;
	srcp += src_pitch;
	srcpn += src_pitch;
	srcpnn += src_pitch;
	cmkp += cmk_pitch;
	for (x=0; x<Width; x+=inc)
	{
		sFirst = srcp[x] - srcpp[x];
		sSecond = srcp[x] - srcpn[x];
		if ((sFirst > cthresh && sSecond > cthresh) || (sFirst < -cthresh && sSecond < -cthresh))
		{
			sFirst = abs(srcpnn[x]+(srcp[x]<<2)+srcpnn[x]-(3*(srcpp[x]+srcpn[x])));
			if (sFirst > cthresh6) cmkp[x] = 0x3C;
		}
	}
	srcppp += src_pitch;
	srcpp += src_pitch;
	srcp += src_pitch;
	srcpn += src_pitch;
	srcpnn += src_pitch;
	cmkp += cmk_pitch;
	for (y=2; y<Height-2; ++y)
	{
		for (x=0; x<Width; x+=inc)
		{
			sFirst = srcp[x] - srcpp[x];
			sSecond = srcp[x] - srcpn[x];
			if ((sFirst > cthresh && sSecond > cthresh) || (sFirst < -cthresh && sSecond < -cthresh))
			{
				sFirst = abs(srcppp[x]+(srcp[x]<<2)+srcpnn[x]-(3*(srcpp[x]+srcpn[x])));
				if (sFirst > cthresh6) cmkp[x] = 0x3C;
			}	
		}
		srcppp += src_pitch;
		srcpp += src_pitch;
		srcp += src_pitch;
		srcpn += src_pitch;
		srcpnn += src_pitch;
		cmkp += cmk_pitch;
	}
	for (x=0; x<Width; x+=inc)
	{
		sFirst = srcp[x] - srcpp[x];
		sSecond = srcp[x] - srcpn[x];
		if ((sFirst > cthresh && sSecond > cthresh) || (sFirst < -cthresh && sSecond < -cthresh))
		{
			sFirst = abs(srcppp[x]+(srcp[x]<<2)+srcppp[x]-(3*(srcpp[x]+srcpn[x])));
			if (sFirst > cthresh6) cmkp[x] = 0x3C;
		}
	}
	srcppp += src_pitch;
	srcpp += src_pitch;
	srcp += src_pitch;
	srcpn += src_pitch;
	srcpnn += src_pitch;
	cmkp += cmk_pitch;
	for (x=0; x<Width; x+=inc)
	{
		sFirst = srcp[x] - srcpp[x];
		if (sFirst > cthresh || sFirst < -cthresh)
		{
			sFirst = abs(srcppp[x]+(srcp[x]<<2)+srcppp[x]-(3*(srcpp[x]+srcpp[x])));
			if (sFirst > cthresh6) cmkp[x] = 0x3C;
		}
	}
	if (chroma) 
	{
		cmkp = cmk_saved;
		for (y=0; y<Height; ++y)
		{
			for (x=0; x<Width; x+=4)
			{
				if (cmkp[x+1] == 0x3C || cmkp[x+3] == 0x3C) cmkp[x] = cmkp[x+2] = 0x3C;
			}
			cmkp += cmk_pitch;
		}
	}
	cmkp = cmk_saved + cmk_pitch;
	cmkpp = cmkp - cmk_pitch;
	cmkpn = cmkp + cmk_pitch;
	memset(cArray,0,arraysize*sizeof(int));
	for (y=1; y<Height-1; ++y)
	{
		temp1 = (y>>yshift)*xblocks4;
		temp2 = ((y+yhalf)>>yshift)*xblocks4;
		for (x=0; x<Width; x+=2)
		{
			if (cmkpp[x] == 0x3C && cmkp[x] == 0x3C && cmkpn[x] == 0x3C)
			{
				box1 = (x>>xshift)<<2;
				box2 = ((x+xhalf)>>xshift)<<2;
				++cArray[temp1+box1+0];
				++cArray[temp1+box2+1];
				++cArray[temp2+box1+2];
				++cArray[temp2+box2+3];