/*
	DMW_PsiEngine.c

	DST TV MW PSI Scan Module

	PSI Scan Core Engine implementation

	Copyright 2006~2009 Digital STREAM Technology, Inc.
	All Rights Reserved

*/

#include "DMW_Platform.h"

// dlib headers
#include "DLIB_PSI_Parser.h"
#include "DLIB_PSIP_Parser.h"
#include "DLIB_PSI_Monitor.h"
#include "DLIB_PSIP_Monitor.h"


#include "DMW_PsiConfig.h"
#include "DMW_PsiEngine.h"
#include "DMW_PsiDatabase.h"
#include "DMW_PsiUtil.h"


DHL_MODULE("psieng", 1);



#if COMMENT
____Configs____(){}
#endif


int gPsiIgnoreEtmLocationInfo = 0;
	// ETM location 정보가 제대로 되어 있는지 테스트 하기 위하 사용하는 값..
	// 있는데 없다고 속이는 건 아닌지 테스트..
	// 일반적인 상황에서는 사/용/금/지/!!!
	//
	// cafrii 060112
	// 일부 customer의 요구에 의해 이 옵션을 사용할 수 있도록 함.
	// 이름에서 "Test" 삭제
	//
	// cafrii 060320 add comment
	// UpdateEtt 함수 안에서는 이 변수를 참고하여 무조건 ett monitor 시도하게 된다.
	// 그러나 ett의 수신여부를 체크하는 함수에서는 이 변수를 고려하지 않으므로 
	// 못받았음에도 불구하고 ett complete로 간주되어버린다. 따라서 retry를 하지 않는다.
	// 즉 first try에 download 성공하지 않으면 그 후에는 retry조차 안되고 계속 안받음.
	// epg_print에서는 그냥 none으로 표시됨.
	//
	// 만약 ett 수신여부 체크하는 함수에까지 적용하게 되면,
	// etm_none이 하나라도 존재하는 스트림에서는 영원이 complete가 안될 수 있으므로 위험.
	// 그래서 그냥 위의 단점에도 불구하고 일부만 적용하도록 한다.



#if COMMENT
____Types____(){}
#endif


#undef IsError
#undef ErrorString

#define IsError(e) ((e)!=0)
#define ErrorString(e) p_dhr2str(e)

/* psi engine task에서만 사용한다는 전제로 static 버퍼 사용하도록 하자.
*/
static const char *p_dhr2str(DHL_RESULT dhr) 
{
	static char buf[10];
	sprintf(buf, "0x%x", dhr);
	return buf;
}



#if COMMENT
____EngineModule____(){}
#endif

// this is singleton object. should be unique.

S_PSIM_CONTEXT *g_psi_engine;


#if COMMENT
____DbgPrint____(){}
#endif


int g_Trace_bPsiEvent = 1;
int g_Trace_bPsiSttInfo = 1;


#if COMMENT
____Declare____(){}
#endif



// forward declaration
// this is the only psi table event proc.
PSI_STATIC void _PsiTableEventProc(tDHL_PSI_Event psiEvent, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam);





#if COMMENT
____Private____(){}
#endif


PSI_STATIC void SendUserCallback(S_PSIM_PORT *tsport, E_PSIM_EVENT event, UINT32 param)
{
	S_PSIM_USER_INPUT *input = (S_PSIM_USER_INPUT *) &tsport->input;

	if (input->userproc)
		(*(input->userproc))(tsport->tsd, event, param);
}

#if 0
PSI_STATIC void SendEventChannelStarted(S_PSIM_PORT *tsport, int id)
{
	S_PSIM_CH_START_CB_PARAM ccb;
	S_PSIM_CHINFO *chInfo;

	return; //test..

	chInfo = PSIDB_GetPsiChInfo(id);
	
	if (1) //if (chInfo->channel_start_notified == 0) 
	{
		memset(&ccb, 0, sizeof(ccb));
		
		ccb.id = chInfo->id;
		ccb.tsd = chInfo->tsd;
		ccb.mgt = chInfo->mgt;
		ccb.vct = chInfo->vct;
		ccb.n_subchannel = chInfo->n_subchannel;

		SendUserCallback(tsport, ePSIM_EVENT_BasePsipReceived, 0);
		SendUserCallback(tsport, ePSIM_EVENT_ChannelStarted, (UINT32) &ccb);
		//chInfo->channel_start_notified = 1;
	}
}

PSI_STATIC void SendEventSubchannelStarted(S_PSIM_PORT *tsport, int id, int source_id)
{
	S_PSIM_SUBCH_START_CB_PARAM sccb;
	S_PSIM_SUBCHINFO *subchInfo;

	subchInfo = PSIDB_GetPsiSubChInfo(id, source_id);
	
	if (subchInfo->subchannel_start_notified == 0) {
		memset(&sccb, 0, sizeof(sccb));
		
		sccb.index = subchInfo->index;
		sccb.source_id = subchInfo->source_id;
		sccb.flags = tsport->input.flags;

	#if 0 // 정확하게 같지 않은 경우 buffer overflow 등의 문제 발생..
		//memcpy(&sccb.vct_info, &subchInfo->vct_info, sizeof(sccb.vct_info));
	#else
		memcpy(sccb.vct_info.short_name, subchInfo->vct_info.short_name, sizeof(sccb.vct_info.short_name));
		sccb.vct_info.major_channel_number = subchInfo->vct_info.major_channel_number;
		sccb.vct_info.minor_channel_number = subchInfo->vct_info.minor_channel_number;
		sccb.vct_info.program_number = subchInfo->vct_info.program_number;
	#endif
		
		SendUserCallback(tsport, ePSIM_EVENT_SubChannelStarted, (UINT32) &sccb);
		subchInfo->subchannel_start_notified = 1;
	}
}

PSI_STATIC void SendEventEitsCompleted(S_PSIM_PORT *tsport, S_PSIM_SUBCHINFO *subchInfo)
{
	S_PSIM_COMPLETE_CB_PARAM cmcb;

	if (subchInfo->eit_complete_notified == 0) {
		cmcb.id = subchInfo->parent->id;
		cmcb.index = subchInfo->index;
		cmcb.source_id = subchInfo->source_id;
		
		SendUserCallback(tsport, ePSIM_EVENT_EitsCompleted, (UINT32) &cmcb);
		subchInfo->eit_complete_notified = 1;
	}
}

PSI_STATIC void SendEventSubchannelCompleted(S_PSIM_PORT *tsport, S_PSIM_SUBCHINFO *subchInfo)
{
	S_PSIM_COMPLETE_CB_PARAM cmcb;

	if (subchInfo->subchannel_complete_notified == 0) {
		cmcb.id = subchInfo->parent->id;
		cmcb.index = subchInfo->index;
		cmcb.source_id = subchInfo->source_id;
		
		SendUserCallback(tsport, ePSIM_EVENT_SubChannelCompleted, (UINT32) &cmcb);
		subchInfo->subchannel_complete_notified = 1;
	}
}

PSI_STATIC void SendEventChannelCompleted(S_PSIM_PORT *tsport, S_PSIM_CHINFO *chInfo)
{
	S_PSIM_COMPLETE_CB_PARAM cmcb;
	
	if (chInfo->channel_complete_notified == 0) {
		cmcb.id = chInfo->id;
		cmcb.index = 0;
		cmcb.source_id = 0;
		
		SendUserCallback(tsport, ePSIM_EVENT_ChannelCompleted, (UINT32) &cmcb);
		chInfo->channel_complete_notified = 1;
	}
}

#endif


#if COMMENT
____Start_Stop____(){}
#endif


void StopMonitorPAT(S_PSIM_PORT *tsport)
{
	if (tsport->patPsiCtl) {
		dprint(3, "cancel prev pat monitor\n");
		DHL_PSI_StopMonitor(tsport->patPsiCtl);
		tsport->patPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}

void StopMonitorPMTs(S_PSIM_PORT *tsport)
{
	int i;
	if (tsport->num_programs) {
		dprint(3, "cancel all %d pmt ctls..\n", tsport->num_programs);
		for (i=0; i<tsport->num_programs; i++) {
			if (tsport->pmtPsiCtlArray[i]) {
				DHL_PSI_StopMonitor(tsport->pmtPsiCtlArray[i]);
				tsport->pmtPsiCtlArray[i] = (tDHL_PSI_ControlHandle)0;
				tsport->n_active_monitors--;
			}
		}
	}
	if (tsport->pmtPsiCtlArray)
		DHL_OS_Free((void **)&tsport->pmtPsiCtlArray);
	tsport->num_programs = 0;
}

void StopMonitorMgt(S_PSIM_PORT *tsport)
{
	if (tsport->mgtPsiCtl) {
		dprint(3, "cancel prev mgt monitor\n");
		DHL_PSI_StopMonitor(tsport->mgtPsiCtl);
		tsport->mgtPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}
void StopMonitorTvct(S_PSIM_PORT *tsport)
{
	if (tsport->tvctPsiCtl) {
		dprint(3, "cancel prev tvct monitor\n");
		DHL_PSI_StopMonitor(tsport->tvctPsiCtl);
		tsport->tvctPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}
void StopMonitorCvct(S_PSIM_PORT *tsport)
{
	if (tsport->cvctPsiCtl) {
		dprint(3, "cancel prev cvct monitor\n");
		DHL_PSI_StopMonitor(tsport->cvctPsiCtl);
		tsport->cvctPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}

void StopMonitorStt(S_PSIM_PORT *tsport)
{
	if (tsport->sttPsiCtl) {
		dprint(3, "cancel prev stt monitor\n");
		DHL_PSI_StopMonitor(tsport->sttPsiCtl);
		tsport->sttPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}

void StopMonitorRrt(S_PSIM_PORT *tsport)
{
	if (tsport->rrtPsiCtl) {
		dprint(3, "cancel prev rrt monitor\n");
		DHL_PSI_StopMonitor(tsport->rrtPsiCtl);
		tsport->rrtPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}

void StopMonitorEit(S_PSIM_PORT *tsport, int iEit)
{
	if (iEit < 0 || iEit >= 128) return;
	
	if (tsport->eitPsiCtl[iEit]) {
		dprint(3, "cancel prev eit[%d] monitor\n", iEit);
		DHL_PSI_StopMonitor(tsport->eitPsiCtl[iEit]);
		tsport->eitPsiCtl[iEit] = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
}

void StopMonitorEtt(S_PSIM_PORT *tsport, int iEit)
{
	if (iEit < 0 || iEit > 128) return;

	if (iEit == 128) {
		if (tsport->ettvPsiCtl) {
			dprint(3, "cancel prev ett-v monitor\n");
			DHL_PSI_StopMonitor(tsport->ettvPsiCtl);
			tsport->ettvPsiCtl = (tDHL_PSI_ControlHandle)0;
			tsport->n_active_monitors--;
		}
	}
	else {
		if (tsport->ettPsiCtl[iEit]) {
			dprint(3, "cancel prev ett[%d] monitor\n", iEit);
			DHL_PSI_StopMonitor(tsport->ettPsiCtl[iEit]);
			tsport->ettPsiCtl[iEit] = (tDHL_PSI_ControlHandle)0;
			tsport->n_active_monitors--;
		}
	}
}

void StopMonitorAllEtts(S_PSIM_PORT *tsport)
{
	int iEit;
	if (tsport->ettvPsiCtl) {
		dprint(3, "cancel prev ett-v monitor\n");
		DHL_PSI_StopMonitor(tsport->ettvPsiCtl);
		tsport->ettvPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	for (iEit=0; iEit<128; iEit++) {
		if (tsport->ettPsiCtl[iEit]) {
			dprint(3, "cancel prev ett[%d] monitor\n", iEit);
			DHL_PSI_StopMonitor(tsport->ettPsiCtl[iEit]);
			tsport->ettPsiCtl[iEit] = (tDHL_PSI_ControlHandle)0;
			tsport->n_active_monitors--;
		}
	}
}


/*
	PAT monitor 시작.
*/
STATUS StartMonitorPAT(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	
	if (tsport->patPsiCtl)
		StopMonitorPAT(tsport);
	
	dprint(3, "monitor pat..\n");
	err = MonitorPAT(
			tsport->tsd, // tDHL_TSD *tsd,
			TRUE, // BOOLEAN current_next_indicator, // get current pat only
			FALSE, // BOOLEAN eager, // get complete table
			ePSIUPDATE_VERCHANGE, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->patPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor pat err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}

	return status;
}


/*
	PMT 모니터를 시작한다.
	
	pat를 받아서 새로 pmt 모니터 시작하는 경우:
		사용자 모드에 따라서 전체, 일부 pmt 시작.
			autoscan 모드: 전체 pmt들을 oneshot으로.
			일반 모드: 지정한 하나의 pmt만 연속으로..

	pmt 모니터를 resource 부족으로 다 시작하지 못했는데 다른 table이 종료된 경우
		아직 시작하지 않은 pmt만 시작.

*/
STATUS StartMonitorPMTs(S_PSIM_PORT *tsport, int preferred_program_number)
{
	int i;
	int pmt_pid, program_number;
	MPEG_PAT *pat;
	MPEG_PMT **pmts;
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode;
	BOOL bScanMode = (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) ? TRUE : FALSE;

	if (bScanMode) {
		// for autoscan mode, we need pmts of all program.
		// but only one copy of pmt is enough.
		preferred_program_number = -1;
		updateMode = ePSIUPDATE_ONESHOT;
		dprint(2, "%s: autoscan mode\n", __FUNCTION__);	
	}
	else {
		// for normal mode, only one program pmt needs to be monitored.
		updateMode = ePSIUPDATE_VERCHANGE;
		dprint(2, "%s: program_number %d\n", __FUNCTION__, preferred_program_number);	
	}

	pat = PSIDB_GetPAT(tsport->input.rf);
	pmts = PSIDB_GetPMTs(tsport->input.rf);
	
	if (pat == NULL || pmts == NULL) {
		dprint(0, "!! %s: pat %x or pmts %x not ready\n", __FUNCTION__, pat, pmts);
		return statusInvalidState;
	}
	
	// PSI db와 ts port 정보가 서로 일치하지 않을 수 잇으므로 체크.
	//
	if (pat->numPrograms != tsport->num_programs) 
	{
		// pmt monitors 정보가 불일치. 먼저 reset..

		// 맨 처음에 pat가 수신되는 경우에는 당연히 tsport num_program은 0일테니,
		// 그런 경우는 디버그 메시지 제외..
		if (tsport->num_programs) {
			dprint(0, "!! pat and pmt monitor inconsistent. pat %d, tsport %d, reset pmt monitors first..\n",
					pat->numPrograms, tsport->num_programs);
		}

		// 동작 중인 pmt monitor를 모두 정지.
		StopMonitorPMTs(tsport);

		tsport->pmtPsiCtlArray = DHL_OS_Malloc(pat->numPrograms * sizeof(tDHL_PSI_ControlHandle));
		if (!tsport->pmtPsiCtlArray) {
			tsport->num_programs = 0; // <- 반드시 필요.
			status = statusOutOfMemory;
			goto label_end;
		}
		tsport->num_programs = pat->numPrograms;
	}

	// PMT의 경우는 특별하게 monitor 최대 갯수에 주의해야 함.
	if (tsport->n_active_monitors >= tsport->max_monitors) {
		dprint(1, "!! cur monitor %d exceed limit %d\n", tsport->n_active_monitors, tsport->max_monitors);
		status = statusOutOfResource;
		goto label_end;
	}

	for (i=0; i<pat->numPrograms; i++)
	{
		program_number = pat->programs[i].program_number;
		if (preferred_program_number >= 0) { // 특정 program number 만 수신하는 모드..
			if (program_number != preferred_program_number)
				continue;
		}
		pmt_pid = pat->programs[i].program_map_PID;

		// normal mode 인 경우라면 이미 pmt가 있더라도 monitor 가동을 해야 한다.
		if (bScanMode && pmts[i]) // this pmt already exist.
			continue;
		
		if (tsport->pmtPsiCtlArray[i]) // this pmt is already started.
			continue;
		
		dprint(3, "new pmt monitor (pid %x, #%d), total monitors %d\n", 
			pmt_pid, program_number, tsport->n_active_monitors);
		
		err = MonitorPMT(
				tsport->tsd, // tDHL_TSD tsd,
				pmt_pid,
				program_number,
				TRUE, // BOOLEAN current_next_indicator, // get current pat only
				updateMode, // tDHL_PSI_Update updateMode, 
				_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
				(UINT32)tsport, // UINT32 userParam, 
				&tsport->pmtPsiCtlArray[i] //  tDHL_PSI_ControlHandle *returnPSICtl
				);
		
		if (err) {
			dprint(0, "!! %s: monitor pmt err %d\n", __FUNCTION__, err);
		}
		else {
			tsport->n_active_monitors++;
		}

		if (preferred_program_number > 0) { // one program monitor..
			break;
		}

		// PMT의 경우는 특별하게 monitor 최대 갯수에 주의해야 함.
		if (tsport->n_active_monitors >= tsport->max_monitors) {
			dprint(1, "!!!! total monitor reached limit %d\n", tsport->n_active_monitors);
			status = statusOK;
			goto label_end;
		}
	}
	
label_end:
	return status;
	
}

STATUS StartMonitorMgt(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode = ePSIUPDATE_VERCHANGE;
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN)
		updateMode = ePSIUPDATE_ONESHOT; // only one instance is enough.
	
	if (tsport->mgtPsiCtl)
		StopMonitorMgt(tsport);
	
	dprint(3, "monitor mgt..\n");
	err = MonitorMgt(
			tsport->tsd, // tDHL_TSD *tsd,
			updateMode, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->mgtPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor mgt err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}
	return status;
}

STATUS StartMonitorTvct(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode = ePSIUPDATE_VERCHANGE;
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN)
		updateMode = ePSIUPDATE_ONESHOT; // only one instance is enough.

	if (tsport->tvctPsiCtl)
		StopMonitorTvct(tsport);
	
	dprint(3, "monitor tvct..\n");
	err = MonitorTvct(
			tsport->tsd, // tDHL_TSD *tsd,
			ePSIMODE_TABLE, // tDHL_PSI_Mode psiMode,
			updateMode, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->tvctPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor tvct err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}
	return status;
}

STATUS StartMonitorCvct(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode = ePSIUPDATE_VERCHANGE;
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN)
		updateMode = ePSIUPDATE_ONESHOT; // only one instance is enough.

	if (tsport->cvctPsiCtl)
		StopMonitorCvct(tsport);

	dprint(3, "monitor cvct..\n");
	err = MonitorCvct(
			tsport->tsd, // tDHL_TSD *tsd,
			ePSIMODE_TABLE, // tDHL_PSI_Mode psiMode,
			updateMode, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->cvctPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor cvct err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}
	return status;
}

STATUS StartMonitorStt(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode = ePSIUPDATE_CONTINEOUS;
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN)
		updateMode = ePSIUPDATE_ONESHOT; // only one instance is enough.

	if (tsport->sttPsiCtl)
		StopMonitorStt(tsport);

	dprint(3, "monitor stt..\n");
	err = MonitorStt(
			tsport->tsd, // tDHL_TSD *tsd,
			updateMode, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->sttPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor stt err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}
	return status;
}

STATUS StartMonitorRrt(S_PSIM_PORT *tsport)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode = ePSIUPDATE_CONTINEOUS;
	
	if (tsport->rrtPsiCtl)
		StopMonitorRrt(tsport);

	dprint(3, "monitor rrt..\n");
	err = MonitorRrt(
			tsport->tsd, // tDHL_TSD *tsd,
			0, // UINT8 region, // it is not used
			updateMode, // tDHL_PSI_Update updateMode, 
			_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
			(UINT32)tsport, // UINT32 userParam, 
			&tsport->rrtPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
			);

	if (err) {
		dprint(0, "!! monitor rrt err %d\n", err);
		status = statusError;
	}
	else {
		tsport->n_active_monitors++;
	}
	return status;
}


/*
	eit monitor를 시작한다.

*/
STATUS StartMonitorEits(S_PSIM_PORT *tsport)
{
	int iEit, source_id;
	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode;
	int maxIndex;

	S_PSIM_SUBCHINFO *subchInfo = NULL;
	S_PSIM_MGT_DIGEST *smgt;

	if (tsport->n_active_monitors >= tsport->max_monitors) {
		dprint(0, "!! cur monitor %d exceed limit %d\n", tsport->n_active_monitors, tsport->max_monitors);
		return statusOutOfResource;
	}

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		subchInfo = NULL;  // 특정 subch 에 대해 동작하는 것이 아니다.
	}
	else {
		subchInfo = PSIDB_GetPsiSubChInfo(tsport->input.rf, tsport->source_id);
		if (!subchInfo) {
			dprint(0, "!! rf %d, sid %d not ready for eit scan..\n", tsport->input.rf, tsport->source_id);
			return statusInvalidState;
		}
	}
	
	smgt = PSIDB_GetMgtDigest(tsport->input.rf);
	if (!smgt) {
		dprint(0, "!! rf %d has no smgt\n", tsport->input.rf);
		return statusInvalidState;
	}
	
	// 어떤 subchannel eit를 시작할 것인지, 어떤 update mode로 진행할 것인지 결정한다.
	
	// filter-eit 가 1:1 이라면 oneShot이 적당하고, 
	// 하나의 filter로 다수의 eit를 받을려고 한다면 Continueous로 진행.
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		updateMode = ePSIUPDATE_CONTINEOUS;
		source_id = 0;  // this means that all source_id table should be received..
		maxIndex = 0;    // eit-0 만 받는다.
		dprint(2, "start eit with autoscan mode..\n");
	}
	else {
		// todo.. 기존 코드는 version change. 뭐가 나은가??
		updateMode = ePSIUPDATE_ONESHOT;
		//updateMode = ePSIUPDATE_VERCHANGE;
		source_id = tsport->source_id;		
		maxIndex = min(127, gPsiMaxEitEttIndexToReceive);
		dprint(2, "start eits, normal mode, sid %d, [0~%d]\n", source_id, maxIndex);
	}

	//-------------------------------------
	// start/restart eit scan
	
	for (iEit=0; iEit<=maxIndex; iEit++)
	{
		if (tsport->eitPsiCtl[iEit]) continue; // it is already started.

		// normal mode 에서는 이미 해당 eit가 수신되었는지도 체크할 수 있다.
		if (subchInfo && subchInfo->eits[iEit]) continue;

		if (smgt->eit_pids[iEit] == 0) // eit[i] does not exist.
			continue;

		dprint(3, "monitor eit[%d] (pid %x, source_id %d), cur monitor %d\n", 
				iEit, smgt->eit_pids[iEit], source_id, tsport->n_active_monitors);
		
		err = MonitorEit(
				tsport->tsd, // tDHL_TSD tsd,
				smgt->eit_pids[iEit], // UINT16 PID, 
				source_id, // UINT16 source_id, 
				ePSIMODE_TABLE, // tDHL_PSI_Mode psiMode,
				updateMode, // tDHL_PSI_Update updateMode, 
				_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
				(UINT32)tsport, // UINT32 userParam, 
				&tsport->eitPsiCtl[iEit] //  tDHL_PSI_ControlHandle *returnPSICtl
				);

		if (err) {
			dprint(0, "!! monitor eit[%d] err %d\n", iEit, err);
			status = statusError;
			goto label_end;
		}
		else {
			tsport->n_active_monitors++;
		}	

		if (tsport->n_active_monitors >= tsport->max_monitors) {
			dprint(2, "!!!! total monitor reached limit %d\n", tsport->n_active_monitors);
			status = statusOK;
			goto label_end;
		}			

	}

label_end:
	return status;

}



/*
	ett 모니터를 시작한다.

	tsport->source_id 에서 지정된 서브채널의 ett만을 scan한다.
	subch ptr, smgt 등은 이미 준비 되어 있어야 한다.

	autoscan 모드인 경우에는 사용되지 않는다.

	channel-ett 를 먼저 monitor 하고, 그 다음 일반 ett monitor 한다.
	이미 받아져 있는 경우, 이미 start 된 경우 등은 skip 하므로,
	ett completed 아닌 경우라면 언제든지 여러번 호출해도 상관 없다.
*/
STATUS StartMonitorEtts(S_PSIM_PORT *tsport)
{
	int k, t, iEtt, iEvent; // loop variables
	int n_etm;
	UINT32 etmid;

	DHL_RESULT err;
	STATUS status = statusOK;
	tDHL_PSI_Update updateMode;
	int maxIndex;

	S_PSIM_SUBCHINFO *subchInfo;
	S_PSIM_MGT_DIGEST *smgt;

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		dprint(0, "!! ett tried in autoscan mode\n");
		return statusOK;
	}

	if (tsport->n_active_monitors >= tsport->max_monitors) {
		dprint(0, "!! cur monitor %d exceed limit %d\n", tsport->n_active_monitors, tsport->max_monitors);
		return statusOutOfResource;
	}

	subchInfo = PSIDB_GetPsiSubChInfo(tsport->input.rf, tsport->source_id);
	if (!subchInfo) {
		dprint(0, "!! rf %d, sid %d not ready for ett scan..\n", tsport->input.rf, tsport->source_id);
		return statusInvalidState;
	}

	smgt = PSIDB_GetMgtDigest(tsport->input.rf);
	if (!smgt) {
		dprint(0, "!! rf %d has no smgt\n", tsport->input.rf);
		return statusInvalidState;
	}
	
	// 어떤 subchannel eit를 시작할 것인지, 어떤 update mode로 진행할 것인지 결정한다.

	updateMode = ePSIUPDATE_CONTINEOUS;
	maxIndex = min(127, gPsiMaxEitEttIndexToReceive);
	dprint(2, "start ett monitoring, sid %d, [0~%d]\n", tsport->source_id, maxIndex);

	//-------------------------------------
	// start/restart ett scan

	// ****** channel-ett **********
	do 
	{
		if (tsport->ettvPsiCtl) continue;  // already started.

		if (subchInfo->channel_ett) continue; // already received.

		if (!PSIDB_IsSubChEttVRequired(tsport->input.rf, tsport->source_id)) continue; // no ettv exist

		dprint(3, "monitor ett-v (pid %x, source_id %d), cur monitor %d\n", 
				smgt->channel_ett_pid, tsport->source_id, tsport->n_active_monitors);

		etmid = PSIUTIL_MakeChannelETMID(subchInfo->source_id) | 0xffff;
		etmid = 0; // we use all pass mode. just ett_pid is the only key.
		err = MonitorEtt(
				tsport->tsd, // tDHL_TSD *tsd,
				smgt->channel_ett_pid, // UINT16 PID, 
				etmid, // UINT32  etm_id, 
				updateMode, // tDHL_PSI_Update updateMode, 
				_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
				(UINT32)tsport, // UINT32 userParam, 
				&tsport->ettvPsiCtl //  tDHL_PSI_ControlHandle *returnPSICtl
				);

		if (err) {
			dprint(0, "!! monitor ett-v err %d\n", err);
			status = statusError;
			goto label_end;
		}
		else {
			tsport->n_active_monitors++;
		}	

		if (tsport->n_active_monitors >= tsport->max_monitors) {
			dprint(2, "!!!! total monitor reached limit %d\n", tsport->n_active_monitors);
			status = statusOK;
			goto label_end;
		}			
	} while (0);
	
	// ****** normal etts **********
	for (iEtt=0; iEtt<=maxIndex; iEtt++)
	{
		if (tsport->ettPsiCtl[iEtt])
			continue;  // already started.

		// eit가 없다면 ett 수신은 불가능함..
		if (!subchInfo->eits[iEtt] || !subchInfo->eits[iEtt]->event)
			continue;  // eit is not received. ett monitor impossible.

		if (smgt->ett_pids[iEtt] == 0) // MGT에 이 ETT-i 정보가 없으면 건너뛴다.
			continue;

		// ------ 관련된 Eit 분석..
		// 이 EIT의 event들 중에서 몇개가 ETM을 가지고 있는지 셈한다.
		//
		for (iEvent=0, n_etm=0; iEvent<subchInfo->eits[iEtt]->numEvents; iEvent++) {
			if (gPsiIgnoreEtmLocationInfo ||                          // ignore 옵션이면 무조건 받는다.
				subchInfo->eits[iEtt]->event[iEvent].ETM_location != ETM_none)
				n_etm++;  // 이 EIT에 관련된 ETT 갯수..
		}
		if (n_etm == 0) {  // 이 EIT의 이벤트들에는 ETT가 하나도 없다고 한다. 다운로드 받을 필요가 없다.
			dprint(3, "        no etts of this eit / total %d events\n", subchInfo->eits[iEtt]->numEvents);
			continue;  // go to next EIT..
			// 다음 단계로 가기 전에 현재 ett들의 자격 검사도 해야 하지 않나????
		}
		else {
			dprint(3, "    %d etm's are expected in this eit / total %d events\n", 
					n_etm, subchInfo->eits[iEtt]->numEvents);
		}

		// 이 EIT에 총 n_etm(>0)개의 ETT가 걸려 있을 것으로 추정된다.. 

		// ------ Ett용 메모리 할당..
		// ett용 메모리가 없으면 새로 할당한다.. 포인터가 있더라도 크기가 변경되었는지 체크.

		// eit event 내에 ett를 저장하는 방법은 어떤가??

		
		if (subchInfo->n_ett[iEtt] != subchInfo->eits[iEtt]->numEvents) { // internal error!!
			dprint(0, "!! eit[%d] num event %d != n_ett %d\n", 
				iEtt, subchInfo->eits[iEtt]->numEvents, subchInfo->n_ett[iEtt]);
			PSIDB_FreeEtts(subchInfo, iEtt);			
		}
		
		if (subchInfo->etts[iEtt] == NULL)
		{
			int n_event = subchInfo->eits[iEtt]->numEvents;
			
			PSIDB_LockDB(TRUE); //---------------

			subchInfo->etts[iEtt] = DHL_OS_Malloc(n_event * sizeof(ettSectionPtr_t));
			if (subchInfo->etts[iEtt]) {
				dprint(3, "        ++ alloc etts memory %x (max %d)\n", 
						subchInfo->etts[iEtt], n_event);
				subchInfo->n_ett[iEtt] = n_event; // 이 Eit에 연결된 ETT-i 의 갯수..
			}
			else {
				dprint(0, "!! out of memory for %d ett ptr\n", n_event);
				subchInfo->n_ett[iEtt] = 0;
			}
			PSIDB_LockDB(FALSE); //----------------

			if (!subchInfo->etts[iEtt])
				break; // 메모리 부족? 더 이상 진행할 필요가 없다.
			
		}
		else
			dprint(3, "        ** reuse etts memory %x (max %d:%d)\n", subchInfo->etts[iEtt], 
						subchInfo->eits[iEtt]->numEvents, subchInfo->n_ett[iEtt]);

		for (iEvent=0; iEvent<subchInfo->eits[iEtt]->numEvents; iEvent++) // 이 EIT내의 모든 이벤트에 대해서 ETT를 수신한다..
		{
			BOOL bSkipThisEtt;
			
			// MGT에 ETM이 없다고 되어 있으면 받으면 안된다.
			if (gPsiIgnoreEtmLocationInfo == FALSE && 
				subchInfo->eits[iEtt]->event[iEvent].ETM_location == ETM_none) {
				//dprint(3, "    [%d] no ETM\n", iEvent);
				continue;
			}

			etmid = PSIUTIL_MakeEventETMID(subchInfo->source_id, subchInfo->eits[iEtt]->event[iEvent].event_id);

			// 이미 이 event에 해당하는 ETT를 받았다면 받을 필요가 없다..  ETM_id를 이용하여 그 여부를 확인한다.
			// 그런데 event[i] 에 해당하는 ett가 있는지 없는지 찾기가 좀 복잡하다..
			// 꼭 이 Eit PID에만 아니라 그 이전 Eit들의 PID에도 존재할 경우가 있기 때문..
			// 3-hour 경계에 걸쳐 있는 event의 경우 앞쪽 event의 PID에 ett가 있을 수 있다.
			//
			bSkipThisEtt = FALSE; 
			
			if (subchInfo->etts[iEtt] && 
				subchInfo->n_ett[iEtt] &&
				subchInfo->etts[iEtt][iEvent] &&
				subchInfo->etts[iEtt][iEvent]->ETM_id == etmid) {
				// 이 Ett가 이미 수신되어 있다면, 받을 필요 없다.
				dprint(3, "    [%d] already exist (etmid 0x%x pid %d)\n", iEvent, etmid, smgt->ett_pids[iEtt]);
				bSkipThisEtt = TRUE;
			}
			
			for (k=iEtt; !bSkipThisEtt && k>=0; k--) {  // 현재 Etts[iEtt]부터  Etts[0] 까지 앞으로 되돌아가면서,
				if (subchInfo->etts[k] == NULL) continue;
				// 각 Ett section을 검사해서 현재 받으려고 하는 etmid의 ett가 받아져 있는지 검사한다.
				for (t=0; t<subchInfo->n_ett[k]; t++) {
					if (subchInfo->etts[k][t] && subchInfo->etts[k][t]->ETM_id == etmid) {
						// 같은 etmid를 가진 Ett가 이미 수신되어 있다면, 받을 필요 없다.
						dprint(2, "    [%d] same etmid 0x%x (ett[%d][%d] pid %d) exist\n", 
										iEvent, etmid, k, t, smgt->ett_pids[k]);
						bSkipThisEtt = TRUE;
						break;
					}
				}
				if (bSkipThisEtt) break;
			}
			if (bSkipThisEtt) continue;
			
			dprint(3, "    [%d] ett pid 0x%x, etmid 0x%x\n", iEvent, smgt->ett_pids[iEtt], etmid);

		#if 0			
			// 개개의 ett를 수신하는 모드..
			// 단 이렇게 하려면 ettPsiCtl 저장 공간도 필요한 만큼 할당 받아야 한다.

			dprint(3, "monitor ett[%d] (pid %x, source_id %d, etmid 0x%x), cur monitor %d\n", 
					iEtt, smgt->ett_pids[iEtt], source_id, etmid, tsport->n_active_monitors);
		
			err = MonitorEtt(tsport->tsd, smgt->ett_pids[iEtt], etmid, updateMode, 
					_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
					(UINT32)tsport, // UINT32 userParam, 
					&tsport->ettPsiCtl[iEtt][iEvent] //  tDHL_PSI_ControlHandle *returnPSICtl
					);
		#endif

		}
		
		dprint(3, "monitor ett[%d] (pid %x, source_id %d), cur monitor %d\n", 
				iEtt, smgt->ett_pids[iEtt], tsport->source_id, tsport->n_active_monitors);

		etmid = PSIUTIL_MakeChannelETMID(subchInfo->source_id) | 0xffff;
		etmid = 0; // we use all pass mode. just ett_pid is the only key.
		err = MonitorEtt(
				tsport->tsd, // tDHL_TSD *tsd,
				smgt->ett_pids[iEtt], // UINT16 PID, 
				etmid, // UINT32  etm_id, 
				updateMode, // tDHL_PSI_Update updateMode, 
				_PsiTableEventProc, // tDHL_PSI_EventProc eventProc,
				(UINT32)tsport, // UINT32 userParam, 
				&tsport->ettPsiCtl[iEtt] //  tDHL_PSI_ControlHandle *returnPSICtl
				);
		
		if (err) {
			dprint(0, "!! monitor ett[%d] err %d\n", iEtt, err);
			status = statusError;
			goto label_end;
		}
		else {
			tsport->n_active_monitors++;
		}	

		if (tsport->n_active_monitors >= tsport->max_monitors) {
			dprint(2, "!!!! total monitor reached limit %d\n", tsport->n_active_monitors);
			status = statusOK;
			goto label_end;
		}			

	}

label_end:
	return status;

}




#if COMMENT
____Subchannel____(){}
#endif




/*
	SubChannel scan 시작.
	TV 시청 모드, 레코딩 모드, Autoscan 모드 다 해당됨.

	어떤 subchannel을 시작할 것인지는 동작 모드와 @tsport->source_id 에 따른다.
*/
STATUS StartSubChannelScan(S_PSIM_PORT *tsport)
{
	STATUS status = statusOK;
	int i;

	if (tsport->n_active_monitors >= tsport->max_monitors) {
		dprint(0, "!! cur monitor %d exceed limit %d\n", tsport->n_active_monitors, tsport->max_monitors);
		return statusOutOfResource;
	}

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) 
	{
		// autoscan 전용 eit complete check 함수가 없으니,
		// 직접 db search 하여 판단하도록 하자.

		S_PSIM_CHINFO *chInfo;
		BOOL bEitsCompleted = TRUE;
		
		chInfo = PSIDB_GetPsiChInfo(tsport->input.rf);
		if (!chInfo) {
			dprint(0, "!! rf %d not ready for subch scan..\n", tsport->input.rf);
			goto label_end;
		}
		// 모든 eit-0 가 다 수신 된 것인지 체크. 하나라도 빠져 있다면 restart..
		for (i=0; i<chInfo->n_subchannel; i++) {		
			if (chInfo->subchannel[i].eits[0] == NULL) {
				bEitsCompleted = FALSE;
				break;
			}
		}
		if (!bEitsCompleted)
			StartMonitorEits(tsport);
		else
			dprint(2, "ch %d eits already completed (autoscan mode)\n", tsport->input.rf);
	}
	else 
	{
		// 일단 eit -> ett 순서대로 진행하자.
		
		if (!PSIDB_IsSubChEitsCompleted(tsport->input.rf, tsport->source_id))
			StartMonitorEits(tsport);
			
		else if (!PSIDB_IsSubChAllEttsCompleted(tsport->input.rf, tsport->source_id))
			StartMonitorEtts(tsport);

		else
			dprint(2, "subch (rf %d, sid %d) already completed\n", tsport->input.rf, tsport->source_id);
	}

label_end:
	return status;
}



#if COMMENT
____EventMonitor____(){}
#endif


#define IS_VALID_SOURCE_ID(sid) ((sid)>=0 && (UINT32)(sid)<=0xFFFF)

#define EVENT_ID_INIT  -2   // last event id 값의 초기값.
#define EVENT_ID_EMPTY -1   // 현재 시간에 해당하는 event 가 없는 경우의 id.

#define IS_VALID_EVENT_ID(evid) ((evid)>=0)


//-----------------------------------
//  CheckIfProgramEventChanged
//
//  현재의 STT를 추정하고,
//  
//  이 채널의 저장되어진 마지막 descriptor 정보로부터
//  descriptor 내용이 변경된 사항이 있는지 검사한다.
//
//
PSI_STATIC void CheckIfProgramEventChanged(S_PSIM_PORT *tsport)
{
	int channel_id = tsport->input.rf;
	int source_id = tsport->input.source_id;

	S_PSIM_CHINFO *chInfo;
	S_PSIM_SUBCHINFO *subchInfo;

	int i;
	int iEit, iEvent;
	int stt_offset;

	UINT32 system_time;
	eitPtr_t eit;
	eitEventPtr_t event;

	if (!PSITASK_IsPsiTask()) {
		dprint(0, "!! %s: called in wrong task\n", __FUNCTION__);
		return;
	}

	// psi task에서 읽기 용도로만 사용할 경우 lock 은 필요 없다.
	
	//Dmc_EpgLockCoreDB(TRUE);

	chInfo = PSIDB_GetPsiChInfo(channel_id);
	
	if (chInfo == NULL) {
		dprint(0, "!! stt from non-exist channel %d\n", channel_id);
		goto label_exit;
	}
	
	if (chInfo->stt_valid == 0) {
		if (g_Trace_bPsiSttInfo)
			dprint(1, "[STT] stt not available yet\n");
		goto label_exit;
	}

	// 현재의 program event를 찾아내는데 사용될 기준 GPS 시간..
	//
	// STT를 수신한지 오래 된 경우라면 보정 값이 필요할 수도 있다.
	//
	stt_offset = (DHL_OS_GetMsCount() - chInfo->tick_stt_get) / 1000;
	system_time = chInfo->flat_stt.system_time + stt_offset;
	
	if (g_Trace_bPsiSttInfo)
	if (stt_offset)
		dprint(1, "[STT] stt offset %d applied\n", stt_offset);

	//----------------------
	// now, use stt data... search subch info
	
	subchInfo = NULL;
	// cafrii 070801 delete check, source_id 가 0인 스트림들이 있음.
	//if (source_id) 
	{
		if (g_Trace_bPsiSttInfo)
			dprint(3, "[STT] source id %d, n_subch %d, subch 0x%x\n", 
				source_id, chInfo->n_subchannel, chInfo->subchannel);
		
		for (i=0; i<chInfo->n_subchannel; i++) {
			if (chInfo->subchannel[i].source_id == source_id) {
				subchInfo = &chInfo->subchannel[i];
				break;
			}
		}
	}
	if (!subchInfo) {
		if (g_Trace_bPsiSttInfo)
			dprint(3, "[STT] !! subchInfo source_id %d not found..\n", source_id);
		goto label_exit;
	}
	
	// Spec 대로라면 반드시 Eit-0 에 있어야 할 것이지만, Local time으로 3-hour
	// boundary에 정확하게 Eit change가 발생하지 않는다면 약간의 오차가 있을 수도 있다.
	// 따라서 Eit-0 과 Eit-1 두개를 조사한다.
	// 
	for (iEit=0; iEit<=1; iEit++) 
	{
		eit = subchInfo->eits[iEit];
		if (eit == NULL) continue;

		if (eit->source_id != source_id) {
			dprint(0, "[STT] !! eit[%d] source id %d mismatch to subch source id %d\n", 
								iEit, eit->source_id, source_id);
			continue;
		}
		
		if (eit->event == NULL || eit->numEvents <= 0)
			continue;

		for (iEvent=0; iEvent<eit->numEvents; iEvent++) 
		{
			// eitEvent_t
			event = &eit->event[iEvent];
			
			// system_time 이 이 event의 구간 내에 들어 있는지 확인..
			//
			if (system_time < event->start_time || 
				system_time > event->start_time + event->length_in_seconds-1)
				continue;

			// now, this event is current!!!
			
			if (g_Trace_bPsiSttInfo)
			dprint(3, "[STT] event found: evid 0x%x,  %d min %d sec long\n",
					event->event_id,
					event->length_in_seconds/60, event->length_in_seconds%60);
			
			// 
			// 가장 마지막으로 기억하고 있었던 event id 랑 달라지면
			// program 이 변경된 것으로 판단한다.
			//
			if (event->event_id != tsport->last_event_id) {
				goto label_notify;
			}

			// todo..
			// event id 가 같더라도 실제 내용이 완전히 동일한지 체크해보자.
			// 그럴려면 last event 사본을 통째로 보전해야 한다.
			//
			// 일단 지금은 기존 event와 동일하므로 처리하지 않고 무시한다.
			goto label_exit;

		} // for iEvent
		
	} // for iEit

	// 아무 event 도 발견이 안된 경우..
	dprint(2, "[STT] no event found. last evid 0x%x\n", tsport->last_event_id);
	
	if (tsport->last_event_id != EVENT_ID_EMPTY) 
	{
		// 가장 마지막 event의 경우 valid 한 것이었는데, 
		// 이제 valid 한 event가 사라졌으니 역시 notify 해 줘야 한다. 
		// No Rating 정보 등을 처리하기 위해.
		
		event = NULL;
		goto label_notify;
	}
	
	goto label_exit;

label_notify:

	if (1)
	{
		S_PSIM_PROGRAM_CHANGED_CB_PARAM param;
		int new_event_id = event ? event->event_id : EVENT_ID_EMPTY;
		
		dprint(1, "******** program event changed 0x%x -> 0x%x\n", 
					tsport->last_event_id, new_event_id);
		
		tsport->last_event_id = new_event_id;

		//
		//  변경된 새 event 정보의 거의 대부분을 callback으로 알려준다.
		// 
		memset(&param, 0, sizeof(param));
		
		param.channel_id = channel_id;
		param.source_id = source_id;
		param.eit_index = event ? iEit : -1;   // eit-0 에서 왔는지, eit-1 에서 발견되었는지..
		param.event_id = new_event_id;
		
		param.system_time = system_time;

		if (event) 
		{
			param.start_time        = event->start_time;
			param.length_in_seconds = event->length_in_seconds;
			param.descriptor_length = event->descriptor_length;
			
			// 필요하면 client가 알아서 복제를 하면 된다.
			// 그냥 원본 포인터를 넘겨주자.
			param.descriptors = event->descriptors;
		}
			
		//Dmc_EpgSendUserEvent2(epgEventNotifyProgramChange, 
		//			(UINT32) new_event_id, (UINT32) &param);

		SendUserCallback(tsport, ePSIM_EVENT_ProgramChanged, (UINT32)&param);	
		
	}

label_exit:
	//Dmc_EpgLockCoreDB(FALSE);
	;
}




#if COMMENT
____Private____(){}
#endif

/*
	수신된 PAT를 처리한다.
*/
PSI_STATIC STATUS ProcessPAT(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	int i;
	DHL_RESULT err;
	STATUS status = statusOK;

	MPEG_PAT *pat, *prev_pat;

	dprint(4, "%s:\n", __FUNCTION__);
	
	err = ParsePAT(desc, &pat);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParsePAT returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// PAT sanity check
	if (!pat || pat->numPrograms == 0 || !pat->programs) {
		dprint(0, "!! wrong pat\n");
		PSIUTIL_FreeTable(&pat);
		return statusInvalidPSI;
	}

	if (tsport->patPsiCtl != desc->handle) {
		dprint(0, "!! inconsistent! patPsiCtl %x != desc psictl %x\n", tsport->patPsiCtl, desc->handle);
		status = statusInvalidState;
		goto label_end;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	if (dprintable(3))
		PrintPAT(pat);

	// 기존 pat와 비교하여 변경 사항이 없으면 skip. --> no!!
	//
	// 변경 사항이 있더라도 pmt_pid, program_number 에 변경 사항이 없으면서 pmt가 시작 중이면 
	// 해당 pmt monitor는 그대로 유지.
	// --> pmt monitor를 restart 해도 별 문제 안되므로 항상 restart하도록 하자.

	prev_pat = PSIDB_GetPAT(tsport->input.rf);

	// something is changed in pat.
	//  reset the pmt monitor that is changed (either pid or program_number)
	
	// pmtPsiCtl array 크기(numPrograms)가 변경 되었는지 체크, 적용.
	// 주의: 
	//   prev_pat->numPrograms 와 비교하지 않고, tsport->num_programs 와 비교함.
	//   왜냐면 예외 상황 등으로 인하여 tsport->num_programs는 0 일 수 있음.
	//
	if (prev_pat == NULL || pat->numPrograms != tsport->num_programs)
	{
		if (!prev_pat) {
			dprint(3, "new pat, %d program\n", pat->numPrograms);
		}
		else {
			dprint(3, "tsport num programs changed, %d -> %d\n", tsport->num_programs, pat->numPrograms);			
		}
		// 기존 동작 중인 pmt monitor를 모두 정지.
		StopMonitorPMTs(tsport);
		
		dprint(3, "alloc %d pmt ctl arrays..\n", pat->numPrograms);
		tsport->pmtPsiCtlArray = DHL_OS_Malloc(pat->numPrograms * sizeof(tDHL_PSI_ControlHandle));
		if (!tsport->pmtPsiCtlArray) {
			// pat 와 pmt monitor 간의 관계가 어긋났으므로 문제가 발생할 수 있음!!
			tsport->num_programs = 0; // <- 반드시 필요.
			// 이왕이면 pat 까지 다 삭제하면 일관성이 있는데, DB의 pat만 삭제할 방법은 없음.
			status = statusOutOfMemory;
			goto label_end;
		}
		tsport->num_programs = pat->numPrograms;

	}
	else // program 갯수 변경이 없는 경우.
	{
		// ASSERT (prev_pat->numPrograms == tsport->num_programs);
		
		// pmt psictl의 pid, pn이 pat 와 일치하는지 체크.
		// 일치하지 않은 monitor는 cancel.
		for (i=0; i<pat->numPrograms; i++)
		{
			if (tsport->pmtPsiCtlArray[i] == (tDHL_PSI_ControlHandle)0) continue;
			
			if (prev_pat->programs[i].program_map_PID != pat->programs[i].program_map_PID ||
				prev_pat->programs[i].program_number != pat->programs[i].program_number)
			{
				dprint(3, "pid/pn diff! cancel pmt[%d] monitor..\n", i);
				DHL_PSI_StopMonitor(tsport->pmtPsiCtlArray[i]);
				tsport->n_active_monitors--;
				tsport->pmtPsiCtlArray[i] = (tDHL_PSI_ControlHandle)0;
			}
		}
	}

	// pat가 기존 pat와 다른 경우에만 update 하고 notify 한다.
	if (!PSIUTIL_IsEquivalentPat(prev_pat, pat))
	{
		// PAT를 DB에 update 한다.
		status = PSIDB_UpdatePAT(tsport->input.rf, pat);

		if (status) {
			// 무슨 이유에서인지 pat update 실패. (대부분 메모리 에러)
			StopMonitorPMTs(tsport);
			goto label_end;
		}
		
		SendUserCallback(tsport, ePSIM_EVENT_PatReceived, (UINT32)pat);
	}
	
	// PMT를 monitor 시작한다.
	// input flag에 따라 동작이 달라짐.

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) 
	{
		StopMonitorPAT(tsport);

		if (PSIDB_IsPmtsCompleted(tsport->input.rf)) {
			SendUserCallback(tsport, ePSIM_EVENT_AllPmtsReceived, 0);
			// pmt monitor 모두 close..
			StopMonitorPMTs(tsport);
		}
		else {
			// 다른 monitor 시작..
			StartMonitorPMTs(tsport, -1); // no preference. get all pmts..
		}
	}
	else {
		StartMonitorPMTs(tsport, tsport->input.program_number);
	}
	pat = NULL; // not to be freed later

label_end:

	if (pat) {
		dprint(3, "  free unused pat %x..\n", pat);
		PSIUTIL_FreeTable(&pat);
	}
	
	return status;
	
}

PSI_STATIC STATUS ProcessPMT(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT err;
	STATUS status = statusOK;

	MPEG_PMT *pmt;
	MPEG_PAT *pat;
	
	int i, index;
	BOOL bPsiCtlConsistent = FALSE;
	//BOOL bPmtComplete;
	
	err = ParsePMT(desc, &pmt);
	if (IsError(err)) {
		dprint(0, "%s: ParsePMT returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// PMT sanity check.
	// todo:  pmt of numStreams zero..  
	// pmt 이후로의 연결된 작업은 없으니, 좀 이상한 pmt라도 일단 수신은 해 둘까?
	//     아니면 향후 작업들을 편하게 하기 위해서 그냥 못받은 것으로??
	// 그냥 버린다면..
	//   pros: 이상한 pmt를 미리 filter out 해 버리면 향후 check 작업이 없어도 되니 편함.
	//   cons: pmt 수신 완료가 안되니까 autoscan 등에서 timeout 발생시까지 느려짐..
	// 
	// --> 속도보다는 안정성.. 그냥 버리자.
	//
	if (!pmt || pmt->numStreams == 0 || !pmt->streams) {
		dprint(0, "!! wrong pmt\n");
		PSIUTIL_FreeTable(&pmt);
		return statusInvalidPSI;
	}

	for (i=0; tsport->pmtPsiCtlArray && i<tsport->num_programs; i++) {
		if (tsport->pmtPsiCtlArray[i] == desc->handle) {
			bPsiCtlConsistent = TRUE;
			break;
		}
	}
	if (!bPsiCtlConsistent) {
		dprint(0, "!! inconsistent! any pmtPsiCtls[] != desc psictl %x\n", desc->handle);
		status = statusInvalidState;
		goto label_end;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	// determine index using origianl psictl pointer
	index = -1;
	for (i=0; i<tsport->num_programs; i++) {
		if (tsport->pmtPsiCtlArray[i] == desc->handle) {
			index = i;
			break;
		}
	}
	if (index < 0) {
		dprint(0, "!! cannot find psictl origin\n");
		// 예외 처리: 그냥 현재 pmt 무시. 재시도 안함.
		status = statusInvalidPSI;
		goto label_end;
	}

	// pat 내용과 일치 여부 체크. (program number ..)
	
	pat = PSIDB_GetPAT(tsport->input.rf);
	if (pat == NULL) {
		dprint(0, "!! pmt without pat?\n");
		// 예외 처리: 그냥 현재 pmt 무시. 재시도 안함.
		status = statusInvalidPSI;
		goto label_end;
	}
	
	if (pat->numPrograms != tsport->num_programs) {
		dprint(0, "!! pat not consistent to pmt monitors\n");
		PSIUTIL_FreeTable(&pmt);

		// 예외 처리: pmt monitor들은 모두 reset 시켜 놓는다.
		StopMonitorPMTs(tsport);
		status = statusInvalidPSI;
		goto label_end;
	}

	if (dprintable(3))
		PrintPMT(pmt);

	// update..
	status = PSIDB_UpdatePMT(tsport->input.rf, pmt);
	// now, don't use pmt any more!

	if (status) {
		// 무슨 이유에서인지 pmt update 실패. (대부분 메모리 에러)
		goto label_end;
	}

	// autoscan 모드라면 현재 수신한 pmt는 stop 하고 추가 pmt 수신이 필요하면 조치함.
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN)
	{
		// 방금 수신한 pmt의 monitor는 종료
		DHL_PSI_StopMonitor(tsport->pmtPsiCtlArray[index]);
		tsport->pmtPsiCtlArray[index] = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;

		if (PSIDB_IsPmtsCompleted(tsport->input.rf)) {
			SendUserCallback(tsport, ePSIM_EVENT_AllPmtsReceived, 0);
			// 이미 pat monitor는 정지되어 있을 것이지만 다시 한번 체크..
			StopMonitorPAT(tsport);
			// pmt monitor 모두 close..
			StopMonitorPMTs(tsport);
		}
		else {
			// 다른 monitor 시작..
			StartMonitorPMTs(tsport, -1);
		}
	}
	else
	{
	#if 1
		// pmt pointer 그대로 access 가능하므로 좀 더 간단해짐.
		SendUserCallback(tsport, ePSIM_EVENT_PmtReceived, (UINT32)pmt);
	#else
		for (i=0; pmtList && i<pat->numPrograms; i++) {
			if (tsport->input.program_number == pmtList[i]->program_number) {
				SendUserCallback(tsport, ePSIM_EVENT_PmtReceived, (UINT32)pmtList[i]);
				break;
			}
		}
	#endif
	}
	pmt = NULL; // not to be freed later

label_end:

	if (pmt) {
		dprint(3, "  free unused pmt %x..\n", pmt);
		PSIUTIL_FreeTable(&pmt);
	}
	return status;

}


PSI_STATIC STATUS ProcessMgt(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	BOOL bMgtChanged = FALSE;
	
	mgtSectionPtr_t mgt, prev_mgt;
	
	err = ParseMgtSection(desc->sectPtr[0], &mgt);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParseMgt returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// sanity check
	if (!mgt || mgt->tables_defined==0 || !mgt->table) {
		dprint(0, "!! invalid mgt\n");
		PSIUTIL_FreeTable(&mgt);
		return statusInvalidPSI;
	}

	if (tsport->mgtPsiCtl != desc->handle) {
		dprint(0, "!! inconsistent! mgtPsiCtl %x != desc psictl %x\n", tsport->mgtPsiCtl, desc->handle);
		status = statusInvalidState;
		goto label_end;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	if (dprintable(4))
		PrintMgtSection(mgt);

	//-----------------------------------
	// 기존 table과 비교하여 변경 사항이 여부 체크

	prev_mgt = PSIDB_GetMgt(tsport->input.rf);

	if (prev_mgt == NULL) {
		dprint(2, "  mgt newly comes.. new mgt ver %d\n", mgt->version_number);
		bMgtChanged = TRUE;
	}
	else if (PSIUTIL_IsEquivalentMgt(prev_mgt, mgt) == FALSE) {
		dprint(2, "  mgt changed.. ver %d --> %d\n", prev_mgt->version_number, mgt->version_number);
		bMgtChanged = TRUE;
	}
	else {
		dprint(2, "  mgt version unchagned %d\n", mgt->version_number);

		// mgt version이 변경되지 않았다고 해도 여러가지 이유로 (filter 부족) 시작하지 못한
		// section들이 있을 수 있으므로 여기서 중단하지 않고 계속 진행한다.
	}

	//-----------------------------------
	if (bMgtChanged) 
	{
		// DB에 update 한다. 이때 내부에서 많은 부가 작업이 같이 진행 된다.
		// ex: 변경 되는 모든 테이블 정리, mgt digest 생성
		//
		status = PSIDB_UpdateMgt(tsport->input.rf, mgt);
		if (status) {
			// 무슨 이유에서인지 mgt update 실패..
			goto label_end;
		}
		//SendUserCallback(tsport, ePSIM_EVENT_MgtReceived, (UINT32)mgt);
	}

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		// autoscan 모드에서는 하나의 instance만 수신하면 되므로 바로 중지.
		StopMonitorMgt(tsport);
	}

	// mgt와 vct가 모두 받아져 있다면 eit/ett 수신을 시작할 수 있다.
	if (!PSIDB_IsSubChScanReadyToStart(tsport->input.rf)) {
		// not ready.
		dprint(2, "  subch scan not ready.. mgt %x, vct %x\n", 
			PSIDB_GetMgt(tsport->input.rf), PSIDB_GetVct(tsport->input.rf));
	}
	else {	
		//test..SendEventChannelStarted(tsport, tsport->input.rf);
		
		StartSubChannelScan(tsport);
	}
	
	mgt = NULL; // not to be freed later
	
label_end:

	if (mgt) {
		dprint(3, "  free unused mgt %x..\n", mgt);
		PSIUTIL_FreeTable(&mgt);
	}
	return status;
	
}

PSI_STATIC STATUS ProcessVct(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	xvctPtr_t vct, prev_vct;
	BOOL bVctChanged = FALSE;

	dprint(2, "process vct..\n");
	
	err = ParseVct(desc->sectPtr, &vct);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParseVct returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// sanity check
	if (!vct || vct->numChannels==0 || !vct->channel) {
		dprint(0, "!! invalid vct\n");
		PSIUTIL_FreeTable(&vct);
		return statusInvalidPSI;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	//-----------------------------------
	// vct 고유의 처리 루틴들.. 두개의 vct 중에서 하나의 monitor만 살려놓는다.
	
	if (vct->is_cvct) // cvct
	{
		if (tsport->cvctPsiCtl == (tDHL_PSI_ControlHandle)0) {
			// already cancelled. this is delayed processing.
			dprint(2, "already cancelled cvct mon\n");
			goto label_end;
		}
		if (tsport->cvctPsiCtl != desc->handle) {
			dprint(0, "!! inconsistent! cvctpsictl %x != desc psictl %x\n", tsport->cvctPsiCtl, desc->handle);
			status = statusInvalidState;
			goto label_end;
		}
		// 당장 tvct는 중지시킨다. 오직 하나의 vct만 가능하도록...
		StopMonitorTvct(tsport);
	}
	else // tvct
	{
		if (tsport->tvctPsiCtl == (tDHL_PSI_ControlHandle)0) {
			// already cancelled. this is delayed processing.
			dprint(2, "already cancelled tvct mon\n");
			goto label_end;
		}
		if (tsport->tvctPsiCtl != desc->handle) {
			dprint(0, "!! inconsistent! tvctpsictl %x != desc psictl %x\n", tsport->tvctPsiCtl, desc->handle);
			status = statusInvalidState;
			goto label_end;
		}
		// 당장 cvct는 중지시킨다. 오직 하나의 vct만 가능하도록...
		StopMonitorCvct(tsport);
	}

	//-----------------------------------
	// 기존 table과 비교하여 변경 사항이 여부 체크

	prev_vct = PSIDB_GetVct(tsport->input.rf);

	if (prev_vct == NULL) {
		dprint(2, "  vct newly comes.. new vct ver %d\n", vct->version_number);
		bVctChanged = TRUE;
	}
	else if (PSIUTIL_IsEquivalentVct(prev_vct, vct) == FALSE) {
		dprint(2, "  vct changed.. ver %d --> %d\n", prev_vct->version_number, vct->version_number);
		bVctChanged = TRUE;
	}
	else {
		dprint(2, "  vct version unchagned %d\n", prev_vct->version_number);
	
		// vct가 변경되지 않았다고 해도 여러가지 이유로 (filter 부족) 시작하지 못한
		// section들이 있을 수 있으므로 여기서 중단하지 않고 계속 진행한다.
	}

	//-----------------------------------
	if (bVctChanged) 
	{
		// DB에 update 한다. 이때 내부에서 많은 부가 작업이 같이 진행 된다.
		// ex: subchannel struct re-init..
		//
		status = PSIDB_UpdateVct(tsport->input.rf, vct);

		if (status) {
			// something wrong! vct not updated to DB..
			goto label_end;
		}
		SendUserCallback(tsport, ePSIM_EVENT_VctReceived, (UINT32)vct);
	}
	else {
		// todo
		//   Equivalent 하지는 않지만, 사소한 아주 작은 차이들이 있을 수 있지 않는가?
		//   즉 DB에는 update를 하는 것이 좋지 않나?
		// 
		//   --> 
		//    Equivalence 체크 루틴의 정확도에 따라 영향이 달라짐.
		//    또 만약 vct continuous 모드로 받고 있다면 계속 DB안의 vct가 replace 될 염려 있음.
		//    따라서 일단은 update 하지 않도록 하자.

		// db update 여부를 떠나서 event callback은 불러주도록 하자.
		SendUserCallback(tsport, ePSIM_EVENT_VctReceived, (UINT32)vct);
	}
	
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		// 어떤 것이 가동중인지 알기 귀찮으니까 tvct, cvct 둘 다 중지.
		StopMonitorTvct(tsport);
		StopMonitorCvct(tsport);
	}

	// mgt와 vct가 모두 받아져 있다면 eit/ett 수신을 시작할 수 있다.
	if (!PSIDB_IsSubChScanReadyToStart(tsport->input.rf)) {
		// not ready.
		dprint(2, "  subch scan not ready.. mgt %x, vct %x\n", 
			PSIDB_GetMgt(tsport->input.rf), PSIDB_GetVct(tsport->input.rf));
	}
	else {
		//test..SendEventChannelStarted(tsport, tsport->input.rf);

		StartSubChannelScan(tsport);
	}
	
	vct = NULL; // not to be freed later
	
label_end:

	if (vct) {
		// DB에 update 되지 않은 vct는 없애줘야 메모리 누수가 없음..
		dprint(3, "  free unused vct %x..\n", vct);
		PSIUTIL_FreeTable(&vct);
	}
	
	return status;
}



//  STT가 수신될 때마다 이 함수가 불린다..
//
//  이 함수에서 STT 처리를 하고 Program event 변경 체크도 한다.
//  즉 program event 변경 체크는 STT가 수신 될 경우에만 수행하게 된다.
//
//  만약 STT 주기가 길거나, 신호 상태가 않좋음 등의 이유로 STT update가 늦어질 경우
//  program event 변경 체크도 늦어질 수 있다.
//
//  따라서 User는 별도로 주기적으로 program event 변경 체크를 불러줄 필요가 있다.
//
PSI_STATIC STATUS ProcessStt(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	DHL_RESULT err;
	STATUS status = statusOK;
	UINT32 tick = DHL_OS_GetMsCount();

	sttSection_t prev_stt_0;
	sttSectionPtr_t stt, prev_stt = &prev_stt_0;
	
	err = ParseSttSection(desc->sectPtr[0], &stt);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParseStt returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// sanity check
	if (!stt) {
		PSIUTIL_FreeTable(&stt);
		return statusInvalidPSI;
	}

	if (tsport->sttPsiCtl != desc->handle) {
		dprint(0, "!! inconsistent! sttPsiCtl %x != desc psictl %x\n", tsport->sttPsiCtl, desc->handle);
		status = statusInvalidState;
		goto label_end;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.
	
	// 혹시 현재의 SttPsiCtl 이 이미 취소 되어 있을 수도 있기 때문에
	// 현재 context의 내용을 확인해 보는 것도 좋다.
	// 
	if (tsport->sttPsiCtl == (tDHL_PSI_ControlHandle)0) {
		dprint(0, "!! %s: stt from null psi ctl\n", __FUNCTION__);
		//return statusInvalidState;
		return statusOK;
	}


	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) 
	{
		StopMonitorStt(tsport);
		//goto label_end;  // stt notify 해주기 위해서 그냥 skip은 안함.

		// autoscan 모드라도 stt notify 등은 필요할 수 있으므로 
		// 아래 작업은 동일하게 수행해 주도록 한다.
		// 단 program change notify는 할 필요 없다.
	}


	// stt 내에는 system time 뿐만 아니라 GPS_UTC offset 및 daylight saving 정보도 있다.
	// 이 모든 내용이 동일한 경우에만 equivalent라고 할 수 있음.
	
	prev_stt = PSIDB_GetStt(tsport->input.rf);

	if (PSIUTIL_IsEquivalentStt(prev_stt, stt))
	{
		// 동일한 시간으로 stt가 수신되었음. 처리할 필요 없다.
		// sarnoff stream: rpbp, fast base pid stream 대응.
		//  stt가 초당 10회씩 전송됨.
	}
	else
	{
		// 기존 stt에 비해 뭔가 다른 stt가 수신된 경우이다.
		// 사실 대부분의 경우 이 범주에 속한다.

		if (dprintable(4))
			PrintSttSection(stt);

		// update를 하기 전에 backup을 해 두어야 함. 그렇지 않으면
		// PSIDB_UpdateStt 하면서 새로운 stt로 overwrite 되어 버린다.
		//
		if (prev_stt) {
			prev_stt_0 = *prev_stt;
			prev_stt = &prev_stt_0;
		}
		
		status = PSIDB_UpdateStt(tsport->input.rf, stt, tick);
		if (status) {
			goto label_end;
		}

		// DB의 stt는 flat_stt 라고 좀 다른 형태이므로 수신 받은 stt는 버리고
		// DB의 stt 정보를 참고하자.
		PSIUTIL_FreeTable(&stt);
		stt = PSIDB_GetStt(tsport->input.rf);

		if (g_Trace_bPsiSttInfo) {
			char cur_time[100] = {0, };		
		#if DMW_EPG_TABLE_DUMP_DEBUG	
			Dmc_SetGpsTimeSync(stt);
			GpsTimeString(stt->system_time, cur_time);
		#endif
			dprint(2, "[STT] (rf %d, sid %d) %s gps 0x%x\n",
					tsport->input.rf, tsport->input.source_id, cur_time, stt->system_time);
		}

		// STT Smart Notification
		//
		//   if 'system time JUMP' is detected, notify to user.
		//   probably stream is changed, tuner setting (rf) is changed,
		//     or signal is re-aquired in weak signal environment.
		//   user had better re-sync system time to this new STT value..
		//     

		// 새 stt가 수신되었다고 해서 매번 notify를 하지는 않는다.
		// 다음 두가지 조건에 해당 될 경우에만 notify 한다.
		//
		// 1. 이 RF에서 psi scan을 시작 한 후 처음 수신된 stt
		// 2. stt threshold를 넘어선 skip이 발견된 경우..
		//
		if (prev_stt == NULL)
		{
			// EpgScan이 시작되고 나서 처음 받은 stt라면 event를 보내준다.
			//
			dprint(1, "first STT received after psi start..\n");
			
			SendUserCallback(tsport, ePSIM_EVENT_SttReceived, (UINT32)stt);
		}
		else if (abs((SINT32)(stt->system_time - prev_stt->system_time)) > STT_JUMP_THRESHOLD)
		{
			//int age = (DHL_OS_GetMsCount() - tick_stt_get) / 1000;
			
			dprint(1, "STT Jump (%d sec) detected..\n", stt->system_time - prev_stt->system_time);
			
			// jump는 음의 값이 될 수도 있다. stream 이 반복해서 재생되는 경우..
			//
			// age를 계산해서 넘겨주는 이유는 이 stt 처리 task가 priority가 낮아서
			// 실제로 stt를 받은 시간과 이 stt를 처리하는 시간에 차이가 있을 수 있기 때문.
			// 대부분 아주 작은 값이거나 0의 값을 갖을 것이다.
			
			SendUserCallback(tsport, ePSIM_EVENT_SttReceived, (UINT32)stt);
		}

		// Program Event 변경 사항 체크. 
		// autoscan 모드인 경우에는 불필요.
		//
		if (PSI_FLAGS_MODE(tsport->input.flags) != PSI_FLAGS_AUTOSCAN /* && IS_VALID_SOURCE_ID(tsport->source_id) */) 
		{
			CheckIfProgramEventChanged(tsport);
		}
		
	}
	stt = NULL; // not to be freed later
	
label_end:

	if (stt) {
		dprint(3, "  free unused stt %x..\n", stt);
		PSIUTIL_FreeTable(&stt);
	}
	return status;
}

PSI_STATIC STATUS ProcessRrt(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	STATUS status = statusOK;
	
	return status;
}

/*
	어떤 eit[k] 인지 확인하기 위해서는 이 테이블을 수신한 psiCtl을 알아야 한다.
	
*/
PSI_STATIC STATUS ProcessEit(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	int index, i;
	STATUS status = statusOK;
	DHL_RESULT err;
	eitPtr_t eit;
	//BOOL bFilterReleased = FALSE;
	BOOL bPsiCtlConsistent = FALSE;
	
	err = ParseEit(desc->sectPtr, &eit);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParseEit returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// Eit table sanity check
	if (eit->numEvents && !eit->event) {
		PSIUTIL_FreeTable(&eit);
		return statusInvalidPSI;
	}

	for (i=0; i<128; i++) {
		if (tsport->eitPsiCtl[i] == desc->handle) {
			bPsiCtlConsistent = TRUE;
			break;
		}
	}
	if (!bPsiCtlConsistent) {
		dprint(0, "!! inconsistent! any eitPsiCtls[] != desc psictl %x\n", desc->handle);
		status = statusInvalidState;
		goto label_end;
	}

	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	// decide which eit it is..
	index = -1;
	for (i=0; i<128; i++) {
		if (desc->handle == tsport->eitPsiCtl[i]) {
			index = i;
			break;
		}
	}
	if (index < 0) {
		dprint(0, "!! orphan eit?\n");
		status = statusInvalidPSI;
		goto label_end;
	}

	dprint(2, "eit[%d] received. sid %d\n", index, eit->source_id);
	if (dprintable(3)) {
		//PrintEit(eit);
	}
	
	// Eit를 DB에 update 한다.
	PSIDB_UpdateEit(tsport->input.rf, eit, index);

#if 0
	// this is just for informational declare.
	if (PSIDB_IsSubChEitsCompleted(tsport->input.rf, eit->source_id)) {
		dprint(2, "\n#### source_id %d subch eit completed\n", eit->source_id);
	}
#endif

	// schedule next job..
	// 혹시 filter 갯수 제한 때문에 받지 못한 다른 table 들 schedule.
	//
	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) 
	{
		if (PSIDB_IsAllSubChEitsCompleted(tsport->input.rf, index)) 
		{
			dprint(2, "all subch's eit[%d] completed. stop monitor..\n", index);
			StopMonitorEit(tsport, index);
			//bFilterReleased = TRUE;

			// monitor remaining pmts..
			StartMonitorPMTs(tsport, -1); // no preference. get all pmts..
		}
	}
	else {
		// 1:1 이므로, 수신하면 바로 중지함.
		StopMonitorEit(tsport, index);
		//bFilterReleased = TRUE;
		
		// monitor remaining eits..
		StartSubChannelScan(tsport);
	}
	eit = NULL; // not to be freed later

label_end:

	if (eit) {
		dprint(3, "  free unused eit %x..\n", eit);
		PSIUTIL_FreeTable(&eit);
	}
	return status;
}


PSI_STATIC STATUS ProcessEtt(S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	int index, i;
	STATUS status = statusOK;
	DHL_RESULT err;
	ettSectionPtr_t ett;
	BOOL bPsiCtlConsistent = FALSE;

	int ett_source_id, ett_event_id;
	S_PSIM_SUBCHINFO *subchInfo;
	
	err = ParseEttSection(desc->sectPtr[0], &ett);
	// desc will be freed at caller.
	
	if (IsError(err)) {
		dprint(0, "%s: ParseEtt returned %s\n", __FUNCTION__, ErrorString(err));
		return statusInvalidPSI;
	}

	// Ett table sanity check
	if (!ett || ett->ETM_id == 0 || !ett->extended_text_message_length) {
		dprint(0, "!! invalid ett\n");
		PSIUTIL_FreeTable(&ett);
		return statusInvalidPSI;
	}

	for (i=0; i<128; i++) {
		if (tsport->ettPsiCtl[i] == desc->handle) {
			bPsiCtlConsistent = TRUE;
			break;
		}
	}
	if (tsport->ettvPsiCtl == desc->handle)
		bPsiCtlConsistent = TRUE;
	
	if (!bPsiCtlConsistent) {
		dprint(0, "!! inconsistent! any ettPsiCtls[] != desc psictl %x\n", desc->handle);
		status = statusInvalidState;
		goto label_end;
	}
	
	//--------------------------------------------------------------------
	// now, table becoms vailid. if not updated to DB, free it carefully.

	// context consistency..

	if (PSI_FLAGS_MODE(tsport->input.flags) == PSI_FLAGS_AUTOSCAN) {
		dprint(0, "!! ett received in autoscan mode?\n");
		PSIUTIL_FreeTable(&ett);
		return statusInvalidState;
	}

#if 0
	// decide which ett it is..
	index = -1;
	if (desc->psiCtl == tsport->ettvPsiCtl) {
		index = 128;
	}
	for (i=0; i<128; i++) {
		if (desc->psiCtl == tsport->ettPsiCtl[i]) {
			index = i;
			break;
		}
	}

	if (index < 0) {
		dprint(0, "!! orphan ett?\n");
		return statusInvalidPSI;
	}
	
#else
	
	// ett의 경우 ettPsiCtl과의 비교로 iEtt를 알아내는 것은 안전하지 않다.
	// 직접 ett 내의 etmid 값을 이용하여 eits의 event_id 와 비교하여 찾아야 한다.

	ett_source_id = PSIUTIL_GetSourceIDFromETMID(ett->ETM_id);
	ett_event_id = PSIUTIL_GetEventIDFromETMID(ett->ETM_id);

	if (tsport->source_id != ett_source_id) {
		dprint(0, "!! ett sid %d not matched to port sid %d\n", 
				ett_source_id, tsport->source_id);
		PSIUTIL_FreeTable(&ett);
		return statusInvalidState;
	}

	subchInfo = PSIDB_GetPsiSubChInfo(tsport->input.rf, tsport->source_id);
	if (!subchInfo) {
		PSIUTIL_FreeTable(&ett);
		return statusInvalidState;
	}
	
	// 어떤 ett인지 찾는다.
	index = -1;
	if ((ett->ETM_id & 0xffff) == 0) // channel-ett
		index = 128;

	for (i=0; index<0 && i<128; i++) {
		int k;
		if (!subchInfo->eits[i]) continue;
		for (k=0; k<subchInfo->eits[i]->numEvents; k++) {
			if (subchInfo->eits[i]->event[k].event_id == ett_event_id) {
				index = i;
				break;
			}
		}
	}
	if (index < 0) {
		dprint(0, "!! orphan ett? etm 0x%x, no such event_id 0x%x..\n", ett->ETM_id, ett_event_id);
		PSIUTIL_FreeTable(&ett);
		return statusInvalidPSI;
	}
	
#endif

	// todo
	// 이미 수신한 ett 인지 검사..
	

	dprint(2, "ett[%d] received. etmid 0x%x\n", index, ett->ETM_id);
	if (dprintable(3)) {
		//PrintEttSection(ett);
	}
	
	// Eit를 DB에 update 한다.
	PSIDB_UpdateEtt(tsport->input.rf, ett, index);

	// 해당 pid의 ett들이 끝났다면 해당 ett psictl을 중지.
	if (PSIDB_IsSubChEttSlotCompleted(tsport->input.rf, tsport->source_id, index)) {
		dprint(2, "  ett[%d] slot all received.\n", index);
		StopMonitorEtt(tsport, index);
	}

	// todo
	// 이 방법은 결코 효율적이지 못하다. 더 좋은 방법 찻아볼것!
	if (PSIDB_IsSubChAllEttsCompleted(tsport->input.rf, tsport->source_id)) {
		dprint(2, "  all etts received\n");
		StopMonitorAllEtts(tsport);
	}
	ett = NULL; // not to be freed later
	
label_end:

	if (ett) {
		dprint(3, "  free unused ett %x..\n", ett);
		PSIUTIL_FreeTable(&ett);
	}
	return status;
}

PSI_STATIC void StopAllPsiMonitors(S_PSIM_PORT *tsport)
{
	//int err;
	int i;

	dprint(2, "%s:\n", __FUNCTION__);

	// PAT
	if (tsport->patPsiCtl) {
		dprint(3, "\t cancel pat monitor\n");
		DHL_PSI_StopMonitor(tsport->patPsiCtl);
		tsport->n_active_monitors--;
		tsport->patPsiCtl = (tDHL_PSI_ControlHandle)0;
	}
	
	// PMTs
	for (i=0; i<tsport->num_programs; i++) {
		if (tsport->pmtPsiCtlArray[i]) {
			dprint(3, "\t cancel pmt[%d] monitor\n", i);
			DHL_PSI_StopMonitor(tsport->pmtPsiCtlArray[i]);
			tsport->n_active_monitors--;
			tsport->pmtPsiCtlArray[i] = (tDHL_PSI_ControlHandle)0;
		}
	}
	tsport->num_programs = 0;
	DHL_OS_Free((void **)&tsport->pmtPsiCtlArray);

	// MGT
	if (tsport->mgtPsiCtl) {
		dprint(3, "\t cancel mgt monitor\n");
		DHL_PSI_StopMonitor(tsport->mgtPsiCtl);
		tsport->mgtPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// TVCT
	if (tsport->tvctPsiCtl) {
		dprint(3, "\t cancel tvct monitor\n");
		DHL_PSI_StopMonitor(tsport->tvctPsiCtl);
		tsport->tvctPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// CVCT
	if (tsport->cvctPsiCtl) {
		dprint(3, "\t cancel cvct monitor\n");
		DHL_PSI_StopMonitor(tsport->cvctPsiCtl);
		tsport->cvctPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// STT
	if (tsport->sttPsiCtl) {
		dprint(3, "\t cancel stt monitor\n");
		DHL_PSI_StopMonitor(tsport->sttPsiCtl);
		tsport->sttPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// RRT
	if (tsport->rrtPsiCtl) {
		dprint(3, "\t cancel rrt monitor\n");
		DHL_PSI_StopMonitor(tsport->rrtPsiCtl);
		tsport->rrtPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// EAS
	if (tsport->easPsiCtl) {
		dprint(3, "\t cancel eas monitor\n");
		DHL_PSI_StopMonitor(tsport->easPsiCtl);
		tsport->easPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	// EIT
	for (i=0; i<128; i++) {
		if (tsport->eitPsiCtl[i]) {
			dprint(3, "\t cancel eit[%d] monitor\n", i);
			DHL_PSI_StopMonitor(tsport->eitPsiCtl[i]);
			tsport->eitPsiCtl[i] = (tDHL_PSI_ControlHandle)0;
			tsport->n_active_monitors--;
		}
	}
	// ETT
	for (i=0; i<128; i++) {
		if (tsport->ettPsiCtl[i]) {
			dprint(3, "\t cancel ett[%d] monitor\n", i);
			DHL_PSI_StopMonitor(tsport->ettPsiCtl[i]);
			tsport->ettPsiCtl[i] = (tDHL_PSI_ControlHandle)0;
			tsport->n_active_monitors--;
		}
	}
	// Channel-ETT
	if (tsport->ettvPsiCtl) {
		dprint(3, "\t cancel ett-v monitor\n", i);
		DHL_PSI_StopMonitor(tsport->ettvPsiCtl);
		tsport->ettvPsiCtl = (tDHL_PSI_ControlHandle)0;
		tsport->n_active_monitors--;
	}
	
	if (tsport->n_active_monitors != 0) {
		dprint(0, "!! orphan active monitors %d\n", tsport->n_active_monitors);
		tsport->n_active_monitors = 0;
	}
}



/*
	모든 table을 받는 event callback 

	무조건 parsing 한 후에 task로 테이블 포인터를 전달한다.
*/
PSI_STATIC void _PsiTableEventProc(tDHL_PSI_Event psiEvent, tDHL_PSI_ControlHandle psiCtl, UINT32 userParam)
{
	STATUS status;
	DHL_RESULT err;
	tDHL_PSI_DataArray *desc;

	S_PSIM_PORT *tsport = (S_PSIM_PORT *) userParam;

	if (psiEvent != ePSIEVENT_DATARECEIVED) {
		if (g_Trace_bPsiEvent) {
			// 신호가 좋지 않은 경우에 lostpacket 이벤트는 아주 빈번하게 발생 가능하므로 제외.
			if (psiEvent != ePSIEVENT_LOSTPACKET)
				dprint(3, "%s: psiEvent %s\n", __FUNCTION__, DHL_PSIEventString(psiEvent));
		}
		return;
	}

	// data recieved event는 debug print하지 않는다.
	//
	err = DHL_PSI_ReadPSIData(psiCtl, &desc);
	if (err) {
		dprint(0, "%s: ReadPSIData returned %s\n", __FUNCTION__, ErrorString(err));
		return;
	}

	status = PSITASK_SendCommand(ePSIM_CMD_TableReceived, (UINT32)tsport, (UINT32)desc, FALSE);

	if (status) {
		// Q가 overflow되어 들어가지 않았기 때문에 
		// 할당한 테이블을 삭제해서 메모리 누수를 막는다
		//if (g_Trace_bDmcPsiEvent)
			dprint(0, "!! %s: DmcQ full\n", __FUNCTION__); 
			
		DHL_PSI_FreePSIData(desc);
	}
}



#if COMMENT
____Public____(){}
#endif

/*
	해당 @tsd 포트에 대해서 @input 설정으로 psi scan을 시작한다.
*/
STATUS PSIE_StartPsiScan(S_PSIM_CONTEXT *pContext, tDHL_TSD tsd, S_PSIM_USER_INPUT *input)
{
	S_PSIM_PORT *tsport;
	int i;	
	STATUS status = statusOK;

	// sanity test
	if (tsd == (tDHL_TSD)0 || input == NULL)
		return statusInvalidArgument;

	dprint(2, "%s: input tsd %x, rf %d, #%d, $%d, mode %d, proc %x, param %x\n", 
			__FUNCTION__, tsd, input->rf, input->program_number, input->source_id,
			input->flags, input->userproc, input->userparam);

	// 지정된 tsd 가 이미 동작 중인 것인지 체크.
	
	tsport = NULL;
	for (i=0; i<MAX_TS_INPUT; i++) {
		if (pContext->tsport[i].tsd == tsd) {
			tsport = &pContext->tsport[i];
			break;
		}
	}
	if (tsport) {
		dprint(0, "!! tsd %x already running. stop first!\n", tsd);

		// 이미 동작 중이라면, 기존 동작 중지하고 새롭게 시작.

		PSIE_StopPsiScan(pContext, tsd);
	}

	// 빈 tsport entry를 찾는다.
	for (i=0; i<MAX_TS_INPUT; i++) {
		if (pContext->tsport[i].tsd == NULL) {
			tsport = &pContext->tsport[i];
			break;
		}
	}

	if (tsport == NULL) {
		dprint(0, "!! no available tsport entry for tsd %x\n", tsd);
		return statusOutOfResource;
	}
	
	/*
		필요하면 현재 task 상태를 설정한다.
	*/
#if 0
	if (pContext->state != ePSIM_TASK_STATE_Idle) {
		pContext->state = ePSIM_TASK_STATE_Idle;
	}
#endif

	/*
		TransportInput port 정보를 초기화 한다.
			TSD, rf, #, sid, mode, 
	*/
	memset(tsport, 0, sizeof(S_PSIM_PORT));
	tsport->tsd = tsd;
	tsport->input = *input;
	
	tsport->max_monitors = MAX_FILTERS_PER_PORT;

	// use input's source_id as a start point.
	tsport->source_id = input->source_id;

	// for program change monitor
	tsport->last_event_id = EVENT_ID_INIT;   // reset last information


	/*
		DB에서 chinfo 구조체 할당.
	*/
	status = PSIDB_AllocateChInfoNode(tsport->input.rf);
	if (status)
		return status;

	// 시작하기 전에 항상 먼저 stt invalidate.
	// 이후 최초 수신되는 stt는 자동 notify 된다.
	//
	PSIDB_InvalidateStt(tsport->input.rf);


	/*
		1차 테이블 수신 시작
		PAT, MGT, VCT, STT, RRT, EAS
	*/

	StartMonitorPAT(tsport);
	// pmt will be started after pat is downloaded.

	// psiUpdateMode may vary according to psi scan mode.
	// right now, this should be considered inside each function.

	StartMonitorStt(tsport);
	StartMonitorMgt(tsport);
	StartMonitorTvct(tsport);
	StartMonitorCvct(tsport);

	if (PSI_FLAGS_MODE(tsport->input.flags) != PSI_FLAGS_AUTOSCAN) {
		StartMonitorRrt(tsport);
	}
	
	return status;
}


/*
	해당 @tsd 포트의 psi scan 작업을 중지한다.
	현재까지 검색된 결과는 그대로 유지된다.
*/
STATUS PSIE_StopPsiScan(S_PSIM_CONTEXT *pContext, tDHL_TSD tsd)
{
	S_PSIM_PORT *tsport;
	int i;
	STATUS status = statusOK;

	// 주어진 tsd 정보로부터 port 정보를 찾는다.

	tsport = NULL;
	for (i=0; i<MAX_TS_INPUT; i++) {
		if (pContext->tsport[i].tsd == tsd) {
			tsport = &pContext->tsport[i];
			break;
		}
	}

	if (tsport == NULL) {
		dprint(0, "!! no such tsd %x\n", tsd);
		return statusInvalidArgument;
	}

	dprint(2, "stop psi scan: rf %d\n", tsport->input.rf);

	// 먼저 monitor를 중지.
	
	StopAllPsiMonitors(tsport);

	// 임시 변수, 테이블 들 초기화.

	// user callback
	// 제대로 구현하자.. todo..
	SendUserCallback(tsport, epgEventStopped, 0);

	memset(tsport, 0, sizeof(*tsport));

	return status;
}

/*
	모든 포트의 psi scan 작업을 중지한다.
*/
STATUS PSIE_StopAllPsiScan(S_PSIM_CONTEXT *pContext)
{
	//S_PSIM_PORT *tsport;
	int i;
	STATUS status = statusOK;

	// 주어진 tsd 정보로부터 port 정보를 찾는다.

	//tsport = NULL;
	for (i=0; i<MAX_TS_INPUT; i++) 
	{
		if (pContext->tsport[i].tsd == NULL)
			continue;
	
		status = PSIE_StopPsiScan(pContext, pContext->tsport[i].tsd);
		if (status)
			dprint(0, "!! stop psi scan err %d\n", status);
	}

	return status;
}

/*
	메모리에 검색되어 저장되어 있는 psi data 중에서 
	인자 @id에 해당되는 것들을 모두 삭제한다.
*/
STATUS PSIE_DeleteTables(S_PSIM_CONTEXT *pContext, int id)
{
	/*
		todo :
		psi scan engine이 동작하는 중에 일부 data가 삭제가 된다면
		문제가 생길 가능성이 있는데, 이를 api 내부에서 처리하는 것이 바람직한가?
	*/
	PSIE_StopAllPsiScan(pContext);

	if (id)
		PSIDB_DeleteTables(id);
	else 
		PSIDB_DeleteAllTables();
	
	return statusOK;
}

/*
	수신 된 psi data를 처리한다.
*/
STATUS PSIE_ProcessReceivedTable(S_PSIM_CONTEXT *pContext, S_PSIM_PORT *tsport, tDHL_PSI_DataArray *desc)
{
	//int err;
	UINT8 table_id;
	STATUS status = statusOK;

	//dprint(2, "%s: \n", __FUNCTION__);

	// sanity check
	if (tsport == NULL || desc == NULL) {
		return statusInvalidArgument;
	}

	#if 0
	if (desc->psiCtl != tsport->tsd) {
		dprint(0, "!! tsd diff: desc %x, port %x\n", desc->psiCtl, tsport->tsd);
		return statusError;
	}
	#endif

	if (desc->numSections < 1) {
		dprint(0, "!! invalid numSection %d\n", desc->numSections);
		return statusError;
	}

	table_id = desc->sectPtr[0][0];

	dprint(2, "============ pid %x, tid %02x (%s)\n", desc->pid, table_id, PSIUTIL_TidString(table_id));

	/*
		각 테이블 별로 나눠서 처리한다.
	*/
	
	switch (table_id)
	{
	case PROGRAM_ASSOCIATION_SECTION:
		status = ProcessPAT(tsport, desc);
		break;

	case TS_PROGRAM_MAP_SECTION:
		status = ProcessPMT(tsport, desc);
		break;

	case tid_master_guide_table:
		status = ProcessMgt(tsport, desc);
		break;

	case tid_terr_virtual_chan_table:
	case tid_cable_virtual_chan_table:
		status = ProcessVct(tsport, desc);
		break;
	
	case tid_system_time_table:
		status = ProcessStt(tsport, desc);
		break;

	//case tid_rating_region_table:
	//	break;

	case tid_event_information_table:
		status = ProcessEit(tsport, desc);
		break;

	case tid_extended_text_table:
		status = ProcessEtt(tsport, desc);
		break;

	default:
		dprint(0, "!! unknown table..\n");
		break;
	};

	DHL_PSI_FreePSIData(desc);

	return status;
	
}




E_PSIM_MODULE_STATE PSIE_GetModuleState(S_PSIM_CONTEXT *pContext)
{
	return pContext->state;
}

void PSIE_ChangeModuleState(S_PSIM_CONTEXT *pContext, E_PSIM_MODULE_STATE newState)
{
	pContext->state = newState;
}

UINT32 PSIE_GetTimeout(S_PSIM_CONTEXT *pContext)
{
	// module state 에 따라 적당한 timeout 을 결정해서 리턴한다.
	// periodic processing 이 필요 없는 state에서는 wait_forever 를 리턴.
	//

	return PSIM_WAIT_FOREVER; // wait forever

}

void PSIE_DoPeridicProcessing(S_PSIM_CONTEXT *pContext)
{
	// this task is stateless and don't have periodic processing.

	//CheckPmtTimeout();
}

/*

*/
S_PSIM_CONTEXT *PSIE_GetEngine(void)
{
	return g_psi_engine;
}



#if COMMENT
____Init____(){}
#endif

void PSIE_DumpTsPort(int index);

static DHL_SymbolTable __symbols[] =
{
	//---- func
	DHL_FNC_SYM_ENTRY2("psi_list", PSIDB_PrintAllTables),
	DHL_FNC_SYM_ENTRY2("psi_port", PSIE_DumpTsPort),
	DHL_FNC_SYM_ENTRY2("psi_delete", DMW_PSI_DeleteTables),
	
	//---- vars
	DHL_VAR_SYM_ENTRY(g_Trace_bPsiEvent),
	DHL_VAR_SYM_ENTRY(g_Trace_bPsiSttInfo),
	//DHL_VAR_SYM_ENTRY(g_Trace_PsiEngine),
};


/*
	psi scan engine을 초기화 한다.
*/
S_PSIM_CONTEXT *PSIE_InitEngine(void)
{
	S_PSIM_CONTEXT *pContext;
	S_PSIM_PORT *tsport;
	int i;

	dprint(2, "%s:\n", __FUNCTION__);
	
	// allow multiple init trying..
	// but we don't guarantee race condition. just for testing.
	if (g_psi_engine && g_psi_engine->magic == PSI_ENGINE_MAGICKEY	) 
	{
		dprint(0, "already inited\n");
		return g_psi_engine;
	}

	DHL_DBG_RegisterSymbols(__symbols, DHL_NUMSYMBOLS(__symbols));
	
	pContext = DHL_OS_Malloc(sizeof(S_PSIM_CONTEXT));
	if (!pContext)
		return NULL;

	pContext->magic = PSI_ENGINE_MAGICKEY;
	pContext->state = ePSIM_MODULE_STATE_Init;

	tsport = pContext->tsport;
	
	for (i=0; i<MAX_TS_INPUT; i++) 
	{
		memset(&tsport[i], 0, sizeof(S_PSIM_PORT));
		
		// do any other initializations..
		tsport[i].max_monitors = MAX_FILTERS_PER_PORT;
	}

	dprint(2, "module context: %x\n", pContext);

	g_psi_engine = pContext;
	
	return pContext;
	
}



#if COMMENT
____Test____(){}
#endif

/*
	지정한 tsport 내부 정보 출력..
	테스트 용도로만 사용할 것!
*/
#define OS_DbgPrintf DHL_OS_Printf

void PSIE_DumpTsPort(int index)
{
	int i;
	S_PSIM_PORT *tsport;
	S_PSIM_CONTEXT *pContext = PSIE_GetEngine();

	if (pContext == NULL) return;

	if (index < 0 || index >= MAX_TS_INPUT) {
		dprint(0, "!! invalid port index %d\n", index);
		return;
	}

	tsport = &pContext->tsport[index];

	OS_DbgPrintf("tsport [%d]:\n", index);
	OS_DbgPrintf("  tsd: 0x%x\n", tsport->tsd);
	OS_DbgPrintf("  input rf %d, # %d, sid %d, flags 0x%x, proc %x, param %x\n", 
		tsport->input.rf, tsport->input.program_number, tsport->input.source_id,
		tsport->input.flags, tsport->input.userproc, tsport->input.userparam);

	OS_DbgPrintf("  # of active monitors %d / max %d\n", 
		tsport->n_active_monitors, tsport->max_monitors);

	OS_DbgPrintf("  -- psictls --\n");
	OS_DbgPrintf("  pat %x, # pgm %d\n", tsport->patPsiCtl, tsport->num_programs);
	for (i=0; i<tsport->num_programs; i++)
		OS_DbgPrintf("    (%d) pmt %x\n", i, tsport->pmtPsiCtlArray[i]);

	OS_DbgPrintf("  mgt %x, stt %x, tvct %x, cvct %x, rrt %x, eas %x\n",
		tsport->mgtPsiCtl, tsport->sttPsiCtl, tsport->tvctPsiCtl, tsport->cvctPsiCtl, 
		tsport->rrtPsiCtl, tsport->easPsiCtl);

	OS_DbgPrintf("  source id %d\n", tsport->source_id);
	OS_DbgPrintf("  eits %x %x %x %x..\n", 
		tsport->eitPsiCtl[0], tsport->eitPsiCtl[1], tsport->eitPsiCtl[2], tsport->eitPsiCtl[3]);
	OS_DbgPrintf("  etts %x %x %x %x..\n", 
		tsport->ettPsiCtl[0], tsport->ettPsiCtl[1], tsport->ettPsiCtl[2], tsport->ettPsiCtl[3]);
	OS_DbgPrintf("  ett-v %x\n", tsport->ettvPsiCtl);

}


/* End of file */