tvenc_test.c

s3c6400 ADS下官方测试程序

	POST_SetNextFrameStAddr(uImgAddr, 0, &oSc);
	POST_StartProcessing(&oSc);

	while(UART_Getc() != 'q')
	{
		TVENCT_SelectClockDivider();
	}
	
	TVENCT_SetTVParameter();


	INTC_Disable(NUM_TVENC);

	POST_SetInterlaceModeOnOff(0, &oSc);
	POST_StopProcessingOfFreeRun(&oSc);
	while (!POST_IsProcessingDone(&oSc));

	TVENC_TurnOnOff(0);
}



static void TVENCT_FIMD_Scaler_Enc_Dual_Perform(void) // post controller initialize
{
	u32 uImgSz, uLcdClock, uWidth, uHeight;
	u32 uLcdHsz, uLcdVsz;
	//u32 uCameraHsz, uCameraVsz;
	CLK_SRC eLcdClockSrc;

	UART_Printf("[TVENCT_FIMD_Scaler_Enc_Perform]\n");
	UART_Printf("\n");
	
	UART_Printf("Select TV out Image Size\n");
	UART_Printf("[0] : Original Image Size\n");
	UART_Printf("[1] : Full Screen size\n");
	UART_Printf("Select number : ");
	uImgSz = UART_GetIntNum();

	UART_Printf("\n");
	UART_Printf("Select FIMD Source Clock\n");
	UART_Printf("[0] : HCLK\n");
	UART_Printf("[1] : MPLLout\n");
	UART_Printf("Select number : ");
	uLcdClock = UART_GetIntNum();
	if(uLcdClock == 0)
		eLcdClockSrc = (CLK_SRC)HCLK_SRC;
	else
		eLcdClockSrc = (CLK_SRC)ECLK0_SRC;
	
	ScalerT_SelectClockSource();
	
	uImgAddr = CODEC_MEM_ST;
	uImgAddr1 = CODEC_MEM_LMT;	

	// FIMD 4.0
	LCD_InitDISPC(RGB24, uImgAddr, WIN0, false);
	LCD_GetFrmSz(&uLcdHsz, &uLcdVsz, WIN0);
	LCD_SetWinOnOff(1, WIN0);
	LCD_SetOutputPath(LCD_TVRGB);
	LCD_SetClkSrc(eLcdClockSrc);
	LCD_Start();

	//uCameraHsz = uLcdHsz;
	//uCameraVsz = uLcdVsz;
	
	if(uImgSz)
	{
		TVENCT_GetTVFullSize(&uWidth, &uHeight);
	}
	else
	{
		uWidth = uLcdHsz;
		uHeight = uLcdVsz;
	}

	INTC_SetVectAddr(NUM_TVENC, Isr_FifoUnderrun);
	INTC_Enable(NUM_TVENC);
	INTC_SetVectAddr(NUM_CAMIF_P, Isr_CamPview);
	INTC_Enable(NUM_CAMIF_P);	
	
	// FIMC 3.0
	CAMERA_SFRInit();	
	CAMERA_InitSensor();
	CAMERA_InitPreviewPath_1(uLcdHsz, uLcdVsz, uImgAddr, uImgAddr, RGB24, FLIP_NO, ROT_0);

	// TV ENCODER 2.0
	TVENC_SetImageSize(uWidth*2, uHeight);
	TVENC_TurnOnOff(1);

	// POST 2.5
	POST_InitIpForFifoInFifoOut(uLcdHsz, uLcdVsz, uWidth*2, uHeight, YUV, FREE_RUN, &oSc);
	POST_SetInterlaceModeOnOff(1, &oSc);
	POST_StartProcessing(&oSc);

	// foreground
	LCD_InitWin(RGB24, uLcdHsz, uLcdVsz, 0, 0, uLcdHsz, uLcdVsz, 0, 0, uImgAddr1+uLcdHsz*uLcdVsz*4, WIN1, false);
	LCD_SetAlpha(0x8, 0x8, 0x8, 0x8, 0x8, 0x8, WIN1);
	LCD_SetWinOnOff(1, WIN1);

	GLIB_InitInstance(uImgAddr1+uLcdHsz*uLcdVsz*4, uLcdHsz, uLcdVsz, RGB24);
	GLIB_DrawPattern(uLcdHsz, uLcdVsz);

	LCD_Start();
	CAMERA_StartPreviewPath();
	
	while(UART_Getc() != 'q')
	{
		u32 uSelclkval;

		UART_Printf("\n");
		UART_Printf("Select the source clock [0x01 ~ 0x3F] : ");
	
		uSelclkval = (u32)UART_GetIntNum();
		LCD_SetClkVal(uSelclkval);
	}

	INTC_Disable(NUM_TVENC);
	INTC_Disable(NUM_CAMIF_P);

	// oPost die..
	POST_StopProcessingOfFreeRun(&oPost);
	while (!POST_IsProcessingDone(&oPost));	

	// oScaler die..
	POST_SetInterlaceModeOnOff(0, &oSc);
	POST_StopProcessingOfFreeRun(&oSc);
	while (!POST_IsProcessingDone(&oSc));

	// oLcdc die..
	LCD_Stop();

	// oTvenc die..
	TVENC_TurnOnOff(0);

	// oCim die..
	CAMERA_StopPreviewPath();

}



static void TVENCT_POST_FIMD_Scaler_Enc_Perform(void)
{
	u32 uImgSz, uWidth, uHeight, uTestItem;
	u32 uLcdHsz, uLcdVsz;

	UART_Printf("Select Image Size\n");
	UART_Printf("[0] : Original Image Size\n");
	UART_Printf("[1] : Full Screen size\n");
	UART_Printf("Select number : ");
	uImgSz = UART_GetIntNum();

	if(uImgSz)
	{
		TVENCT_GetTVFullSize(&uWidth, &uHeight);
	}
	else
	{
		uWidth = uImgXsize;
		uHeight = uImgYsize;
	}

	uTestItem = 1;
	
	INTC_Enable(NUM_TVENC);
	INTC_SetVectAddr(NUM_TVENC, Isr_FifoUnderrun);
	
	// TV ENCODER 2.0
	TVENC_SetImageSize(uWidth*2, uHeight);
	TVENC_TurnOnOff(1);

	// FIMD 4.0
	if(uTestItem == 0)
		LCD_InitBase1(uImgXsize, uImgYsize);
	else if(uTestItem == 1)
		LCD_InitBase();
	LCD_InitWinForFifoIn(IN_POST, WIN0);
	LCD_SetWinOnOff(1, WIN0);	
	LCD_SetOutputPath(LCD_TV);
	LCD_GetFrmSz(&uLcdHsz, &uLcdVsz, WIN0);
	
	if(uTestItem == 0)
		POST_InitIpForFifoInFifoOut(	uImgXsize, uImgYsize, uWidth*2, uHeight, YUV, FREE_RUN, &oSc);
	else if(uTestItem == 1)
		POST_InitIpForFifoInFifoOut(	uLcdHsz, uLcdVsz, uWidth*2, uHeight, YUV, FREE_RUN, &oSc);
	
	POST_SetInterlaceModeOnOff(1, &oSc);
	POST_StartProcessing(&oSc);

	LCD_Start();

	// POST 2.5
	if(uTestItem == 0)
		POST_InitIpForDmaInFifoOut(uImgXsize, uImgYsize, uImgAddr, uImgResolution, 
									uImgXsize, uImgYsize, RGB, 1, &oPost);
	else if(uTestItem == 1)
		POST_InitIpForDmaInFifoOut(uImgXsize, uImgYsize, uImgAddr, uImgResolution, 
									uLcdHsz, uLcdVsz, RGB, 1, &oPost);
	POST_SetNextFrameStAddr(uImgAddr, 0, &oPost);
	POST_StartProcessing(&oPost);

	while(UART_Getc() != 'q')
	{
		u32 uSelclkval;

		UART_Printf("\n");
		UART_Printf("Select the source clock [0x01 ~ 0x3F] : ");
	
		uSelclkval = (u32)UART_GetIntNum();
		LCD_SetClkVal(uSelclkval);
	}
	TVENCT_SetTVParameter();

	INTC_Disable(NUM_TVENC);

	// oPost die..
	POST_StopProcessingOfFreeRun(&oPost);
	Delay(1000);

	// oScaler die..
	POST_SetInterlaceModeOnOff(0, &oSc);
	POST_StopProcessingOfFreeRun(&oSc);
	Delay(1000);

	// oLcdc die..
	LCD_Stop();

	// oTvenc die..
	TVENC_TurnOnOff(0);
}


extern void POSTT_SelectClockSource(void);
static void TVENCT_POST_FIMD_Scaler_Enc_Dual_Perform(void)
{
	u32 uImgSz, uLcdClock, uWidth, uHeight;
	u32 uLcdHsz, uLcdVsz;
	u32 uCameraHsz, uCameraVsz;
	CLK_SRC eLcdClockSrc;
	
	UART_Printf("Select Image Size\n");
	UART_Printf("[0] : Original Image Size\n");
	UART_Printf("[1] : Full Screen size\n");
	UART_Printf("Select number : ");
	uImgSz = UART_GetIntNum();

	POSTT_SelectClockSource();
	
	UART_Printf("\n");
	UART_Printf("Select FIMD Source Clock\n");
	UART_Printf("[0] : HCLK\n");
	UART_Printf("[1] : MPLLout\n");
	UART_Printf("Select number : ");
	uLcdClock = UART_GetIntNum();
	if(uLcdClock == 0)
		eLcdClockSrc = (CLK_SRC)HCLK_SRC;
	else
		eLcdClockSrc = (CLK_SRC)ECLK0_SRC;
	
	ScalerT_SelectClockSource();
	
	uImgAddr = CODEC_MEM_ST;
	uImgAddr1 = CODEC_MEM_LMT;	

	// FIMD 4.0
	LCD_InitBase();
	LCD_InitWinForFifoIn(IN_POST, WIN0);
	LCD_GetFrmSz(&uLcdHsz, &uLcdVsz, WIN0);
	LCD_SetWinOnOff(1, WIN0);
	LCD_SetOutputPath(LCD_TVRGB);
	LCD_SetClkSrc(eLcdClockSrc);
	
	uCameraHsz = uLcdHsz;
	uCameraVsz = uLcdVsz;
	
	if(uImgSz)
	{
		TVENCT_GetTVFullSize(&uWidth, &uHeight);
	}
	else
	{
		//uWidth = uLcdHsz;
		//uHeight = uLcdVsz;
		uWidth = 360;
		uHeight = 480;
	}
	
	INTC_SetVectAddr(NUM_TVENC, Isr_FifoUnderrun);
	INTC_Enable(NUM_TVENC);
	INTC_SetVectAddr(NUM_CAMIF_P, Isr_CamPview);
	INTC_Enable(NUM_CAMIF_P);	
	
	// FIMC 3.0
	CAMERA_SFRInit();	
	CAMERA_InitSensor();
	CAMERA_InitPreviewPath_1(uCameraHsz, uCameraVsz, uImgAddr, uImgAddr1, YCBYCR, FLIP_NO, ROT_0);
	CAMERA_StartPreviewPath();
	//GLIB_InitInstance(uImgAddr, uCameraHsz, uCameraVsz, RGB24);
	//GLIB_DrawPattern2(uCameraHsz, uCameraVsz);
	//GLIB_InitInstance(uImgAddr1, uCameraHsz, uCameraVsz, RGB24);
	//GLIB_DrawPattern2(uCameraHsz, uCameraVsz);
	
	// TV ENCODER 2.0
	TVENC_SetImageSize(uWidth*2, uHeight);
	TVENC_TurnOnOff(1);

	// POST 2.5
	POST_InitIpForFifoInFifoOut(uLcdHsz, uLcdVsz, uWidth*2, uHeight, YUV, FREE_RUN, &oSc);
	POST_SetInterlaceModeOnOff(1, &oSc);
	POST_StartProcessing(&oSc);

	// foreground
	LCD_InitWin(RGB24, uLcdHsz, uLcdVsz, 0, 0, uLcdHsz, uLcdVsz, 0, 0, uImgAddr1+uCameraHsz*uCameraVsz*4, WIN1, false);
	LCD_SetAlpha(0x8, 0x8, 0x8, 0x8, 0x8, 0x8, WIN1);
	LCD_SetWinOnOff(1, WIN1);

	GLIB_InitInstance(uImgAddr1+uCameraHsz*uCameraVsz*4, uLcdHsz, uLcdVsz, RGB24);
	GLIB_DrawPattern(uLcdHsz, uLcdVsz);

	LCD_Start();
	
	// POST 2.5
	POST_InitIpForDmaInFifoOut(uCameraHsz, uCameraVsz, uImgAddr, YCBYCR, uLcdHsz, uLcdVsz, RGB, 1, &oPost);
	//POST_InitIpForDmaInFifoOut(uCameraHsz, uCameraVsz, uImgAddr, RGB24, uLcdHsz, uLcdVsz, RGB, 1, &oPost);
	POST_SetNextFrameStAddr(uImgAddr1, 0, &oPost);
	POST_SetInterlaceModeOnOff(0, &oPost);

	POST_StartProcessing(&oPost);

	while(UART_Getc() != 'q')
	{
		u32 uSelclkval;

		UART_Printf("\n");
		UART_Printf("Select the source clock [0x01 ~ 0x3F] : ");
	
		uSelclkval = (u32)UART_GetIntNum();
		LCD_SetClkVal(uSelclkval);
	}
	TVENCT_SetTVParameter();

	INTC_Disable(NUM_TVENC);
	INTC_Disable(NUM_CAMIF_P);

	// oPost die..
	POST_StopProcessingOfFreeRun(&oPost);
	while (!POST_IsProcessingDone(&oPost));	

	// oScaler die..
	POST_SetInterlaceModeOnOff(0, &oSc);
	POST_StopProcessingOfFreeRun(&oSc);
	while (!POST_IsProcessingDone(&oSc));

	// oLcdc die..
	LCD_Stop();

	// oTvenc die..
	TVENC_TurnOnOff(0);

	// oCim die..
	CAMERA_StopPreviewPath();
}



const testFuncMenu tvenc_scenario_menu[]=
{
	TVENCT_Scaler_Enc_Perform,							"TV Only  : [SCALER -> TVenc]",
	TVENCT_POST_FIMD_Scaler_Enc_Perform,				"TV Only  : [POST -> FIMD -> SCALER -> TVenc ]",
	TVENCT_FIMD_Scaler_Enc_Dual_Perform,				"LCD & TV : [FIMD -> SCALER -> TVenc]",
	TVENCT_POST_FIMD_Scaler_Enc_Dual_Perform,		"LCD & TV : [POST -> FIMD -> SCALER -> TVenc]",
	0,0
};

void TVENCT_ScenarioPerform(void)
{
	u32 i;
	s32 sSel;
	
	UART_Printf("\n");
	UART_Printf("[TVENCT_ScenarioPerform]\n");
	
	while(1)
	{
		UART_Printf("\n");
		for (i=0; (int)(tvenc_scenario_menu[i].desc)!=0; i++)
			UART_Printf("%2d: %s\n", i, tvenc_scenario_menu[i].desc);

		UART_Printf("\nSelect the function to test : ");
		sSel = UART_GetIntNum();
		UART_Printf("\n");

		if (sSel == -1)
			break;
		if (sSel>=0 && sSel<(sizeof(tvenc_scenario_menu)/8-1))
			(tvenc_scenario_menu[sSel].func)();
	}
}


const testFuncMenu tvenc_menu[]=
{
	TVENCT_Scaler_Enc,								"TV on [SCALER -> ENCODER]",
	TVENCT_FIMD_Scaler_Enc,						"TV on [FIMD -> SCALER -> ENCODER]",
	TVENCT_POST_FIMD_Scaler_Enc,					"TV on [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_Dual_POST_CPUFIMD_Scaler_Enc,			"Dual Display (CPU-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_Dual_POST_RGBFIMD_Scaler_Enc,			"Dual Display (RGB-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_DualBuffer_POST_CPUFIMD_Scaler_Enc,	"Double Buffer (CPU-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_DualBuffer_POST_RGBFIMD_Scaler_Enc,	"Double Buffer (RGB-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_MultiLayer_POST_CPUFIMD_Scaler_Enc,	"Multi Layer (CPU-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_MultiLayer_POST_RGBFIMD_Scaler_Enc,	"Multi Layer (RGB-LCD + TV) [POST -> FIMD -> SCALER -> ENCODER]",
	TVENCT_OtherImage_LCDandTV,					"Other image display(RGB-LCD + TV) [POST -> FIMD & SCALER -> ENCODER]",
	TVENCT_MakeImage,								"Make Image",
	TVENCT_LoadImageToMemory,					"Load Image File",	
	TVENCT_SetTVParameter,							"Set Parameter",
	TVENCT_ScenarioPerform,						"Scenario Performance",
	
	0,0
};

	
void TVENC_Test(void)
{
	u32 i;
	s32 sSel;

	TVENCT_SelectTVOutputFormat();
	
	POST_InitCh(POST_A, &oPost);
	POST_InitCh(POST_B, &oSc);

	//Camera Setting
	GPIO_SetFunctionAll( eGPIO_F, 0x2aaaaaa, 0); // Camera GPIO Setting : rGPFCON = 0x2aa aaaa
	GPIO_SetPullUpDownAll(eGPIO_F, 0);
   	CAMERA_ClkSetting(); // Camera Module CLK Setting

	//LCD Setting
	LCD_SetPort();
	LCD_InitLDI(MAIN);
	LCD_Stop();

	//TVENCT_MakeImage();
	//TVENCT_Scaler_Enc();
	
	while(1)
	{
		UART_Printf("\n");
		for (i=0; (int)(tvenc_menu[i].desc)!=0; i++)
			UART_Printf("%2d: %s\n", i, tvenc_menu[i].desc);

		UART_Printf("\nSelect the function to test : ");
		sSel = UART_GetIntNum();
		UART_Printf("\n");

		if (sSel == -1)
			break;
		if (sSel>=0 && sSel<(sizeof(tvenc_menu)/8-1))
			(tvenc_menu[sSel].func)();
	}
}