repos_ecs/Device/HC_OCX/StoneU_HC_OCX/RemoteChannelConfig.cpp

// RemoteChannelConfig.cpp : implementation file
//

#include "stdafx.h"
#include "StoneU_HC_OCX.h"
#include "RemoteChannelConfig.h"
#include "RemoteRecordPlanConfig.h"
#include "RemoteDetectConfig.h"
#include "RemoteHideConfig.h"
#include "RemoteHideAlarm.h"
#include "VideoLost.h"
#include "ShowString.h"
#include "RemoteParamsCfg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern CRemoteParamsCfg *m_pRemoteParam;

extern	SERVER_INFO serverinfo[MAXIPNUMBER];
extern	CLIENTPARAM	ClientParam;
LPNET_DVR_MOTION lpMotionDetect;
LPNET_DVR_HIDEALARM lpHideAlarm;
LPNET_DVR_VILOST lpVILost;

WORD getFrameI(DWORD selFrameRate)
{
	WORD nRet = 0;
	switch(selFrameRate)
	{
	case 0:
		nRet = 25;
		break;
	case 6:
		nRet = 2;
		break;
	case 7:
		nRet = 4;
		break;
	case 8:
		nRet = 6;
		break;
	case 9:
		nRet = 8;
		break;
	case 10:
		nRet = 10;
		break;
	case 11:
		nRet = 12;
		break;
	case 12:
		nRet = 16;
		break;
	case 13:
		nRet = 20;
		break;
	case 14:
		nRet = 15;
		break;
	case 15:
		nRet = 18;
		break;
	case 16:
		nRet = 22;
		break;
	default:
		nRet = 1;
	}
	nRet *= 4;
	return nRet;
}
/////////////////////////////////////////////////////////////////////////////
// CRemoteChannelConfig dialog


CRemoteChannelConfig::CRemoteChannelConfig(CWnd* pParent /*=NULL*/)
	: CDialog(CRemoteChannelConfig::IDD, pParent)
{
	//{{AFX_DATA_INIT(CRemoteChannelConfig)
	m_ChannelName = _T("");
	m_bOsd = FALSE;
	m_bRecord = FALSE;
	m_bHide = FALSE;
	m_channame_x = 0;
	m_channame_y = 0;
	m_bChanname = FALSE;
	m_bDispWeek = FALSE;
	m_osd_y = 0;
	m_osd_x = 0;
	m_bMotion = FALSE;
	m_bHideAlarm = FALSE;
	m_BitRate = 0;
	m_bVILost = FALSE;
	m_FrameI = 0;
	m_bUseEvent = FALSE;
	//}}AFX_DATA_INIT
}


void CRemoteChannelConfig::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRemoteChannelConfig)
	DDX_Control(pDX, IDC_PARAMCOMBO, m_ParamCombo);
	DDX_Control(pDX, IDC_COMBOBPINTERVAL, m_BPIntervalCtrl);
	DDX_Control(pDX, IDC_PRERECORDTIME, m_PreRecordTime);
	DDX_Control(pDX, IDC_DELAY, m_DelayCtrl);
	DDX_Control(pDX, IDC_OSDTYPE, m_OsdType);
	DDX_Control(pDX, IDC_OSDATTRIB, m_OsdAttrib);
	DDX_Control(pDX, IDC_COMBOCOPYCHAN, m_CopyChannelCtrl);
	DDX_Control(pDX, IDC_COMCHAN, m_ChannelCtrl);
	DDX_Control(pDX, IDC_COMBOSTREAMTYPE, m_StreamTypeCtrl);
	DDX_Control(pDX, IDC_COMBORESOLUTION, m_ResolutionCtrl);
	DDX_Control(pDX, IDC_COMBOIMAGEQUALITY, m_ImageQualityCtrl);
	DDX_Control(pDX, IDC_COMBOBITRATETYPE, m_BitRateTypeCtrl);
	DDX_Control(pDX, IDC_COMBOFRAMERATE, m_FrameRateCtrl);
	DDX_Control(pDX, IDC_COMBOBITRATE, m_BitRateCtrl);
	DDX_Text(pDX, IDC_CHANNELNAME, m_ChannelName);
	DDX_Check(pDX, IDC_CHKOSD, m_bOsd);
	DDX_Check(pDX, IDC_CHKRECORD, m_bRecord);
	DDX_Check(pDX, IDC_CHKHIDEAREA, m_bHide);
	DDX_Text(pDX, IDC_CHANNAME_X, m_channame_x);
	DDX_Text(pDX, IDC_CHANNAME_Y, m_channame_y);
	DDX_Check(pDX, IDC_CHKCHANNAME, m_bChanname);
	DDX_Check(pDX, IDC_CHKDISPWEEK, m_bDispWeek);
	DDX_Text(pDX, IDC_OSD_Y, m_osd_y);
	DDX_Text(pDX, IDC_OSD_X, m_osd_x);
	DDX_Check(pDX, IDC_CHKMOTION, m_bMotion);
	DDX_Check(pDX, IDC_CHKHIDEALARM, m_bHideAlarm);
	DDX_Text(pDX, IDC_EDITBITRATE, m_BitRate);
	DDX_Check(pDX, IDC_CHKVILOST, m_bVILost);
	DDX_Text(pDX, IDC_EDITFRAMEI, m_FrameI);
	DDX_Check(pDX, IDC_CHECKEVENT, m_bUseEvent);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CRemoteChannelConfig, CDialog)
	//{{AFX_MSG_MAP(CRemoteChannelConfig)
	ON_BN_CLICKED(IDC_BUTCHANCOPY, OnButchancopy)
	ON_BN_CLICKED(IDC_BUTMOTION, OnButmotion)
	ON_BN_CLICKED(IDC_BUTRECORD, OnButrecord)
	ON_BN_CLICKED(IDC_CHKRECORD, OnChkrecord)
	ON_BN_CLICKED(IDC_BUTHIDE, OnButhide)
	ON_BN_CLICKED(IDC_CHKHIDEAREA, OnChkhidearea)
	ON_BN_CLICKED(IDC_CHKOSD, OnChkosd)
	ON_BN_CLICKED(IDC_CHKCHANNAME, OnChkchanname)
	ON_CBN_SELCHANGE(IDC_COMCHAN, OnSelchangeComchan)
	ON_CBN_SELCHANGE(IDC_COMBOCOPYCHAN, OnSelchangeCombocopychan)
	ON_BN_CLICKED(IDCHANCFGOK, OnChancfgok)
	ON_BN_CLICKED(IDCHANCFGEXIT, OnChancfgexit)
	ON_BN_CLICKED(IDC_REMOTERECORD, OnRemoterecord)
	ON_BN_CLICKED(IDC_CHKMOTION, OnChkmotion)
	ON_BN_CLICKED(IDC_CHKHIDEALARM, OnChkhidealarm)
	ON_BN_CLICKED(IDC_BUTHIDEALARM, OnButhidealarm)
	ON_CBN_SELCHANGE(IDC_COMBOBITRATE, OnSelchangeCombobitrate)
	ON_BN_CLICKED(IDC_CHKVILOST, OnChkvilost)
	ON_BN_CLICKED(IDC_BUTVILOST, OnButvilost)
	ON_BN_CLICKED(IDC_BUTSTRING, OnButstring)
	ON_CBN_SELCHANGE(IDC_COMBOFRAMERATE, OnSelchangeComboframerate)
	ON_CBN_SELCHANGE(IDC_PARAMCOMBO, OnSelchangeParamcombo)
	ON_BN_CLICKED(IDC_COMPRESSOK, OnCompressok)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRemoteChannelConfig message handlers
BOOL CRemoteChannelConfig::CheckPara()
{
	CString sTemp;
	m_CopyChannelCtrl.ResetContent();
	m_ChannelCtrl.ResetContent();	
	sTemp.Format(_T("全部通道"));
	m_CopyChannelCtrl.AddString(sTemp);
	
	char cTemp[100];
	m_nChanSel = 0;
	m_nCopyChanNum = -1;

	for(int i=0; i<m_iChannelnumber; i++)
	{
		sTemp.Format("通道%d", (m_lStartChannel+i));
		m_ChannelCtrl.AddString(sTemp);
		m_CopyChannelCtrl.AddString(sTemp);
		m_nChanNum = i+m_lStartChannel;
		bSetChannelPara[i] = FALSE;
		bGetChannelPara[i] = FALSE;
		bRemoteRecord[i] = FALSE;
		if(m_bConnectServer)
		{
			if(GetChanPara(i))
			{
				bGetChannelPara[i] = TRUE;
			}
			else
			{
				sTemp.Format("获取%d通道参数失败!",m_lStartChannel+i);
				MessageBox(sTemp, "温馨提示", MB_ICONINFORMATION);
			}
		}
	}
	m_ChannelCtrl.SetCurSel(m_nChanSel);
	m_CopyChannelCtrl.SetCurSel(m_nChanSel);
	m_nChanNum = m_nChanSel+m_lStartChannel;
	if(bGetChannelPara[m_nChanSel])
	{
		if((m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate >> 31) && 0x01)
		{
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
			m_BitRateCtrl.SetCurSel(22);		//自定义码流
			m_BitRate = m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate & 0x7fffffff;
		}
		else
		{
			m_BitRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate-2);			
			m_BitRate = 0;
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
		}
		
		m_ResolutionCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byResolution);
		m_StreamTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byStreamType);
		m_ImageQualityCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byPicQuality);
		m_BitRateTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byBitrateType);
		m_FrameRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoFrameRate);
		m_BPIntervalCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byIntervalBPFrame);	
		m_FrameI = m_compressioncfg[m_nChanSel].struRecordPara.wIntervalFrameI;
	
		m_bRecord = m_record[m_nChanSel].dwRecord;
		GetDlgItem(IDC_BUTRECORD)->EnableWindow(m_bRecord);
		m_DelayCtrl.SetCurSel(m_record[m_nChanSel].dwRecordTime);
		m_PreRecordTime.SetCurSel(m_record[m_nChanSel].dwPreRecordTime);
		ZeroMemory(cTemp, 100);
		memcpy(cTemp, m_piccfg[m_nChanSel].sChanName, NAME_LEN);
		m_ChannelName.Format("%s",cTemp);
		m_bHide = m_piccfg[m_nChanSel].dwEnableHide;
		GetDlgItem(IDC_BUTHIDE)->EnableWindow(m_bHide);
		m_bMotion = m_piccfg[m_nChanSel].struMotion.byEnableHandleMotion;
		GetDlgItem(IDC_BUTMOTION)->EnableWindow(m_bMotion);
		if(m_piccfg[m_nChanSel].struHideAlarm.dwEnableHideAlarm > 0)
		{
			m_bHideAlarm = TRUE;
		}
		else
		{
			m_bHideAlarm = FALSE;
		}
		GetDlgItem(IDC_BUTHIDEALARM)->EnableWindow(m_bHideAlarm);
		m_bChanname = m_piccfg[m_nChanSel].dwShowChanName;
		m_channame_x = m_piccfg[m_nChanSel].wShowNameTopLeftX;
		m_channame_y = m_piccfg[m_nChanSel].wShowNameTopLeftY;
		m_bOsd = m_piccfg[m_nChanSel].dwShowOsd;
		m_osd_x = m_piccfg[m_nChanSel].wOSDTopLeftX;
		m_osd_y = m_piccfg[m_nChanSel].wOSDTopLeftY;
		m_bDispWeek = m_piccfg[m_nChanSel].byDispWeek;
		m_OsdAttrib.SetCurSel(m_piccfg[m_nChanSel].byOSDAttrib-1);
		m_OsdType.SetCurSel(m_piccfg[m_nChanSel].byOSDType);
		EnableChanname(m_bChanname);
		EnableOsd(m_bOsd);
		m_bVILost = m_piccfg[m_nChanSel].struVILost.byEnableHandleVILost;
		GetDlgItem(IDC_BUTVILOST)->EnableWindow(m_bVILost);
		GetDlgItem(IDCHANCFGOK)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDCHANCFGOK)->EnableWindow(FALSE);
	}
	m_ParamCombo.SetCurSel(0);
	UpdateData(FALSE);

	return TRUE;
}

BOOL CRemoteChannelConfig::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	CRect rc(0, 0, 0, 0);
	GetParent()->GetClientRect(&rc);
	((CTabCtrl*)GetParent())->AdjustRect(FALSE, &rc);
	MoveWindow(&rc);
	
	m_ParamCombo.ResetContent();
	m_ParamCombo.AddString("主码流(录像)");
    m_ParamCombo.AddString("子码流(网传)");

	if (serverinfo[m_iServer].m_dwDevSoftVersion >= 0x20001)
	{
		m_ParamCombo.AddString("事件触发");
	}
	m_ParamCombo.SetCurSel(0);

	m_iSelected = -1;

	if(m_pRemoteParam->m_dvrSelect != -1)
	{
		CheckPara();
	}

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

BOOL CRemoteChannelConfig::GetChanPara(int nIndex)
{ 
	DWORD dwReturned;	
	memset(&m_piccfg[nIndex], 0, sizeof(m_piccfg[nIndex]));
	if(!NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_PICCFG_EX, m_nChanNum, &m_piccfg[nIndex], sizeof(NET_DVR_PICCFG_EX), &dwReturned))
	{
		CString sTemp;
		sTemp.Format("%d : NET_DVR_GET_PICCFG_EX = %d \n", m_nChanNum, NET_DVR_GetLastError());
		TRACE(sTemp);
	}
	memset(&m_compressioncfg[nIndex], 0, sizeof(m_compressioncfg[nIndex]));
	if(!NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_COMPRESSCFG_EX, m_nChanNum, &m_compressioncfg[nIndex], sizeof(NET_DVR_COMPRESSIONCFG_EX), &dwReturned))
	{
		CString sTemp;
		sTemp.Format("%d : ERROR: NET_DVR_GET_COMPRESSCFG_EX = %d \n", m_nChanNum, NET_DVR_GetLastError());
		TRACE(sTemp); 
	}
	memset(&m_compressionNew[nIndex], 0, sizeof(m_compressionNew[nIndex]));
	if (serverinfo[m_iServer].m_dwDevSoftVersion >= 0x20001)
	{
		if(!NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_EVENTCOMPCFG, m_nChanNum, &m_compressionNew[nIndex], sizeof(NET_DVR_COMPRESSIONCFG), &dwReturned))
		{
			CString sTemp;
			sTemp.Format("%d : ERROR: NET_DVR_GET_EVENTCOMPCFG = %d \n", m_nChanNum, NET_DVR_GetLastError());
			TRACE(sTemp); 
		}
	}
	memset(&m_record[nIndex], 0, sizeof(m_record[nIndex]));
	if(!NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_RECORDCFG, m_nChanNum, &m_record[nIndex], sizeof(NET_DVR_RECORD), &dwReturned))	
	{
		CString sTemp;
		sTemp.Format("%d : ERROR: NET_DVR_GET_RECORDCFG = %d \n", m_nChanNum, NET_DVR_GetLastError());
		TRACE(sTemp);	
	}
	return TRUE;
}

void CRemoteChannelConfig::OnButchancopy() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	int nTemp = 0;
	
	if(m_nCopyChanNum == m_nChanSel)
		return;
	if(m_nCopyChanNum == -1)
	{
		for(int i=0; i<m_iChannelnumber; i++)
		{
			if(i == m_nChanSel)
				continue;
			switch(m_iSelected)
			{
			case 0:
				GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
				GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
				GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
				GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
				m_compressioncfg[i].struRecordPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
				m_compressioncfg[i].struRecordPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
				if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流 MIN-16K MAX-8192K
				{
					nTemp = m_BitRate;				
					if(nTemp < 32*1024)
						nTemp = 32*1024;
					if(nTemp > 8192*1024)
						nTemp =  8192*1024;
					nTemp |= 0x80000000;
					
					m_compressioncfg[i].struRecordPara.dwVideoBitrate = nTemp;
				}
				else
				{
					m_compressioncfg[i].struRecordPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
				}
				
				m_compressioncfg[i].struRecordPara.byResolution = m_ResolutionCtrl.GetCurSel();
				m_compressioncfg[i].struRecordPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
				m_compressioncfg[i].struRecordPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();
				m_compressioncfg[i].struRecordPara.byIntervalBPFrame = m_BPIntervalCtrl.GetCurSel();	
				m_compressioncfg[i].struRecordPara.wIntervalFrameI = m_FrameI;
				break;
//2005-07-08 双码流中的网传参数
			case 1:
				GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
				GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
				GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
				GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
				m_compressioncfg[i].struNetPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
				m_compressioncfg[i].struNetPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
				if (m_BitRateCtrl.GetCurSel() == 22)	//自定义码流 MIN-32K MAX-8192K
				{
					nTemp = m_BitRate;				
					if (nTemp < 32*1024)
						nTemp = 32*1024;
					if (nTemp > 8192*1024)
						nTemp =  8192*1024;
					nTemp |= 0x80000000;
					
					m_compressioncfg[i].struNetPara.dwVideoBitrate = nTemp;
				}
				else
				{
					m_compressioncfg[i].struNetPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
				}
				
				m_compressioncfg[i].struNetPara.byResolution = m_ResolutionCtrl.GetCurSel()+1;
				m_compressioncfg[i].struNetPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
				m_compressioncfg[i].struNetPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();	
				m_compressioncfg[i].struNetPara.byIntervalBPFrame = m_BPIntervalCtrl.GetCurSel();	
				m_compressioncfg[i].struNetPara.wIntervalFrameI = m_FrameI;
				break;
			case 2:
				GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(FALSE);
				GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(FALSE);
				GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(FALSE);
				GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(FALSE);
				m_compressionNew[i].struRecordPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
				m_compressionNew[i].struRecordPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
				if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
				{
					nTemp = m_BitRate;		
					if(nTemp < 32*1024)
						nTemp = 32*1024;
					if(nTemp > 8192*1024)
						nTemp =  8192*1024;
					nTemp |= 0x80000000;
					m_compressionNew[i].struRecordPara.dwVideoBitrate = nTemp;
				}
				else
				{
					m_compressionNew[i].struRecordPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
				}
				m_compressionNew[i].struRecordPara.byResolution = m_ResolutionCtrl.GetCurSel();
				m_compressionNew[i].struRecordPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
				m_compressionNew[i].struRecordPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();
				break;
			default:
				break;
			}
			
			m_record[i].dwRecord = m_bRecord;
			m_record[i].dwRecordTime = m_DelayCtrl.GetCurSel();
			m_record[i].dwPreRecordTime = m_PreRecordTime.GetCurSel();
			//复制时间表
			for(int k=0; k<MAX_DAYS; k++)
			{
				memcpy(&(m_record[i].struRecAllDay[k]), &(m_record[m_nChanSel].struRecAllDay[k]), sizeof(NET_DVR_RECORDDAY));
				for(int j=0; j<MAX_TIMESEGMENT; j++)
				{
					memcpy(&m_record[i].struRecordSched[k][j],&m_record[m_nChanSel].struRecordSched[k][j],sizeof(NET_DVR_RECORDSCHED));				
				}
			}

			m_piccfg[i].dwEnableHide = m_bHide;
			m_piccfg[i].struMotion.byEnableHandleMotion = m_bMotion;			
			if(!m_bHideAlarm)
			{
				m_piccfg[i].struHideAlarm.dwEnableHideAlarm = m_bHideAlarm;
			}
			m_piccfg[i].dwShowChanName = m_bChanname;
			m_piccfg[i].wShowNameTopLeftX = m_channame_x;
			m_piccfg[i].wShowNameTopLeftY = m_channame_y;
			m_piccfg[i].dwShowOsd = m_bOsd;
			m_piccfg[i].wOSDTopLeftX = m_osd_x;
			m_piccfg[i].wOSDTopLeftY = m_osd_y;
			m_piccfg[i].byDispWeek = m_bDispWeek;
			m_piccfg[i].byOSDAttrib = m_OsdAttrib.GetCurSel()+1;
			m_piccfg[i].byOSDType = m_OsdType.GetCurSel();
			m_piccfg[i].struVILost.byEnableHandleVILost = m_bVILost;
			//复制视频参数
			m_piccfg[i].byBrightness = m_piccfg[m_nChanSel].byBrightness;
			m_piccfg[i].byContrast = m_piccfg[m_nChanSel].byContrast;
			m_piccfg[i].byHue = m_piccfg[m_nChanSel].byHue;
			m_piccfg[i].bySaturation = m_piccfg[m_nChanSel].bySaturation;
			
			bSetChannelPara[i] = TRUE;
		}		
	}
	else
	{
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
		m_compressioncfg[m_nCopyChanNum].struRecordPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
		m_compressioncfg[m_nCopyChanNum].struRecordPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
		if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
		{
			nTemp = m_BitRate;			
			if(nTemp < 32*1024)
				nTemp = 32*1024;
			if(nTemp > 8192*1024)
				nTemp =  8192*1024;
			nTemp |= 0x80000000;
			m_compressioncfg[m_nCopyChanNum].struRecordPara.dwVideoBitrate = nTemp;
		}
		else
		{
			m_compressioncfg[m_nCopyChanNum].struRecordPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
		}
		m_compressioncfg[m_nCopyChanNum].struRecordPara.byResolution = m_ResolutionCtrl.GetCurSel();
		m_compressioncfg[m_nCopyChanNum].struRecordPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
		m_compressioncfg[m_nCopyChanNum].struRecordPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();	
		m_compressioncfg[m_nCopyChanNum].struRecordPara.byIntervalBPFrame = m_BPIntervalCtrl.GetCurSel();	
		m_compressioncfg[m_nCopyChanNum].struRecordPara.wIntervalFrameI = m_FrameI;
				
		m_record[m_nCopyChanNum].dwRecord = m_bRecord;
		m_record[m_nCopyChanNum].dwRecordTime = m_DelayCtrl.GetCurSel();
		m_record[m_nCopyChanNum].dwPreRecordTime = m_PreRecordTime.GetCurSel();
	
		//复制时间表
		for(int k=0; k<MAX_DAYS; k++)
		{
			memcpy(&(m_record[m_nCopyChanNum].struRecAllDay[k]), &(m_record[m_nChanSel].struRecAllDay[k]), sizeof(NET_DVR_RECORDDAY));
			for(int j=0; j<MAX_TIMESEGMENT; j++)
			{
				memcpy(&m_record[m_nCopyChanNum].struRecordSched[k][j],&m_record[m_nChanSel].struRecordSched[k][j],sizeof(NET_DVR_RECORDSCHED));				
			}
		}
		m_piccfg[m_nCopyChanNum].dwEnableHide = m_bHide;
		m_piccfg[m_nCopyChanNum].struMotion.byEnableHandleMotion = m_bMotion;
		if(!m_bHideAlarm)
		{
			m_piccfg[m_nCopyChanNum].struHideAlarm.dwEnableHideAlarm = m_bHideAlarm;
		}
		m_piccfg[m_nCopyChanNum].dwShowChanName = m_bChanname;
		m_piccfg[m_nCopyChanNum].wShowNameTopLeftX = m_channame_x;
		m_piccfg[m_nCopyChanNum].wShowNameTopLeftY = m_channame_y;
		m_piccfg[m_nCopyChanNum].dwShowOsd = m_bOsd;
		m_piccfg[m_nCopyChanNum].wOSDTopLeftX = m_osd_x;
		m_piccfg[m_nCopyChanNum].wOSDTopLeftY = m_osd_y;
		m_piccfg[m_nCopyChanNum].byDispWeek = m_bDispWeek;
		m_piccfg[m_nCopyChanNum].byOSDAttrib = m_OsdAttrib.GetCurSel()+1;
		m_piccfg[m_nCopyChanNum].byOSDType = m_OsdType.GetCurSel();
		m_piccfg[m_nCopyChanNum].struVILost.byEnableHandleVILost = m_bVILost;
		
		//复制视频参数
		m_piccfg[m_nCopyChanNum].byBrightness = m_piccfg[m_nChanSel].byBrightness;
		m_piccfg[m_nCopyChanNum].byContrast = m_piccfg[m_nChanSel].byContrast;
		m_piccfg[m_nCopyChanNum].byHue = m_piccfg[m_nChanSel].byHue;
		m_piccfg[m_nCopyChanNum].bySaturation = m_piccfg[m_nChanSel].bySaturation;
		bSetChannelPara[m_nCopyChanNum] = TRUE;
	}
}

void CRemoteChannelConfig::OnButmotion() 
{
	// TODO: Add your control notification handler code here
	CRemoteDetectConfig DetectCfgDlg;
	
	lpMotionDetect = &(m_piccfg[m_nChanSel].struMotion);
	DetectCfgDlg.m_iChannel = m_nChanNum;
	DetectCfgDlg.m_lServerID = m_lServerID;
	DetectCfgDlg.m_dwAlarmOutNum = m_dwAlarmOutNum;
	DetectCfgDlg.m_iChannelnumber = m_iChannelnumber;
	if(DetectCfgDlg.DoModal() == IDOK)
		bSetChannelPara[m_nChanSel] = TRUE;
}

void CRemoteChannelConfig::OnButrecord() 
{
	// TODO: Add your control notification handler code here
	CRemoteRecordPlanConfig dlg;

	dlg.serverrecordplan = &(m_record[m_nChanSel]);
	if(dlg.DoModal() == IDOK)
		bSetChannelPara[m_nChanSel] = TRUE;
}

void CRemoteChannelConfig::OnChkrecord() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if(m_bRecord)
		GetDlgItem(IDC_BUTRECORD)->EnableWindow(TRUE);
	else
		GetDlgItem(IDC_BUTRECORD)->EnableWindow(FALSE);
}


void CRemoteChannelConfig::OnButhide() 
{
	// TODO: Add your control notification handler code here
	CRemoteHideConfig Dlg;
	int i = 0;
	
	for(i=0; i<MAX_SHELTERNUM; i++)
	{
		memcpy(&(Dlg.struShelter[i]), &(m_piccfg[m_nChanSel].struShelter[i]),sizeof(NET_DVR_SHELTER));
	}
	Dlg.m_iChannel = m_nChanNum;
	Dlg.m_lServerID = m_lServerID;
	if(Dlg.DoModal() == IDOK)
	{
		for(i=0; i<MAX_SHELTERNUM; i++)
		{
			memcpy(&(m_piccfg[m_nChanSel].struShelter[i]), &(Dlg.struShelter[i]),sizeof(NET_DVR_SHELTER));
		}
		bSetChannelPara[m_nChanSel] = TRUE;
	}
}

void CRemoteChannelConfig::OnChkhidearea() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if(m_bHide)
		GetDlgItem(IDC_BUTHIDE)->EnableWindow(TRUE);
	else
		GetDlgItem(IDC_BUTHIDE)->EnableWindow(FALSE);
}

void CRemoteChannelConfig::OnChkosd() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	EnableOsd(m_bOsd);
}

void CRemoteChannelConfig::OnChkchanname() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	EnableChanname(m_bChanname);
}

void CRemoteChannelConfig::EnableOsd(BOOL bEnable) 
{
	// TODO: Add your control notification handler code here
	GetDlgItem(IDC_OSD_X)->EnableWindow(bEnable);
	GetDlgItem(IDC_OSD_Y)->EnableWindow(bEnable);
	GetDlgItem(IDC_OSDATTRIB)->EnableWindow(bEnable);
	GetDlgItem(IDC_OSDTYPE)->EnableWindow(bEnable);
	GetDlgItem(IDC_CHKDISPWEEK)->EnableWindow(bEnable);
		
}

void CRemoteChannelConfig::EnableChanname(BOOL bEnable) 
{
	// TODO: Add your control notification handler code here
	GetDlgItem(IDC_CHANNAME_X)->EnableWindow(bEnable);
	GetDlgItem(IDC_CHANNAME_Y)->EnableWindow(bEnable);
}

void CRemoteChannelConfig::OnSelchangeComchan() 
{
	// TODO: Add your control notification handler code here
	char cTemp[100];
	m_nChanSel = m_ChannelCtrl.GetCurSel();
	m_nChanNum = m_nChanSel+m_lStartChannel;
	if(!bGetChannelPara[m_nChanSel])
	{		
		if(GetChanPara(m_nChanSel))
		{
			bGetChannelPara[m_nChanSel] = TRUE;
		}
		else
		{
			GetDlgItem(IDCHANCFGOK)->EnableWindow(FALSE);
			CString sTemp;
			sTemp.Format("获取%d通道参数失败!",m_nChanSel);
			MessageBox(sTemp, "温馨提示", MB_ICONINFORMATION);
			return;
		}
	}
	m_ParamCombo.SetCurSel(0);
	m_iSelected = 0;
	GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
	GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
	GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
	GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);

	m_ResolutionCtrl.ResetContent();
	m_ResolutionCtrl.AddString("DCIF");
	m_ResolutionCtrl.AddString("CIF");
	m_ResolutionCtrl.AddString("QCIF");
	m_ResolutionCtrl.AddString("4CIF");
	m_ResolutionCtrl.AddString("2CIF");
	GetDlgItem(IDC_CHECKEVENT)->ShowWindow(SW_HIDE);
	if((m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate >> 31) && 0x01)
	{
		GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
		m_BitRateCtrl.SetCurSel(22);		//自定义码流
		m_BitRate = m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate & 0x7fffffff;
	}
	else
	{
		m_BitRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate-2);			
		m_BitRate = 0;
		GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
	}	
	m_ResolutionCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byResolution);
	m_StreamTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byStreamType);
	m_ImageQualityCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byPicQuality);
	m_BitRateTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byBitrateType);
	m_FrameRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoFrameRate);
	m_BPIntervalCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byIntervalBPFrame);	
	m_FrameI = m_compressioncfg[m_nChanSel].struRecordPara.wIntervalFrameI;	
	
	m_bRecord = m_record[m_nChanSel].dwRecord;
	GetDlgItem(IDC_BUTRECORD)->EnableWindow(m_bRecord);
	m_DelayCtrl.SetCurSel(m_record[m_nChanSel].dwRecordTime);
	m_PreRecordTime.SetCurSel(m_record[m_nChanSel].dwPreRecordTime);
	ZeroMemory(cTemp, 100);
	memcpy(cTemp, m_piccfg[m_nChanSel].sChanName, NAME_LEN);
	m_ChannelName.Format("%s",cTemp);
	m_bHide = m_piccfg[m_nChanSel].dwEnableHide;
	GetDlgItem(IDC_BUTHIDE)->EnableWindow(m_bHide);
	m_bMotion = m_piccfg[m_nChanSel].struMotion.byEnableHandleMotion;
	GetDlgItem(IDC_BUTMOTION)->EnableWindow(m_bMotion);
	if(m_piccfg[m_nChanSel].struHideAlarm.dwEnableHideAlarm > 0)
	{
		m_bHideAlarm = TRUE;
	}
	else
	{
		m_bHideAlarm = FALSE;
	}
	GetDlgItem(IDC_BUTHIDEALARM)->EnableWindow(m_bHideAlarm);
	m_bChanname = m_piccfg[m_nChanSel].dwShowChanName;	
	m_channame_x = m_piccfg[m_nChanSel].wShowNameTopLeftX;
	m_channame_y = m_piccfg[m_nChanSel].wShowNameTopLeftY;
	m_bOsd = m_piccfg[m_nChanSel].dwShowOsd;	
	m_osd_x = m_piccfg[m_nChanSel].wOSDTopLeftX;
	m_osd_y = m_piccfg[m_nChanSel].wOSDTopLeftY;
	m_bDispWeek = m_piccfg[m_nChanSel].byDispWeek;
	m_OsdAttrib.SetCurSel(m_piccfg[m_nChanSel].byOSDAttrib-1);
	m_OsdType.SetCurSel(m_piccfg[m_nChanSel].byOSDType);
	m_bVILost = m_piccfg[m_nChanSel].struVILost.byEnableHandleVILost;
	GetDlgItem(IDC_BUTVILOST)->EnableWindow(m_bVILost);

	GetDlgItem(IDCHANCFGOK)->EnableWindow(TRUE);
	if(bRemoteRecord[m_nChanSel])
	{
		GetDlgItem(IDC_REMOTERECORD)->SetWindowText("停止录像");		
	}
	else
	{
		GetDlgItem(IDC_REMOTERECORD)->SetWindowText("远程录像");
	}
	UpdateData(FALSE);
}

void CRemoteChannelConfig::OnSelchangeCombocopychan() 
{
	// TODO: Add your control notification handler code here
	m_nCopyChanNum = m_CopyChannelCtrl.GetCurSel() - 1;
}

void CRemoteChannelConfig::OnChancfgok() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);	
	memcpy(m_piccfg[m_nChanSel].sChanName, m_ChannelName, NAME_LEN);
	
	m_record[m_nChanSel].dwRecord = m_bRecord;
	m_record[m_nChanSel].dwRecordTime = m_DelayCtrl.GetCurSel();
	m_record[m_nChanSel].dwPreRecordTime = m_PreRecordTime.GetCurSel();
	
	m_piccfg[m_nChanSel].dwEnableHide = m_bHide;
	m_piccfg[m_nChanSel].struMotion.byEnableHandleMotion = m_bMotion;
	if(!m_bHideAlarm)
	{
		m_piccfg[m_nChanSel].struHideAlarm.dwEnableHideAlarm = m_bHideAlarm;
	}
	m_piccfg[m_nChanSel].dwShowChanName = m_bChanname;
	m_piccfg[m_nChanSel].wShowNameTopLeftX = m_channame_x;
	m_piccfg[m_nChanSel].wShowNameTopLeftY = m_channame_y;
	m_piccfg[m_nChanSel].dwShowOsd = m_bOsd;
	m_piccfg[m_nChanSel].wOSDTopLeftX = m_osd_x;
	m_piccfg[m_nChanSel].wOSDTopLeftY = m_osd_y;
	m_piccfg[m_nChanSel].byDispWeek = m_bDispWeek;
	m_piccfg[m_nChanSel].byOSDAttrib = m_OsdAttrib.GetCurSel()+1;
	m_piccfg[m_nChanSel].byOSDType = m_OsdType.GetCurSel();
	m_piccfg[m_nChanSel].struVILost.byEnableHandleVILost = m_bVILost;	
	bSetChannelPara[m_nChanSel] = TRUE;
	GetDlgItem(IDC_BUTCHANCOPY)->EnableWindow(TRUE);
}

void CRemoteChannelConfig::OnChancfgexit() 
{
	// TODO: Add your control notification handler code here
	for(int i=0; i<m_iChannelnumber; i++)
	{
		bSetChannelPara[i] = FALSE;
	}
}

void CRemoteChannelConfig::OnCancel() 
{
	// TODO: Add extra cleanup here
	
	//CDialog::OnCancel();
}

void CRemoteChannelConfig::OnRemoterecord() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	//m_nChanSel = m_ChannelCtrl.GetCurSel();
	//m_nChanNum = m_nChanSel+m_lStartChannel;
	//if(!bRemoteRecord[m_nChanSel])
	//{
	//	if(NET_DVR_StartDVRRecord(m_lServerID, m_nChanNum, 0))
	//	{
	//		GetDlgItem(IDC_REMOTERECORD)->SetWindowText("停止录像");
	//		bRemoteRecord[m_nChanSel] = TRUE;
	//	}		
	//}
	//else
	{
		if(NET_DVR_StopDVRRecord(m_lServerID, m_nChanNum))
		{
			GetDlgItem(IDC_REMOTERECORD)->SetWindowText("远程录像");
			bRemoteRecord[m_nChanSel] = FALSE;
		}
	}
}

void CRemoteChannelConfig::OnChkmotion() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if(m_bMotion)
		GetDlgItem(IDC_BUTMOTION)->EnableWindow(TRUE);
	else
		GetDlgItem(IDC_BUTMOTION)->EnableWindow(FALSE);
}

void CRemoteChannelConfig::OnChkhidealarm() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if(m_bHideAlarm)
		GetDlgItem(IDC_BUTHIDEALARM)->EnableWindow(TRUE);
	else
		GetDlgItem(IDC_BUTHIDEALARM)->EnableWindow(FALSE);
}

void CRemoteChannelConfig::OnButhidealarm() 
{
	// TODO: Add your control notification handler code here
	CRemoteHideAlarm Dlg;

	lpHideAlarm = &(m_piccfg[m_nChanSel].struHideAlarm);
	Dlg.m_iChannel = m_nChanNum;
	Dlg.m_lServerID = m_lServerID;
	Dlg.m_dwAlarmOutNum = m_dwAlarmOutNum;
	if(Dlg.DoModal() == IDOK)
	{
		bSetChannelPara[m_nChanSel] = TRUE;
	}
}

void CRemoteChannelConfig::OnSelchangeCombobitrate() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
	{
		GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
	}
}



void CRemoteChannelConfig::OnChkvilost() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	GetDlgItem(IDC_BUTVILOST)->EnableWindow(m_bVILost);
}

void CRemoteChannelConfig::OnButvilost() 
{
	// TODO: Add your control notification handler code here
	CVideoLost Dlg;
	
	lpVILost = &(m_piccfg[m_nChanSel].struVILost);
	Dlg.m_iChannel = m_nChanNum;
	Dlg.m_lServerID = m_lServerID;
	Dlg.m_dwAlarmOutNum = m_dwAlarmOutNum;
	if(Dlg.DoModal() == IDOK)
	{
		bSetChannelPara[m_nChanSel] = TRUE;
	}
}


void CRemoteChannelConfig::OnButstring() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	CShowString Dlg;
	
	Dlg.m_lServerID = m_lServerID;
	Dlg.m_nChanNum = m_nChanNum;
	Dlg.DoModal();
}


void CRemoteChannelConfig::OnSelchangeComboframerate() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	WORD temp = m_FrameRateCtrl.GetCurSel();
	m_FrameI = getFrameI(temp);	
	UpdateData(FALSE);
	
}


void CRemoteChannelConfig::OnSelchangeParamcombo() 
{
	if(m_pRemoteParam->m_dvrSelect == -1)
		return;
	// TODO: Add your control notification handler code here
	int sel = m_ParamCombo.GetCurSel();
	
	if(m_iSelected == sel)
		return;
	m_iSelected = sel;

	m_ResolutionCtrl.ResetContent();
	m_ResolutionCtrl.AddString("DCIF");
	m_ResolutionCtrl.AddString("CIF");
	m_ResolutionCtrl.AddString("QCIF");
	m_ResolutionCtrl.AddString("4CIF");
	m_ResolutionCtrl.AddString("2CIF");
	GetDlgItem(IDC_CHECKEVENT)->ShowWindow(SW_HIDE);
	switch(m_iSelected)
	{
	case 0:
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
		if((m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate >> 31) && 0x01)
		{
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
			m_BitRateCtrl.SetCurSel(22);		//自定义码流
			m_BitRate = m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate & 0x7fffffff;
		}
		else
		{
			m_BitRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate-2);			
			m_BitRate = 0;
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
		}	
		m_ResolutionCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byResolution);
		m_StreamTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byStreamType);
		m_ImageQualityCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byPicQuality);
		m_BitRateTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byBitrateType);
		m_FrameRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.dwVideoFrameRate);
		m_BPIntervalCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struRecordPara.byIntervalBPFrame);	
		m_FrameI = m_compressioncfg[m_nChanSel].struRecordPara.wIntervalFrameI;
		break;
	case 1:	
		m_ResolutionCtrl.ResetContent();
		m_ResolutionCtrl.AddString("CIF");
		m_ResolutionCtrl.AddString("QCIF");

		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
		if ((m_compressioncfg[m_nChanSel].struNetPara.dwVideoBitrate >> 31) && 0x01)
		{
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
			m_BitRateCtrl.SetCurSel(22);		//自定义码流
			m_BitRate = m_compressioncfg[m_nChanSel].struNetPara.dwVideoBitrate & 0x7fffffff;
		}
		else
		{
			m_BitRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.dwVideoBitrate-2);			
			m_BitRate = 0;
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
		}
		m_ResolutionCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.byResolution-1);
		m_StreamTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.byStreamType);
		m_ImageQualityCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.byPicQuality);
		m_BitRateTypeCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.byBitrateType);
		m_FrameRateCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.dwVideoFrameRate);	
		m_BPIntervalCtrl.SetCurSel(m_compressioncfg[m_nChanSel].struNetPara.byIntervalBPFrame);	
		m_FrameI = m_compressioncfg[m_nChanSel].struNetPara.wIntervalFrameI;
		break;
	case 2:
		GetDlgItem(IDC_CHECKEVENT)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(FALSE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(FALSE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(FALSE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(FALSE);
		if((m_compressionNew[m_nChanSel].struRecordPara.dwVideoBitrate >> 31) && 0x01)
		{
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(TRUE);
			m_BitRateCtrl.SetCurSel(22);		//自定义码流
			m_BitRate = m_compressionNew[m_nChanSel].struRecordPara.dwVideoBitrate & 0x7fffffff;
		}
		else
		{
			m_BitRateCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.dwVideoBitrate-2);			
			m_BitRate = 0;
			GetDlgItem(IDC_EDITBITRATE)->EnableWindow(FALSE);
		}	
		m_ResolutionCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.byResolution);
		//2008-03-31 码流类型的最高位用来表示是否事件触发参数是即时生效的
		if (m_compressionNew[m_nChanSel].struRecordPara.byStreamType & 0x80)
		{
			m_bUseEvent = TRUE;
			m_compressionNew[m_nChanSel].struRecordPara.byStreamType &= 0x7f;
		}
		m_StreamTypeCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.byStreamType);
		m_ImageQualityCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.byPicQuality);
		m_BitRateTypeCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.byBitrateType);
		m_FrameRateCtrl.SetCurSel(m_compressionNew[m_nChanSel].struRecordPara.dwVideoFrameRate);
		break;
	default:
		break;
	}

	UpdateData(FALSE);
}

void CRemoteChannelConfig::OnCompressok() 
{
	int nTemp = 0;
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	int sel = m_ParamCombo.GetCurSel();
	m_iSelected = sel;

	switch(m_iSelected)
	{
	case 0:
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
		m_compressioncfg[m_nChanSel].struRecordPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struRecordPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
		if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
		{
			nTemp = m_BitRate;		
			if(nTemp < 32*1024)
				nTemp = 32*1024;
			if(nTemp > 8192*1024)
				nTemp =  8192*1024;
			nTemp |= 0x80000000;
			m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate = nTemp;
		}
		else
		{
			m_compressioncfg[m_nChanSel].struRecordPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
		}
		m_compressioncfg[m_nChanSel].struRecordPara.byResolution = m_ResolutionCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struRecordPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struRecordPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struRecordPara.byIntervalBPFrame = m_BPIntervalCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struRecordPara.wIntervalFrameI = m_FrameI;
		break;
	case 1:
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(TRUE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(TRUE);
		m_compressioncfg[m_nChanSel].struNetPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struNetPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
		if (m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
		{
			nTemp = m_BitRate;		
			if (nTemp < 32*1024)
				nTemp = 32*1024;
			if (nTemp > 8192*1024)
				nTemp =  8192*1024;
			nTemp |= 0x80000000;
			m_compressioncfg[m_nChanSel].struNetPara.dwVideoBitrate = nTemp;
		}
		else
		{
			m_compressioncfg[m_nChanSel].struNetPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
		}
		m_compressioncfg[m_nChanSel].struNetPara.byResolution = m_ResolutionCtrl.GetCurSel()+1;
		m_compressioncfg[m_nChanSel].struNetPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struNetPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struNetPara.byIntervalBPFrame = m_BPIntervalCtrl.GetCurSel();
		m_compressioncfg[m_nChanSel].struNetPara.wIntervalFrameI = m_FrameI;
		break;
	case 2:
		GetDlgItem(IDC_COMBOSTREAMTYPE)->EnableWindow(FALSE);
		GetDlgItem(IDC_COMBORESOLUTION)->EnableWindow(FALSE);
		GetDlgItem(IDC_EDITFRAMEI)->EnableWindow(FALSE);
		GetDlgItem(IDC_COMBOBPINTERVAL)->EnableWindow(FALSE);
		m_compressionNew[m_nChanSel].struRecordPara.byStreamType = m_StreamTypeCtrl.GetCurSel();
		//2008-03-31 码流类型的最高位用来表示事件触发参数是否设置后即生效
		if (m_bUseEvent)
		{
			m_compressionNew[m_nChanSel].struRecordPara.byStreamType |= 0x80;
		}
		m_compressionNew[m_nChanSel].struRecordPara.byPicQuality = m_ImageQualityCtrl.GetCurSel();
		if(m_BitRateCtrl.GetCurSel() == 22)	//自定义码流
		{
			nTemp = m_BitRate;		
			if(nTemp < 32*1024)
				nTemp = 32*1024;
			if(nTemp > 8192*1024)
				nTemp =  8192*1024;
			nTemp |= 0x80000000;
			m_compressionNew[m_nChanSel].struRecordPara.dwVideoBitrate = nTemp;
		}
		else
		{
			m_compressionNew[m_nChanSel].struRecordPara.dwVideoBitrate = m_BitRateCtrl.GetCurSel()+2;
		}
		m_compressionNew[m_nChanSel].struRecordPara.byResolution = m_ResolutionCtrl.GetCurSel();
		m_compressionNew[m_nChanSel].struRecordPara.dwVideoFrameRate = m_FrameRateCtrl.GetCurSel();
		m_compressionNew[m_nChanSel].struRecordPara.byBitrateType = m_BitRateTypeCtrl.GetCurSel();
		break;
	default:
		break;
	}
	bSetChannelPara[m_nChanSel] = TRUE;
}