g2d.c

samsung 最新芯片2450 的测试程序.

//	Assert( (usSrcEndX <= oG2d.m_uCwX2)&&(usDstEndX <= oG2d.m_uCwX2) );

	// Check boundary of Y coordinate
//	Assert( (usSrcStY >= oG2d.m_uCwY1)&&(usSrcEndY >= oG2d.m_uCwY1) );
	// Coordinate Y of source image or destination image should be less than that of clipping window.
//	Assert( (usSrcEndY <= oG2d.m_uCwY2)&&(usDstEndY <= oG2d.m_uCwY2) );

    G2D_CheckFifo(17);

    
    rG2D_COORD0_X=usSrcStX;
    rG2D_COORD0_Y=usSrcStY;
    rG2D_COORD1_X=usSrcEndX;
	rG2D_COORD1_Y=usSrcEndY;

    rG2D_COORD2_X= usDstStX;
    rG2D_COORD2_Y= usDstStY;
    rG2D_COORD3_X= usDstEndX;
    rG2D_COORD3_Y= usDstEndY;

	if(bIsStretch==true) {
		usSrcWidth=ABS(usSrcStX-usSrcEndX);
		usDstWidth=ABS(usDstStX-usDstEndX);
		usSrcHeight=ABS(usSrcStY-usSrcEndY);
		usDstHeight=ABS(usDstStY-usDstEndY);

		G2D_SetXYIncrFormat(usSrcWidth, usDstWidth, &uXYIncr);
		rG2D_X_INCR= uXYIncr;
		

		G2D_SetXYIncrFormat(usSrcHeight, usDstHeight, &uXYIncr);
		rG2D_Y_INCR= uXYIncr;
    	}

		uCmdRegVal=rG2D_CMDR1;
		uCmdRegVal &= ~(0x3<<0);
		uCmdRegVal |= (bIsStretch == true) ? G2D_STRETCH_BITBLT_BIT : G2D_NORMAL_BITBLT_BIT;
		rG2D_CMDR1= uCmdRegVal;
#ifdef PROFILE
		PWM_PushTimer(); //Timer 0 will start
#endif
#ifdef INTERRUPT_MODE
		while(!bG2dDone);
		bG2dDone=0;
#endif
	
}

// Get Original Coordinate (X,Y) to rotate window
// usDestStX, usDesStY : Target Destination after rotation
// (usSrcX1, usSrcY1), (usSrcX2, usSrcY2) : Coordinate (X1,Y1), (X2, Y2) before rotation
// usRotDegree : support only 90/180/270 degrees
// usOrigX, usOrigY : Rotation Coordinate. the register value for rG2D_ROT_OC_X and rG2D_ROT_OC_Y

// formula to get usOrigX, usOrigY
// | usDestX - usOrigX |   | cosA -sinA | | usSRCX - usOrigX |
// |                   | = |            | |                  |
// | usDestY - usOrigY |   | sinA  cosA | | usSRCY - usOrigY |
//
//
//( if A == 90 degrees, usSRCX = usSrcX1 and usSRCY = usSrcY2
// else if A == 180 degrees, usSRCX = usSrcX2 and usSRCY = usSrcY2
// else if A == 270 degrees, usSRCX = usSrcX1 and usSRCY = usSrcY2 )


// cf. SRC window coordinate
//
// (usSrcX1, usSrcY1)                (usSrcX2, usSrcY1)
//         *---------------------------------*
//         |                                 |
//         |                                 |
//         |            Window               |
//         |                                 |
//         |                                 |
//         *---------------------------------*
// (usSrcX1, usSrcY2)                 (usSrcX2, usSrcY2)

void G2D_GetRotationOrgXY(u16 usSrcX1, u16 usSrcY1, u16 usSrcX2, u16 usSrcY2, u16 usDestX1, u16 usDestY1,
                             ROT_DEG eRotDegree, u16* usOrgX, u16* usOrgY)
{
	G2D_CheckFifo(17);

	switch(eRotDegree)
	{
		case ROT_0:
			return;
		case ROT_90:
			*usOrgX = (usDestX1 - usDestY1 + usSrcX1 + usSrcY2)/2;
			*usOrgY = (usDestX1 + usDestY1 - usSrcX1 + usSrcY2)/2;

			break;
		case ROT_180:
			*usOrgX = (usDestX1 + usSrcX2)/2;
			*usOrgY = (usDestY1 + usSrcY2)/2;

			break;
		case ROT_270:
			*usOrgX = (usDestX1 + usDestY1 + usSrcX2 - usSrcY1)/2;
			*usOrgY = (usDestY1 - usDestX1 + usSrcX2 + usSrcY1)/2;

			break;
		default:
		//	Assert(0); // UnSupported Rotation Degree!
			break;
	}

}

void G2D_RotateImage(
	u16 usSrcX1, u16 usSrcY1, u16 usSrcX2, u16 usSrcY2,
	u16 usDestX1, u16 usDestY1, ROT_DEG eRotDegree)
{
	u16 usOrgX, usOrgY;
	u32 uRotDegree;

	G2D_GetRotationOrgXY(usSrcX1, usSrcY1, usSrcX2, usSrcY2, usDestX1, usDestY1, eRotDegree, &usOrgX, &usOrgY);

	G2D_CheckFifo(17);

	rG2D_ROT_OC_X|= usOrgX;
	rG2D_ROT_OC_Y|= usOrgY;

	uRotDegree =
		(eRotDegree == ROT_0) ? G2D_ROTATION_0_DEG_BIT :
		(eRotDegree == ROT_90) ? G2D_ROTATION_90_DEG_BIT :
		(eRotDegree == ROT_180) ? G2D_ROTATION_180_DEG_BIT : G2D_ROTATION_270_DEG_BIT;

	rG2D_ROTATE= uRotDegree;
}

void G2D_RotateWithBitBlt(
	u16 usSrcX1, u16 usSrcY1, u16 usSrcX2, u16 usSrcY2,
	u16 usDestX1, u16 usDestY1,   ROT_DEG eRotDegree)
{
	u16 usOrgX, usOrgY;
	u32 uRotDegree;

	G2D_GetRotationOrgXY(usSrcX1, usSrcY1, usSrcX2, usSrcY2, usDestX1, usDestY1, eRotDegree, &usOrgX, &usOrgY);

	G2D_CheckFifo(17);

	rG2D_ROT_OC_X|= usOrgX;
	rG2D_ROT_OC_Y|= usOrgY;

	uRotDegree =
		(eRotDegree == ROT_0) ? G2D_ROTATION_0_DEG_BIT :
		(eRotDegree == ROT_90) ? G2D_ROTATION_90_DEG_BIT :
		(eRotDegree == ROT_180) ? G2D_ROTATION_180_DEG_BIT : G2D_ROTATION_270_DEG_BIT ;

	rG2D_ROTATE= uRotDegree;

	G2D_BitBlt(usSrcX1, usSrcY1, usSrcX2, usSrcY2, usSrcX1, usSrcY1, usSrcX2, usSrcY2, false);
}

// if ucTransMode is '1', Transparent Mode
// else '0', Opaque Mode
void G2D_SetTransparentMode1(bool bIsTransparent, u32 uBsColor)
{
	u32 uRopRegVal;

	G2D_CheckFifo(17);

	uRopRegVal=rG2D_ROP;

	uRopRegVal =
		(bIsTransparent == 1) ? (uRopRegVal | G2D_TRANSPARENT_BIT) : (uRopRegVal & ~(G2D_TRANSPARENT_BIT));
	

	rG2D_ROP= uRopRegVal;

	// register Blue Screen Color
	rG2D_BS_COLOR= uBsColor;

	
}

void G2D_SetTransparentMode(bool bIsTransparent, G2D_COLOR eBsColor)
{
	G2D_SetTransparentMode1(bIsTransparent, oG2d.m_uColorVal[eBsColor]);
}

// if ucTransMode is '1', Transparent Mode
// else '0', Opaque Mode
void G2D_SetColorKeyOn1(u32 uBsColor)
{
	G2D_CheckFifo(17);

	rG2D_ROP|=G2D_TRANSPARENT_BIT;

	// register Blue Screen Color
	rG2D_BS_COLOR= uBsColor;
}

void G2D_SetColorKeyOn(G2D_COLOR eBsColor)
{
	G2D_SetColorKeyOn1(oG2d.m_uColorVal[eBsColor]);
}

void G2D_SetColorKeyOff(void)
{
	G2D_CheckFifo(17);

	// Blue screen off
	rG2D_ROP&=~(G2D_TRANSPARENT_BIT);

	// color key off	
	rG2D_COLORKEY_CNTL&=~(0x1f);
	
}



void G2D_SetPatternOffsetX(u8 ucPatOffsetX)
{
	ucPatOffsetX &= 0x7; // ucPatOffsetX[2:0]

	G2D_CheckFifo(17);
	rG2D_PATOFF_X= ucPatOffsetX;
}

void G2D_SetPatternOffsetY(u8 ucPatOffsetY)
{
	ucPatOffsetY &= 0x7; // ucPatOffsetY[2:0]

	G2D_CheckFifo(17);
	rG2D_PATOFF_Y= ucPatOffsetY;
}





void G2D_SetFgEcolor(G2D_COLOR eFgColor)
{
	G2D_SetFgColor(oG2d.m_uColorVal[eFgColor]);
}

void G2D_SetFgColor(u32 uFgColor)
{
	uFgColor &= 0x00ffffff;
	rG2D_FG_COLOR= uFgColor;
}
void G2D_SetBgEcolor(G2D_COLOR eBgColor)
{
	G2D_SetBgColor(oG2d.m_uColorVal[eBgColor]);
}

void G2D_SetBgColor(u32 uBgColor)
{
	uBgColor &= 0x00ffffff;
	rG2D_BG_COLOR= uBgColor;
}


void G2D_SetFbAddr(u32 uFbAddr, u32 uWhichBuffer)
{
	if(uWhichBuffer==SRCBUF)
		rG2D_SRC_BASE_ADDR= uFbAddr;
	else if(uWhichBuffer==DSTBUF)
		rG2D_DEST_BASE_ADDR= uFbAddr;
	
}


void G2D_SetBppMode(CSPACE eBpp, u32 uWhichBuffer)
{

	u32 uBpp;
	
	switch(eBpp)
	{
		case RGB16:
			uBpp = 0;
			break;
		case RGBA16:
			uBpp = 1;
			break;
		case ARGB16:
			uBpp = 2;
			break;
		case RGBA24:
			uBpp = 3;
			break;
		case ARGB24:
			uBpp = 4;
			break;
		case RGB24:
			uBpp = 5;
			break;
		case RGBX24:
			uBpp = 6;
			break;
		default:
			uBpp = 5;
			break;			
	}

	if(uWhichBuffer==SRCBUF)
		rG2D_SRC_COLOR_MODE=rG2D_SRC_COLOR_MODE&~(0x7)|(uBpp);
	else if(uWhichBuffer==DSTBUF)
		rG2D_DEST_COLOR_MODE=rG2D_DEST_COLOR_MODE&~(0x7)|(uBpp);	
}



// if bIsTransparent == 1, Transparent Mode and uBgColor isn't applied
// else if bIsTransparent ==0, Opaque Mode
void G2D_SetFontColor1(u32 uFontColor, u32 uBgColor, bool bIsTransparent)
{
	u32 uRopRegVal;

	G2D_CheckFifo(17);

	uRopRegVal=rG2D_ROP;

	uRopRegVal =
		(bIsTransparent == 1) ? (uRopRegVal | G2D_TRANSPARENT_BIT) : (uRopRegVal & ~(G2D_TRANSPARENT_BIT));

	rG2D_ROP=uRopRegVal;


	rG2D_FG_COLOR= uFontColor;
	rG2D_BG_COLOR= uBgColor;
}

void G2D_SetFontColor(G2D_COLOR eFontColor, G2D_COLOR eBgColor, bool bIsTransparent)
{
	G2D_SetFontColor1(oG2d.m_uColorVal[eFontColor], oG2d.m_uColorVal[eBgColor], bIsTransparent);
}

/* v.12
void G2D_PutString(u32 uPosX, u32 uPosY, char* cStr)
{
	u8* ucOneLetter;
	u32 uHostData = 0x0;
	u32 uTempData = 0x0;
	int i, j, k;

	u32 uPosX2, uPosY2;
	u32 uFontOffset;
	u32 uAddressOffset;
	// Only support 8X15 font size
	// All font size will be implemented, but now only support 8X15 font size

	if(oG2d.m_bIsBitBlt==true) printf("Host to screen BitBLT!\n");
		
	if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==8)
		uFontOffset = 8;
	else if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==15)
		uFontOffset = 15;
	else if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==16)
		uFontOffset = 16;	
	
	uPosX2 = uPosX + oG2d.m_uFontWidth - 1;
	uPosY2 = uPosY + oG2d.m_uFontHeight - 1;

	G2D_CheckFifo(17);


	for (i=0; i<strlen(cStr); i++)
	{
		if (oG2d.m_bIsBitBlt == true)
		{
			Outp32(rG2D_COORD2_X, uPosX); // COORD_0: LeftTop
			Outp32(rG2D_COORD2_Y, uPosY);
			Outp32(rG2D_COORD3_X, uPosX2); // COORD_1: RightBottom
			Outp32(rG2D_COORD3_Y, uPosY2);
			//printf("HS BitBLT!\n");
		}
		if (oG2d.m_bIsBitBlt == false)
		{
			Outp32(rG2D_COORD0_X, uPosX); // COORD_0: LeftTop
			Outp32(rG2D_COORD0_Y, uPosY);
			Outp32(rG2D_COORD1_X, uPosX2); // COORD_1: RightBottom
			Outp32(rG2D_COORD1_Y, uPosY2);
		}

		//ucOneLetter = oG2d.m_upFontType + (cStr[i]-START_ASCII)*15; // get start address of chosen letter in font8x15
		ucOneLetter = oG2d.m_upFontType + (cStr[i]-START_ASCII)*uFontOffset; // get start address of chosen letter in font8x15

		uHostData = uTempData = 0;

		for (j=0; j<4; j++) // Generate of first 1 word of data for a font (start)
		{
			uTempData = (u32)ucOneLetter[j];
			uHostData |= (uTempData << (24 - 8*j));
		}

		if (oG2d.m_bIsScr2Scr==1 && oG2d.m_bIsBitBlt ==0) {
			uAddressOffset=((oG2d.m_uFontWidth/8*oG2d.m_uFontHeight+3)/4)*4;			
			G2D_SetCMDR7(oG2d.m_uFontAddr+(cStr[i]-START_ASCII)*uAddressOffset);
#ifdef INTERRUPT_MODE
			while(!bG2dDone);
			bG2dDone=0;
#endif							
		}
		else if (oG2d.m_bIsBitBlt) {
			Outp32(rG2D_CMDR2, uHostData);
		}	
		else {
			Outp32(rG2D_CMDR4, uHostData); // Set New font
		}	

		if(oG2d.m_bIsScr2Scr != 1) 
		{
			for(k=0; k<((uFontOffset-4+3)/4); k++) // Generate next n word of data for the font (continue)
			{
				uHostData = uTempData = 0;
				for (j=0+4*(k+1); j<4+4*(k+1); j++) // Upto font height(height: 15)
				{
					uTempData = (u32)ucOneLetter[j];
					uHostData |= (uTempData<< (24 - 8*(j%4)));
				}
				if (oG2d.m_bIsScr2Scr==1 && oG2d.m_bIsBitBlt ==0) break;
				else if (oG2d.m_bIsBitBlt) {
					Outp32(rG2D_CMDR3, uHostData);
				}	
				else {
					Outp32(rG2D_CMDR5, uHostData);
				}	
			}
#ifdef INTERRUPT_MODE
				while(!bG2dDone);
				bG2dDone=0;
#endif
		}


		uPosX = uPosX2; //  Set left top X coordinate of next letter
		uPosX2 = uPosX + oG2d.m_uFontWidth - 1; // Set rigth bottom X coordiante of next letter
	}
}
*/

void G2D_PutString(u32 uPosX, u32 uPosY, char* cStr)
{
	u8* ucOneLetter;
	u32 uHostData = 0x0;
	u32 uTempData = 0x0;
	int i, j, k;

	u32 uPosX2, uPosY2;
	u32 uFontOffset;
	u32 uAddressOffset;
	
	// Only support 8X15 font size
	// All font size will be implemented, but now only support 8X15 font size
	if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==8)
		uFontOffset = 8;
	else if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==15)
		uFontOffset = 15;
	else if(oG2d.m_uFontWidth==8 && oG2d.m_uFontHeight==16)
		uFontOffset = 16;	
	
	uPosX2 = uPosX + oG2d.m_uFontWidth - 1;
	uPosY2 = uPosY + oG2d.m_uFontHeight - 1;

	G2D_CheckFifo(17);


	for (i=0; i<strlen(cStr); i++)
	{
		rG2D_COORD0_X= uPosX; // COORD_0: LeftTop
		rG2D_COORD0_Y= uPosY;
		rG2D_COORD1_X= uPosX2; // COORD_1: RightBottom
		rG2D_COORD1_Y= uPosY2;


		//ucOneLetter = oG2d.m_upFontType + (cStr[i]-START_ASCII)*15; // get start address of chosen letter in font8x15
		ucOneLetter = oG2d.m_upFontType + (cStr[i]-START_ASCII)*uFontOffset; // get start address of chosen letter in font8x15

		uHostData = uTempData = 0;

		for (j=0; j<4; j++) // Generate of first 1 word of data for a font (start)
		{
			uTempData = (u32)ucOneLetter[j];
			uHostData |= (uTempData << (24 - 8*j));
		}

		if (oG2d.m_bIsScr2Scr==1) {
			uAddressOffset=((oG2d.m_uFontWidth/8*oG2d.m_uFontHeight+3)/4)*4;			
			G2D_SetCMDR7(oG2d.m_uFontAddr+(cStr[i]-START_ASCII)*uAddressOffset);
#ifdef INTERRUPT_MODE
			while(!bG2dDone);
			bG2dDone=0;
#endif							
		}
		else {
			rG2D_CMDR4= uHostData; // Set New font
		}	

		if(oG2d.m_bIsScr2Scr != 1) 
		{
			for(k=0; k<((uFontOffset-4+3)/4); k++) // Generate next n word of data for the font (continue)
			{
				uHostData = uTempData = 0;
				for (j=0+4*(k+1); j<4+4*(k+1); j++) // Upto font height(height: 15)
				{
					uTempData = (u32)ucOneLetter[j];
					uHostData |= (uTempData<< (24 - 8*(j%4)));
				}
				rG2D_CMDR5= uHostData;
			}