/*******************************************************************
 * DMW_Ucm.c
 *
 * User Channel Map management routines.
 *
 * Copyright 2003 Digital STREAM Technology, Inc.
 * All Rights Reserved
 *
 * $Id: DMW_Ucm.c,v 1.0 2004/05  cafrii Exp $
 *
 ********************************************************************/


#include "DMW_Platform.h"



#include "DHL_OSAL.h"
#include "DHL_DBG.h"
//#include "DHL_VIDEO.h"
#define USE_FLATTEN_VIDEO 0


#include "DMW_Config.h"
#include "DMW_Channel.h"
#include "DMW_ChannelAPI.h"
#include "DMW_Mutex.h"
#include "DMW_DebugUtil.h"
#include "DMW_CodeConv.h"

#include "dmw_ucm_priv.h"
#include "dmw_channel_priv.h"

//#include <string.h>

DHL_MODULE("$ucm", 0);

//------------------------------------------
//  Configurations..

BOOL g_bReserveUcmIndex0 = FALSE;
	// runtime시에 Ucm index 0를 reserve 할 것인지 아닌지 조건 체크.
	// TRUE이면 reserve를 한다.





//------------------------------------------

#define equiv4(a1, a2, a3, a4, b1, b2, b3, b4) \
	((a1)==(b1) && (a2)==(b2) && (a3)==(b3) && (a4)==(b4))

#define equiv_ucm(a, b) \
	((a)->Major==(b)->Major && (a)->Minor==(b)->Minor && (a)->RF==(b)->RF && (a)->VctFlag==(b)->VctFlag)
	// a == b


//------------------------------------------
// Global variables..
//
//


char *ShortNameString(UINT16 *src, char *dst) 
{
	// 'dst' buffer는 최소 15바이트이상이어야 함.
	//
	return DMW_Unicode2Ks((UINT16*)src, 7, dst);
	// cafrii 041103 replace 

#if 0
	#if 1	
		// cafrii 041103 add for MBCS
		int k;
		for (k=0; k<7; k++) {
			if ((src[k] >> 8) == 0)
				dst[k] = src[k] & 0xff;
			else
				dst[k] = '?';    // ascii가 아닌 글자는 특별한 표시를 하도록 함..
		}
		dst[7] = 0;
		return dst;
	
	#else	
		int k;
		for (k=0; k<7; k++)
			dst[k] = (char)src[k]; // unicode to ascii
		dst[7] = 0;
		return dst;
	#endif
	
#endif
}

#if 0
_____________________()
#endif

//----------------------------
// UCM libraries..
//
UCM_DB_T *g_UCM = NULL;  // DB pointer
INT32     g_UCM_number;  // number of DB element stored in RAM, not NvRam!!!
INT32     g_UCM_max;     // max number of writable DB element.

const int g_sizeUcmExtension;
	// 확장 영역 크기.




//   Mutex = { SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag,        traceLvl }
//
DMW_MUTEX 
  ucmMutex = { 0,     0,     0,       0,       FALSE,  "UcmMtx", OS_SEM_PRIO, FALSE, };

void DMW_MSC_LockUcm()
{
	DMW_LockMutex(&ucmMutex);
}

STATUS DMW_MSC_LockUcmWait(UINT32 tick)
{
	STATUS status;

	status = DMW_LockMutexWait(&ucmMutex, tick);

	return status;
}

void DMW_MSC_UnlockUcm()
{
	DMW_UnlockMutex(&ucmMutex);
}



#if 0
_____________________()
#endif

//---------------------------------------------------------------------
// UCM management library.
//
//  아래 제공하는 UCM들은 이미 공개된 구조를 갖는 g_UCM 자료구조를 access 하기 위한
//  편의 함수들이다.
//  모두 lock/unlock으로 보호되고 있지 않으므로 caller측에서 이를 고려하여 호출해야 한다.
//
//


// UID Generation functions.
// 이 함수는 MW 내부적으로만 사용된다.
//
// UID는 1부터 시작해서 1씩 증가되어 부여된다.
// UINT16 범위의 최대값 (65535)를 넘어가면 0이 되는데 0의 값은 사용되지 않고 1부터 다시 시작한다.
// 채널 DB 갯수가 65535개가 넘지 않을 것이므로 uid full이 날 가능성은 없다.

// UID가 만들어지는 시점:
//    1. Autoscan 종료 시점에 MCM으로부터 UCM으로 복사될때 UID 생성 번호가 리셋되고 새롭게 UID가 부여된다.
//    2. NvRam에서 UCM을 읽어들일때 UID 생성 번호가 리셋되고 새롭게 UID가 부여된다.
//    3. Application에서 임시 UCM item을 만들때 부여된다.

static UINT16 g_current_uid = 1;  // 0 is not used.
UINT16 make_new_ucm_uid_counter()
{
	int i;
	int original_uid = g_current_uid ? g_current_uid : 1;
	// 0은 사용하지 않기로 했으니까..
	
	while (1)
	{
		for (i=0; i<g_UCM_number; i++) {
			if (g_UCM[i].Uid == g_current_uid)
				break;
		}
		if (i == g_UCM_number)
			return g_current_uid;  // 일치하는 것이 없으므로 안전하게 사용 가능함.
			
		g_current_uid++;
		if (g_current_uid == 0) // 0값은 사용하지 않기로 하자.
			g_current_uid++;
			
		if (g_current_uid == original_uid)
			dprint(0, "!! uid counter is full???\n");
	}
}

void reset_ucm_uid_counter()
{
	// UID 생성 번호를 리셋한다. 0 값은 사용되지 않고 1부터 사용한다.
	g_current_uid = 1;
}


STATUS prepare_ucm_space(int margin)
{
	// 새 ucm을 추가하기 위해 필요한 공간이 있는지 검사.
	// "공간이 없는 경우에만" 확장한다.
	// margin은 확장을 하게 될 경우 확장 할 크기이다.
	
	if (g_UCM_number >= g_UCM_max) // 공간이 부족하면,
	{
		g_UCM_number = g_UCM_max; // for safety..
			// g_UCM_number가 g_UCM_max보다 클 수 없음.

		if (margin < 8)
			margin = 8;
					
		if (g_UCM) {
			
		#if 0
			// 메모리 재할당..
			
			if (OS_Realloc(&g_UCM, g_UCM_max * UcmItemMemorySize(), 
					(g_UCM_max + margin) * UcmItemMemorySize())) {
				g_UCM_max += margin;
			}
			else {
				// OS_Realloc()이 실패해도 g_UCM에는 변화가 없다.
				return statusOutOfMemory;
			}
		#else // cafrii 031112 TL_OS bug..
		
			UCM_DB_T *tmpUcm = DHL_OS_Malloc(UcmItemMemorySize() * (g_UCM_max + margin));
			if (tmpUcm == NULL)
				return statusOutOfMemory;
				
			memcpy(tmpUcm, g_UCM, UcmItemMemorySize() * g_UCM_number);
			
			DHL_OS_Free((void**)&g_UCM);
			g_UCM = tmpUcm;
			g_UCM_max += margin;
		
		#endif
		
		}
		else {
			g_UCM_number = 0; // 메모리 신규 할당.
			g_UCM_max = margin;
			g_UCM = DHL_OS_Malloc(UcmItemMemorySize() * g_UCM_max);
			
			if (g_UCM == NULL) {
				g_UCM_max = 0;
				return statusOutOfMemory;
			}
		}
	}
	return statusOK;
}

UCM_DB_T *insert_ucm_ptr(int major, int minor, int rf, int vctFlag)
{
	int idx = insert_ucm(major, minor, rf, vctFlag);
	if (g_UCM && idx >= 0)
		return &g_UCM[idx];
	else
		return NULL;
}

int insert_ucm(int major, int minor, int rf, int vctFlag)
{
	// 주어진 parameter의 ucm이 들어갈 자리를 찾는다. (오름차순 정렬 조건하에서..)
	// 새 ucm을 위한 공간을 마련하고,
	// 새 ucm의 index를 리턴한다.
	// ucm 확장을 위한 메모리가 부족할 경우 -1 리턴.
	//
	// 주의!!!!
	//  만약 기존의 UCM에 이와 똑같은 정보를 가진게 있으면 기존의 것을 지워버릴 것이니까
	//  꼭 find_ucm_mj_mn_rf_vf()을 이용해서 확실히 없다고 판단 한 후 이 함수를 이용하기 바람.
	
	UCM_DB_T *t;
	int i, k;
	BOOL equiv_found = FALSE;
	
	vctFlag = vctFlag ? 1 : 0;

	if (g_UCM) {
		
		//oldidx = find_ucm(major, minor, rf, vctFlag);  // 두번 루프도는 것은 비효율적이라 삭제함..
		//if (oldidx < 0) ...
		
		for (i=0; g_UCM && i<g_UCM_number; i++) {
			t = &g_UCM[i];
			if (! ordered_ucm(t->Major, t->Minor, t->RF, t->VctFlag, major, minor, rf, vctFlag)) {
				if (equiv4(t->Major, t->Minor, t->RF, t->VctFlag, major, minor, rf, vctFlag)) {
					equiv_found = TRUE;
					dprint(0, "!! warning! insert_ucm(): equiv ucm found (%d-%d %d %c, %d). overwritten.\n",
						major, minor, rf, vctFlag ? 'v' : '_', t->Uid);
				}
					
				break;
			}
		}
	}
	else
		i = 0;  // g_UCM이 없으면 맨 처음에 들어감.
	
	if (equiv_found) {
		memset(t, 0, UcmItemMemorySize()); // cafrii 030326
		
		t->Major = major;  // cafrii 040812 bugfix
		t->Minor = minor;
		t->RF = rf;
		t->VctFlag = vctFlag;
		t->Skipped = 1;
		// 주의!!   cafrii 040812 add comment
		//  Mj/Mn, RF, Vf 를 제외한 모든 다른 flag들은 리셋시켜버린다.
	}
	else {
		// (t == 'i'번지)가 새 ucm이 들어갈 자리다.
		//  ucm 버퍼 확장한다.
		
		if (prepare_ucm_space(8) != statusOK)
			return -1;
	
		// i번째 ucm 이하 모든 item을 한칸씩 뒤로 shift.. (i번째 ucm 포함)
		for (k=g_UCM_number-1; k>=i; k--)
			//g_UCM[k+1] = g_UCM[k];    // BUGBUG!!
			memcpy(&g_UCM[k+1], &g_UCM[k], UcmItemMemorySize()); // cafrii, 030326
		
		t = &g_UCM[i];
		// 이제 t ('i'번째 ucm) 는 비어있다.
		memset(t, 0, UcmItemMemorySize());
		t->Major = major;
		t->Minor = minor;
		t->RF = rf;
		t->VctFlag = vctFlag;
		t->Skipped = 1;  // cafrii 030325, initially disable.
		
		g_UCM_number++;
	}
	
	return i;  // return index of newly allocated ucm.
}

int find_ucm_mj_mn_rf_vf(int major, int minor, int rf, int vctFlag)
{
	// 조건에 맞는 ucm item을 찾는다. index를 리턴한다. 일치하는게 없으면 -1.
	int i;
	if (!g_UCM)
		return -1;
	
	vctFlag = vctFlag ? 1 : 0;
	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].Major == major && g_UCM[i].Minor == minor && 
			g_UCM[i].RF == rf && g_UCM[i].VctFlag == vctFlag)
			return i;
	}
	return -1;
}

// hschang, 2003-10-08
int find_ucm_analog_RF(int rf)
{
	// analog 이면서 (Service_type == 0)
	// RF == rf인 채널을 찾는다.
	
	int i;
	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].RF == rf && g_UCM[i].Minor==0)
			return i;
	}
	return -1;	
}

STATUS select_max_ucm(int major, int minor, int vctFlag)
{
	// UCM에서 같은 번호를 갖는 채널들 중에서 "대표채널"을 선택하고 그 채널만을 enable시킨다.
	// 여기서 같은 번호란, 현재 방침에 따르면 major/minor/vf 이다.

	// 현재 sorting되어 있는 상태이므로 작은 번호의 채널부터 시작해서
	// 동일한 Mj/Mn/Rf 값을 갖는 채널들 중에서 신호 세기가 가장 큰 것을 선택하고,
	//     나머지는 skip flag를 세팅한다.

	int maxnd, n;

	if (g_UCM == NULL || g_UCM_number <= 0)
		return statusOK;

	vctFlag = vctFlag ? 1 : 0;
	maxnd = -1;  // maxnd는 현재까지 최대 strength를 갖는 ucm의 인덱스.

	// mj/mn/rf/vctf 만으로 판단한다.
	//  위 데이터가 모두 동일하면서 ntsc/8vsb/64qam/256qam이 서로 다른 것들은
	//    적당한 것으로 이미 선택되어 통일 되어 있다고 가정.
	//  

	for (n=0; n<g_UCM_number; n++)
	{
		if (g_UCM[n].Major == major && g_UCM[n].Minor == minor && g_UCM[n].VctFlag == vctFlag)
			continue;
		
		g_UCM[n].Skipped = TRUE;  // 기본으로 모두 skip으로 설정하고, 나중에 특정한 MCM만 activate한다.

		if (g_UCM[n].hidden) continue;  // hidden은 항상 Skip.

		if (maxnd == -1)  // 아직까지 대표채널이 없는 경우..
			maxnd = n;   // 이 채널을 대표 채널로 지정.
		
		// 비교 단계 계속 진행중...
		// 지금까지의 우승후보(최대 strength의 노드)인 'maxnd'와 'n'과 경쟁..

		if (g_UCM[maxnd].signal_strength < g_UCM[n].signal_strength)
			maxnd = n;	// 새로운 우승자 'n' 탄생.. maxnd로 승격.
	}

	if (maxnd < 0)
		dprint(0, "!! select_max_ucm(): no ucm (%d-%d %c) exist.\n", major, minor, vctFlag ? 'v' : '_');
	else {
		dprint(2, "select_max_ucm(%d-%d %c) uid %d is selected.\n", major, minor, 
				vctFlag ? 'v' : '_', g_UCM[maxnd].Uid);
		g_UCM[maxnd].Skipped = FALSE; // <-- "선택!!!"
	}

	return statusOK;
}


BOOL DMW_MSC_IsUcmValid()
{
	// 정렬이 되어 있는지 체크한다.
	// Major/Minor/Rf/VctFlag가 중복된 것이 있는지 체크한다.
	// Uid가 중복된 것이 있는지 체크한다.
	int i, k;
	UCM_DB_T *a, *b;
	BOOL has_err = FALSE;
	
	DMW_MSC_LockUcm();
	
	dprint(2, "*** Check UCM Validity ***\n");
	// 정렬 체크.
	for (i=1; i<g_UCM_number; i++) {
		a = &g_UCM[i-1];
		b = &g_UCM[i];
		if (equiv_ucm(a, b)) {
			dprint(0, "!!  %d:[%03d] and %d:[%03d] equivalent.\n", 
					i-1, g_UCM[i-1].Uid, i, g_UCM[i].Uid);
			has_err = TRUE;
		}
		else {
			if (! ordered_ucm(a->Major, a->Minor, a->RF, a->VctFlag, 
				b->Major, b->Minor, b->RF, b->VctFlag)) {
				dprint(0, "!!  %d:[%03d] > %d:[%03d], not sorted!\n", 
					i-1, g_UCM[i-1].Uid, i, g_UCM[i].Uid);
				has_err = TRUE;
			}
		}
	}

	// Uid 체크.	
	for (i=0; i<g_UCM_number-1; i++) {
		for (k=i+1; k<g_UCM_number; k++) {
			if (g_UCM[i].Uid == g_UCM[k].Uid) {
				dprint(0, "!!  Uid collision, %d:[%03d] == %d:[%03d]\n", 
					i, g_UCM[i].Uid, k, g_UCM[k].Uid);
				has_err = TRUE;
			}
		}
	}
	
	DMW_MSC_UnlockUcm();
	
	return (has_err ? FALSE : TRUE);
}


STATUS DMW_MSC_EnableChannel(int uid, BOOL bEnable)
{
	int i;
	STATUS status = statusOK;
	DMW_MSC_LockUcm();
	
	i = DMW_MSC_Uid2Index(uid);
	if (i>=0) {
		g_UCM[i].Skipped = bEnable ? 0 : 1;  // caution! inverted.
		DMW_CDB_ReleaseSurfChannel(i);
		//g_UCM[i].SurfIndex = 0;
	}
	else
		status = statusChannelNotFound;
	
	DMW_MSC_UnlockUcm();
	return status;
}



void DMW_MSC_DisableAllPsiChannel()
{
	int i;
	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++) {
		if (g_UCM[i].VctFlag == 0) {
			g_UCM[i].Skipped = 1;  // skip means disable.
			DMW_CDB_ReleaseSurfChannel(i);
			//g_UCM[i].SurfIndex = 0;
		}
	}
	DMW_MSC_UnlockUcm();
}


void DMW_MSC_SortUcm()
{
	// UCM을 Major/Minor/RF/Vf 순으로 정리한다. (오름차순. Vf만 내림차순.)
	//
#define require_ucm_swap(a, b)  \
	(((a)->Major>(b)->Major) || \
	 ((a)->Major==(b)->Major && (a)->Minor>(b)->Minor) || \
	 ((a)->Major==(b)->Major && (a)->Minor==(b)->Minor && (a)->RF>(b)->RF) || \
	 ((a)->Major==(b)->Major && (a)->Minor==(b)->Minor && (a)->RF==(b)->RF &&   \
	  (a)->VctFlag<(b)->VctFlag) )
	// UCM 정렬에서 a와 b 두 UCM item 위치를 바꿔야 되는지 체크하는 매크로.
	// 기본적으로 Major/Minor/RF/VctFlag 순서로 순위를 두고, Major/Minor/Rf는 오름차순,
	// VctFlag는 내림차순으로 정렬해야 한다.

	
	UCM_DB_T tmp;
	int i, k;
	
	if (g_UCM_number <= 0)
		return;

	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number-1; i++)
		if (g_UCM[i].VctFlag) 
			g_UCM[i].VctFlag = 1;  // TRUE의 정의가 non-zero로 좀 애매하므로 정렬할때는 1로 고정시키는게 편함.
		
	for (i=0; i<g_UCM_number-1; i++)
	{
		for (k=i+1; k<g_UCM_number; k++)
		{
			// i와 k를 비교해서 i가 더 크면 교환.
			if (require_ucm_swap(&g_UCM[i], &g_UCM[k])) {
				// swap
				tmp = g_UCM[i];
				g_UCM[i] = g_UCM[k];
				g_UCM[k] = tmp;
			}
		}
	}
	
	DMW_MSC_UnlockUcm();
	
#undef require_ucm_swap
}

//-----------------------------------------------------------------
//
//  miscellaneous functions.
//  Index를 리턴하는 각종 함수들은 UCM을 lock하지 않음에 유의한다. caller에서 보호를 해야 한다.

STATUS DMW_MSC_FindUcmByRF(int rf, int *returnIndex)
{
	int i;	
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (rf == g_UCM[i].RF)
			break;
	}
	
	if (i < g_UCM_number) {
		if (returnIndex)
			*returnIndex = i;
		return statusOK;
	}
	return statusChannelNotFound;
}




//----------------
//  2/24 추가..

char *CsfString(int flag, char *buf)
{
	static char _buf[40];
	if (buf == NULL) buf = _buf;
	
	sprintf(buf, "%s%s%s%s%s", 
		(flag & CSF_Include_Disabled) ? "Dis " : "",
		(flag & CSF_Include_Skipped) ? "" : "Active ",
		((flag & CSF_Mask_MF) == CSF_ATSC_Only) ? "AtscOnly " : "",
		((flag & CSF_Mask_MF) == CSF_NTSC_Only) ? "NtscOnly " : "",
		(flag & CSF_Include_PSI) ? "" : "Vct ");
	return buf;	
}

int find_next_key_major(int curMajor, BOOLEAN bIncrease, int flag, int *pNewMajor)
{
	// 'curMajor'를 기준으로 차 상위, 차 하위 채널을 찾는다.
	//  같은 key major값을 갖는 채널이 여러개 존재하면 DB상에서 맨 처음 채널 인텍스를 리턴한다.
	
	// 끝까지 도달하면 wrap-around되어 처음부터 검색..
	// 선택할 채널이 없으면 에러 리턴. (-1)을 리턴.

	int i, k, newMajor, minimumIndex;
	char tmp[40];
	
	if (bIncrease) 
	{
		for (i=0; i<g_UCM_number; i++)  // curMajor보다 큰 메이저 채널을 찾는다.
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 051031 add
			
			if (curMajor < g_UCM[i].Major) {
				dprint(3, " find first ucm: %c(%02d) %d-%d %c %d\n", 
						g_UCM[i].Skipped ? ' ' : '+', i, g_UCM[i].Major, g_UCM[i].Minor, 
						g_UCM[i].VctFlag ? 'v' : 'p', g_UCM[i].Service_type);
				break;
			}
		}
	
		if (i == g_UCM_number) {
			// ucm db 끝에 도달해버렸다!!! 현재 채널 이후의 적당한 up 채널이 없다는 의미임.
			// 그러면 UCM의 앞에서부터 첫번째 enable 채널을 돌려준다! (wrap-around)
	
			//dprint(2, " ucm not found!. wrap around and retry..\n");
			for (i=0; i<g_UCM_number; i++) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
				if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;
				if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
				if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
				if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

				if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 051031 add

				break;  // 위의 조건을 다 건너뛰었으면 OK!
			}
			if (i == g_UCM_number) {
				// !!! 이 UCM에는 enable 채널이 하나도 없다!!
				// 그냥 아무것도 안한다.
				dprint(0, "!! FindNextMajor: not found %s ucm!!\n", CsfString(flag, tmp));
				return -1;
			}
			else {
				dprint(3, " ucm wrapped around: (%02d) %d-%d\n", i, g_UCM[i].Major, g_UCM[i].Minor);
			}
		}
		newMajor = g_UCM[i].Major;
	}
	else // decrese..
	{
		for (i=g_UCM_number-1; i>=0; i--) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 051031 add

			// curMajor 보다 작거나 같은 채널중에서 처음 발견되는 채널을 찾는다.
			if (curMajor > g_UCM[i].Major) {
				dprint(3, " find first ucm: %c(%02d) %d-%d %c %d\n", 
						g_UCM[i].Skipped ? ' ' : '+', i, g_UCM[i].Major, g_UCM[i].Minor, 
						g_UCM[i].VctFlag ? 'v' : 'p', g_UCM[i].Service_type);
				break;
			}
		}
	
		if (i < 0) {
			// ucm db 맨 앞에 도달해버렸다!!! 적당한 up 채널이 없다는 의미임.
			// 그러면 UCM의 맨 뒤에서부터 다시 찾는다. (wrap-around)
			dprint(3, " ucm not found!. wrap around and retry..\n");
	
			for (i=g_UCM_number-1; i>=0; i--) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
				if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;
				if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
				if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
				if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

				if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 051031 add

				break;  // 위의 조건을 다 건너뛰었으면 OK!
			}
			if (i < 0) {
				// !!! 이 UCM에는 enable 채널이 하나도 없다!!
				// 그냥 아무것도 안한다.
				dprint(0, "!! FindNextMajor: no proper %s ucm!!\n", CsfString(flag, tmp));
				return -1;
			}
			else {
				dprint(3, " ucm wrapped around: (%02d) %d-%d\n", i, g_UCM[i].Major, g_UCM[i].Minor);
			}
		}
		// decresing 인 경우의 추가사항:
		// 이제 해당 major-XXX 집합 중에서 제일 앞에 위치한 채널을 선택한다.
		
		newMajor = g_UCM[i].Major;
		minimumIndex = i;
		for (k=i; k>=0; k--) 
		{
			// cafrii 050906 bugfix!  change 'i' -> 'k' in this for loop
			if (g_bReserveUcmIndex0)
				if(k==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[k].Skipped) continue;
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[k].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[k].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[k].VctFlag == 0)	continue; 
			
			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[k].hidden) continue; // cafrii 051031 add

			if (g_UCM[k].Major == newMajor)
				minimumIndex = k;
		}
		i = minimumIndex;
	}
	
	if (pNewMajor)
		*pNewMajor = newMajor;
	return i;
}




#if 0
_____________________()
#endif

// 새 Tuning Policy 요구사항을 적용한 코드.

// UCM 채널 정보의 Uid (Unique ID)
//
// 새 Tuning Policy에는 Uid라는 새 id값을 사용한다.
// 더이상 Major/Minor/RF 데이터 쌍이 unique 함을 보장할 수 없고,
// UCM의 index 값은 UCM lock을 할 경우에만 의미가 있으므로 새로운 ID가 필요하게 된 것.
//
// Uid는 16bit unsigned 값으로서 채널 정보가 메모리에 존재하는 동안은 그 정보를 유일하게
// 구별할 수 있도록 부여된 값이다.
// NvRam에는 저장되지 않는 휘발성 값이다. NvRam에서 load될 경우에는 새롭게 ID가 할당된다.
//
// 현재 구현 정보:
//    현재 구현은 1부터 시작하는 일련 번호이며, 중간에 UCM 데이터 일부를 삭제할 경우 빈 번호가 
//    존재하기도 한다.
//    UINT16의 최대값인 65535를 넘어가면 wrap-around되지만 '0'의 값은 사용하지 않고 있다.
//

//$$
// int DMW_MSC_Uid2Index(UINT16 uid);
// int DMW_MSC_Index2Uid(int index);
//   index <--> Uid간의 변환에 사용한다.
//   해당 채널이 없으면 -1을 리턴한다.
//
// 주의1:
// Uid의 타입은 원래 UINT16이나, -1과 같은 에러를 알려주기 위해 리턴값 'int'가 사용되었다.
//
// 주의2: 
// index를 함수인자나 리턴값으로 사용하는 모든 함수는 caller에서 Ucm을 lock을 걸어 보호해 줄 필요가 있다.
// 이 두 함수도 예외가 아님.
//

int DMW_MSC_Uid2Index(int uid)
{
	int i;
	for (i=0; i<g_UCM_number; i++)
		if (uid == g_UCM[i].Uid)
			return i;
	return -1;
}

int DMW_MSC_Index2Uid(int index)
{
	// index 0의 값은 의미 없을 수도 있으므로 caller에서 주의하여 사용하도록 한다.
	
	if (index < 0 || index >= g_UCM_number) return -1;
	return g_UCM[index].Uid;
}


//$$
// DMW_MSC_GetMaxMinorNumber(int major);
// 
// 해당 'major' 값을 메이저 번호로 갖는 채널 정보들 중에서 최대 minor값을 찾는다.
// 이는 PSI로부터 추출된 채널 정보에 Major-Minor 스타일의 채널 번호 명명을 하기 위해
// application에서 사용할 수 있다.
// 
// 예를 들어 현재 major 9를 갖는 채널 정보들 중, minor 값의 최대값이 3이라고 하면
// applicaiton에서는 PMT에서 알아낸 채널 정보 두개를 9-4, 9-5로 명명할 수 있을 것이다.
//
// PSI 채널 정보의 명명법은 application의 자유이므로 위의 예는 강제사항이 아니다.
//
int DMW_MSC_GetMaxMinorNumber(int major)
{
	int i, maxminor = -1;
	DMW_MSC_LockUcm();
	
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (major != g_UCM[i].Major)
			continue;
		if (!g_UCM[i].VctFlag)
			continue;
			
		// minor 값 중에서 최대값을 찾는다.
		if (maxminor < g_UCM[i].Minor)
			maxminor = g_UCM[i].Minor;
	}
	DMW_MSC_UnlockUcm();
	return maxminor;
}

//
// 채널 DB에서 검색하는 함수들.
//
// 아래 함수들은 공통적으로  복수개의 검색결과를 리턴받기 위해서 
//   flag, szBuf, *buf 인자를 가지고 있다.
//
// 함수의 리턴값은 모두 검색된 채널의 갯수이다. 
//  szBuf의 값과는 상관없이 해당 채널의 갯수를 리턴한다.
//
int DMW_MSC_FindChannelMajorMinor(int major, int minor, int flag, int szBuf, int *buf)
{
	// major, minor가 일치하는 채널을 찾는다.
	
	int i, nMatch = 0;
	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if (g_UCM[i].Major != major || g_UCM[i].Minor != minor) continue;
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
				// 'PSI는 포함하지 말아라' 인데, PSI 채널 정보라면 skip.
		if (buf && nMatch < szBuf)
			buf[nMatch] = g_UCM[i].Uid;
		nMatch++;
	}
	DMW_MSC_UnlockUcm();
	return nMatch;
}

int DMW_MSC_FindChannelMajor(int major, int flag, int szBuf, int *buf)
{
	// major만 일치하는 모든 채널을 찾는다.
	
	int i, nMatch = 0;

	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if (g_UCM[i].Major != major) continue;
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
		if (buf && nMatch < szBuf)
			buf[nMatch] = g_UCM[i].Uid;
		nMatch++;
	}
	DMW_MSC_UnlockUcm();
	return nMatch;
}

// cafrii 031114, add new feature:
//     find channel from "Major" info, instead of "Uid"
//     to use "Major" base, specify negative number.
//
int DMW_MSC_FindMajorUp(int uidCurrentOrMajor, int flag, int szBuf, int *uidBuf)
{
	// ex)
	//      DMW_MSC_FindMajorUp(5, flag, sz, buf);
	//            UID 5번 채널이 6-1 이었다면,
	//            6-2, 6-3은 건너뛰고 9-1, 9-2 등이 검색될 수 있다.
	//
	//      DMW_MSC_FindMajorUp(-11, flag, sz, buf);
	//            major 번호 11번의 다음 Up 채널을 찾는다.
	//            13-0, 13-1, 13-2 등이 검색될 수 있다.
	//           
	int i, index, nMatch = 0, curMajor, newMajor;
	UINT16 uidCurrent;

	DMW_MSC_LockUcm();
	
	if (uidCurrentOrMajor >= 0) // UID로 찾는다.
	{
		uidCurrent = uidCurrentOrMajor;
	
		index = DMW_MSC_Uid2Index(uidCurrent);
		if (index < 0) {
			DMW_MSC_UnlockUcm();
			return 0;
		}
		curMajor = g_UCM[index].Major;

		// find next new major number.
		for (i=index+1; i<g_UCM_number; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if (g_UCM[i].Major <= curMajor) continue;
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
			
			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add
			
			break; // this is one!!
		}
		if (i >= g_UCM_number) // not found!
		{
			// cafrii 050608 add
			if (flag & CSF_DontWrapAround)
			{
				dprint(2, " ucm not found.. return..\n");
				DMW_MSC_UnlockUcm();
				return 0;
			}
			
			for (i=0; i<=index; i++) // wrap-around and found smallest major.
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
				if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
				if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
				if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
				if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
				
				if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add
				
				break;
			}
			if (i > index) { // 한바퀴를 다 돌았는데 없다. not found again!!
				DMW_MSC_UnlockUcm();
				dprint(0, "!! FindMajorUp: next major of %d (uid %d) not found\n", curMajor, uidCurrent);
				return 0;
			}
		}
		// 'i' is index of new major.
	}
	else { // uidCurrentOrMajor가 음의 값을 가지고 있음.  Major로 찾는다.
		
		curMajor = -uidCurrentOrMajor;

		// curMajor 값보다 더 큰 major 값을 가지고 있는 channel 정보를 찾는다.
		i = find_next_key_major(curMajor, TRUE, flag, &newMajor);  // increasing direction
		
		if (i < 0) {
			// 발견되지 않음!!!
			DMW_MSC_UnlockUcm();
			dprint(0, "!! FindMajorDown: smaller major of %d not found!\n", curMajor);
			return 0;
		}
		// 'i' is index of new major.
	}
	
	// 'i' is index of new major.
	newMajor = g_UCM[i].Major;
	
	// 이제 같은 major 중에서 있는대로 선택한다.
	for (; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].Major != newMajor) 
			break;
		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add

	    if (nMatch < szBuf && uidBuf)
	    	uidBuf[nMatch] = g_UCM[i].Uid;
	    nMatch++;
		dprint(2, " find ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
			g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
	}
		
	DMW_MSC_UnlockUcm();
	return nMatch;
}

// cafrii 031114, add new feature:
//     find channel from "Major" info, instead of "Uid"
//     to use "Major" base, specify negative number.
//
int DMW_MSC_FindMajorDown(int uidCurrentOrMajor, int flag, int szBuf, int *uidBuf)
{
	// ex)
	//      DMW_MSC_FindMajorDown(5, flag, sz, buf);
	//            UID 5번 채널이 9-2 이었다면,
	//            9-1, 9-0은 건너뛰고 6-1, 6-2 등이 검색될 수 있다.
	//
	//      DMW_MSC_FindMajorDown(-11, flag, sz, buf);
	//            major 번호 11번의 이전 down 채널을 찾는다.
	//            9-0, 9-1, 9-2 등이 검색될 수 있다.
	//            
	
	int i, index, nMatch = 0, curMajor, newMajor;
	UINT16 uidCurrent; // cafrii 031114 add
	
	DMW_MSC_LockUcm();
	
	if (uidCurrentOrMajor >= 0)
	{
		uidCurrent = uidCurrentOrMajor; // cafrii 040511 bugfix

		//dprint(2, "find major down by uid %d\n", uidCurrent
		index = DMW_MSC_Uid2Index(uidCurrent);
		if (index < 0) {
			DMW_MSC_UnlockUcm();
			return 0;
		}
		curMajor = g_UCM[index].Major;
		
		// find next new major number.
		for (i=index-1; i>=0; i--) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;
				
			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if (g_UCM[i].Major >= curMajor) continue;  // cafrii, 030325 bug fix.
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
			
			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add
			
			break; // this is one!!
		}
		if (i < 0) // not found!
		{
			// cafrii 050608 add
			if (flag & CSF_DontWrapAround)
			{
				dprint(2, " ucm not found.. return..\n");
				DMW_MSC_UnlockUcm();
				return 0;  // channel not found
			}
			
			for (i=g_UCM_number-1; i>=index; i--) // wrap-around to top and found largest major.
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
				if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
				if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
				if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
				if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
				
				if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add
				
				break;
			}
			if (i < index) { // not found again!!
				DMW_MSC_UnlockUcm();
				dprint(0, "!! FindMajorDown: smaller major of %d (uid %d) not found\n", curMajor, uidCurrent);
				return 0;
			}
		}
		// 'i' is index of new major.
	}
	else {  // uidCurrentOrMajor가 음의 값을 가지고 있음.

		curMajor = -uidCurrentOrMajor;

		// curMajor 값보다 더 큰 major 값을 가지고 있는 channel 정보를 찾는다.
		i = find_next_key_major(curMajor, FALSE, flag, &newMajor);  // decreasing direction
		
		if (i < 0) {
			// 발견되지 않음!!!
			DMW_MSC_UnlockUcm();
			dprint(0, "!! FindMajorDown: smaller major of %d not found!\n", curMajor);
			return 0;
		}
		// 'i' is index of new major.
	}
	
	// 'i' is index of new major.
	newMajor = g_UCM[i].Major;
	
	// 이제 같은 major 중에서 있는대로 선택한다.
	
	// Note! cafrii 030331.
	//  index를 내려가면서 선택하면 UCM의 inverse-order가 된다.
	//  따라서 맨 처음으로 먼저 움직인 후 그곳부터 시작해서 선택한다.
	for (; i>=0; i--)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].Major != newMajor) 
			break;
		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add

	    //if (nMatch < szBuf && uidBuf)
	    //	uidBuf[nMatch] = g_UCM[i].Uid;
	    nMatch++;
		//dprint(2, " find ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
		//	g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
	}
	
	if (nMatch == 0) {
		dprint(0, "!!! FindMajorDown: Critical Error! Should be greater than 1!!\n");
		DMW_MSC_UnlockUcm();
		return 0;
	}
	
	// 이 시점에서 i는 newMajor보다 작은 major이거나 또는 i==-1 이 될 것이므로 이곳부터 다시 올라가며
	// 선택한다.
	if (i < 0) i = 0;
	//if (g_UCM[i].Major != newMajor) i++; // BUGBUG!! skip 된 채널이 있으므로 1만 더해서는 안됨!
		// 얼마만큼 더해야 될지 모르므로 여기서 더하지 않고, 
		// 나중에 buffer에 채워넣을때 major check를 한번 더 한다.
	
	nMatch = 0;
	for (; i<g_UCM_number; i++)  // index에 무관하게 전 UCM에서 해당 되는것을 다 찾으면 된다.
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].Major > newMajor) // 조건이 변경됨. 더이상 비교할 필요없음!!
			break;
		if (g_UCM[i].Major != newMajor) continue;  // 조건이 추가됨.
		
		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050608 add

	    if (nMatch < szBuf && uidBuf)
	    	uidBuf[nMatch] = g_UCM[i].Uid;
	    nMatch++;
		dprint(2, " find ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
			g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
	}
	
	DMW_MSC_UnlockUcm();
	return nMatch;
}


int DMW_MSC_FindMinorUp(int uidCurrentOrMajorMinor, int flag, int szBuf, int *uidBuf)
{
	// 현재 uidCurrent 채널에서부터 하나 up 채널의 uid를 리턴.
	// 끝까지 도달하면 wrap-around된다.
	// 선택된 채널 갯수를 리턴한다. 이 함수는 항상 한개의 채널만을 찾으므로 1을 리턴함.
	// 선택할 채널이 없으면 0을 리턴.
	//
	// ucm은 정렬이 되어 있으므로 작은 쪽에서부터 찾아올라가면된다.
	// flag의 값에 따라 다르게 동작한다.
	//
	// uidCurrent가 잘못된 값이라면 (존재하지 않는 채널), 맨 처음부터 새로 찾는다.

	int i, index;
	
	DMW_MSC_LockUcm();
	
	if (uidCurrentOrMajorMinor < 0) 
	{
		//int nMajor, nMinor;
		UINT32 majorminor;
		
		uidCurrentOrMajorMinor = -uidCurrentOrMajorMinor;
		index = -1;
		
		for (i=0; i<g_UCM_number; i++)
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;
	
			majorminor = ((g_UCM[i].Major & 0xffff) << 16) | (g_UCM[i].Minor & 0xffff);
			
			if ((unsigned int)uidCurrentOrMajorMinor == majorminor) {
				break;   // 정확히 일치. 이 채널 다음부터 찾으면 된다.
			}
			if ((unsigned int)uidCurrentOrMajorMinor < majorminor) {
				i--;  // 이 i번째 채널부터 찾으면 된다.
				break;
			}
		}
		if (i < g_UCM_number)
			index = i;
		else
			// DB의 모든 채널이 지정한 값보다 작은 경우..
			index = g_UCM_number-1;
	}
	else 
	{
		UINT16 uidCurrent = (uidCurrentOrMajorMinor & 0xffff);
		index = DMW_MSC_Uid2Index(uidCurrent);
		if (index < 0) {
			if (g_UCM_number <= 0) {
				dprint(0, "!! no channel info in ucm\n");			
				DMW_MSC_UnlockUcm();
				return 0;
			}
		#if 0
			index = g_UCM_number-1; // cafrii 030323, 맨 처음 채널부터 찾을 수 있도록..
		#else
			index = -1; 
				// cafrii 050614 bugfix
				// 맨 처음 부터 찾을려면 이렇게 해야 한다.
				// 왜냐면 이제는 Don't Wrap Around flag가 있기 때문에 
				// 자동으로 wrap-around를 하지 않기 때문.
		#endif	
		}
	}
	
	
	for (i=index+1; i<g_UCM_number; i++) // 이 위치에서부터 채널을 찾는다.
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 
		
		if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050602 add

		break;
	}
	
	if (i >= g_UCM_number) 
	{
		// ucm db 끝에 도달해버렸다!!! 현재 채널 이후의 적당한 up 채널이 없다는 의미임.
		// 그러면 UCM의 앞에서부터 첫번째 enable 채널을 돌려준다! (wrap-around)

		// cafrii 050602 add
		if (flag & CSF_DontWrapAround)
		{
			dprint(2, " ucm not found.. return..\n");
			DMW_MSC_UnlockUcm();
			return 0;  // channel not found
		}
				
		dprint(2, " ucm not found!. wrap around and retry..\n");

		for (i=0; i<=index; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050602 add

			break;
		}
		if (i > index) {
			// !!! 이 UCM에는 enable 채널이 하나도 없다!!
			// 그냥 아무것도 안한다.
			dprint(0, "!! no enabled proper ucm!!\n");
			DMW_MSC_UnlockUcm();
			return 0;
		}
		//dprint(2, " find ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
		//		g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
	}

	// minor up/down의 경우 caller가 uid buffer를 제공하지만 어짜피 넘겨주는 것은 최대 1개다.
	if (szBuf > 0 && uidBuf)
		uidBuf[0] = g_UCM[i].Uid;
		
	DMW_MSC_UnlockUcm();
	return 1;
}

int DMW_MSC_FindMinorDown(int uidCurrentOrMajorMinor, int flag, int szBuf, int *uidBuf)
{
	// DMW_MSC_FindMinorUp()과 동일하다.
	//
	// uidCurrent가 잘못된 값이라면 (존재하지 않는 채널), 맨 뒤부터 새로 찾는다.

	int i, index;
	
	DMW_MSC_LockUcm();

	if (uidCurrentOrMajorMinor < 0) 
	{
		//int nMajor, nMinor;
		UINT32 majorminor;
		
		uidCurrentOrMajorMinor = -uidCurrentOrMajorMinor;
		index = -1;
		
		for (i=g_UCM_number-1; i>=0; i--)
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;
	
			majorminor = ((g_UCM[i].Major & 0xffff) << 16) | (g_UCM[i].Minor & 0xffff);
			
			if ((unsigned int)uidCurrentOrMajorMinor == majorminor) {
				break;   // 정확히 일치. 이 채널 앞부터 찾아 내려오면 된다.
			}
			if ((unsigned int)uidCurrentOrMajorMinor > majorminor) {
				i++;  // 이 i번째 채널부터 찾으면 된다.
				break;
			}
		}
		if (i >= 0)
			index = i;
		else
			// DB의 모든 채널이 지정한 값보다 큰 경우..
			index = 0;
	}
	else
	{
		UINT16 uidCurrent = (uidCurrentOrMajorMinor & 0xffff);
		index = DMW_MSC_Uid2Index(uidCurrent);
		if (index < 0) {
			if (g_UCM_number <= 0) {
				dprint(0, "!! no channel info in ucm\n");			
				DMW_MSC_UnlockUcm();
				return 0;
			}			
		#if 0
			index = 0; // cafrii 030323, 맨 마지막 채널부터 찾을 수 있도록..		
		#else
			index = g_UCM_number;
				// cafrii 050614 bugfix
				// 맨 마지막 채널부터 찾기 위해서는 이렇게 해야 한다.
				// Don'tWrapAround 플래그가 있기 때문..
		#endif	
		}
	}
		
	for (i=index-1; i>=0; i--) // 이 위치에서부터 enable 채널을 찾는다.
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
		if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
		if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
		if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
		if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050602 add

		break;
	}
	
	if (i < 0) 
	{
		// ucm db 앞에 도달해버렸다!!! 현재 채널 앞에 적당한 down 채널이 없다는 의미임.
		
		// cafrii 050602 add
		if (flag & CSF_DontWrapAround)
		{
			dprint(2, " ucm not found.. return..\n");
			DMW_MSC_UnlockUcm();
			return 0;  // channel not found
		}
		
		dprint(2, " ucm not found!. wrap around and retry..\n");

		for (i=g_UCM_number-1; i>=index; i--) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

			if ((flag & CSF_Include_Hidden) == 0 && g_UCM[i].hidden) continue; // cafrii 050602 add

			break;
		}
		if (i < index) {
			dprint(0, "!! no enabled proper ucm!!\n");
			DMW_MSC_UnlockUcm();	
			return 0;
		}
		//dprint(2, " find ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
		//		g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
	}
	if (szBuf > 0 && uidBuf)
		uidBuf[0] = g_UCM[i].Uid;
		
	DMW_MSC_UnlockUcm();	
	return 1;
}



#if 0
_____________________()
#endif

// Rf surfing 관련.. 4/24 추가
//
//

int DMW_MSC_FindRfUp(UINT16 rfCurrent, int flag, int szBuf, int *uidBuf)
{
	int i, nMatch = 0;
	int rf, rfOriginal = rfCurrent;
	BOOL bOverwrapped = FALSE;
	
	DMW_MSC_LockUcm();

	// rfCurrent validity check.
	// required??
	if (g_UCM_number <= 0) {
		DMW_MSC_UnlockUcm();
		return 0;
	}

	while (1) 
	{
		// 원하는 정보를 찾을 때 까지 반복한다.
		
		// rfCurrent보다 큰 최소 rf를 찾는다.
		// g_UCM[i].RF 가 UINT8이므로 비교에 주의를 요함!!
		
		rf = 1000;  // set to maximum.
		for (i=0; i<g_UCM_number; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;
			if (g_UCM[i].RF > rfCurrent && g_UCM[i].RF < rf)
				rf = g_UCM[i].RF;
		}

		if (rf == 1000) {  // not found in this rfCurrent.
			if (bOverwrapped) {
				//dprint(0, "!! no proper channel in UCM!\n");
				break;
			}
			rfCurrent = 0;  // retry finding from lowest rf
			bOverwrapped = TRUE;
			//dprint(2, "RF greater than %d not found. retry from lowest..\n", rfCurrent);
			continue;
		}

		//dprint(2, "found rf %d\n", rf);

		if (bOverwrapped && rfCurrent >= rfOriginal) {
			// not found in whole UCM. end loop.
			//dprint(2, "! overwrapped and return to original %d\n", rfCurrent);
			break;
		}

		nMatch = 0;
		for (i=0; i<g_UCM_number; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if (g_UCM[i].RF != rf) continue;
			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		    if (nMatch < szBuf && uidBuf)
		    	uidBuf[nMatch] = g_UCM[i].Uid;
		    nMatch++;
			//dprint(2, " find rf ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
			//	g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
		}
		
		if (nMatch > 0)
			break;      // some ucm found.
			
		//dprint(0, "!! rf %d found, but not proper. continue next rf..\n", rf);
		rfCurrent = rf;
			
	} // end of while
	
	DMW_MSC_UnlockUcm();
	return nMatch;
}


int DMW_MSC_FindRfDown(UINT16 rfCurrent, int flag, int szBuf, int *uidBuf)
{
	int i, nMatch = 0;
	int rf, rfOriginal = rfCurrent;
	BOOL bOverwrapped = FALSE;
	
	DMW_MSC_LockUcm();

	// rfCurrent validity check.
	// required??
	if (g_UCM_number <= 0) {
		DMW_MSC_UnlockUcm();
		return 0;
	}

	while (1) 
	{
		// 원하는 정보를 찾을 때 까지 반복한다.
		
		// rfCurrent보다 작은 최대 rf를 찾는다.
		rf = 0;
		for (i=0; i<g_UCM_number; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if (g_UCM[i].RF < rfCurrent && g_UCM[i].RF > rf)
				rf = g_UCM[i].RF;
		}

		if (rf == 0) {  // not found using this rf. find from largest rf.
			if (bOverwrapped)
				break;
			rfCurrent = 1000;
			bOverwrapped = TRUE;
			continue;
		}

		if (bOverwrapped && rfCurrent <= rfOriginal) {
			// not found in whole UCM. end loop.
			break;
		}

		nMatch = 0;
		for (i=0; i<g_UCM_number; i++) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if (g_UCM[i].RF != rf) continue;
			if ((flag & CSF_Include_Disabled) == 0 && g_UCM[i].disabled) continue; // cafrii 101209
			if ((flag & CSF_Include_Skipped) == 0 && g_UCM[i].Skipped) continue;  // cafrii, 030325
			if ((flag & CSF_Mask_MF) == CSF_ATSC_Only && g_UCM[i].Service_type == 0) continue;
			if ((flag & CSF_Mask_MF) == CSF_NTSC_Only && g_UCM[i].Service_type != 0) continue;
			if ((flag & CSF_Include_PSI) == 0 && g_UCM[i].VctFlag == 0)	continue; 

		    if (nMatch < szBuf && uidBuf)
		    	uidBuf[nMatch] = g_UCM[i].Uid;
		    nMatch++;
			//dprint(2, " find rf ucm: (%02d) %d-%d, %d %c[%03d]\n", i, g_UCM[i].Major, g_UCM[i].Minor,
			//	g_UCM[i].RF, g_UCM[i].VctFlag ? 'v' : ' ', g_UCM[i].Uid);
		}
		
		if (nMatch > 0)
			break;      // some ucm found.
			
		rfCurrent = rf;
			
	} // end of while
	
	DMW_MSC_UnlockUcm();
	return nMatch;
}


#if 0
_____________________()
#endif


// surf 채널 관련.. 3/21 추가
//
//

int DMW_MSC_Surf2Index(int surf)
{
	// surfIndex --> index (ucm).  require caller's UCM lock.
	
	int i, idx = -1;
	
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].SurfIndex == surf)
			idx = i;
	}
	return idx;
}

int DMW_MSC_FindUidFromSurfIndex(int surf)
{
	// surfIndex --> uid
	// 동일한 surfIndex가 여러개 발견될 경우, 제일 마지막에 발견된 채널 uid가 리턴된다.
	
	int i, uid = -1;
	if (surf == 0) return 0;
	
	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].SurfIndex != surf) continue;
		
		uid = g_UCM[i].Uid;
	}
	DMW_MSC_UnlockUcm();
	return uid;
}


UINT16 DMW_MSC_FindSurfIndexFromUid(int uid)
{
	// uid --> surfIndex
	
	int index;
	UINT16 surf;
	
	DMW_MSC_LockUcm();
	index = DMW_MSC_Uid2Index(uid);

	if (index < 0) {
		DMW_MSC_UnlockUcm();
		return 0;
	}
	surf = g_UCM[index].SurfIndex;
	DMW_MSC_UnlockUcm();
	return surf;
}

UINT16 DMW_MSC_FindMaxSurfIndex(int *returnUcmIndex)
{
	// *returnUcmIndex: max surfIndex를 가지는 channel의 UCM index
	// return value: surfIndex
	// returnUcmIndex가 NonNull일 경우에는 caller측에서 UcmLock을 필요로 함.
	
	int i;
	int maxidx = -1;
	UINT16 maxsurf = 0;
	
	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		//dprint(2, "i=%d SurfIndex=%d\n",i, g_UCM[i].SurfIndex);
	
		if (maxsurf < g_UCM[i].SurfIndex) 
		{
			maxsurf = g_UCM[i].SurfIndex;  // 현재까지의 최대 surfIndex
			maxidx = i;
		}
	}
	if (maxidx >= 0 && returnUcmIndex) *returnUcmIndex = maxidx;
	
	DMW_MSC_UnlockUcm();
	return maxsurf;
}

UINT16 DMW_MSC_FindMinSurfIndex(int *returnUcmIndex)
{
	// *returnUcmIndex: min surfIndex를 가지는 channel의 UCM index
	// return value: surfIndex
	// returnUcmIndex가 NonNull일 경우에는 caller측에서 UcmLock을 필요로 함.
	
	int i;
	int minidx = -1;
	UINT16 minsurf = 65535;
	
	DMW_MSC_LockUcm();
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].SurfIndex && minsurf > g_UCM[i].SurfIndex) {
			minsurf = g_UCM[i].SurfIndex;
			minidx = i;
		}
	}
	if (minidx >= 0 && returnUcmIndex) *returnUcmIndex = minidx;
	
	DMW_MSC_UnlockUcm();
	return minsurf;
}	


int DMW_MSC_FindSurfUp(int uidCurrent, int flag)
{
	// return uid.
	
	int i, index, uid;
	UINT16 surf, surf_start, max_surf;

	DMW_MSC_LockUcm();
	index = DMW_MSC_Uid2Index(uidCurrent);

	if (index < 0 || g_UCM[index].SurfIndex == 0)
	{
		dprint(0, "!! uid %d, idx %d is invalid or not surf ch.\n", uidCurrent, index);
		if (index < 0 || flag & CSF_IgnoreSurfOrder) 
		{
			// find lowest index channel which is in surf list.
			uid = -1;
			for (i=0; i<g_UCM_number; i++) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) {
					uid = g_UCM[i].Uid;
					break;
				}
			}
			if (uid < 0) dprint(0, "!! no surf channel!\n");
			DMW_MSC_UnlockUcm();
			return uid;
		}
		else {
			// find nearest upper surf channel from uidCurrent (index).
			uid = -1;
			for (i=index+1; i!=index; i=(i+1)%g_UCM_number) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) {
					uid = g_UCM[i].Uid;
					break;
				}
			}
			if (uid < 0) dprint(0, "!! no surf channel!\n");
			DMW_MSC_UnlockUcm();
			return uid;
		}
	}
	
	// uidCurrent is one of surf channel.
	if (flag & CSF_IgnoreSurfOrder) 
	{
		// just treat surfindex as binary.
		//  find nearest upper surf channel from index.
		dprint(2, "** ignore surf order\n");
		uid = -1;
		for (i=index+1; i!=index; i=(i+1)%g_UCM_number) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) break;
		}
		// 만약 이 시점에서 index == i이라면 다른 surf channel이 하나도 없는 경우이다.
		if (i==index) dprint(0, "!! not found any other surf channel!\n");
		uid = g_UCM[i].Uid;
		DMW_MSC_UnlockUcm();
		return uid;
	}
	else {
		// surf index 값을 사용하여 다음 upper surf index 채널을 찾는다.
		surf_start = g_UCM[index].SurfIndex;
		max_surf = DMW_MSC_FindMaxSurfIndex(NULL);
	
		// surf_index를  surf+1, surf+2, ... 순서로 계속 찾아본다.
		surf = (surf_start==max_surf) ? 1 : surf_start+1;
		dprint(2, "search from sid %d..\n", surf);
		for ( ; surf!=surf_start; surf = (surf==max_surf) ? 1 : surf+1) 
		{
			//if (g_bReserveUcmIndex0)
			//	if(i==0) continue;

			i = DMW_MSC_Surf2Index(surf);
			if (i >= 0)
				break;
		}
		if (surf == surf_start) {
			dprint(0, "!! not found any other surf channel!\n");
			i = index;
		}
		//else dprint(2, "found sid %d\n", surf);
		uid = g_UCM[i].Uid;
		DMW_MSC_UnlockUcm();
		return uid;
	}
}

int DMW_MSC_FindSurfDown(int uidCurrent, int flag)
{
	// return uid.
	
	int i, index, uid;
	UINT16 surf, surf_start, max_surf;
	
	DMW_MSC_LockUcm();
	index = DMW_MSC_Uid2Index(uidCurrent);

	if (index < 0 || g_UCM[index].SurfIndex == 0)
	{
		dprint(0, "!! uid %d, idx %d is invalid or not surf ch.\n", uidCurrent, index);
		if (index < 0 || flag & CSF_IgnoreSurfOrder) {
			// find lowest index channel which is in surf list.
			uid = -1;
			for (i=0; i<g_UCM_number; i++) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) {
					uid = g_UCM[i].Uid;
					break;
				}
			}
			if (uid < 0) dprint(0, "!! no surf channel!\n");
			DMW_MSC_UnlockUcm();
			return uid;
		}
		else {
			// find nearest lower surf channel from uidCurrent (index).			
			uid = -1;
			for (i=index-1; i!=index; i=(i-1+g_UCM_number)%g_UCM_number) 
			{
				if (g_bReserveUcmIndex0)
					if(i==0) continue;

				if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) {
					uid = g_UCM[i].Uid;
					break;
				}
			}
			if (uid < 0) dprint(0, "!! no surf channel!\n");
			DMW_MSC_UnlockUcm();
			return uid;
		}
	}
	
	// uidCurrent is one of surf channel.
	if (flag & CSF_IgnoreSurfOrder) {
		uid = -1;
		for (i=index-1; i!=index; i=(i-1+g_UCM_number)%g_UCM_number) 
		{
			if (g_bReserveUcmIndex0)
				if(i==0) continue;

			if (!g_UCM[i].Skipped && g_UCM[i].SurfIndex) break;
		}
		if (i==index) dprint(0, "!! not found any other surf channel!\n");
		uid = g_UCM[i].Uid;
		DMW_MSC_UnlockUcm();
		return uid;
	}
	else {
		surf_start = g_UCM[index].SurfIndex;
		max_surf = DMW_MSC_FindMaxSurfIndex(NULL);
	
		// surf_index를  surf-1, surf-2, ... 순서로 계속 찾아본다.
		surf = (surf_start==1) ? max_surf : surf_start-1;
		for ( ; surf!=surf_start; surf = (surf==1) ? max_surf : surf-1) 
		{
			//if (g_bReserveUcmIndex0)
			//	if(i==0) continue;

			i = DMW_MSC_Surf2Index(surf);
			if (i >= 0)
				break;
		}
		if (surf == surf_start) {
			dprint(0, "!! not found any other surf channel!\n");
			i = index;
		}
		//else dprint(2, "found sid %d\n", surf);
		uid = g_UCM[i].Uid;
		DMW_MSC_UnlockUcm();
		return uid;
	}
}





#if 0
______API_____________()
#endif

STATUS (*g_fnUcmDeleteHook)(int idx);
	// channel delete hook entry function



STATUS DMW_CDB_InitializeChannelLib(ChannelType type, int sizeExtension)
{
	
	if (sizeExtension < 0) sizeExtension = 0;
	if (sizeExtension > 32) sizeExtension = 32;

#if 1 
	// Custom ChannelType을 추가한 경우는 비교 구문을 수정해야 한다.
	//
	if (type != ChannelType_Air && type != ChannelType_Cable) {
		dprint(0, "!! invalid channel type %d\n", type);
		return statusInvalidArgument;
	}
#endif
	
	if (g_CurChannelType != type)
	{
		DMW_CDB_ClearAll();  // 기존의 UCm을 폐기.

		if (g_sizeUcmExtension != sizeExtension) 
		{
			DMW_MSC_LockUcm();
			DHL_OS_Free((void**)&g_UCM);
			g_UCM_max = 0;
			*(int *)&g_sizeUcmExtension = sizeExtension;	
			DMW_MSC_UnlockUcm();
		}
		
		// cafrii 040628 add
		//
		// 디폴트 Frequency standard를 적용시켜준다.
		// Cable MultiStandard를 지원하지 않는 Application에서는 신경쓰지 않고
		// Air/Cable_Std 두가지만 사용할 수 있도록...
		//
		if (type == ChannelType_Air) {
			DMW_HAL_SetChannelStandard(eDHL_FREQ_AIR);
		}
		else {
			DMW_HAL_SetChannelStandard(eDHL_FREQ_STD); 
			// 일단 STD_Cable로 설정한다.
			// 만약 STD 이외의 다른 규격을 지원한다면 이 API 이후에 별도로 Change 하는 API를
			// 다시 호출해야 한다.
		}
		
		*(ChannelType *)&g_CurChannelType = type;  // cafrii, 030322 버그수정.
	}
	else {
		// cafrii 040628 add
		// channel number, PID 값을 Context 저장의 키로 사용하기 때문에
		// 모든 Flatten된 정보도 삭제되어야 한다.
		// DB Clear 될때 수행되기는 하지만 channel type은 동일한데
		// Frequency std 만 변경되는 경우에는 혹 User의 실수로 DB를 지우지 않을 수도 있기때문..
		//
#if USE_FLATTEN_VIDEO
		DHL_VID_DeleteAllFlattenedInfo();
#endif

	}
	
	return statusOK;
}

STATUS  DMW_CDB_TerminateChannelLib()
{
	dprint(2, "TerminateChannelLib.\n");
		
	return statusOK;
}




//******************************************************************
//
//    Update Channel DB APIs
//
//


// channel DB와 관련있는 broadcast type은 Air/Cable인데,
// 현재 메모리에는 한 종류의 channel DB만 올라올수 있다.
// 물론 NvRAM에는 두 종류 다 저장되어 있을 수 있다.


//--------------------------------------------------
//  initialize channel DB
//
STATUS DMW_CDB_ClearAll()
{
	int i;
	
	DMW_MSC_LockUcm();

	// DMW_CDB_DeleteUcmChannel 이 함수를 각 entry별로 각각 부르면 매번 delete 할 때마다
	// DB sorting을 수행하기 때문에 부하가 많다.
	// 따라서 모든 DB를 다 지우는 이런 함수같은 경우에는 따로 코드를 작성한다.
	//
	if (g_fnUcmDeleteHook) {
		// delete hook이 있는 경우에만 각 entry별 처리를 하면 된다.
		// delete hook이 없다면 그냥 UCM 영역만 지워버리면 된다.

		for (i=g_UCM_number-1; i>=0; i--) {
			g_fnUcmDeleteHook(i);
		}
	}
	
	// cafrii 041126 add
	//for (i=g_UCM_number-1; i>=0; i--)
	//	DMW_CDB_DeleteUcmCsd(i);
	DMW_CDB_DeleteAllUcmCsd();   // cafrii 041127 fix.. more efficient
	
	g_UCM_number = 0;
	// 할당된 메모리를 해제하지는 않는다. 다시 사용될 경우를 대비해서 그냥 둔다.

	// index 0에 대한 특별한 경우도 이 함수에서는 신경쓰지 않는다.
	// caller에서 필요한 경우 추가로 assine 하면 된다.
	
	DMW_MSC_UnlockUcm();

	// cafrii 060630 add
	// channel number, PID 값을 Context 저장의 키로 사용하기 때문에
	// 모든 Flatten된 정보도 삭제되어야 한다.
	//
#if USE_FLATTEN_VIDEO
	DHL_VID_DeleteAllFlattenedInfo();
#endif

	return statusOK;
}



//------------------------------
//  DMW_CDB_UpdateDB
// 
// TV 시청 중에 현재 RF 의 채널을 다시 검색하는 함수.
// 이미 tuning은 되어 있기 때문에 Tuner 설정은 하지 않으며, 단지 table 만 다시 받는다.
// 
// 여기서 지정하는 rf는 실제로 tuner를 setting하기 위한 것이 아니고, 
// update할 DB의 필요한 자료로서 넘겨주는 것이다. 따라서 반드시 정확한 RF를 넘겨줘야 한다.
//
// 일부 Tuner 모듈은 아날로그와 디지털 튜닝이 완전히 구분되어 사용되어야 하는데,
// 이 경우 만약 현재 아날로그를 시청중이라면 디지털 검색이 불가능하며
// 현재 디지털을 시청중이라면 아날로그 검색은 불가능하다. 
// 즉, scan_flag의 모든 값이 다 반영되지 못하는 경우가 있다.
// 
//
STATUS DMW_CDB_UpdateDB(int rf, int scan_flag, int *pnUid, int **puidBuf)
{

	// 이 함수는 더이상 지원하지 않는다.
	return statusNotImpl;
}





//------------------------------
//  DMW_CDB_ScanChannel
//
// Autoscan 함수의 one-channel 버전.
// 꼭 TV Stop 상태에서 call 되어야 함. (튜너를 새로 설정하기 때문..)
// 사용자가 지정한 Air/Cable 플래그는 무시됨. 현재의 ChannelType 상태 안에서 동작한다.
// NTSC/VSB/QAM 플래그는 사용된다.
//
// DMW_CDB_ScanChannel 과 DMW_CDB_ScanChannelEx 의 구분을 없애고
// DMW_CDB_ScanChannel 로 통일한다.
// Argument가 추가되었음에 유의.

STATUS DMW_CDB_ScanChannel(int rf, int flag, ChannelScanCallback eventcb, 
								int *pnUid, int **puidBuf)
{
	// DMW_ASC_ScanChannel에서 지원한다.
	//
	return statusNotImpl;
}

#if 0
// 아래 함수가 정리될 때 까지 block
STATUS DMW_CDB_UpdateUcmFromTvct(tvctPtr_t tvct, int rf, int scan_flag, int *pnUid, int **puidBuf)
{
	return update_ucm_from_tvct(tvct, rf, scan_flag, pnUid, puidBuf);
}

STATUS DMW_CDB_UpdateUcmFromCvct(cvctPtr_t cvct, int rf, int scan_flag, int *pnUid, int **puidBuf)
{
	return update_ucm_from_cvct(cvct, rf, scan_flag, pnUid, puidBuf);
}
#endif

/*
	이 함수는 이미 준비 된 psi/psip 테이블을 이용하여 ch update를 수행한다.
	
*/
STATUS DMW_CDB_UpdateChannel(xvctPtr_t vct, MPEG_PAT *pat, MPEG_PMT **pmtlist, 
						int rf, int scan_flag, 
						int *pnUid, int **puidBuf)
{
	return SCN_UpdateUcmVct(vct, pat, pmtlist, rf, scan_flag, pnUid, puidBuf);
}


int DMW_CDB_MakeNewUcm(int major, int minor, int rf, int vf, int st)
{
	// do not call this function unless you know what this function does..
	// 리턴되는 idx 값을 사용하려면 caller쪽에서도 마찬가지로 UcmLock을 해야 한다.
	
	int idx;
	
	DMW_MSC_LockUcm();
	idx = insert_ucm(major, minor, rf, vf);
	if (g_UCM && idx >= 0) {
		g_UCM[idx].Service_type = (st & 3);
		g_UCM[idx].Uid          = make_new_ucm_uid_counter();
	}
	DMW_MSC_UnlockUcm();
	return idx;
}


void *DMW_CDB_RegisterUcmDeleteHook(STATUS (*fn)(int idx))
{
	void *oldfn;
	
	dprint(2, "RegisterUcmDeleteHook: %x\n", fn);
	
	oldfn = (void *)g_fnUcmDeleteHook;
	g_fnUcmDeleteHook = fn;
	
	return (void *) oldfn;
		// 리턴되는 값은 previous hook function. caller는 이 값을 기억했다가
		// hook function이 call되면 맨 나중이 이전 previous hook을 호출해서
		// call chain이 끊어지지 않도록 해야 한다.
}

STATUS DMW_CDB_DeleteUcmChannel(int idx)
{
	// 해당 index의 ucm을 지운다.
	//
	// 이 함수는 굉장히 주의해서 사용하기 바람.
	// Autoscan의 마지막 과정 이외에 UCM을 지우는 것은 권장되지 않는다.
	//
	// 지운 후에도 오름차순 정렬을 유지하며, 빈 자리는 shift되어 메꿔진다.

	// extern STATUS DMW_EPG_DeleteCurrentChannel(int idx);
	
	int i;
	if (!g_UCM || idx < 0 || idx >= g_UCM_number)
		return statusOutOfRange;

	if (g_bReserveUcmIndex0 && idx == 0) {
		dprint(0, "!! Deleting UCM[0] not allowed..\n");
		return statusInvalidArgument;	
	}
	
	dprint(2, "DeleteUcmItem(idx %d, uid %d) --> total ucm number %d\n",
		idx, g_UCM[idx].Uid, g_UCM_number-1);
	
	if (g_fnUcmDeleteHook == NULL) {
		if (g_UCM[idx].pEpgDB)
			dprint(0, "!! Warning: EPG DB link exist, but fnUcmDeleteHook not registerred\n");
	}
	else {
		g_fnUcmDeleteHook(idx);
	}
	
	// cafrii 041126 add
	DMW_CDB_DeleteUcmCsd(idx);
	
	// idx를 지우는거니까 idx+1 부터 끝까지를 한칸씩 앞으로 이동..
	for (i=idx+1; i<g_UCM_number; i++)
		g_UCM[i-1] = g_UCM[i];      // byte copy

	g_UCM_number--;
	return statusOK;
}

// Uid로 지정하여 UCM item을 하나 지운다.
//
STATUS DMW_CDB_DeleteChanInfoUid(UINT16 uid)
{
	int i;
	DMW_MSC_LockUcm();
	
	i = DMW_MSC_Uid2Index(uid);
	if (i >= 0)
		DMW_CDB_DeleteUcmChannel(i);

	DMW_MSC_UnlockUcm();
	
	return (i>=0) ? statusOK : statusChannelNotFound;
}


// delete channel information of specified RF channel
//
STATUS DMW_CDB_DeleteRFChanInfo(int RF_number)
{
	int i;

	if (!g_UCM) return statusOK;
		
	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].RF == RF_number)
		{
			DMW_CDB_DeleteUcmChannel(i); // 안에서 UCM_number도 감소해야 함..
			i--;  // 현재것이 지워졌으니까, 현재 index부터 다시 시작.
		}
	}

	DMW_MSC_UnlockUcm();

	return statusOK;
}

// delete channel information of specified major number
STATUS DMW_CDB_DeleteMajorChanInfo(int major_number)
{
	int i;

	if (!g_UCM) return statusOK;

	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].Major > major_number) // 오름차순 정렬이므로 더 이상 진행 불필요.
			break;

		if (g_UCM[i].Major == major_number && g_UCM[i].VctFlag)
		{
			DMW_CDB_DeleteUcmChannel(i); // 안에서 UCM_number도 감소해야 함..
			i--;  // 현재것이 지워졌으니까, 현재 index부터 다시 시작.
		}
	}

	DMW_MSC_UnlockUcm();

	return statusOK;
}


// delete channel information of specified major number
STATUS DMW_CDB_DeleteMajorMinorChanInfo(int major, int minor)
{
	int i;
	if (!g_UCM) return statusOK;

	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number; i++)
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;
				
		if (g_UCM[i].Major > major) // 오름차순 정렬이므로 더 이상 진행 불필요.
			break;

		if (g_UCM[i].Major == major && g_UCM[i].Minor == minor && g_UCM[i].VctFlag)
		{
			DMW_CDB_DeleteUcmChannel(i); // 안에서 UCM_number도 감소해야 함..
			i--;  // 현재것이 지워졌으니까, 현재 index부터 다시 시작.
		}
	}

	DMW_MSC_UnlockUcm();

	return statusOK;
}


STATUS DMW_CDB_DeleteAllAnalogChannel()
{
	// Digital only STB의 경우 VCT에서 추출된 analog 채널 정보가 필요가 없으므로
	// 이 함수를 이용해서 삭제할 수 있다.
	// StartScan()의 scanComplete message callback에서 이 함수를 불러주면 된다.
	//
	// 또는 아예 StartScan()에서 VCT의 analog를 skip하는 방법도 고려해 볼 수 있다.
	// 위 두가지 방법을 겸용하는 것도 안전을 위해서 선택할 수 있는 좋은 방법임.
	//
	int i;
	if (!g_UCM) return statusOK;

	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number; i++)
	{
		if (g_UCM[i].Service_type == 0)	{
			DMW_CDB_DeleteUcmChannel(i); // 안에서 UCM_number도 감소해야 함..
			i--;  // 현재것이 지워졌으니까, 현재 index부터 다시 시작.
		}
	}
	DMW_MSC_UnlockUcm();
	
	return statusOK;
}

void DMW_CDB_DeleteDisabledChannel(void)
{
	int i;
	if (!g_UCM) return;

	DMW_MSC_LockUcm();

	for (i=0; i<g_UCM_number; i++)
	{
		if (g_UCM[i].disabled)	{
			DMW_CDB_DeleteUcmChannel(i); // 안에서 UCM_number도 감소해야 함..
			i--;  // 현재것이 지워졌으니까, 현재 index부터 다시 시작.
		}
	}
	DMW_MSC_UnlockUcm();
}

// insert a channel in Surf channel link
// add flag parameter to support skipped channel! leon 2003.10.9 
	// currently supported flag is only CSF_Default or CSF_Include_Skipped.
	//	CSF_Default: not include skipped
	//	CSF_Include_Skipped: include skipped	
STATUS DMW_CDB_SetSurfChannel(int index, int prev_index)
{
	// prev_index의 채널이 surf 채널이면 그 surf_index 다음 번호로 세팅.
	// prev_index의 채널이 surf 리스트에 없는 채널이면 맨처음에 추가.
	// prev_index == -1이면 surf list 맨 처음에 추가.
	// prev_index == -2이면 surf list 맨 마지막에 추가.

	// 
	int surfindex, i;
	
	if (index < 0 || index >= g_UCM_number)
		return statusInvalidArgument;
		
	#if 0//leon 2003.10.9  skipped channel도 surf에 추가할수있도록 
		if (g_UCM[index].Skipped)
			return statusSkippedChannel;
	#endif
	
	if (g_UCM[index].SurfIndex)
		DMW_CDB_ReleaseSurfChannel(index); // 먼저 지우자.
		
	// surfIndex는 1부터 시작하는 값이다.
	if (prev_index == -1)
		surfindex = 1;
	else if (prev_index == -2)
		surfindex = DMW_MSC_FindMaxSurfIndex(NULL) + 1;  // 하나도 없으면 1 (맨처음)
	else if (prev_index < 0 || prev_index >= g_UCM_number)
		surfindex = 1;    // first channel in surf list.
	else {
		surfindex = g_UCM[prev_index].SurfIndex + 1;
			// prev_index가 surf list에 없는 것이면 1번부터 번호매김.
	}
	
	// 'surfindex' 이후의 모든 surfindex들을 하나씩 뒤로 미룬다.
	for (i=0; i<g_UCM_number; i++) 
	{
		if (g_bReserveUcmIndex0)
			if(i==0) continue;

		if (g_UCM[i].SurfIndex && g_UCM[i].SurfIndex >= surfindex) {
			g_UCM[i].SurfIndex++;
		}
	}
	
	g_UCM[index].SurfIndex = surfindex;
	//g_maxSufIndex++;
	return statusOK;
}

// delete a channel in Surf channel link
STATUS DMW_CDB_ReleaseSurfChannel(int index)
{
	int surfindex, i;
	if (index < 0 || index >= g_UCM_number)
		return statusInvalidArgument;

	surfindex = g_UCM[index].SurfIndex;
	g_UCM[index].SurfIndex = 0;
	
	if (surfindex) {
		// 'surfindex' 이후의 모든 surfindex들을 하나씩 뒤로 미룬다.
		for (i=0; i<g_UCM_number; i++) {
			if (g_UCM[i].SurfIndex && g_UCM[i].SurfIndex > surfindex) {
				g_UCM[i].SurfIndex--;
			}
		}
	}
	return statusOK;
}


// set a channel as active channel
STATUS DMW_CDB_SetFavChannel(int index)
{
	if (index < 0 || index >= g_UCM_number)
		return statusInvalidArgument;

	g_UCM[index].Skipped = FALSE;
	return statusOK;
}

// set a channel as inactive channel
STATUS DMW_CDB_ReleaseFavChannel(int index)
{
	if (index < 0 || index >= g_UCM_number)
		return statusInvalidArgument;
		
	DMW_CDB_ReleaseSurfChannel(index);
	g_UCM[index].Skipped = TRUE;
	
	return statusOK;
}


// cafrii 060630 add
void DMW_CDB_InvalidateAllPidInfo(void)
{
	int i;

	dprint(2, "invalidate all pids info\n");
	
	DMW_MSC_LockUcm();
	
	for (i=0; i<g_UCM_number; i++)
	{
		g_UCM[i].Video_pid = DMW_PID_NO_INFO;
		g_UCM[i].Audio_pid = DMW_PID_NO_INFO;
		g_UCM[i].Pcr_pid = DMW_PID_NO_INFO;
		g_UCM[i].pmt_pid = DMW_PID_NO_INFO;
	}

	// NvRam에 저장 불필요. PID 정보는 저장 대상 아님..

	DMW_MSC_UnlockUcm();	
}


#if 0
______Tune____________()
#endif



// cafrii 041202 add new API..
// 
STATUS DMW_TUN_TuneChannelByUidAndFlag(UINT16 uid, UINT32 flag,
		BOOL bWaitCompletion, ChannelTuneCallback fn, UINT32 userparam)
{
	// RfTune의 flag 설정을 이용하여 UID Tune을 한다. 
	// 사실 UidTune은 DB의 값을 이용하고, Retry 기능을 사용하지 않는 RfTune과 동일함.
	// 단,
	// RfTune에서는 Prescan PID를 사용하지 않으므로 bSkipPids는 항상 TRUE로 동작한다.
	
	TuneParam tuneParam_0, *tuneParam = &tuneParam_0;
	int index;
	
	//bSkipPrescanPids = TRUE;
	// UID tune을 할 때에는 PID 정보를 최대한 이용하면 성능에 도움이 된다.
	
    DMW_MSC_LockUcm();
	index = DMW_MSC_Uid2Index(uid);
	if (index >= 0)
	{
		memset(tuneParam, 0, sizeof(TuneParam));

		tuneParam->rf = g_UCM[index].RF;
		//tuneParam->tuneRequired = TRUE;
		tuneParam->type = (ModulationType) g_UCM[index].Service_type;

		// cafrii 060630 change
		if ((flag & CTF_SkipPrescanPidInfo) == 0) // if NOT skip, 
		{
			// 어느 하나의 pid라도 NO_INFO가 있으면 pid 튜닝은 사용 불가..
			//
			// todo.. 070201 to check
			//   여기서 pmt_pid도 체크 해야 하는가?
			//
			if (g_UCM[index].Video_pid == DMW_PID_NO_INFO ||
				g_UCM[index].Audio_pid == DMW_PID_NO_INFO ||
				g_UCM[index].Pcr_pid == DMW_PID_NO_INFO)
			{
				dprint(0, "!! no info pid exist. skip prescan pid info..\n");
				tuneParam->vidPid = tuneParam->audPid = tuneParam->pcrPid = 0;
				flag |= CTF_SkipPrescanPidInfo;
			}
			else {
	    		tuneParam->vidPid = g_UCM[index].Video_pid;
	    		tuneParam->audPid = g_UCM[index].Audio_pid;
	    		tuneParam->pcrPid = g_UCM[index].Pcr_pid;
	    		tuneParam->vidType = g_UCM[index].Video_type;
	    		tuneParam->audType = g_UCM[index].Audio_type;
    		}
    	}
    	tuneParam->flag = flag;
    	tuneParam->flag = (tuneParam->flag & ~CTF_Mask_Tuning) |
    						(g_UCM[index].VctFlag ? CTF_VCTOnly : CTF_PSIOnly);
		
		// CTF_TunerAutoFreqAdjust 는 사용하지 않는다. (필요하면 추가..)
		//tuneParam->flag |= CTF_ShowHiddenChannelAlso;
		
		if (g_UCM[index].Minor == ONE_PART_CHANNEL_INDICATOR) { // this is one part channel number
			tuneParam->major = g_UCM[index].Major;  // only in VCT
			tuneParam->minor = g_UCM[index].Minor;
		}
		else {
			tuneParam->major = g_UCM[index].Major;  // only in VCT
			tuneParam->minor = g_UCM[index].Minor;
		}
		tuneParam->progNumber = g_UCM[index].Prog_number;  // only in PSI
		
#if 1
		// cafrii 050305 bugfix.. 
		tuneParam->freqOffset = g_UCM[index].freqOffset;
#else
		if(tuneParam->type == 0){
			tuneParam->freqOffset = g_UCM[index].freqOffset;
		}else{
			tuneParam->freqOffset = 0;
		}
#endif
	}
    DMW_MSC_UnlockUcm();

    if (index < 0) {  // no such Uid exist.
    	dprint(0, "!! invalid Uid %d. stop!\n", uid);
    	return statusChannelNotFound;
    }
	
	dprint(2, "Call RfTune: rf %d, type %d, offset %d, %d-%d, #%d\n", 
				tuneParam->rf, tuneParam->type, tuneParam->freqOffset,
				tuneParam->major, tuneParam->minor, tuneParam->progNumber);
				
	return Dmc_ChangeRfChannelByTuneParam(tuneParam, bWaitCompletion, (void *)fn, userparam);
}


// cafrii 041202, redesign using new API.. more simple..
// 
STATUS DMW_TUN_TuneChannelByUid(UINT16 uid, BOOL bSkipPrescanPids, 
		BOOL bWaitCompletion, ChannelTuneCallback fn, UINT32 userparam)
{
	UINT32 flag = 0;
	
	if (bSkipPrescanPids)
		flag |= CTF_SkipPrescanPidInfo;
		
	return DMW_TUN_TuneChannelByUidAndFlag(uid, flag, bWaitCompletion, fn, userparam);
}




#if 0
______Backup____________()
#endif


//----------------------------------------------------------------
// cafrii 031205, add UCM CORE functionalities..
//
UCM_CORE *DMW_CDB_BackupUcmCore()
{
	// if NULL, memory resource is not sufficient to allocate memory..
	// caller should free this memory after use

	int i;
	UCM_CORE *core = NULL;
	UCM_CORE_ENTRY *uc = NULL;

	DMW_MSC_LockUcm();
	
	if (g_UCM_number) {
		uc = (UCM_CORE_ENTRY *) DHL_OS_Malloc(sizeof(UCM_CORE_ENTRY) * g_UCM_number);
		if (uc == NULL) {
			dprint(0, "!! Out of memory in BackupUcmCore\n");
			goto end_of_function;
		}
	}
		
	core = (UCM_CORE *) DHL_OS_Malloc(sizeof(UCM_CORE));
	if (core == NULL) {
		dprint(0, "!! Out of memory in BackupUcmCore\n");
		DHL_OS_Free((void**)&uc);
		goto end_of_function;
	}

	core->num = g_UCM_number;
	core->entry = uc;  // entry may be NULL if g_UCM_number is zero.

	for (i=0; i<g_UCM_number; i++) {
		uc[i].rf    = g_UCM[i].RF;
		uc[i].major = g_UCM[i].Major;
		uc[i].minor = g_UCM[i].Minor;
		uc[i].skip  = g_UCM[i].Skipped;
		uc[i].surf = g_UCM[i].SurfIndex;
		uc[i].block = g_UCM[i].blocked;
	}

end_of_function:
	
	DMW_MSC_UnlockUcm();
	
	return core;  // it may be NULL..
}

void TestPrintUcmCore(UCM_CORE *core)
{
	int k;
	for (k=0; core && core->entry && k<core->num; k++) {
		UCM_CORE_ENTRY *uc = core->entry;
		DHL_OS_Printf("   [%d] rf %d, %d-%d  skip %d, surf %d, block %d\n", 
			k, (int)uc[k].rf, (int)uc[k].major, (int)uc[k].minor,
			(int)uc[k].skip, (int)uc[k].surf, (int)uc[k].block);
	}
}

STATUS DMW_CDB_UpdateUcmCore(UCM_CORE *core)
{
	// update UCM core so that channel parameters can be unchanged..
	UCM_CORE_ENTRY *uc;
	int i, k;

	if (core == NULL) 
		return statusInvalidArgument;

	//dprint(1, "UpdateUcmCore(%x, %d, %x)\n", core, core->num, core->entry);
	
	if (core->num == 0) {
		dprint(2, "  No entries in UcmCore. \n");
		return statusOK;  // update할 데이터가 없다.
	}
	
	DMW_MSC_LockUcm();
	for (k=0; k<core->num; k++) {
		
		uc = core->entry;
		
		//dprint(2, "   [%d] rf %d, %d-%d  skip %d, surf %d, block %d\n", 
			//k, uc[k].rf, uc[k].major, uc[k].minor, uc[k].skip, uc[k].surf, uc[k].block);
		
		// 기존 데이터랑 일치하는 것 있으면 무조건 overwrite.
		for (i=0; i<g_UCM_number; i++) {
			if (g_UCM[i].RF    == uc[k].rf &&
				g_UCM[i].Major == uc[k].major &&
				g_UCM[i].Minor == uc[k].minor)
			{
				//dprint(2, "!! old match found. new ucm[%d] <= uc[%d] apply..\n", i, k);
				g_UCM[i].Skipped = uc[k].skip;
				g_UCM[i].SurfIndex = uc[k].surf;
				g_UCM[i].blocked = uc[k].block;
			}
		}
	}
	DMW_MSC_UnlockUcm();
	
	//dprint(2, "Total %d ucm cores are udpated\n", core->num);
	
	// Please call this "FREE" function in caller (Application)

	return statusOK;	
}

void DMW_CDB_FreeUcmCore(UCM_CORE *core)
{
	if (!core) return;
	
	DHL_OS_Free((void**)&core->entry); 
	DHL_OS_Free((void**)&core);
}





// cafrii 041126 add
// use MW's own ucm print function
// 

//
// 메모리에 있는 UCM을 리스트한다.
//
void DMW_CDB_PrintOneUcm(int i, int detailLevel)
{
	char surf[20];
	char channel[20]; // 65536 135,  999-999 13

	if (g_UCM[i].SurfIndex)
		sprintf(surf, "%02d", g_UCM[i].SurfIndex % 100);
	else sprintf(surf, "..");

	if (g_UCM[i].Service_type == 0) { // NTSC

		#if 0
			sprintf(channel, "%2d-%-3d %-3d", g_UCM[i].Major, g_UCM[i].Minor, g_UCM[i].RF);
		#else // cafrii 050119 add.. 아날로그도 OnePart 가 가능함
			if (g_UCM[i].Minor == ONE_PART_CHANNEL_INDICATOR) 
				sprintf(channel, " %-5d %-3d", g_UCM[i].Major, g_UCM[i].RF);
			else
				sprintf(channel, "%2d-%-3d %-3d", g_UCM[i].Major, g_UCM[i].Minor, g_UCM[i].RF);
		#endif
		
			DHL_OS_Printf(" %c(%02d) %-10s %c[%03d] %s $%-3d analog (%dKHz) [%s] %d/%d\n",
				g_UCM[i].disabled ? 'x' :
					g_UCM[i].hidden ? 'h' :
					g_UCM[i].Skipped ? ' ' : 
					g_UCM[i].blocked ? 'b' : '+',
				i, channel, // g_UCM[i].Major, g_UCM[i].Minor, g_UCM[i].RF,
				g_UCM[i].VctFlag ? 'v' : ' ',
				g_UCM[i].Uid, surf,
				g_UCM[i].source_id,  // SI 에서는 source_id가 중요하므로 같이 표시..
				g_UCM[i].freqOffset/1000,
				DMW_Unicode2Ks((UINT16*)(g_UCM[i].ShortName), 7, NULL),
				g_UCM[i].num_csd,  g_UCM[i].max_csd
			);
			if (detailLevel >= 1 && g_UCM[i].csd)
				DMW_CDB_PrintCsd(g_UCM[i].csd, g_UCM[i].num_csd, 6, detailLevel);
	}
	else {
		if (g_UCM[i].VctFlag) {  // from VCT
			if (g_UCM[i].Minor == ONE_PART_CHANNEL_INDICATOR) 
				sprintf(channel, " %-5d %-3d", g_UCM[i].Major, g_UCM[i].RF);
			else
				sprintf(channel, "%2d-%-3d %-3d", g_UCM[i].Major, g_UCM[i].Minor, g_UCM[i].RF);
			
			DHL_OS_Printf(" %c(%02d) %-10s%c%c[%03d] %s #%-2d $%-3d %s [%s] (%dKHz) %x/%x/%x %x/%x:%x %d/%d\n",
				g_UCM[i].disabled ? 'x' :
					g_UCM[i].hidden ? 'h' :
					g_UCM[i].Skipped ? ' ' :
					g_UCM[i].blocked ? 'b' : '+',         // enabled channel
				i, channel,
				g_UCM[i].scrambled ? '*' : ' ',  // cafrii 041130 add
				g_UCM[i].VctFlag ? 'v' : ' ',
				g_UCM[i].Uid, surf,
				g_UCM[i].Prog_number, g_UCM[i].source_id,
				ServiceTypeString(g_UCM[i].Service_type),
				DMW_Unicode2Ks((UINT16*)(g_UCM[i].ShortName), 7, NULL),
				g_UCM[i].freqOffset/1000,
				g_UCM[i].Pcr_pid, g_UCM[i].Video_pid, g_UCM[i].Audio_pid,
				g_UCM[i].Video_type, g_UCM[i].Audio_type, 
				g_UCM[i].video_format,
				g_UCM[i].num_csd,  g_UCM[i].max_csd
			);
			if (detailLevel >= 1 && g_UCM[i].csd)
				DMW_CDB_PrintCsd(g_UCM[i].csd, g_UCM[i].num_csd, 6, detailLevel);
			if (detailLevel >= 2 && g_UCM[i].LongName[0]) {
				char longname[100];
				DMW_Unicode2Ks((UINT16*)(g_UCM[i].LongName), 
					(int)sizeof(g_UCM[i].LongName)/sizeof(g_UCM[i].LongName[0]), longname),
				DHL_OS_Printf("      longname: '%s'\n", longname);
			}
		}
		else {  // from PSI
			//if (g_UCM[i].Minor == ONE_PART_CHANNEL_INDICATOR) 
			//	sprintf(channel, "%3d", g_UCM[i].Major);
			//else
				sprintf(channel, "%2d-%-3d %-3d", g_UCM[i].Major, g_UCM[i].Minor, g_UCM[i].RF);

			DHL_OS_Printf(" %c(%02d) %-10s%c%c[%03d] %s #%-2d $%-3d %s [PSI] (%dKHz) %x/%x/%x %x/%x:%x %d/%d\n",
				g_UCM[i].disabled ? 'x' :
					g_UCM[i].Skipped ? ' ' :
					g_UCM[i].blocked ? 'b' : '+',         // enabled channel
				i, channel,
				g_UCM[i].scrambled ? '*' : ' ',  // cafrii 041130 add
				g_UCM[i].VctFlag ? 'v' : ' ',
				g_UCM[i].Uid, surf,
				g_UCM[i].Prog_number, g_UCM[i].source_id,
				ServiceTypeString(g_UCM[i].Service_type),
				g_UCM[i].freqOffset/1000,
				g_UCM[i].Pcr_pid, g_UCM[i].Video_pid, g_UCM[i].Audio_pid,
				g_UCM[i].Video_type, g_UCM[i].Audio_type,
				g_UCM[i].video_format,
				g_UCM[i].num_csd,  g_UCM[i].max_csd
			);
			if (detailLevel >= 1 && g_UCM[i].csd)
				DMW_CDB_PrintCsd(g_UCM[i].csd, g_UCM[i].num_csd, 6, detailLevel);
		}
	}
}

void DMW_CDB_PrintUcm(int detailLevel) // 메모리에 있는 UCM을 리스트한다.
{
	int i;
	DMW_MSC_LockUcm();
	DHL_OS_Printf("  ---- UCM (total %d) [pid:p/v/a vt/at hex]----\n", g_UCM_number);
	for (i=0; g_UCM && i<g_UCM_number; i++) {
		DMW_CDB_PrintOneUcm(i, detailLevel);
	}
	DHL_OS_Printf("\n");
	DMW_MSC_UnlockUcm();
}


// cafrii 041206 add
//
void DMW_CDB_PrintRfUcm(int detailLevel) // 메모리에 있는 UCM을 리스트한다.
{
	int i, rf, n_ucm;
	
	DMW_MSC_LockUcm();
	DHL_OS_Printf("---- UCM by RF (total %d) ----\n", g_UCM_number);
	
	n_ucm = 0;  // 출력한 ucm 갯수
	for (rf=0; rf<200; rf++) {
		for (i=0; g_UCM && i<g_UCM_number; i++) {
			if (g_UCM[i].RF == rf) {
				DMW_CDB_PrintOneUcm(i, detailLevel);
				n_ucm++;
				if (n_ucm == g_UCM_number) break;
			}
		}
		if (n_ucm == g_UCM_number) break;
	}
	
	if (n_ucm != g_UCM_number) 
		DHL_OS_Printf("!! %d ucm exist, but %d ucm printed\n", g_UCM_number, n_ucm);
	DHL_OS_Printf("\n");
	
	DMW_MSC_UnlockUcm();
}



#if 0
______DebugSymbol____()
#endif





#if DMW_REGISTER_DEBUG_SYMBOL

static DHL_SymbolTable ChannelUcmSymbols[] =
{
	//---- functions
	DHL_FNC_SYM_ENTRY(DMW_CDB_InitializeChannelLib),
	DHL_FNC_SYM_ENTRY(DMW_CDB_ClearAll),
	DHL_FNC_SYM_ENTRY(DMW_CDB_PrintUcm),

	DHL_FNC_SYM_ENTRY(DMW_CDB_DeleteChanInfoUid),
	DHL_FNC_SYM_ENTRY(DMW_MSC_EnableChannel),

	DHL_FNC_SYM_ENTRY(DMW_CDB_InvalidateAllPidInfo),

	DHL_FNC_SYM_ENTRY(DMW_MSC_LockUcm),
	DHL_FNC_SYM_ENTRY(DMW_MSC_UnlockUcm),
	
	//---- variables
	//DHL_VAR_SYM_ENTRY(g_Trace_bUcmDebug),
	//DHL_VAR_SYM_ENTRY(g_Trace_bUcmSearch),
	//DHL_VAR_SYM_ENTRY(g_Trace_Mcm),
};

#endif // DMW_REGISTER_DEBUG_SYMBOL


void DMW_CDB_RegisterChannelUcmSymbols()
{
#if DMW_REGISTER_DEBUG_SYMBOL
	DHL_DBG_RegisterSymbols(ChannelUcmSymbols, DHL_NUMSYMBOLS(ChannelUcmSymbols));
	
#endif
}





/******************************************************************************
 
  $Log: DMW_Ucm.c,v $

	1.18 2005/4/4   ScanChannel 에 demux start 코드 추가

	1.17 2005/3/15  NtscFreqOffset->freqOffset 이름 변경
	1.16 2005/3/5   Uid tune에서 freqOffset이 적용되지 않던 문제 수정
	1.15 2005/01/19 PrintUCM 수정
	1.14 2004/12/09 update_current_scan 에 bSetTuner 인자 추가된것 적용
	
	1.13 2004/12/06 DMW_CDB_PrintRfUcm 추가

	1.12 2004/12/02 DMW_TUN_TuneChannelByUidAndFlag 추가.

	1.11 2004/11/30 UpdateDB 에서 scan_flag 조정
	                DMW_CDB_PrintOneUcm, scramble channel 표시

	1.10 2004/11/27 DMW_CDB_ClearAll 에서 좀더 효율적인 DeleteAllUcmCsd 사용
	1.09 2004/11/26 ucm entry를 delete 할때 csd 도 같이 delete
	                자체적인 ucm print 함수 추가
	1.08 2004/11/5 DMW_TUN_TuneChannelByUid 에서 two part channel system으로 
	               다시 변경하는 코드 삭제
	
	1.07 2004/11/3 ShortNameString에서 non-ascii 글자 깨지는거 수정.
	               DebugUtil.h 포함

	1.06 2004/11/1 UpdateDB에서 CBTF_IgnoreScrambledChannel 플래그 삭제
	
	1.05 2004/8/30 DMW_CDB_ChangeFrequencyStandard 가 ChannelTune 모듈로 이동
	             FreqSTd 관련 모든 기능은 ChannelDB와 분리
	   8/31      g_CurChannelType HAL 모듈로 이동
	
	1.04 2004/8/12 insert_ucm 에서 일치하는 entry가 있을경우 reset되는 버그 수정 (from miyu)
	
	1.03 2004/6/4  DMW_CDB_UpdateDB 에서 pause하기 전 psiCtl상태 체크
	1.02 2004/5/11 FindMajorDown bugfix
  
  OS_Realloc 버그 회피코드 추가 031111

  DMW_CDB_DeleteMajorMinorChanInfo() 추가
 
  rev 1.01 2003/2/24, cafrii
  insert_ucm 버그 수정.
  upper/lower major surfing 추가.  
 
  Revision 1.0  2003/02/00   cafrii
  Initial coding from ground
 
******************************************************************************/