/*
	DMW_ChannelTune.c
	
	
	
*/



#include "DMW_Platform.h"




#include "DHL_DBG.h"
#define Demux_tsdStart(a,b)

#include "DMW_Config.h"
#include "DMW_DebugUtil.h"
#include "DMW_Status.h"

#include "DMW_Channel.h"
#include "DMW_ChannelUtil.h"
#include "DMW_ChannelDemux.h"

#include "DMW_ChannelPM.h" // Performance monitor

//#include <string.h>


DHL_MODULE("$dmc", 1);





#if USE_PERF_MON

static char *PM_EV_Name[] =
{
	"Total", // total elapsed time for tuning
	"Stop",  // previous video stop
	"Lock",  // tuner/demod lock
	"PSIP",  // download psip
	"PSI",   // download psi
	"AV",    // video+audio
	"Video", // video context creation
	"Audio", // audio start and detect
	"Callback", // tune complete callback
};

DHL_PM_HANDLE gDmcPMTune;

#endif





// Config Param: [0 ~ 100]  Tuner 드라이버의 신호세기 리턴 범위 지정
//
// 디지털 채널에서 Signal strengh threshold
//
// channel scan을 진행하기 위해 필요한 최저 신호 세기.
// 설령 lock이 되었더라도 이 신호세기만큼 잡히지 않으면 채널 Lock이 안된 것으로 
// 간주한다. 이 값은 디지털 채널에서만 적용된다.  
// 0은 특별한 의미로서, 신호세기에 무관하게 lock 여부로만 판단하여 진행하도록
// 한다.
//
int g_SignalThresholdForDigitalChannel = 0;


//
// Config Param: TRUE or FALSE
//
// 테스트 변수
//
// TRUE이면 tuning할 때 signal lock 체크를 하지 않는다.
// signal 관련된 테스트를 할 때 사용.
// 
int gDmcTestSkipCheckSignalLock = 0;



//
// Config Param: TRUE or FALSE
//
// 테스트 변수
//
// TRUE이면 tuning할 때 VCT를 수신하지 못한 것 처럼 동작한다.
// 
// cafrii 060628 addd
//
int gDmcTestSkipVctDownload = 0;



// TuneParam
//   1. AV Decoding에 필요한 Request Parameter. RfTune의 함수 인자로 application이 제공.
//   2. TuneCallback을 통해서 tuning의 결과가 넘겨질때 Dmc code가 app로 제공함.

typedef struct
{
	TuneParam param;

	int rf, program_number; // 이 정보는 video cache indicator로 사용된다.
	
	// Video/Audio decoding..
	UINT32 pcrPid, vidPid, audPid;

	// cafrii 070718 add
	BOOL pid_tune_fail_count;
	UINT32 pid_tune_fail_time;

	MPEG_PAT *pat;
	MPEG_PMT *pmt;
	xvctPtr_t vct;
	
	VideoStreamDescriptor *vidDesc;
	
	tDHL_VideoCodingType  vidType; /* add for avc */
	
	tDHL_AudioCodingType  audType;

} ChannelTuneContext;






#if COMMENT
_______DMC_CORE3________(){}
#endif


//-------------------------------------------------------


xvctChannelPtr_t doDmc_FindNextVctChannel(xvctPtr_t vctPtr, UINT32 currentMajorMinor, 
					BOOL bSkipNonFamilyChannel, BOOL bSkipHiddenChannel)
{
	int i;
	xvctChannelPtr_t channel;
	UINT32 minMajorMinor, tmpMajorMinor;
	int minIndex;
	UINT16 major, minor;
	
	if (!vctPtr) return NULL;
	
	// 지정된 채널 번호 (currentMajorMinor) 부터 검색.
	//

	// currentMM 보다 큰 MM 중에서 최소 MM을 찾는다.
	// 단 CTF_RetryOtherFamilyChannel 모드에서는 Major가 같은 채널로 제한함.
	//
	//dprint(2, " find minimum minor..\n");
	minMajorMinor = (UINT32)(-1);
	minIndex = -1;
	
	for (i=0; i<vctPtr->numChannels; i++)
	{
		channel = &vctPtr->channel[i];
		if (channel == NULL) continue;

		major = Dmc_GetMajorNumber(vctPtr->is_cvct, channel);
		minor = Dmc_GetMinorNumber(vctPtr->is_cvct, channel);

		if (bSkipHiddenChannel && channel->hidden)
			continue;

		if (bSkipNonFamilyChannel && (currentMajorMinor >> 16)) {
			// FamilyChannel 모드: 발견되었더라도 Major가 꼭 일치해야 한다.
			//
			if ((currentMajorMinor >> 16) != major) {
				dprint(2, "!! skip non-family channel %d,%d\n", major, minor);
				continue;
			}
		}

		//dprint(2, "       [%d] %d-%d\n", i, major, minor);
		tmpMajorMinor = (major<<16UL) + minor;
		if (currentMajorMinor >= tmpMajorMinor) continue; // 더 작은 채널번호. skip!

		if (minMajorMinor > tmpMajorMinor) {
			minMajorMinor = tmpMajorMinor;
			minIndex = i;
		}
	}

	if (minIndex < 0)  // 더이상 없음.
		return NULL;
		
	channel = &vctPtr->channel[minIndex];
	
	return channel;
}



// cafrii 060710 add
//
//  vct의 program number에 해당하는 프로그램이 PAT에 없는 경우,
//  vct의 program number의 PMT가 수신이 안되는 경우,
//  vct의 program number 정보가 잘못된 것으로 가정하고 복구를 수행한다.
//  등록된 모든 PMT를 수신해서 가장 비슷한 PMT의 program number로 교체한다.
//
//  [IN] xvctChannelPtr_t channel : 복구할 vct channel.
//       pat
//
//  [OUT] 새롭게 수신 된 pmt
// 
STATUS doDmc_RecoverVctProgramNumber(ChannelTuneContext *ctx, xvctChannelPtr_t channel)
{
	STATUS status;
	int k;
	int _second = 1000;

	MPEG_PAT *pat = ctx->pat;
	MPEG_PMT *pmt = NULL;

	PidInfo pid1, pid2;

	if (channel == NULL)
		return statusInvalidArgument;

	dprint(2, "doDmc_RecoverVctProgramNumber(#%d):\n", channel->program_number);

	if (ctx->pmt) {
		dprint(2, "\tfree previous PMT.. program num %d\n", ctx->pmt->program_number);
		FreePMT(ctx->pmt);
		ctx->pmt = NULL;
	}

	if (ctx->pat == NULL)
		return statusInvalidPSI;
	
	// PAT 수신을 더이상 시도하지 않는다. 
	// 이 함수가 불리는 단계라면 이미 몇 번 PAT 수신에 실패한 경우일 것임.
	//

	if (pat->numPrograms == 0 || pat->programs == NULL) {
		dprint(1, "!! invalid PSI.. no program in pat?\n");
		status = statusInvalidPSI;
		goto label_end_function;
	}

	//--------------------
	//  VCT processing
	
	memset(&pid1, 0, sizeof(pid1));

	status = Dmc_GetInfoFromVctDesc(channel->descriptors, 
				channel->descriptor_length, &pid1, NULL);

	if (status) {
		dprint(2, "!! vct pid info invalid. cannot recover\n");
		return statusInvalidVCT;
	}

	//--------------------
	//  PMT processing

	dprint(2, "  load %d pmts\n", pat->numPrograms);
	
	for (k=0; k<pat->numPrograms; k++)
	{
		dprint(2, "    [%d] get pmt #%d, pid %x\n", k, 
			pat->programs[k].program_number, pat->programs[k].program_map_PID);

		if (pmt) {
			FreePMT(pmt);
			pmt = NULL;  // cafrii 060719 bugfix!! PR DS075 fix
		}
		status = Dmc_GetPMT(Dmc_GetCurrentTsd(), pat->programs[k].program_map_PID,
						pat->programs[k].program_number, &pmt, 
						g_Timeout_PmtLoading*_second/1000, Dmc_CheckCancel);

		if (status == statusCancelled) goto label_cancelled;

		else if (status) {
			dprint(2, "\t !! PMT[%d] load failed, %d\n", k, status);
			continue;
		}

		// pmt의 pid 정보와, vct의 pid 정보가 일치하면 서로 같은 program으로 보고
		// vct의 program number를 수정하자!

		status = Dmc_GetPidInfoFromPMT(pmt, &pid2);

		if (status) {
			dprint(2, "\t PMT[%d] pid info err %d\n", k, status);
			continue;
		}

		if (pid1.pcr == pid2.pcr &&
			pid1.video == pid2.video &&
			pid1.audio == pid2.audio)
		{
			dprint(2, "\tcorrect pmt found. recover #%d -> #%d\n", 
					channel->program_number, pmt->program_number);
			channel->program_number = pmt->program_number;

			if (ctx->pmt)
				FreePMT(ctx->pmt);
			
			ctx->pmt = pmt;
			pmt = NULL;

			goto label_end_function;
		}
	}

	dprint(2, "\tproper pmt not found.\n");
	goto label_end_function;
	
label_cancelled:
	status = statusCancelled;
	
label_end_function:

	if (pmt)
		FreePMT(pmt);

	return status;

}


//  
//  해당 program number에 해당하는 PAT/PMT를 수신한다.
//    statusOK
//    statusInvalidPSI
//    statusNoPSI
//    statusCancelled
//
STATUS doDmc_GetPmtByProgramNumber(ChannelTuneContext *ctx, UINT16 program_number)
{
	return Dmc_GetPmtByProgramNumber(&(ctx->pat), &(ctx->pmt), 
					program_number, doDmc_CheckCancel);
}



// cafrii 070201 add
void doDmc_NotifyPidInfo(UINT16 uVidPid, UINT16 uAudPid, UINT16 uPcrPid, UINT16 uPmtPid)
{
	DecodingPidReadyParam dprp;
	
	dprp.vid_pid = uVidPid;
	dprp.aud_pid = uAudPid;
	dprp.pcr_pid = uPcrPid;
	dprp.pmt_pid = uPmtPid;
	
	doDmc_Notify(DMW_NOTIFY_DecodingPidReady, (UINT32) &dprp);	
}



//  doDmc_DownloadTables
//
//  Digital tuning 에서 호출되어 TVCT, CVCT, PAT를 동시에 수신한다.
//  수신된 VCT들은 xvct로 통합되어 관리된다.
//
//  리턴값은 statusOK 아니면 statusCancelled 만 가능하다.
//  자세한 에러 상황은 리턴되지 않으며, 결과 pointer를 보고 판단해야 한다.
// 
STATUS doDmc_DownloadTables(ChannelTuneContext *ctx)
{
	tvctPtr_t tvct = NULL;
	cvctPtr_t cvct = NULL;
	
	STATUS status;
	int _second = 1000;
	
	//------------
	
	dprint(1, "downloading tables..\n");

	//-------------
	// 이미 TuneParam에 뭔가 받아진게 있으면 삭제한다.
	// 이 함수는 RfTune 초기에 불리기 때문에 어떠한 table도 받아져있으면 안된다.
	
	ctx->vct = NULL;
	ctx->pat = NULL;
	
	//------ Table 로딩 (synchornous 방식)

	status = Dmc_GetVctAndPat(Dmc_GetCurrentTsd(), 
					&tvct, &cvct,
					&ctx->pat, 
					g_Timeout_VctLoading*_second/1000, Dmc_CheckCancel);
	//
	// pat와 (tvct나 cvct) 둘 중 하나만 수신되면 일단 리턴한다. 
	// 물론 동시에 둘 다 수신될 가능성도 있다.

	if (status == statusCancelled)
		return statusCancelled;

	// TVCT, CVCT가 둘 다 수신이 안될 수도 있다. 설령 PAT는 수신이 되었다고 하더라도 
	// 진행하지는 않도록 하자.
	//
	if (tvct == NULL && cvct == NULL) {
		dprint(1, "!! No VCTs found\n");
		return statusNoVCT;  // 리턴값은 별 의미가 없다.
	}
	
	// Antenna 모드에서는 CVCT가 수신이 되었어도 이것을 사용하지 않도록 한다.
	
	if (cvct && g_CurChannelType == ChannelType_Cable)
	{
		status = Dmc_TranslateCvct(cvct, &(ctx->vct));
		if (status == statusOK)
			dprint(2, "\tCVCT found. total %d channels\n", ctx->vct->numChannels);
		else {
			dprint(0, "!! cvct->vct err %d\n", status);
			ctx->vct = NULL;
		}
	}
	else if (tvct)
	{
		status = Dmc_TranslateTvct(tvct, &(ctx->vct));
		if (status == statusOK)
			dprint(2, "\tTVCT found. total %d channels\n", ctx->vct->numChannels);
		else {
			dprint(0, "!! cvct->vct err %d\n", status);
			ctx->vct = NULL;
		}
	}
	
	if (tvct)
		FreeAtscTable(tvct);
	if (cvct)
		FreeAtscTable(cvct);

	if (gDmcTestSkipVctDownload) // cafrii 060628 add
		Dmc_FreeAtscTable(&ctx->vct);
		
	return status;
	
}



//  doDmc_TuneByVctChannel
//  
//  선택된 VCT subchannel 정보를 이용하여 디지털 튜닝을 수행한다.
//  튜닝하기 전에 항상 일치하는 PSI 정보가 있는지를 확인한다.
//
//    statusOK
//    statusInvalidPSI, statusInvalidVCT, statusNoPSI
//    statusVideoError
//    statusCancelled
//
STATUS doDmc_RfTuneByVctSubChannel(ChannelTuneContext *ctx, xvctChannelPtr_t channel)
{
	STATUS status;
	TuneParam *tuneParam = &ctx->param;
	DMC_VIDEO_CACHE cache;
	PidInfo pidinfo;

	if (channel == NULL) return statusInvalidArgument;

	dprint(2, "\ttune vct subchannel #%d\n", channel->program_number);
#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSI_LOAD, 0);
#endif
	
	status = doDmc_GetPmtByProgramNumber(ctx, channel->program_number);
	
	if (status == statusCancelled) 	// PMT 받는 작업은 blocking 작업이므로 cancel 체크 필요.
		return statusCancelled;

	if (status != statusOK || ctx->pat == NULL || ctx->pmt == NULL)
	{
		if (tuneParam->flag & CTF_DontUseVctRecover)
			return statusInvalidVCT;
			
		// cafrii 060707 add
		// vct의 program number가 잘못된 경우가 있다.
		// vct를 비롯한 PSIP에는 여러 많은 정보가 있으므로, 
		// 이를 그냥 버리기는 아깝다. 
		// 그래서 smart 하게 program number를 복구하는 작업을 수행한다.

		status = doDmc_RecoverVctProgramNumber(ctx, channel);

		// 수행 결과에 따라 channel->program_number가 변경 될 수도 있다.

		if (status == statusCancelled) 	// PMT 받는 작업은 blocking 작업이므로 cancel 체크 필요.
			return statusCancelled;
	}

	// cafrii 070718 change
	// 나중에 pid가 완전히 결정 된 후에 update하도록 하자.
	//ctx->pcrPid = ctx->vidPid = ctx->audPid = 0;
	
	status = Dmc_DecidePidInfo2(ctx->pmt, channel->descriptors, 
					channel->descriptor_length, &pidinfo, 0);
	
	if (status == statusOK && pidinfo.bValid) {
		dprint(2, "\t pid decided. pva %x %x %x, type va %d %d\n", 
			pidinfo.pcr, pidinfo.video, pidinfo.audio,
			pidinfo.videoType, pidinfo.audioType);
	}
	else {
		pidinfo.pcr = pidinfo.video = pidinfo.audio = 0;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSI_LOAD, 1);
#endif

	doDmc_SelectAudioStream(ctx->pmt, channel, &(pidinfo.audio), &(pidinfo.audioType));
	doDmc_SelectVideoStream(ctx->pmt, channel, &(pidinfo.video), &(pidinfo.videoType));

	if (pidinfo.pcr == 0 || 
		(pidinfo.video == 0 && pidinfo.audio == 0)) {
		dprint(1, "!! No valid video or audio pid..\n");
		return statusInvalidVCT;
	}

	// cafrii 070718 add check.
	// 이 전에 이미 실패한 pid라면 다시 시도할 필요가 없음.
	if (ctx->pid_tune_fail_count > 0 &&
		DHL_OS_GetMsCount() - ctx->pid_tune_fail_time < 1000*20 &&
		ctx->pcrPid == pidinfo.pcr &&
		ctx->vidPid == pidinfo.video &&
		ctx->audPid == pidinfo.audio &&
		ctx->vidType == pidinfo.videoType &&
		ctx->audType == pidinfo.audioType)
	{
		dprint(0, "!! pid pvat (%x %x %x %x) already failed at %u ms before..\n",
			ctx->pcrPid, ctx->vidPid, ctx->audPid, ctx->audType,
			(DHL_OS_GetMsCount() - ctx->pid_tune_fail_time)*1000/1000);
		return statusInvalidVCT;
	}	

	ctx->pcrPid = pidinfo.pcr;
	ctx->vidPid = pidinfo.video;
	ctx->audPid = pidinfo.audio;
	ctx->audType = pidinfo.audioType;
	ctx->vidType  = pidinfo.videoType;

	// 모든 pid 정보가 준비 되었음.
	// 특정 descramble system의 경우 pmt pid 정보를 필요로 하기도 하므로
	// callback을 통해서 pid 정보를 notify해준다.

	if (ctx->pmt) { // cafrii 070711 bugfix! check pmt null
		// cafrii 070201 add
		doDmc_NotifyPidInfo(ctx->vidPid, ctx->audPid, ctx->pcrPid, ctx->pmt->PID);
	}
	
	dprint(2, "\tdecoding p%x, v%x(t%d), a%x(t%d) start..\n", 
			 ctx->pcrPid, ctx->vidPid, ctx->vidType, ctx->audPid, ctx->audType);


// arzhna, 100203
// VCT에 의한 Tune도 CA PMT를 전달하도록 수정
// APP에서 CableCard장착시 튜닝 모드에 대해 취사 선택하도록 한다
//
// doDmc_Notify()로 app에 notify,
// app에서 처리하여 CARD에 report한다.
	{
		PSIChangeNotifyInfo pcni;
		memset(&pcni, 0, sizeof(pcni));
	
		pcni.pmtchanged = TRUE; 	// This is PMT
		pcni.pmt = ctx->pmt;          // new PMT	

		// CableCard 모드에서는 PSI로만 튜닝을 하는데,
		// 튜닝을 하기 전에 PMT report를 수행한다.
		dprint(2, "\tReport CaPmt (pid %d,%d)\n", ctx->vidPid, ctx->audPid);

		// arzhna, 100203
		// CA PMT를 전달하기 위한 callback 호출 
		// DMC_NOTIFY_CaPmt event를 별도로 만들어 처리 
		doDmc_Notify(DMC_NOTIFY_CaPmt, (UINT32)&pcni);	
	}


#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 0);
#endif

#if SUPPORT_DMW_VIDEO_CACHE
	// 혹시 cache 정보가 있는지 load 해본다.
	cache = DHL_AV_LoadVideoFromCache(ctx->rf, ctx->program_number, 
					ctx->vidPid, ctx->pcrPid);
#else
	cache = (DMC_VIDEO_CACHE)NULL;
#endif

	status = doDmc_StartDigital(ctx->vidPid, ctx->audPid, ctx->pcrPid, cache, ctx->vidType, ctx->audType);

	// Video Context를 만드는 작업 역시 blocking 작업이므로 cancel 체크..
	if (status == statusCancelled) {
		doDmc_ClearProgramInfo();
		return statusCancelled;
	}
		
	if (status) {
		dprint(1, "!! cannot start with CVCT pids, status %d\n", status);
		doDmc_ClearProgramInfo();
		return status; // statusScrambled, statusVideoError, ...
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 1);
#endif

	doDmc_UpdateProgramInfoDigital(tuneParam->rf, tuneParam->type, TUNE_METHOD_ByVCT,
			Dmc_GetMajorNumber(ctx->vct->is_cvct, channel), //tuneParam->major
			Dmc_GetMinorNumber(ctx->vct->is_cvct, channel), //tuneParam->minor
			channel->program_number,
			ctx->vidPid, ctx->audPid, ctx->pcrPid, ctx->vidType, ctx->audType);
		// retry flag가 사용되었다면 실제 user가 지정한 major/minor 와 다를 수 있다. 주의..
		// cafrii 060725, tune param의 major/minor 값 보다, vct의 정보를 보여주자.

	doDmc_UpdatePsiInfo(ctx->pat, ctx->pmt);
	ctx->pat = NULL;
	ctx->pmt = NULL;
	
	return statusOK;

}



// doDmc_RfTuneByVct
// 
//  다운로드 받은 VCT를 이용하여 튜닝을 한다. (tuneParam->vctPtr)
//  TuneParam에 있는 사용자의 요구사항대로 튜닝을 한다 (major/minor)
//  
//
// 가능한 리턴값들:
//  statusOK              : AV decoding success
//  statusCancelled       : user에 의해 취소 되었음
//  statusNoVCT/InvalidVCT/NoPSI
//  statusInvalidVCT      : VCT의 내용이 올바르지 못하여 진행 안됨
//  statusChannelNotFound : 사용자가 지정한 채널을 찾지 못했음.
//  statusVideoError      : 모든 정보를 제대로 수신하였으나 AV decoding시에 에러 발생

STATUS doDmc_RfTuneByVct(ChannelTuneContext *ctx)
{
	int i;
	STATUS status;
	STATUS returnStatus = statusOK;  // 최종적으로 이 함수를 return 할 때 사용할 status값..
	UINT16 major, minor;
	
	xvctChannelPtr_t channel;
	UINT32 currentMajorMinor;
	BOOL bChannelFound;
	
	TuneParam *tuneParam = &ctx->param;

	dprint(1, "doDmc_RfTuneByVct: %d-%d\n", tuneParam->major, tuneParam->minor);
	
	if (ctx->vct == NULL)
		return statusInvalidState;
		
	if (tuneParam->major == 0)
	{
		//-------------------
		// unspecified tuning
		// caller가 직접 Major/minor를 지정하지 않은 경우이다.
		// tuneParam->major, tuneParam->minor 모두 0 이다.
		// 이때는 자동적으로 retry loop으로 들어간다. 
		// 그러나 계속적으로 retry를 할 것인지 아닌지는 Retry flag에 따라서 결정된다.
		//
		currentMajorMinor = 0;
		dprint(2, "\tunspecified tuning: search from 0-0\n");
		
		goto label_retry_vct;
		
	} // end unspecified tuning

	//-------------------
	// Specified Tuning :
	// 직접 Major/minor 번호를 지정해서 그 채널을 튜닝하는 방법
	// CTF_RetryMainChannel이 set되면 Main채널은 다시 튜닝 시도 한다. (1회한)
	//
	// find 'the channel' major-minor. 정확하게 일치하는 M-m 채널을 찾아야만 한다.
	//
	bChannelFound = FALSE;

	// caller는 직접적으로 OnePartNumber로 호출했을 수도 있고, (minor가 특정 indication값)
	// Raw major/minor로 호출했을 수도 있다. (major 상위 6비트가 1)
	//
	if (tuneParam->minor == ONE_PART_CHANNEL_INDICATOR) {
		dprint(2, "\t  tune with OnePartChannel %d\n", tuneParam->major);
	}
	else if (IsOnePartChannelNumber(tuneParam->major)) 
	{
		// 이것은 Raw major/minor로 호출된 OnePartNumber이다. 변환이 필요하다.
		UINT16 nOnePartChannelNumber;
		nOnePartChannelNumber = ConvertToOnePartChannelNumber(tuneParam->major, tuneParam->minor);
		
		dprint(2, "\t  change %d-%d to OnePartChannelNumber %d\n", 
				tuneParam->major, tuneParam->minor, nOnePartChannelNumber);
		tuneParam->major = nOnePartChannelNumber;
		tuneParam->minor = ONE_PART_CHANNEL_INDICATOR;
	}

	//----------------------------
	//  이제 채널을 찾아본다.
	//
	dprint(2, "\tspecified tuning: try tune %d-%d..\n", tuneParam->major, tuneParam->minor);
	
	for (i=0; i<ctx->vct->numChannels; i++)
	{
		channel = &(ctx->vct->channel[i]);
		
		major = Dmc_GetMajorNumber(ctx->vct->is_cvct, channel);
		minor = Dmc_GetMinorNumber(ctx->vct->is_cvct, channel);
		
		if (major == tuneParam->major && minor == tuneParam->minor) 
		{
			if (!channel->hidden || (tuneParam->flag & CTF_ShowHiddenChannelAlso)) {
				// hidden도 아니고, hidden이더라도 ShowHidden flag가 있으면 처리 가능함..
				bChannelFound = TRUE;
				break;
			}
			else {
				dprint(2, "!! channel found, but hidden! ignore it!\n");
				bChannelFound = FALSE;
			}
		}
	}

	if (bChannelFound)
	{
		dprint(2, "\tchannel %d-%d found. (specified channel)\n", major, minor);

		status = doDmc_RfTuneByVctSubChannel(ctx, channel);

		if (status == statusCancelled)
			return statusCancelled;
		
		if (status == statusOK) {
			return statusOK;
		}
		returnStatus = status;
	}
	else 
	{
		dprint(1, "!! %d-%d not found in CVCT\n", tuneParam->major, tuneParam->minor);
		returnStatus = statusChannelNotFound;
	}
	
	// specified tuning 방법을 사용했을때 tuning에 실패하면
	// 현재 옵션에 따라서 retry를 할 것인지 아닌지를 결정한다.
	//

	if ((tuneParam->flag & CTF_RetryOtherChannel)) {
		dprint(2, "\t retry other channel.. search from %d-%d\n", 
							tuneParam->major, tuneParam->minor);
		currentMajorMinor = (tuneParam->major << 16UL) + (tuneParam->minor);
			// 현재 채널 MM: retry를 할때 검색의 시작점이 된다.
	}
	else {
		// 재시도를 하지 않는다. 에러를 리턴함.
		//  returnStatus는 최종 에러 값을 보유하고 있다.
		//  returnStatus : ChannelNotFound, VideoError, InvalidVCT 등.
		//
		return returnStatus;
	}

label_retry_vct:

	//---------------------		
	// VCT retry mode
	//
 	// Retry모드일 경우 에러가 발생하면 계속 반복한다. 
 	// 더이상 채널 정보가 없을 때 까지 반복.
 
 	while (1)
	{
		// currentMM 보다 "큰" MM 중에서 최소 MM을 찾는다.
		// 단 CTF_SkipNonFamilyChannel 모드에서는 Major가 같은 채널로 제한함.
		//
		channel = doDmc_FindNextVctChannel(ctx->vct, currentMajorMinor, 
						(tuneParam->flag & CTF_SkipNonFamilyChannel) ? TRUE : FALSE, 
						(tuneParam->flag & CTF_ShowHiddenChannelAlso) ? FALSE : TRUE);
		
		if (channel == NULL) { // 더이상 원하는 채널 없음.
			dprint(1, "\tNo more valid channel in VCT\n");
			return statusChannelNotFound;
		}
				
		// 채널이 발견되었음. 'channel' pointer가 가리키는 곳에 원하는 정보가 있다.

		major = Dmc_GetMajorNumber(ctx->vct->is_cvct, channel);
		minor = Dmc_GetMinorNumber(ctx->vct->is_cvct, channel);
		
		currentMajorMinor = (major << 16UL) + minor;
		dprint(2, "\t  found channel  %d-%d (unspecified or retry channel)\n", major, minor);
		
		status = doDmc_RfTuneByVctSubChannel(ctx, channel);
		
		if (status == statusCancelled)
			return statusCancelled;
		
		if (status == statusOK) {
			return statusOK;
		}
		returnStatus = status;
		
		// 채널 검색에 실패. 다음 채널로 재시도 하기 전에 retry 모드인지 아닌지 체크를 한다.
		if ((tuneParam->flag & CTF_RetryOtherChannel)) {
			dprint(2, "!! cannot start %d-%d in CVCT! try next channel..\n", major, minor);
			continue;
		}
		else {
			// retry 모드가 아니므로 그냥 실패로 종료. returnStatus는 마지막 에러 값을 가지고 있다.
			dprint(2, "!! failed in starting %d-%d in CVCT! No retry, last err %d\n", 
						major, minor, returnStatus);
			// returnStatus: InvalidVCT or VideoError 등..
			return returnStatus;
		}
	}

}




STATUS doDmc_RfTuneByPsiSubChannel(ChannelTuneContext *ctx, int PmtPID, int program_number)
{
	STATUS status;
	TuneParam *tuneParam = &ctx->param;
	DMC_VIDEO_CACHE cache;
	PidInfo psiPid;

	if (ctx->pmt) {
		dprint(2, "\tfree previous pmt\n");
		FreePMT(ctx->pmt);
		ctx->pmt = NULL;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSI_LOAD, 0);
#endif
	
	status = Dmc_GetPMT(Dmc_GetCurrentTsd(), PmtPID, program_number, 
					&ctx->pmt, 
					g_Timeout_PmtLoading*1000/1000, 
					Dmc_CheckCancel);

	if (status == statusCancelled) 
		return statusCancelled;

	else if (status) {
		dprint(1, "!! PMT load failed.\n");
		return statusNoPSI;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSI_LOAD, 1);
#endif

	// cafrii 070718 change
	// 나중에 pid가 완전히 결정 된 후에 update함.
	//ctx->pcrPid = ctx->vidPid = ctx->audPid = 0;

	status = Dmc_DecidePidInfo(ctx->pmt, NULL, &psiPid, 0);

	if (status == statusOK && psiPid.bValid) 
	{
		dprint(2, "\t pid from pmt decided. pva %x %x %x, type va %d %d\n", 
			psiPid.pcr, psiPid.video, psiPid.audio,
			psiPid.videoType, psiPid.audioType);
	}
	else {
		// 에러 체크는 아래에서 audio pid 까지 결정 된 다음에 하자.
		psiPid.pcr = psiPid.video = psiPid.audio = 0;
	}

	doDmc_SelectAudioStream(ctx->pmt, NULL, &(psiPid.audio), &(psiPid.audioType));
	doDmc_SelectVideoStream(ctx->pmt, NULL, &(psiPid.video), &(psiPid.videoType));

	if (psiPid.pcr == 0 || 
		(psiPid.video == 0 && psiPid.audio == 0)) 
	{
		dprint(1, "!! No valid video or audio pid..\n");
		return statusInvalidPSI;
	}

	// cafrii 070718 add check.
	// 이 전에 이미 실패한 pid라면 다시 시도할 필요가 없음.
	if (ctx->pid_tune_fail_count > 0 &&
		DHL_OS_GetMsCount() - ctx->pid_tune_fail_time < 1000*20 &&
		ctx->pcrPid == psiPid.pcr &&
		ctx->vidPid == psiPid.video &&
		ctx->audPid == psiPid.audio &&
		(ctx->audType == 0 || ctx->audType == psiPid.audioType))
	{
		dprint(0, "!! pid pvax (%x %x %x %x) already failed at %u ms before..\n",
			ctx->pcrPid, ctx->vidPid, ctx->audPid, ctx->audType,
			(DHL_OS_GetMsCount() - ctx->pid_tune_fail_time)*1000/1000);
		return statusInvalidPSI;
	}	

	// 모든 pid 정보 준비 완료.
	ctx->pcrPid = psiPid.pcr;
	ctx->vidPid = psiPid.video;
	ctx->audPid = psiPid.audio;
	ctx->audType = psiPid.audioType;
	ctx->vidType = psiPid.videoType;


	// cafrii 070412, add check pmt null
	if (ctx->pmt) { 
		// cafrii 070201 add
		doDmc_NotifyPidInfo(ctx->vidPid, ctx->audPid, ctx->pcrPid, ctx->pmt->PID);
	}

	dprint(2, "\t vPid %x (t%d), aPid %x (t%d), pPid %x decoding start..\n",
			ctx->vidPid, ctx->vidType, ctx->audPid, ctx->audType, ctx->pcrPid);

// arzhna, 100129
// doDmc_Notify()로 app에 notify,
// app에서 처리하여 CARD에 report한다.
// 기존의 루틴은 삭제 
	{
		PSIChangeNotifyInfo pcni;
		memset(&pcni, 0, sizeof(pcni));
	
		pcni.pmtchanged = TRUE; 	// This is PMT
		pcni.pmt = ctx->pmt;          // new PMT

		// CableCard 모드에서는 PSI로만 튜닝을 하는데,
		// 튜닝을 하기 전에 PMT report를 수행한다.
		dprint(2, "\tReport CaPmt (prog# %d, pid %d,%d)\n", 
					program_number, ctx->vidPid, ctx->audPid);
		
		// arzhna, 100203
		// CA PMT를 전달하기 위한 callback 호출 
		// DMC_NOTIFY_CaPmt event를 별도로 만들어 처리 
		doDmc_Notify(DMC_NOTIFY_CaPmt, (UINT32)&pcni);	
		}
		
#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 0);
#endif

#if SUPPORT_DMW_VIDEO_CACHE
	// 혹시 cache 정보가 있는지 load 해본다.
	cache = (DMC_VIDEO_CACHE)DHL_AV_LoadVideoFromCache(ctx->rf, ctx->program_number, 
						ctx->vidPid, ctx->pcrPid);
#else
	cache = (DMC_VIDEO_CACHE)NULL;
#endif

	status = doDmc_StartDigital(ctx->vidPid, ctx->audPid, ctx->pcrPid, cache, ctx->vidType, ctx->audType);

	if (status == statusCancelled) {
		doDmc_ClearProgramInfo();
		return statusCancelled;
	}
	
	if (status) {
		doDmc_ClearProgramInfo();
		return status;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 1);
#endif

	doDmc_UpdateProgramInfoDigital(tuneParam->rf, tuneParam->type, TUNE_METHOD_ByPSI,
						0, 0, program_number,
						ctx->vidPid, ctx->audPid, ctx->pcrPid, ctx->vidType, ctx->audType);

	doDmc_UpdatePsiInfo(ctx->pat, ctx->pmt);
	ctx->pat = NULL;
	ctx->pmt = NULL;

	return statusOK;	
}



/***********
	CmdRfTune 함수에서 풀리는 Sub-fuction이다.
	
	NIM의 frequency & demod 설정은 완료된 상태..
	PSI 데이터 (PAT/PMTs)를 다운로드 받아 참조하여 tuneParam에서 지정한 대로 튜닝을 시도한다.
	프로그램을 선택하는데 tuneParam->progNumber를 사용한다.
	
***********/
STATUS doDmc_RfTuneByPsi(ChannelTuneContext *ctx)
{
	int i;
	STATUS status;
	STATUS returnStatus;

	int _second = 1000;
	int idx;  // PAT index
	TuneParam *tuneParam = &ctx->param;
	
	if (Dmc_CheckCancel()) goto label_cancelled;

	dprint(1, "RfTuneByPsi: prognum %d\n", tuneParam->progNumber);

	// pat가 수신이 안되어 있는 경우라면 다시 수신한다.
	//
	if (ctx->pat == NULL) {
		dprint(2, "\tGet New PAT..\n");
		status = Dmc_GetPAT(Dmc_GetCurrentTsd(), &ctx->pat, 
							g_Timeout_PatLoading*_second/1000, 
							Dmc_CheckCancel);

		if (status == statusCancelled) goto label_cancelled;
	
		else if (status) {
			dprint(1, "!! PAT load failed, %d\n", status);
			returnStatus = statusNoPSI;
			goto label_end_tune;
		}
		if (Dmc_CheckCancel()) goto label_cancelled;
	}

	dprint(2, "\tPAT found. total %d programs\n", ctx->pat->numPrograms);

	if (ctx->pat->numPrograms == 0 || ctx->pat->programs == NULL) {
		dprint(2, "!! invalid PSI.. no program!\n");
		returnStatus = statusInvalidPSI;
		goto label_end_tune;
	}		

	if (tuneParam->progNumber == 0) {
		// Unspecified tuning.
		// caller가 특정 프로그램 번호를 지정하지 않은 경우이다.
		// 이 경우 대표 프로그램 (Main program)을 선택해야 하는데,
		// 현재는 그냥 맨 처음 것을 사용한다.
		
		idx = 0; // 맨 처음 프로그램 부터 검색 시작한다.
		tuneParam->progNumber = ctx->pat->programs[0].program_number; 
		// 이렇게 하면 항상 반드시 찾아지게 된다.
		dprint(2, "\t unspecified tuning. start from index 0\n");
	}
	else {
		// find 'the program' whose program number is 'progNumber'.
		// if not found, we report error directly.
		//
		idx = -1;
		for (i=0; i<ctx->pat->numPrograms; ++i) {
			if (ctx->pat->programs[i].program_number == tuneParam->progNumber) {
				idx = i;
				break;
			}
		}
	}
	
	if (idx < 0 || idx >= ctx->pat->numPrograms) { // cafrii 060628 bugfix!! i->idx
		dprint(1, "!! program number %d not found!\n", tuneParam->progNumber);
		returnStatus = statusChannelNotFound;
		goto label_end_tune;
	}
	
	//------ Program decoding loop -------------
	// 'idx' is index of program table (PAT)
	// Retry flag가 있는 경우라면 성공 할 때까지 계속 retry를 하게 된다.
	// idx부터 시작해서 모든 program을 모두 검사해본다. (wrap-around)
	// 
	// cafrii 060727 bugfix
	//   무한 루프 도는 문제 수정. cancel은 되니까 치명적이진 않음.
	//   i는 횟수 counting만 하고, idx로 indexing.
	//
	//for (i=idx; i<ctx->pat->numPrograms; i=(i+1)%ctx->pat->numPrograms) 
	for (i=0; i<ctx->pat->numPrograms; i++, idx=(idx+1)%ctx->pat->numPrograms) 
	{
		dprint(2, "\ttry program [%d], pid %d, program number #%d\n", 
						idx, 
						ctx->pat->programs[idx].program_map_PID,
						ctx->pat->programs[idx].program_number);

		// MPEG_PAT
		status = doDmc_RfTuneByPsiSubChannel(ctx, 
					ctx->pat->programs[idx].program_map_PID, 
					ctx->pat->programs[idx].program_number);
		
		if (status == statusCancelled) goto label_cancelled;

		if (status == statusOK) {
			returnStatus = statusOK;
			goto label_end_tune;
		}

		// 그밖의 모든 에러..
		// flag에 따라서 retry의 여부가 결정된다.
		
		if (tuneParam->flag & CTF_RetryOtherProgram) {
			// 다음 program 재시도
			dprint(2, "\t! Psi tune err %d;.. retry other program..\n", status);
			continue;
		}
		else {
			returnStatus = statusInvalidPSI;
			goto label_end_tune;
		}

	} //--------- end for loop -----------

	dprint(1, "!! No valid program! stop!\n");
	returnStatus = statusInvalidPSI;
	goto label_end_tune;


label_cancelled:
	returnStatus = statusCancelled;

label_end_tune:
	return returnStatus;

}





STATUS doDmc_RfTuneSetTuner(ChannelTuneContext *ctx)
{
	STATUS status = statusOK;
	UINT32 tickStartTunerSet;
	BOOL bLocked;   // signal lock status
	int strength;   // signal strength
	int _second = 1000;

	DHL_RESULT dhr;
	UINT32 cap;
	
	TuneParam *tuneParam = &ctx->param;

	// cafrii 060630 add, if already tuned to rf, skip!
	// modulation mode may be different..
	//
	if ((tuneParam->flag & CTF_ForceSetTuner) == 0 &&
		tuneParam->rf == DMW_HAL_GetCurrentRF() &&
		DMW_HAL_DetectNIMChannel())
	{
		//dprint(2, "\talready tuned to rf %d.. skip tune\n", ctx->rf);
		dprint(2, "\talready tuned to rf %d.. skip tuner setting\n", ctx->rf);
		// cafrii 070411 오해 소지가 있는 debug message 문구 수정.
		return statusOK;
	}

	dhr = DHL_FE_GetDeviceInfo(DEFAULT_TUNER_ID, eDHL_FE_DEV_CAPABILITY_1, &cap);
	if (dhr != DHL_OK) {
		dprint(0, "!! dev cap query err %d\n", dhr);
		DHL_ASSERT(FALSE, "");
	}

	tickStartTunerSet = DHL_OS_GetMsCount();

	// 디지털 modulation인 경우
	//
	if (tuneParam->type != Modulation_NTSC)
	{
		int nModeToTry = 0;
		ModulationType aModes[5];

		int i, type, lock_timeout;

		int typeFirstTried; // cafrii 070227 add

		type = tuneParam->type;
		if (type == Modulation_CableAuto) {
			// Cable auto 모드는 Analog 까지 포함하는 것이지만, 
			// 구현이 복잡하므로 그냥 QamAuto 모드로 간주.
			type = Modulation_QAM;
		}
		
		if (tuneParam->flag & CTF_SkipQamModulation)
		{
			dprint(2, "\t Skip QAM mode..\n");
			if (cap & eDHL_TUCAP_VSB) {
				aModes[nModeToTry++] = Modulation_8VSB;
			}
			else
				dprint(0, "!! FE not support VSB, but SkipQam mode requested\n");
		}
		else if (type == Modulation_64QAM || type == Modulation_256QAM)
		{
				// arzhna, 100407
				// QAM Mode가 지정되었을때 지정되지 않은 다른 mode도 try하지 않도록 auto와 나눈다.
			if ((cap & eDHL_TUCAP_QAMAUTO) && (tuneParam->flag & CTF_UseQamAutoMode)) {
				aModes[nModeToTry++] = Modulation_QAM;
			}
			else if (cap & eDHL_TUCAP_QAM) {
				// QAMAUTO는 지원하면서 QAM은 지원하지 않는 FE가 있으면 안됨.
				// 참고로 Capability에는 QAM64와 QAM256에 구분이 없다. 
				// 두 QAM 중에 하나만 지원하는 그런 demod는 없을 거라고 가정함..
				aModes[nModeToTry++] = (ModulationType)type;
			}
			else 
				dprint(0, "!! FE not support QAM, but QAM requested. tucap 0x%x, req %d\n",	cap, type);
		}
		else if (type == Modulation_QAM)
		{
			if ((cap & eDHL_TUCAP_QAMAUTO) && (tuneParam->flag & CTF_UseQamAutoMode)) {
				aModes[nModeToTry++] = Modulation_QAM;
			}
			else if (cap & eDHL_TUCAP_QAM) {
				// 64, 256 각각 나눠서 따로 시도.. 순서는 일단 caller의 param을 존중..
				// Qam auto 를 request 한 경우라면 어짜피 qam auto가 지원 안되므로, 아무거나 먼저..
				if (type == Modulation_QAM) type = Modulation_256QAM;
				aModes[nModeToTry++] = (ModulationType)type;
				aModes[nModeToTry++] = (ModulationType)type == Modulation_64QAM ? Modulation_256QAM : Modulation_64QAM;
			}
			else 
				dprint(0, "!! FE not support QAM, but QAM requested. tucap 0x%x, req %d\n",	cap, type);
		}
		else if (type == Modulation_8VSB) 
		{
			if (cap & eDHL_TUCAP_VSB) {
				aModes[nModeToTry++] = Modulation_8VSB;
			}
			else
				dprint(0, "!! FE not support VSB but VSB requested\n");

			// 지원이 된다면 추가로 QAM 도 시도..
			if ((cap & eDHL_TUCAP_QAMAUTO) && (tuneParam->flag & CTF_UseQamAutoMode)) {
				aModes[nModeToTry++] = Modulation_QAM;
			}
			else if (cap & eDHL_TUCAP_QAM) {
				aModes[nModeToTry++] = Modulation_64QAM;
				aModes[nModeToTry++] = Modulation_256QAM;
			}
		}

		if (nModeToTry == 0) {
			dprint(0, "!! no mode to tune\n");
			status = statusInvalidState;
			goto label_tune_end;
		}
		
		typeFirstTried = type;
		
		for (i=0; i<nModeToTry; i++)  // 세가지 Modulation 방식을 하나씩 try 한다.
		{
			type = aModes[i];
			tickStartTunerSet = DHL_OS_GetMsCount();
			
			dprint(2, "\t%s changing rf %d, type %d (%s), offset %d, autoFreq %d..\n", 
				i ? "!! retry" : "",
				tuneParam->rf, type, ServiceTypeString(type), 
				tuneParam->freqOffset, (tuneParam->flag & CTF_TunerAutoFreqAdjust) ? 1 : 0);

			// cafrii 070710 use return value to check cancel
			status = DMW_HAL_TunerSetChannel(tuneParam->rf, (ModulationType)type, 
						tuneParam->freqOffset, 
						(tuneParam->flag & CTF_TunerAutoFreqAdjust) ? FREQTUNE_SHORT_SEARCH : FREQTUNE_FIXED,
						Dmc_CheckCancel);

			if (status == statusCancelled) 
				goto label_cancelled;

			if (gDmcTestSkipCheckSignalLock) {
				dprint(2, "\tskip signal detect..\n");
				status = statusOK;
				goto label_tune_end;
			}
			if (status)
				goto label_tune_end;
			
			lock_timeout = g_Timeout_SignalLock;  
			
			while (1)  // wait until signal is locked.
			{
				bLocked = DMW_HAL_DetectNIMChannel();
				
				if (bLocked)  // 만약 lock이 되었으면 더 기다리지 않는다. 바로 break.
					break;
	
				if ((DHL_OS_GetMsCount() - tickStartTunerSet) > (unsigned int)lock_timeout*_second/1000)
					break;  // time out!
	
				if (Dmc_CheckCancel()) goto label_cancelled;
				
				DHL_OS_Delay(_second/20); // give chance for other task to take CPU control.
			}
	
			if (Dmc_CheckCancel()) goto label_cancelled;
	
			if (bLocked && g_SignalThresholdForDigitalChannel) 
			{
				strength = DMW_HAL_GetSignalStrength();
				if (strength < g_SignalThresholdForDigitalChannel) {
					dprint(1, "!! signal locked, but strength too weak! %d < threshold %d. stop!\n",
								strength, g_SignalThresholdForDigitalChannel);
					bLocked = FALSE; // signal unlock과 동일하게 처리한다.
				}
			}
	
			if (bLocked) {
				dprint(2, "\tsignal locked. %d ms\n", 
					(DHL_OS_GetMsCount()-tickStartTunerSet)*1000/1000);
				goto label_tune_end;
			}

			// retry를 하지 않는 조건.. NTSC인 경우, Air 모드인 경우..
			
			if (g_CurChannelType == ChannelType_Air)
				break;
			
			// 이 type으로 실패했으므로 다른 type으로 다시 시도한다.
			//
		} // end for modulation type

		// signal is not locked!! do error proccessing..
	
		if (tuneParam->flag & CTF_RetryAnalogIfSignalUnlock) {
			dprint(2, "\t signal unlock. retry Analog mode..\n");
			tuneParam->type = Modulation_NTSC;  // force to NTSC..
			if (tuneParam->rf) {
				dprint(2, "\tchanging tuner rf %d, type %d..\n", tuneParam->rf, 0);
				DMW_HAL_TunerSetChannel(tuneParam->rf, Modulation_NTSC, 0, 
							FREQTUNE_SHORT_SEARCH,
							Dmc_CheckCancel);
					// offset zero, auto adjust TRUE
			}
		}
		else {
			dprint(1, "!! digital signal unlocked. stop!\n");

			// cafrii 070227 add trick code
			// 어짜피 실패한 것인데, 맨 처음 try한 demodulation 방법으로 바꿔 놓자. 
			// 다음 번에 자동 detect가 빨리 될 것임.

			DMW_HAL_TunerSetChannel(tuneParam->rf, (ModulationType)typeFirstTried, 
						tuneParam->freqOffset, 
						(tuneParam->flag & CTF_TunerAutoFreqAdjust) ? FREQTUNE_SHORT_SEARCH : FREQTUNE_FIXED,
						Dmc_CheckCancel);
			// 결과는 체크할 필요 없음..
			
			status = statusNoSignal;
			goto label_tune_end;
		}
	
	}
	else // NTSC tuning
	{
		if (tuneParam->rf) {
			dprint(2, "\tchanging tuner rf %d, type %d, offset %+d, autoFreq %d..\n",
					tuneParam->rf, tuneParam->type, tuneParam->freqOffset,
					(tuneParam->flag & CTF_TunerAutoFreqAdjust) ? 1 : 0);
			DMW_HAL_TunerSetChannel(tuneParam->rf, Modulation_NTSC, 
						tuneParam->freqOffset, 
						//FREQTUNE_SHORT_SEARCH,
						(tuneParam->flag & CTF_TunerAutoFreqAdjust) ? FREQTUNE_SHORT_SEARCH : FREQTUNE_FIXED,
						Dmc_CheckCancel);
				// offset zero, auto adjust TRUE
		}
	}

label_tune_end:
	return status;

label_cancelled:
	return statusCancelled;

}



STATUS doDmc_RfTuneByPidOnly(ChannelTuneContext *ctx)
{
	STATUS status = statusOK;
	TuneParam *tuneParam = &ctx->param;
	DMC_VIDEO_CACHE cache;
	
	//----------------------------------------
	// tune by PIDs..	

	// video pid, audio pid 모두 0으로 설정해서 call하면
	// pre-scan pid tuning 기능을 skip하는 것으로 받아들인다.
	//
	
	if (tuneParam->pcrPid && 
		(tuneParam->vidPid || tuneParam->audPid) && 
		tuneParam->rf && 
		tuneParam->progNumber)  // prescan PID에 의한 튜닝 시도.
	{
		
		dprint(2, "    Try using prescan pids pvat %x %x %x vt %x at %x rf %d #%d..\n",
			tuneParam->pcrPid, tuneParam->vidPid, tuneParam->audPid, 
			tuneParam->vidType, tuneParam->audType,
			tuneParam->rf, tuneParam->progNumber);

		ctx->vidPid = tuneParam->vidPid;
		ctx->audPid = tuneParam->audPid;
		ctx->pcrPid = tuneParam->pcrPid;
		ctx->audType = tuneParam->audType;
		ctx->vidType = tuneParam->vidType;

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 0);
#endif

#if SUPPORT_DMW_VIDEO_CACHE
		// 혹시 cache 정보가 있는지 load 해본다.
		cache = (DMC_VIDEO_CACHE)DHL_AV_LoadVideoFromCache(ctx->rf, ctx->program_number, 
						ctx->vidPid, ctx->pcrPid);
#else
		cache = (DMC_VIDEO_CACHE)NULL;
#endif

		status = doDmc_StartDigital(ctx->vidPid, ctx->audPid, ctx->pcrPid, cache, ctx->vidType, ctx->audType);
		
		if (status == statusCancelled) {
			doDmc_ClearProgramInfo();
			return statusCancelled;
		}
		else if (status) {
			//if (err != timeoutError)
				// timeout 외의 다른 에러라면 문제가 있는 경우이다.
			dprint(1, "!! pre-scan PID tune err %d. continue..\n", status);
			doDmc_ClearProgramInfo();
			// prescan PID 정보를 무시하고 정상적인 방법으로 계속 진행한다.

			// cafrii 070718 add
			ctx->pid_tune_fail_count++;
			ctx->pid_tune_fail_time = DHL_OS_GetMsCount();
				// 나중에 다시 psip/psi로 시도 할 때 pid가 동일하면 다시 시도할 필요가 없어서.
			
			return status;
		}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 1);
#endif
		//
		// 특정 기능을 위해서 현재 재생중인 program의 program_number를 쉽게 알 수 있는
		// 방법이 필요하다.
		// 그러기 위해서 tuning에 직접 사용되지 않았던 파라미터들도
		// 모두 ProgramInfo에 기록을 해 둔다.
		// 단 이 정보가 현재 수신중인 program의 정보와 동일하다는 보장은 할 수 없다.
		// UCM이 아주 오래전에 update된 경우라면 틀릴 가능성도 있다.
		//
		
		doDmc_UpdateProgramInfoDigital(tuneParam->rf, tuneParam->type, TUNE_METHOD_ByPIDs,
							tuneParam->major, tuneParam->minor, 
							tuneParam->progNumber,
							tuneParam->vidPid, tuneParam->audPid, tuneParam->pcrPid, tuneParam->vidType, tuneParam->audType);
		
		// cafrii 040527 add comment
		// 이 방식의 tuning에서만큼은 이 시점에서 PTS 설정을 할 수 없다. PMT를 아직 받지 못했기 때문.
		// PTS 설정은 나중에 PsiMonitor가 가동된 후 PMT가 수신되었을때 한다.
		//
		status = statusOK;

	}
	else
		status = statusInvalidArgument;
	
	return status;	
}






void doDmc_ReturnTuneResult(void *pfnCompleted, STATUS status, 
							UINT32 userparam, UINT32 additionalParam)
{
	DMC_FN_TUNE_COMPLETED fn;
	fn = (DMC_FN_TUNE_COMPLETED) pfnCompleted;
	
	if (fn) {
		dprint(2, "    return %s (%d, '%s') to caller..\n",
			status ? "error" : "success", status, DMW_CDB_ErrString(status));
		fn(status, userparam, (AppRfTuneCallbackParam *) additionalParam);
	}
	else
		dprint(2, "    return %s (%d, '%s') skipped.\n",
			status ? "error" : "success", status, DMW_CDB_ErrString(status));
}


STATUS doDmc_RfTuneAnalog(ChannelTuneContext *ctx)
{
	STATUS status;
	TuneParam *tuneParam = &ctx->param;	
	CaptureParam capParam;

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 0);
#endif

	dprint(2, "\tstart analog video..\n");


// arzhna, 100129
// doDmc_Notify()로 app에 notify,
// app에서 처리하여 CARD에 report한다.
// 기존의 루틴은 삭제 
	//
	// DMC_NOTIFY_CaPmt event를 별도로 만들어 처리 
		dprint(2, "\t Report CaPmt (NULL)\n");
	doDmc_Notify(DMC_NOTIFY_CaPmt, (UINT32)NULL);	
	
	memset(&capParam, 0, sizeof(capParam));
	
	capParam.input_video = eDHL_CAP_NTSC0_VIDEO;
	capParam.input_audio = eDHL_CAP_NTSC0_AUDIO;
	
	status = doDmc_StartAnalog(&capParam);
	if (status) {
		status = statusAnalogError;
		dprint(0, "!! err in start analog, err %d. stop!\n", status);
	}
	else {
		doDmc_UpdateProgramInfoAnalog(tuneParam->rf, 
					eDHL_CAP_NTSC0_VIDEO, eDHL_CAP_NTSC0_AUDIO);
		
		status = statusOK;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_AV_START, 1);
#endif

	return status;
}


STATUS doDmc_CmdRfTune(DmcMessage *pmsg)
{
	STATUS status;
	
	ChannelTuneContext context, *ctx = &context;
	TuneParam *tuneParam;
		// 파라미터로 건네지는 tuneParam은 사용 후 OS_Free시켜야 한다.
		
	dprint(1, "cmdRfTune: cid %d\n", pmsg->cancelId);

	if (pmsg->param == 0) {
		dprint(0, "  !! tuneParam NULL! stop! no callback!!\n");
		return statusInvalidArgument;
	}

#if USE_PERF_MON
	if (gDmcPMTune == 0) {
		gDmcPMTune = DHL_PerfMonInit("DmcTune", 1);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_TOTAL, PM_EV_Name[PM_EV_TUNE_TOTAL]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_STOP, PM_EV_Name[PM_EV_TUNE_STOP]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_LOCK, PM_EV_Name[PM_EV_TUNE_LOCK]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_PSIP_LOAD, PM_EV_Name[PM_EV_TUNE_PSIP_LOAD]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_PSI_LOAD, PM_EV_Name[PM_EV_TUNE_PSI_LOAD]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_AV_START, PM_EV_Name[PM_EV_TUNE_AV_START]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_VIDEO_START, PM_EV_Name[PM_EV_TUNE_VIDEO_START]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_AUDIO_START, PM_EV_Name[PM_EV_TUNE_AUDIO_START]);
		DHL_PerfMonRegister(gDmcPMTune, PM_EV_TUNE_CALLBACK, PM_EV_Name[PM_EV_TUNE_CALLBACK]);
	}
#endif

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_TOTAL, 0);
#endif

	memset(ctx, 0, sizeof(ChannelTuneContext));
	
	(ctx->param) = *(TuneParam *)pmsg->param;  // tune param backup
	ctx->rf = ctx->param.rf;
	ctx->program_number = ctx->param.progNumber;

	
	Dmc_ParamHeapDeallocator(pmsg->param);
	
	tuneParam = &ctx->param;

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_STOP, 0);
#endif
	
	// 기존 비디오가 동작중이면 닫는다.
	doDmc_Stop();

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_STOP, 1);
#endif

	if (Dmc_CheckCancel()) goto label_cancelled;

	//----------------------------------------
	//

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_LOCK, 0);
#endif

	#if 0 // cafrii 060630 delete
	if (! tuneParam->tuneRequired) {
		dprint(2, "\tskip tuner HAL tuning..\n");
	}
	else 
	#endif
	{
		status = doDmc_RfTuneSetTuner(ctx);
		if (status)
			goto label_end_tune;
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_LOCK, 1);
#endif

	if (tuneParam->flag & CTF_TunerSetOnly) {
		// 튜너 설정만 수행하라는 옵션이다.
		// 이 기능은 POD 모드에서 ChannelForceTune request가 올 경우에 사용된다.
		//
		dprint(1, "  TunerSetOnly mode..\n");
		
		status = statusOK;
		goto label_end_tune;
	}

	if (Dmc_CheckCancel()) goto label_cancelled;
	
	//----------------------------------------
	// NTSC tuning
	
	if (tuneParam->type == Modulation_NTSC)
	{
		status = doDmc_RfTuneAnalog(ctx);
		
		goto label_end_tune;  // 아날로그 채널은 이것으로 모든 작업이 끝난다.
	}
	
	Demux_tsdStart(Dmc_GetCurrentTsd(), 0);
	
	//----------------------------------------
	// cafrii 041201 add
	// POD mode 에서는 PID tuning을 사용하기가 곤란함.
	// 먼저 PMT를 수신한 다음 CA_PMT를 POD에 report를 한 다음에 튜닝해야 하기 때문.
	//
	{
		// bugfix. callback 미 구현시 디폴트는 normal mode.
		PodStatusParam status;
		status.isPodInserted = FALSE;
		doDmc_Notify(DMC_NOTIFY_IsPodInserted, (UINT32)&status);	
		
		if (status.isPodInserted) {
		dprint(2, "  cable card active mode.. force PSI tuning\n");
		goto label_try_psi;
	}
	}

	//----------------------------------------
	// tune by PIDs..	

	if (tuneParam->flag & CTF_SkipPrescanPidInfo) {
		dprint(3, "  skip prescan pids by user flag\n");
	}
	else {
		status = doDmc_RfTuneByPidOnly(ctx);
		
		if (status == statusCancelled)
			goto label_cancelled;
			
		else if (status == statusOK) {
			doDmc_StartFinalPsiMonitor(TRUE);
			goto label_end_tune;
		}
	}

	//----------------------------------------
	// 테이블을 수신한다.  TVCT, CVCT, PAT 모두 수신.
	//

	// cafrii 070427 move position
	//  psi only mode 에서는 vct를 받아도 사용하지도 않으므로 
	//  각자 필요한 때에 pat/pmt를 받도록 한다.
	//
	if ((tuneParam->flag & CTF_Mask_Tuning) == CTF_PSIOnly) {
		dprint(2, "\tPSI only modes..\n");
		goto label_try_psi;
	}

	
#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSIP_LOAD, 0);
#endif
			
	status = doDmc_DownloadTables(ctx);

	if (status == statusCancelled)
		goto label_cancelled;

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_PSIP_LOAD, 1);
#endif

	
	if (ctx->vct)
	{
		// 수신된 VCT를 이용하여 튜닝을 시도한다.
		//
		status = doDmc_RfTuneByVct(ctx);
	
		if (status == statusCancelled) {
			goto label_cancelled;
		}
		else if (status == statusOK) {
			doDmc_StartFinalPsiMonitor(TRUE);
			goto label_end_tune;
		}
	}

	// 사용 가능한 Tuning Mode
	//     CTF_VCTOnly or CTR_Automatic or CTR_SemiAutomatic.
	//
	//  VCTOnly는 VCT로 처리하는 도중 에러가 발생하면 그냥 에러로 중단.
	//  Automatic/SemiAutomatic인 경우는 VCT에서 에러가 나면 PSI로 넘어가서 계속 진행.
	//

	if ((tuneParam->flag & CTF_Mask_Tuning) == CTF_VCTOnly) {
		// returnStatus 값은 이미 적당한 값을 가지고 있어야 한다.
		// 이 값이 그대로 callback에 리턴된다.
		goto label_end_tune;
	}

	if ((tuneParam->flag & CTF_Mask_Tuning) == CTF_SemiAutomatic) {
		// semi automatic 모드라면 현재 어떤 에러값을 가지고 있느냐에 따라
		// 분기가 결정된다.
		// 또한 이 모드는 retry 플래그와 함께 사용되면 의미가 없다. 무시된다.
		if ((tuneParam->flag & CTF_RetryOtherChannel) == 0 &&
			(status == statusVideoError)) {
			// 이미 video decoding이 시도된 상태이므로 더이상 시도하지 않는다.
			dprint(2, "\tsemiAuto, noRetry mode with videoError status. skip PSI mode\n");
			goto label_end_tune;
		}
	}

label_try_psi: //------------------------------------------------------------

	// PAT, PMT를 이용하여 튜닝을 시도한다.
	
	status = doDmc_RfTuneByPsi(ctx);

	if (status == statusCancelled) {
		goto label_cancelled;
	}
	else if (status == statusOK) {
		doDmc_StartFinalPsiMonitor(TRUE);
	}
	goto label_end_tune;


label_cancelled:
	status = statusCancelled;
  	goto label_end_tune;


label_end_tune: //------------------------------------------------------------

	// cafrii 060802 add
	//   statusCancelled 메시지 전달은 아주 중요하다.
	//   모든 result 값에 우선해서 전달되어야 한다.
	//   현재 모든 tuning 관련 작업이 거의 다 성공했다 하더라도 
	//   user가 cancel을 원하면 statusCancelled를 넘겨줘야 한다.
	//
	if (status != statusCancelled)
	{
		if (Dmc_CheckCancel()) {
			dprint(0, "!! tuning cancelled at final stage. status %d -> %d\n",
						status, statusCancelled);
			status = statusCancelled;
		}
	}
	
	if (1)
	{
		AppRfTuneCallbackParam returnParam;
		ProgramAVInfo *av;
		
		memset(&returnParam, 0, sizeof(AppRfTuneCallbackParam));
		
		av = Dmc_LockAVMutex();
		
		returnParam.program = av;
		returnParam.tuneParam = tuneParam;
		returnParam.vct = ctx->vct;
			
		returnParam.pat = av->pat ? av->pat : ctx->pat;
		returnParam.pmt = av->pmt ? av->pmt : ctx->pmt;
			// Tuning을 하면서 PAT/PMT가 준비가 되었다면 av->pat/pmt에 저장되어 있으므로
			// 그 값을 넘겨준다.
			// 튜닝 중에 실패한 경우라면 그냥 ctx 내에 남아있을 것이다.

		// cafrii 060804 add
		av->userParam = pmsg->userParam;  
			// tune callback의 userparam을 기억해 두고
			// psi changed notification에서 이 parameter를 넘겨주자.
		
#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_CALLBACK, 0);
#endif

		doDmc_ReturnTuneResult((void *)pmsg->pfnCompleted, status, 
						pmsg->userParam, (UINT32)&returnParam);

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_CALLBACK, 1);
#endif
	
		Dmc_UnlockAVMutex();
		
	}
		
	if (ctx->vct) {
		dprint(2, "\t free ctx->vct 0x%x\n", ctx->vct);
		FreeAtscTable(ctx->vct);
	}

	// pat, pmt가 dmc_pat/dmc_pmt로 등록되는 것은 StartDigital 에서 active ON 되는 순간이다.
	// tuneParam에 pat/pmt가 남아있는 경우는 tuning에 실패한 경우일때이다.
	//
 	if (ctx->pat) {
 		dprint(2, "\t free ctx->pat 0x%x\n", ctx->pat);
 		FreePAT(ctx->pat);
 	}
	if (ctx->pmt) {
 		dprint(2, "\t free ctx->pmt 0x%x\n", ctx->pmt);
		FreePMT(ctx->pmt);
	}

#if USE_PERF_MON
	DHL_PerfMonCheck(gDmcPMTune, PM_EV_TUNE_TOTAL, 1);
#endif


	return status;

}  // doDmc_CmdRfTune





#if COMMENT
________(){}
#endif

#if DMW_REGISTER_DEBUG_SYMBOL


static DHL_SymbolTable symbols[] =
{
	//---- functions
	
	
	//---- vars
	DHL_VAR_SYM_ENTRY(g_SignalThresholdForDigitalChannel),

	DHL_VAR_SYM_ENTRY(gDmcTestSkipVctDownload),
	
};

#endif

void RegisterChannelTuneSymbols(void)
{
	
#if DMW_REGISTER_DEBUG_SYMBOL
	DHL_DBG_RegisterSymbols(symbols, DHL_NUMSYMBOLS(symbols));
#endif

}