#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

#include "sysc.h"
#include "system.h"
#include "intc.h"
#include "jpeg.h"
#include "lcd.h"
#include "camera.h"
#include "glib.h"
#include "post.h"
#include "option.h"
#include "library.h"
#include "sdhc.h"
#include "fat.h"
#include "uart.h"

#ifndef PREPARED_JPEG
#define PREPARED_JPEG      "./jpg/144_96_420.jpg"
#endif

#define CAPTURED_JPEG      "Captured.jpg"
#define YUV_FILE_NAME      "Captured.yuv"

static POST	oPost;
static SDHC   oSdhc;

static u32 uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr;
static u32 uRawImgHsz_Enc, uRawImgVsz_Enc, uGlibAddr;
static CSPACE eRawImgFormat;
static u32 uLcdFbAddr, uLcdHSz, uLcdVSz;
static CSPACE eLcdBpp;
static u32 uJpgAddr;
static JPEG_TYPE eJpgFormat;
static u32 uJpgSize;
static JPEG_STATUS eJpgStatus;
static bool bIsJpgLoaded;
static bool bIsOneStep;
static u32 uIntCnt;

#if 1
#define WaitForSet(bDone) while (!bDone)
#else
#define WaitForSet(bDone) \
	for (int i=0; !bDone; i++) \
	{ \
		Delay(100); \
		if (i == 100) \
		{ \
			printf(" Abnormal termination !!!\n"); \
			return; \
		} \
	}
#endif

#if 0   // Polling mode
#define WaitForConversionDone(bDone) while(!CIM_IsProcessingDone())
#else   // Interrupt mode
#define WaitForConversionDone(bDone) while(!bDone)
#endif

static volatile bool bCamifDone;

void __irq Isr_Camif_P(void)
{
	LCD_Trigger();
	//bPreviewDone = true;
	//printf("P");
	CAMERA_SetClearPreviewInt();
	INTC_ClearVectAddr();		
}

void __irq Isr_Camif_C(void)
{
	INTC_Disable(NUM_CAMIF_C );
	bCamifDone = true;	
	CAMERA_SetClearCodecInt();
	INTC_Disable(NUM_CAMIF_C );
	INTC_ClearVectAddr();
}

static volatile bool bJpegDone;

void __irq Isr_Jpeg(void)
{
	INTC_Disable(NUM_JPEG);
	if ( (bIsOneStep == false) || ((bIsOneStep == true)&&(uIntCnt == 1)) )
	{
		JPEG_ReadAndClearStatus(&eJpgStatus);
		uIntCnt = 0;
	}
	//INTC_ClearPending(INT_JPEG);
	bJpegDone = true;
	uIntCnt++;
	printf("bJpegDone: %d\n", bJpegDone); 

	INTC_Enable(NUM_JPEG);
	INTC_ClearVectAddr();	
}

#define MJPEG_FRAME_NUM	5
#define MJPEG_MAX_SZ		0x8000
#define MJPEG_STREAM_ST	(uJpgAddr)
#define MJPEG_YUV_ST		(MJPEG_STREAM_ST+MJPEG_MAX_SZ*MJPEG_FRAME_NUM)	// after 10 frame

static volatile u32  uMjpgCount;
static volatile bool bMjpgEncDone;

void __irq Isr_EncMotion(void)
{
	u32 uResult; //, cnt;
	//Assert(0);
	INTC_Disable(NUM_JPEG);

	uMjpgCount++;
	JPEG_SetNextFrameStartAddr(MJPEG_STREAM_ST + MJPEG_MAX_SZ*(uMjpgCount+1));
	JPEG_CheckDone(&uResult);

	if (uResult)
	{
		JPEG_GetEncodedStreamLen(&uJpgSize);
		if (uMjpgCount >= MJPEG_FRAME_NUM)
		{
			bMjpgEncDone = 1;
		}
	}
	else
	{
		JPEG_GetEncodedStreamLen(&uJpgSize);
		printf("JPEG Encoding: Done abnormally. %x\n", uJpgSize);
		bMjpgEncDone = 0;
	}
	printf("JPEG Encoding frame = %d Done.\n", uJpgSize);
	INTC_Enable(NUM_JPEG);
	INTC_ClearVectAddr();	
}

static void TestDscSubsys(void)
{
	char x=0;
	u32 uSrcHsz ,uSrcVsz ;
	u32 uCaptureHsz, uCaptureVsz;
	u32 uCodecAddr = uJpgAddr + 0x500000;

	CSPACE eDstDataFmt = RGB16;
	IMG_SIZE eCodecSz = UXGA;

	// 1. Initialize LCD
	//========================================
	LCD_InitLDI(MAIN);
	LCD_InitDISPC(eDstDataFmt, uLcdFbAddr, WIN0, false);
	LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);
	LCD_Start();

	// 2. Initialize Interrupt
	//========================================
	INTC_Init();
	INTC_SetVectAddr(NUM_JPEG, Isr_Jpeg);
	INTC_SetVectAddr(NUM_CAMIF_C, Isr_Camif_C);	
	//INTC_SetVectAddr(NUM_CAMIF_P, Isr_Camif_P);	
	INTC_Enable(NUM_JPEG);
	INTC_Enable(NUM_CAMIF_C);
	//INTC_Enable(NUM_CAMIF_P);	

	// 3. Initialize camera and run the  process of preview path.
	//========================================
	CAMERA_InitSensor();		//CAMERA_InitSensor1(ePreviewSz, CCIR601, YCBYCR);
	CAMERA_SetSensorSize(eCodecSz);
	CAMERA_GetSrcImgSz(&uSrcHsz, &uSrcVsz);
	
	uSrcHsz = (uSrcHsz > uLcdHSz) ? uLcdHSz : uSrcHsz;
	uSrcVsz = (uSrcVsz > uLcdVSz) ? uLcdVSz : uSrcVsz;

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

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

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

			bCamifDone = false;

			ConvertImgSzToNumber(eCodecSz, &uCaptureHsz, &uCaptureVsz);
			eDstDataFmt = YCBYCR;
			CAMERA_InitCodecPath(uCaptureHsz, uCaptureVsz, uCodecAddr,  eDstDataFmt, FLIP_NO, ROT_0);
			CAMERA_StartCodecPath(1);

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

			CAMERA_ClearFrameEndStatus();
			printf("Capturing raw image  ... \n");				
			
			bJpegDone = false;
			JPEG_StartEncodingOneFrame(uCaptureHsz, uCaptureVsz, uCodecAddr, eDstDataFmt, uJpgAddr, eJpgFormat);
			WaitForSet(bJpegDone);
			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();
*/			

#if	 SEMIHOSTING
			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();
			x = getchar();

			printf("%c\n", x);

			eCodecSz =  (x=='11') ? UXGA : (x=='22') ? SXGA : (x=='33') ? SVGA : (x=='44') ? VGA : SVGA;
		}
		else
			printf("Invalid input! Retry!!\n");
	}
	CAMERA_StopPreviewPath();

}

static void TestOneStepDecoding(void)
{
	bIsOneStep = true;
	
	if (bIsJpgLoaded == false)
	{
		printf("ERROR! Load a raw image first!!\n");
		return;
	}

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

	uRawImgAddr = uJpgAddr+((uJpgSize+16)/16)*16;
	bJpegDone = false;
	JPEG_StartDecodingOneFrame(uJpgAddr, uRawImgAddr, false);
	WaitForSet(bJpegDone);
	//Assert(eJpgStatus == OK_ENC_OR_DEC);
	JPEG_Wait_Done();
	
	JPEG_GetDecodedWidthAndHeight(&uRawImgHSz_Dec, &uRawImgVSz_Dec);
	if ( uRawImgHSz_Dec == 0 || uRawImgVSz_Dec == 0 )
		printf("Error! Widht or Height is zero\n");
	else 
		printf(" Hsz = %d, Vsz = %d\n", uRawImgHSz_Dec, uRawImgVSz_Dec);

	/*
	CIM_InitDmaInPath(uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, YCBYCR,
		uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, FLIP_NO, ROT_0, C_PATH);

	bCamifDone = false;
	CIM_StartDmaInPath();
	WaitForConversionDone(bCamifDone);
	*/

	POST_InitIp(
		uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, CRYCBY,
		//uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, 1, false, ONE_SHOT, &oPost);
		320, 240, uLcdFbAddr, eLcdBpp, 1, false, ONE_SHOT, &oPost);

	POST_StartProcessing(&oPost);
	while (!POST_IsFreeRunDone(&oPost));
	
}

static void TestTwoStepDecoding(void)
{
	char pType[30];

	bIsOneStep = false;	
	
	if (bIsJpgLoaded == false)
	{
		printf("ERROR! Load a raw image first !!\n");
		return;
	}

	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);

	// Header Parsing
	bJpegDone = false;
	JPEG_StartParsingHeader(uJpgAddr);
	WaitForSet(bJpegDone);
	
	Assert(eJpgStatus == OK_HD_PARSING);

	JPEG_GetJpegType1(pType);
	printf(" 1. Sub-Sampling Mode = %s\n", pType);

	JPEG_GetDecodedWidthAndHeight(&uRawImgHSz_Dec, &uRawImgVSz_Dec);
	if ( uRawImgHSz_Dec == 0 || uRawImgVSz_Dec == 0 )
		printf("Error! Width or Height is zero\n");
	else
		printf(" 2. Resolution : Width = %d, Height = %d\n", uRawImgHSz_Dec, uRawImgVSz_Dec);

	// Decoding body.
	uRawImgAddr = uJpgAddr+((uJpgSize+16)/16)*16;
	printf(" uRawImgAddr = 0x%x\n",uRawImgAddr);
	bJpegDone = false;
	JPEG_StartDecodingBody(uRawImgAddr, false);
	WaitForSet(bJpegDone);
	Assert(eJpgStatus == OK_ENC_OR_DEC);
	
	//printf("After JpegDone\n");

	#if 0	// camera dma

	CAMERA_InitDmaInPath(uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, YCBYCR,
		//uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, FLIP_NO, ROT_0, C_PATH);
		320, 240, uLcdFbAddr, eLcdBpp, FLIP_NO, ROT_0, C_PATH);

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

	#else

	POST_InitIp(
		uRawImgHSz_Dec, uRawImgVSz_Dec, uRawImgAddr, CRYCBY,
		uLcdHSz, uLcdVSz, uLcdFbAddr, eLcdBpp, 1, false, ONE_SHOT, &oPost);
	POST_StartProcessing(&oPost);
	while (!POST_IsFreeRunDone(&oPost));

	#endif

}

#if	 SEMIHOSTING
static void GetJpegStreamFromPc(void)
{
	const char *pFileName = PREPARED_JPEG;
	printf(" Loading %s from PC ...\n", pFileName);
	LoadFromFile1(pFileName, uJpgAddr, &uJpgSize);

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

static void GetJpegStreamFromSd(void)
{
	u32 uTotalNumOfFiles, i;
	int sel;
	char pFileName[50];

	if (!SDHC_OpenMedia(SDHC_HCLK, &oSdhc) || !FAT_LoadFileSystem(&oSdhc))
		Assert(0);
	
	FAT_GetTotalNumOfFiles(&uTotalNumOfFiles, &oSdhc);
	for (i=0; i<uTotalNumOfFiles; i++)
	{
		FAT_GetFileName(i, pFileName, &oSdhc);
		printf("%02d -- %s\n", i, pFileName);