📄 hal_display.c

📁 一款SmartPhone的驱动代码
💻 C
📖 第 1 页 / 共 3 页
字号:
上一页 1 23
		else
			width = halReadReg16(REG0224_PIP_X_END_POS) - halReadReg16(REG0220_PIP_X_START_POS) + 1;
	}
	else
	{
		if (swivel == 90 || swivel == 270)
			width = GetLcdVdp(GetOutputPort());
		else
			width = GetLcdHdp(GetOutputPort());
	}

	if (GetPixelDoubling(WindowNum) & cl_PIXELDOUBLE_HORIZ)
		width /= 2;

	return width;
}




/****************************************************************************
; Function:	Get the Display Height	
; Input :	Window Number
; Output :	Display Height
; Format :	unsigned long GetDisplayHeight(WindowDef WindowNum)
;****************************************************************************/
unsigned long GetDisplayHeight(WindowDef WindowNum)
{
	unsigned long height;
	unsigned long swivel = GetSwivelViewMode(WindowNum);

	if (WindowNum == cl_PIP_WINDOW)
	{
		if (swivel == 90 || swivel == 270)
			height = halReadReg16(REG0224_PIP_X_END_POS) - halReadReg16(REG0220_PIP_X_START_POS) + 1;
		else
			height = halReadReg16(REG0226_PIP_Y_END_POS) - halReadReg16(REG0222_PIP_Y_START_POS) + 1;
	}
	else
	{
		if (swivel == 90 || swivel == 270)
			height = GetLcdHdp(GetOutputPort());
		else
			height = GetLcdVdp(GetOutputPort());
	}		

	if (GetPixelDoubling(WindowNum) & cl_PIXELDOUBLE_VERT)
		height /= 2;

	return height;
}


/****************************************************************************
; Function:	Set the YUV to RGB enable 	
; Input :
; Output :	None
; Format :	void SetYUVToRGBEn(Boolean enable)
;****************************************************************************/
void SetYUVToRGBEn(BOOL enable)
{

	unsigned short reg = halReadReg16( REG0240_YUVRGB_TRANSLATE_MODE);
	reg &= (~0x8000);
	reg |= ( unsigned short )(enable << 15);
	halWriteReg16( REG0240_YUVRGB_TRANSLATE_MODE, reg );

}

/****************************************************************************
; Function:	Set the YUV to RGB mode 	
; Input :
; Output :	None
; Format :	void SetYUVToRGBMode(unsigend short mode)
;****************************************************************************/
void SetYUVToRGBMode(unsigned short mode)
{

	unsigned short reg = halReadReg16( REG0240_YUVRGB_TRANSLATE_MODE);
	reg &= (~0x0007);
	reg |= ( unsigned short )(mode&0x0007);
	halWriteReg16( REG0240_YUVRGB_TRANSLATE_MODE, reg );

}

/****************************************************************************
; Function:	Set the YUV to RGB mode 	
; Input :
; Output :	None
; Format :	void SetYUVToRGBMode(unsigend short mode)
;****************************************************************************/
void SetYUVToRGBType(unsigned short mode)
{

	unsigned short reg = halReadReg16( REG0240_YUVRGB_TRANSLATE_MODE);
	reg &= (~0x0010);
	reg |= (unsigned short )((mode<<4)&0x0010);
	halWriteReg16( REG0240_YUVRGB_TRANSLATE_MODE, reg );

}

/****************************************************************************
; Function:	Set the YUV Image start address 	
; Input :	
; Output :	
; Format :	void SetYUVImageStartAddress(unsigned long address)
;****************************************************************************/
void SetYUVImageStartAddress(unsigned long address)
{
	halWriteReg16( REG0242_YUV_WR_START_ADDR0REG0, (unsigned short)address );
	halWriteReg16( REG0244_YUV_WR_START_ADDR0REG1, (unsigned short)(address >> 16) );

}

/****************************************************************************
; Function:	Set the YUV output type 	
; Input :
; Output :	None
; Format :	void SetYUVToRGBMode(unsigend short mode)
;****************************************************************************/
void SetYUVOutputType(unsigned short mode)
{

	unsigned short reg = halReadReg16( REG0240_YUVRGB_TRANSLATE_MODE);
	reg &= (~0x0100);
	reg |= (unsigned short )((mode<<8)&0x0100);
	halWriteReg16( REG0240_YUVRGB_TRANSLATE_MODE, reg );

}

/****************************************************************************
; Function:	Set the YRC to RGB Bpp 	
; Input :
; Output :	None
; Format :	void SetYUVToRGBMode(unsigend short mode)
;****************************************************************************/
void SetYRCToRGBBpp(unsigned short mode)
{

	unsigned short reg = halReadReg16( REG0240_YUVRGB_TRANSLATE_MODE);

	mode=mode/8-1;
	reg &= (~0x0C00);
	reg |= ( unsigned short )(mode<<10&0x0C00);
	halWriteReg16( REG0240_YUVRGB_TRANSLATE_MODE, reg );

}

/****************************************************************************
; Function:	Set Overlay Key Color 	
; Input :	Overlay Mode
;		red green blue
; Output :	None
; Format :	void SetOverlayKeyColor(OverlayModeDef mode, unsigned char red, unsigned char green, unsigned char blue)
;****************************************************************************/
void SetOverlayKeyColor(OverlayModeDef mode, unsigned char red, unsigned char green, unsigned char blue)
{
	if (mode & cl_OVERLAY_TRANS)
	{
		halWriteReg16(REG0204_OVERLAY_KEY_COL_RED, red);
		halWriteReg16(REG0206_OVERLAY_KEY_COL_GREEN, green);
		halWriteReg16(REG0208_OVERLAY_KEY_COL_BLUE, blue);
	}

	if (mode & cl_OVERLAY_AVG)
	{
		halWriteReg16(REG0310_AVG_OVERLAY_KEY_COL_RED, red);
		halWriteReg16(REG0312_AVG_OVERLAY_KEY_COL_GREEN, green);
		halWriteReg16(REG0314_AVG_OVERLAY_KEY_COL_BLUE, blue);
	}

	if (mode & cl_OVERLAY_AND)
	{
		halWriteReg16(REG0316_AND_OVERLAY_KEY_COL_RED, red);
		halWriteReg16(REG0318_AND_OVERLAY_KEY_COL_GREEN, green);
		halWriteReg16(REG031A_AND_OVERLAY_KEY_COL_BLUE, blue);
	}

	if (mode & cl_OVERLAY_OR)
	{
		halWriteReg16(REG031C_OR_OVERLAY_KEY_COL_RED, red);
		halWriteReg16(REG031E_OR_OVERLAY_KEY_COL_GREEN, green);
		halWriteReg16(REG0320_OR_OVERLAY_KEY_COL_BLUE, blue);
	}

	if (mode & cl_OVERLAY_INV)
	{
		halWriteReg16(REG0322_INV_OVERLAY_KEY_COL_RED, red);
		halWriteReg16(REG0324_INV_OVERLAY_KEY_COL_GREEN, green);
		halWriteReg16(REG0326_INV_OVERLAY_KEY_COL_BLUE, blue);
	}
}

/****************************************************************************
; Function:	Get Overlay Key Color 	
; Input :	Overlay mode the pointer of red green and blue
; Output :	True/false
; Format :	Boolean GetOverlayKeyColor(OverlayModeDef mode, unsigned char *red, unsigned char *green, unsigned char *blue)
;****************************************************************************/
BOOL GetOverlayKeyColor(OverlayModeDef mode, unsigned char *red, unsigned char *green, unsigned char *blue)
{
	*red = *green = *blue = 0;

	switch (mode)
	{
		case cl_OVERLAY_NONE:
		default:
			return FALSE;

		case cl_OVERLAY_TRANS:
			*red = (unsigned char) halReadReg16(REG0204_OVERLAY_KEY_COL_RED);
			*green = (unsigned char) halReadReg16(REG0206_OVERLAY_KEY_COL_GREEN);
			*blue = (unsigned char) halReadReg16(REG0208_OVERLAY_KEY_COL_BLUE);
			return TRUE;
			break;

		case cl_OVERLAY_AVG:
			*red = (unsigned char) halReadReg16(REG0310_AVG_OVERLAY_KEY_COL_RED);
			*green = (unsigned char) halReadReg16(REG0312_AVG_OVERLAY_KEY_COL_GREEN);
			*blue = (unsigned char) halReadReg16(REG0314_AVG_OVERLAY_KEY_COL_BLUE);
			return TRUE;
			break;

		case cl_OVERLAY_AND:
			*red = (unsigned char) halReadReg16(REG0316_AND_OVERLAY_KEY_COL_RED);
			*green = (unsigned char) halReadReg16(REG0318_AND_OVERLAY_KEY_COL_GREEN);
			*blue = (unsigned char) halReadReg16(REG031A_AND_OVERLAY_KEY_COL_BLUE);
			return TRUE;
			break;

		case cl_OVERLAY_OR:
			*red = (unsigned char) halReadReg16(REG031C_OR_OVERLAY_KEY_COL_RED);
			*green = (unsigned char) halReadReg16(REG031E_OR_OVERLAY_KEY_COL_GREEN);
			*blue = (unsigned char) halReadReg16(REG0320_OR_OVERLAY_KEY_COL_BLUE);
			return TRUE;
			break;

		case cl_OVERLAY_INV:
			*red = (unsigned char) halReadReg16(REG0322_INV_OVERLAY_KEY_COL_RED);
			*green = (unsigned char) halReadReg16(REG0324_INV_OVERLAY_KEY_COL_GREEN);
			*blue = (unsigned char) halReadReg16(REG0326_INV_OVERLAY_KEY_COL_BLUE);
			return TRUE;
			break;
	}
}


/****************************************************************************
; Function:	Set Win Bit Shift	
; Input :	Windows number
;		Bit Shift
; Output :	false / true
; Format :	Boolean SetWinBitShift(WindowDef WindowNum, BitShiftDef BitShift)
;****************************************************************************/
BOOL SetWinBitShift(WindowDef WindowNum, BitShiftDef BitShift)
{
	unsigned short reg;

	switch (WindowNum)
	{
		default:
		case cl_MAIN_WINDOW:
			reg = (unsigned short) (halReadReg16(REG0328_OVERLAY_MISCELLANEOUS) & ~0x2000);
		
			switch (BitShift)
			{
				case cl_BIT_SHIFT_NONE:
					break;
		
				case cl_BIT_SHIFT_DIVIDE2:
					reg |= 0x2000;
					break;
		
				default:
					return FALSE;
					break;
			}
			break;

		case cl_PIP_WINDOW:
			reg = (unsigned short) (halReadReg16(REG0328_OVERLAY_MISCELLANEOUS) & ~0x8000);
		
			switch (BitShift)
			{
				case cl_BIT_SHIFT_NONE:
					break;
		
				case cl_BIT_SHIFT_DIVIDE2:
					reg |= 0x8000;
					break;
		
				default:
					return FALSE;
					break;
			}
			break;
	}

	halWriteReg16(REG0328_OVERLAY_MISCELLANEOUS, reg);
	return TRUE;
}

/****************************************************************************
; Function:	Get Win Bit Shift 	
; Input :	Windows Number
; Output :	Bit shift
; Format :	BitShiftDef GetWinBitShift(WindowDef WindowNum)
;****************************************************************************/
BitShiftDef GetWinBitShift(WindowDef WindowNum)
{
	switch (WindowNum)
	{
		default:
		case cl_MAIN_WINDOW:
			if (halReadReg16(REG0328_OVERLAY_MISCELLANEOUS) & 0x2000)
				return cl_BIT_SHIFT_DIVIDE2;
			else
				return cl_BIT_SHIFT_NONE;
			break;

		case cl_PIP_WINDOW:
			if (halReadReg16(REG0328_OVERLAY_MISCELLANEOUS) & 0x8000)
				return cl_BIT_SHIFT_DIVIDE2;
			else
				return cl_BIT_SHIFT_NONE;
			break;
	}
}

/****************************************************************************
; Function:	Set Overlay Key Color Enable 	
; Input :	Overlay Mode 
;		Enable/Disable
; Output :	None
; Format :	void SetOverlayKeyColorEnable(OverlayModeDef OverlayMode, unsigned short enable)
;****************************************************************************/
void SetOverlayKeyColorEnable(OverlayModeDef OverlayMode, unsigned short enable)
{
	unsigned short reg;

	reg = halReadReg16(REG0328_OVERLAY_MISCELLANEOUS);

	if (OverlayMode & cl_OVERLAY_TRANS)
	{
		if (enable)
			reg |= 0x0001;
		else
			reg &= ~0x0001;
	}

	if (OverlayMode & cl_OVERLAY_AVG)
	{
		if (enable)
			reg |= 0x0002;
		else
			reg &= ~0x0002;
	}

	if (OverlayMode & cl_OVERLAY_AND)
	{
		if (enable)
			reg |= 0x0004;
		else
			reg &= ~0x0004;
	}

	if (OverlayMode & cl_OVERLAY_OR)
	{
		if (enable)
			reg |= 0x0008;
		else
			reg &= ~0x0008;
	}

	if (OverlayMode & cl_OVERLAY_INV)
	{
		if (enable)
			reg |= 0x0010;
		else
			reg &= ~0x0010;
	}

	halWriteReg16(REG0328_OVERLAY_MISCELLANEOUS, reg);
}

/****************************************************************************
; Function:	Get Overlay Key Color Enable 	
; Input :	None
; Output :	Overlay Mode
; Format :	OverlayModeDef GetOverlayKeyColorEnable(void)
;****************************************************************************/
OverlayModeDef GetOverlayKeyColorEnable(void)
{
	OverlayModeDef KeyColorEnable;
	unsigned short reg;

	KeyColorEnable = cl_OVERLAY_NONE;
	reg = halReadReg16(REG0328_OVERLAY_MISCELLANEOUS);

	if (reg & 0x0001)
		KeyColorEnable |= cl_OVERLAY_TRANS;

	if (reg & 0x0002)
		KeyColorEnable |= cl_OVERLAY_AVG;

	if (reg & 0x0004)
		KeyColorEnable |= cl_OVERLAY_AND;

	if (reg & 0x0008)
		KeyColorEnable |= cl_OVERLAY_OR;

	if (reg & 0x0010)
		KeyColorEnable |= cl_OVERLAY_INV;

	return KeyColorEnable;
}
上一页 1 23
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -