/*
	DMW_PsiDatabase.c

	DST TV MW PSI Scan Module

	PSI Database management implementation

	Copyright 2006~2009 Digital STREAM Technology, Inc.
	All Rights Reserved

*/


#include "DMW_Platform.h"

#include "DMW_PsiUtil.h"
#include "DMW_PsiDatabase.h"
#include "DMW_PsiEngine.h"
#include "DMW_PsiLinkedList.h"

#include "DMW_PsiAPI.h"


// additional headers
#include "DMW_Mutex.h"
#include "DMW_CodeConv.h"





#if COMMENT
____DbgPrint____(){}
#endif


DHL_MODULE("psidb", 1);



#if COMMENT
____Config____(){}
#endif


int gPsiDontDownloadChannelEtt = 0;
	// 실제 필드에서 Channel ETT같은 경우는 Mgt에 등록은 되어 있으면서 실제로는 없는 경우가 있다.
	// 그래서 테/스/트/로 이를 막아버리는 옵션을 두었음.
	// 그러나 이 옵션을 실제 양산 프로그램에 적용하기는 어렵다..



int gPsiReloadAllTableAtMgtChange = 0;
	// Mgt check루틴이 문제가 있을 경우 이것을 1로 해서 무조건 다시 받도록 하는 옵션..
	// 이 옵션을 쓰면 잘못된 PSIP에 대해 좀 더 안전하게 대응이 가능하기는 하다..
	// 대신 다시 모든 table을 받아야 하므로 시간은 더 걸릴것임..
	// 제대로 하려면 FALSE 이어야 함.
	// 테스트 결과 이 옵션이 없이도 대체로 잘 동작하는 것 같아서 막아둠..


int gPsiFakeMgtVersionChange = 0;
	// mgt가 버전이 바뀐것처럼 흉내내는 테스트 플래그.. 
	// TRUE이면 매번 mgt 이하 모든 테이블을 다시 받으므로 사용 주의!!!

int gPsiInterTableCompareInMgtChange = 1;
	// 이 값이 TRUE 이면 Mgt version change 시에 서로 다른 index 간의 Eit/Ett table들을
	// 비교해보아서 최대한 재사용을 한다.
	// 예를 들어 이전 mgt의 Eit-3 과 새 mgt의 Eit-2 가 버전과 table 크기가 같으면 이를
	// 재사용을 한다.
	// 그런데 Spec에 의하면 이 값은 0이 되어야 한다. (A/65)
	// 어디까지나 이것은 방송사 PSIP generation program의 동작에 따라 유용할수도, 없을 수도 있다.
	// 그러나 1이라면 Sarnoff 예제와 같이 Eit shift하는 경우 좋은 성능을 보일 수 있다.
	// 대체로 완전히 서로 다른 테이블이 버전도 같고, table size도 같을 경우가 흔하지 않으므로 
	// 일단 TRUE로 해서 테스트를 하고 있음..
	// 문제가 되면 0으로 설정하기 바람.

int gPsiDeleteEttsWhenEitChange = 1;
	// Eit가 바뀔경우 그에 해당하는 Ett를 무조건 지우는 플래그
	// 보통은 Ett도 버전 체크를 해서 변경되었다고 판단되는 경우에만 지우는게 좋겠다.
	// PSIP 표준에 의하면 내용이 바뀌면 반드시 버전도 바뀔 것이므로
	// 무조건 지우지 않아도 버전 체크 루틴에서 판단하여 필요하면 다시 받을 것이다.

int gPsiMaxEitEttIndexToReceive = 127;
	// 
	// Eit/Ett를 모두 다 받을 필요가 없는 시스템이 있는데, 
	// 그런 경우 최대 Index를 지정해 놓으면 필요한 만큼만 받게 된다.
	// 127 이면 모두 다 받는 것이고,
	// -1로 지정하면 Eit/Ett는 하나도 받지 않는다..
	//
	// 0 부터 127 까지 임의의 수를 지정 할 수 있다. 단 Runtime 중에는 변경되지 않도록 하자.


int gPsiSkipCheckVersionMatchMgtAndEit = 0;
int gPsiSkipCheckVersionMatchMgtAndEtt = 0;
	//
	// mgt에서 기술하고 있는 Eit의 version 번호와 실제 Eit의 version 번호가
	// 일치하는지 체크하는 코드를 skip.
	// 부작용이 있을 수 있음.
	// mgt version이 변경되면서 실제로 eit version은 변경되지 않았더라도
	// eit를 다시 다운로드 받게 됨.
	// ORION의 여러 스트림들을 테스트 하려면 이 flag 필요.



#if COMMENT
____DB____(){}
#endif


#if DMW_EPG_SUPPORT_RRT

	extern rrtSectionPtr_t g_EpgRrt;
		// 수신한 rrt

	extern UINT32 g_EpgRrtUpdateCount;
		// rrt가 update 될 때 마다 증가하는 counter
	
	extern int g_EpgRrtForceUpdateMode;
		// force update mode:
		// 이미 수신되어 있는 rrt version에 관계없이 무조건 rrt를 다시 받는 모드.
		// 내부 state variable 이며,
		// menu에서 사용자가 "rrt update" 기능을 선택하면 이 flag가 set되고
		// rrt를 1회 update하면 자동으로 reset 된다.
	
#endif



#if COMMENT
____Mutex____(){}
#endif


//===========================================================================
//
//   Mutex Service
//

//   Mutex = { SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag,        traceLvl }
//
DMW_MUTEX 
   g_MutexPsiDB = { 0,     0,     0,       0,       TRUE,  "PSI", OS_SEM_PRIO, FALSE, };
			// cafrii 050701 change UseOsMutex param to TRUE
			// ThreadX에서는 OS mutex가 안전하기 때문에 디버깅 편의상 OS Mutex를 사용한다.

   // g_EpgDB --> ChannelInfo, SubChannelInfo 데이터를 보호하는데 사용되는 mutex semaphore
   //
   // Rule 1:
   //     EPG Scan Task 에서는 EpgDB는 아무때나 마음데로 읽을 수 있다.
   //     EPG Scan Task 에서 EpgDB를 수정 (write) 할 경우에는 Mutex Lock을 해야 한다.
   //
   // Rule 2:
   //     임의의 Task 에서는 EpgDB를 절대 수정 할 수 없다.
   //     임의의 Task 에서 EpgDB를 읽으려면 Mutex Lock 상태에서 읽어야 한다.
   // 


PSI_STATIC void LockPsiDB(BOOL bLock)
{
	if (bLock)
		DMW_LockMutex(&g_MutexPsiDB);
	else
		DMW_UnlockMutex(&g_MutexPsiDB);
}

#if 0
void DeletePsiDBMutex(void)
{
	DMW_DeleteMutex(&g_MutexPsiDB);
}
#endif








#if COMMENT
____Get_API____(){}
#endif


PSI_STATIC S_PSIM_SUBCHINFO *GetSubChInfo(int id, int source_id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	int i;

	if (!chInfo) return NULL;

	if (chInfo->n_subchannel == 0 || chInfo->subchannel == NULL) return NULL;

	for (i=0; i<chInfo->n_subchannel; i++) {
		if (chInfo->subchannel[i].source_id == source_id)
			return &chInfo->subchannel[i];
	}
	return NULL;
}

/*
	database lock은 하지 않으므로, caller가 주의해서 사용할 것.
*/
MPEG_PAT *PSIDB_GetPAT(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return chInfo ? chInfo->pat : NULL;
}

MPEG_PMT **PSIDB_GetPMTs(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return chInfo ? chInfo->pmts : NULL;
}

mgtSectionPtr_t PSIDB_GetMgt(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return chInfo ? chInfo->mgt : NULL;
}

xvctPtr_t PSIDB_GetVct(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return chInfo ? chInfo->vct : NULL;
}

sttSectionPtr_t PSIDB_GetStt(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return (chInfo && chInfo->stt_valid) ? &chInfo->flat_stt : NULL;
}

eitPtr_t *PSIDB_GetEits(int id, int source_id)
{
	S_PSIM_SUBCHINFO *subchInfo = GetSubChInfo(id, source_id);

	return subchInfo ? subchInfo->eits : NULL;
}

eitPtr_t PSIDB_GetEit(int id, int source_id, int iEit)
{
	eitPtr_t *eits;
	if (iEit<0 || iEit>=128) return NULL;

	eits = PSIDB_GetEits(id, source_id);
	return eits ? eits[iEit] : NULL;
}

S_PSIM_MGT_DIGEST *PSIDB_GetMgtDigest(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	return chInfo ? &chInfo->smgt : NULL;
}


#if COMMENT
____Check____(){}
#endif


/*
	check that all pmts (and pat) are received.

*/
BOOL PSIDB_IsPmtsCompleted(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	int i;
	BOOL bPmtComplete = TRUE;

	if (!chInfo) return FALSE;
	if (!chInfo->pat || !chInfo->pmts) return FALSE;
	
	for (i=0; i<chInfo->pat->numPrograms; i++) {
		if (chInfo->pmts[i] == NULL) {
			bPmtComplete = FALSE;
			break;
		}
	}
	return bPmtComplete;
}

/*
	check that subchannel scan is ready to start.

	both mgt and vct is required.
*/
BOOL PSIDB_IsSubChScanReadyToStart(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);

	if (!chInfo) return FALSE;
	return (chInfo->mgt && chInfo->vct) ? TRUE : FALSE;
}


/*
	해당 subchannel (@id, @source_id)의 모든 EIT가 수신되었는지 검사.
	complete 되었다면 TRUE 리턴.
	
	return true if all eits in the specified subchannel (with @source_id)
	are received.
*/
BOOL PSIDB_IsSubChEitsCompleted(int id, int source_id)
{
	int i, maxEitIndex;
	BOOL bEitsCompleted = FALSE;

	S_PSIM_SUBCHINFO *subchInfo;
	S_PSIM_CHINFO *chInfo;

	S_PSIM_MGT_DIGEST *smgt;
	
	subchInfo = PSIDB_GetPsiSubChInfo(id, source_id);
	if (!subchInfo) goto label_end;
	
	chInfo = subchInfo->parent;
	if (!chInfo) goto label_end;

	smgt = &chInfo->smgt;

	maxEitIndex = min(127, gPsiMaxEitEttIndexToReceive);

	for (i=0; i<=maxEitIndex; i++)
	{
		if (smgt->eit_pids[i] == 0) continue; // no such eit[i].

		if (subchInfo->eits[i] == NULL) {
			dprint(2, " eit-%d not received..\n", i);
			goto label_end;
		}
		if (smgt->eit_ver[i] != subchInfo->eits[i]->version_number) {
			if (gPsiSkipCheckVersionMatchMgtAndEit)
				dprint(1, "!! eit-%d (ver %d) version mismatch (mgt's %d), but continue\n", i, 
						subchInfo->eits[i]->version_number, smgt->eit_ver[i]);
			else {
				dprint(0, "!! eit-%d (ver %d) version mismatch (mgt's %d)\n", i, 
						subchInfo->eits[i]->version_number, smgt->eit_ver[i]);
				goto label_end; // need to receive again..
			}
		}
	}
	bEitsCompleted = TRUE;

label_end:
	return bEitsCompleted;

}


/*
	check eit[@iEit] of all subch received or not.
	if all received, return true.
	if it returns true, caller will close eit psi filter.
	it is used for autoscan mode.

	if status is not correct, return false.
*/
BOOL PSIDB_IsAllSubChEitsCompleted(int id, int iEit)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	int i;

	if (iEit < 0 || iEit >= 128) return FALSE;
	
	if (!chInfo) return FALSE;

	if (chInfo->n_subchannel == 0 || chInfo->subchannel == NULL) return FALSE;

	for (i=0; i<chInfo->n_subchannel; i++) {
		if (chInfo->subchannel[i].eits[iEit] == NULL) return FALSE;
	}
	return TRUE;
}

/*
	PSIDB_IsSubChEttVRequired
	
	특정 subchannel (@id, @source_id)의 channel_ett가 수신되어야 하는지를 검사.
	수신되어야 한다면 true 리턴.

	주의! channel_ett가 받아졌는지를 체크하는 것이 아니라 받아야 하는지를 체크.
*/
BOOL PSIDB_IsSubChEttVRequired(int id, int source_id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);

	BOOL bEttvRequired = FALSE;
	int i;
	int ettv_etm_loc = -1;
	
	if (chInfo->vct && chInfo->vct->channel) {
		for (i=0; i<chInfo->vct->numChannels; i++) {
			if (chInfo->vct->channel[i].source_id == source_id) {
				ettv_etm_loc = chInfo->vct->channel[i].ETM_location;
				break;
			}
		}
	}

	if (ettv_etm_loc == -1) { 
		dprint(0, "!! vct invalid! cannot find source_id %d\n", source_id);
	}
	else if (chInfo->smgt.channel_ett_pid &&          // MGT에 channel ETT가 등록이 되어 있고,
			gPsiDontDownloadChannelEtt == FALSE &&  // 테스트 조건이 아니면서,
			(ettv_etm_loc == ETM_in_this_PTC || ettv_etm_loc == ETM_in_channel_TSID_PTC))  // ETT가 있다고 등록되어 있으면,
	{
		bEttvRequired = TRUE;
	}
#if 0 // IgnoreEtmLocationInfo option은 psi engine module 에서만 사용하도록 하자.
	else if (chInfo->smgt.channel_ett_pid &&
			gPsiDontDownloadChannelEtt == FALSE &&
			gPsiIgnoreEtmLocationInfo)  // ettv_etm_loc의 값에 관계없이 (ETM_none 포함) 무조건 받는 옵션
	{
		bEttvRequired = TRUE;
	}
#endif

	return bEttvRequired;
}


/*
	PSIDB_IsSubChEttSlotCompleted

	지정한 subchannel의 특정 time slot (iEit)의 모든 Eit/Ett 가 수신 완료 되었는지를 체크한다.

	return true if all etts in the specified subchannel (with @source_id)
	are received.
*/
BOOL PSIDB_IsSubChEttSlotCompleted(int id, int source_id, int iEit)
{
	// 이 함수는 Eit 가 모두 완료된 상태에서만 그 의미가 있다.
	// Eit가 없이 Ett를 수신할 수는 없기 때문...
	// Eit가 없으면 FALSE 리턴..  Ett가 없어도 FALSE 리턴..  Eit/Ett 모두 있으면 TRUE 리턴..
	//
	int k; //, maxEttIndex;
	int n_etm;  // number of etm in one eit instance.
	BOOL bEttsCompleted = FALSE;
	
	S_PSIM_SUBCHINFO *subchInfo;
	S_PSIM_CHINFO *chInfo;

	S_PSIM_MGT_DIGEST *smgt;

	subchInfo = PSIDB_GetPsiSubChInfo(id, source_id);
	if (!subchInfo) goto label_end;
	
	chInfo = subchInfo->parent;
	if (!chInfo) goto label_end;

	// get mgt digest info
	smgt = &chInfo->smgt;

	if (iEit == 128) {
		if (!PSIDB_IsSubChEttVRequired(id, source_id) || subchInfo->channel_ett)
			bEttsCompleted = TRUE;
		goto label_end;
	}
	if (iEit < 0 || iEit >= 128) { // invalid index..
		goto label_end;
	}
	
	do
	{
		//---------- 먼저 eit 유효성 부터 체크 -----------
		
		if (smgt->eit_pids[iEit] == 0) continue; // 존재하지 않는 EIT

		if (subchInfo->eits[iEit] == NULL) {
			dprint(2, " Eit-%d not received..\n", iEit);
			goto label_end;
		}
		if (smgt->eit_ver[iEit] != subchInfo->eits[iEit]->version_number) {
			if (gPsiSkipCheckVersionMatchMgtAndEit)
				dprint(1, "!! eit-%d (ver %d) version mismatch (mgt's %d) but continue\n", iEit, 
						subchInfo->eits[iEit]->version_number, smgt->eit_ver[iEit]);
			else {
				dprint(0, "!! eit-%d (ver %d) version mismatch (mgt's %d)\n", iEit, 
						subchInfo->eits[iEit]->version_number, smgt->eit_ver[iEit]);
				goto label_end; // need to receive again..
			}
		}
		if (subchInfo->eits[iEit]->event == NULL) 
			continue; // 비었는 eit이면?  ETT가 있을 수가 없을 것이다.. 다음 eit 체크..

		//---------- ett 유효성 체크 -----------

		if (smgt->ett_pids[iEit] == 0) continue;  // ETT가 없다면 다음..

		for (k=0, n_etm=0; k<subchInfo->eits[iEit]->numEvents; k++) {
			if (subchInfo->eits[iEit]->event[k].ETM_location != ETM_none)
				n_etm++;  // 이 EIT에 관련된 ETT 갯수..
		}
		if (n_etm <= 0) continue;  // 원래 ETT 없음..
		
		if (subchInfo->etts[iEit] == NULL || subchInfo->n_ett[iEit] == 0) {
			dprint(2, " eit[%d] exist, but etts array NULL or n_ett 0 %d\n", iEit, subchInfo->n_ett[iEit]);
			goto label_end;
		}
		if (subchInfo->eits[iEit]->numEvents != subchInfo->n_ett[iEit]) {
			dprint(2, " num event %d != n_ett %d\n", subchInfo->eits[iEit]->numEvents, subchInfo->n_ett[iEit]);
			goto label_end;
		}
		
		//---------- ett 각 event 별 체크 -----------

		for (k=0; k<subchInfo->n_ett[iEit]; k++) 
		{
			BOOL bSkipThisEtt = FALSE; 
			UINT32 etmid = PSIUTIL_MakeEventETMID(subchInfo->source_id, subchInfo->eits[iEit]->event[k].event_id);

			int ii, kk;
			
			if (subchInfo->etts[iEit][k] && subchInfo->etts[iEit][k]->ETM_id == etmid)
				continue;  // 수신되었음.. 다음..

			// 꼭 이 Eit PID에만 아니라 그 이전 Eit들의 PID에도 존재할 경우가 있다..
			// 3-hour 경계에 걸쳐 있는 event의 경우 앞쪽 event의 PID에 ett가 있을 수 있다.
			// 그러므로 현재 Ett table pointer가 NULL 이라고 해서 바로 FALSE 처리하면 안된다.
			// 앞의 모든 table들을 찾아봐야 한다.
			//
			for (ii=iEit; ii>=0; ii--) {  // 현재 Etts[iEit]부터  Etts[0] 까지 앞으로 되돌아가면서,
				if (subchInfo->etts[ii] == NULL) continue;
				// 각 Ett section을 검사해서 현재 받으려고 하는 etm_id의 ett가 받아져 있는지 검사한다.
				for (kk=0; kk<subchInfo->n_ett[ii]; kk++) {
					if (subchInfo->etts[ii][kk] && subchInfo->etts[ii][kk]->ETM_id == etmid) {
						// 같은 etm_id를 가진 Ett가 이미 수신되어 있다면, 받을 필요 없다.
						dprint(3, "  Ett-%d[ev %d]: same etmid 0x%x (ett-%d ev%d pid %d) exist. \n", 
							iEit, k, etmid, ii, kk, smgt->ett_pids[ii]);
						bSkipThisEtt = TRUE;
						break;
					}
				}
				if (bSkipThisEtt) break;
			}
			if (bSkipThisEtt)
				continue;
			
			if (subchInfo->eits[iEit]->event[k].ETM_location != ETM_none && 
				subchInfo->etts[iEit][k] == NULL) {
				dprint(2, "  ett-%d[ev %d] etm_loc %d, but ett NULL\n", 
						iEit, k, subchInfo->eits[iEit]->event[k].ETM_location);
				goto label_end;		
			}
		}

	} while (0);
	
	bEttsCompleted = TRUE;  // OK.. All eits are completed.	

label_end:

	return bEttsCompleted;
	
}


/*
	PSIDB_IsSubChAllEttsCompleted

	지정한 subchannel의 모든 Eit/Ett 가 수신 완료 되었는지를 체크한다.

	이 함수는 channel ett 의 수신 여부를 체크할 때 미리 계산된 boolean flag를 사용하기 때문에
	해당 subchannel에 대해서 update etts 함수가 먼저 불린 다음에만 사용되어야 한다.
	즉 사용 시점에 주의를 요한다.

	return true if all etts in the specified subchannel (with @source_id)
	are received.
*/
BOOL PSIDB_IsSubChAllEttsCompleted(int id, int source_id)
{
	// 이 함수는 Eit 가 모두 완료된 상태에서만 그 의미가 있다.
	// Eit가 없이 Ett를 수신할 수는 없기 때문...
	// Eit가 없으면 FALSE 리턴..  Ett가 없어도 FALSE 리턴..  Eit/Ett 모두 있으면 TRUE 리턴..
	//
	int i, k, maxEttIndex;
	int n_etm;  // number of etm in one eit instance.
	BOOL bEttsCompleted = FALSE;
	
	S_PSIM_SUBCHINFO *subchInfo;
	S_PSIM_CHINFO *chInfo;

	S_PSIM_MGT_DIGEST *smgt;

	// 임의 task에서도 사용할 수 있는 용도를 고려할 필요는 없을 듯 함.
	//if (PSITASK_IsPsiTask())
	//	PSIDB_LockDB(TRUE);  //-------------------------

	subchInfo = PSIDB_GetPsiSubChInfo(id, source_id);
	if (!subchInfo) goto label_end;
	
	chInfo = subchInfo->parent;
	if (!chInfo) goto label_end;

	// get mgt digest info
	smgt = &chInfo->smgt;

	if (PSIDB_IsSubChEttVRequired(id, source_id) && subchInfo->channel_ett == NULL)
		goto label_end;  // ett-v 가 수신되어야 하는데 아직 수신이 안되었으므로 FALSE..

	maxEttIndex = min(127, gPsiMaxEitEttIndexToReceive);   // cafrii 041202 add

	for (i=0; i<=maxEttIndex; i++) 
	{
		if (smgt->eit_pids[i] == 0) continue; // 존재하지 않는 EIT

		if (subchInfo->eits[i] == NULL) {
			dprint(2, " Eit-%d not received..\n", i);
			goto label_end;
		}
		if (smgt->eit_ver[i] != subchInfo->eits[i]->version_number) {
			if (gPsiSkipCheckVersionMatchMgtAndEit)
				dprint(1, "!! eit-%d (ver %d) version mismatch (mgt's %d) but continue\n", i, 
						subchInfo->eits[i]->version_number, smgt->eit_ver[i]);
			else {
				dprint(0, "!! eit-%d (ver %d) version mismatch (mgt's %d)\n", i, 
						subchInfo->eits[i]->version_number, smgt->eit_ver[i]);
				goto label_end; // need to receive again..
			}
		}
		if (subchInfo->eits[i]->event == NULL) 
			continue; // 비었는 eit이면?  ETT가 있을 수가 없을 것이다.. 다음 eit 체크..

		if (smgt->ett_pids[i] == 0) continue;  // ETT가 없다면 다음..

		for (k=0, n_etm=0; k<subchInfo->eits[i]->numEvents; k++) {
			if (subchInfo->eits[i]->event[k].ETM_location != ETM_none)
				n_etm++;  // 이 EIT에 관련된 ETT 갯수..
		}
		if (n_etm <= 0) continue;  // 원래 ETT 없음..
		
		if (subchInfo->etts[i] == NULL || subchInfo->n_ett[i] == 0) {
			dprint(2, " eit[%d] exist, but etts array NULL or n_ett 0 %d\n", i, subchInfo->n_ett[i]);
			goto label_end;
		}
		if (subchInfo->eits[i]->numEvents != subchInfo->n_ett[i]) {
			dprint(2, " num event %d != n_ett %d\n", subchInfo->eits[i]->numEvents, subchInfo->n_ett[i]);
			goto label_end;
		}
		
		for (k=0; k<subchInfo->n_ett[i]; k++) 
		{
			BOOL bSkipThisEtt = FALSE; 
			UINT32 etmid = PSIUTIL_MakeEventETMID(subchInfo->source_id, subchInfo->eits[i]->event[k].event_id);

			int ii, kk;
			
			if (subchInfo->etts[i][k] && subchInfo->etts[i][k]->ETM_id == etmid)
				continue;  // 수신되었음.. 다음..

			// 꼭 이 Eit PID에만 아니라 그 이전 Eit들의 PID에도 존재할 경우가 있다..
			// 3-hour 경계에 걸쳐 있는 event의 경우 앞쪽 event의 PID에 ett가 있을 수 있다.
			// 그러므로 현재 Ett table pointer가 NULL 이라고 해서 바로 FALSE 처리하면 안된다.
			// 앞의 모든 table들을 찾아봐야 한다.
			//
			for (ii=i; ii>=0; ii--) {  // 현재 Etts[i]부터  Etts[0] 까지 앞으로 되돌아가면서,
				if (subchInfo->etts[ii] == NULL) continue;
				// 각 Ett section을 검사해서 현재 받으려고 하는 etm_id의 ett가 받아져 있는지 검사한다.
				for (kk=0; kk<subchInfo->n_ett[ii]; kk++) {
					if (subchInfo->etts[ii][kk] && subchInfo->etts[ii][kk]->ETM_id == etmid) {
						// 같은 etm_id를 가진 Ett가 이미 수신되어 있다면, 받을 필요 없다.
						dprint(3, " Ett-%d[ev %d]: same etmid 0x%x (ett-%d ev%d pid %d) exist. \n", 
							i, k, etmid, ii, kk, smgt->ett_pids[ii]);
						bSkipThisEtt = TRUE;
						break;
					}
				}
				if (bSkipThisEtt) break;
			}
			if (bSkipThisEtt)
				continue;
			
			if (subchInfo->eits[i]->event[k].ETM_location != ETM_none && 
				subchInfo->etts[i][k] == NULL) {
				dprint(2, " ett-%d[ev %d] etm_loc %d, but ett NULL\n", 
						i, k, subchInfo->eits[i]->event[k].ETM_location);
				goto label_end;		
			}
		}
		
	}
	
	bEttsCompleted = TRUE;  // OK.. All eits are completed.	

label_end:
	//if (PSITASK_IsPsiTask())
	//	PSIDB_LockDB(FALSE);  //-------------------------

	return bEttsCompleted;
	
}



#if COMMENT
____Free____(){}
#endif

//
// note!! below PSIDB_FreeXXX don't care mutex lock. caller should lock.
//


/*
	eit[iEit]와 연관된 모든 ett들, 그리고 그것들과 관련 data structure를 제거한다.

	최대 eit[iEit]->numEvents 만큼의 ett들, 그리고 이 ett들을 담고 있는 ett array를 free함.

	channel ett는 해당 사항 없음. 일반 event ett만 삭제한다.
*/
void PSIDB_FreeEtts(S_PSIM_SUBCHINFO *subchInfo, int iEit)
{
	// subchInfo는 Non-NULL, i는 0 ~ 128-1 사이의 값이어야 한다.
	int k;

	if (subchInfo == 0 || iEit < 0 || iEit >= 128)
		return;
	
	if (subchInfo->etts[iEit] == NULL) { // it is already freed.
		subchInfo->n_ett[iEit] = 0;
		return;
	}
	
	// ett 모두 삭제
	for (k=0; k<subchInfo->n_ett[iEit]; k++)
		PSIUTIL_FreeTable(&subchInfo->etts[iEit][k]);
		
	// ett container 삭제
	DHL_OS_Free((void **)&subchInfo->etts[iEit]);
	subchInfo->n_ett[iEit] = 0;
}

/*
	eit[iEit]를 포함하여 관련된 모든 ett들과 data structure를 제거한다.

*/
void PSIDB_FreeEitAndRelatedEtts(S_PSIM_SUBCHINFO *subchInfo, int iEit)
{
	// subchInfo는 Non-NULL, i는 0 ~ 128-1 사이의 값이어야 한다.
	int k;

	if (subchInfo == NULL || iEit < 0 || iEit >= 128)
		return;       // invalid argument error
	
	if (subchInfo->etts[iEit] == NULL) {
		subchInfo->n_ett[iEit] = 0;
	}
	else {
		// ett 모두 삭제
		for (k=0; k<subchInfo->n_ett[iEit]; k++)
			PSIUTIL_FreeTable(&subchInfo->etts[iEit][k]);
	
		// ett container 삭제
		DHL_OS_Free((void **)&subchInfo->etts[iEit]);
		subchInfo->n_ett[iEit] = 0;
	}

	// eit 삭제
	PSIUTIL_FreeTable(&subchInfo->eits[iEit]);

}

/*
	subchannel내의 모든 정보를 free한다.
	subchInfo 구조체 자체는 free 하지 않음.
*/
void PSIDB_FreeSubChInfo(S_PSIM_SUBCHINFO *subchInfo)
{
	// subchannel info 모든 정보를 삭제한다.
	int j, k;
	
	if (subchInfo == NULL) return;

	// todo.. inactive subch의 경우 이 함수가 불리는가?
	if (subchInfo->active == 0) return;

	if (subchInfo->channel_ett) {
		dprint(2, "  delete ett-v.. \n");
		PSIUTIL_FreeTable(&subchInfo->channel_ett);
	}

#if 0
	for (k=0; k<128; k++)
		PSIDB_FreeEitAndRelatedEtts(subchInfo, k);
#else
	// 어떤 table들이 지워지는지 debug print를 위해 재 작성..
	// free etts
	for (k=0; k<128; k++) {
		if (subchInfo->etts[k] == NULL) continue; // No ETTs here..
		for (j=0; j<subchInfo->n_ett[k]; j++) {
			if (subchInfo->etts[k][j]) {
				dprint(3, "   ett[%d][%d]: %x\n", k, j, subchInfo->etts[k][j]);
				PSIUTIL_FreeTable(&subchInfo->etts[k][j]);
			}
		}
		DHL_OS_Free((void **)&subchInfo->etts[k]); // ett container 삭제
		subchInfo->n_ett[k] = 0;
	}
	
	// free eits
	for (k=0; k<128; k++) {
		if (subchInfo->eits[k] == NULL) continue;
		dprint(3, "    eit[%d]: %x\n", k, subchInfo->eits[k]);
		PSIUTIL_FreeTable(&subchInfo->eits[k]);
	}
#endif
	
	//DHL_OS_Free((void **)&(subchInfo->eits)); // 이것은 동적할당된 것이 아님!!
	
	subchInfo->active = FALSE;
}

void PSIDB_FreeChInfo(S_PSIM_CHINFO *chInfo)
{
	int i;
	
	if (chInfo == NULL) return;

	if (chInfo->subchannel) 
	{
		//dprint(2, "  total %d subchannels..\n", chInfo->n_subchannel);
		for (i=0; i<chInfo->n_subchannel; i++)  {
			//dprint(2, "  delete subchannel[%d] data..\n", i);
			PSIDB_FreeSubChInfo(&chInfo->subchannel[i]);
		}
	}
	//dprint(2, "  delete subchannel info itself..\n");
	DHL_OS_Free((void **)&(chInfo->subchannel));

	//dprint(2, "  delete tables in channel..\n");
	//PSIUTIL_FreeTable(&chInfo->tvct);
	//PSIUTIL_FreeTable(&chInfo->cvct);
	PSIUTIL_FreeTable(&chInfo->vct);
	
#if 0
	PSIUTIL_FreeTable(&chInfo->stt); // cafrii 050330, stt changed to flat_stt
#endif
	PSIUTIL_FreeTable(&chInfo->mgt);
	PSIUTIL_FreeTable(&chInfo->mgt_old);

	for (i=0; chInfo->pat && chInfo->pmts && i<chInfo->pat->numPrograms; i++) {
		//dprint(2, "  delete pmt[%d]..\n", i);
		PSIUTIL_FreeTable(&chInfo->pmts[i]);
	}
	//dprint(2, "  delete pat..\n");
	PSIUTIL_FreeTable(&chInfo->pat);

	// do not reset contents!!
	//  we need prev/next link to remove from linked list.
	//---memset(chInfo, 0, sizeof(S_PSIM_CHINFO));
}



#if COMMENT
____Alloc_Remove____(){}
#endif


STATUS PSIDB_AllocateChInfoNode(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	if (chInfo)
		return statusOK;

	chInfo = PSI_NewChInfo(id);
	if (chInfo == NULL)
		return statusOutOfMemory;

	LockPsiDB(TRUE);
	PSI_InsertChInfo(chInfo);
	LockPsiDB(FALSE);

	return statusOK;
}

STATUS PSIDB_RemoveChInfoNode(int id)
{
	S_PSIM_CHINFO *chInfo = PSI_GetChInfo(id);
	if (!chInfo)
		return statusOK; // not exist.

	LockPsiDB(TRUE);
	PSI_RemoveChInfo(chInfo);
	LockPsiDB(FALSE);

	return statusOK;
}



#if COMMENT
____Private____(){}
#endif


/*
	새로 수신된 MGT를 보고, 기존 EpgDB의 Table들을 정리한다.
	새로 받아야 하는 table들이라면 삭제, 재사용이 가능하면 그대로 둔다.

	현재 @chInfo 내에 저장되어 있는 mgt는 old_mgt 이고, 인자로 전달된 @mgt는 새 mgt이다.
*/
PSI_STATIC STATUS CheckAndProcessMgtVersionChange(S_PSIM_CHINFO *chInfo, mgtSectionPtr_t mgt)
{
	// mgt version change 분석..
	// 주의:
	// 이 함수가 불리는 시점은 update 또는 최초 download인 경우인데,
	// 최초로 불리는 경우라면 subchannel 정보가 없을 수도 있으므로 유의한다.
	//
	int i, j, k;
	int offset;   // EIT, ETT들의 shift된 차이.. 
	UINT8 candidate[128];
		// Eit/Ett의 time-shift에 의한 mgt version change의 경우 현재 table의 후보 값이다.
		// 예를 들어 Eit의 경우 candidate[3] == 4 인 경우,
		// 현재 Eit-3 의 후보는 예전 Eit-4 이다.
		// 즉, 현재 mgt의 Eit-3과 예전 mgt의 Eit-4의 version과 byte size가 동일하다는 의미이다.
		// candidate의 디폴트 값은 0xff 로서 이는 후보가 없음을 의미한다.

	S_PSIM_SUBCHINFO *subchInfo;

	mgtTablePtr_t tbl1, tbl2;

	dprint(1, "%s:\n", __FUNCTION__);

	if (chInfo == NULL) return statusInvalidArgument;

	if (chInfo->mgt == NULL) {
		dprint(2, "No Previous mgt..\n");
		return statusOK;
	}
	
	if (chInfo->mgt->version_number == mgt->version_number && !gPsiFakeMgtVersionChange) 
	{
		dprint(2, "MGT version (%d) same.. \n", mgt->version_number);

		// cafrii 050331 
		// 버전 비교 만으로는 안전하지 못할 수 있다.
		// version bit가 적기 때문에 서로 다른 Mgt임에도 불구하고 버전은 같을 수 있기 때문.
		//
		if (PSIUTIL_IsEquivalentMgt(chInfo->mgt, mgt)) 
		{
			// equivalent란 의미는 mgt의 version은 신경쓰지 않고
			// mgt 안의 table들을 하나씩 비교해 봐서 내용이 같은 내용이라는 뜻.
			//dprint(2, "MGTs are equivalent..\n");
			return statusOK;
		}
		else
			dprint(2, "!! MGTs are different while versions are same\n");
	}

	
	// Basic Rule:
	// 1. 기존 테이블 정보가 없었으면 당연히 무조건 받아야 한다. 
	//    (혹시 정보도 없이 table은 있을 수도 있으므로 이 경우 기존 테이블은 삭제해버리자)
	//
	// 2. 기존 테이블 버전과 새 테이블 버전이 다르면, 기존 테이블이 이미 수신되어 있는 상황이라도
	//    기존 테이블을 삭제하고 다시 받는다. (물론 기존 테이블은 시간제한으로 못 받아서 없을 수도 있다)
	//
	// 3. 기존 테이블 버전과 새 테이블 버전이 같으면 기존 테이블이 없는 경우에만 추가하여 받는다.
	// 
	
	dprint(2, "MGT version changed  %d -> %d.. analyzing..\n", chInfo->mgt->version_number, mgt->version_number);
	dprint(2, "  old mgt : 0x%x,  new mgt : 0x%x\n", chInfo->mgt, mgt);

	PSIUTIL_ComparePrintTwoMgts(chInfo->mgt, mgt, 3);

	// 이 시점부터 이 함수 끝날때까지 모두 DB Lock을 한다.	
	LockPsiDB(TRUE);
	
	// 모든 subchannel에 있는 eit/ett complete flag를 reset 한다..
	
	for (i=0; i<chInfo->n_subchannel; i++) {
		chInfo->subchannel[i].eit_complete = FALSE;
		chInfo->subchannel[i].ett_complete = FALSE;
	}
	
	if (gPsiReloadAllTableAtMgtChange) // mgt 버전이 바뀌면 항상 모든 테이블을 다시 받는 안전한 모드..
	{
		dprint(2, "## Policy1: Reload all tables at mgt version change\n");

		if (chInfo->subchannel) // subchannel 정보가 없을 수도 있으므로 항상 체크한다.
		{
			dprint(2, "  total %d subchannels..\n", chInfo->n_subchannel);
			for (i=0; i<chInfo->n_subchannel; i++)  {
				PSIDB_FreeSubChInfo(&chInfo->subchannel[i]);
			}
			dprint(2, "  delete subchannel info..\n"); // subchannel info 그 자체까지 다 지울 필요가 있나? 
			DHL_OS_Free((void **)&(chInfo->subchannel));
		}
		dprint(2, "  delete vct tables in channel..\n");
		PSIUTIL_FreeTable(&chInfo->vct);
	}

	if (chInfo->vct && !chInfo->vct->is_cvct) {
		// ---------- TVCT check
		tbl1 = PSIUTIL_FindTableInMgt(chInfo->mgt, tt_terrestrial_VCT_cni_1);  // 기존 MGT에서 찾고,
		tbl2 = PSIUTIL_FindTableInMgt(mgt, tt_terrestrial_VCT_cni_1);          // 새 MGT에서 찾는다.
		
		if (tbl2 == NULL || tbl1 == NULL)
			//PSIUTIL_FreeTable(&chInfo->tvct);
			PSIUTIL_FreeTable(&chInfo->vct);
		else {
			if (tbl1->table_type_version_number != tbl2->table_type_version_number) {
				dprint(2, "TVCT version changed %d->%d\n", tbl1->table_type_version_number, tbl2->table_type_version_number);
				//PSIUTIL_FreeTable(&chInfo->tvct);
				PSIUTIL_FreeTable(&chInfo->vct);
				// todo..
				// 이때 subchannel info의 내용을 다 지워야 하는가? source_id의 내용이 변경되었는지 체크는?
				// n_subchannel의 갯수가 변경되었는지의 여부??
			}
		}
	}
	else if (chInfo->vct && chInfo->vct->is_cvct) {
		// ----------- CVCT check
		tbl1 = PSIUTIL_FindTableInMgt(chInfo->mgt, tt_cable_VCT_cni_1);
		tbl2 = PSIUTIL_FindTableInMgt(mgt, tt_cable_VCT_cni_1);
		
		if (tbl2 == NULL || tbl1 == NULL)
			//PSIUTIL_FreeTable(&chInfo->cvct);
			PSIUTIL_FreeTable(&chInfo->vct);
		else {
			if (tbl1->table_type_version_number != tbl2->table_type_version_number) {
				dprint(2, "CVCT version changed %d->%d\n", tbl1->table_type_version_number, tbl2->table_type_version_number);
				//PSIUTIL_FreeTable(&chInfo->cvct);
				PSIUTIL_FreeTable(&chInfo->vct);
				// todo..
				// 이때 subchannel info의 내용을 다 지워야 하는가? source_id의 내용이 변경되었는지 체크는?
				// n_subchannel의 갯수가 변경되었는지의 여부??
			}
		}
	}
	
	if (gPsiFakeMgtVersionChange) {
		dprint(2, "******** simulation of mgt version change\n");
		// 마치 mgt version change가 일어난것과 같은 흉내를 낸다. candidate는 하나도 없는 상태로 가정..
		// 
		for (i=0; i<128; i++)
			candidate[i] = 0xff; // 모두 적절한 candidate가 없는 상태..
		offset = 0;
		goto label_move_new_eits;
	}
	
	// ----------- All EIT check
	dprint(2, " check eit version..\n");
	for (i=0; i<128; i++) 
	{
		// EIT의 경우는 3-hour time shift의 경우를 고려하여, PID, version, byte size가 같으면 다른 EIT라 하여도
		// 같은 내용일 수가 있다.
		//
		int search_end;
		candidate[i] = 0xff; // no candidate yet..
		
		tbl2 = PSIUTIL_FindTableInMgt(mgt, tt_EIT_min+i); // 새 MGT에서 EIT-i 정보를 찾는다.
		if (tbl2 == NULL) {
			//dprint(3, "  new EIT-%d not exist..\n", i);
			continue;
		}
		
		if (gPsiInterTableCompareInMgtChange) 
			search_end = min(i+3, 127);  // Eit-i 부터 Eit-(i+3)까지 비교..
		else
			search_end = i;              // 동일한 Eit-i만 비교..
			
		// 기존 MGT에서 새 EIT-i의 정보 (PID, version, bytesize)와 같은 EIT를 찾는다..
		//
		for (k=i; k<=search_end; k++) 
		{
			tbl1 = PSIUTIL_FindTableInMgt(chInfo->mgt, tt_EIT_min+k); // 옛날 MGT에서 EIT-k 정보를 찾는다.
			if (tbl1 == NULL) continue;
			
			if (tbl1->table_type_PID == tbl2->table_type_PID && 
			    tbl1->table_type_version_number == tbl2->table_type_version_number &&
			    tbl1->number_bytes == tbl2->number_bytes) 
			{
				// 일단 모든 정보가 같으므로 이 tbl을 사용할 수 있을것 같다..
				candidate[i] = k;
				dprint(3, "   new Eit-%d same as Eit-%d (PID %x, v%d, %d)\n", 
						i, k, tbl1->table_type_PID, tbl1->table_type_version_number, tbl1->number_bytes);
				break;
			}
		}
		if (candidate[i] == 0xff)
			dprint(3, "   new Eit-%d should be downloaded..\n", i);
	}
	
	// 이제 candidate[i]는 
	//   새 EIT-i가 없다면 0xff
	//   새 EIT-i가 존재하는데 동일한 예전 EIT가 없다면 0xff
	//   새 EIT-i가 존재하고 동일한 예전 EIT-k가 존재한다면 k를 가진다. 
	//   (그러나 EIT-k가 지금 현재 수신되어 있는 상태라는것을 의미하지는 않는다. 단순히 MGT 정보에 의한 값이다.)

	// case 1: 3-hour boundary shift인 경우
	// case 2: 일부 EIT의 내용만 변경된 경우
	//  두 경우 모두 동일한 로직으로 처리 가능하다..
	//
	// 모든 offset들이 동일한지 체크한다. 하나라도 틀리면 모두 무효화 시키자!!
	offset = -1;  // offset default value..
	for (i=0; i<128; i++) 
	{
		if (candidate[i] == 0xff) continue;
		if (offset < 0)
			offset = candidate[i] - i;         // candidate[i]는 반드시 i보다 크거나 같은 값이다.
		else if (offset != (candidate[i] - i))
		{
			dprint(2, "  !! candidate[%d]=%d mismatch with offset %d\n", i, candidate[i], offset);
			dprint(2, "     ignore all candidate offset value..\n");
			for (k=0; k<128; k++) candidate[k] = 0xff; // 모두 무효화...
			break;
		}
	}
	if (offset >= 0)
		dprint(2, " Eit match offset value is %d\n", offset);
	else {
		dprint(2, " No available old tables. offset is set to default 0\n");
		offset = 0; // 일치하는 것이 하나도 없다면..
	}

label_move_new_eits:

	// 이제 candidate가 아닌 EIT는 삭제하고 이동한다..
	for (k=0; chInfo->subchannel && k<chInfo->n_subchannel; k++)
	{
		if (chInfo->subchannel[k].active == 0) continue;
		subchInfo = &chInfo->subchannel[k];
		
		dprint(2, " move eits for subchannel[%d]..\n", k);
		
		for (i=0; i<128; i++) {
			if (candidate[i] == i) {          // same
				dprint(3, "    reuse old Eit-%d\n", i);
			}
			else if (candidate[i] == 0xff) {  // no match
				if (subchInfo->eits[i])
					dprint(3, "    delete old Eit-%d\n", i);
				// Ett까지 다 같이 지울까??
				if (gPsiDeleteEttsWhenEitChange)
					PSIDB_FreeEitAndRelatedEtts(subchInfo, i);
				else
					PSIUTIL_FreeTable(&subchInfo->eits[i]);
			}
			else {                            // match with other eit
				if (subchInfo->eits[i]) {
					dprint(3, "    overwrite old EIT-%d --> EIT-%d\n", candidate[i], i);

					if (gPsiDeleteEttsWhenEitChange) 
						//dprint(3, "      delete old Eit-%d and Ett-%d\n", i, i);
						PSIDB_FreeEitAndRelatedEtts(subchInfo, i);
					else {
						//dprint(3, "      delete old Eit-%d\n", i);
						PSIUTIL_FreeTable(&subchInfo->eits[i]);
					}
					
					subchInfo->eits[i] = subchInfo->eits[candidate[i]];
					subchInfo->eits[candidate[i]] = NULL;  // cafrii add 040713
				}
				else {
					dprint(3, "    move old Eit-%d --> Eit-%d\n", candidate[i], i);
					subchInfo->eits[i] = subchInfo->eits[candidate[i]];
					subchInfo->eits[candidate[i]] = NULL;  // cafrii add 040713
				}
			}
		}
	}
	// ----------- ETT check
	// ETT의 경우는 EIT에서 정해진 offset value를 그대로 사용하도록 한다. 맞지 않는 경우 모두 reload하자.

	if (gPsiInterTableCompareInMgtChange == 0)
		offset = 0;   // inter table compare 모드가 아닌 경우에는 항상 같은 번호의 Ett-j : Ett-k만을 비교해야 한다.
	
	dprint(2, " check ett version..\n");
	for (i=0; i<128; i++) 
	{
		candidate[i] = 0xff; // no candidate yet..
		
		tbl2 = PSIUTIL_FindTableInMgt(mgt, tt_event_ETT_min+i); // 새 MGT에서 EIT-i 정보를 찾는다.
		if (tbl2 == NULL) {
			//dprint(3, "  new ETT-%d not exist..\n", i);
			continue;
		}
		
		tbl1 = PSIUTIL_FindTableInMgt(chInfo->mgt, tt_event_ETT_min+i+offset); // 옛날 MGT에서 ETT-(i+offset) 정보를 찾는다.
		if (tbl1 == NULL) continue;
			
		if (tbl1->table_type_PID == tbl2->table_type_PID && 
		    tbl1->table_type_version_number == tbl2->table_type_version_number &&
		    tbl1->number_bytes == tbl2->number_bytes) 
		{
			// 일단 모든 정보가 같으므로 이 tbl을 사용할 수 있을것 같다..
			candidate[i] = i + offset;
			dprint(3, "   new Ett-%d same as Ett-%d (PID %x, v%d, %d)\n", 
					i, i+offset, tbl1->table_type_PID, tbl1->table_type_version_number, tbl1->number_bytes);
		}
		else {
			dprint(3, "   new Ett-%d should be downloaded..\n", i);
		}
	}

	// 이제 candidate가 아닌 ETT는 삭제하고 이동한다..
	for (k=0; chInfo->subchannel && k<chInfo->n_subchannel; k++)
	{
		if (chInfo->subchannel[k].active == 0) continue;
		subchInfo = &chInfo->subchannel[k];
		
		dprint(2, " move Etts for subchannel[%d]..\n", k);
		
		for (i=0; i<128; i++) {
			if (candidate[i] == i) {          // same
				dprint(3, "    reuse old Ett-%d (%d events)\n", i, subchInfo->n_ett[i]);
			}
			else if (candidate[i] == 0xff) {  // no match
				if (subchInfo->etts[i])
					dprint(3, "    delete old Ett-%d (%d events)\n", i, subchInfo->n_ett[i]);
				PSIDB_FreeEtts(subchInfo, i);
			}
			else {                            // match with other ett
				if (subchInfo->eits[i]) {
					dprint(3, "    overwrite old %d Ett-%d --> Ett-%d\n", subchInfo->n_ett[candidate[i]], candidate[i], i);
					PSIDB_FreeEtts(subchInfo, i);
					subchInfo->etts[i] = subchInfo->etts[candidate[i]];
					subchInfo->n_ett[i] = subchInfo->n_ett[candidate[i]];
					
					subchInfo->etts[candidate[i]] = NULL;  // cafrii 040713 add
					subchInfo->n_ett[candidate[i]] = 0;
				}
				else {
					dprint(3, "    move old %d Ett-%d --> Ett-%d\n", subchInfo->n_ett[candidate[i]], candidate[i], i);
					subchInfo->etts[i] = subchInfo->etts[candidate[i]];
					subchInfo->n_ett[i] = subchInfo->n_ett[candidate[i]];
					
					subchInfo->etts[candidate[i]] = NULL;  // cafrii 040713 add
					subchInfo->n_ett[candidate[i]] = 0;
				}
			}
		}
	}
	
	// ----------- channel ETT check
	tbl1 = PSIUTIL_FindTableInMgt(chInfo->mgt, tt_channel_ETT);
	tbl2 = PSIUTIL_FindTableInMgt(mgt, tt_channel_ETT);
	if (tbl2 == NULL || tbl1 == NULL) {
		dprint(2, " Delete all channel ETT\n");
		for (k=0; chInfo->subchannel && k<chInfo->n_subchannel; k++) {
			if (chInfo->subchannel[k].active == 0) continue;
			PSIUTIL_FreeTable(&chInfo->subchannel[k].channel_ett);
		}
	}
	else {
		if (tbl1->table_type_version_number != tbl2->table_type_version_number) {
			dprint(2, " ETT-v version changed %d->%d\n", tbl1->table_type_version_number, tbl2->table_type_version_number);
			for (k=0; chInfo->subchannel && k<chInfo->n_subchannel; k++) {
				if (chInfo->subchannel[k].active == 0) continue;
				PSIUTIL_FreeTable(&chInfo->subchannel[k].channel_ett);
			}
		}
	}

	// 모든 table들을 출력해보자..
	dprint(2, "------- Eit/Ett tables after version check ---------\n");
	for (k=0; chInfo->subchannel && k<chInfo->n_subchannel; k++) {
		subchInfo = &chInfo->subchannel[k];
		if (subchInfo->active == 0) continue;
		for (i=0; i<128; i++) {
			if (subchInfo->eits[i])
				dprint(2, "  Eit-%d: 0x%x ver %d\n", i, subchInfo->eits[i], subchInfo->eits[i] ? subchInfo->eits[i]->version_number : 0);
			for (j=0; j<subchInfo->n_ett[i]; j++)
				dprint(2, "     Ett-%d [%d]: 0x%x ver %d\n", i, j, subchInfo->etts[i][j], subchInfo->etts[i][j] ? subchInfo->etts[i][j]->version_number : 0);
		}
	}
	dprint(2, "\n");
	
	LockPsiDB(FALSE);
	return statusOK;	
}


//-----------------------------------
//  PSIDB_MakeMgtSummary
//
//  mgt에서 어떤 VCT가 사용 가능한지 알아낸다.
//  또, 다운로드 받을 수 있는 모든 EIT가 몇개나 되는지, PID가 어떤지 찾는다.
//
PSI_STATIC void MakeMgtDigest(S_PSIM_MGT_DIGEST *smgt, mgtSectionPtr_t mgt)
{
	int i;

 	dprint(1, "%s:\n", __FUNCTION__);
	
	if (!smgt || !mgt) return;
	
	// 이 시점부터 이 함수 끝까지 모두 Lock을 한다.
	LockPsiDB(TRUE);
	
	smgt->tvct_exist_in_mgt = smgt->cvct_exist_in_mgt = FALSE;
	smgt->tvct_ver = smgt->cvct_ver = 0xFF;

	smgt->channel_ett_pid = 0;
	smgt->channel_ett_ver = 0xff;
	
	for (i=0; i<128; i++) {
		smgt->eit_pids[i] = 0;
		smgt->eit_ver[i] = 0xff;
		smgt->ett_pids[i] = 0;
		smgt->ett_ver[i] = 0xff;
	}
		
	for (i=0; i<mgt->tables_defined; i++) // search all tables..
	{
		int index;
		
		if (mgt->table[i].table_type == tt_terrestrial_VCT_cni_1) {           // TVCT
			smgt->tvct_exist_in_mgt = TRUE;
			smgt->tvct_ver = mgt->table[i].table_type_version_number;
		}
		else if (mgt->table[i].table_type == tt_cable_VCT_cni_1) {            // CVCT
			smgt->cvct_exist_in_mgt = TRUE;
			smgt->cvct_ver = mgt->table[i].table_type_version_number;
		}
		else if (mgt->table[i].table_type >= tt_EIT_min &&                    // EIT
				mgt->table[i].table_type <= tt_EIT_max)      
		{
			index = (mgt->table[i].table_type - tt_EIT_min);

			if (smgt->eit_pids[index] == 0) {
				// cafrii 070712 add check for bugfix
				if (mgt->table[i].table_type_PID == 0 || 
					mgt->table[i].table_type_PID >= 0x1FFF) {
					dprint(0, "!! MGT table[%d] EIT-%d pid 0x%x invalid. ignored!\n", 
							i, index, mgt->table[i].table_type_PID);
				}
				else {
					smgt->eit_pids[index] = mgt->table[i].table_type_PID;
					smgt->eit_ver[index] = mgt->table[i].table_type_version_number;
				}
			}
			else {
				if (mgt->table[i].table_type_PID != smgt->eit_pids[index])
					dprint(0, "!! MGT table[%d] pid 0x%x != prev EIT-%d pid 0x%x! ignored!\n", 
							i, mgt->table[i].table_type_PID, index, smgt->eit_pids[index]);
				else
					dprint(0, "!! MGT table[%d] is EIT-%d but redundant! ignored!\n", i, index);
			}
		}
		else if (mgt->table[i].table_type == tt_channel_ETT) {                // channel ETT

			if (smgt->channel_ett_pid == 0) {
				// cafrii 070712 add check for bugfix
				if (mgt->table[i].table_type_PID == 0 || 
					mgt->table[i].table_type_PID >= 0x1FFF) {
					dprint(0, "!! MGT table[%d] ETT-v pid 0x%x invalid. ignored!\n", 
							i, smgt->channel_ett_pid);
				}
				else {
					smgt->channel_ett_pid = mgt->table[i].table_type_PID;
					smgt->channel_ett_ver = mgt->table[i].table_type_version_number;
				}
			}
			else {
				if (mgt->table[i].table_type_PID != smgt->channel_ett_pid)
					dprint(0, "!! MGT table[%d] pid 0x%x != prev ETT-v pid 0x%x! ignored!\n", 
							i, mgt->table[i].table_type_PID, smgt->channel_ett_pid);
				else
					dprint(0, "!! MGT table[%d] is ETT-v but redundant! ignored!\n", i);
			}
		}
		else if (mgt->table[i].table_type >= tt_event_ETT_min &&              // ETT
				mgt->table[i].table_type <= tt_event_ETT_max)
		{ 
			index = (mgt->table[i].table_type - tt_event_ETT_min);

			if (smgt->ett_pids[index] == 0) {
				// cafrii 070712 add check for bugfix
				if (mgt->table[i].table_type_PID == 0 || 
					mgt->table[i].table_type_PID >= 0x1FFF) {
					dprint(0, "!! MGT table[%d] ETT-%d pid 0x%x invalid. ignored!\n", 
							i, index, mgt->table[i].table_type_PID);
				}
				else {
					smgt->ett_pids[index] = mgt->table[i].table_type_PID;
					smgt->ett_ver[index] = mgt->table[i].table_type_version_number;
				}
			}
			else {
				if (mgt->table[i].table_type_PID != smgt->ett_pids[index])
					dprint(0, "!! MGT table[%d] pid 0x%x != prev ETT-%d pid 0x%x! ignored!\n", 
							i, mgt->table[i].table_type_PID, index, smgt->ett_pids[index]);
				else
					dprint(0, "!! MGT table[%d] is ETT-%d but redundant! ignored!\n", i, index);
			}
		}
		else if (mgt->table[i].table_type >= tt_RRT_region_1 &&               // RRT
				mgt->table[i].table_type <= tt_RRT_region_255) 
		{
			//dprint(2, "RRT not supported yet..\n");
		}
		else {
			dprint(0, "!! unknown table type %d\n", mgt->table[i].table_type);
		}
	}
	
	LockPsiDB(FALSE);

	if (smgt->tvct_exist_in_mgt == FALSE && smgt->cvct_exist_in_mgt == FALSE) {
	#if 0
		sprintf(context->event_string_buf, "Neither of VCT exist in mgt");
		Dmc_EpgSendUserEvent(context, epgEventError, (UINT32)statusPSIPError, (UINT32) context->event_string_buf);

		dprint(0, "!! %s\n", context->event_string_buf);
		return statusPSIPError;
			// 이런 에러의 경우에는 다시 retry를 할 필요도 없다. 아주 잘못된 것이기 때문..
	#else
		// mgt에는 없지만 실제로 존재할 수도 있으므로 계속 진행.
		dprint(0, "!! neither of vct exist in mgt\n");
	#endif
	}
	
}



/*
	vct의 subch 갯수를 알아내고, 필요한 경우 기존 subch 정보를 초기화 한다.
	subch 정보 안의 vct backup 부분도 초기화 한다.

	처리할 vct는 이미 @chInfo 안에 저장되어 있어야 한다.
*/
PSI_STATIC STATUS PrepareSubchStructUsingVct(S_PSIM_CHINFO *chInfo)
{
	STATUS status = statusOK;
	int i;
	int n_subchannel;
	BOOL bSubchResetRequired;

	if (!chInfo->vct)
		return statusInvalidArgument;
	
	// 이제 여기서부터는 tvct나 cvct 둘 중 하나는 반드시 존재한다고 가정하고 진행한다.
	// 사실 통합 xvct 하나만 존재함.

	dprint(2, "prepare_subch:\n");

#if 0
	//------------------------------------------------------
	// VCT integrity check..
	// MGT에서 지정하고 있는 버전과 동일한 것인지 체크한다. 반드시 그럴 필요는 없지만 하는게 좋겠다..
	//
	if (chInfo->tvct_ver != chInfo->tvct->version_number) {
		dprint(0, "!! Warning! TVCT version in MGT %d mismatch with real TVCT version %d\n", 
				chInfo->tvct_ver, chInfo->tvct->version_number);
		// todo..
		// 버전이 달라진 이런 경우 어떻게 할 것인가?  일단 그대로 진행하자.
	}
#endif

	//------------------------------------------------------
	// 새 vct 정보로부터 만들어야 할 subch 갯수 알아냄.
	//
	if (chInfo->vct->channel == NULL) 
	{ 
		// ParseTvct 에서 numChannels 가 0이면 이럴 수도 있지 않는가? --> No..
		// NULL channel 인 경우 numChannels 0 으로 간주해서 동작시키면 안되나? --> OK..
		//
		dprint(0, "!! vct channel info NULL\n");
		n_subchannel = 0;
	}
	else
		n_subchannel = chInfo->vct->numChannels;
		// 주의! vct syntax 상 n_subchannel 이 0일 수도 있음.

	//------------------------------------------------------
	// subchannel 정보 초기화 필요한 경우..
	//   case 1. 처음 vct를 받는 경우 (기존 subchannel 정보가 없는 경우) -> 새롭게 malloc
	//   case 2. subchannel 갯수가 달라진 경우..   -> buffer re-alloc
	//   case 3. source_id 정보가 하나라도 바뀌어 버린 경우 -> 내용 reset
	//
	bSubchResetRequired = FALSE;

	// case 1, 2.
	if (chInfo->subchannel == NULL || chInfo->n_subchannel != n_subchannel) {
		if (chInfo->subchannel)
			dprint(1, "!! subchannel number different!! old %d, new %d\n", chInfo->n_subchannel, n_subchannel);
		bSubchResetRequired = TRUE;
	}
	else { // case 3.
		for (i=0; i<n_subchannel; i++) {
			if (chInfo->subchannel[i].source_id != chInfo->vct->channel[i].source_id) {
				dprint(1, "!! subchannel[%d] sid changed!! %d->%d\n", i, 
						chInfo->subchannel[i].source_id, chInfo->vct->channel[i].source_id);
				bSubchResetRequired = TRUE;
				break;
			}
		}
	}
	
	if (bSubchResetRequired)
	{
		dprint(2, "  subch reset required.. prev n_subch = %d\n", chInfo->n_subchannel);
		LockPsiDB(TRUE); //-------------
		
		// num channel이 달라서 reallocation하는 경우, 내부 내용을 다 free시켜야 한다..
		for (i=0; chInfo->subchannel && i<chInfo->n_subchannel; i++) {
			//dprint(2, "  deleting subchannel info [%d] \n", i);
			PSIDB_FreeSubChInfo(&chInfo->subchannel[i]);
		}
		DHL_OS_Free((void **)&chInfo->subchannel);
		chInfo->n_subchannel = 0;

		// 이미 언급했듯이 n_subchannel은 0일 가능성이 있다.
		if (n_subchannel > 0) 
		{	
			dprint(2, "  make new subchannel info.. n_subch %d\n", n_subchannel);
			// subchannel 정보 구조체 초기화..
			//
			chInfo->subchannel = DHL_OS_Malloc(n_subchannel * sizeof(S_PSIM_SUBCHINFO));
			if (!chInfo->subchannel) {
				dprint(0, "!! out of memory for %d subch..\n", n_subchannel);
				chInfo->n_subchannel = 0;
				status = statusOutOfMemory;
			}
			else {
				chInfo->n_subchannel = n_subchannel;
			}
			
			for (i=0; i<chInfo->n_subchannel; i++) {
				chInfo->subchannel[i].parent = chInfo;  // make back pointer
				chInfo->subchannel[i].index = i;
				chInfo->subchannel[i].source_id = chInfo->vct->channel[i].source_id;
				chInfo->subchannel[i].active = TRUE;

#if DMW_PSI_SUPPORT_ELAPSED_TIMER
				DMW_ResetCounter(&chInfo->subchannel[i].counter);
				DMW_HoldCounter(&chInfo->subchannel[i].counter);
#endif
			}
		}
		LockPsiDB(FALSE); //-------------
	}
	else {
		dprint(2, "  prev n_subch %d not changed\n", chInfo->n_subchannel);
	}
	
	//------------------------------------------------------
	// vct의 일부 정보를 각 subchannel 로 백업해둔다.
	//
	for (i=0; i<chInfo->n_subchannel; i++) 
	{
		memcpy(chInfo->subchannel[i].vct_info.short_name, chInfo->vct->channel[i].short_name, sizeof(UINT16)*7);

		if (chInfo->vct->is_cvct) {
			chInfo->subchannel[i].vct_info.major_channel_number = EpgMajorNumberInCVCT(&chInfo->vct->channel[i]);
			chInfo->subchannel[i].vct_info.minor_channel_number = EpgMinorNumberInCVCT(&chInfo->vct->channel[i]);
		}
		else {
			chInfo->subchannel[i].vct_info.major_channel_number = chInfo->vct->channel[i].major_channel_number;
			chInfo->subchannel[i].vct_info.minor_channel_number = chInfo->vct->channel[i].minor_channel_number;
		}
		chInfo->subchannel[i].vct_info.program_number = chInfo->vct->channel[i].program_number;

		chInfo->subchannel[i].vct_info.analog = 
			(chInfo->vct->channel[i].modulation_mode == mm_analog ||
			chInfo->vct->channel[i].service_type == st_analog_television) ? 1 : 0;

		chInfo->subchannel[i].vct_info.etm_location = chInfo->vct->channel[i].ETM_location;
	}
	
	return status;
}


#if COMMENT
____Update____(){}
#endif

/*
	각종 Table을 PSI DB에 update 함.

	공통 Rule:

		statusOK를 리턴하면, 제대로 DB에 반영되었다는 의미임.
		따라서 caller는 인자로 지정한 table pointer를 읽기 전용으로 사용 가능.

		statusOK가 아닌 에러를 리턴한다면 DB에 반영되지 않았다는 의미이므로
		caller는 사용되지 않은 table pointer를 free 시키는 등의 조치를 해야 한다.

	기존 table 과의 일관성 문제:

		새 table 처리 도중에 에러가 발생할 경우 
		일관성 차원에서 필요하다면 기존 테이블 (데이터들) 도 삭제해야 한다.
		
*/


/*
	PAT를 update 한다.
	필요하면 pmts array를 resize도 한다. 
	이미 pmt가 존재하는 경우 새로운 pat와 비교해서 문제가 있다면 pmt들을 free한다.

	어느 순간에든 항상 pat->numPrograms 와 pmts array 크기는 일치시키도록 한다.
	이 조건이 유지되지 않으면 update 불가!!
*/

STATUS PSIDB_UpdatePAT(int id, MPEG_PAT *pat)
{
	S_PSIM_CHINFO *chInfo;
	int i;
	STATUS status = statusOK;
	
	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo || !pat) {
		status = statusInvalidArgument;
		goto label_end;
	}
	
	if (chInfo->pat) // 기존 pat 가 존재하는 경우..
	{
		dprint(2, "pat update, ver %d -> %d, #pgm %d -> %d\n", 
			chInfo->pat->version_number, pat->version_number, chInfo->pat->numPrograms, pat->numPrograms);

		// resize pmts array 
		if (chInfo->pat->numPrograms != pat->numPrograms) 
		{
			// ASSERT (chInfo->pmts != NULL) <- true because chInfo->pat exists.
			
			// delete all pmts
			for (i=0; i<chInfo->pat->numPrograms; i++) {
				PSIUTIL_FreeTable(&chInfo->pmts[i]);
			}
			DHL_OS_Free((void **)&chInfo->pmts);

			// 새로운 pat에 맞춰서 pmt list 버퍼 다시 할당..
			chInfo->pmts = DHL_OS_Malloc(pat->numPrograms * sizeof(MPEG_PMT *));
			if (!chInfo->pmts) {
				// critical!!
				// our assumption is that (pat->numPrograms == size of pmts array).
				// so, easy way to keep this assumption is delete whole pat!
				dprint(0, "!! re-alloc pmts err. free pat!\n");
				PSIUTIL_FreeTable(&chInfo->pat); // free previous pat also!!
				status = statusOutOfMemory;
				goto label_end;
			}
		}
		else {
			// free only inconsistent pmts..
			for (i=0; i<chInfo->pat->numPrograms; i++) {
				if (chInfo->pat->programs[i].program_map_PID != chInfo->pmts[i]->PID ||
					chInfo->pat->programs[i].program_number != chInfo->pmts[i]->program_number)
				{
					dprint(2, "  pmt[%d] (pid %x, #%d) unmatched to pat info (pid %x, #%d). free it..\n",
							i, chInfo->pmts[i]->PID, chInfo->pmts[i]->program_number,
							chInfo->pat->programs[i].program_map_PID, chInfo->pat->programs[i].program_number);
					PSIUTIL_FreeTable(&chInfo->pmts[i]);
					// keep pmt whose pid & program number is unchanged.
				}
			}
		}

		// now, replace old pat..
		PSIUTIL_FreeTable(&chInfo->pat);
		chInfo->pat = pat;
	}
	else // 기존 pat가 없는 경우. 처음 받는 pat..
	{
		dprint(2, "new pat, ver %d, %d programs\n", pat->version_number, pat->numPrograms);

		chInfo->pmts = DHL_OS_Malloc(pat->numPrograms * sizeof(MPEG_PMT *));
		if (!chInfo->pmts) {
			// critical!!
			dprint(0, "!! alloc pmts err. free pat!\n");
			PSIUTIL_FreeTable(&chInfo->pat);
			status = statusOutOfMemory;
			goto label_end;
		}
		chInfo->pat = pat;
		pat = NULL;
	}

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (pat)
	//	PSIUTIL_FreeTable(&pat);

	return status;
}

/*

*/
STATUS PSIDB_UpdatePMT(int id, MPEG_PMT *pmt)
{
	S_PSIM_CHINFO *chInfo;
	int i, index;
	STATUS status = statusOK;
	
	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo || !pmt) {
		status = statusInvalidArgument;
		goto label_end;
	}
	
	// pmts list 안에서의 순서는 pat 내의 순서대로 한다.
	index = -1;
	for (i=0; i<chInfo->pat->numPrograms; i++) {
		if (chInfo->pat->programs[i].program_number == pmt->program_number) {
			index = i;
			break;
		}
	}

	if (index < 0) {
		// warning! this pmt is not related to pat!!
		dprint(0, "!! cannot find pmt (#%d) info in pat\n", pmt->program_number);
		status = statusInvalidPSI;
		goto label_end;
	}

	if (chInfo->pmts[index]) { // previous pmt already exist.
		dprint(2, "pmt[%d] update, #%d, ver %d -> %d\n", index, pmt->program_number, 
					chInfo->pmts[index]->version_number, pmt->version_number);
		PSIUTIL_FreeTable(&chInfo->pmts[index]);
	}
	else {
		dprint(2, "new pmt[%d], #%d, ver %d\n", index, pmt->program_number, pmt->version_number);
	}
	chInfo->pmts[index] = pmt;
	//pmt = NULL;

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (pmt)
	//	PSIUTIL_FreeTable(&pmt);

	return status;
}



/*
	새 @mgt를 DB에 update 한다.

	바로 update 하기 전에 변경 되는 사항들에 대한 impact에 대한 처리를 수행한다.
	그리고 mgt summary 정보 등도 생성한다.
*/
STATUS PSIDB_UpdateMgt(int id, mgtSectionPtr_t mgt)
{
	S_PSIM_CHINFO *chInfo;
	STATUS status = statusOK;

	dprint(3, "update_mgt: id %d, %x\n", id, mgt);
	
	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo || !mgt) {
		status = statusInvalidArgument;
		goto label_end;
	}
	
	//------------------------------------------------------------------------
	// MGT 버전 변경 처리..
	//
	// 이 함수는 chInfo 에 있는 mgt와, mgt를 비교하기 때문에 이 시점까지는 chInfo에
	// mgt를 저장하면 안된다.
	//
	CheckAndProcessMgtVersionChange(chInfo, mgt);


	//------------------------------------------------------------------------
	// MGT 분석 
	// chInfo 에 저장된 mgt가 아니라 지정한 mgt로 체크를 한다..
	//
	MakeMgtDigest(&chInfo->smgt, mgt);


	PSIUTIL_FreeTable(&chInfo->mgt_old);
	chInfo->mgt_old = chInfo->mgt;  	// 이전 MGT는 보관해둔다.	
	chInfo->mgt = mgt;
	//mgt = NULL;

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (mgt)
	//	PSIUTIL_FreeTable(&mgt);

	return status;

}


/*
	DB에 새 @vct를 update 한다.
	
	
*/
STATUS PSIDB_UpdateVct(int id, xvctPtr_t vct)
{
	S_PSIM_CHINFO *chInfo;
	STATUS status = statusOK;

	dprint(2, "update_vct: id %d, vct 0x%x\n", id, vct);

	DHL_ASSERT(vct!=0, "null vct");
	
	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo || !vct) {
		dprint(0, "!! chInfo of id %d is %x, vct %x\n", id, chInfo, vct);
		status = statusInvalidArgument;
		goto label_end;
	}

	PSIUTIL_FreeTable(&chInfo->vct); // 기존 vct를 제거..
	chInfo->vct = vct;

	//---------------------------
	// 새 vct 정보에 따라 subch struct 내용을 일치시킨다.
	//
	status = PrepareSubchStructUsingVct(chInfo);
	if (status) {
		// 무슨 이유에서인지 subch 구성이 실패하였음.
		// vct를 그대로 둘 것인가? 아니면 일관성을 위해 삭제할 것인가?
		// --> 안정성 위주로 동작.
		//  status 를 에러로 리턴하면 caller에서 table 관리를 담당하므로
		// 그냥 NULL setting 만 하면 된다.
		chInfo->vct = NULL;
	}
	
label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	//if (vct)
	//	PSIUTIL_FreeTable(&vct);

	return status;
}


STATUS PSIDB_UpdateStt(int id, sttSectionPtr_t stt, UINT32 tick_stt_get)
{
	S_PSIM_CHINFO *chInfo;
	STATUS status = statusOK;

	LockPsiDB(TRUE); // >>>>>>>>>>>>

	chInfo = PSI_GetChInfo(id);
	if (!chInfo || !stt) {
		status = statusInvalidArgument;
		goto label_end;
	}

	dprint(2, "stt updated, gps %x\n", stt->system_time);
	
	// copy whole stt contents.
	chInfo->flat_stt = *stt;
	
	// reset descriptor info..
	chInfo->flat_stt.descriptors = NULL;
	chInfo->flat_stt.descriptor_length = 0;

	chInfo->tick_stt_get = tick_stt_get; // stt 취득 시점의 tick
	chInfo->stt_valid = TRUE;
	
label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (stt)
	//	PSIUTIL_FreeTable(&stt);

	return status;
}

STATUS PSIDB_InvalidateStt(int id)
{
	S_PSIM_CHINFO *chInfo;
	STATUS status = statusOK;

	LockPsiDB(TRUE); // >>>>>>>>>>>>

	chInfo = PSI_GetChInfo(id);
	if (!chInfo) {
		status = statusInvalidArgument;
		goto label_end;
	}

	chInfo->stt_valid = FALSE;

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	return status;
}

STATUS PSIDB_UpdateRrt(int id, rrtSectionPtr_t rrt)
{
	STATUS status = statusOK;

	return status;
}


/*
	eit를 DB에 update 한다.

	관련 ett 정보 data structure도 초기화한다.
*/
STATUS PSIDB_UpdateEit(int id, eitPtr_t eit, int iEit)
{
	S_PSIM_CHINFO *chInfo;
	S_PSIM_SUBCHINFO *subchInfo;
	int source_id;
	int i;
	STATUS status = statusOK;

	dprint(2, "update_eit: (rf %d, idx %d)\n", id, iEit);
	
	// 1. sanity check
	//    valid iEit range is 0 ~ 127.
	if (!eit || iEit < 0 || iEit >= 128)
		return statusInvalidArgument;

	if (eit->numEvents && !eit->event) // invalid table!
		return statusInvalidArgument;
	
	source_id = eit->source_id;

	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo) {
		status = statusInvalidArgument;
		goto label_end;
	}
	
	// find subchannel index and get 'subchInfo' pointer.
	subchInfo = NULL;
	for (i=0; i<chInfo->n_subchannel; i++) {
		if (chInfo->subchannel[i].source_id == source_id) {
			subchInfo = &chInfo->subchannel[i];
			break;
		}
	}
	if (!subchInfo) { 
		// 수신한 eit에 해당되는 subch가 없다?
		// burst eit 가 queue에 쌓여서 늦게 처리될 때 이럴 수 있음.
		dprint(0, "!! no subchannel of source_id %d\n", source_id);
		status = statusInvalidState;
		goto label_end;
	}

	// ok.. eit index found. check if any changes of events and ett arrays.

	if (subchInfo->eits[iEit]) 
	{
		if (subchInfo->eits[iEit]->version_number != eit->version_number)
			dprint(2, "  eit[%d] update, ver %d -> %d\n", 
				iEit, subchInfo->eits[iEit]->version_number, eit->version_number);
		else
			dprint(2, "  same eit[%d] ver %d exist\n", eit->version_number);

		// check ett arrays are consistent.
	#if 0
		// 1. n_ett vs. etts
		if (subchInfo->etts[iEit] == NULL && subchInfo->n_ett[iEit]) {
			dprint(0, "!!!! etts[%d] null but n_ett[%d]=%d\n", iEit, iEit, subchInfo->n_ett[iEit]);
			subchInfo->n_ett[iEit] = 0;
		}
		else if (subchInfo->etts[iEit] && subchInfo->n_ett[iEit] == 0) {
			dprint(0, "!!!! n_ett[%d]=0, but etts[%d]=%x\n", iEit, iEit, subchInfo->etts[iEit]);
			DHL_OS_Free((void **)&subchInfo->etts[iEit]);      // 이 경우는 비정상적 상황임..
		}
	#endif
		// 2. number of events and n_ett
		if (subchInfo->n_ett[iEit] > 0 && eit->numEvents != subchInfo->n_ett[iEit]) {
			dprint(2, "!! n_event changed, %d -> %d. clear etts[%d] array\n", 
					subchInfo->n_ett, eit->numEvents, iEit);
			PSIDB_FreeEtts(subchInfo, iEit);
		}
		
		// 3. event_id match
		if (subchInfo->n_ett[iEit] && subchInfo->etts[iEit])
		{
			// 만약 기존 Ett가 일부라도 존재한다면, 이것들이 모두 Eit의 event 내용과 일치해야만 재사용이 가능하다.
			// 하나라도 뭔가 안맞는게 있으면 이것은 재사용할 수 없다.
			//
			// --> 맞는것은 재 사용하는것은 어떨까??
			//
			BOOL bReuseEtt = TRUE;
			UINT16 eit_event_id;
			UINT32 etm_id;
			
			// n_ett[k] == eits[k]->numEvents 이다.
			for (i=0; i<subchInfo->n_ett[iEit]; i++) {
				if (subchInfo->etts[iEit][i] == NULL) continue; // 없는 ETT는 굳이 체크할 필요 없다.
				
				eit_event_id = eit->event[i].event_id;
				etm_id = subchInfo->etts[iEit][i]->ETM_id;
				if (eit_event_id != PSIUTIL_GetEventIDFromETMID(etm_id)) {
					dprint(0, "     !! Ett[%d][%d] event id mismatch! eit(%x) != etm(%x)\n", 
							iEit, i, eit_event_id, PSIUTIL_GetEventIDFromETMID(etm_id));
					bReuseEtt = FALSE;
					break;
				}
			}
			if (bReuseEtt == FALSE) {
				// 재사용 불가하면, 모두 지운다.
				dprint(1, "     !! cannot reuse old Etts[%d].. delete!\n", iEit);
				PSIDB_FreeEtts(subchInfo, iEit);
			}
		}

		PSIUTIL_FreeTable(&subchInfo->eits[iEit]);
		subchInfo->eits[iEit] = eit;
		//eit = NULL;
	}
	else 
	{
		dprint(2, "  new eit[%d], ver %d\n", iEit, eit->version_number);
		subchInfo->eits[iEit] = eit;
		//eit = NULL;
		// clear any related etts. actually they should not exist at all!
		if (subchInfo->n_ett[iEit] || subchInfo->etts[iEit]) {
			dprint(0, "!! etts should not exist! clear etts[%d]..\n", iEit);
			PSIDB_FreeEtts(subchInfo, iEit);
		}
	}

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (eit)
	//	PSIUTIL_FreeTable(&eit);
	
	return status;
}


#if 0
void PSIDB_PrepareEttDownload(int id, int iEit)
{
	// eit의 event 갯수와 etts array 갯수 일치 체크.
	int n_etm;

	// 이 EIT의 event들 중에서 몇개가 ETM을 가지고 있는지 셈한다.
	//
	for (i=0, n_etm=0; i<subchInfo->eits[iEit]->numEvents; i++) {
		if (gPsiIgnoreEtmLocationInfo ||                          // ignore 옵션이면 무조건 받는다.
			subchInfo->eits[iEit]->event[i].ETM_location != ETM_none)
			n_etm++;  // 이 EIT에 관련된 ETT 갯수..
	}
	if (n_etm == 0) {  // 이 EIT의 이벤트들에는 ETT가 하나도 없다고 한다. 다운로드 받을 필요가 없다.
		dprint(3, "        no ETTs of this eit[%d]..\n", iEit);
		// 다음 단계로 가기 전에 현재 ett들의 자격 검사도 해야 하지 않나????
	}
	else {
		dprint(3, "   %d ETM's are expected in this EIT..\n", n_etm);
	}

	// ------ Ett용 메모리 할당..
	// ett용 메모리가 없으면 새로 할당한다..  만약 etts가 있다면 n_ett는 numEvents와 같을 것이다. (이미 체크완료)
	if (subchInfo->etts[iEit] == NULL)
	{
		int n_event = subchInfo->eits[iEit]->numEvents;
		
		subchInfo->etts[iEit] = DHL_OS_Malloc(n_event * sizeof(ettSectionPtr_t));
		if (subchInfo->etts[iEit] == NULL) {
			dprint(0, "!! out of memory for %d ETT ptr\n", n_event);
			subchInfo->n_ett[iEit] = 0;
			break;          // 메모리 부족? 더 이상 진행할 필요가 없다.
			
			// 루프 바깥으로 나가면 지금까지 request된 것만이라도 download를 시도 할 수는 있다...
		}
		dprint(3, "        ++ alloc etts memory %x (max %d)\n", subchInfo->etts[iEit], subchInfo->eits[iEit]->numEvents);
		subchInfo->n_ett[iEit] = subchInfo->eits[iEit]->numEvents; // 이 Eit에 연결된 ETT-i 의 갯수..
	}
	else
		dprint(3, "        ** reuse etts memory %x (max %d:%d)\n", subchInfo->etts[iEit], 
					subchInfo->eits[iEit]->numEvents, subchInfo->n_ett[iEit]);

}
#endif


/*
	channel-ett index is passed as 128.

*/
STATUS PSIDB_UpdateEtt(int id, ettSectionPtr_t ett, int iEit)
{
	S_PSIM_CHINFO *chInfo;
	S_PSIM_SUBCHINFO *subchInfo;
	int source_id, event_id;
	UINT32 etm_id;
	int i, iEvent;
	STATUS status = statusOK;
	
	eitPtr_t eit;
	ettSectionPtr_t *p_ett = NULL; // pointer of ett to be updated

	dprint(2, "update_ett: (rf %d, idx %d)\n", id, iEit);
	
	// sanity check
	// note that iEit 128 is considered as channel-ett.
	//
	if (!ett || iEit < 0 || iEit > 128)
		return statusInvalidArgument;

	etm_id = ett->ETM_id;
	source_id = PSIUTIL_GetSourceIDFromETMID(etm_id);
	event_id = PSIUTIL_GetEventIDFromETMID(etm_id);

	LockPsiDB(TRUE); // >>>>>>>>>>>>
	
	chInfo = PSI_GetChInfo(id);
	if (!chInfo) {
		status = statusInvalidArgument;
		goto label_end;
	}
	
	// find subchannel index and 'subchInfo' ptr
	subchInfo = NULL;
	for (i=0; i<chInfo->n_subchannel; i++) {
		if (chInfo->subchannel[i].source_id == source_id) {
			subchInfo = &chInfo->subchannel[i];
			break;
		}
	}
	if (!subchInfo) {
		dprint(0, "!! no subchannel of source_id %d\n", source_id);
		status = statusInvalidState;
		goto label_end;
	}

	// first, consider channel-ett..
	if (iEit == 128) {
		iEvent = 0; // meaningless for channel-ett..
		p_ett = &subchInfo->channel_ett;
		goto label_update;
	}

	// now, consider normal event ett..
	// check consistency..
	
	eit = subchInfo->eits[iEit];
	if (!eit) {
		dprint(0, "!! ett[%d] received without eit[%d]?\n", iEit);
		status = statusInvalidState;
		goto label_end;
	}
	if (eit->numEvents != subchInfo->n_ett[iEit]) {
		dprint(0, "!! eit[%d] num event %d != n_ett %d\n", eit->numEvents, subchInfo->n_ett[iEit]);
		status = statusInvalidState;
		goto label_end;
	}
	
	//  find related eit using event_id
	
	iEvent = -1;
	for (i=0; i<eit->numEvents; i++) {
		if (eit->event[i].event_id == event_id) {
			iEvent = i;
			break;
		}
	}
	if (iEvent < 0) {
		dprint(0, "ett[%d] event_id 0x%x not matched to eit\n", iEit, event_id);
		status = statusInvalidState;
		goto label_end;
	}

	// check etts array exist and its length is consistent to eit events..
	if (eit->numEvents != subchInfo->n_ett[iEit]) {
		dprint(0, "!! eit events %d != n_ett[%d] %d !!\n", eit->numEvents, iEit, subchInfo->n_ett[iEit]);
		PSIUTIL_FreeTable(&ett);
		status = statusInvalidState;
		goto label_end;
	}
	
	p_ett = &subchInfo->etts[iEit][iEvent];

label_update:
	if (*p_ett == NULL) {
		dprint(2, "  new ett[%d][%d], ver %d, etm %x\n", iEit, iEvent, ett->version_number, ett->ETM_id);
		(*p_ett) = ett;
	}
	else if ((*p_ett)->version_number != ett->version_number) {
		dprint(2, "  ett[%d][%d] update, ver %d->%d, etm %x\n", 
			iEit, iEvent, (*p_ett)->version_number, ett->version_number, ett->ETM_id);
		PSIUTIL_FreeTable(p_ett);
		(*p_ett) = ett;
	}
	else { // same version number
		dprint(2, "  same ett[%d][%d] ver %d exist, etm %x\n", iEit, iEvent, ett->version_number, ett->ETM_id);
		PSIUTIL_FreeTable(&ett); // 새로 받은 ett를 삭제한다.
	}
	//ett = NULL; // not to be freed later..

label_end:
	LockPsiDB(FALSE); // <<<<<<<<<<<<

	// caller에서 관리함.. 삭제..
	// now, un-registered table pointer should be freed.
	//if (ett)
	//	PSIUTIL_FreeTable(&ett);
	
	return status;
}



#if COMMENT
____Modify____(){}
#endif


void PSIDB_DeleteTables(int id)
{
	S_PSIM_CHINFO *chInfo;

	if (!PSITASK_IsPsiTask()) {
		dprint(0, "!! changing psi db in other task is illegal!\n");
		return;
	}

	LockPsiDB(TRUE);
	chInfo = PSI_GetChInfo(id);

	if (chInfo){
		dprint(2, "delete chinfo rf %d\n", id);
		PSIDB_FreeChInfo(chInfo);
		PSIDB_RemoveChInfoNode(id);
	}
	LockPsiDB(FALSE);
}

void PSIDB_DeleteAllTables(void)
{
	S_PSIM_CHINFO *chInfo;
	int id;
	
	if (!PSITASK_IsPsiTask()) {
		dprint(0, "!! changing psi db in other task is illegal!\n");
		return;
	}
	dprint(2, "delete all chinfo..\n");
	
	LockPsiDB(TRUE);
	while (1)
	{
		chInfo = PSI_FirstChInfo();
		if (!chInfo) break;

		id = chInfo->id;
		dprint(2, "  delete chinfo rf %d\n", chInfo->id);
		PSIDB_FreeChInfo(chInfo);
		PSIDB_RemoveChInfoNode(id);
	}
	LockPsiDB(FALSE);
}

#if COMMENT
____Public_API____(){}
#endif

/*
	다른 task에서 DB에 접근하기 위해서는 반드시 lock 필요.
	다른 task에서는 읽기만 가능하며, 쓰기는 금지.
*/
void PSIDB_LockDB(BOOL bLock)
{
	LockPsiDB(bLock);
}


// below two function should be called with lock in arbitrary task.
// if not found, returns NULL.
//
S_PSIM_CHINFO *PSIDB_GetPsiChInfo(int id)
{
	return PSI_GetChInfo(id);
}

S_PSIM_SUBCHINFO *PSIDB_GetPsiSubChInfo(int id, int source_id)
{
	return GetSubChInfo(id, source_id);
}




#if COMMENT
____Test____(){}
#endif


void PSIDB_PrintAllTables(int id, int source_id, BOOL bDetail)
{
	// id : channelInfo id
	// index : subchannel index  0 ~ n_subchannel-1
	
	int i, k;
	int index=0;
	BOOL bSimple = bDetail ? 0 : 1; // cafrii 061106, 'simple' is default now.
	int program_number = -1;
	
	S_PSIM_CHINFO *chInfo;
	S_PSIM_SUBCHINFO *subchInfo;
	
	//int org_flag;
	//org_flag = OS_UsePrintfSemaphore(0); // do not use printf task..
	
#undef OS_DbgPrintf
#define OS_DbgPrintf DMW_DBG_SimplePrint

	OS_DbgPrintf("%s: (id %d, source_id %d)\n", __FUNCTION__, id, source_id);
	
	LockPsiDB(TRUE); //------------------
	
	chInfo = PSI_GetChInfo(id);
	if (chInfo == NULL) 
	{
		int cnt=0;
		OS_DbgPrintf(" !! EpgDB of id %d not found!!\n", id);
		//
		// 현재 모든 channel 정보를 표시해주자..
		OS_DbgPrintf("==== Summary List of all EPG ====\n");
		
		chInfo = PSI_FirstChInfo();
		while (chInfo) 
		{
			OS_DbgPrintf(" (%d) id %d, num subch %d, %d sec%s\n", 
						cnt++, chInfo->id, chInfo->n_subchannel,
#if DMW_PSI_SUPPORT_ELAPSED_TIMER
						DMW_GetTickCount(&chInfo->counter)/OS_GetTicksPerSecond(),
						DMW_GetCounterHoldState(&chInfo->counter) ? "" : ".."
#else
						0, ""
#endif
						);
			for (i=0; i<chInfo->n_subchannel; i++)
				OS_DbgPrintf("     [%d] source id %d, %s [%s], #%d, %s %sactive, %d sec%s, %s\n", 
						i, chInfo->subchannel[i].source_id, 

						PSIUTIL_ChannelNumberString(chInfo->subchannel[i].vct_info.major_channel_number, 
										chInfo->subchannel[i].vct_info.minor_channel_number, 0),
						DMW_Unicode2Ks(chInfo->subchannel[i].vct_info.short_name, 7, 0),
						chInfo->subchannel[i].vct_info.program_number,
						// cafrii 060320 add
						chInfo->subchannel[i].vct_info.analog ? "analog," : "",

						chInfo->subchannel[i].active ? "" : "NOT ",

#if DMW_PSI_SUPPORT_ELAPSED_TIMER
						DMW_GetTickCount(&chInfo->subchannel[i].counter)/OS_GetTicksPerSecond(),
						DMW_GetCounterHoldState(&chInfo->subchannel[i].counter) ? "" : "..",
#else
						0, "",
#endif
						chInfo->subchannel[i].eit_complete == 0 ? "Incomplete!!" :
						chInfo->subchannel[i].ett_complete == 0 ? "Eit Completed" : "Completed");
						
			chInfo = PSI_NextChInfo(chInfo);

		}
		OS_DbgPrintf("\n");
		goto label_exit;
	}

	#if DMW_EPG_TABLE_DUMP_DEBUG
		//DMW_InitCodeConvLib();
		// cafrii 041102 delete. 이게 없이도 제대로 출력 되는 것 같다.
			// Unicode --> Ks 변환 table 및 관련 함수를 초기화 한다.
	#endif

	OS_DbgPrintf("\nPrint EPG Tables of Ch %d, Subch %d..\n\n", id, index);
	
	// 현재는 subchannel 하나만 테스트 하고 있으니까, 1개만 출력한다.
	//
	index = -1;

#if 0 // 일부러 틀린 sid를 지정하여 전체 개요보기를 할 수도 있음.
	// cafrii 041030 add, subchannel 이 한개이면 그냥 그것 출력하도록 함..
	if (chInfo->n_subchannel == 1)  
		source_id = chInfo->subchannel[0].source_id;
#endif

	// 지정한 source_id 가 있는지 확인..	
	for (i=0; i<chInfo->n_subchannel; i++) {
		if (chInfo->subchannel[i].source_id == source_id) {
			index = i;
			break;
		}
	}
	//--------------------------------------------------------------------
	// 지정한 source_id 서브 채널이 없는 경우..
	
	if (index < 0) {
		OS_DbgPrintf(" !! source id %d not found\n", source_id);
		//
		// subchannel 정보만 간단하게 보여준다..
		OS_DbgPrintf("**** ChannelInfo of id %d: total %d subchannel\n", chInfo->id, chInfo->n_subchannel);

		//---- PSI info
		if (chInfo->pat) {
			OS_DbgPrintf("   PAT : 0x%x, ver %d, %d programs\n", 
						chInfo->pat, chInfo->pat->version_number, chInfo->pat->numPrograms);
			for (i=0; chInfo->pmts && i<chInfo->pat->numPrograms; i++) {
				OS_DbgPrintf("     (%d) PMT: 0x%x, pid %04x, #%d, %d streams\n", 
					i, chInfo->pmts[i], chInfo->pmts[i]->PID, 
					chInfo->pmts[i]->program_number, chInfo->pmts[i]->numStreams);
			}
		}
		//---- PSIP info summary
		OS_DbgPrintf("   MGT: 0x%x, VCT: 0x%x\n", chInfo->mgt, chInfo->vct);
		for (i=0; i<chInfo->n_subchannel; i++) {
			OS_DbgPrintf("     [%d] source id %d, %s [%s], #%d, %sactive, %d sec%s, %s\n", 
					i, chInfo->subchannel[i].source_id, 

					PSIUTIL_ChannelNumberString(chInfo->subchannel[i].vct_info.major_channel_number, 
									chInfo->subchannel[i].vct_info.minor_channel_number, 0),
					DMW_Unicode2Ks(chInfo->subchannel[i].vct_info.short_name, 7, 0),
					chInfo->subchannel[i].vct_info.program_number,

					chInfo->subchannel[i].active ? "" : "NOT ",

#if DMW_PSI_SUPPORT_ELAPSED_TIMER
					DMW_GetTickCount(&chInfo->subchannel[i].counter)/OS_GetTicksPerSecond(), 
					DMW_GetCounterHoldState(&chInfo->subchannel[i].counter) ? "" : "..",
#else
					0, "",
#endif
					chInfo->subchannel[i].eit_complete == 0 ? "Incomplete!!" :
					chInfo->subchannel[i].ett_complete == 0 ? "Eit Completed" : "Completed");
		}
		OS_DbgPrintf("\n");
		goto label_exit;	
	}
	
	if (chInfo->subchannel[index].active == 0) {
		OS_DbgPrintf("!! subchannel %d is inactive now..\n", index);
		goto label_exit;
	}

	//--------------------------------------------------------------------
	// 지정한 source_id 서브 채널이 있는 경우..

	subchInfo = &chInfo->subchannel[index];

	OS_DbgPrintf(" [%d] source id %d, %s [%s], #%d, %sactive, %d sec%s, %s\n", 
			index, subchInfo->source_id, 

			PSIUTIL_ChannelNumberString(subchInfo->vct_info.major_channel_number, 
							subchInfo->vct_info.minor_channel_number, 0),
			DMW_Unicode2Ks(subchInfo->vct_info.short_name, 7, 0),
			subchInfo->vct_info.program_number,

			subchInfo->active ? "" : "NOT ",

#if DMW_PSI_SUPPORT_ELAPSED_TIMER
			DMW_GetTickCount(&subchInfo->counter)/OS_GetTicksPerSecond(), 
			DMW_GetCounterHoldState(&subchInfo->counter) ? "" : "..",
#else
			0, "",
#endif
			subchInfo->eit_complete == 0 ? "Incomplete!!" :
			subchInfo->ett_complete == 0 ? "Eit Completed" : "Completed");

	program_number = subchInfo->vct_info.program_number;
	
	if (chInfo->pat)  
		OS_DbgPrintf("   PAT     : 0x%x, ver %d, %d programs\n", 
					chInfo->pat, chInfo->pat->version_number, chInfo->pat->numPrograms);
	if (chInfo->pat && chInfo->pmts) {
		for (i=0; i<chInfo->pat->numPrograms; i++) {
			if (chInfo->pmts[i]->program_number == program_number)
				OS_DbgPrintf("   PMT[%d]  : 0x%x, ver %d, %d streams\n", 
					i, chInfo->pmts[i], chInfo->pmts[i]->version_number, chInfo->pmts[i]->numStreams);
		}
	}
	if (chInfo->mgt)      OS_DbgPrintf("   MGT     : 0x%x, ver %d\n", chInfo->mgt, chInfo->mgt->version_number);
	if (chInfo->mgt_old)  OS_DbgPrintf("   preMGT  : 0x%x, ver %d\n", chInfo->mgt_old, chInfo->mgt_old->version_number);

	//if (chInfo->tvct) OS_DbgPrintf("   TVCT    : 0x%x, ver %d\n", chInfo->tvct, chInfo->tvct->version_number);
	//if (chInfo->cvct) OS_DbgPrintf("   CVCT    : 0x%x, ver %d\n", chInfo->cvct, chInfo->cvct->version_number);
	if (chInfo->vct) 
		OS_DbgPrintf("   VCT     : 0x%x, ver %d %s, %d subchannels\n", 
				chInfo->vct, chInfo->vct->version_number, chInfo->vct->is_cvct ? "(cvct)" : "(tvct)",
				chInfo->vct->numChannels);

#if 0 // cafrii 050330 stt 삭제
	if (chInfo->stt)  OS_DbgPrintf("   STT  : 0x%x\n", chInfo->stt);
#else
	// cafrii 060724, show stt time
	// cafrii 061106, show local time and timezone also
	OS_DbgPrintf("   STT time: 0x%x, (%s)\n", chInfo->flat_stt.system_time,
				PSIUTIL_GpsTimeString2(chInfo->flat_stt.system_time, NULL, 4)); 
#endif

#if DMW_EPG_SUPPORT_RRT
	if (g_EpgRrt) {
		OS_DbgPrintf("   RRT : 0x%x (region %d)\n", 
			g_EpgRrt, (int)g_EpgRrt->rating_region);
		PSIUTIL_PrintRrt(g_EpgRrt, 4, 0);
	}
#endif

	OS_DbgPrintf("   EIT-array : 0x%x\n", subchInfo->eits);
	OS_DbgPrintf("\n");

	//if (subchInfo->channel_ett_exist) 
	if (PSIDB_IsSubChEttVRequired(id, source_id))
	{
		if (subchInfo->channel_ett) {
			OS_DbgPrintf("...ETT-v : 0x%x\n", subchInfo->channel_ett);
			#if DMW_EPG_TABLE_DUMP_DEBUG		
				Dmc_PrintEtt(subchInfo->channel_ett, 6);
				OS_DbgPrintf("\n");
			#endif
		}
		else 
			OS_DbgPrintf("...ETT-v : **** Not loaded yet ****\n");  // cafrii 041123 add
	}

	
	for (k=0; k<128; k++)
	{
		if (k == gPsiMaxEitEttIndexToReceive+1) { // cafrii 050412 change to variables
			OS_DbgPrintf("-------- MAX EIT/ETT index %d --------\n", 
				gPsiMaxEitEttIndexToReceive);
			if (bSimple)
				break; // simple mode에서는 더 이상 출력하지 말자.
		}

		if (chInfo->smgt.eit_pids[k] == 0) continue;
			// mgt에 아예 등록이 안된 eit는 표시도 하지 않는다.
			
		if (subchInfo->eits[k] == NULL) {
			OS_DbgPrintf("...EIT-%d : **** Not loaded yet ****\n", k); 
			continue;
		}
		
		//OS_DbgPrintf("...EIT-%d : 0x%x,   ETT-array: 0x%x\n", k, subchInfo->eits[k], subchInfo->etts[k]);
		OS_DbgPrintf("...EIT-%d : 0x%x (pid 0x%x)  ETT-array: 0x%x\n", 
							k, subchInfo->eits[k], chInfo->smgt.eit_pids[k], subchInfo->etts[k]);
			// cafrii 050413, Eit PID 표시 추가
		
		PSIUTIL_PrintEit(subchInfo->eits[k], 6, bSimple ? subchInfo->etts[k] : 0);
		OS_DbgPrintf("\n");
		
		if (bSimple) // 간단하게 표시하는 모드라면 PrintEit 에서 Ett도 같이 출력되었을 것이다. 여기서 종료..
			continue;
			
		//if (chInfo->ett_pids[k] == 0) continue;  // pid 정보 같은 것들은 최종 결과물은 아니다. 참조하지 말자.
		if (subchInfo->etts[k] == NULL) continue;
		
		for (i=0; i<subchInfo->n_ett[k]; i++) {
			//if (subchInfo->eits[k]->event[i].ETM_location == ETM_none)  continue;
			
			if (subchInfo->etts[k][i] == NULL) {
				if (subchInfo->eits[k]->event[i].ETM_location == ETM_none)
					OS_DbgPrintf("........ETT-%d [%d] : None\n", k, i);
				else {
					UINT32 etmid = PSIUTIL_MakeEventETMID(subchInfo->source_id, subchInfo->eits[k]->event[i].event_id);
						// cafrii 041028, MakeETMID -> MakeEventETMID
						
					// 아직 수신이 안된 것인지, 아니면 겹치는게 있는 것인지 조사..
					BOOL bMatchExist = FALSE;
					int t1, t2;
					
					for (t1=k; t1>=0; t1--) {  // 하나씩 거꾸로 되돌아가면서..
						if (subchInfo->etts[t1] == NULL) continue;
						for (t2=0; t2<subchInfo->n_ett[t1]; t2++) {
							if (subchInfo->etts[t1][t2] && subchInfo->etts[t1][t2]->ETM_id == etmid) {
								bMatchExist = TRUE;
								break;
							}
						}
						if (bMatchExist) break;
					}
					
					if (bMatchExist)
						OS_DbgPrintf("........ETT-%d [%d] : same etm (0x%x) exist\n", k, i, etmid);
					else
						OS_DbgPrintf("........ETT-%d [%d] : **** Not loaded yet, etmid 0x%x, pid 0x%x ****\n", 
										k, i, etmid, chInfo->smgt.ett_pids[k]);
				}
				continue;
			}
			
			OS_DbgPrintf("........ETT-%d [%d] : 0x%x (pid 0x%x)\n", 
					k, i, subchInfo->etts[k][i], chInfo->smgt.ett_pids[k]);  // 에러가 발생했다면 0x0 으로 표시된다.
					// cafrii 050413 ett pid 표시 추가.
			
 			PSIUTIL_PrintEtt(subchInfo->etts[k][i], 8);
			OS_DbgPrintf("\n");
		
		}
	}
	
	
label_exit:

	LockPsiDB(FALSE); //------------------
	//OS_UsePrintfSemaphore(org_flag);

#undef OS_DbgPrintf
	
}