}

	printf(" Which file to read ? ");
	sel = GetIntNum();
	if (!FAT_ReadFile2(sel, uJpgAddr, &uJpgSize, &oSdhc))
		printf(" Loading failed ....\n");

	FAT_UnloadFileSystem(&oSdhc);
	SDHC_CloseMedia(&oSdhc);

	printf(" Stream size = %d bytes\n", uJpgSize);
	bIsJpgLoaded = true;

}

static void SaveRawImgToFile(void)
{
#if	 SEMIHOSTING
	SaveToFile(YUV_FILE_NAME, uRawImgHSz_Dec*uRawImgVSz_Dec*2, uRawImgAddr);
#else
	// Under Construction. SD will be used.
#endif
}

static void TestDecodingConformance(void)
{
	//JPEG_TYPE eJpgType;
	u32 uJpgSize, i;
	char cKey;
	char pFileName[50];
	u32 uNumOfFiles, uCnt;
	char pType[30];

	bIsOneStep = false;
	
	if ((!SDHC_OpenMedia(SDHC_HCLK, &oSdhc))||(!FAT_LoadFileSystem(&oSdhc)))
	{
		printf("FAIL TO OPEN MEDIA OR FAIL TO LOAD FILE SYSTEM\n");
		return;
	}

	FAT_GetTotalNumOfFiles(&uNumOfFiles, &oSdhc);
	for (i=0; i<uNumOfFiles; i++)
	{
		FAT_GetFileName(i, pFileName, &oSdhc);
		printf("%02d -- %s\n", i, pFileName);
	}

	FAT_GetTotalNumOfFiles(&uNumOfFiles, &oSdhc);

	for (uCnt=0; uCnt<uNumOfFiles; uCnt++)
	{
		if (!FAT_ReadFile2(uCnt, uJpgAddr, &uJpgSize, &oSdhc))
		{
			printf(" Loading failed .......\n");
			continue;
		}

		FAT_GetFileName(uCnt, pFileName, &oSdhc);

		printf(" 1. %s\n", pFileName);

		INTC_Init();
		INTC_SetVectAddr(NUM_JPEG, Isr_Jpeg);
		INTC_Enable(NUM_JPEG);

		bJpegDone = false;

		// Header Parsing
		JPEG_StartParsingHeader(uJpgAddr);
		WaitForSet(bJpegDone);
		if (eJpgStatus != OK_HD_PARSING)
			printf(" Parsing Error -------------------------------\n");

		JPEG_GetJpegType1(pType);
		printf(" 2. %s\n", pType);

		JPEG_GetDecodedWidthAndHeight(&uRawImgHSz_Dec, &uRawImgVSz_Dec);
		if ( uRawImgHSz_Dec == 0 || uRawImgVSz_Dec == 0 )
			printf("Error! Widht or Height is zero\n");
		else 
			printf(" 3. W = %d, H = %d\n", uRawImgHSz_Dec, uRawImgVSz_Dec);

		// Decoding body
		uRawImgAddr = uJpgAddr+((uJpgSize+16)/16)*16;
		bJpegDone = false;
		JPEG_StartDecodingBody(uRawImgAddr, false);
		WaitForSet(bJpegDone);
		if (eJpgStatus != OK_ENC_OR_DEC)
			printf(" Decoding Error -------------------------------\n");

		// printflay the image
		CAMERA_InitDmaInPath(uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, YCBYCR,
			uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, FLIP_NO, ROT_0, C_PATH);

		bCamifDone = false;
		CAMERA_StartDmaInPath();
		WaitForConversionDone(bCamifDone);

		printf("\n Hit any key to continue, \'x\' to exit\n\n");
		cKey = Getc();
		if (cKey == 'X' || cKey == 'x')
			break;
	}
	FAT_UnloadFileSystem(&oSdhc);
	SDHC_CloseMedia(&oSdhc);
	
}

static void SetJpegTypeForEnc(void)
{
	u32 uSelFmt;

	while (true)
	{
		printf("[0] Exit\n");
		printf("[1] YUV422 \n");
		printf("[2] YUV420 \n");

		printf("\n");
		printf("Enter the encoding format: ");

		uSelFmt = GetIntNum();

		if (uSelFmt == 0)
			return;
		else if (uSelFmt >=1 && uSelFmt <=2)
		{
			eJpgFormat = (uSelFmt == 1) ? JPEG_422: JPEG_420;
			printf("eJpgFormat = 0x%x\n", eJpgFormat);
			break;
		}
		else
			printf("Invalid Input! Retry It!!\n");
	}
}

void TestEncoding(void)
{
	bIsOneStep = false;	

	//SetRawImgTypeForEnc();
	SetJpegTypeForEnc();
	
	Assert(eRawImgFormat == YCBYCR || eRawImgFormat == RGB16);

	INTC_Init();
	INTC_SetVectAddr(NUM_JPEG, Isr_Jpeg);
	INTC_SetVectAddr(NUM_CAMIF_C, Isr_Camif_C);	
	INTC_Enable(NUM_JPEG);
	INTC_Enable(NUM_CAMIF_C);

	// Draw src. img.
	//GLIB oGlib(uGlibAddr, uRawImgHsz_Enc, uRawImgVsz_Enc, RGB16);
	//oGlib.DrawPattern(PTN1);
	GLIB_InitInstance(uGlibAddr, uRawImgHsz_Enc, uRawImgVsz_Enc, RGB16);
	GLIB_DrawPattern(uRawImgHsz_Enc, uRawImgVsz_Enc);

	if (eRawImgFormat == YCBYCR)
	{
		CAMERA_InitDmaInPath(uRawImgHsz_Enc, uRawImgVsz_Enc, uGlibAddr, RGB16,
			uRawImgHsz_Enc, uRawImgVsz_Enc, uRawImgAddr, YCBYCR, FLIP_NO, ROT_0, C_PATH);

		bCamifDone = false;
		CAMERA_StartDmaInPath();
		WaitForConversionDone(bCamifDone);
		
		/*
		POST_InitIp(	uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, YCBYCR,
					uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, 1, false, ONE_SHOT, &oPost);
		bCamifDone = false;
		POST_StartProcessing(&oPost);
		while (!POST_IsFreeRunDone(&oPost));
		*/
	}

	uRawImgAddr = (eRawImgFormat == YCBYCR) ? uRawImgAddr : uGlibAddr;

	bJpegDone = false;
	JPEG_StartEncodingOneFrame(uRawImgHsz_Enc, uRawImgVsz_Enc, uRawImgAddr, eRawImgFormat,
		uJpgAddr, eJpgFormat);
	WaitForSet(bJpegDone);

	Assert(eJpgStatus == OK_ENC_OR_DEC);

	JPEG_GetEncodedStreamLen(&uJpgSize);
	printf(" Encoded Stream = %d bytes\n", uJpgSize);
	
}

static void SaveJpegStreamToFile(void)
{

#if	 SEMIHOSTING
	SaveToFile(CAPTURED_JPEG, uJpgSize, uJpgAddr);
#else
	// Under Construction. SD will be used.
#endif

}

void Test_EncMotionJPEG(void)
{
	char x=0;
	u32 uSrcHsz ,uSrcVsz ;
	u32 uCaptureHsz, uCaptureVsz;
	CSPACE eDstDataFmt = RGB16;
	IMG_SIZE eCodecSz=VGA;
	IMG_SIZE ePreviewSz = VGA;

	u32 uCodecAddr = uJpgAddr + 0x500000;

	LCD_InitLDI(MAIN);
	LCD_InitDISPC(eDstDataFmt, uLcdFbAddr, WIN0, false);
	LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);
	LCD_Start();

	INTC_Init();
	INTC_SetVectAddr(NUM_JPEG, Isr_EncMotion);
	INTC_SetVectAddr(NUM_CAMIF_C, Isr_Camif_C);	
	INTC_Enable(NUM_JPEG);
	INTC_Enable(NUM_CAMIF_C);
	
	CAMERA_InitSensor1(ePreviewSz, CCIR601, YCBYCR);
	CAMERA_GetSrcImgSz(&uSrcHsz, &uSrcVsz);

	uSrcHsz = (uSrcHsz > uLcdHSz) ? uLcdHSz : uSrcHsz;
	uSrcVsz = (uSrcVsz > uLcdVSz) ? uLcdVSz : uSrcVsz;

	CAMERA_InitPreviewPath(uSrcHsz, uSrcVsz, uLcdFbAddr, eDstDataFmt, FLIP_NO, ROT_0);
	CAMERA_StartPreviewPath();

	while(true)
	{
		printf("x = Turn off Camera, s = Capture IMG(Enocoded To JPEG), c = Change IMG Size : ");
		x = Getc();
		printf("%c\n", x);

		if(x == 'x' || x=='X')
		{
			CAMERA_StopPreviewPath();
			break;
		}
		else if(x=='s' || x=='S')
		{
			CAMERA_StopPreviewPath();
			//CIM_SetSensorSize(eCodecSz);

			bCamifDone = false;
			
			ConvertImgSzToNumber(eCodecSz, &uCaptureHsz, &uCaptureVsz);
			eDstDataFmt = YCBYCR;

			CAMERA_InitCodecPath(uCaptureHsz, uCaptureVsz, uCodecAddr,  eDstDataFmt, FLIP_NO, ROT_0);
			CAMERA_StartCodecPath(MJPEG_FRAME_NUM);

			//while(!CIM_IsProcessingDone());
			WaitForConversionDone(bCamifDone);			

			CAMERA_ClearFrameEndStatus();
			printf("Capturing raw image  ... \n");	

			Delay(2000);

			bMjpgEncDone = false;
			uMjpgCount = 0;

			//JPEG_StartEncodingOneFrame(uCaptureHsz, uCaptureVsz, uCodecAddr, eDstDataFmt, uJpgAddr, eJpgFormat);
			JPEG_InitIpForMotionEncoding(uCaptureHsz, uCaptureVsz, uCodecAddr, eDstDataFmt,
										MJPEG_STREAM_ST, eJpgFormat, MJPEG_MAX_SZ);

			//JPEG_StartEncodingMotionJPEG(uCaptureHsz, uCaptureVsz, uCodecAddr, eDstDataFmt, MJPEG_STREAM_ST, eJpgFormat);

			WaitForSet(bMjpgEncDone);
			Assert(eJpgStatus == OK_ENC_OR_DEC);
			//JPEG_Wait_Done();

			JPEG_GetEncodedStreamLen(&uJpgSize);
			/*
			//+daedoo 061212
			CIM_SetSensorSize(ePreviewSz);
			CIM_InitPreviewPath(uSrcHsz, uSrcVsz, uLcdFbAddr, eDstDataFmt, FLIP_NO, ROT_0);
			CIM_StartPreviewPath();
			*/			

#ifdef SEMI_HOSTING
			printf("Saving image to file ... \n");						
			SaveToFile(CAPTURED_JPEG, uJpgSize, uJpgAddr);
#else
			// Under Construction. SD/MMC will be used.
#endif
			
		}

		else if(x=='c' || x=='C')
		{
			printf("1 = UXGA, 2 = SXGA, 3 = SVGA, 4 = VGA : ");
			x = Getc();
			printf("%c\n", x);

			eCodecSz =  (x=='1') ? UXGA : (x=='2') ? SXGA : (x=='3') ? SVGA : (x=='4') ? VGA : SVGA;
		}
		else
			printf("Invalid input! Retry!!\n");
	}
	CAMERA_StopPreviewPath();

}

void JPEG_Test(void)
{
	int i, sel;

	const testFuncMenu menu[]=
	{
		0,                                  "Exit",
#ifdef SEMI_HOSTING
		GetJpegStreamFromPc,             "Load Jpg File from PC",
#endif		
		GetJpegStreamFromSd,             "Load Jpg File from SD",
		//SetJpegTypeForEnc,                   "Set Jpeg Encoding Format",
		TestEncoding,                      	  "Encoding Image test (Generated Image)",		
		//SetRawImgTypeForEnc,              "Set Raw Img. Type For Generated Image",
		TestOneStepDecoding,               "H/W Decoding test (One Step)",
		TestTwoStepDecoding,               "Decoding test (Two Step)",
		TestDscSubsys,                      	    "Camera Capture test",
		SaveRawImgToFile,                    "Save Raw Image",
		TestDecodingConformance,        "Jpg Stream->Raw Img->LCD Using SD/MMC",
		//Test_EncMotionJPEG,		     	   "Motion JPEG Encoding",
		SaveJpegStreamToFile,               "Save Jpg file to PC\n",
		0,0
	};

	SDHC_InitCh(SDHC_CHANNEL_0, &oSdhc);
	JPEG_Init();
	POST_InitCh(POST_A, &oPost);

	eJpgFormat = JPEG_420;
	eLcdBpp = RGB16;

	uLcdFbAddr = CODEC_MEM_ST+0x1000000;
	uGlibAddr = uLcdFbAddr + 240*320*4;
	uJpgAddr = CODEC_MEM_ST;

	eRawImgFormat = RGB16;
	uRawImgAddr = uJpgAddr + 0x10000;

	uRawImgHsz_Enc = 320;
	uRawImgVsz_Enc = 240;

	bIsJpgLoaded = false;
	bIsOneStep = false;
	uIntCnt = 0;

	LCD_SetPort();

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

	LCD_InitLDI(MAIN);
	LCD_InitDISPC(eLcdBpp, uLcdFbAddr, WIN0, false);
	LCD_SetWinOnOff(1, WIN0);
	LCD_Start();
	LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);

	while(1)
	{
		printf("\n");
		for (i=0; (int)(menu[i].desc)!=0; i++) {
			printf("%2d: %s\n", i, menu[i].desc);
		}

		printf("\nSelect the function to test : ");
		sel = GetIntNum();
		printf("\n");

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