/********************************************************************
	DHL_AVCAP.c
	
	PHOENIX Driver HAL library
	AudioVideo decoding/capture/output implementation

	Copyright 2010 Digital STREAM Technology, Inc.
	All Rights Reserved

	$Id: DHL_AVCAP.c  v1.00 2006/04 cafrii Exp $
	
	
********************************************************************/

#include "DHL_OSAL.h"
#include "DHL_DBG.h"
#include "DHL_SYS.h"
#include "DHL_AVCAP.h"
#include "DHL_AVCAP_Impl.h"
#include "bsettop.h"
#include "bsettop_user_io.h"
#include "bsettop_rfm.h"
#include "bsettop_tuner.h"

////#include <string.h>

/*
	¸ðµç Çì´õ ÆÄÀÏÀ» Æ÷ÇÔÇÏÁö´Â ¾ÊÀ¸¸ç, compile timeÀ» ÁÙÀ̱â À§ÇØ
	°¢ ¸ðµâÀº ÇÊ¿äÇÑ ¸¸Å­ÀÇ Çì´õ¸¦ ¼±¾ðÇϵµ·Ï ÇÔ.
*/



/*
	DHL µð¹ö±× ¸ðµâ À̸§ Á¤ÀÇ ·ê Âü°í:

	DHL ¸ðµâµéÀº ¸ðµÎ * ·Î ½ÃÀÛ.
	API´Â ´ë¹®ÀÚ, Platform ¹× ±âŸ´Â ¼Ò¹®ÀÚ »ç¿ë.

	µðÆúÆ® ·¹º§Àº 0À¸·Î ¼³Á¤ÇÑ´Ù. (0: ¿¡·¯ ¸Þ½ÃÁö¸¸ Ãâ·Â)
	
	
*/


//DHL_MODULE("*AV", 0);



#if COMMENT
____Config____(){}
#endif


#define AV_EVT_TASK_STACK_SIZE 0x1000
#define AV_EVT_TASK_PRIORITY   TASK_PRI_DHL_AV_EVT


#define MAX_NUM_608_STORED_DATA 256





#define TICK_1SEC DHL_OS_GetTicksPerSecond()
#define TICK_CUR DHL_OS_GetTickCount()
#define TICK_PASS(stTick) (TICK_CUR-stTick)



//-----------------------------------------------------------

//
// from MPEG-2 System: Transport Stream Packet layer
//
//   PES·Î »ç¿ë °¡´ÉÇÑ PID´Â 0x10 ~ 0x1FFE
//   PCR·Î »ç¿ë °¡´ÉÇÑ PID´Â 0x0, 0x1, 0x10 ~ 0x1FFE
//
// from ATSC A/53, Annex C
//   PES PID is base_PID + 1 ~ base_PID + 0xA (?)
//   PCR PID is base_PID + 1
//
//
//  Cable »ç¾÷ÀÚÀÇ °æ¿ì¸¦ °í·ÁÇØ¾ß Çϱ⠶§¹®¿¡ 
//  ÃÖ´ëÇÑ MPEG-2 ¼öÁØÀÇ resriction¸¸ °¡Áö°í °¡ÀÚ.
// 
//
#define IS_VALID_PES_PID(p) ((p)>=0x10 && (p)<=0x1ffe)

#define IS_VALID_PCR_PID(p) ((p)>=0x10 && (p)<=0x1ffe)

// todo..
// pcr pid 0¸¦ reserved·Î »ç¿ëÇÏ´Â Äڵ尡 ¸¹¾Æ¼­
//  ´çºÐ°£ ¾Æ·¡ Àû¿ëÀº Èûµé´Ù.. 
//#define IS_VALID_PCR_PID(pid) ((pid)==0 || (pid)==1 || ((pid)>=0x10 && (pid)<=1ffe))


// ´ÜÀ§´Â milisec
int g_Timeout_ContextCreation = 6000;

int g_Timeout_AudioStart = 2000;
	// cafrii 060711 add
	// audioµµ ½ÃÀÛÇÏ°í ³ª¼­ µðÄÚµùÀÌ ÀÌ·ç¾îÁö´Â °ÍÀ» È®ÀÎÇÒ °æ¿ì
	// ÃÖ´ë ´ë±â ½Ã°£..
	
	


#if COMMENT
____Types____(){}
#endif




#if COMMENT
____Global____(){}
#endif
/*
	Audio/Video ¸ðµç Áß¿ä Á¤º¸¸¦ ÀúÀåÇÏ´Â °ø°£.

	ÀÌ º¯¼öÀÇ ÁÖ¿ä °ü¸®ÀÚ´Â DHL_AVCAPÀ̸ç
	ÇÊ¿ä¿¡ µû¶ó °¢ impl ¿¡¼­µµ »ç¿ëÇϱ⵵ ÇÑ´Ù.

*/
DHL_AV_CONFIG g_dhlav;

static BOOL is_inited=FALSE;


static tDHL_VideoCodingType g_vid_type = eDHL_VIDEO_TYPE_UNKNOWN;
static tDHL_AudioCodingType g_aud_type = eDHL_AUDIO_TYPE_UNKNOWN;
static UINT16 g_pcr_pid = 0x0000, g_vid_pid = 0x0000, g_aud_pid = 0x0000;
static BOOL g_pcr_start = FALSE, g_vid_start = FALSE, g_aud_start = FALSE;

static BOOL g_vid_alive = FALSE, g_aud_alive = FALSE;
static UINT32 g_vid_alive_chk_time = 0, g_aud_alive_chk_time = 0;
static UINT32 g_vid_frm_cnt = 0, g_aud_frm_cnt = 0;

static UINT32 g_audVolumeMin = 0, g_audVolumeMax = 100, g_audVolume = 100;
static UINT32 g_audMixType = eDHL_AUDIO_MIX_TYPE_LTRT;

static tDHL_AVCALLBACK g_vid_seq_hdr_cb = NULL, g_vid_usr_data_cb = NULL,
                       g_vid_first_show_cb = NULL;

tDHL_VideoSeqHdr g_vid_seq_hdr;


int crop_w = 1000, crop_h = 1000, crop_x = 0, crop_y = 0;
int disp_w = 1000, disp_h = 1000, disp_x = 0, disp_y = 0;

//static UINT16 f1_data[MAX_NUM_608_STORED_DATA],
//              f2_data[MAX_NUM_608_STORED_DATA];
//static UINT32 wrCntF1 = 0, rdCntF1 = 0, wrCntF2 = 0, rdCntF2 = 0;

#if COMMENT
_______API_______(){}
#endif

DHL_RESULT DHL_SetRFM34(UINT8 chnum)
{
	extern brfm_t g_sys_rfm;
	if(chnum)
		brfm_set_ch3(g_sys_rfm, 1);//RFMCH4
	else
		brfm_set_ch3(g_sys_rfm, 0);//RFMCH3	
}

DHL_RESULT DHL_SetLTO(BOOL onoff)
{
	if(onoff)
		NXP_TDA182I4_SetPowerState(1);
	else
		NXP_TDA182I4_SetPowerState(0);
}
void DHL_AV_TakeMutex(void)
{
//TODO:	DHL_OS_TakeSemaphore(g_dhlav.Mutex);
}

void DHL_AV_GiveMutex(void)
{
//TODO:	DHL_OS_GiveSemaphore(g_dhlav.Mutex);
}


#if COMMENT
____Video____(){}
#endif

#if 0

void dhl_av_video_feeding_608_cb(InterruptNum eIntNum)
{

	char c1, c2;
	
	if (eIntNum != E_INT_FIQ_FIELD_VE4VBI)
	{
		DHL_OS_Printf("|%s| wrong interrupt(0x%x).\n", __FUNCTION__, eIntNum);
		
		return;
	}
	
	if (rdCntF1 != wrCntF1)
	{
		MDrv_VE_SendCcData(1, f1_data[rdCntF1]);
		/*c1 = isprint((f1_data[rdCntF1] >> 8) & 0x7f) ? (f1_data[rdCntF1] >> 8) & 0x7f : '.';
		c2 = isprint(f1_data[rdCntF1] & 0x7f) ? f1_data[rdCntF1] & 0x7f : '.';
		DHL_OS_Printf("f1_rd(%4d):%4X(%c,%c)\n", DHL_OS_GetMsCount(), f1_data[rdCntF1], c1, c2);*/
		
		rdCntF1++;
		if (MAX_NUM_608_STORED_DATA <= rdCntF1)
		{
			rdCntF1 = 0;
		}
	}
	else
	{
		MDrv_VE_SendCcData(1, 0x8080);
	}
	if (rdCntF2 != wrCntF2)
	{
		MDrv_VE_SendCcData(0, f2_data[rdCntF2]);
		/*c1 = isprint((f2_data[rdCntF2] >> 8) & 0x7f) ? (f2_data[rdCntF2] >> 8) & 0x7f : '.';
		c2 = isprint(f2_data[rdCntF2] & 0x7f) ? f2_data[rdCntF2] & 0x7f : '.';
		DHL_OS_Printf("f2_rd(%4d):%4X(%c,%c)\n", DHL_OS_GetMsCount(), f2_data[rdCntF2], c1, c2);*/
		
		rdCntF2++;
		if (MAX_NUM_608_STORED_DATA <= rdCntF2)
		{
			rdCntF2 = 0;
		}
	}
	else
	{
		MDrv_VE_SendCcData(0, 0x8080);
	}
	
    MsOS_EnableInterrupt(E_INT_FIQ_FIELD_VE4VBI);
}
#endif

//void dhl_av_video_event_cb(MS_U32 eFlag, void *param)
//{
//
//}

#if 0
void dhl_av_video_event_process(MS_U32 eFlag, void *param)
{
	if ((eFlag & E_VDEC_EX_EVENT_USER_DATA_FOUND) ==
	    E_VDEC_EX_EVENT_USER_DATA_FOUND)
	{
		while (MApi_VDEC_IsCCAvailable())
		{
			VDEC_CC_Info stVdecCCInfo;
			
			memset(&stVdecCCInfo, 0, sizeof(VDEC_EX_CC_Info));
			if (MApi_VDEC_GetCCInfo(&stVdecCCInfo, sizeof(stVdecCCInfo)))
			{
				if (g_vid_usr_data_cb)
				{
					UINT32 fType;
					UINT32 info[3];
					
					switch ((VDEC_FrameType)param)
					{
						case E_VDEC_FRM_TYPE_I:
							fType = 1;
							
							break;
						
						case E_VDEC_FRM_TYPE_P:
							fType = 2;
							
							break;
						
						case E_VDEC_FRM_TYPE_B:
							fType = 3;
							
							break;
						
						default:
							fType = 0;
							
							break;
					}
					
					// get userdata here
					info[0] = (UINT32)stVdecCCInfo.u32UserDataBuf;  // userdata
					info[1] = stVdecCCInfo.u32UserDataSize;  // userdata size
					// ÇöÀç ¹Ìµé¿þ¾îÀÇ userdata ¼ø¼­ ¼³Á¤ÀÌ display order·Î
					// µÇ¾î ÀÖ°í, ºñµð¿À µðÄÚ´õ°¡ÀÇ userdata ¼ø¼­ ¼³Á¤µµ
					// display order·Î µÇ¾î ÀÖÀ¸¹Ç·Î, pic typeÀ» ¹«Á¶°Ç
					// I·Î ¼³Á¤ÇÏ¿© ³Ñ±ä´Ù.
					info[2] = 1;  // pic type(I,P,B...)
					(*g_vid_usr_data_cb)(eDHL_CB_VideoUserData, (UINT32)info);
				}
			}
		}
		
		eFlag &= ~E_VDEC_EX_EVENT_USER_DATA_FOUND;
	}
	if ((eFlag & E_VDEC_EVENT_DISP_INFO_CHG) == E_VDEC_EVENT_DISP_INFO_CHG ||
	    (eFlag & E_VDEC_EVENT_DISP_INFO_RDY) == E_VDEC_EVENT_DISP_INFO_RDY)
	{
		VDEC_DispInfo dispInfo;
		MS_WINDOW_TYPE capWin, dispWin;
		int art[][2]={{2, DAR_3_4},
		              {3, DAR_9_16},
		              {1, SAR_SquarePixel}};
		int frt[][2]={{23, FRAMERATE_23_976},
		              {23976, FRAMERATE_23_976},
		              {24, FRAMERATE_24},
		              {24000, FRAMERATE_24},
		              {25, FRAMERATE_25},
		              {25000, FRAMERATE_25},
		              {29, FRAMERATE_29_97},
		              {29970, FRAMERATE_29_97},
		              {30, FRAMERATE_30},
		              {30000, FRAMERATE_30},
		              {50, FRAMERATE_50},
		              {50000, FRAMERATE_50},
		              {59, FRAMERATE_59_94},
		              {59940, FRAMERATE_59_94},
		              {60, FRAMERATE_60},
		              {60000, FRAMERATE_60}};
		static UINT32 refresh_cnt;
		int i;
		
		// change video scaler 
		msAPI_XC_EnableCCIRInput(0, DISABLE);
		MApi_VDEC_SetBlueScreen(FALSE);
		MApi_VDEC_GetDispInfo(&dispInfo);
		msAPI_XC_SetVDECInfo(dispInfo);
		if (g_vid_type == eDHL_VIDEO_TYPE_H264)
		{
			msAPI_XC_SetMVOPConfig(MVOP_INPUT_H264);
		}
		else if (g_vid_type == eDHL_VIDEO_TYPE_MPEG2)
		{
			msAPI_XC_SetMVOPConfig(MVOP_INPUT_MVD);
		}
		msAPI_XC_DTV_SetMode();
		capWin.x = dispInfo.u16HorSize * crop_x / 1000;
		capWin.y = dispInfo.u16VerSize * crop_y / 1000;
		capWin.width = dispInfo.u16HorSize * crop_w / 1000;
		capWin.height = dispInfo.u16VerSize * crop_h / 1000;
		dispWin.x = 720 * disp_x / 1000;
		dispWin.y = 480 * disp_y / 1000;
		dispWin.width = 720 * disp_w / 1000;
		dispWin.height= 480 * disp_h / 1000;
		msAPI_XC_SetWin(NULL, &capWin, &dispWin, MAIN_WINDOW);
		msAPI_VE_SetMode();
		MApi_XC_WaitOutputVSync(2, 100, MAIN_WINDOW);
		
		// get sequence header
		g_vid_seq_hdr.generationNumber = 0;
		g_vid_seq_hdr.aspect_ratio_information = aspectRatioUnknown; /* default °ª */
		for (i = 0; i < (int)(sizeof(art) / sizeof(art[0])); i++)
		{
			if (art[i][0] == (int)dispInfo.u8AspectRate)
			{
				g_vid_seq_hdr.aspect_ratio_information = art[i][1];
				
				break;
			}
		}
		if (10000 <= dispInfo.u32FrameRate)
		{
			// ½ºÆ®¸²¿¡ µû¶ó framerateÀÇ ¼Ò¼öÁ¡ ¼Â° ÀÚ¸®°¡ 0ÀÌ
			// ¾Æ´Ñ °ªÀ¸·Î ¿À´Â °æ¿ì°¡ ÀÖÀ¸¹Ç·Î 0À¸·Î °­Á¦·Î ¸¸µç´Ù.
			dispInfo.u32FrameRate /= 10;
			dispInfo.u32FrameRate *= 10;
		}
		g_vid_seq_hdr.frame_rate_code = (MPEG_FRAME_RATE)-1; /* default °ª, unknown ¿¡ ´ëÇÑ type Á¤ÀÇ°¡ ¾ø¾î ÀÓÀÇ·Î -1 °ª Àû¿ë */
		for (i=0; i < (int)(sizeof(frt) / sizeof(frt[0])); i++)
		{
			if (frt[i][0] == (int)dispInfo.u32FrameRate)
			{
				g_vid_seq_hdr.frame_rate_code = frt[i][1];
				
				break;
			}
		}
		g_vid_seq_hdr.horizontal_size = dispInfo.u16HorSize;
		g_vid_seq_hdr.vertical_size = dispInfo.u16VerSize;
		g_vid_seq_hdr.progressive_sequence = dispInfo.u8Interlace ? 0 : 1;
		// ¹Ø¿¡ ÆĶó¹ÌÅÍ°ªÀº M/W¿¡¼­ »ç¿ë ¾ÈÇϹǷΠ0 °ª ó¸®..
		g_vid_seq_hdr.bit_rate = 0;
		g_vid_seq_hdr.chroma_format = 0;
		g_vid_seq_hdr.constrained_parameter_flag = 0;
		g_vid_seq_hdr.frame_rate = 0;
		g_vid_seq_hdr.low_delay = 0;
		g_vid_seq_hdr.MPEG2 = 0;
		g_vid_seq_hdr.profile_and_level_indication = 0;
		g_vid_seq_hdr.vbv_buffer_size = 0;
		g_vid_seq_hdr.generationNumber = 0x80000000 | refresh_cnt++;
		
		if(g_vid_seq_hdr_cb)
		{
			(*g_vid_seq_hdr_cb)(eDHL_CB_VideoSeqHdr, (UINT32)&g_vid_seq_hdr);
		}
		
		eFlag &= ~E_VDEC_EVENT_DISP_INFO_CHG;
		eFlag &= ~E_VDEC_EVENT_DISP_INFO_RDY;
	}
	if ((eFlag & E_VDEC_EVENT_VIDEO_UNMUTE) == E_VDEC_EVENT_VIDEO_UNMUTE)
	{
		#define AV_SYNC_TIMEOUT			2000
		
		UINT32 sync_start_tick;
		BOOL sync_done;
		
		sync_start_tick = DHL_OS_GetMsCount();
		sync_done = FALSE;
		while (!sync_done)
		{
			if (MApi_VDEC_IsAVSyncOn() == E_VDEC_FAIL)
			{
				sync_done = TRUE;
				
				continue;
			}
			if (MApi_VDEC_IsReachSync() == E_VDEC_OK)
			{
				sync_done = TRUE;
				
				continue;
			}
			
			if (AV_SYNC_TIMEOUT < (DHL_OS_GetMsCount() - sync_start_tick))
			{
				sync_done = TRUE;
				
				continue;
			}
		}
		
		dhl_av_video_hide(0, 0, FALSE);
		
		if (g_vid_first_show_cb)
		{
			(*g_vid_first_show_cb)(eDHL_CB_FirstVideoShow, 0);
		}
		
		eFlag &= ~E_VDEC_EVENT_VIDEO_UNMUTE;
	}
	if (eFlag)
	{
		DHL_OS_Printf("|%s| wrong event(0x%x).\n", __FUNCTION__, eFlag);
	}
}
#endif

DHL_RESULT DHL_AV_VideoStart(tDHL_VDID id, 
	UINT16 vid_pid, UINT16 pcr_pid, tDHL_VideoCodingType vid_type)
{

	DHL_RESULT dhlResult;
	UINT32 tickStart;
	UINT32 waitTime=TICK_1SEC*g_Timeout_ContextCreation/1000;

	printf("%s: vidpid 0x%x pcrpid 0x%x vid_type %d\n", __FUNCTION__, vid_pid, pcr_pid, vid_type);
	
	if (!IS_VALID_PES_PID(vid_pid) || 
			!IS_VALID_PCR_PID(pcr_pid)) 
	{
		printf("!! %s: invalid pid (video 0x%x, pcr 0x%x)\n", __FUNCTION__, 
					vid_pid, pcr_pid);
		return DHL_FAIL;
	}

	dhlResult = dhl_av_video_start(vid_pid, pcr_pid, 0, vid_type);
	if (dhlResult == DHL_OK)
	{
		//dhl_av_video_hide(0);
		dhl_av_video_start_end(vid_pid, pcr_pid, TRUE); // success

		DHL_AV_TakeMutex();
		
		g_dhlav.curVideoContext=(void *)0x1;
		g_dhlav.uVidPID = vid_pid;
		g_dhlav.uPcrPID = pcr_pid;
		g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_READY;

		g_pcr_pid = pcr_pid;
		g_pcr_start = TRUE;
		g_vid_type = vid_type;
		g_vid_pid = vid_pid;
		g_vid_start = TRUE;
		
		g_vid_alive = TRUE;
		g_vid_alive_chk_time = DHL_OS_GetMsCount();
		dhl_av_get_video_pts(&g_vid_frm_cnt);

		DHL_AV_GiveMutex();

		return dhlResult;
	}
	else
	{
		g_vid_alive = FALSE;
		dhl_av_video_start_end(vid_pid, pcr_pid, FALSE); // fail
		return DHL_FAIL;
	}
#if 0//khw140408 blocking.	
	dhlResult=DHL_FAIL_TIMEOUT;
		
	for (tickStart=TICK_CUR; TICK_PASS(tickStart) < waitTime;) 
	{
		//printf("video trying\n");
		
		if (TICK_PASS(tickStart)>TICK_1SEC/10 &&   // timeout not reached,
			dhl_av_video_decoding_ready())    // video decoder is ready
		{ 
			dhlResult = DHL_OK;
			break;
		}
		
//BKTODO (MW)
//		if (ckFn && ckFn()) {
//			dhlResult = DHL_FAIL_CANCELLED_BY_USER;
//			break;
//		}
		DHL_OS_Delay(OS_GetTicksPerSecond()/10);
	}


	if (dhlResult) {
		dhl_av_video_start_end(vid_pid, pcr_pid, FALSE); // fail
	}
	else 
	{
		dhl_av_video_start_end(vid_pid, pcr_pid, TRUE); // success

		DHL_AV_TakeMutex();
		
		g_dhlav.curVideoContext=(void *)0x1;
		g_dhlav.uVidPID = vid_pid;
		g_dhlav.uPcrPID = pcr_pid;
		g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_READY;


		g_pcr_pid = pcr_pid;
		g_pcr_start = TRUE;
		g_vid_type = vid_type;
		g_vid_pid = vid_pid;
		g_vid_start = TRUE;
		
		g_vid_alive = TRUE;
		g_vid_alive_chk_time = DHL_OS_GetMsCount();
		dhl_av_get_video_pts(&g_vid_frm_cnt);



		DHL_AV_GiveMutex();
	}
	
	return dhlResult;
#endif
}


DHL_RESULT DHL_AV_VideoStop (tDHL_VDID id)
{

	DHL_AV_TakeMutex();
	// pes stop
	if (g_vid_start == TRUE)
	{

		dhl_av_video_stop(g_dhlav.uVidPID);

		g_dhlav.curVideoContext = NULL;
		g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_STOP; // cafrii 060621 add bugfix
		g_dhlav.uVidPID = 0;
		if (g_dhlav.uAudPID == 0) // cafrii 070718 add. PCR pidµµ resetÀÌ ÇÊ¿ä.
			g_dhlav.uPcrPID = 0;


		g_vid_type = eDHL_VIDEO_TYPE_UNKNOWN;
		g_vid_pid = 0x0000;
		g_vid_start = FALSE;
		
		g_vid_alive = FALSE;
		g_vid_alive_chk_time = 0;
		g_vid_frm_cnt = 0;
		
		g_vid_seq_hdr.generationNumber = 0;

	}
	DHL_AV_GiveMutex();
	
	return DHL_OK;
}

void DHL_AV_DispStop(BOOL onoff)
{
	DHL_AV_TakeMutex();
	
	dhl_av_disp_stop(onoff);
	
	DHL_AV_GiveMutex();
}


DHL_RESULT DHL_AV_VideoHide(tDHL_VDID id, BOOL bHide)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	printf("%s: %d\n", __FUNCTION__, bHide);

	DHL_AV_TakeMutex();

	dhlResult = dhl_av_video_hide(bHide);
	g_dhlav.bVideoHide = bHide ? TRUE : FALSE;
	
	DHL_AV_GiveMutex();
	
	return dhlResult;

}


DHL_RESULT DHL_AV_VideoFreeze(tDHL_VDID id, BOOL bFreeze)
{
		DHL_RESULT dhlResult = DHL_OK;
#if 0
		printf("%s: %d\n", __FUNCTION__, bFreeze);
	
		DHL_AV_TakeMutex();
	
		if (g_dhlav.curVideoContext == NULL)
		{
			if (g_dhlav.uCurVideoStatus != DHL_AV_VIDEO_STOP) {
				printf("!! Null context with non-stopped state?\n");
				g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_STOP;
			}
			printf("!! video stop state\n");
			dhlResult = DHL_FAIL_INVALID_STATE;
			goto label_end;
		}
		
		if (bFreeze)
		{
			if (g_dhlav.uCurVideoStatus == DHL_AV_VIDEO_START) 
			{
				printf("\t freeze video context\n");
				
				dhl_av_video_freeze(TRUE);
				
				g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_FREEZE;
			}
			else if (g_dhlav.uCurVideoStatus == DHL_AV_VIDEO_FREEZE)
				printf("\t video already freezed..\n");
			else
				printf("!! video invalid state %d for freeze\n", g_dhlav.uCurVideoStatus);	
		}
		else
		{
			// todo..
			// timeoutÀ» ÀûÀýÇÏ°Ô µÎ°í ¹®Á¦°¡ »ý±â¸é error¸¦ ¸®ÅÏÇÏ´Â°Ô ÁÁ°ÚÀ½
			//
			if (g_dhlav.uCurVideoStatus == DHL_AV_VIDEO_FREEZE) 
			{
				printf("\t unfreeze video\n");
				
				dhl_av_video_freeze(FALSE);
				
				g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_START;
			}
			else if (g_dhlav.uCurVideoStatus == DHL_AV_VIDEO_START)
				printf("\t video already unfreezed\n");
			else
				printf("!! video invalid state %d for unfreeze\n", g_dhlav.uCurVideoStatus);
		}
	
	label_end:
		DHL_AV_GiveMutex();
#endif
		return dhlResult;

}


DHL_RESULT DHL_AV_VideoResize(tDHL_VDID id, int x, int y, int w, int h)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	printf( "%s: (%d,%d %d,%d)\n", __FUNCTION__, x, y, w, h);

	DHL_AV_TakeMutex();

	dhlResult = dhl_av_video_resize(x, y, w, h);

	if (dhlResult == DHL_OK)
	{
		g_dhlav.curWinRect.x = x;
		g_dhlav.curWinRect.y = y;
		g_dhlav.curWinRect.w = w;
		g_dhlav.curWinRect.h = h;
	}
	else
		goto label_end;

label_end:
	DHL_AV_GiveMutex();

	return dhlResult;

}

// cafrii 060928 add
const char *DHL_AV_AdjustmentString(tDHL_DispARC adj)
{
	return
		adj == eDHL_ARC_FULLSCREEN ? "eDHL_ARC_FULLSCREEN" :
		adj == eDHL_ARC_LETTERBOX ? "eDHL_ARC_LETTERBOX" :
		adj == eDHL_ARC_SIDEBAR ? "eDHL_ARC_SIDEBAR" :
		adj == eDHL_ARC_PAN_AND_SCAN ? "eDHL_ARC_PAN_AND_SCAN" :
		adj == eDHL_ARC_TILT_AND_SCAN ? "eDHL_ARC_TILT_AND_SCAN" :
		adj == eDHL_ARC_PARTIAL_LETTERBOX ? "eDHL_ARC_PARTIAL_LETTERBOX" :
		adj == eDHL_ARC_PARTIAL_SIDEBAR ? "eDHL_ARC_PARTIAL_SIDEBAR" :
		adj == eDHL_ARC_ZOOM1 ? "eDHL_ARC_ZOOM1" :
		adj == eDHL_ARC_ZOOM2 ? "eDHL_ARC_ZOOM2" :
		adj == eDHL_ARC_USER ? "eDHL_ARC_USER" : "?";
}


DHL_RESULT DHL_AV_VideoSetARC(tDHL_DispARC adj_hd, tDHL_DispARC adj_sd)
{
		DHL_RESULT dhlResult = DHL_OK;
	

		DHL_AV_TakeMutex();
	
		if (g_dhlav.curARAdjustment == adj_hd) {
			printf("\t same adj %d. skip\n", adj_hd);
			goto label_end;
		}
		
		printf("\t change to %d '%s'\n", adj_hd, DHL_AV_AdjustmentString(adj_hd));
	
		dhlResult = dhl_av_change_display_adjustment(adj_hd, 0);
	
		if (dhlResult == DHL_OK)
		{
			g_dhlav.curARAdjustment = (tDHL_DispARC) adj_hd;
		}
	
label_end:
		DHL_AV_GiveMutex();
		
		return dhlResult;

}


DHL_RESULT DHL_AV_DispSetFormat(
     tDHL_DispPort port, tDHL_DispFormat format, tDHL_DispColorSpace color)
{
	DHL_RESULT result = DHL_OK;
	
//BKTODO
	return result;
}


DHL_RESULT DHL_AV_VideoSeqInfo(tDHL_VDID id, tDHL_VideoSeqHdr *pSeq)
{
	if (pSeq == NULL) {
		printf("!! %s: null arg\n", __FUNCTION__);
		return DHL_FAIL_INVALID_PARAM;
	}
	
	return dhl_av_get_seq_hdr(pSeq);
}


DHL_RESULT DHL_AV_VideoGetStatus(tDHL_VDID id, tDHL_VideoStatus *pStatus)
{
	DHL_RESULT result = DHL_OK;
	
	if (pStatus == NULL)
	{
		DHL_OS_Printf("|%s| null arg(pStatus).\n", __FUNCTION__);
		
		result = DHL_FAIL_NULL_POINTER;
		
		return result;
	}
	
	if (g_vid_start == TRUE)
	{

		UINT32 curr_frm_cnt;
		dhl_av_get_video_pts(&curr_frm_cnt);
		if (curr_frm_cnt == g_vid_frm_cnt)
		{
			#define VID_ALIVE_CHK_PERIOD		12000  // ms
			UINT32 curr_time;
			curr_time = DHL_OS_GetMsCount();
			if (VID_ALIVE_CHK_PERIOD <= (curr_time - g_vid_alive_chk_time))
			{
				g_vid_alive = FALSE;	
			}
		}
		else
		{
			g_vid_alive = TRUE;
			g_vid_alive_chk_time = DHL_OS_GetMsCount();
		}
		g_vid_frm_cnt = curr_frm_cnt;
	}
	else
	{
		g_vid_alive = FALSE;
	}
	
	memset(pStatus, 0, sizeof(tDHL_VideoStatus));
	pStatus->bDecoding = g_vid_start;
	pStatus->type = g_vid_type;
	pStatus->bOutputExist = g_vid_alive;
	pStatus->bScrambleDetected = FALSE;
	pStatus->bHdmiConnected = FALSE;
	pStatus->curDisplayFormat = eDHL_DISP_720x480i;
	
	return result;
}

DHL_RESULT DHL_AV_VideoFeeding608(BOOL is_even, UINT8 data1, UINT8 data2,
                                  BOOL is_end)
{
#if 0	//BKTODO: check here
	static struct
	{
		UINT8 d1;
		UINT8 d2;
		UINT8 field;
	} stored[MAX_NUM_608_STORED_DATA];
	static int idx = 0;
	DHL_RESULT result = DHL_OK;
	
	if (is_end)
	{
		int i;
		
		for (i = 0; i < idx; i++)
		{
			if (!stored[i].field)
			{
				f1_data[wrCntF1] = (stored[i].d2 << 8) | stored[i].d1;
				
				wrCntF1++;
				if (MAX_NUM_608_STORED_DATA <= wrCntF1)
				{
					wrCntF1 = 0;
				}
			}
			else
			{
				f2_data[wrCntF2] = (stored[i].d2 << 8) | stored[i].d1;
				
				wrCntF2++;
				if (MAX_NUM_608_STORED_DATA <= wrCntF2)
				{
					wrCntF2 = 0;
				}
			}
		}
		
		idx = 0;
	}
	else
	{
		static UINT32 prev_ms;
		
		if ((DHL_OS_GetMsCount() - prev_ms) > 1000)
		{
			idx = 0;
		}
		
		stored[idx].d1 = data1;
		stored[idx].d2 = data2;
		stored[idx].field = is_even;
		
		idx++;
		if (MAX_NUM_608_STORED_DATA <= idx)
		{
			idx = 0;
		}
		
		prev_ms = DHL_OS_GetMsCount();
	}
	return result;
#else
	return DHL_OK;
#endif
}


#if COMMENT
____Audio____(){}
#endif


DHL_RESULT dhl_av_audio_set_mix_type(UINT32 value)
{
	DHL_RESULT result = DHL_OK;
//BKTODO:
	
	return result;
}

DHL_RESULT DHL_AV_AudioStart(UINT16 aud_pid, UINT16 pcr_pid, tDHL_AudioCodingType aud_type)
{
	DHL_RESULT result = DHL_OK;
	result = dhl_av_audio_start(aud_pid, pcr_pid, aud_type);
	if(result == DHL_OK)
	{
		dhl_av_audio_start_end(aud_pid, pcr_pid, TRUE); // success ÀÎÁö ¾Æ´ÑÁö ¾Ë ¼ö ¾øÀ½. success·Î °¡Á¤.

		DHL_AV_TakeMutex();
		
		g_dhlav.curVideoContext=(void *)0x1;
		g_dhlav.uAudPID = aud_pid;
		g_aud_type = aud_type;
		g_aud_start = TRUE;
		g_aud_alive = TRUE;
		g_aud_alive_chk_time = DHL_OS_GetMsCount();
		DHL_AV_GiveMutex();
		return DHL_OK;
	}
	else
	{
		g_aud_alive = FALSE;
		dhl_av_audio_start_end(aud_pid, pcr_pid, FALSE);
		return DHL_FAIL;
	}
#if 0//khw140408 blocking.	
//	g_dhlav.curAudioContext = (void *)1; // TODO.. 
	g_dhlav.uAudPID = aud_pid;

	if (g_dhlav.uPcrPID && g_dhlav.uPcrPID != pcr_pid) {
		printf("!! pcr pid setting mismatch! video pcr 0x%x != audio pcr 0x%x\n",
				g_dhlav.uPcrPID, pcr_pid);
		// ÀÌ·¸°Ô Çϱâ À§Çؼ­´Â AV stopÀ» ÇÒ ¶§ ¸ðµç pid Á¤º¸¸¦ 0À¸·Î resetÀ» ÇØ¾ß ÇÑ´Ù.
		// mismatch°¡ ¹ß»ýÇÏ¸é ¾î¶»°Ô ÇÒ °ÍÀΰ¡?
		// --> ÀÏ´Ü ±×´ë·Î ÁøÇà..
	}

	return DHL_OK;
#endif
}


DHL_RESULT DHL_AV_AudioStop(void)
{
	DHL_RESULT result = DHL_OK;

	// cafrii 080910 add
	dhl_av_audio_stop(g_dhlav.uAudPID);
	
	g_aud_start = FALSE;
	g_aud_alive = FALSE;
	g_aud_alive_chk_time = 0;
	
	g_dhlav.uAudPID = 0;
	if (g_dhlav.uVidPID == 0) // cafrii 070718 add. PCR pidµµ resetÀÌ ÇÊ¿ä.
		g_dhlav.uPcrPID = 0;

//	g_dhlav.curAudioContext = 0;


	return result;

}


DHL_RESULT DHL_AV_AudioMuteControl(tDHL_AudioMutePlace mutePlace, BOOL bMute)
{

	DHL_RESULT dhlResult = DHL_OK;
	
	// we remember just for debugging.
	// actually, this is not necessary.
	//
	if (bMute)
		g_dhlav.audioMuteMap |= (1 << (int)(mutePlace));
	else
		g_dhlav.audioMuteMap &= ~(1 << (int)(mutePlace));

	dhl_av_audio_mute_control(mutePlace, bMute);

	return dhlResult;

}


DHL_RESULT DHL_AV_AudioSetUserVolumeRange(UINT32 uVolMin, UINT32 uVolMax)
{
	DHL_RESULT result = DHL_OK;
	
	g_audVolumeMin = uVolMin;
	g_audVolumeMax = uVolMax;
	
	if (g_audVolumeMax < g_audVolume)
	{
		g_audVolume = g_audVolumeMax;
	}
	if (g_audVolume < g_audVolumeMin)
	{
		g_audVolume = g_audVolumeMin;
	}
	
	return result;
}


DHL_RESULT DHL_AV_AudioSetVolume(UINT16 uVolLvl)
{

	DHL_RESULT dhlResult = DHL_OK;
	int logicalVol;

	// uVolLvl is user volume. (UserMin ~ UserMax)
	// realVol is logical volume. 0 ~ 100.
	//
	// device volume also may be different. it is controlled in AVCAP_Impl module.
	//
	logicalVol = uVolLvl*100/
		(g_audVolumeMax-g_audVolumeMin)-g_audVolumeMin;

	printf("audio vol: input %d, real %d\n", uVolLvl, logicalVol);

	// note that if decoder mute is ON, there will be no sound.
	
	dhlResult = dhl_av_audio_set_volume(logicalVol);
	if (dhlResult == DHL_OK) {
		g_dhlav.uVolLvl = uVolLvl; // uVolLvl is user's volume settings value.
		g_dhlav.uLogVolLvl = logicalVol;
	}
	
	return dhlResult;
}


DHL_RESULT DHL_AV_AudioGetStatus(tDHL_AudioStatus *pStatus)
{
	DHL_RESULT result = DHL_OK;
	
	if (pStatus == NULL)
	{
		DHL_OS_Printf("|%s| null arg(pStatus).\n", __FUNCTION__);
		
		result = DHL_FAIL_NULL_POINTER;
		
		return result;
	}

	if (g_aud_start == TRUE)
	{

		UINT32 curr_frm_cnt;
		
		curr_frm_cnt = dhl_av_audio_frame_count();
		if (curr_frm_cnt == g_aud_frm_cnt)
		{
			#define AUD_ALIVE_CHK_PERIOD		2000  // ms
			
			UINT32 curr_time;
			
			curr_time = DHL_OS_GetMsCount();
			if (AUD_ALIVE_CHK_PERIOD <= (curr_time - g_aud_alive_chk_time))
			{
				g_aud_alive = FALSE;
			}
		}
		else
		{
			g_aud_alive = TRUE;
			g_aud_alive_chk_time = DHL_OS_GetMsCount();
		}
		g_aud_frm_cnt = curr_frm_cnt;
	}
	else
	{
		g_aud_alive = FALSE;
	}

	memset(pStatus, 0, sizeof(tDHL_AudioStatus));
	pStatus->bDecoding = g_aud_start;
	pStatus->type = g_aud_type;
	pStatus->bOutputExist = g_aud_alive;
	if (g_aud_start == TRUE)
	{
		dhl_av_audio_get_channel_info(&pStatus->bSurround, &pStatus->bStereo);
	}
	else
	{
		pStatus->bSurround = FALSE;
		pStatus->bStereo = FALSE;
	}
	
	return result;
}


#if COMMENT
____AV____(){}
#endif


//static void dhl_av_evt_task(UINT32 arg)
//{
//
//	DHL_OS_SelfDeleteTask();
//}

DHL_RESULT DHL_AV_Init(void)
{
	DHL_RESULT dhlResult = DHL_OK;
	if(is_inited) return DHL_OK;

	// av context allocation
	// -> not necessary.

	// mutex creation
	g_dhlav.Mutex = DHL_OS_CreateMutexSemaphore("DHLAV");
	if (g_dhlav.Mutex == 0) {
	printf("!! Create DHLAV mutex failed\n");
	return DHL_FAIL;
	}

	dhlResult = dhl_av_init();

	DHL_ASSERT(dhlResult == DHL_OK, "!! av init err");

	g_dhlav.uCurVideoStatus = DHL_AV_VIDEO_STOP;
	g_dhlav.audioMuteMap = 0;  
	is_inited=TRUE;

	return DHL_OK;

}

DHL_RESULT DHL_AV_Terminate(void)
{
	DHL_RESULT result = DHL_OK;
	
	if(!is_inited) return DHL_OK;
	
	is_inited = FALSE;

	result = dhl_av_terminate();

	

	return result;
}


DHL_RESULT DHL_AV_Query(tDHL_AVQueryType type, UINT32 *pValue)
{
	DHL_RESULT result = DHL_OK;
	
	if (pValue == NULL)
	{
		DHL_OS_Printf("|%s| null arg(pValue).\n", __FUNCTION__);
		
		result = DHL_FAIL_NULL_POINTER;
		
		return result;
	}
	
	if (type == eDHL_AV_QUERY_VIDEO_CAP)
	{
		*pValue = (1 << eDHL_VIDEO_TYPE_MPEG2) |
		          (1 << eDHL_VIDEO_TYPE_H264);
	}
	else if (type == eDHL_AV_QUERY_AUDIO_CAP)
	{
		*pValue = (1 << eDHL_AUDIO_TYPE_AC3) |
		          (1 << eDHL_AUDIO_TYPE_AAC_ADTS) |
		          (1 << eDHL_AUDIO_TYPE_AAC_LATM) |
		          (1 << eDHL_AUDIO_TYPE_MPEG_1) |
		          (1 << eDHL_AUDIO_TYPE_MPEG_2);
	}
	else if(type == eDHL_AV_QUERY_VIDEO_FMT)
	{
		*pValue=g_vid_type;
	}
	else if(type == eDHL_AV_QUERY_AUDIO_FMT)
	{
		*pValue=g_aud_type;
	}
	else
	{
		*pValue=0;
		
		DHL_OS_Printf("|%s| not implemented(type:0x%x)...\n", __FUNCTION__,
		              type);
	}
	
	return result;
}


DHL_RESULT DHL_AV_Control(tDHL_AVControlType type, UINT32 value)
{
	DHL_RESULT result = DHL_OK;
	
	if (type == eDHL_AV_CTL_AUDIO_MIX_TYPE)
	{
		dhl_av_audio_set_mix_type(value);
		
		g_audMixType = value;
	}
	else
	{
		DHL_OS_Printf("|%s| not implemented(type:0x%x)...\n", __FUNCTION__,
		              type);
	}
	
	return result;
}


#if COMMENT
________________(){}
#endif


//DHL_RESULT DHL_AV_PresetCallback(tDHL_AVCALLBACK pCallBack, 
//						tDHL_AVCallbackType CBType, UINT32 ClientCntx)
//{
//	return dhl_av_register_callback(pCallBack, CBType, ClientCntx);
//}


DHL_RESULT DHL_AV_SetCallback(tDHL_AVCallbackType cb_type, tDHL_AVCALLBACK cb)
{
	DHL_RESULT result = DHL_OK;
	
	//printf("[cb_type(%d)]\n\n", cb_type);
#if 0/* khw video°¡ Á׾ Àӽ÷Π¿­¾î³õÀ½ */
	if (cb_type == eDHL_CB_VideoSeqHdr)
	{
		g_vid_seq_hdr_cb = cb;
	}		
	else if (cb_type == eDHL_CB_VideoUserData)
	{
		g_vid_usr_data_cb = cb;
	}
	else if (cb_type == eDHL_CB_FirstVideoShow)
	{
		g_vid_first_show_cb = cb;
	}
	else
	{
		result = DHL_FAIL_NOT_IMPLEMENTED;
		
		goto err;
	}
	
err:	
#else
	dhl_av_register_callback(cb, cb_type);
#endif
	return result;
}


#if COMMENT
____Cap____(){}
#endif


DHL_RESULT DHL_CAP_ChangeVideoSource(tDHL_VDID id, tDHL_CapVideoInput VideoInputSrc)
{
	return DHL_OK;
}
DHL_RESULT DHL_CAP_ChangeAudioSource(tDHL_CapAudioInput AudioInputSrc)
{
	return DHL_OK;
}


#if COMMENT
_______Test_______(){}
#endif


void set_xc_disp(int cx, int cy, int cw, int ch, int dx, int dy, int dw, int dh)
{

}

void dav_start(UINT16 vpid, UINT16 apid, BOOL b_kview)
{
	if (b_kview == 0x0f)
	{
		DHL_AV_VideoStart(0, vpid, vpid, eDHL_VIDEO_TYPE_H264);
		DHL_AV_AudioStart(apid, vpid, eDHL_AUDIO_TYPE_AAC_ADTS);	
	}
	else if (b_kview == 0x11)
	{
		DHL_AV_VideoStart(0, vpid, vpid, eDHL_VIDEO_TYPE_H264);
		DHL_AV_AudioStart(apid, vpid, eDHL_AUDIO_TYPE_AAC_LATM);	
	}
	else
	{
		DHL_AV_VideoStart(0, vpid, vpid, eDHL_VIDEO_TYPE_MPEG2);
		DHL_AV_AudioStart(apid, vpid, eDHL_AUDIO_TYPE_AC3);	
	}
	
	DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_AMP, FALSE);
	DHL_AV_VideoHide(0, FALSE);
}

void dav_stop(void)
{
	DHL_AV_VideoStop(0);
	DHL_AV_AudioStop();
}

void get_vfrm(void)
{
	//DHL_OS_Printf("video frame = 0x%x\n", vdec_getDecodedFrameCount());
}

void get_afrm(void)
{
	//DHL_OS_Printf("audio frame = 0x%x\n", *(UINT32 *)CMD20);
}