/**
	@file
		DMW_PsiSdds.c

	@brief
		PSI MW SDDS implementation

	Copyright 2010 Digital STREAM Technology, Inc.
	All Rights Reserved
*/


#include "DHL_OSAL.h"
#include "DHL_DBG.h"

#include "DHL_Timer.h"

#include "DLIB_SDDS_Monitor.h"
#include "DLIB_SDDS_Parser.h"

#include "DMW_Status.h"
#include "DMW_PsiSdds.h"


//#include <string.h> // memcmp


/*
	모든 헤더 파일을 포함하지는 않으며, compile time을 줄이기 위해
	각 모듈은 필요한 만큼의 헤더를 선언하도록 함.
*/



/*
	DHL 디버그 모듈 이름 정의 룰 참고:

	DHL 모듈들은 모두 * 로 시작.
	API는 대문자, Platform 및 기타는 소문자 사용.

	디폴트 레벨은 0으로 설정한다. (0: 에러 메시지만 출력)
	
	
*/

DHL_MODULE("$sds", 0);



#if COMMENT
____Config____(){}
#endif

/*
	이 모듈 내부에서 사용되는 각종 configuration 정의.
*/



#define DMW_SDDS_TEST 0
	// 테스트 코드 포함.



#define SDDS_ENABLE_SECTION_SYNTAX_CHECK 1
	// 섹션 syntax에 문제가 없는 것인지 MW 레벨에서 다시 체크.
	// DLIB 에서도 일단 기본적인 체크는 해 주어야 겠지만..


#define SDDS_ENABLE_DDB_RX_INTERLEAVING 1
	// 1이면 ddb 수신율을 높이기 위해 인터리빙 모드로 동작한다.
	// 대신 ddb 필터를 두배로 소모하는 단점이 있다.
	

#define SDDS_ENABLE_GLOBAL_DDB_RX 1
	// 1 이면 각 모듈별 ddb 필터를 사용하지 않고,
	// group 내의 모든 모듈 block을 수신가능하도록 ddb 필터를 설정하여 사용한다.
	


#if COMMENT
____Types____(){}
#endif

/*
	이 모듈 내부에서 사용되는 structure 및 enumerations.
*/



typedef struct
{
	//---- sddsDiiModule_t 정보의 copy
	UINT16		moduleId;
	UINT32		moduleSize; // 모듈 전체의 크기.

	//---- sddsModuleInfoDesc_t 정보의 backup
	UINT8		*moduleName;
	UINT8		*moduleSignature;

	BOOL		bNeedToDownload; // 다운로드 필요함을 의미.
	
	// 버퍼 관리를 app 쪽으로 넘겼음.
#if 0
	// 다운로드 받을 블럭이 저장될 버퍼 공간. 크기는 moduleSize 바이트.
	UINT8		*moduleBuffer;
#endif

	// 블럭의 갯수는 (moduleSize+dii->blockSize-1)/dii->blockSize 이다.
	// 맨 마지막 block의 크기는 blockSize 보다 적을 수 있다.
	UINT16		numberOfBlocks;

	// DDB의 blockNumber의 값의 범위는 16bit로서 0 부터 65535 이다.
	// blockSize는 16 bit이지만, 최대 크기는 4066 이다.
	// 따라서 모듈의 최대 크기는 4066 * 65536 = 266,469,376 이다. 약 254MB.

	// 각 DDB의 수신이 완료 되었는지를 기록하는 플래그.
	//
	// DDB가 순서대로 수신되지 않을 수 있고, 또 신호 상태에 따라 중간에 빠지는 경우도 있으므로 
	// 각 DDB 별로 수신 상태를 관리해야 한다.
	//
	// 해당 bit가 1이면 complete 되었다는 의미이다.
	// flags[blockIndex/8] & (1 << blockIndex%8) 와 같이 사용.
	// 
	UINT8		completedFlags[65536/8];  
		// <-- 너무 크다. 동적 할당으로 할까?
		// 메모리가 부족하지만 않다면 상관 없다. 이 ModuleInfo 자체도 동적 할당 받은 것임.

	// 이 파일 다운로드가 다 끝나면 true.
	BOOL 		bDownloadCompleted;

	// ddb를 수신하기 위한 psi control 핸들.
	// 인터리빙 수신 옵션이 enable 이면 0, 1 모두 사용하고 
	// 그렇지 않다면 0 만 사용한다.
	tDHL_PSI_ControlHandle hDdbCtl0; // even block number
	tDHL_PSI_ControlHandle hDdbCtl1; // odd block number

} S_SDDS_ModuleInfo;

typedef struct
{
	UINT32	groupId;
		// copy of ctx->dsi->group[ctx->iGroup].groupId;

	// compatibility 등 기타 정보를 체크해 본 결과, 처리할 필요가 없는 group 인 경우
	// 이 flag를 true로 하여 skip 하도록 한다.
	//BOOL	bNotUsed;

	// 맨 마지막 block을 제외한 모든 block의 크기.
	UINT16  blockSize; 
		// copy of ctx->dii->blockSize
	
	// dii를 수신하기 위한 psi control 핸들.
	tDHL_PSI_ControlHandle	hDiiCtl;

	// download 된 dii 섹션. NULL if not downloaded yet.
	// 모든 dii의 transaction id는 groupId와 동일해야 한다.
	sddsDiiPtr_t	dii;

	// 모듈 갯수의 제한은 딱히 없으므로, 동적으로 할당 받는다.
	int 					numModules;  // same as dii->numberOfModules
	S_SDDS_ModuleInfo		*mi;     // this is moduleinfo array.

} S_SDDS_GroupInfo;



#if COMMENT
____Types____(){}
#endif



typedef struct
{
	tDHL_TSD 	tsd;
	UINT16 		pid;

	// dsi를 수신하기 위한 psi control 핸들.
	tDHL_PSI_ControlHandle	hDsiCtl;

	// download 된 dsi 섹션. NULL if not downloaded yet.
	sddsDsiPtr_t 		dsi;
	int 				iGroup;  // dsi에서 우리가 처리할 group index
	
	S_SDDS_GroupInfo	*gi;

} S_SDDS_Context;


typedef enum
{
	//---------------------------
	eSDDS_Cmd_BEGIN = 0x20,
	eSDDS_Cmd_Init,
		// param1: task info..
	eSDDS_Cmd_Start,
		// param1: tsd
		// param2: pid
	eSDDS_Cmd_Stop,
		// no param
	eSDDS_Cmd_Delete,
		// no param
	eSDDS_Cmd_GetStatus,
		// param1: SddsStatusStructure *
		// param2: Ack semaphore
	eSDDS_Cmd_PrintStatus,
		// param1: detail level
	eSDDS_Cmd_UserAction,
		// param1: user param

	eSDDS_Cmd_Shutdown,
	
	//---------------------------
	eSDDS_Evt_BEGIN = 0x40,
	// 이벤트 공통
	// 		param1: tDHL_PSI_ControlHandle
	//		param2: tDHL_PSI_DataArray *
	eSDDS_Evt_DSI, // DSI 수신
	eSDDS_Evt_DII, // DII 수신
	eSDDS_Evt_DDB, // DDB 수신
	eSDDS_Evt_DC,  // DC  수신

	
} E_SDDS_Command;


typedef struct
{
	E_SDDS_Command cmd;

	UINT32 param[4];

} S_SDDS_TaskMessage;





#if COMMENT
____Variables____(){}
#endif

/*
	global로 적용되는 variable 정의.
	각 function 별로 특수한 용도의 variable은 각 functionX block 에서 정의 가능.
*/

static S_SDDS_Context s_sdds_context;

/*
	user callback
*/
F_SDDS_CALLBACK s_sdds_user_cb;



/*
	테스트를 위한 변수들..
*/
BOOL s_sdds_force_pidchange;



#if COMMENT
____Function____(){}
#endif


STATUS sdds_task_send_cmd(E_SDDS_Command cmd, UINT32 p0, UINT32 p1, BOOL bWait);
STATUS sdds_task_send_event(E_SDDS_Command evt, UINT32 p0, UINT32 p1);


#if COMMENT
____Group1____(){}
#endif


S_SDDS_Context *sdds_get_context(void)
{
	return &s_sdds_context;
}

void sdds_check_task(void *handle)
{
}


/**
	return TRUE if two dsi is same.
*/
BOOL sdds_is_same_dsi(sddsDsiPtr_t dsi1, sddsDsiPtr_t dsi2)
{
	int i;
	sddsDsiGroup_t *g1, *g2;
	
	if (!dsi1 || !dsi2) return FALSE;
	
	if (dsi1->transactionId != dsi2->transactionId) return FALSE;
		// transactionId 에 버전 정보가 포함되어 있으므로 
		// 이것만 비교해도 무방할 듯 함.
#if 0
	if (memcmp(&dsi1->compat, &dsi2->compat, sizeof(sddsCompatDesc_t))) return FALSE;
	if (dsi1->numberOfGroups != dsi2->numberOfGroups) return FALSE;
	
	for (i=0; i<dsi1->numberOfGroups; i++) {
		g1 = &dsi1->groups[i]; g2 = &dsi2->groups[i];
		if (g1->groupId != g2->groupId) return FALSE;
		if (g1->groupSize != g2->groupSize) return FALSE;
		if (memcmp(&g1->compat, &g2->compat, sizeof(sddsCompatDesc_t))) return FALSE;
		// 이 부분은 버그임. compat 안에 malloc 포인터가 있으므로 그냥 memcmp 하면 안됨.

		if (g1->groupInfoLength != g2->groupInfoLength) return FALSE;
		if (memcmp(&g1->groupDescriptors, &g2->groupDescriptors, g1->groupInfoLength)) return FALSE;
	}
	if (dsi1->groupInfoPrivateDataLength != dsi2->groupInfoPrivateDataLength) return FALSE;
	if (memcmp(&dsi1->groupInfoPrivateDataBytes, &dsi2->groupInfoPrivateDataBytes, 
				dsi1->groupInfoPrivateDataLength)) return FALSE;
#endif

	if (dsi1->checksum_CRC32 != dsi2->checksum_CRC32) return FALSE;
	
	return TRUE; // all data same..
}

BOOL sdds_is_same_dii(sddsDiiPtr_t dii1, sddsDiiPtr_t dii2)
{
	if (!dii1 || !dii2) return FALSE;
	if (dii1->transactionId != dii2->transactionId) return FALSE;

	// todo..

	if (dii1->checksum_CRC32 != dii2->checksum_CRC32) return FALSE;
	
	return TRUE;
}

void sdds_stop_monitor(tDHL_PSI_ControlHandle *pHandle)
{
	if (pHandle == NULL || *pHandle == (tDHL_PSI_ControlHandle)0) return;
	DLIB_SDDS_StopMonitor(*pHandle);
	*pHandle = (tDHL_PSI_ControlHandle)0;
}

void sdds_free_section(void *ppSection)
{
	void **pp = (void **)ppSection;
	if (pp == NULL || *pp == NULL) return;
	DLIB_SDDS_FreeSection(*pp);
	*pp = (void *)NULL;
}

void sdds_free_module_info(int index, S_SDDS_ModuleInfo *mi)
{
	if (!mi) return;
	
	dprint(3, "    free module info [%d] 0x%x..\n", index, mi);
#if 0
	if (mi->moduleBuffer) {
		dprint(3, "    free module buf 0x%x\n", mi->moduleBuffer);
		DHL_OS_Free((void **)&mi->moduleBuffer);
	}
#endif

	sdds_stop_monitor(&mi->hDdbCtl0);
	sdds_stop_monitor(&mi->hDdbCtl1);

	memset(mi, 0, sizeof(S_SDDS_ModuleInfo));
}

void sdds_free_all_module_info(S_SDDS_GroupInfo *gi)
{
	int iModule;
	if (!gi) return;
	
	dprint(3, "   free all %d module info\n", gi->numModules);
	for (iModule=0; iModule<gi->numModules; iModule++)
		sdds_free_module_info(iModule, &gi->mi[iModule]);
	DHL_OS_Free((void **)&gi->mi);
	
	gi->numModules = 0;
}

void sdds_free_group_info(S_SDDS_GroupInfo *gi)
{
	int iModule;
	if (!gi) return;

	dprint(3, "  free group info %x..\n", gi);
	sdds_stop_monitor(&gi->hDiiCtl);
	sdds_free_section(&gi->dii);
	
	for (iModule=0; iModule<gi->numModules; iModule++)
		sdds_free_module_info(iModule, &gi->mi[iModule]);
	DHL_OS_Free((void **)&gi->mi);

	memset(gi, 0, sizeof(S_SDDS_GroupInfo));
}

void sdds_free_all_group_info(S_SDDS_Context *ctx)
{
	if (ctx->gi == NULL) return;
	
	dprint(3, "  free all group info..\n");
	sdds_free_group_info(ctx->gi);

	DHL_OS_Free((void **)&ctx->gi);

	// ctx->dsi 및 hDsiCtl은 건드리지 않는다. 이것은 GroupInfo가 아니다.
}

void sdds_stop_all_monitor(S_SDDS_Context *ctx)
{
	int i;
	if (ctx->hDsiCtl) {
		dprint(3, "  stop dsi ctl..\n");
		sdds_stop_monitor(&ctx->hDsiCtl);
	}
	if (ctx->gi && ctx->gi->hDiiCtl) {
		dprint(3, "  stop dii ctl..\n");
		sdds_stop_monitor(&ctx->gi->hDiiCtl);
	}
	for (i=0; ctx->gi && i<ctx->gi->numModules; i++) {
		if (ctx->gi->mi[i].hDdbCtl0) {
			dprint(3, "  stop ddb0[%u] ctl..\n", i);
			sdds_stop_monitor(&ctx->gi->mi[i].hDdbCtl0);
		}
		if (ctx->gi->mi[i].hDdbCtl1) {
			dprint(3, "  stop ddb1[%u] ctl..\n", i);
			sdds_stop_monitor(&ctx->gi->mi[i].hDdbCtl1);
		}
	}
}

/*
	user callback을 호출.
*/
void sdds_user_call(E_SDDS_CB_TYPE cbtype, void *param)
{
	if (!s_sdds_user_cb) return;
	
	dprint(2, "--> user callback (cbtype %u, param 0x%x)\n", cbtype, param);
	(*s_sdds_user_cb)(cbtype, param);
}


/*
	선택된 group index를 리턴.
	없다면 -1을 리턴한다.
*/
int sdds_choose_group_from_dsi(sddsDsiPtr_t dsi)
{
	int iGroup;
	
	for (iGroup=0; iGroup<dsi->numberOfGroups; iGroup++) 
	{
		// 여기서 callback을 보내서 제조사가 맞는지 체크..
		S_SDDS_CBPARAM_GET_OUI cbp = {0, };
		sdds_user_call(eSDDS_CB_TYPE_GetOUI, &cbp);

		if (cbp.oui == 0) // user가 구현하지 않았음.
			; // user not specifed oui.
		
		// group descriptor가 없다면, manufacturere를 찾을 수 없으므로, 
		// 이 dsi 그룹은 사용 불가.
		if (dsi->groups[iGroup].compat.descriptorCount == 0) continue;

		if (cbp.oui == 0x80000000) {
			dprint(2, "test mode: accept any group..\n");
			break;
		}
		if (cbp.oui) {
			// oui 정보를 알고 있는 경우.. 두 개의 desc만 체크한다.
			sddsCompatDescEntry_t *d;

			d = &dsi->groups[iGroup].compat.desc[0];
			if (d->specifierType == compatSpecifierType_IEEE_OUI &&
				(d->specifierData == cbp.oui || 0x80000000 == cbp.oui))
				dprint(2, "group[%d] desc0 oui matched 0x%x\n", iGroup, cbp.oui);
			else
				continue; // oui not matched. try next group..

			if (d->model == cbp.model || 0xFFFF == cbp.model)
				dprint(2, "group[%d] desc0 model matched 0x%x\n", iGroup, cbp.model);
			else
				continue;
			if (d->version == cbp.version || 0xFFFF == cbp.version)
				dprint(2, "group[%d] desc0 version matched 0x%x\n", iGroup, cbp.version);
			else
				continue;
		#if 0 // 그냥 맨 앞의 하나의 compat descriptor만 조사하자.
			d = &dsi->groups[iGroup].compat.desc[1];
			if (dsi->groups[iGroup].compat.descriptorCount > 1 &&
				d->specifierType == compatSpecifierType_IEEE_OUI &&
				d->specifierData == cbp.oui) {
				dprint(2, "found group[%d] desc1 oui matched 0x%x\n", iGroup, cbp.oui);
				break;
			}
			..
		#endif
		
		}
		else {
			// oui 정보를 모르는 경우. user에게 callback으로 하나씩 query..
			S_SDDS_CBPARAM_CHECK_DESC cbp2;
			cbp2.desc = &dsi->groups[iGroup].compat;
			cbp2.isOk = FALSE;
			sdds_user_call(eSDDS_CB_TYPE_CheckCompatDesc, &cbp2);
			if (cbp2.isOk) {
				dprint(2, "user choosed group[%d].\n", iGroup);
				break;
			}
		}
	}
	
	if (iGroup >= dsi->numberOfGroups) {
		dprint(0, "!! cannot find group in dsi!!\n");
		return -1;
	}
	// iGroup 선택은 완료.
	return iGroup;

}

int sdds_rx_blk_count(S_SDDS_ModuleInfo *mi)
{
	int count, i;
	for (count=0, i=0; i<mi->numberOfBlocks; i++) {
		if (mi->completedFlags[i/8] & (1<<i%8))
			count++;
	}
	//dprint(2, "  total %d / %u received\n", count, mi->numberOfBlocks);
	return count;
}

void sdds_prepare_module_info(int index, sddsDiiModule_t *m, 
			S_SDDS_CBPARAM_CHECK_FILE *f)
{
	memset(f, 0, sizeof(*f));

	//f->index = index;
	
	//-------- 모듈 상태 변수 초기화..
	f->id = m->moduleId;
	f->size = m->moduleSize; // 모듈 전체의 크기.

	// module info 디스크립터 정보 복사.
	if (m->moduleInfoDesc) 
	{
		sddsModuleInfoDesc_t *mid = m->moduleInfoDesc;
		sddsDstModuleInfoDesc_t *di = &mid->dstinfo;

		f->name = di->moduleName;
		f->version = di->moduleVer;
		f->type = di->moduleType;
		f->numSupportedHwVersions = di->numSupportedHwVersions;
		f->supportedHwVersions = di->supportedHwVersions;
		f->crc32 = di->fileCRC32;
	}

end:
	return;
}

#if COMMENT
____Group1____(){}
#endif




void SDDS_PsiRxCallback(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, 
			E_SDDS_Command cmd, UINT32 userParam)
{
	DHL_RESULT dhr;
	STATUS err;
	tDHL_PSI_DataArray *desc;
	
	if (event != ePSIEVENT_DATARECEIVED) {
		dprint(0, "!! psicallback err %d\n", event);
		return;
	}

	if (cmd == eSDDS_Evt_DSI || cmd == eSDDS_Evt_DII ||
		cmd == eSDDS_Evt_DDB || cmd == eSDDS_Evt_DC) 
	{
		dprint(2, "sdds psi rx, cmd %d, psictl %x\n", cmd, psiCtl);
		
		// race condition 으로부터의 보호가 아직 완벽하지 않으므로,
		// desc detach 작업을 이 callback task에서 수행하도록 하자.
		//
		dhr = DHL_PSI_ReadPSIData(psiCtl, &desc);
		if (dhr) {
			dprint(0, "!! %s: DHL_PSI_ReadPSIData err %x\n", __FUNCTION__, dhr);
			return;
		}
		err = sdds_task_send_event(cmd, (UINT32)psiCtl, (UINT32)desc);
					// jump to..
					// SDDS_HandleEvtProcessDsi
					// SDDS_HandleEvtProcessDii
					// SDDS_HandleEvtProcessDdb
					// SDDS_HandleEvtProcessDc
		if (err) {
			dprint(0, "!! %s: send dpc event err %d\n", __FUNCTION__, err);
			// detach 한 desc를 해제 해 줘야 메모리 leak가 없다.
			DHL_PSI_FreePSIData(desc);
		}
	}
	else {
		dprint(0, "!! %s: unknown evt msg %d\n", __FUNCTION__, cmd);
		goto errexit;
	}

errexit:
	// psiCtl clean up??
	return;	
}

void SDDS_DsiCallback(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
	SDDS_PsiRxCallback(event, psiCtl, eSDDS_Evt_DSI, userParam);
}
void SDDS_DiiCallback(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
	SDDS_PsiRxCallback(event, psiCtl, eSDDS_Evt_DII, userParam);
}
void SDDS_DdbCallback(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
	SDDS_PsiRxCallback(event, psiCtl, eSDDS_Evt_DDB, userParam);
}
void SDDS_DcCallback(tDHL_PSI_Event event, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
	SDDS_PsiRxCallback(event, psiCtl, eSDDS_Evt_DC, userParam);
}



void SDDS_HandleCmdInit(void *handle)
{
	S_SDDS_Context *ctx;

	//-------- get context
	ctx = sdds_get_context();

	//-------- init context
	memset(ctx, 0, sizeof(*ctx));
	
	dprint(2, "sdds init.. handle %x.. \n", handle);

	// iGroup은 ctx->dsi가 있을 때에만 의미가 있다.
	ctx->iGroup = -1;
}


/*
	Start API의 핸들러
*/
void SDDS_HandleCmdStart(tDHL_TSD tsd, UINT16 pid)
{
	DHL_RESULT dhr;
	S_SDDS_Context *ctx;

	//-------- parameter checking
	// tsd, pid..

	//-------- get context
	ctx = sdds_get_context();

	// check task is valid.
	//sdds_check_task(ctx->task);

	//-------- 기존에 동작 중인지 먼저 체크.
	//
	/*
		tsd나 pid가 달라지면 일단 모두 reset하고 다시 시작하는 것으로 한다.
		다음과 같은 시나리오에서 이런 경우가 발생한다.

		1. 한 RF 내에 여러 sdds 가상 채널 서비스가 존재하는 경우.
		2. 다른 방송국(다른 RF)에서 sdds 서비스를 실시하는 경우.
		3. 기존에 동작 중이던 sdds 서비스가 완료되지 않은 상태에서,
			나중에 시간이 흐른 후에 다른 pid로 새 sdds 서비스 개시..
		
		국내 규격상, 이런 경우는 발생하지 않겠지만 실험실 등에서의 실수/의도 등으로 
		이런 상황이 발생되면 최대한 문제가 없게 해야 한다.

		2번 같은 경우는 다른 RF에서 "동일한" pid로 서비스를 하는 경우에,
		이 둘의 구분이 불가능하다는 점인데, 별도의 rf_id 등이 추가되어야 할 것 같다.

		방법 1) 기존 sdds 동작이 완료 될 때 까지 새 sdds 서비스 reject.
			--> 3번 같은 경우는 기존 sdds는 이미 물건너 간 경우. 따라서 사용 불가!!
			
		방법 2) 기존 sdds 동작을 중지하고, 새로 시작
			--> 이 방법을 사용할 수 밖에 없음.
			
		빈번하게 자꾸 pid 가 변경되어 restart 되더라도 안정성에 문제가 없는지
		충분히 테스트 필요하다.

		테스트 방법: 
			A. pid 다른 두개의 스트림을 만들어 스트림 장비에서 반복 재생.
			B. 시뮬레이션.
	*/
	if (s_sdds_force_pidchange ||
		(ctx->pid != pid || ctx->tsd != tsd)) {
		if (s_sdds_force_pidchange)
			dprint(0, "-- pid change simul..\n");
		else if (ctx->pid)
			dprint(2, "!! warning: pid %x tsd %x changed\n", pid, tsd);

		dprint(2, "reset all..\n");
		
		sdds_free_all_group_info(ctx);
		// 이 안에서 reset 안되는 것들은 hDsiCtl, dsi 뿐이다.
		sdds_free_section(&ctx->dsi);

		sdds_user_call(eSDDS_CB_TYPE_ResetDownload, NULL);
	}

	//-------- 파라미터들 초기화
	ctx->tsd = tsd;
	ctx->pid = pid;

	dprint(2, "start sdds, tsd %x, pid 0x%x\n", tsd, pid);

	//-------- dsi 모니터 시작.
	// 처음에는 table_id_extension 필터 없이 모두 받는다.
	//
	/*
		이미 시작 중인데 다시 Start api가 불리는 것도 허용한다.
		즉, app 에서 채널 변경시 매번 Stop 함수를 부르지 않아도 
		MW 동작은 되도록 설계 한다. 그러나 권장하는 것은 아님.

		1. 기존 모니터가 있으니 그냥 skip 하는 방법
			혹시 그 뒷단의 dii, ddb 등에 문제가 있어서 다시 시작시키고 싶은 경우라면
			이 방법은 효과가 없음..
			dii, ddb에 문제가 있을 가능성은??

		2. filter를 다시 시작하는 방법
			무조건 dsi를 한번 더 받게 될 것임..
			어차피 채널 변경 하다가 sdds RF로 가면 무조건 dsi를 다시 받게 되므로
			별 부담은 아님..
			--> 이 방법 사용.
	*/
#if 0 // method 1
	if (ctx->hDsiCtl) {
		dprint(2, "prev dsi ctl %x active. skip dsi monitor..\n", ctx->hDsiCtl);
	}
	else
#else // method 2
	if (ctx->hDsiCtl) {
		dprint(2, "prev dsi ctl %x active.. restart..\n", ctx->hDsiCtl);
		sdds_stop_monitor(&ctx->hDsiCtl);
	}
#endif

	{
		dprint(2, "start monitor dsi..\n");
		dhr = DLIB_SDDS_MonitorDsi(tsd, pid, (UINT32)-1, ePSIUPDATE_CONTINEOUS, 
				SDDS_DsiCallback, 0, &ctx->hDsiCtl);
		DHL_ASSERT(dhr == DHL_OK, "");
	}
	
	/*
		ctx의 groupinfo 등에 대해서는 체크하지 말자.
		일단 dsi 수신 이후에 고려하자.
	*/

}


/*
	다음과 같은 경우에 호출 된다.

	1. app 에서 sdds 채널을 벗어나 다른 채널로 이동할 때..
	2. 대기모드에서 sdds 다운로드 중인데 사용자가 전원을 켜서 
		시청 채널로 가야 할 때.. (1번의 특수 케이스)

	데이터는 그대로 두고, monitor들만 중지 (stop) 한다.
*/
void SDDS_HandleCmdStop(void)
{
	S_SDDS_Context *ctx;
	int i;

	//-------- parameter checking
	// none
	
	//-------- get context
	ctx = sdds_get_context();

	dprint(2, "stop sdds rx\n");

	// check task is valid.
	//sdds_check_task(ctx->task);

	sdds_stop_all_monitor(ctx);

	sdds_user_call(eSDDS_CB_TYPE_DownloadStopped, NULL);
	
}

/*
	sdds 관련 데이터를 모두 지운다.
	지운 후에도 계속 받아지면 안되므로, 내부에서 당연히 먼저 stop 부터 한다.

	다음과 같은 경우에 호출 된다.
	1. flash update 까지 완료 된 후(??)
	2. 

	app 에서는 delete 한 이후에도 채널 변경시 마다 start를 다시 호출할 것이다.	
	셋탑은 update가 끝났다고 하더라도 채널 변경시 마다 sdds 서비스를 다시 발견할 것이니까.
	
	그래서 sdds RF의 채널을 튜닝 할 때 마다 최소한 dsi, dii는 받게 된다.
	(dsi 만 받아서는 이미 update된 sdds 스트림인지 구분 불가이므로 dii도 받음.
	더불어 groupinfo 버퍼, moduleinfo array buffer 등도 매번 할당 된다.)

	따라서 flash update 이후에도 delete를 할 필요가 별로 없다.
	firmware용 버퍼는 app에서 관리하므로, 이 delete api 없이도 쉽게 free 할 수 있을 것임.

	물론 app에서 sdds download를 대기모드에서만 수행하게 한다든가 하는 
	방식을 쓰면 좀 덜할 것임.

	추가:
		flash update가 완료 되면 어차피 reboot을 한다.
		그러면 굳이 delete를 부를 필요도 없다.
		즉 이 api는 테스트 용도 이외에는 별 의미 없다는 것..
*/
void SDDS_HandleCmdDelete(void)
{
	S_SDDS_Context *ctx;

	//-------- parameter checking
	// none
	
	//-------- get context
	ctx = sdds_get_context();

	dprint(2, "delete all sdds data\n");

	// delete 하려면 먼저 stop 부터..
	sdds_stop_all_monitor(ctx);

	// group 정보를 지우고
	sdds_free_all_group_info(ctx);

	sdds_stop_monitor(&ctx->hDsiCtl);
	sdds_free_section(&ctx->dsi);
	ctx->iGroup = -1;

	sdds_user_call(eSDDS_CB_TYPE_ResetDownload, NULL);

}


void SDDS_HandleCmdPrintStatus(int level)
{
	S_SDDS_Context *ctx;
	S_SDDS_GroupInfo  *gi;
	S_SDDS_ModuleInfo *mi;
	int k;

	//-------- parameter checking
	// none
	
	//-------- get context
	ctx = sdds_get_context();

#define print DHL_OS_Printf
	
	// dsi info
	print("--------------------------------\n");
	print("  tsd 0x%x, pid 0x%x (%u)\n", ctx->tsd, ctx->pid, ctx->pid);
	print("  dsi 0x%x, selected group idx %d\n", ctx->dsi, ctx->iGroup);
	print("  dsictl 0x%x, groupinfo 0x%x\n", ctx->hDsiCtl, ctx->gi);
	DLIB_SDDS_PrintDsiSection(ctx->dsi, 5);

	// group info
	gi = ctx->gi;
	if (gi == NULL) goto label_end;
	print("  group id 0x%x, blksz %d (0x%x)\n", gi->groupId, gi->blockSize, gi->blockSize);
	print("  dii 0x%x, %d modules\n", gi->dii, gi->numModules);
	print("  diictl 0x%x, moduleinfo list 0x%x\n", gi->hDiiCtl, gi->mi);
	DLIB_SDDS_PrintDiiSection(gi->dii, 5);

	// module info list
	if (gi->mi == NULL) goto label_end;
	for (k=0; k<gi->numModules; k++) {
		mi = &gi->mi[k];
		print("  (%d) module id 0x%x, size %d (0x%x)\n", k, mi->moduleId, mi->moduleSize, mi->moduleSize);
		print("       ddbctl0 0x%x, ddbctl1 0x%x, active %d, completed %d\n",  
					mi->hDdbCtl0, mi->hDdbCtl1, mi->bNeedToDownload, mi->bDownloadCompleted);
		print("       %d/%u received\n", sdds_rx_blk_count(mi), mi->numberOfBlocks);
	}

label_end:
	print("--------------------------------\n");

#undef print

}


void SDDS_HandleCmdUserAction(UINT32 userparam)
{
	sdds_user_call(eSDDS_CB_TYPE_UserAction, (void *)userparam);
}

/*

*/
void SDDS_HandleEvtProcessDsi(tDHL_PSI_ControlHandle psiCtl, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT dhr;
	int iGroup;
	S_SDDS_Context *ctx;
	sddsDsiPtr_t dsi = NULL;
	int i, k;

	dprint(2, "%s\n", __FUNCTION__);
	//-------- parameter checking
	

	//-------- get context
	ctx = sdds_get_context();


	//-------- check if we are too late
	// check psictl is valid
	// todo
	/*
		아래와 같은 경우는 psi event 전달이 너무 늦게 되었고, 
		그 사이에 stop api가 불린 경우이다. (또는 그 이후에 다시 start api 호출..)

		desc는 이미 핸들에서 detach 되었기 때문에 우리 소관이다. free 해줘야 한다.
	*/
	if (ctx->hDsiCtl != psiCtl) {
		// 이 psictl은 이미 stop 된 invalid handle 일 것임.
		dprint(0, "!! dsi received, but psictl mismatch ours %x event %x\n", ctx->hDsiCtl, psiCtl);
		psiCtl = (tDHL_PSI_ControlHandle)0;
		goto label_end;
	}
	
	//-------- 파싱..
	dprint(2, "  parse dsi..\n");
	if (dprintable(2)) { // dsi dump
		int size = ((desc->sectPtr[0][1] & 0xf)<<8UL) | desc->sectPtr[0][2];
		memdump(desc->sectPtr[0], size+3, "");
	}
	dhr = DLIB_SDDS_ParseDsiSection(desc->sectPtr[0], &dsi);
	DHL_ASSERT(dhr == DHL_OK && dsi != NULL, "");

	DHL_PSI_FreePSIData(desc);
	desc = NULL;

	//-------- 내용 표시..
	if (dprintable(2)) {
		DLIB_SDDS_PrintDsiSection(dsi, 0);
	}

	// dsi sanity check.
	// 모든 table consistency는 MW 레벨에서 다시 체크하도록 한다.
#if SDDS_ENABLE_SECTION_SYNTAX_CHECK
	DHL_ASSERT(dsi->numberOfGroups > 0, "");
	DHL_ASSERT(dsi->groups != NULL, "");

	if (!dsi->groups || dsi->numberOfGroups <= 0) {
		dprint(0, "!! invalid dsi, num_group %d\n", dsi->numberOfGroups);
		// 다시 받아도 마찬가지 일 것이므로 그냥 중단.
		// dsi 모니터는 continuous 모드로 받고 있으므로  빨리 중단.
		sdds_stop_monitor(&ctx->hDsiCtl);
		goto label_end;
	}
#endif // SDDS_ENABLE_SECTION_SYNTAX_CHECK


	//------- 이미 받은 dsi와 동일한 것을 또 수신 했을 수도 있으므로 체크.

	if (ctx->dsi) 
	{
		do {
			/*
				어느 정도 까지 자세히 비교해야 할까? 
				그냥 버전 비교만으로 되는지 아니면 byte compare가 필요한지..
				todo..
			*/
			if (!sdds_is_same_dsi(ctx->dsi, dsi)) {
				dprint(2, "  dsi changed\n");
				break;
			}
			dprint(2, "  new dsi is same as old one\n");
			// pause 되었다가 재시작 한 경우이거나, 
			// 뭔가 필터가 잘못 되어 동일한 섹션이 수신된 경우이다. 

			// ctx->dsi 가 non-null 이라면 반드시 다음 조건이 만족되어야 한다.
			//    1. ctx->iGroup 이 valid.
			//    2. ctx->groups 버퍼 할당 완료
			// 이 조건이 만족되지 않으면 다시 시작해야 함.
			
			if (ctx->iGroup < 0 || ctx->iGroup >= ctx->dsi->numberOfGroups) {
				dprint(0, "!! iGroup %d invalid!\n", ctx->iGroup);
				break;
			}
			if (ctx->gi == NULL) {
				dprint(0, "!! ctx groupinfo null!\n");
				break;
			}
			// dsi 를 더 이상 처리할 필요가 없는 경우이다.
			sdds_free_section(&dsi);
			// 새로 받은 dsi는 ctx->dsi와 중복된 것이므로 free하고 
			// dii 처리부로 간다.
			goto monitor_dii;
			
		} while (0);

		/*
			dsi가 변경 될 수 있는 상황:
			1. 스트림이 중간에 변경. (실험실 상황)
			2. 오래전에 실시 되었던 sdds가 완료 되지 못하고 남아 있다가 
			   나중의 새 sdds 발견. (가능성은 희박)
		*/
		// dsi가 변경 된 경우.. 또는 뭔가 문제가 생겨서 다시 reset 해야 하는 경우..
		// 이 모든 경우가 사실상 비정상 상황이다.
		dprint(0, "!!!! dsi is changed. clean up first..\n");

		// 동작 중인 모든 필터를 다 stop 하고, 
		// 내부를 완전히 reset 한다.
		sdds_free_all_group_info(ctx);
		// 이 안에서 reset 안되는 것들은 hDsiCtl, dsi 뿐이다.

		sdds_free_section(&ctx->dsi);
		//ctx->dsi = dsi;  // group 정보를 다 처리한 후 맨 나중에 등록해야 한다.
		// 두개의 중복 포인터는 자제하는 것이 바람직.

		sdds_user_call(eSDDS_CB_TYPE_ResetDownload, NULL);
		
	}
	else {
		// dsi를 처음 수신 한 경우..
		dprint(2, "  first dsi\n");

		// 혹시 남아 있을 지 모르는 모든 데이터를 삭제..
		sdds_free_all_group_info(ctx);
		//ctx->dsi = dsi;  // group 정보를 다 처리한 후 맨 나중에 등록해야 한다.
		// 두개의 중복 포인터는 자제하는 것이 바람직.
	}

	//------------- 그룹 선택 ----------
	DHL_ASSERT(ctx->dsi == NULL && dsi != NULL, "");

	/*

	*/
	iGroup = sdds_choose_group_from_dsi(dsi);

	if (iGroup < 0) {
		// 그룹이 없다면 이 dsi는 쓸모 없는 데이터이다.
		// 그러나 삭제를 하면 새로운 dsi 수신을 할 수 없으므로 (trid)
		// 일단 keep한다.
		//sdds_free_section(&dsi);
		ctx->dsi = dsi;
		dsi = NULL;
		sdds_free_all_group_info(ctx);

		goto monitor_dsi_change;
	}

	// iGroup 선택은 완료.
	DHL_ASSERT(iGroup >= 0 && iGroup < dsi->numberOfGroups, "");

	//-------- 그룹 구조체 메모리 할당 및 초기화..

	if (1) {
		// 우리가 관심있는 그룹 하나만 처리..

		ctx->gi = DHL_OS_Malloc(sizeof(S_SDDS_GroupInfo));
		DHL_ASSERT(ctx->gi != NULL, "");
		dprint(2, "  groupinfo: 0x%x\n", ctx->gi);

		ctx->gi->groupId = dsi->groups[iGroup].groupId;
	}
	
	//-------- dsi 처리 완료 ------------
	ctx->dsi = dsi;
	dsi = NULL;     // 관리 편의를 위해 하나의 포인터만 사용.
	ctx->iGroup = iGroup;


	//-------- dsi 기타 정보 ------------
	if (ctx->dsi->groups[iGroup].scheduleDescriptor.numSchedules > 0)
	{
		// schedule 정보 알려줌.
		sdds_user_call(eSDDS_CB_TYPE_NotifySchedules, 
			&ctx->dsi->groups[iGroup].scheduleDescriptor);

		// schedule 정보와 상관 없이, 항상 다음 단계로 진행한다.
		// schedule 정보는 standby 상태에서 app에서 사용할 것임.
	}

	//-------- dii 모니터 시작 ---------
monitor_dii:

	// 이 시점부터는 dsi 는 사용하지 않고, ctx->dsi 만 사용하도록 하자. (관리 편의)
	DHL_ASSERT(dsi == NULL, "");
	DHL_ASSERT(ctx->gi != NULL, "");
	
	if (1) {
		S_SDDS_GroupInfo *gi = ctx->gi;

		dprint(2, "  processing group id 0x%x..\n", gi->groupId);

		//-------- 기존 dii 모니터 stop.
		/* comment
			새 dsi가 수신되면 무조건 기존 monitor는 restart 하도록 하자.
			groupId 등의 변경 여부를 체크해서 선택적으로 restart 해도 되지만,
			매번 restart 해도 크게 문제되지 않을 듯 함.

			논리적으로 dii ctl이 남아 있을 수도 있다. stop 없이 start api를 연속 부르면..
		*/
		if (gi->hDiiCtl) {
			dprint(0, "!!    cancel old dii monitor.. %x\n", gi->hDiiCtl);
			sdds_stop_monitor(&gi->hDiiCtl);
		}

		//-------- dii 모니터 시작.
		// 처음에는 table_id_extension 필터 없이 모두 받는다.
		// 
		dprint(2, "    monitor dii with groupid 0x%x..\n", gi->groupId);
		dhr = DLIB_SDDS_MonitorDii(ctx->tsd, ctx->pid, gi->groupId, ePSIUPDATE_ONESHOT, 
				SDDS_DiiCallback, 0, &gi->hDiiCtl);
		DHL_ASSERT(dhr == DHL_OK, "");
	}

monitor_dsi_change:

	/* comment
		dsi change를 hardware적으로 filtering 하면 좋은데
		top-level dsi는 많은 bit가 0으로 고정이므로
		table_id_extension 만을 사용할 경우 LSB 1bit 밖에 사용할 수 없다.

		만약 dsi1 --> dsi2 --> dsi3 과 같이 세번 변경이 되고 있는데, 
		dsi2 부분에 신호 상태 등이 않좋아서 dsi2를 받지 못했다면 
		dsi3는 못받을 수도 있다.

		제대로 하려면 transaction_id 의 version field(14bit)를 filter로 걸면 된다.
		HAL에서 지원되는지에 따라 사용 가능 여부가 달라진다.

		하지만 위 예에서와 같이 dsi3를 못받는 상황에서도 stop & start를 하면 
		다시 받게 된다. (다른 채널에 다녀오면 받는 다는 의미)
		따라서 1 bit 만 monitor해도 될 듯 하다.
	*/

	// 현재의 dsi를 기준으로 새로운 dsi를 monitor한다.
	DHL_ASSERT(ctx->dsi != NULL, "");
	sdds_stop_monitor(&ctx->hDsiCtl);

	//-------- 새로운 dsi 모니터.
	
	// dsi는 버전이 올라갈 때 마다 transactionId의 마지막 LSB가 toggle된다.
	dprint(2, "  monitor dsi with new trid %x..\n", ctx->dsi->transactionId ^ 1);
	dhr = DLIB_SDDS_MonitorDsi(ctx->tsd, ctx->pid, 
			ctx->dsi->transactionId ^ 1, ePSIUPDATE_CONTINEOUS, 
			SDDS_DsiCallback, 0, &ctx->hDsiCtl);
	DHL_ASSERT(dhr == DHL_OK, "");

label_end:
	if (dsi){
		// 여기까지 dsi가 흘러온 거면 정상 상황이 아님.
		sdds_free_section(&dsi);
	}
	if (desc) {
		DHL_PSI_FreePSIData(desc);
		desc = NULL;
	}
}


/*


*/
void SDDS_HandleEvtProcessDii(tDHL_PSI_ControlHandle psiCtl, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT dhr;
	int iModule;
	int nModuleToDownload;
	int nModuleCompleted;
	int nBlocksToDownload;
	S_SDDS_Context *ctx;
	S_SDDS_GroupInfo *gi = NULL;
	sddsDiiPtr_t dii = NULL;
	int i;

	dprint(2, "%s\n", __FUNCTION__);
	
	//-------- parameter checking
	

	//-------- get context
	ctx = sdds_get_context();
	gi = ctx->gi;

	//-------- check if we are too late
	//if ( ) return;
	// check psictl is valid

	/*
		event처리가 늦어진 상황에서:
			reset api가 호출되었다면 gi가 null
			stop api가 호출되었다면 psictl이 달라짐.
	*/
	if (gi == NULL) {
		dprint(0, "!! dii without groupinfo\n"); // app 에서 Reset을 했을 수도 있음.
		goto label_end;  // 그냥 조용히 무시..
	}
	
	if (gi->hDiiCtl != psiCtl) { // app 에서 Reset 또는 Stop 을 했을 수도 있음.
		// 이 psictl은 이미 stop 된 invalid handle 일 것임.
		dprint(0, "!! dii received, but psictl mismatch %x %x\n", gi->hDiiCtl, psiCtl);
		psiCtl = (tDHL_PSI_ControlHandle)0;
		goto label_end;  // 그냥 조용히 무시..
	}

	//-------- 파싱..
	dprint(2, "  parse dii..\n");
	if (dprintable(2)) {
		int size = ((desc->sectPtr[0][1] & 0xf)<<8UL) | desc->sectPtr[0][2];
		memdump(desc->sectPtr[0], size+3, "");
	}
	dhr = DLIB_SDDS_ParseDiiSection(desc->sectPtr[0], &dii);
	DHL_ASSERT(dhr == DHL_OK && dii != NULL, "");

	DHL_PSI_FreePSIData(desc);
	desc = NULL;

	//-------- 내용 표시..

	if (dprintable(2)) {
		DLIB_SDDS_PrintDiiSection(dii, 0);
	}

#if SDDS_ENABLE_SECTION_SYNTAX_CHECK
	DHL_ASSERT(dii->numberOfModules > 0, "");
	DHL_ASSERT(dii->modules != NULL, "");

	if (!dii->modules || dii->numberOfModules == 0) {
		dprint(0, "!! invalid dii, num module %d\n", dii->numberOfModules);
		// 이 dii는 invalid 하므로, 다음 버전 up되기를 기다려야 함.
		// 버전 변경은 dsi 부터 다시 시작하므로, 이 dii psictl은 중단.
		sdds_stop_monitor(&gi->hDiiCtl);
		goto label_end;
	}
#endif // SDDS_ENABLE_SECTION_SYNTAX_CHECK


	//-------- 현재의 context 상황 체크.

	// 아래 각종 메시지들은 일반적인 상황에서는 발생되지 않아야 하지만,
	// 과부하 상태에서는 충분히 발생 가능한 것들임.
	//
	// 예로 continuous 모드로 수신하면서 (dii callback 이 계속 불림)
	// 이 task의 처리가 늦어지면 (이 task 에서 dii psictl stop)
	// queue 에 쌓여 있던 dii callback이 뒤늦게 올 수 있다.

	if (ctx->dsi == NULL) {
		dprint(0, "!! dii without dsi\n"); // app 에서 Reset을 했을 수도 있음.
		goto label_end;  // 그냥 조용히 무시..
	}
	if (gi->groupId != dii->transactionId) { 
		// 이런 경우는 드물다.. dii는 특정 trid로 지정 수신함.
		dprint(0, "!! new dii's trid %x not matched of group id %x\n",
					dii->transactionId, gi->groupId);
		// 처리가 늦어져서 발생한 경우라면 그냥 조용히 무시하면 되는데, 그럴 가능성 낮음.
		// 그 이외의 경우라면, 더 받아 봤자 똑같으니 psictl 중단.
		sdds_stop_monitor(&gi->hDiiCtl);
		goto label_end;
	}

	//-------- dii filtering

	// no filtering required.
	

	//-------- 기존 dii 와의 비교. 변경 사항 체크.

	if (gi->dii)
	{
		do {
			if (!sdds_is_same_dii(gi->dii, dii)) break;

			// 정말로 모든 것이 다 동일한지 하나씩 다시 체크..	
			if (gi->numModules != dii->numberOfModules) {
				dprint(0, "!! num module changed %u %u\n", gi->numModules, dii->numberOfModules);
				break;
			}
			for (i=0; i<gi->numModules; i++) {
				//if (gi->mi[i].moduleBuffer == NULL) break;
				if (gi->mi[i].moduleId != dii->modules[i].moduleId) break;
				if (gi->mi[i].moduleSize != dii->modules[i].moduleSize) break;
			}
			if (i<gi->numModules) {
				dprint(0, "!! module info [%d] changed\n", i);
				break;
			}

			dprint(2, "  new dii is same as old one\n");
			// ok. dii 와 mi 정보는 완전히 동일하다고 볼 수 있음.
			// dii 는 gi->dii 와 중복된다고 보고 삭제 하고 ddb 모니터로 jump..			
			sdds_free_section(&dii);
			goto download_start;
			
		} while(0);

		dprint(0, "  module info or dii changed. reset!\n");

		sdds_free_all_module_info(gi);
		sdds_free_section(&gi->dii);

		// user에게도 이 사실을 알려줌.
		sdds_user_call(eSDDS_CB_TYPE_ResetDownload, NULL);
		
	}
	else {
		dprint(2, "  first dii\n");
		sdds_free_all_module_info(gi);
	}

	//-------- 모듈 구조체 메모리 할당 및 초기화..

	DHL_ASSERT(gi->dii == NULL && dii != NULL, "");
	DHL_ASSERT(gi->mi == NULL, "");
	
	dprint(2, "  alloc %d module info..\n", dii->numberOfModules);
	gi->mi = DHL_OS_Malloc(dii->numberOfModules * sizeof(S_SDDS_ModuleInfo));
	DHL_ASSERT(gi->mi != NULL, "");

	gi->blockSize = dii->blockSize;
	gi->numModules = dii->numberOfModules;

	for (iModule=0; iModule<gi->numModules; iModule++)
	{
		S_SDDS_CBPARAM_CHECK_FILE fileinfo;
		S_SDDS_ModuleInfo *mi = &gi->mi[iModule];

		dprint(2, "  processing module[%d]..\n", iModule);

		// application query callback
		sdds_prepare_module_info(iModule, &dii->modules[iModule], &fileinfo);


		//-------- module 정보 callback. accept 여부 query.
		fileinfo.isOk = FALSE;
		sdds_user_call(eSDDS_CB_TYPE_CheckModuleInfo, &fileinfo);

		if (fileinfo.isOk) {
			dprint(2, "  module accepted\n");
			mi->bNeedToDownload = TRUE;
		}
		else {
			dprint(2, "  !! user denied this module\n");
			mi->bNeedToDownload = FALSE;
		}

		//-------- 모듈 상태 변수 
		mi->moduleId        = fileinfo.id;
		mi->moduleSize      = fileinfo.size;
		mi->moduleName      = fileinfo.name;
		mi->moduleSignature = fileinfo.version;

		// 블럭의 갯수는 (moduleSize+dii->blockSize-1)/dii->blockSize 이다.
		// 맨 마지막 block의 크기는 blockSize 보다 적을 수 있다.
		mi->numberOfBlocks = (mi->moduleSize + dii->blockSize-1)/dii->blockSize;
		mi->bDownloadCompleted = FALSE;

		/*
			버퍼 관리는 app 에서 하도록 정책 변경.
			버퍼를 MW에서 하게 되면 나중에 buffer free를 위한 별도의 api가 필요하게 됨.
		*/
	#if 0
		//-------- 모듈 버퍼 메모리 할당..
		// 다운로드 받을 블럭이 저장될 버퍼 공간. 크기는 moduleSize 바이트.
		dprint(2, "    alloc module buffers.. %u bytes..\n", mi->moduleSize);
		// todo..
		// 요구 하는 메모리 크기가 엄청 클 수도 있음.. 체크 요망..

		if (mi->moduleSize > SDDS_MAX_MODULE_SIZE) {
			dprint(2, "!! module size exceed max\n");
		}
		else {
			mi->moduleBuffer = DHL_OS_Malloc(mi->moduleSize);
			DHL_ASSERT(mi->moduleBuffer != NULL, "");
		}
	#endif
		
		//mi->completedFlags[65536/8];
		memset(mi->completedFlags, 0, sizeof(mi->completedFlags));

	}

	//-------- dii 처리 완료 ------------
	gi->dii = dii;
	dii = NULL;

download_start:

	DHL_ASSERT(gi->dii != NULL && dii == NULL, "");

	//-------- ddb 모니터 준비..
	for (iModule=0, nModuleToDownload=0, nBlocksToDownload=0; iModule<gi->numModules; iModule++)
	{
		S_SDDS_ModuleInfo *mi = &gi->mi[iModule];

		//-------- 기존 ddb 모니터 중지.
		// 새 dii가 수신되면 무조건 기존 monitor는 restart 하도록 하자.
		if (mi->hDdbCtl0) {
			dprint(2, "    cancel old ddb0 monitor[%d] 0x%x..\n", iModule, mi->hDdbCtl0);
			sdds_stop_monitor(&mi->hDdbCtl0);
		}
		if (mi->hDdbCtl1) {
			dprint(2, "    cancel old ddb1 monitor[%d] 0x%x..\n", iModule, mi->hDdbCtl1);
			sdds_stop_monitor(&mi->hDdbCtl1);
		}
		/* 버전 등을 확인하여 download가 필요 없는 파일들은 별도로 check를 해 두었음.
		*/
		if (!mi->bNeedToDownload) continue;

		if (mi->bDownloadCompleted) {
			nModuleCompleted++;
			continue;
		}

		nModuleToDownload ++;
		nBlocksToDownload += mi->numberOfBlocks;
	}

	if (nModuleToDownload > 0) {
		// 이제 ddb monitor를 시작하면 바로 blonk 수신이 시작된다.
		// 이 시점에서 download start callback 알림.
		S_SDDS_CBPARAM_DOWNLOAD_START param;
		param.total_blocks = nBlocksToDownload;
		sdds_user_call(eSDDS_CB_TYPE_DownloadStarted, &param);
	}
	else if (nModuleCompleted > 0) {
		dprint(2, "    all modules downloaded already\n");
		sdds_user_call(eSDDS_CB_TYPE_DownloadCompleted, (void *)(-1));
		goto monitor_dii_change;
	}
	else {
		dprint(2, "    no modules to download\n");
		sdds_user_call(eSDDS_CB_TYPE_DownloadNotRequired, NULL);
		goto monitor_dii_change;
	}
	
	//-------- ddb 모니터 시작.
	for (iModule=0; iModule<gi->numModules; iModule++)
	{
		S_SDDS_ModuleInfo *mi = &gi->mi[iModule];

		//-------- 기존 ddb 모니터 중지.
		// 새 dii가 수신되면 무조건 기존 monitor는 restart 하도록 하자.
		if (mi->hDdbCtl0)
			sdds_stop_monitor(&mi->hDdbCtl0);
		if (mi->hDdbCtl1)
			sdds_stop_monitor(&mi->hDdbCtl1);

		if (!mi->bNeedToDownload) {
			dprint(2, "    module[%d] download skipped\n", iModule);
			continue;
		}

#if SDDS_ENABLE_DDB_RX_INTERLEAVING
		dprint(2, "    start monitor ddb_0 [%d]..\n", iModule);
		dhr = DLIB_SDDS_MonitorDdb(ctx->tsd, ctx->pid, mi->moduleId, 
				eDDB_RIM_Even, ePSIUPDATE_CONTINEOUS, 
				SDDS_DdbCallback, 0, &mi->hDdbCtl0);
		DHL_ASSERT(dhr == DHL_OK, "");
		dprint(2, "    start monitor ddb_1 [%d]..\n", iModule);
		dhr = DLIB_SDDS_MonitorDdb(ctx->tsd, ctx->pid, mi->moduleId, 
				eDDB_RIM_Odd, ePSIUPDATE_CONTINEOUS, 
				SDDS_DdbCallback, 0, &mi->hDdbCtl1);
		DHL_ASSERT(dhr == DHL_OK, "");
#else
		dprint(2, "    start monitor ddb[%d]..\n", iModule);
		dhr = DLIB_SDDS_MonitorDdb(ctx->tsd, ctx->pid, mi->moduleId, 
				eDDB_RIM_All, ePSIUPDATE_CONTINEOUS, 
				SDDS_DdbCallback, 0, &mi->hDdbCtl0);
		DHL_ASSERT(dhr == DHL_OK, "");
		// 인터리빙 수신을 하지 않는다면 hDdbCtl1 은 사용하지 않는다.
#endif

	}

monitor_dii_change:

	DHL_ASSERT(gi->dii != NULL, "");
	sdds_stop_monitor(&gi->hDiiCtl);

	// dii가 바뀌면 dsi도 같이 바뀌니까 굳이 모니터를 걸지 않아도 될 듯 함..

label_end:

	if (dii) {
		// ctx에 등록되지 않고 여기까지 흘러온 dii는 버려야 함.
		sdds_free_section(&dii);
	}
	if (desc) { // 에러 발생시 여기서 desc가 free 됨.
		DHL_PSI_FreePSIData(desc);
		desc = NULL;
	}

}


/*


*/
void SDDS_HandleEvtProcessDdb(tDHL_PSI_ControlHandle psiCtl, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT dhr;
	S_SDDS_Context *ctx;
	S_SDDS_GroupInfo *gi = NULL;
	S_SDDS_ModuleInfo *mi = NULL;
	sddsDdbPtr_t ddb = NULL;
	int i, iModule;
	UINT32 received_blocks;

	dprint(2, "%s\n", __FUNCTION__);
	
	//-------- parameter checking
	

	//-------- get context
	ctx = sdds_get_context();

	//-------- check if we are too late
	//if ( ) return;
	// check psictl is valid

	gi = ctx->gi;
	if (gi == NULL) {
		dprint(0, "!! ddb without groupinfo\n");
		goto label_end;
	}
	if (gi->mi == NULL || gi->numModules <= 0) {
		dprint(0, "!! ddb without moduleinfo\n");
		goto label_end;
	}

	/*
		psictl이 유효한 것인지를 검사해야 하는데, mi->hDdbCtl 에 저윳퓸?있다.
		그러나 이 시점에서 mi를 찾을 수는 없다.
		어느 module 의 데이터인지를 알려면 ddb를 parsing 해서
		ddb->moduleId 와 일치하는 module을 찾아야 한다.
		그래서 순서가 다른 handler와 좀 다르다. 일단 parsing 부터 해 봐야 한다.

		이미 잘못된 psictl이라면 엉뚱한 데이터일 수 있다. (ddb가 아니라 pat 라든가..)
		HAL에서 handle을 validate check 하는 api를 제공해 주면 좋다.
	*/
	//-------- 파싱..
	dprint(2, "  parse ddb..\n");
	dhr = DLIB_SDDS_ParseDdbSection(desc->sectPtr[0], &ddb);
	// 에러가 발생할 수도 있음.. 대책 필요..
	DHL_ASSERT(dhr == DHL_OK && ddb != NULL, "");


	//-------- 내용 표시..

	if (dprintable(2)) {
		DLIB_SDDS_PrintDdbSection(ddb, 0);
	}


	//-------- 현재의 context 상황 체크.

	// 어느 모듈에 속한 블럭인지 찾는다.
	for (mi=NULL, iModule=0; iModule<gi->numModules; iModule++) {
		if (gi->mi[iModule].moduleId == ddb->moduleId) {
			mi = &gi->mi[iModule];
			break;
		}
	}
	if (mi == NULL) {
		dprint(0, "!! cannot find related module\n");
		goto label_end;
	}	
	if (mi->hDdbCtl0 != psiCtl && mi->hDdbCtl1 != psiCtl) {
		dprint(0, "!! ddb received, but psictl mismatch 0:%x 1:%x this:%x\n", 
				mi->hDdbCtl0, mi->hDdbCtl1, psiCtl);
		psiCtl = (tDHL_PSI_ControlHandle)0; // 이미 stop 된 핸들임.
		goto label_end; // 그냥 조용히 무시..
	}

	dprint(2, "  this block is from module[%d], moduleId 0x%x, ddbctl %d\n", 
			iModule, mi->moduleId, psiCtl==mi->hDdbCtl0 ? 0 : 1);

	//------- block 검사 및 처리..

	// 어떤 경우? 
	// 이미 reset 된 경우 밖에 없을 듯 함.. reset은 위에서 걸러지는데. 일단 체크하자.
	if (mi->bNeedToDownload == FALSE) {
		dprint(0, "!! ddb with non-necessary module?\n");
		//DHL_ASSERT(FALSE, "");
		goto label_end;
	}

	// block number 범위 체크.
	if (ddb->blockNumber >= mi->numberOfBlocks) {
		dprint(0, "!! ddb block# %u exceed max %u. moduleSize %u\n", 
			ddb->blockNumber, mi->numberOfBlocks, mi->moduleSize);
		goto label_end;
	}
	// block data size 체크. 모듈의 마지막 block을 제외하고는 모두 미리 알려진 정보와 일치해야 함.
	if ((ddb->blockNumber < mi->numberOfBlocks-1 && ddb->blockDataLength != gi->blockSize) ||
		(ddb->blockNumber == mi->numberOfBlocks-1 && ddb->blockDataLength > 4066)) {
		dprint(0, "!! ddb block (blk# %u) data len %u invalid\n", 
					ddb->blockNumber, ddb->blockDataLength);
		goto label_end;
	}

	// 기 수신 여부 체크.
	if (mi->completedFlags[ddb->blockNumber/8] & (1 << ddb->blockNumber%8)) {
		dprint(1, "  block #%u (moduleId %u) already received, %d/%u\n", 
				ddb->blockNumber, mi->moduleId, sdds_rx_blk_count(mi), mi->numberOfBlocks);
		// cafrii 100819 fix
		// 이미 수신 완료 상태에서 caller가 다시 start 했을 수도 있으므로 
		// 매 block 수신 마다 complete 체크를 하도록 하자.

		received_blocks = sdds_rx_blk_count(mi);
		goto label_check_complete;
	}

	mi->completedFlags[ddb->blockNumber/8] |= (1 << ddb->blockNumber%8);
	
	// 수신 정도 표시.. 
	received_blocks = sdds_rx_blk_count(mi);
	dprint(1, "  %d/%u ddb blks received\n", received_blocks, mi->numberOfBlocks);

	//------- application callback

	if (1) {
		S_SDDS_CBPARAM_BLOCK_RECEIVED cbp;

		memset(&cbp, 0, sizeof(cbp));
		cbp.ddb = ddb;
		cbp.idxblk = ddb->blockNumber;
		cbp.offset = ddb->blockNumber*gi->blockSize;
		cbp.received_blocks = received_blocks;
		cbp.total_blocks = mi->numberOfBlocks;

		sdds_user_call(eSDDS_CB_TYPE_BlockReceived, &cbp);
	}

label_check_complete:

	// 다 수신 된 거라면 완료.

	if (received_blocks == mi->numberOfBlocks) {
		dprint(2, "  module[%d] download completed\n", iModule);
		sdds_stop_monitor(&mi->hDdbCtl0);
		sdds_stop_monitor(&mi->hDdbCtl1);
		mi->bDownloadCompleted = TRUE;

		sdds_user_call(eSDDS_CB_TYPE_DownloadCompleted, (void *)(UINT32)mi->moduleId);
	}

	// 모든 module 이 다운로드 완료 되면 callback.
	if (1) 
	{
		BOOL bAllCompleted = TRUE;
		for (i=0; i<gi->numModules; i++) {
			// 하나라도 다 안받은 모듈이 있다면 아님..
			if (gi->mi[i].bNeedToDownload && !gi->mi[i].bDownloadCompleted) {
				bAllCompleted = FALSE;
				break;
			}
		}
		if (bAllCompleted) {
			dprint(2, "  all modules are completed\n");
			sdds_user_call(eSDDS_CB_TYPE_DownloadCompleted, (void *)-1);
		}
	}

label_end:

	//-------- 마무리..

	// ddb 섹션의 포인터는 실제로는 이 desc 안의 데이터를 그냥 pointing 만 한 것이다.
	// 따라서 ddb 섹션을 다 활용하기 전까지는 이 desc를 free 하면 안된다.

	// 꼭 필요하다면 memcpy를 해 두어야 하는데, 권장하지 않음..
	if (desc)
		DHL_PSI_FreePSIData(desc);

	sdds_free_section(&ddb);
	
}


void SDDS_HandleEvtProcessDc(tDHL_PSI_ControlHandle psiCtl, tDHL_PSI_DataArray *desc)
{
	dprint(2, "%s\n", __FUNCTION__);

	DHL_PSI_FreePSIData(desc);
}




#if COMMENT
____TaskWrapper____(){}
#endif


DHL_TMHANDLE g_sdds_task;

#define DMW_SDDS_TASK_PRIO  TASK_PRI_DMW_PSI
#define DMW_SDDS_TASK_STACK 16384


/*
	proxy는 timer stub들을 보이지 않게 해 주는 thin layer.

	command 와 event를 분리하는 특별한 이유는 없음.

	모든 command/event를 다 분리할 수도 있고, (각각의 timer callback 사용)
		(--> 코드가 지저분..)
	모든 command/event를 하나의 callback에서 처리할 수도 있다. 
		(--> 성능 상의 손해..)

	그냥 두 극단 옵션의 중간 정도를 사용함..
*/
void _sdds_task_proxy_cmd(UINT32 idTimer, UINT32 *param)
{
	if (0);
	else if (idTimer == eSDDS_Cmd_Init) {
		dprint(2, "cmd init\n");
		SDDS_HandleCmdInit((void *)param[0]);
	}
	else if (idTimer == eSDDS_Cmd_Start) {
		dprint(2, "cmd start\n");
		SDDS_HandleCmdStart((tDHL_TSD)param[0], param[1]);
	}
	else if (idTimer == eSDDS_Cmd_Stop) {
		dprint(2, "cmd stop\n");
		SDDS_HandleCmdStop();
	}
	else if (idTimer == eSDDS_Cmd_Delete) {
		//dprint(2, "cmd delete\n");
		SDDS_HandleCmdDelete();
	}
	else if (idTimer == eSDDS_Cmd_GetStatus) {
		//dprint(2, "cmd get status\n");
		//SDDS_HandleCmdGetStatus(param[0], param[1]);
	}
	else if (idTimer == eSDDS_Cmd_PrintStatus) {
		//dprint(2, "cmd print status\n");
		SDDS_HandleCmdPrintStatus(param[0]);
	}
	else if (idTimer == eSDDS_Cmd_UserAction) {
		SDDS_HandleCmdUserAction(param[0]);
	}
	else if (idTimer == eSDDS_Cmd_Shutdown) {
		//dprint(2, "cmd shutdown\n");
		//SDDS_HandleCmdShutdown(param[0], param[1]);
	}
	else
		dprint(0, "!! unknown cmd 0x%x\n", idTimer);
}

void _sdds_task_proxy_event(UINT32 idTimer, UINT32 *param)
{
	if (0);
	else if (idTimer == eSDDS_Evt_DSI) {
		dprint(2, "dsi msg\n");
		SDDS_HandleEvtProcessDsi((tDHL_PSI_ControlHandle)param[0], (tDHL_PSI_DataArray *)param[1]);
	}
	else if (idTimer == eSDDS_Evt_DII) {
		dprint(2, "dii msg\n");
		SDDS_HandleEvtProcessDii((tDHL_PSI_ControlHandle)param[0], (tDHL_PSI_DataArray *)param[1]);
	}
	else if (idTimer == eSDDS_Evt_DDB) {
		dprint(2, "ddb msg\n");
		SDDS_HandleEvtProcessDdb((tDHL_PSI_ControlHandle)param[0], (tDHL_PSI_DataArray *)param[1]);
	}
	else if (idTimer == eSDDS_Evt_DC) {
		dprint(2, "dc msg\n");
		SDDS_HandleEvtProcessDc((tDHL_PSI_ControlHandle)param[0], (tDHL_PSI_DataArray *)param[1]);
	}
	else
		dprint(0, "!! unknown evt 0x%x\n", idTimer);
}

STATUS sdds_task_send_cmd(E_SDDS_Command cmd, UINT32 p0, UINT32 p1, BOOL bWait)
{
	DHL_RESULT dhr;
	UINT32 params[4];
	
	params[0] = p0; params[1] = p1;

	dhr = DHL_TIMER_StartEx(
			g_sdds_task, cmd, 0, /* zero period ==> dpc */
			_sdds_task_proxy_cmd, 2, params, eTIMER_FLAG_OneShot);

	if (bWait)
		DHL_TIMER_Sync(g_sdds_task);

	return dhr ? statusError : statusOK;
}

STATUS sdds_task_send_event(E_SDDS_Command evt, UINT32 p0, UINT32 p1)
{
	DHL_RESULT dhr;
	UINT32 params[4];

	params[0] = p0; params[1] = p1;

	dhr = DHL_TIMER_StartEx(
			g_sdds_task, evt, 0, /* zero period ==> dpc */
			_sdds_task_proxy_event, 2, params, eTIMER_FLAG_OneShot);
	return dhr ? statusError : statusOK;
}

void sdds_task_init(void)
{
	DHL_RESULT dhr;
	DHL_TIMER_INIT_PARAM param;

	//dhl_timer_module_init(); // DHL_SYS_Timer 는 미리 초기화 되었다고 가정.

	if (g_sdds_task)
		return;  // dhl timer already initialized.
	
	memset(&param, 0, sizeof(DHL_TIMER_INIT_PARAM));

	param.max_timer_entry = 2; // 현재는 모두 dpc 로만 사용하므로, 많이 필요 없음.
	param.name = "sdds";
	param.task_priority = DMW_SDDS_TASK_PRIO;
	param.stack_size = DMW_SDDS_TASK_STACK;
	param.use_mutex_lock = 0; // we should support ISR!!
	param.num_user_param = 2;
	param.msg_que_size = 32;
	
	dhr = DHL_TIMER_Initialize(&param, &g_sdds_task);
	DHL_ASSERT(dhr == DHL_OK, "");

	dprint(2, "sdds task init..\n");

}



#if COMMENT
____Debug____(){}
#endif




#if COMMENT
____Symbol____(){}
#endif


#if DHL_REGISTER_DEUBG_SYMBOLS

static DHL_SymbolTable _symbols[] =
{
	/* however, if you want typing short-cut, it is good usage.
	DHL_FNC_SYM_ENTRY2("epg_start", App_EpgUpdateStart),
	DHL_FNC_SYM_ENTRY2("epg_stop", App_EpgUpdateCancel),
	DHL_FNC_SYM_ENTRY2("epg_list", Dmc_EpgPrintAllTables),
	DHL_FNC_SYM_ENTRY2("epg_delete", App_EpgDeleteAll),

	DHL_VAR_SYM_ENTRY(g_XX_TestMode),
	*/
	0,
};

#endif	/* DHL_REGISTER_DEUBG_SYMBOLS */



#if COMMENT
____Init____(){}
#endif


void DMW_SDDS_Init(void)
{
	//STATUS status;
	
#if DHL_REGISTER_DEUBG_SYMBOLS
	DHL_DBG_RegisterSymbols(_symbols, DHL_NUMSYMBOLS(_symbols));
#endif

	/* 각종 init code.. */

	sdds_task_init();

	// bwait 모드 사용시 주의. user action command (flashing) 작업은 오래 걸릴 수 있으므로..
	// sdds init 은 처음 init task 에서 1회만 불리므로 괜찮음.
	sdds_task_send_cmd(eSDDS_Cmd_Init, 0, 0, TRUE);
		// jump to SDDS_HandleCmdInit
}

void DMW_SDDS_RegisterCallback(F_SDDS_CALLBACK cb)
{
	s_sdds_user_cb = cb;
}

void DMW_SDDS_Start(int pid)
{
	sdds_task_send_cmd(eSDDS_Cmd_Start, (UINT32)DHL_DMX_GetTsd(), pid, FALSE);
		// jump to SDDS_HandleCmdStart
}

void DMW_SDDS_Stop(void)
{
	sdds_task_send_cmd(eSDDS_Cmd_Stop, 0, 0, FALSE);
		// jump to SDDS_HandleCmdStop
}

void DMW_SDDS_Reset(void)
{
	sdds_task_send_cmd(eSDDS_Cmd_Delete, 0, 0, FALSE);
		// jump to SDDS_HandleCmdDelete
}

void DMW_SDDS_PrintStatus(int level)
{
	sdds_task_send_cmd(eSDDS_Cmd_PrintStatus, level, 0, FALSE);
		// jump to SDDS_HandleCmdPrintStatus
}

void DMW_SDDS_UserAction(UINT32 userparam)
{
	sdds_task_send_cmd(eSDDS_Cmd_UserAction, 0, 0, FALSE);
}


#if COMMENT
____Test____(){}
#endif

#if DMW_SDDS_TEST

/*
	test procedure

	m2_init
	m2_chtype 0
	m2_scan 18 18
		// 또는 KBS-2 live.. sdds 서비스가 포함되어 있어야 함.
	//m2_tune 7
	sml $sds 4
	
	DMW_SDDS_Init
	DWM_SDDS_Start 0x1200
		// vct/pmt 에서 pid는 찾아야 하는데, 
		// 국내 KBS sdds는 지금 0x1200 으로 고정 된 듯 함..
		// 나중에 바뀔 수 있음.
*/

void sdt_callback(E_SDDS_CB_TYPE cbtype, void *param)
{
	dprint(0, "------- callback, type %d, param %x\n", cbtype, param);

	if (0);
#if 0
	else if (cbtype == eSDDS_CB_TYPE_GetOUI) {
		S_SDDS_CBPARAM_GET_OUI *cbp = (S_SDDS_CBPARAM_GET_OUI *)param;
		cbp->oui = IEEE_OUI_DST;
		//cbp->oui = 0x80000000; // special marker.. meaning accept anyone.
		/*  주의 !!!!!!!!
			이 스페셜 마커는 개발용으로만 사용되어야 함!!!!
			OUI는 24비트 이므로, 위 값은 실제로는 사용되지 않는 범위임.
		*/
		cbp->model = 0x01; // NEWBY
		cbp->version = 0xFFFF; // any version.
	}
#else
	else if (cbtype == eSDDS_CB_TYPE_CheckCompatDesc) {
		S_SDDS_CBPARAM_CHECK_DESC *cbp = (S_SDDS_CBPARAM_CHECK_DESC *)param;
		int i;
		for (i=0; i<cbp->desc->descriptorCount; i++) {
			sddsCompatDescEntry_t *desc = &cbp->desc->desc[i];
			if (desc->descriptorType != eSystemHardwareDescriptor &&
				desc->descriptorType != eSystemSoftwareDescriptor)
				continue;
			if (desc->specifierType != compatSpecifierType_IEEE_OUI)
				continue;
			if (desc->specifierData != IEEE_OUI_DST)
				continue;
			if (desc->model != 0x01) // NEWBY
				continue;
			// DST 규격, NEWBY 규정에서는 version은 미사용.
			
			// desc->subDescriptorCount 에는 urgency mode 가 들어 있을텐데,
			// 일단 사용하지 않는다.
			cbp->isOk = TRUE;
			break;
		}
	}
#endif

	else if (cbtype == eSDDS_CB_TYPE_NotifySchedules) {
		int i;
		sddsScheduleDesc_t *sch = (sddsScheduleDesc_t *)param;
		for (i=0; sch && sch->schedules && i<sch->numSchedules; i++) {
			dprint(2, "  sched[%d] %x, %d seconds\n", 
				sch->schedules[i].startTime,
				sch->schedules[i].lengthInSeconds);
		}
	}

	else if (cbtype == eSDDS_CB_TYPE_CheckModuleInfo) {
		S_SDDS_CBPARAM_CHECK_FILE *cbp = (S_SDDS_CBPARAM_CHECK_FILE *)param;

		dprint(2, "  [%d] check file: mid %u, '%s'", cbp->id, cbp->name);
		cbp->isOk = TRUE;
	}

	else if (cbtype == eSDDS_CB_TYPE_BlockReceived) {
		S_SDDS_CBPARAM_BLOCK_RECEIVED *cbp = (S_SDDS_CBPARAM_BLOCK_RECEIVED *)param;
		dprint(2, "  %u/%u blocks received\n", cbp->received_blocks, cbp->total_blocks);
	}

}

void sdt_init(void)
{
	void m2_init(void);
	void m2_chtype(int);
	void m2_scan(int,int);
	
	DHL_DBG_SetModuleLevel("$sds", 4);
	m2_init();
	m2_chtype(0);
	m2_scan(18, 18); // 또는 KBS-2 live.. sdds 서비스가 포함되어 있어야 함.

	DMW_SDDS_Init();
	DMW_SDDS_RegisterCallback(sdt_callback);
}

void sdt_start(UINT16 pid)
{
	DMW_SDDS_Start(pid); 
}

#endif // DMW_SDDS_TEST


/* end of file */