tvenc.c

三星 s3c6400测试代码

//////////
// Function Name : TVENC_SetSubCarrierFreq
// Function Description : Control the Fsc 
// Input : 	uFreq - Current DTO set value + uFreq[14:0]*(2^9)
// Output : 	None
void TVENC_SetSubCarrierFreq(u32 uFreq)
{
	Outp32(FSCCTRL, FSC_CTRL(uFreq));
}


//////////
// Function Name : TVENC_SetFscDTO
// Function Description : Fsc DTO manual control & enable
// Input : 	uVal - FscDTOManual[30:0] = Fsc*(2^33)/Fclk[MHz]
// Output : 	None
void TVENC_SetFscDTO(u32 uVal)
{
	u32 uTemp;

	uTemp = (u32)((u32)(1<<31)|(uVal & 0x7FFFFFFF));
	Outp32(FSCDTOMANCTRL, uTemp);
}


//////////
// Function Name : TVENC_DisableFscDTO
// Function Description : Disable the Fsc DTO manual control
// Input : 	None
// Output : 	None
void TVENC_DisableFscDTO(void)
{
	u32 uTemp;

	uTemp = Inp32(FSCDTOMANCTRL);
	uTemp &= ~(1<<31);
	Outp32(FSCDTOMANCTRL, uTemp);
}


//////////
// Function Name : TVENC_SetBackGround
// Function Description : Set the background color & luminance offset and enable/disable soft mixed enable
// Input : 	bSmeUsed - Soft mixed enable or disable
//			uColNum - Background color select
//			uLumaOffset - Background luminance offset
// Output : 	None
void TVENC_SetBackGround(bool bSmeUsed, u32 uColNum, u32 uLumaOffset)
{
	u32 uBgColor;

	switch (uColNum)
	{
		case 0 : uBgColor = BGC_BGCS_BLACK; break;
		case 1 : uBgColor = BGC_BGCS_BLUE; break;
		case 2 : uBgColor = BGC_BGCS_RED; break;
		case 3 : uBgColor = BGC_BGCS_MAGENTA; break;
		case 4 : uBgColor = BGC_BGCS_GREEN; break;
		case 5 : uBgColor = BGC_BGCS_CYAN; break;
		case 6 : uBgColor = BGC_BGCS_YELLOW; break;
		case 7 : uBgColor = BGC_BGCS_WHITE; break;
	}

	if (bSmeUsed)
		Outp32(BGCTRL, BGC_SME_ENA|uBgColor|BGC_BGYOFS(uLumaOffset));
	else
		Outp32(BGCTRL, BGC_SME_DIS|uBgColor|BGC_BGYOFS(uLumaOffset));
}


//////////
// Function Name : TVENC_SetBgVavHav
// Function Description : Set the background VAV & HAV
// Input : 	uHavLen - Background HAV Length
//			uVavLen - Background VAV Length
//			uHavSt - Background HAV Start Position
//			uVavSt - Background VAV Start Position
// Output : 	None
void TVENC_SetBgVavHav(u32 uHavLen, u32 uVavLen, u32 uHavSt, u32 uVavSt)
{
	Outp32(BGHVAVCTRL, BVH_BG_HL(uHavLen)|BVH_BG_HS(uHavSt)|BVH_BG_VL(uVavLen)|BVH_BG_VS(uVavSt));
}


//////////
// Function Name : TVENC_SetHuePhase
// Function Description : Set the HUE Phase
// Input : 	uInc - HUE Phase value( 0x00 : 0' Phase,  0xFF : 58.5938' Phase)
// Output : 	None
void TVENC_SetHuePhase(u32 uInc)
{
	Outp32(HUECTRL, HUE_CTRL(uInc));
}


//////////
// Function Name : TVENC_GetHuePhase
// Function Description : Get the current HUE Phase value
// Input : 	None
// Output : 	the current HUE Phase value
u32 TVENC_GetHuePhase(void)
{
	u32 uTemp;

	uTemp = Inp32(HUECTRL);
	return (uTemp&0xFF);

	//rb1004....6400
	//return Inp32(HUECTRL);
}


//////////
// Function Name : TVENC_SetContrast
// Function Description : Set the Contrast Gain
// Input : 	uContrast - Contrast gain value
// Output : 	None
void TVENC_SetContrast(u32 uContrast)
{
	u32 uTemp;

	uTemp = Inp32(CONTRABRIGHT);
	uTemp = (uTemp&~(0xFF<<0)) | (uContrast<<0);
	Outp32(CONTRABRIGHT, uTemp);
}


//////////
// Function Name : TVENC_GetContrast
// Function Description : Get the current Contrast gain value
// Input : 	None
// Output : 	the current Contrast gain value
u32 TVENC_GetContrast(void)
{
	u32 uTemp;

	uTemp = Inp32(CONTRABRIGHT);
	return (uTemp & 0xFF);
}


//////////
// Function Name : TVENC_SetBright
// Function Description : Set the Brightness Gain
// Input : 	uBright - Brightness gain value
// Output : 	None
void TVENC_SetBright(u32 uBright)
{
	u32 uTemp;

	uTemp = Inp32(CONTRABRIGHT);
	uTemp = (uTemp&~(0xFF<<16)) | (uBright<<16);
	Outp32(CONTRABRIGHT, uTemp);
}


//////////
// Function Name : TVENC_GetBright
// Function Description : Get the current Brightness gain value
// Input : 	None
// Output : 	the current Brightness gain value
u32 TVENC_GetBright(void)
{
	u32 uTemp;

	uTemp = Inp32(CONTRABRIGHT);
	uTemp = (uTemp & (0xFF<<16))>>16;
	return uTemp;
}


//////////
// Function Name : TVENC_SetCbGain
// Function Description : Set the Cb Gain
// Input : 	uCbGain - Cb gain value
// Output : 	None
void TVENC_SetCbGain(u32 uCbGain)
{
	u32 uTemp;

	uTemp = Inp32(CBCRGAINCTRL);
	uTemp = (uTemp&~(0xFF<<0)) | (uCbGain<<0);
	Outp32(CBCRGAINCTRL, uTemp);
}


//////////
// Function Name : TVENC_GetCbGain
// Function Description : Get the current Cb gain value
// Input : 	None
// Output : 	the current Cb gain value
u32 TVENC_GetCbGain(void)
{
	u32 uTemp;

	uTemp = Inp32(CBCRGAINCTRL);
	uTemp = (uTemp&(0xFF<<0));
	return uTemp;
}


//////////
// Function Name : TVENC_SetCrGain
// Function Description : Set the Cr Gain
// Input : 	uCrGain - Cr gain value
// Output : 	None
void TVENC_SetCrGain(u32 uCrGain)
{
	u32 uTemp;

	uTemp = Inp32(CBCRGAINCTRL);
	uTemp = (uTemp&~(0xFF<<16)) | (uCrGain<<16);
	Outp32(CBCRGAINCTRL, uTemp);
}


//////////
// Function Name : TVENC_GetCrGain
// Function Description : Get the current Cr gain value
// Input : 	None
// Output : 	the current Cr gain value
u32 TVENC_GetCrGain(void)
{
	u32 uTemp;

	uTemp = Inp32(CBCRGAINCTRL);
	uTemp = (uTemp&(0xFF<<16))>>16;
	return uTemp;
}


//////////
// Function Name : TVENC_EnableGammaControl
// Function Description : Enable/Disable Gamma control
// Input : 	bEnable - Enable or Disable
// Output : 	None
void TVENC_EnableGammaControl(bool bEnable)
{
	u32 uTemp;

	uTemp = Inp32(GAMMACTRL);
	
	if(bEnable == TRUE)
		uTemp |= (1<<12);
	else
		uTemp &= ~(1<<12);
		
	Outp32(GAMMACTRL, uTemp);
}


//////////
// Function Name : TVENC_SetGammaGain
// Function Description : Set the Gamma Gain
// Input : 	uGamma - Gamma gain value
// Output : 	None
void TVENC_SetGammaGain(u32 uGamma)
{
	u32 uTemp;

	uTemp = Inp32(GAMMACTRL);
	uTemp = (uTemp&~(0x7<<8)) | (uGamma<<8);
	Outp32(GAMMACTRL, uTemp);
}


//////////
// Function Name : TVENC_GetGammaGain
// Function Description : Get the current Gamma gain value
// Input : 	None
// Output : 	the current Gamma gain value
u32 TVENC_GetGammaGain(void)
{
	u32 uTemp;

	uTemp = Inp32(GAMMACTRL);
	uTemp = (uTemp&(0x7<<8))>>8;
	return uTemp;
}


//////////
// Function Name : TVENC_EnableMuteControl
// Function Description : Enable/Disable the Video Mute control
// Input : 	bEnable - Enable or Disable
// Output : 	None
void TVENC_EnableMuteControl(bool bEnable)
{
	u32 uTemp;

	uTemp = Inp32(MUTECTRL);
	
	if(bEnable == FALSE)
		uTemp |= (1<<0);
	else
		uTemp &= ~(1<<0);
		
	Outp32(MUTECTRL, uTemp);
}


//////////
// Function Name : TVENC_SetMuteYCbCr
// Function Description : Set the Y, Cb, Cr Mute component
// Input : 	uY - Mute Y component
//			uCb - Mute Cb component
//			uCr -Mute Cr component
// Output : 	None
void TVENC_SetMuteYCbCr(u32 uY, u32 uCb, u32 uCr)
{
	u32 uTemp;

	uTemp = Inp32(MUTECTRL);
	uTemp = (uTemp&~(0xFFFFFF<<8)) | ((uCr&0xFF)<<24) | ((uCb&0xFF)<<16) | ((uY&0xFF)<<8);
	Outp32(MUTECTRL, uTemp);
}


//////////
// Function Name : TVENC_GetMuteYCbCr
// Function Description : Get the Y, Cb, Cr Mute component
// Input : 	Output variable address
// Output : 	uY - Mute Y component
//			uCb - Mute Cb component
//			uCr -Mute Cr component
void TVENC_GetMuteYCbCr(u32 *uY, u32 *uCb, u32 *uCr)
{
	u32 uTemp;

	uTemp = Inp32(MUTECTRL);
	*uY= (uTemp&(0xFF<<8))>>8;
	*uCb = (uTemp&(0xFF<<16))>>16;
	*uCr = (uTemp&((u32)(0xFF<<24)))>>24;
}


//////////
// Function Name : TVENC_GetActiveWinCenter
// Function Description : Get the Active window center position
// Input : 	Output variable address
// Output : 	uVer - Vertical active window center position
//			uHor - Horizontal active window center position
void TVENC_GetActiveWinCenter(u32 *uVer, u32 *uHor)
{
	u32 uTemp;

	uTemp = Inp32(HENHOFFSET);
	*uVer= (uTemp&(0x3F<<24))>>24;
	*uHor = (uTemp&(0xFF<<16))>>16;
}


//////////
// Function Name : TVENC_SetActiveWinCenter
// Function Description : Set the Active window center position
// Input : 	uVer - Vertical active window center position
//			uHor - Horizontal active window center position
// Output : 	None
void TVENC_SetActiveWinCenter(u32 uVer, u32 uHor)
{
	u32 uTemp;

	uTemp = Inp32(HENHOFFSET);
	uTemp = (uTemp&~(0x3FFF<<16)) | ((uVer&0x3F)<<24) | ((uHor&0xFF)<<16);
	Outp32(HENHOFFSET, uTemp);
}


//////////
// Function Name : TVENC_EnableEnhancerDemoWindow
// Function Description : Enable/Disable enhancer demo window
// Input : 	bEnable - Enable or Disable
// Output : 	None
void TVENC_EnableEnhancerDemoWindow(bool bEnable)
{
	u32 uTemp;

	uTemp = Inp32(DEMOWINCTRL);
	
	if(bEnable == TRUE)
		uTemp |= (1<<24);
	else
		uTemp &= ~(1<<24);
		
	Outp32(DEMOWINCTRL, uTemp);	
}


//////////
// Function Name : TVENC_SetDemoWinSize
// Function Description : Get the enhancing demo window size
// Input : 	Output variable address
// Output : 	uVWinSize - Vertical demo window size
//			uVStart - Vertical demo window start point
//			uHWinSize - Horizontal demo window size
//			uHStart - Horizontal demo window start point
void TVENC_GetEnhancerDemoWindow(u32 *uVWinSize, u32 *uVStart, u32 *uHWinSize, u32 *uHStart)
{
	u32 uTemp;

	uTemp = Inp32(VDEMOWSIZE);
	*uVWinSize = (uTemp&(0x1FF<<16))>>16;
	*uVStart = uTemp&0x1FF;
	
	uTemp = Inp32(HDEMOWSIZE);
	*uHWinSize = (uTemp&(0x7FF<<16))>>16;
	*uHStart = uTemp&0x7FF;	
}


//////////
// Function Name : TVENC_SetEnhancerDemoWindow
// Function Description : Set the enhancing demo window size
// Input : 	uVWinSize - Vertical demo window size
//			uVStart - Vertical demo window start point
//			uHWinSize - Horizontal demo window size
//			uHStart - Horizontal demo window start point
// Output : 	None
void TVENC_SetEnhancerDemoWindow(u32 uVWinSize, u32 uVStart, u32 uHWinSize, u32 uHStart)
{
	u32 uTemp;

	uTemp = ((uVWinSize&0x1FF)<<16) | (uVStart&0x1FF);
	Outp32(VDEMOWSIZE, uTemp);

	uTemp = ((uHWinSize&0x7FF)<<16) | (uHStart&0x7FF);
	Outp32(HDEMOWSIZE, uTemp);	
}


//////////
// Function Name : TVENC_EnableBackground
// Function Description : Enable/Disable background control
// Input : 	bEnable - Enable or Disable
// Output : 	None
void TVENC_EnableBackground(bool bEnable)
{
	u32 uTemp;

	uTemp = Inp32(BGCTRL);
	if(bEnable == TRUE)
		uTemp |= (1<<8);
	else
		uTemp &= ~(1<<8);
	Outp32(BGCTRL, uTemp);

	uTemp = Inp32(ENCCTRL);
	if(bEnable == TRUE)
		uTemp |= (1<<0);
	else
		uTemp &= ~(1<<0);
	Outp32(ENCCTRL, uTemp);
}


//////////
// Function Name : TVENC_GetBackground
// Function Description : Get the background VAV & HAV
// Input : 	Output variable address
// Output : 	uColor - Background color select
//			uHStart - Background HAV Start Position
//			uVStart - Background VAV Start Position
//			uHVisualSize - Background HAV Length
//			uVVisualSize - Background VAV Length
void TVENC_GetBackground(u32 *uColor, u32 *uHStart, u32 *uVStart, u32 *uHVisualSize, u32 *uVVisualSize)
{
	u32 uTemp;

	uTemp = Inp32(BGCTRL);
	*uColor = (uTemp&(0x07<<4))>>4;

	uTemp = Inp32(BGHVAVCTRL);
	*uHStart = (uTemp&(0xFF<<16))>>16;      
	*uVStart = (uTemp&(0xFF<<0))>>0;  
	*uHVisualSize = (uTemp&((u32)(0xFF<<24)))>>24;
	*uVVisualSize = (uTemp&(0xFF<<8))>>8;
}


//////////
// Function Name : TVENC_SetBackground
// Function Description : Set the background VAV & HAV
// Input : 	uColor - Background color select
//			uHStart - Background HAV Start Position
//			uVStart - Background VAV Start Position
//			uHVisualSize - Background HAV Length
//			uVVisualSize - Background VAV Length
// Output : 	None
void TVENC_SetBackground(u32 uColor, u32 uHStart, u32 uVStart, u32 uHVisualSize, u32 uVVisualSize)
{
	u32 uTemp;

//	Inp32(BGCTRL, uTemp);
//	uTemp = (uTemp & ~(0x7<<4)) | ((uColor&0x07)<<4);
//	Outp32(BGCTRL, uTemp);

	TVENC_SetBackGround(TRUE, uColor, 0);
	
	uTemp = ((uHVisualSize&0xFF)<<24) | ((uHStart&0xFF)<<16) | ((uVVisualSize&0xFF)<<8) | (uVStart&0xFF);
	Outp32(BGHVAVCTRL, uTemp);
}


//////////
// Function Name : TVENC_SetSharpness
// Function Description : Set the Sharpness gain
// Input : 	uSharpness - Sharpness gain
// Output : 	None
void TVENC_SetSharpness(u32 uSharpness)
{
	u32 uTemp;

	uTemp = Inp32(SHARPCTRL);
	uTemp = (uTemp&~(0x3F)) | (uSharpness&0x3f);
	Outp32(SHARPCTRL, uTemp);
}


//////////
// Function Name : TVENC_GetSharpness
// Function Description : Get the current Sharpness gain
// Input : 	None
// Output : 	uSharpness - Sharpness gain
u32 TVENC_GetSharpness(void)
{
	u32 uTemp;

	uTemp = Inp32(SHARPCTRL);
	uTemp = uTemp&0x3F;
	return uTemp;
}

void __irq Isr_TVFifoUnderrun(void)
{
	UART_Printf("@Isr_FifoUnderrun\n");

	TVENC_ClearUnderrunInt();
	INTC_ClearVectAddr();
}


void TVENC_DisplayTVout(TV_STANDARDS eTvmode, eTV_CONN_TYPE eTvout, u32 uSizeX, u32 uSizeY)
{
	TVENC_SetTvConMode(eTvmode, eTvout);
	
	INTC_Enable(NUM_TVENC);
	INTC_SetVectAddr(NUM_TVENC, Isr_TVFifoUnderrun);

	TVENC_SetImageSize(uSizeX*2, uSizeY);
	TVENC_TurnOnOff(1);
}