tdeinterlaceyv12.cpp

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

					t13 = (abs(srcpnY[x] - prv2pnY[x]) < mthreshL);
					t14 = (abs(nxtppY[x] - prvppY[x]) < mthreshL);
					t15 = (abs(nxtpnY[x] - prvpnY[x]) < mthreshL);
					t16 = (abs(nxt2ppY[x] - srcppY[x]) < mthreshL);
					t17 = (abs(nxt2pnY[x] - srcpnY[x]) < mthreshL);
					t18 = (abs(srcpY[x] - prv2pY[x]) < mthreshL);
					t19 = (abs(nxtpY[x] - prvpY[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)))))
						maskwY[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskwY[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskwY[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskwY[x] = 10;
					else if (abs(prvpY[x]-srcppY[x])<4 && abs(prvpY[x]-srcpnY[x])<4) maskwY[x] = 120;
					else if (abs(srcpY[x]-srcppY[x])<4 && abs(srcpY[x]-srcpnY[x])<4) maskwY[x] = 110;
					else maskwY[x] = 60;
				}
				prv2ppY += prv2_pitchY;
				prv2pY += prv2_pitchY;
				prv2pnY += prv2_pitchY;
				prvppY += prv_pitchY;
				prvpY += prv_pitchY;
				prvpnY += prv_pitchY;
				srcppY += src_pitchY;
				srcpY += src_pitchY;
				srcpnY += src_pitchY;
				nxtppY += nxt_pitchY;
				nxtpY += nxt_pitchY;
				nxtpnY += nxt_pitchY;
				nxt2ppY += nxt2_pitchY;
				nxt2pY += nxt2_pitchY;
				nxt2pnY += nxt2_pitchY;
				maskwY += mask_pitchY;
			}
			for (y=1; y<HeightUV-1; y+=2)
			{
				for (x=0; x<WidthUV; ++x)
				{
					t1 = (abs(srcppV[x] - prvppV[x]) < mthreshC);
					t2 = (abs(srcpnV[x] - prvpnV[x]) < mthreshC);
					t3 = (abs(srcppV[x] - nxtppV[x]) < mthreshC);
					t4 = (abs(srcpnV[x] - nxtpnV[x]) < mthreshC);
					t5 = (abs(prvpV[x] - prv2pV[x]) < mthreshC);
					t6 = (abs(srcpV[x] - prvpV[x]) < mthreshC);
					t7 = (abs(srcpV[x] - nxtpV[x]) < mthreshC);
					t8 = (abs(prvppV[x] - prv2ppV[x]) < mthreshC);
					t9 = (abs(prvpnV[x] - prv2pnV[x]) < mthreshC);
					t10 = (abs(nxtppV[x] - nxt2ppV[x]) < mthreshC);
					t11 = (abs(nxtpnV[x] - nxt2pnV[x]) < mthreshC);
					t12 = (abs(srcppV[x] - prv2ppV[x]) < mthreshC);
					t13 = (abs(srcpnV[x] - prv2pnV[x]) < mthreshC);
					t14 = (abs(nxtppV[x] - prvppV[x]) < mthreshC);
					t15 = (abs(nxtpnV[x] - prvpnV[x]) < mthreshC);
					t16 = (abs(nxt2ppV[x] - srcppV[x]) < mthreshC);
					t17 = (abs(nxt2pnV[x] - srcpnV[x]) < mthreshC);
					t18 = (abs(srcpV[x] - prv2pV[x]) < mthreshC);
					t19 = (abs(nxtpV[x] - prvpV[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)))))
						maskwV[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskwV[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskwV[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskwV[x] = 10;
					else if (abs(prvpV[x]-srcppV[x])<4 && abs(prvpV[x]-srcpnV[x])<4) maskwV[x] = 120;
					else if (abs(srcpV[x]-srcppV[x])<4 && abs(srcpV[x]-srcpnV[x])<4) maskwV[x] = 110;
					else maskwV[x] = 60;
					t1 = (abs(srcppU[x] - prvppU[x]) < mthreshC);
					t2 = (abs(srcpnU[x] - prvpnU[x]) < mthreshC);
					t3 = (abs(srcppU[x] - nxtppU[x]) < mthreshC);
					t4 = (abs(srcpnU[x] - nxtpnU[x]) < mthreshC);
					t5 = (abs(prvpU[x] - prv2pU[x]) < mthreshC);
					t6 = (abs(srcpU[x] - prvpU[x]) < mthreshC);
					t7 = (abs(srcpU[x] - nxtpU[x]) < mthreshC);
					t8 = (abs(prvppU[x] - prv2ppU[x]) < mthreshC);
					t9 = (abs(prvpnU[x] - prv2pnU[x]) < mthreshC);
					t10 = (abs(nxtppU[x] - nxt2ppU[x]) < mthreshC);
					t11 = (abs(nxtpnU[x] - nxt2pnU[x]) < mthreshC);
					t12 = (abs(srcppU[x] - prv2ppU[x]) < mthreshC);
					t13 = (abs(srcpnU[x] - prv2pnU[x]) < mthreshC);
					t14 = (abs(nxtppU[x] - prvppU[x]) < mthreshC);
					t15 = (abs(nxtpnU[x] - prvpnU[x]) < mthreshC);
					t16 = (abs(nxt2ppU[x] - srcppU[x]) < mthreshC);
					t17 = (abs(nxt2pnU[x] - srcpnU[x]) < mthreshC);
					t18 = (abs(srcpU[x] - prv2pU[x]) < mthreshC);
					t19 = (abs(nxtpU[x] - prvpU[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)))))
						maskwU[x] = val1;
					else if (t1 && t2 && t3 && t4 && t5 && t7 && t14 && t15) maskwU[x] = val1;
					else if (t1 && t5 && t2 && t8 && t9 && t12 && t13) maskwU[x] = 20;
					else if (t3 && t7 && t4 && t10 && t11 && t16 && t17) maskwU[x] = 10;
					else if (abs(prvpU[x]-srcppU[x])<4 && abs(prvpU[x]-srcpnU[x])<4) maskwU[x] = 120;
					else if (abs(srcpU[x]-srcppU[x])<4 && abs(srcpU[x]-srcpnU[x])<4) maskwU[x] = 110;
					else maskwU[x] = 60;
				}
				prv2ppV += prv2_pitchUV;
				prv2pV += prv2_pitchUV;
				prv2pnV += prv2_pitchUV;
				prv2ppU += prv2_pitchUV;
				prv2pU += prv2_pitchUV;
				prv2pnU += prv2_pitchUV;
				prvppV += prv_pitchUV;
				prvpV += prv_pitchUV;
				prvpnV += prv_pitchUV;
				prvppU += prv_pitchUV;
				prvpU += prv_pitchUV;
				prvpnU += prv_pitchUV;
				srcppV += src_pitchUV;
				srcpV += src_pitchUV;
				srcpnV += src_pitchUV;
				srcppU += src_pitchUV;
				srcpU += src_pitchUV;
				srcpnU += src_pitchUV;
				nxtppV += nxt_pitchUV;
				nxtpV += nxt_pitchUV;
				nxtpnV += nxt_pitchUV;
				nxtppU += nxt_pitchUV;
				nxtpU += nxt_pitchUV;
				nxtpnU += nxt_pitchUV;
				nxt2ppV += nxt2_pitchUV;
				nxt2pV += nxt2_pitchUV;
				nxt2pnV += nxt2_pitchUV;
				nxt2ppU += nxt2_pitchUV;
				nxt2pU += nxt2_pitchUV;
				nxt2pnU += nxt2_pitchUV;
				maskwV += mask_pitchUV;
				maskwU += mask_pitchUV;
			}
		}
	}
}

void TDeinterlace::linkFULL_YV12(PVideoFrame &mask) 
{
	unsigned char *maskpY = mask->GetWritePtr(PLANAR_Y);
	unsigned char *maskpV = mask->GetWritePtr(PLANAR_V);
	unsigned char *maskpU = mask->GetWritePtr(PLANAR_U);
	int mask_pitchY = mask->GetPitch(PLANAR_Y);
	int mask_pitchY2 = mask_pitchY<<1;
	int mask_pitchY4 = mask_pitchY<<2;
	int mask_pitchUV = mask->GetPitch(PLANAR_V);
	int mask_pitchUV2 = mask_pitchUV<<1;
	int HeightUV = mask->GetHeight(PLANAR_V);
	int WidthUV = mask->GetRowSize(PLANAR_V);
	maskpY += mask_pitchY*field;
	maskpV += mask_pitchUV*field;
	maskpU += mask_pitchUV*field;
	unsigned char *maskpnY = maskpY + mask_pitchY2;
	int x, y;
	for (y=field; y<HeightUV; y+=2)
	{
		for (x=0; x<WidthUV; ++x)
		{
			if (((((unsigned short*)maskpY)[x] == (unsigned short)0x3C3C) && 
				 (((unsigned short*)maskpnY)[x] == (unsigned short)0x3C3C)) ||
				maskpV[x] == 0x3C || maskpU[x] == 0x3C)
			{
				((unsigned short*)maskpY)[x] = (unsigned short) 0x3C3C;
				((unsigned short*)maskpnY)[x] = (unsigned short) 0x3C3C;
				maskpV[x] = maskpU[x] = 0x3C;
			}
		}
		maskpY += mask_pitchY4;
		maskpnY += mask_pitchY4;
		maskpV += mask_pitchUV2;
		maskpU += mask_pitchUV2;
	}
}

void TDeinterlace::linkYtoUV_YV12(PVideoFrame &mask) 
{
	unsigned char *maskpY = mask->GetWritePtr(PLANAR_Y);
	unsigned char *maskpV = mask->GetWritePtr(PLANAR_V);
	unsigned char *maskpU = mask->GetWritePtr(PLANAR_U);
	int mask_pitchY = mask->GetPitch(PLANAR_Y);
	int mask_pitchY2 = mask_pitchY<<1;
	int mask_pitchY4 = mask_pitchY<<2;
	int mask_pitchUV = mask->GetPitch(PLANAR_V);
	int mask_pitchUV2 = mask_pitchUV<<1;
	int HeightUV = mask->GetHeight(PLANAR_V);
	int WidthUV = mask->GetRowSize(PLANAR_V);
	maskpY += mask_pitchY*field;
	maskpV += mask_pitchUV*field;
	maskpU += mask_pitchUV*field;
	unsigned char *maskpnY = maskpY + mask_pitchY2;
	int x, y;
	for (y=field; y<HeightUV; y+=2)
	{
		for (x=0; x<WidthUV; ++x)
		{
			if (((unsigned short*)maskpY)[x] == (unsigned short)0x3C3C && 
				((unsigned short*)maskpnY)[x] == (unsigned short)0x3C3C)
			{
				maskpV[x] = maskpU[x] = 0x3C;
			}
		}
		maskpY += mask_pitchY4;
		maskpnY += mask_pitchY4;
		maskpV += mask_pitchUV2;
		maskpU += mask_pitchUV2;
	}
}

void TDeinterlace::linkUVtoY_YV12(PVideoFrame &mask) 
{
	unsigned char *maskpY = mask->GetWritePtr(PLANAR_Y);
	unsigned char *maskpV = mask->GetWritePtr(PLANAR_V);
	unsigned char *maskpU = mask->GetWritePtr(PLANAR_U);
	int mask_pitchY = mask->GetPitch(PLANAR_Y);
	int mask_pitchY2 = mask_pitchY<<1;
	int mask_pitchY4 = mask_pitchY<<2;
	int mask_pitchUV = mask->GetPitch(PLANAR_V);
	int mask_pitchUV2 = mask_pitchUV<<1;
	int HeightUV = mask->GetHeight(PLANAR_V);
	int WidthUV = mask->GetRowSize(PLANAR_V);
	maskpY += mask_pitchY*field;
	maskpV += mask_pitchUV*field;
	maskpU += mask_pitchUV*field;
	unsigned char *maskpnY = maskpY + mask_pitchY2;
	int x, y;
	for (y=field; y<HeightUV; y+=2)
	{
		for (x=0; x<WidthUV; ++x)
		{
			if (maskpV[x] == 0x3C || maskpU[x] == 0x3C)
			{
				((unsigned short*)maskpY)[x] = (unsigned short) 0x3C3C;
				((unsigned short*)maskpnY)[x] = (unsigned short) 0x3C3C;
			}
		}
		maskpY += mask_pitchY4;
		maskpnY += mask_pitchY4;
		maskpV += mask_pitchUV2;
		maskpU += mask_pitchUV2;
	}
}

void TDeinterlace::denoiseYV12(PVideoFrame &mask) 
{
	unsigned char *maskpY = mask->GetWritePtr(PLANAR_Y);
	unsigned char *maskpV = mask->GetWritePtr(PLANAR_V);
	unsigned char *maskpU = mask->GetWritePtr(PLANAR_U);
	int mask_pitchY = mask->GetPitch(PLANAR_Y);
	int mask_pitchY2 = mask_pitchY<<1;
	int mask_pitchUV = mask->GetPitch(PLANAR_V);
	int mask_pitchUV2 = mask_pitchUV<<1;
	int HeightY = mask->GetHeight(PLANAR_Y);
	int HeightUV = mask->GetHeight(PLANAR_V);
	int WidthY = mask->GetRowSize(PLANAR_Y);
	int WidthUV = mask->GetRowSize(PLANAR_V);
	maskpY += mask_pitchY*(2+field);
	maskpV += mask_pitchUV*(2+field);
	maskpU += mask_pitchUV*(2+field);
	unsigned char *maskppY = maskpY - mask_pitchY2;
	unsigned char *maskppV = maskpV - mask_pitchUV2;
	unsigned char *maskppU = maskpU - mask_pitchUV2;
	unsigned char *maskpnY = maskpY + mask_pitchY2;
	unsigned char *maskpnV = maskpV + mask_pitchUV2;
	unsigned char *maskpnU = maskpU + mask_pitchUV2;
	int sum, xhi, v, x, y;
	for (y=2; y<HeightY-2; y+=2)
	{
		for (x=1; x<WidthY-1; ++x)
		{
			if (maskpY[x] == 0x3C)
			{
				for (sum=0,v=x-1,xhi=x+2; v<xhi && sum<2; ++v)
				{
					if (maskppY[v] == 0x3C) ++sum;
					if (maskpY[v] == 0x3C) ++sum;
					if (maskpnY[v] == 0x3C) ++sum;
				}
				if (sum < 2) maskpY[x] = (maskpY[x-1] == maskpY[x+1]) ? maskpY[x-1] :
								(maskppY[x] == maskpnY[x]) ? maskppY[x] : maskpY[x-1];
			}
		}
		maskppY += mask_pitchY2;
		maskpY += mask_pitchY2;
		maskpnY += mask_pitchY2;
	}
	for (y=2; y<HeightUV-2; y+=2)
	{
		for (x=1; x<WidthUV-1; ++x)
		{
			if (maskpV[x] == 0x3C)
			{
				for (sum=0,v=x-1,xhi=x+2; v<xhi && sum<2; ++v)
				{
					if (maskppV[v] == 0x3C) ++sum;
					if (maskpV[v] == 0x3C) ++sum;
					if (maskpnV[v] == 0x3C) ++sum;
				}
				if (sum < 2) maskpV[x] = (maskpV[x-1] == maskpV[x+1]) ? maskpV[x-1] :
								(maskppV[x] == maskpnV[x]) ? maskppV[x] : maskpV[x-1];
			}
			if (maskpU[x] == 0x3C)
			{
				for (sum=0,v=x-1,xhi=x+2; v<xhi && sum<2; ++v)
				{
					if (maskppU[v] == 0x3C) ++sum;
					if (maskpU[v] == 0x3C) ++sum;
					if (maskpnU[v] == 0x3C) ++sum;
				}
				if (sum < 2) maskpU[x] = (maskpU[x-1] == maskpU[x+1]) ? ma