#include "DST_ChannelTune.h"
#include "DST_HostInterface.h"
#include "DST_GlobalVariables.h"
#include "DST_WindowEvent.h"
#include "DST_WindowType.h"
#include "DST_WinManagerTask.h" //ui
#include "DST_DataStrings.h"
#include "DST_SignalMonitor.h"
#include "DST_UserInterface.h"
#include "DST_FontEngine.h"
#include "DST_CCTask.h"
#include "DST_WinManager.h"
#include "DST_ISDBT_ChannelTask.h"
#include "dst_eroum_interface.h"
#include "DST_DB_Engine.h"
#include "DST_DB.h"
#include "DST_EEPROM.h"
#include "DST_GlobalVariables.h"
#include "DST_Updates.h"
#include "DST_MemoryDB.h"

void DST_USBUpdateInit(void);

void DST_DB_Del();
char *DST_GetModelName(void);

static void DST_CT_CallBack(DS_U8 Cmd, DS_U32 p1, DS_U32 p2, DS_U32 p3, DS_U32 p4, DS_U32 p5, DS_U32 p6);

// 공장 초기화 후 재팅 후 첫번째로 불리는 함수
// EEPROM과 채널맵을 모두 지운다.
void DST_Factory_Reset()
{
	DST_DB_Del();
	DST_EEPROM_FactoryInit();
}

void DST_Tune(DS_U8 RF, DS_U16 program_number)
{
	if (program_number == 0)
	{
//		CDB db;
//		db.Query("update signal set signal_strength=99 where signal_strength=100");
//		db.Query("delete from signal where rf=%d", RF);
//		db.Query("insert into signal values(%d, %d, %d, %d, %d)", RF, 100, 0, 0, 1);
		//Minor = 1;
	}
	JST_Open(DST_CT_CallBack);
	JST_Tune(RF, DHL_MODULATION_8VSB, program_number);
}

// 채널 튜닝을 한다.
void DST_Scan(DS_U8 RF)
{
	JST_Open(DST_CT_CallBack);
	JST_Scan(RF);
}
	
#if 0
____AV_STATE___()
#endif
static DS_U8  g_AV_RF = 0;
static DS_U16 g_AV_program_number = 0;
static DS_U16 g_AV_source_id = 0;

// 콜백으로 올라온 AV의 진행 상황
void DST_GetAVState(DS_U8 *RF, DS_U16 *program_number, DS_U16 *source_id)
{
	if (RF) *RF = g_AV_RF;
	if (program_number) *program_number = g_AV_program_number;
	if (source_id) *source_id = g_AV_source_id;
}

static DS_U32 g_AV_PCR = 0;
static DS_U32 g_AV_VideoType = 0;
static DS_U32  g_AV_AudioType = 0;
static DS_U32 g_AV_VideoPID = 0;
static DS_U32  g_AV_AudioPID = 0;

void DST_SetAVInfo(DS_U32 PCR, DS_U32 vPid, DS_U32 aPid, DS_U32 vType, DS_U32 aType)
{
	g_AV_PCR = PCR;
	g_AV_VideoPID = vPid;
	g_AV_AudioPID = aPid;
	g_AV_VideoType = vType;
	g_AV_AudioType = aType;

}

// 콜백으로 올라온 AV의 진행 상황
void DST_GetAVInfo(DS_U32 *PCR, DS_U32 *vPid, DS_U32 *aPid, DS_U32 *vType, DS_U32 *aType)
{
	if (PCR) *PCR = g_AV_PCR;
	if (vType) *vPid = g_AV_VideoPID;
	if (aType) *aPid = g_AV_AudioPID;
	if (vType) *vType = g_AV_VideoType;
	if (aType) *aType = g_AV_AudioType;
}


static DS_U16 DST_g_VideoWidthTV = 0;
static DS_U16 DST_g_VideoHeightTV = 0;
static DS_U16 DST_g_RefreshRate = 0;
static bool DST_g_bInterlace = false;
static bool DST_g_Wide = false;
// 비디오 크기를 반환한다.
// 리턴값은 interlace 유무다.
void DST_GetVideoSize(DS_U16* width, DS_U16* height, DS_U16* fps, bool* bInterlace, bool* bWide)
{
#if 1
	*width = DST_g_VideoWidthTV;
	*height = DST_g_VideoHeightTV;
	*fps = DST_g_RefreshRate;
	*bInterlace = DST_g_bInterlace;
	*bWide = DST_g_Wide;
#else
//	//테스트용:: 비디오 소스가 4:3일때 
//	*width = 720;
//	*height = 480;
//	*fps = DST_g_RefreshRate;
//	*bInterlace = DST_g_bInterlace;	
//	*bWide = false; 
	//테스트용:: 비디오 소스가 16:9일때 
	*width = 1920;
	*height = 1080;
	*fps = DST_g_RefreshRate;
	*bInterlace = DST_g_bInterlace;	
	*bWide = true;

#endif
}

void DST_ResetVideoSize()
{
	DST_g_VideoWidthTV = 0;
	DST_g_VideoHeightTV = 0;
	DST_g_RefreshRate = 0;
	DST_g_bInterlace = false;
	DST_g_Wide = false;
}

#if 0
____TIME___()
#endif

#if 0
____STT Set___()
#endif
static DS_U32 g_systemTime = 0;
static DS_U8 g_gpsUtcOffset = 0;
static DS_U32 g_refreshSystemTime = 0;  // system time 갱신 시간

void DST_SetTimeBySTT(DS_U32 RF, DS_U32 a_systemTime, DS_U8 a_offset, DS_U32 a_time)
{
//	DST_Printf("RF = %d a_systemTime = %d a_offset = %d a_time=%d\n", RF, a_systemTime, a_offset, a_time);
	g_systemTime = a_systemTime;
	g_gpsUtcOffset = a_offset;
	DST_g_TimeOffset[RF]=g_gpsUtcOffset;
	g_refreshSystemTime = a_time;
}

DS_U32 DST_GetCurrentUTCTime()
{
	DS_U32 systemTime = 0;
	if(g_systemTime)
	{
		if (g_refreshSystemTime > DST_OS_GetTickCount()) g_refreshSystemTime = DST_OS_GetTickCount();
		systemTime = g_systemTime + (DST_OS_GetTickCount() - g_refreshSystemTime) /  DST_OS_GetTicksPerSecond();
	}
	return systemTime;
}

DS_U32 DST_GetCurrentLocalTime()
{
	if(g_systemTime == 0) return 0;

	return DST_GetCurrentUTCTime() + g_gpsUtcOffset + 9 * 3600;
}

DS_U32 DST_UTCTimeToLocalTime(DS_U32 a_systemTime)
{
	if(a_systemTime == 0) return 0;

	DS_U32 localTime = a_systemTime + g_gpsUtcOffset + 9 * 3600;
	DST_Printf("system time -> local time : %ld -> %ld\n", a_systemTime, localTime);
	
	return localTime;
}

DS_U16* DST_GetTimeString(DS_U32 a_time, TIME_MODE a_mode, bool bApplyTimeZone, int a_offset)
{
	DS_U32 year, month, date, day;
	DS_U32 hour, min, sec;
	DS_U32 utc = a_time;
	DS_U32 daytab[2][13] = {
		{365, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
		{366, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
	};
	int acc_day;
	int i, leap;

	utc += a_offset;
	/* timezone 설정에 따른 보정을 한다. */
	if(bApplyTimeZone)
		utc += (9 * 3600);
	
	/* 1980/1/1 부터 UTC의 기준인 1980/1/6 까지의 시간을 더한 다음
	    1980년 부터 계산해 나가면 편하다.
	*/
	utc += 432000;	 /* 5일간의 초	*/
	acc_day = -5;
	year = 1980;
	month = 1;
	date = 1;
	day = 2; /* Tuesday: 1980년 1월 1일은 화요일 */
	hour = 0;
	min = 0;
	sec = 0;
	leap = 1;	/* 1980년은 4의 배수이므로 윤년.. */

	/* year를 계산 */
	while (utc >= (daytab[leap][0]*86400))
	{
		utc -= daytab[leap][0]*86400;
		acc_day += daytab[leap][0];
		year ++;
		leap = ((year%4==0)&&(year%100!=0))||(year%400==0);
	}

	/* month를 계산 */
	i=1;
	while (utc >= (daytab[leap][i]*86400))
	{
		utc -= daytab[leap][i]*86400;
		acc_day += daytab[leap][i];
		month ++;
		i++;
	}

	date += (utc/86400);
	acc_day += (utc/86400);
	utc = utc%86400;
	
	day = (acc_day + 7) % 7;
	
	hour = (utc/3600);
	utc = utc%3600;
	
	min = (utc/60);		
	sec = utc%60;

	static DS_U16 timeStr[100];
	memset(timeStr, 0, 100);
	char tmpStr[20] = {0, };
	switch(a_mode)
	{
		case DATE_NO_YEAR_TIME_NO_SEC_DETAIL:
		{
			sprintf(tmpStr, "%d", (int)month);
			str2uni(timeStr, tmpStr);
			strcat16(timeStr, pz_Month[OSD_Lang]);
			memset(tmpStr, 0, strlen(tmpStr));
			sprintf(tmpStr, " %d", (int)date);
			str2uni(&timeStr[strlen16(timeStr)], tmpStr);
			strcat16(timeStr, pz_Day[OSD_Lang]);		
			strcat16_8(timeStr, (char*)"(");
			DS_U16* dayStr = DST_GetDayOfWeakString(day);
			strcat16(timeStr, dayStr);
			strcat16_8(timeStr, (char*)") ");
			strcat16(timeStr,  (hour>12)?pz_PM[OSD_Lang]:pz_AM[OSD_Lang]);
			sprintf(tmpStr, " %02d:%02d", (hour>12)?(int)hour-12:(int)hour, (int)min);
			strcat16_8(timeStr, tmpStr);
			break;
		}	
		case DATE_NO_YEAR_TIME_NO_SEC:
		{
			sprintf(tmpStr, "%d/%d(", (int)month, (int)date);
			str2uni(timeStr, tmpStr);
			DS_U16* dayStr = DST_GetDayOfWeakString(day);
			strcat16(timeStr, dayStr);
			strcat16_8(timeStr, (char*)") ");
			strcat16(timeStr,  (hour>12)?pz_PM[OSD_Lang]:pz_AM[OSD_Lang]);
			sprintf(tmpStr, " %02d:%02d", (hour>12)?(int)hour-12:(int)hour, (int)min);

			strcat16_8(timeStr, tmpStr);
			break;
		}
		case DATE_TIME_NO_SEC:
		{
			sprintf(tmpStr, "%d.%d.%d(", (int)year, (int)month, (int)date);
			str2uni(timeStr, tmpStr);
			DS_U16* dayStr = DST_GetDayOfWeakString(day);
			strcat16(timeStr, dayStr);
			strcat16_8(timeStr, (char*)") ");
			strcat16(timeStr,  (hour>12)?pz_PM[OSD_Lang]:pz_AM[OSD_Lang]);
			sprintf(tmpStr, " %02d:%02d", (hour>12)?(int)hour-12:(int)hour, (int)min);

			strcat16_8(timeStr, tmpStr);
			break;
		}
		case DATE_TIME:
		{
			sprintf(tmpStr, "%d.%d.%d(", (int)year, (int)month, (int)date);
			str2uni(timeStr, tmpStr);
			DS_U16* dayStr = DST_GetDayOfWeakString(day);
			strcat16(timeStr, dayStr);
			strcat16_8(timeStr, (char*)") ");
			sprintf(tmpStr, "%02d:%02d:%02d", (int)hour, (int)min, (int)sec);
			strcat16_8(timeStr, tmpStr);
			break;
		}
		case DATE_ONLY:
		{
			sprintf(tmpStr, "%d.%d.%d(", (int)year, (int)month, (int)date);
			str2uni(timeStr, tmpStr);
			DS_U16* dayStr = DST_GetDayOfWeakString(day);
			strcat16(timeStr, dayStr);
			sprintf(tmpStr, ")");
			strcat16_8(timeStr, tmpStr);
			break;
		}
		case TIME_NO_SEC:
		{
			strcat16(timeStr,  (hour>12)?pz_PM[OSD_Lang]:pz_AM[OSD_Lang]);
			sprintf(tmpStr, "%02d:%02d", (hour>12)?(int)hour-12:(int)hour, (int)min);

			str2uni(&timeStr[strlen16(timeStr)], tmpStr);
			break;
		}
		case TIME_NO_SEC_NO_AMPM:
		{
			sprintf(tmpStr, "%02d:%02d", (hour>12)?(int)hour-12:(int)hour, (int)min);
			str2uni(timeStr, tmpStr);
			break;
		}
		case TIME_ONLY:
		{
			sprintf(tmpStr, "%02d:%02d:%02d", (int)hour, (int)min, (int)sec);
			str2uni(timeStr, tmpStr);
			break;
		}
		case AMPM:
		{			
			strcat16(timeStr,  (hour>12)?pz_PM[OSD_Lang]:pz_AM[OSD_Lang]);
			break;
		}
	}

	return timeStr;
}

// 아래 브라질행 시간 관련 함수 삭제 예정
typedef struct 
{
	DS_U16 date;
	DS_U32 time;
	int offset;
	DS_U32 tick;
} DATETIME;

static DATETIME g_time[256];

// MJD시간 변환
//static void DST_MJD(int mjd, int *year, int *month, int *day, int *wday)
//{
//	int y = int((mjd-15078.2f)/365.25f);
//	int m = int((mjd-14956.1f - int(y*365.25f)) / 30.6001f);
//	int k = (m==14 || m==15) ? 1 : 0;
//	*day = mjd-14956-int(y*365.25f)-int(m*30.6001f);
//	*year = 1900 + y + k;
//	*month = m - 1 - k * 12;
//	*wday = ((mjd+3) % 7); // 일요일이 0 월요일이 1
//}

int DST_GetTimeOffset()
{
	DS_U8 RF = 0;
	DST_GetAVState(&RF, 0, 0);
	DATETIME time = g_time[0];
	if (g_time[RF].tick) time = g_time[RF];
	return time.offset;
}

// 현재 시간을 가져온다.
//bool DST_GetTime(STime_t *t)
//{
//	DS_U8 RF = 0;
//	DST_GetAVState(&RF);
//	DATETIME time = g_time[0];
//	if (g_time[RF].tick) time = g_time[RF];
//	if (time.date == 0 || time.tick == 0) return false;
//	int sec = time.time + ((DST_OS_GetTickCount() - time.tick) / DST_OS_GetTicksPerSecond()) + time.offset * (60*60);
//	int day = time.date;
//	if (sec >= (24*60*60)) // 틱 카운트로 보정한 값이 밤 12시를 넘어가면 보정한다.
//	{
//		 sec = sec - (24*60*60);
//		 day = day + 1;
//	}
//	if (sec < 0) // OFFSET을 적용하면 음수가 될 수 있다
//	{
//		 sec = sec + (24*60*60);
//		 day = day - 1;
//	}
//	DST_MJD(day, &t->year, &t->month, &t->day, &t->wday);
//	t->hour = sec / 3600;
//	t->min  = (sec % 3600) / 60;
//	t->sec  = sec % 60;
//	return true;
//}

#if 0
____NEW_EPG_DB___()
#endif

#if EPG_SUPPORT

static void q_sort(DS_U32 numbers[], DS_U32 left, DS_U32 right)
{
	static int count = 0;
	DS_U32 pivot, l_hold, r_hold;
	count++;
	if(count > 1000) DST_Printf("\n\n\n\n\n\n ERROR : sort count exceed 1000 count %d \n\n\n\n\n\n",count);
	
	l_hold = left;
	r_hold = right;
	pivot = numbers[left];
	while (left < right)
	{
		while ((numbers[right] >= pivot) && (left < right))
		  right--;
		if (left != right)
		{
		  numbers[left] = numbers[right];
		  left++;
		}
		while ((numbers[left] <= pivot) && (left < right))
		  left++;
		if (left != right)
		{
		  numbers[right] = numbers[left];
		  right--;
		}
	}
	numbers[left] = pivot;
	pivot = left;
	left = l_hold;
	right = r_hold;
	if (left < pivot)
	q_sort(numbers, left, pivot-1);
	if (right > pivot)
	q_sort(numbers, pivot+1, right);

	count--;
}

EPG_DB* DST_EPG_DB_Get(int *nCount, int limit)
{
//	*nCount = 0;
//	return 0;
#if 1
	//DST_Printf("DST_EPG_DB_Get\n");
	// 현재 방송중인 정보를 가져온다
	int count = 0;
	DS_U8  RF = 0;
	DS_U16 sID = 0;
	DST_GetAVState(&RF, 0, &sID);
	EPG_DB *tmp_epg_db =0;
	EPG_DB *epg_db =0;
	if (sID == 0) 
	{
		*nCount = count;
		return 0;	
	}

	DS_U32 curTime = DST_GetCurrentUTCTime();
	int max_start_time = -1;
	int tmp_count = 0;
	int i = 0;
	DS_U32 eventTime = 0;
	bool bFound = false;
//	T();
	DS_U32 tmp_startTime = 0;
	DS_U32 tmp_endTime = tmp_startTime + 0;

	DS_U32 *_startTime_list = (DS_U32*)DST_OS_Calloc(DB_EIT_SUB_MAX, sizeof(DS_U32));
	
	for (i = 0; i < DB_EIT_SUB_MAX; i++)
	{
		if(db_eit_sub[i].rf != RF) continue;
		if(db_eit_sub[i].source_id != sID) continue;
		if(db_eit_sub[i].start_time <= curTime)
		{
			_startTime_list[tmp_count] = db_eit_sub[i].start_time;
			tmp_count ++;
		}
		
	}
	if(tmp_count < 1)
	{
		*nCount = count;
		return 0;
	}	

	q_sort(_startTime_list, 0 ,tmp_count-1);

	for (i = 0; i < DB_EIT_SUB_MAX; i++)
	{
		if(db_eit_sub[i].start_time == _startTime_list[tmp_count-1])
		{
			eventTime = db_eit_sub[i].start_time;
			tmp_startTime = db_eit_sub[i].start_time;
			tmp_endTime = tmp_startTime + db_eit_sub[i].length_in_seconds;
			if(tmp_startTime <= curTime && curTime < tmp_endTime)
			{
				bFound = true;
				break;
			}			
		}
	}

	DST_OS_Free(&_startTime_list);
	
	int nRealCount = 0;
	int pos_list[DB_EIT_SUB_MAX];
	memset(pos_list, 0 , sizeof(pos_list));
	if(bFound)
	{
		for (i = 0; i < DB_EIT_SUB_MAX; i++)
		{
			if(db_eit_sub[i].rf != RF) continue;
			if(db_eit_sub[i].source_id != sID) continue;
			if(db_eit_sub[i].start_time >= eventTime)
			{
				pos_list[nRealCount] = i; 
				nRealCount ++;
			}
			
		}
		
		if(nRealCount < 1)
		{
			*nCount = count;
			return 0;
		}
		tmp_epg_db = (EPG_DB*)DST_OS_Calloc(nRealCount, sizeof(EPG_DB));
		int j=0;
		
		DS_U32 *tmp_startTime_list = (DS_U32*)DST_OS_Calloc(nRealCount, sizeof(DS_U32));
		int x = 0;
		bool bSkip = false;
		count = 0;
		for( i=0 ; i<nRealCount ; i++)
		{
			 bSkip = false;
			for(x = 0; x < nRealCount; x++)
			{
				if(tmp_epg_db[x].event_id == db_eit_sub[pos_list[i]].event_id && tmp_epg_db[x].source_id== db_eit_sub[pos_list[i]].source_id && tmp_epg_db[x].start_time== db_eit_sub[pos_list[i]].start_time) 
				{
					bSkip = true;
					break;
				}
			}
			if(!bSkip)
			{
				tmp_epg_db[count].source_id = db_eit_sub[pos_list[i]].source_id;
				tmp_epg_db[count].event_id =  db_eit_sub[pos_list[i]].event_id;
				strcpy((char*)tmp_epg_db[count].title,	db_eit_sub[pos_list[i]].title); 
				tmp_epg_db[count].start_time=  db_eit_sub[pos_list[i]].start_time;
				tmp_epg_db[count].duration=  db_eit_sub[pos_list[i]].length_in_seconds;
				for( j = 0; j< DB_ETT_MAX; j++)
				{
					if(db_ett[j].crc == 0) continue;
					if(db_ett[j].rf != RF) continue;
					if(db_ett[j].source_id != tmp_epg_db[count].source_id) continue;
					if(db_ett[j].event_id != tmp_epg_db[count].event_id) continue;
					tmp_epg_db[count].text = (char*)DST_OS_Calloc(strlen(db_ett[j].title)+1, 1);
					strcpy(tmp_epg_db[count].text, db_ett[j].title);
					break;
				}
				if(tmp_epg_db[count].text == 0)
				{
					tmp_epg_db[count].text = (char*)DST_OS_Calloc(1, 1);
				}
				tmp_startTime_list[count] = tmp_epg_db[count].start_time;
				count++;
			}
		}
//		DST_Printf("nRealCount=%d,count=%d\n",nRealCount,count);
//		for(i = 0; i < count; i++)
//		{
//			DST_Printf("source_id=%d , event_id=%d , title=%s , text=%s\n",tmp_epg_db[i].source_id,tmp_epg_db[i].event_id,tmp_epg_db[i].title,tmp_epg_db[i].text);
//		}

		DS_U32 *startTime_list = (DS_U32*)DST_OS_Calloc(count, sizeof(DS_U32));
		memcpy(startTime_list, tmp_startTime_list, count*sizeof(DS_U32));	

		epg_db = (EPG_DB*)DST_OS_Calloc(count, sizeof(EPG_DB));
		if(count > 0) q_sort(startTime_list, 0, count-1);

		i=0;
		for(i=0;i<count;i++)
		{
			j=0;
			for(j=0;j<count;j++)
			{			
				if(tmp_epg_db[j].start_time == startTime_list[i])
				{
					epg_db[i].source_id = tmp_epg_db[j].source_id;
					epg_db[i].event_id = tmp_epg_db[j].event_id;
					strcpy(epg_db[i].title, tmp_epg_db[j].title);
					epg_db[i].start_time = tmp_epg_db[j].start_time;
					epg_db[i].duration = tmp_epg_db[j].duration;
					epg_db[i].text = (char*)DST_OS_Calloc(strlen(tmp_epg_db[j].text)+1, 1);
					strcpy(epg_db[i].text, tmp_epg_db[j].text);
					break;
				}
			}

		}
//		for(i = 0; i < count; i++)
//		{
//			DST_Printf("source_id=%d , event_id=%d , title=%s , text=%s\n",epg_db[i].source_id,epg_db[i].event_id,epg_db[i].title,epg_db[i].text);
//		}		
		DST_EPG_DB_Free(tmp_epg_db, nRealCount);
		DST_OS_Free(&tmp_startTime_list);
		DST_OS_Free(&startTime_list);
		nRealCount = count;


	}
	*nCount = nRealCount;
	return epg_db;
#endif
}
// EPG 디비 메모리를 해제한다.
void DST_EPG_DB_Free(EPG_DB* db, int nCount)
{
	int i;
	for ( i = 0; i < nCount; i++)
	{
		if (db[i].text) DST_OS_Free(&db[i].text);	
	}
	DST_OS_Free(&db);
}

#endif

#if 0
____SIGNAL MONITOR___()
#endif


static DHL_AUDIO_MODE g_AudioMode = DHL_AUDIO_UNKNOWN;
DHL_AUDIO_MODE DST_AUD_GetMode()
{
	return g_AudioMode;
}

int DST_GetSignalStrength()
{
	DS_U8 RF = 0;
	DST_GetAVState(&RF, 0, 0);
	return DST_g_SignalStrength;
}


static bool g_Lock  = true;
static bool g_Video = true;
static bool g_Audio = true;

bool  DST_IsAVBlock()
{
	return (g_Lock == false || g_Video == false);
}

bool DST_IsWeakSignal()
{
	return (g_Lock == false);
}

bool DST_IsAudioOnly()
{
	return (g_Lock == true && g_Video == false && g_Audio == true);
}

bool DST_IsNoProgram()
{
	return (g_Lock == true && g_Video == false && g_Audio == false);
}

static int TUNE_SCAN_STATE = CT_STOPPED;
bool DST_IsTuneMode()
{
	return (TUNE_SCAN_STATE == CT_TUNE_START);
}


typedef struct 
{
	DS_U16 date; // day
	DS_U32 time; // sec
} DATETIME2;
bool DST_IsBetweenTime(DATETIME2 compare_time, DATETIME2 conrol_start_time, DATETIME2 conrol_end_time)
{	
	if(compare_time.date == 0 || conrol_start_time.date == 0 || conrol_end_time.date == 0) return false;
	if(conrol_start_time.time <= compare_time.time && compare_time.time < conrol_end_time.time)
	{
		return true;
	}
	else
	{
		if(conrol_start_time.date<= compare_time.date && compare_time.date < conrol_end_time.date) return true;
		else return false;
	}
	
}


#if 0
____RF_UPDATE___()
#endif


static char* g_RFUpdate_data = 0;
static int g_RFUpdate_data_length = 0;

//static int DST_CheckCRC(DS_U32 crc_value, char * data, int size)
//{
//	DS_U32 ulCrc = DST_crc32((DS_U8 *)data, size);
//
//	if (ulCrc != crc_value) 
//	{
//		DST_Printf("Total image crc error!!!\n");
//		DST_Printf("\nFilelength:0x%08x \n", size);
//		DST_Printf("Computed crc32:0x%08x, correct crc32:0x%08x\n",(int)ulCrc, (int)crc_value);
//		return CRC_READ_TOTAL_FAIL;
//	}
//
//	DST_Printf("Total image crc ok...\n");
//	return UPDATE_OK;	
//}

int write2Flash(int partition, int partition_size, int data_size, int offset, char * data, int category)
{
#ifdef DSTAR
		char filename[64];
		sprintf(filename, "%s", category == UPDATE_BOOTLOADER ? "bootloader.bin" : "image.bin" );
		FILE *fp = fopen(filename,"wb+");
#endif

	int ret = 0;
	int old_pos = -1;

	SWinEventMsg event;
	event.cmd = WM_RF_UPDATE;
	int i;
	for ( i = 0; i < data_size; i+=4096)
	{
		int pos = i * 100 / data_size;
		int length = (i+4096 > data_size) ? data_size-i : 4096;
#ifdef DSTAR
		fwrite(&g_RFUpdate_data[i+offset], 1, length, fp);
#endif
		if (i < partition_size)
		{
			/*ret = */DHL_Flash_Write(partition+i, length, (DS_U8*)&data[offset+i]);
		}

		if (ret != 0) return ret;
			
		if (pos != old_pos)
		{
			old_pos = pos;
			event.data32[0] = FLASH_WRITING;
			event.data32[1] = pos;
			event.data32[2] = category;
			static DS_U32 tick = 0;
			// 0.5초마다 그리도록
			if (tick > DST_OS_GetTickCount()) tick = DST_OS_GetTickCount();
			if((DST_OS_GetTickCount() - tick >= DST_OS_GetTicksPerSecond()/2) || (pos >= 100)) 
			{
				tick = DST_OS_GetTickCount();
				DST_SendWindowEvent(event);
			}
			DST_OS_Delay(10);
		}
	}
#ifdef DSTAR
	fclose(fp);
#endif	
	return ret;

}

void sendFinishMessage(int status1, int status2, int category)
{
	SWinEventMsg event;
	event.cmd = WM_RF_UPDATE;
	event.data32[0] = status1;
	event.data32[1] = status2;
	event.data32[2] = category;
	DST_SendWindowEvent(event);
	
	g_RFUpdate_data_length = 0;
	DST_CT_CallBack(CT_FLASH_WRITE_COMPLETE,0,0,0,0,0,0);	
}

static void tFlashWrite()
{
	int err_ret = 0;
	int buf_offset = 0;
	DS_U8 nBank = DHL_INFO_GetBankNumber();
	
	// 4KB씩 쓴다.
	
	//헤더 복사
	BootHeader bootHeader;
//	ApplicationHeader applicationHeader;
	memset(&bootHeader, 0 , sizeof(BootHeader));
	memcpy(&bootHeader, &g_RFUpdate_data[FLASH_BOOT_SIZE], sizeof(BootHeader));
	DST_Printf("\n");
	DST_Printf("bootHeader.boot_order : %ld (0x%16X)\n",bootHeader.boot_order,bootHeader.boot_order);
	DST_Printf("bootHeader.chip_id    : %ld (0x%16X)\n",bootHeader.chip_id,bootHeader.chip_id);
	DST_Printf("bootHeader.dummy[1]   : %ld (0x%16X)\n",bootHeader.dummy[0],bootHeader.dummy[0]);
	DST_Printf("bootHeader.dummy[1]   : %ld (0x%16X)\n",bootHeader.dummy[1],bootHeader.dummy[1]);

	//Bootloader Flash Writing
	err_ret = write2Flash(FLASH_BOOT_POS, FLASH_BOOT_SIZE, FLASH_BOOT_SIZE, buf_offset, g_RFUpdate_data, UPDATE_BOOTLOADER);
	if(err_ret != 0)
	{
		sendFinishMessage(FLASH_WRITING_FAIL, WRITE_FLASH_FAIL, UPDATE_BOOTLOADER);
		DST_OS_SelfDeleteTask();
		return;		
	}
	buf_offset = FLASH_BOOT_SIZE;
	//Application Flash Writing
	DS_U32 nFlashBaseAddress = nBank ? FLASH_BANK0_POS : FLASH_BANK1_POS;
	err_ret = write2Flash(nFlashBaseAddress, FLASH_BANK_SIZE, g_RFUpdate_data_length - FLASH_BOOT_SIZE, buf_offset, g_RFUpdate_data, nBank ? UPDATE_APPLICATION0 : UPDATE_APPLICATION1);
	if(err_ret != 0)
	{
		sendFinishMessage(FLASH_WRITING_FAIL, WRITE_FLASH_FAIL, nBank ? UPDATE_APPLICATION0 : UPDATE_APPLICATION1);
		DST_OS_SelfDeleteTask();
		return;
	}	

	DHL_INFO_SetBankNumber(nBank ? 0 : 1);
	
	nBank = DHL_INFO_GetBankNumber();

	nFlashBaseAddress = nBank ? FLASH_BANK0_POS : FLASH_BANK1_POS;
	err_ret = write2Flash(nFlashBaseAddress, FLASH_BANK_SIZE, g_RFUpdate_data_length - FLASH_BOOT_SIZE, buf_offset, g_RFUpdate_data, nBank ? UPDATE_APPLICATION0 : UPDATE_APPLICATION1);
	if(err_ret != 0)
	{
		sendFinishMessage(FLASH_WRITING_FAIL, WRITE_FLASH_FAIL, nBank ? UPDATE_APPLICATION0 : UPDATE_APPLICATION1);
		DST_OS_SelfDeleteTask();
		return;
	}	

	DHL_INFO_SetBankNumber(nBank ? 0 : 1);


	DST_OS_Delay(10);
	sendFinishMessage(FLASH_WRITING_COMPLETE,UPDATE_FINISHED,UPDATE_OK);
	DST_OS_SelfDeleteTask();
}

static void DST_RFUpdateWrite(char* p, int length)
{
	if (g_RFUpdate_data) return;
	g_RFUpdate_data = p;
	g_RFUpdate_data_length = length;
	/*int taskID = */DST_OS_SpawnTask((void (*)(void *)) tFlashWrite, (char*)"tFlashWrite", APP_TASK_PRIO_RF_UPDATE_WRITE, WIN_MGR_TASK_STACKSIZE, 0);
}

static int DST_g_PowerLevel = 0;
static int DST_g_SNR = 0;
static bool DST_g_vAlive = false;
static bool DST_g_aAlive = false;

void DST_GetAVAliveInfo(bool *vAlive, bool *aAlive)
{
	if(vAlive) *vAlive = DST_g_vAlive;
	if(aAlive) *aAlive = DST_g_aAlive;
}

void DST_GetSignalInfo(bool *bLock, int *ss, int *powerlevel, int *snr)
{
	DS_U8 RF = 0;
	DST_GetAVState(&RF, 0, 0);
	if (bLock) *bLock = DST_g_Lock;
	if (ss) *ss = DST_g_SignalStrength;
	if (powerlevel) *powerlevel = DST_g_PowerLevel;
	if (snr) *snr = DST_g_SNR;
}

// class CMEMFILE을 C로 변환 
static int m_nTotalSize = 0; // 메모리 파일의 전체 길이
static int m_nBlockSize = 0; // 블럭당 사이즈
static char* m_data = 0; // 저장되는 데이터
static int m_nMaxBlockNumber = 0; // 가장큰 블럭 번호. 블럭번호는 0에서 시작한다.
static int* m_BlockList =  0; // 이미 받은 데이터는 버리기위해 이전에 받은 블럭 번호를 저장한다.
static int m_nReceiveCount = 0; // 받은 유효한 데이터 갯수

static void CMemFile_New(int nTotalSize, int nBlockSize)
{
	m_nTotalSize = nTotalSize;
	m_nBlockSize = nBlockSize;
	DST_OS_Free(&m_data);
	m_data = (char*)DST_OS_Malloc(nTotalSize);
	m_nMaxBlockNumber = (nTotalSize-1) / nBlockSize;
	DST_OS_Free(&m_BlockList);
	m_BlockList = (int*)DST_OS_Malloc((m_nMaxBlockNumber+1)* sizeof(int));
	m_nReceiveCount = 0;
}

static void CMemFile_SetBlock(int nBlockNumber, char* data, int nDataLength)
{
	int i;
	for ( i = 0; i < m_nReceiveCount; i++) if (m_BlockList[i] == nBlockNumber) return; // 이미 받은 데이터면 무시
	if (nBlockNumber > m_nMaxBlockNumber) return; // 잘못된 블럭번호는 버린다.
	//printf("m_nBlockSize = %d nBlockNumber = %d\n", m_nBlockSize , nBlockNumber);
	memcpy(m_data + m_nBlockSize * nBlockNumber, data, nDataLength);
	m_BlockList[m_nReceiveCount++] = nBlockNumber; // 블럭 번호를 저장하여 다시 받는것을 방지
}

static void CMemFile_GetProgress(int *RecieveCount, int *TotalCount)
{
	*RecieveCount = m_nReceiveCount; 
	*TotalCount = m_nMaxBlockNumber+1;
}

static char* CMemFile_GetData()
{
	return m_data;
}

static int CMemFile_GetLength()
{
	return m_nTotalSize;
}

static void CMemFile_Delete()
{
	DST_OS_Free(&m_data);
	DST_OS_Free(&m_BlockList);
}
	
static void DST_CT_CallBack(DS_U8 Cmd, DS_U32 p1, DS_U32 p2, DS_U32 p3, DS_U32 p4, DS_U32 p5, DS_U32 p6)
{
	if (Cmd == CT_RECEIVE_STT)
	{
		//DST_SendWindowEventWithOnlyCmd(WM_RECEIVE_STT);
		DST_SetTimeBySTT(p1, p2, p3, p4);
	}
	
	switch (Cmd)
	{
		case CT_SIGNAL:
		case CT_SIGNAL_INFO:
		case CT_AV_START:
		case CT_OTC_RECEIVE_DDB:
		case CT_RECEIVE_RF_UPDATE:
		case CT_VIDEO_RESOLUTION:
		case CT_AV_INFO:
		case CT_AUDIO_MODE:
			break;
			
		default:
			{
				SWinEventMsg event;
				event.cmd = WM_CT_MSG;
				event.data32[0] = Cmd;
				event.data32[1] = p1;
				event.data32[2] = p2;
				event.data32[3] = p3;
				event.data32[4] = p4;	
				event.data32[5] = p5;		
				event.data32[6] = p6;
				DST_SendWindowEvent(event);
			}
			break;
	}
//	if (Cmd != CT_SIGNAL_INFO  && Cmd != CT_AV_START)
//	{
////		DST_Printf(">>Cmd = %s(%d) %x %x %x %x\n", CT_GetMsgName(Cmd), Cmd, (int)p1, (int)p2, (int)p3, (int)p4);
//	}
	static DS_U32 DST_g_WeakSignalStartTime = 0;
	SWinEventMsg event;
	memset(&event, 0, sizeof(SWinEventMsg));

	switch (Cmd)
	{
		case CT_RECEIVE_TVCT:
			if (p2 == 0) break;
			{
				// VCT에서 튜닝하려던 채널이 사라진 경우
				//	동일 RF의 첫번째 채널로 튜닝
				DBLock(true);
				DS_U16 program_number = 0;
				int i;
				for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
				{
					if (db_channel_db[i].rf != p1) continue;
					program_number = db_channel_db[i].program_number;
					break;
				}
				DBLock(false);
				if (program_number > 0) DST_UI_ChannelTune(p1, program_number);
			}			
			break;
			
		case CT_AV_INFO:
			//(CT_AV_INFO, RF, PcrPid, VideoPid, AudioPid, VideoType, AudioType)
			if(g_AV_PCR != p2 || g_AV_VideoPID != p3 || g_AV_AudioPID != p4 || g_AV_VideoType != p5 || g_AV_AudioType != p6)
			{
				DST_SetAVInfo(p2, p3, p4, p5, p6);
				DST_SendWindowEventWithOnlyCmd(WM_SOURCE_FORMAT_DONE);			
			}
			break;

		case CT_SIGNAL_INFO:
			//(CT_SIGNAL_INFO, RF, bLock, ss, ber_a, ber_b)
			DST_g_Lock = p2;
			DST_g_SignalStrength = p3;
			DST_g_PowerLevel = p4;
			DST_g_SNR = p5;
			{
				bool bWeakSignal = false;
				if (DST_g_Lock == false) bWeakSignal = true;
//				if (DST_g_Demod != (DHL_MODULATION_MODE)DHL_MODULATION_8VSB && DST_g_SNR <= 25) bWeakSignal = true;
//				if (DST_g_Demod == (DHL_MODULATION_MODE)DHL_MODULATION_8VSB && DST_g_SNR <= 14) bWeakSignal = true;
				static int old_rf = 0;
				if (old_rf != (int)p1) // 주파수가 변경된 경우는 Weak Signal 아닌 걸로 간주
				{
					bWeakSignal = false;
					old_rf = p1;
				}
				if (bWeakSignal == true)
				{
					if (DST_g_WeakSignalStartTime == 0) DST_g_WeakSignalStartTime = DST_OS_GetTickCount();
				}	
				else
				{
					DST_g_WeakSignalStartTime = 0;
				}
				if (DST_g_WeakSignalStartTime > DST_OS_GetTickCount()) DST_g_WeakSignalStartTime = DST_OS_GetTickCount();
				
				if (DST_g_WeakSignalMuteOff == false)
				{
					CT_WeakSignalMute(bWeakSignal && (DST_OS_GetTickCount() - DST_g_WeakSignalStartTime) > 10*DST_OS_GetTicksPerSecond()); // 10초이상 Weak Signal
				}
			}

			break;

		case  CT_SIGNAL:
			{
				//(CT_SIGNAL, RF, sourceID, VideoPid ? DHL_VID_Alive() : 0, AudioPid ? DHL_AUD_Alive() : 0)
				static DS_U32 nLastSendCommand = 0;
				static DS_U32 nLastSendTime = 0;
				static DS_U32 LastSourceID = 0;
				static DS_U32 LastRF = 0;
				static DS_U32 old_nCmd = SM_GOOD_SIGNAL;
				DS_U32 nCmd = SM_GOOD_SIGNAL;
				if (DST_g_LastTuneTryTime > DST_OS_GetTickCount()) DST_g_LastTuneTryTime = DST_OS_GetTickCount();
				if ((nCmd == SM_GOOD_SIGNAL)&& DST_OS_GetTickCount() - DST_g_LastTuneTryTime < WAITING_PERIOD && DST_g_VideoHeightTV == 0)
				{
					nCmd = SM_WAIT_SIGNAL;
				}				
				if (DST_g_WeakSignalStartTime > DST_OS_GetTickCount()) DST_g_WeakSignalStartTime = DST_OS_GetTickCount();
				if (nCmd == SM_GOOD_SIGNAL && DST_g_WeakSignalStartTime > 0 && DST_OS_GetTickCount() - DST_g_WeakSignalStartTime > DST_OS_GetTicksPerSecond())
				{
					nCmd = SM_WEAK_SIGNAL;
				}
				if ((nCmd == SM_GOOD_SIGNAL )&& p3 == 0 && p4 == 0 && DST_OS_GetTickCount() - DST_g_LastTuneTryTime > WAITING_PERIOD)
				{
					nCmd = SM_NO_PROGRAM;
				}
				if ((nCmd == SM_GOOD_SIGNAL || nCmd == SM_WAIT_SIGNAL )&& p3 == 0 && p4 != 0)
				{
					nCmd = SM_AUDIO_ONLY;
				}
				if (nLastSendTime >  DST_OS_GetTickCount()) nLastSendTime = DST_OS_GetTickCount();
//				DST_Printf("LastSourceID:%d, p2:%d++++++++++++++++++++++++++++++++++++++\n",LastSourceID,p2);
				if(LastRF != p1 || LastSourceID != p2 ) 
				{
					nCmd = SM_WAIT_SIGNAL;
					LastRF = p1;
					LastSourceID = p2;
				}

				if (DST_g_BadSignalStartTime > DST_OS_GetTickCount())	DST_g_BadSignalStartTime = DST_OS_GetTickCount();
				if(nCmd == SM_WEAK_SIGNAL || nCmd == SM_NO_PROGRAM)
				{
					if(old_nCmd != nCmd)
					{
						if(!(old_nCmd == SM_WEAK_SIGNAL || old_nCmd == SM_NO_PROGRAM))
						{
							DST_g_BadSignalStartTime = DST_OS_GetTickCount();
						}
						old_nCmd = nCmd;
					}
				}
				else
				{
					DST_g_BadSignalStartTime = 0;
				}
				
				if (nCmd != nLastSendCommand || DST_OS_GetTickCount() - nLastSendTime > DST_OS_GetTicksPerSecond())
				{
					DST_g_vAlive = p3?true:false;
					DST_g_aAlive = p4?true:false;
					DST_g_SignalState = nCmd;
					event.cmd = WM_SIGNAL_STATE;
					event.data32[0] = nCmd;
					DST_SendWindowEvent(event); 	
					nLastSendCommand = nCmd;
					nLastSendTime = DST_OS_GetTickCount();
					
//					DST_g_OldSignalState = event.data32[0];
//					if (DST_g_SignalState == SM_NO_PROGRAM) DST_g_OldSignalState = SM_NO_PROGRAM;
//					DST_Printf("\n\n\nDST_g_SignalState:%d\n\n\n",DST_g_SignalState);
				}
			}		
			break;
		case CT_AUDIO_MODE:
			g_AudioMode = (DHL_AUDIO_MODE)p1;
			break;
		case CT_VIDEO_RESOLUTION:
			DST_g_VideoWidthTV = (p1 < 2000 && p1 < 2000) ? p1 : 0;
			DST_g_VideoHeightTV = (p2 < 2000 && p2 < 2000) ? p2 : 0;
			DST_g_RefreshRate = p3;
			DST_g_bInterlace = p4 ? true: false;
			switch (p5)
			{
				case DHL_SOURCE_16x9:
					DST_g_Wide = true;
					break;
				case DHL_SOURCE_4x3:
					DST_g_Wide = false;
					break;
				default:
					if (DST_g_VideoWidthTV == 0 || DST_g_VideoHeightTV == 0) break;
					DST_g_Wide = (((DST_g_VideoWidthTV * 100) / DST_g_VideoHeightTV) > 155) ? true : false;
					break;
			}
			// DST_SendWindowEventWithOnlyCmd(WM_SOURCE_FORMAT_DONE);
			DST_AspectRatio();
			break;

		case CT_SCAN_LOCK_WAIT:
			DST_g_SignalStrength = p3;
			break;
			
		case CT_AV_START:
			if(g_AV_RF != p1 || g_AV_program_number != p2)
			{
				static bool bFirst = true;
				DST_CloseWin(WIN_ERROR);
				if(DST_g_bFactoryMode == false)
				{
					if (DST_GetWin(WIN_CHANNEL_BANNER) == false)
						DST_CreateWin(WIN_CHANNEL_BANNER, WIN_NULL, BANNER_NORMAL, 3, 0, 0);
				}
				
				bFirst = false;
			}
			break;
		case CT_SCAN_START:
			TUNE_SCAN_STATE = CT_SCAN_START;
			break;
		case CT_TUNE_START:
			TUNE_SCAN_STATE = CT_TUNE_START;
			if(g_AV_RF != p1 || g_AV_program_number != p2)
			{
				DST_ResetVideoSize();
				DST_CloseWin(WIN_ERROR);
			}
			g_AV_RF = p1;
			g_AV_program_number = p2;
			g_AV_source_id = p3;
			//DST_Printf("\n\n\n");
			//DST_Printf("CT_TUNE_START %d %d %d\n", g_AV_RF, g_AV_program_number, g_AV_source_id);
			//DST_Printf("\n\n\n");
			break;
		case CT_STOPPED:
			TUNE_SCAN_STATE = CT_STOPPED;
			g_AV_RF = 0;
			g_AV_program_number = 0;
			g_AV_source_id = 0;
			break;
		case CT_CVT_START:
			g_AV_RF = 0;
			g_AV_program_number = 0;
			g_AV_source_id = 0;
			break;
			
		case CT_OTC_START:
			DST_g_bOTCMode = true;
//			DST_SendWindowProgressEvent(WM_OTC_DOWNLOADING_STARTED);
			break;
	}
	
	// OTC 관련 처리
//	static CMemFile *mf = 0;
	static bool bOTC_Receive_Complete = true;
	switch (Cmd)
	{
		case CT_OTC_RECEIVE_DII:
//			if (mf) delete mf;
//			mf = new CMemFile(p1, p2);
			CMemFile_New(p1, p2);
			bOTC_Receive_Complete = false; 
			break;
			
		case CT_OTC_RECEIVE_DDB:
			{
				if (bOTC_Receive_Complete) break;
				CMemFile_SetBlock(p1, (char*)p2, p3);
				int nReceiveCount = 0;
				int nMaxBlockNumber = 0;
				CMemFile_GetProgress(&nReceiveCount, &nMaxBlockNumber);
				SWinEventMsg event;
				memset(&event, 0, sizeof(SWinEventMsg));
				event.cmd = WM_RF_UPDATE;
				if (nReceiveCount == nMaxBlockNumber)
				{
					bOTC_Receive_Complete = true;
					event.data32[0] = DATA_RECEIVING_COMPLETE; // 수신 완료
					DST_SendWindowEvent(event);
					JST_Stop();
					DST_CreateWin(WIN_UPDATE, WIN_NULL, 0,0,0,0);
					DST_RFUpdateWrite(CMemFile_GetData(), CMemFile_GetLength());
				}
				else
				{
					static int old_pos = -1;
					int pos =  (nReceiveCount - 1) * 100 / nMaxBlockNumber;
					event.data32[0] = DATA_RECEIVING; // 수신중
					event.data32[1] = pos;
					if (old_pos != pos) 
					{
						DST_SendWindowEvent(event);
						old_pos = pos;
					}
				}
			}
			break;
		case CT_FLASH_WRITE_COMPLETE:
			CMemFile_Delete();
			T();DST_Printf("CT_FLASH_WRITE_COMPLETE\n");
			bOTC_Receive_Complete = true;
			break;

		case CT_RF_UPDATE_START:
			bOTC_Receive_Complete = false; 
			break;
			
		case CT_RECEIVE_RF_UPDATE:
			{
				if (bOTC_Receive_Complete == true) break;
				char *p = (char*)p2;
				char *strModelName = &p[3+5]; //제품모델명
				char *strVersionName = &p[13+5]; // S/W 버전
				char *strFileSize = &p[21+5]; // 전체 파일 길이
//				char *strPosition = &p[29]; // 데이터의 시작 위치
				char *strLength = &p[37+5]; // 데이터의 길이
				char *strMaxBlockNumber = &p[45+5]; // 마지막 블럭 번호
				char *strBlockNumber = &p[53+5]; // 몇번째 블럭인지 0부터 시작
				char *pSrc = &p[61+5];
				
				int nFileSize = dst_atoi(strFileSize);
//				int nPosition = dst_atoi(strPosition);
				int nLength = dst_atoi(strLength);
				int nMaxBlockNumber = dst_atoi(strMaxBlockNumber);
				int nBlockNumber = dst_atoi(strBlockNumber);
			
				// 테스트 비교 조건임 확인 후 수정 필요
				static char* pData = 0;
				static int*   pLength = 0;
				
				SWinEventMsg event;
				event.cmd = WM_RF_UPDATE;
				memcpy(&event.data32[2], strVersionName, 8);
					
				if (strcmp(strModelName, DST_GetModelName()) != 0)
				{
					T();
					DST_Printf("%s %s\n", strModelName, DST_GetModelName());
					bOTC_Receive_Complete = true;
					JST_Stop();
					if (pData) DST_OS_Free(&pData);
					if (pLength) DST_OS_Free(&pLength);
					event.data32[0] = 100; // 다른 모델임
					DST_SendWindowEvent(event);
					break;
				}
//				if (strcmp(strVersionName, DST_GetAppShortVersion()) == 0)
//				{
//					T();
//					bOTC_Receive_Complete = true;
//					JST_Stop();
//					if (pData) DST_OS_Free(&pData);
//					if (pLength) DST_OS_Free(&pLength);
//					event.data32[0] = 101; // 같은 버전임
//					DST_SendWindowEvent(event);
//					break;
//				}
				
				if (CMemFile_GetLength() == 0) // 처음 받는 경우 
				{
					bOTC_Receive_Complete = false;
					CMemFile_New(nFileSize, nLength);
				}
				CMemFile_SetBlock(nBlockNumber, pSrc, nLength);
				
				int nReceiveCount = 0;
				nMaxBlockNumber = 0;
				CMemFile_GetProgress(&nReceiveCount, &nMaxBlockNumber);
				//SWinEventMsg event;
				memset(&event, 0, sizeof(SWinEventMsg));
				event.cmd = WM_RF_UPDATE;
				if (nReceiveCount == nMaxBlockNumber)
				{
					bOTC_Receive_Complete = true;
					event.data32[0] = DATA_RECEIVING_COMPLETE; // 수신 완료
					DST_SendWindowEvent(event);
					JST_Stop();
					DST_RFUpdateWrite(CMemFile_GetData(), CMemFile_GetLength());
				}
				else
				{
					static int old_pos = -1;
					int pos =  (nReceiveCount - 1) * 100 / nMaxBlockNumber;
					event.data32[0] = DATA_RECEIVING; // 수신중
					event.data32[1] = pos;
					if (old_pos != pos) 
					{
						DST_SendWindowEvent(event);
						old_pos = pos;
					}
				}
			}
			break;
	}
}