fimgse2d.cpp

SMDK2416_BSP

	m_pG2DReg->CMDR0 = G2D_REND_POINT_BIT;
	WaitForSingleObject(m_hInterrupt2D, INFINITE);

	IntDisable();	
	IntPendingClear();	

	InterruptDone(m_dwSysIntr2D);
#elif (G2D_CMDPROCESSING==G2D_BUSYWAITING)
	CheckFifo(1);
	IntEnable();	
	while(!WaitForFinish());						// Polling Style	
	m_pG2DReg->CMDR0 = G2D_REND_POINT_BIT;

	IntDisable();	
#else
	RETAILMSG(TRUE,(TEXT("CMDPROCESSING TYPE is invalid, Please Check Header Definition\n")));
	return ;
#endif

}

/**
 * Draw Line
 * (usPosX1, usPosY1) ~ (usPosX2, usPosY2)
 * Do not draw last point
 *   0 < usPosX, usPosY1, usPosX2, usPosY2 < 2048
 */
void FIMGSE2D::PutLine(DWORD usPosX1, DWORD usPosY1, DWORD usPosX2, DWORD usPosY2, DWORD uColor, bool bIsDrawLastPoint) //modification
{
	int nMajorCoordX;
	DWORD uHSz, uVSz;
	int i;
	int nIncr=0;
	DWORD uCmdRegVal;

	CheckFifo(7);

	m_pG2DReg->COORD0_X = usPosX1;
	m_pG2DReg->COORD0_Y = usPosY1;
	m_pG2DReg->COORD2_X = usPosX2;
	m_pG2DReg->COORD2_Y = usPosY2;	

	RETAILMSG(0,(TEXT("COORD0_X: %d, COORD0_Y:%d, COORD2_X:%d, COORD2_Y:%d\n"), 
			m_pG2DReg->COORD0 & (0x7ff),
			(m_pG2DReg->COORD0 & (0x7ff<<16)) >> 16,			
			m_pG2DReg->COORD2 & (0x7ff),
			(m_pG2DReg->COORD2 & (0x7ff<<16)) >> 16));			
	RETAILMSG(0,(TEXT("CLIP_LT_X: %d, CLIP_LT_Y:%d, CLIP_RB_X:%d, CLIP_RB_Y:%d\n"), 
			m_pG2DReg->CW_LEFT_TOP & (0x7ff),
			(m_pG2DReg->CW_LEFT_TOP & (0x7ff<<16)) >> 16,			
			m_pG2DReg->CW_RIGHT_BOTTOM & (0x7ff),
			(m_pG2DReg->CW_RIGHT_BOTTOM & (0x7ff<<16)) >> 16));				

	uVSz = ABS((WORD)usPosY1 - (WORD)usPosY2);
	uHSz = ABS((WORD)usPosX1 - (WORD)usPosX2);

	nMajorCoordX = (uHSz>=uVSz);

	if(nMajorCoordX)
	{
		for (i=0; i<12; i++)
		{
	    	uVSz <<= 1;
	    	nIncr <<= 1;
	    	if (uVSz >= uHSz)
	    	{
				nIncr = nIncr | 1;
				uVSz -= uHSz;
	    	}
		}
		nIncr = (nIncr + 1) >> 1;
		if (usPosY1 > usPosY2)
		{
	    	nIncr = (~nIncr) + 1; // 2's complement
		}
//		printf("pre YINCR: %x  ", nIncr );						
  }
	else
	{
		for (i=0; i<12; i++)
		{
	    	uHSz <<= 1;
	    	nIncr <<= 1;
	    	if (uHSz >= uVSz)
	    	{
				nIncr = nIncr | 1;
				uHSz -= uVSz;
	    	}
		}
		nIncr = (nIncr + 1) >> 1;
		if (usPosX1 > usPosX2)
		{
	    	nIncr = (~nIncr) + 1; // 2's complement
		}
//		printf("pre XINCR: %x  ", nIncr );				
	}

	m_pG2DReg->FG_COLOR = uColor;

	uCmdRegVal = 0;

	if(nMajorCoordX)
	{
		SetYIncr(nIncr);

		uCmdRegVal =
			(bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT & G2D_DRAW_LAST_POINT_BIT) :
			(G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);
		
		RETAILMSG(0,(TEXT("m_pG2DReg:0x%x, CMD: %x, XINCR: %x, YINCR: %x\n"), m_pG2DReg, uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR ));
	}
	else
	{
		SetXIncr(nIncr);

		uCmdRegVal =
			(bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_Y_BIT & G2D_DRAW_LAST_POINT_BIT) :
			(G2D_REND_LINE_BIT | G2D_MAJOR_COORD_Y_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);

		RETAILMSG(0,(TEXT("CMD: %x, XINCR: %x, YINCR: %x\n"), uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR ));
	}

#if	(G2D_CMDPROCESSING==G2D_FASTRETURN)
	WaitForEmptyFifo();		//< This is check fully empty command fifo.
	m_pG2DReg->CMDR0 = uCmdRegVal;
#elif (G2D_CMDPROCESSING==G2D_INTERRUPT)
	CheckFifo(1);
	IntEnable();	
	m_pG2DReg->CMDR0 = uCmdRegVal;
	WaitForSingleObject(m_hInterrupt2D, INFINITE);

	IntDisable();	
	IntPendingClear();	

	InterruptDone(m_dwSysIntr2D);
#elif (G2D_CMDPROCESSING==G2D_BUSYWAITING)
	CheckFifo(1);
	IntEnable();	
	while(!WaitForFinish());						// Polling Style	
	m_pG2DReg->CMDR0 = uCmdRegVal;

	IntDisable();	
#else
	RETAILMSG(TRUE,(TEXT("CMDPROCESSING TYPE is invalid, Please Check Header Definition\n")));
	return FALSE;
#endif

	
}


/**
*	@fn	FIMGSE2D::SetRopEtype(G2D_ROP_TYPE eRopType)
*	@note	Set Ternary Raster Operation
*	@note	Only support 7 raster operation (most used Rop)
*/
void FIMGSE2D::SetRopEtype(G2D_ROP_TYPE eRopType)
{
	DWORD uRopVal;

	uRopVal =
		(eRopType == ROP_SRC_ONLY) ? G2D_ROP_SRC_ONLY :
		(eRopType == ROP_DST_ONLY) ? G2D_ROP_DST_ONLY :
		(eRopType == ROP_PAT_ONLY) ? G2D_ROP_PAT_ONLY :
		(eRopType == ROP_SRC_AND_DST) ? G2D_ROP_SRC_AND_DST:
		(eRopType == ROP_SRC_AND_PAT) ? G2D_ROP_SRC_AND_PAT :		
		(eRopType == ROP_DST_AND_PAT) ? G2D_ROP_DST_AND_PAT :
		(eRopType == ROP_SRC_OR_DST) ? G2D_ROP_SRC_OR_DST :
		(eRopType == ROP_SRC_OR_PAT) ? G2D_ROP_SRC_OR_PAT :		
		(eRopType == ROP_DST_OR_PAT) ? G2D_ROP_DST_OR_PAT :		
		(eRopType == ROP_SRC_XOR_DST) ? G2D_ROP_SRC_XOR_DST :
		(eRopType == ROP_SRC_XOR_PAT) ? G2D_ROP_SRC_XOR_PAT :
		(eRopType == ROP_DST_XOR_PAT) ? G2D_ROP_DST_XOR_PAT :
	 	G2D_ROP_SRC_ONLY;

	SetRopValue(uRopVal); 

}



void FIMGSE2D::SetStencilKey(DWORD uIsColorKeyOn, DWORD uIsInverseOn, DWORD uIsSwapOn)
{	
	CheckFifo(1);
	m_pG2DReg->COLORKEY_CNTL = ((uIsColorKeyOn&1)<<31)|((uIsInverseOn&1)<<23)|(uIsSwapOn&1);
}

void FIMGSE2D::SetStencilMinMax(DWORD uRedMin, DWORD uRedMax, DWORD uGreenMin, DWORD uGreenMax, DWORD uBlueMin, DWORD uBlueMax)
{
	CheckFifo(2);
	m_pG2DReg->COLORKEY_DR_MIN = ((uRedMin&0xff)<<16)|((uGreenMin&0xff)<<8)|(uBlueMin&0xff);
	m_pG2DReg->COLORKEY_DR_MAX = ((0xffU<<24)|(uRedMax&0xff)<<16)|((uGreenMax&0xff)<<8)|(uBlueMax&0xff);	
}

void FIMGSE2D::SetColorExpansionMethod(bool bIsScr2Scr)
{
	m_bIsScr2Scr  = (bIsScr2Scr) ? 1 :	0;
}

void FIMGSE2D::BlendingOut(DWORD uSrcData, DWORD uDstData, BYTE ucAlphaVal, bool bFading, BYTE ucFadingOffset, DWORD *uBlendingOut)
{

	DWORD uSrcRed, uSrcGreen, uSrcBlue;
	DWORD uDstRed, uDstGreen, uDstBlue;
	DWORD uBldRed, uBldGreen, uBldBlue;	
	
	uSrcRed= (uSrcData & 0x00ff0000)>>16;  // Mask R
	uSrcGreen = (uSrcData & 0x0000ff00)>>8;	 // Mask G
	uSrcBlue = uSrcData & 0x000000ff;		 // Mask B

	uDstRed = (uDstData & 0x00ff0000)>>16; // Mask R
	uDstGreen = (uDstData & 0x0000ff00)>>8;  // Mask G
	uDstBlue = uDstData & 0x000000ff;		 // Mask B

	if(bFading) {
		uBldRed= ((uSrcRed*(ucAlphaVal+1))>>8) + ucFadingOffset; // R output
		uBldGreen= ((uSrcGreen*(ucAlphaVal+1))>>8) + ucFadingOffset; // G output
		uBldBlue= ((uSrcBlue*(ucAlphaVal+1)>>8)) + ucFadingOffset; // B output
		if(uBldRed>=256) uBldRed=255;
		if(uBldGreen>=256) uBldGreen=255;
		if(uBldBlue>=256) uBldBlue=255;
	}
	else {
		uBldRed= ((uSrcRed*(ucAlphaVal+1)) + (uDstRed*(256-ucAlphaVal)))>>8; // R output
		uBldGreen= ((uSrcGreen*(ucAlphaVal+1)) + (uDstGreen*(256-ucAlphaVal)))>>8; // G output
		uBldBlue= ((uSrcBlue*(ucAlphaVal+1)) + (uDstBlue*(256-ucAlphaVal)))>>8; // B output
	}

	*uBlendingOut = (uBldRed<<16) | (uBldGreen<<8) | uBldBlue;
}


void FIMGSE2D::Convert24bpp(DWORD uSrcData, EGPEFormat eBpp, bool bSwap, DWORD *uConvertedData)
{

	DWORD uRed, uGreen, uBlue;
	
	switch(eBpp) {
/*		case  ARGB8: // 15 bit color mode
			if(bSwap == 1) {  // pde_state == 2(BitBlt)
				uRed = uSrcData & 0x00007c00;  // R
				uGreen = uSrcData & 0x000003e0;  // G
				uBlue = uSrcData & 0x0000001f;  // B
			
				*uConvertedData = uRed<<9 | uGreen<<6 | uBlue<<3; // SUM
			}
			else { //hsel = 0
				uRed = uSrcData & 0x7c000000;
				uGreen = uSrcData & 0x03e00000;
				uBlue = uSrcData & 0x001f0000;

				*uConvertedData = uRed>>7 | uGreen>>10 | uBlue>>13;
			} 
			break;*/
		case gpe16Bpp : // 16 bit color mode
			if(bSwap == 1) {
				uRed = uSrcData & 0x0000f800;
				uGreen = uSrcData & 0x000007e0;
				uBlue = uSrcData & 0x0000001f;

				*uConvertedData = uRed<<8 | uGreen<<5 | uBlue<<3;
			}
			else {
				uRed = uSrcData & 0xf8000000;
				uGreen = uSrcData & 0x07e00000;
				uBlue = uSrcData & 0x001f0000;

				*uConvertedData = uRed>>8 | uGreen>>11 | uBlue>>13;
			}
			break;	

/*		case RGB18 : // 18 bit color mode
			uRed = uSrcData & 0x0003f000;
			uGreen = uSrcData & 0x00000fc0;
			uBlue = uSrcData & 0x0000003f;
	
			*uConvertedData = uRed<<6 | uGreen<<4 | uBlue<<2;
			break;

		case RGB24 : // 24 bit color mode
			*uConvertedData = uSrcData;
			break;*/
	} // End of switch
} // End of g2d_cvt24bpp function


void FIMGSE2D::GetRotateCoordinate(DWORD uDstX, DWORD uDstY, DWORD uOrgX, DWORD uOrgY, DWORD uRType, DWORD *uRsltX, DWORD *uRsltY) 
{

	switch(uRType) {
		case  1 : // No Rotate. bypass.
			*uRsltX = uDstX;
			*uRsltY = uDstY;
			break;
		case  2 : // 90 degree Rotation
			*uRsltX = uOrgX + uOrgY - uDstY;
			*uRsltY = uDstX - uOrgX + uOrgY;			
			break;
		case  4 : // 180 degree Rotation
			*uRsltX = 2*uOrgX - uDstX;
			*uRsltY = 2*uOrgY - uDstY;
			break;
		case  8 : // 270 degree Rotation
			*uRsltX = uDstY + uOrgX - uOrgY;
			*uRsltY = uOrgX + uOrgY - uDstX;
			break;
		case 16 : // X-flip
			*uRsltX = uDstX;
			*uRsltY = 2*uOrgY - uDstY;
			break;
		case 32 : // Y-flip
			*uRsltX = 2*uOrgX - uDstX;
			*uRsltY = uDstY;		
			break;
		default :
			Assert(0);
			break;
	}
}



BOOL FIMGSE2D::InitializeInterrupt(void)
{
	DWORD dwIRQ;

	dwIRQ = IRQ_2D;					// 2D Accelerator IRQ
	m_dwSysIntr2D = SYSINTR_UNDEFINED;
	m_hInterrupt2D = NULL;

	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &m_dwSysIntr2D, sizeof(DWORD), NULL))
	{
		m_dwSysIntr2D = SYSINTR_UNDEFINED;
		return FALSE;
	}
	RETAILMSG(1, (TEXT("2D Sysintr : %d\r\n"),m_dwSysIntr2D));

	m_hInterrupt2D = CreateEvent(NULL, FALSE, FALSE, NULL);
	if(NULL == m_hInterrupt2D)
	{
		return FALSE;
	}

	if (!(InterruptInitialize(m_dwSysIntr2D, m_hInterrupt2D, 0, 0)))
	{
		return FALSE;
	}	
	return TRUE;
}

void FIMGSE2D::DeinitInterrupt(void)
{
	if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
	{
		InterruptDisable(m_dwSysIntr2D);
	}

	if (m_hInterrupt2D != NULL)
	{
		CloseHandle(m_hInterrupt2D);
	}

	if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
	{
		KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &m_dwSysIntr2D, sizeof(DWORD), NULL, 0, NULL);
	}	
}