net_cmdtcp.cpp

实时监控

	if(!avtcp[group]->open_channel(rip, rport, channel_idx,bUdpav))
		return FALSE;

	char portinfo[2] = {(char)channel_idx, 0};
	send_cmd_data(group, NETCOM_OPEN_REALIMAGE_REQ, portinfo, 2);
	avtcp[group]->shutdownsocket();

	POST_NOTIFY(cmdcb, NTM_CMD_CHANNEL_OPENED, rip, MAKEDWORD(rport, channel_idx));
	return TRUE;
}

// 关闭主机视频通道
//##ModelId=3F9A1D2302AD
BOOL net_cmdtcp::close_remote_channel(LONG group)
{
	if( group >= max_channel )
		return FALSE;

	if( !avtcp[group]->is_opened() )
		return FALSE;

	int chnl = avtcp[group]->svr_chnl();
	char portinfo = (char)chnl;

	send_cmd(avtcp[group]->svr_ip(), avtcp[group]->svr_port(), NETCOM_CLOSE_REALIMAGE_REQ, &portinfo, 1);

	return close_local_channel(group);
}

/*
 *	关闭客户端(本地)视频通道
 */
//##ModelId=3F9A1D2302C1
BOOL net_cmdtcp::close_local_channel(LONG group)
{
	pcallback[group] = NULL;
	pdrawcallback[group] = NULL;

	pcallback_user1[group] = 0;
	pcallback_user2[group] = 0;

	pdrawcallback_user1[group] = 0;
	pdrawcallback_user2[group] = 0;

	if(avtcp[group]->is_vod()) 
	{
		close_vod(group);
		return TRUE;
	}
	
	avtcp[group]->leave();
	return TRUE;
}


//##ModelId=3F9A1D2302DF
void net_cmdtcp::set_option(IPPORT, NET_OPTIONS no, void* stuff, OPT_SET_CALLEE cb)
{
	int size = 0;
	int msg = 0;
	bytebuf send(256);
	
	switch(no)
	{
	case OPT_SYS_TIME:
		msg = NETCOM_SETSYSTIME_CTRL ;
		size = sizeof(TSYS_TIME) ;
		memcpy(send, stuff, size) ;
		break;
	case OPT_SYS_IP:
		msg = NETCOM_SETNETADDR_CTRL ;
		size = sizeof(TNET_ATTRIBUTE) ;
		memcpy(send, stuff, size) ;
		break ;
	case OPT_REC:
		msg = NETCOM_SETRECPARA_CTRL;
		size = sizeof(TREC_PARAMETER);
		memcpy(send, stuff, size);
		break;
	case OPT_SCHED:
		msg = NETCOM_SETSCHDREC_CTRL;
		size = sizeof(TREC_SCHEDULEPARA);
		memcpy(send, stuff, size);
		break;
	case OPT_MD:
		msg = NETCOM_SETMOVEREC_CTRL;
		size = sizeof(TREC_MOTIONRECPARA);
		memcpy(send, stuff, size);
		break;
	case OPT_ALARM_16_AREA:
		msg = NET_SET_16_MOTION_AREA;
		size = sizeof(TREC_MOTIONRECPARA_16);
		memcpy(send, stuff, size);
		break;
	case OPT_ALARM:
		msg = NETCOM_SETALARMREC_CTRL;
		size = sizeof(TREC_ALARMRECPARA);
		memcpy(send, stuff, size);
		{
			TREC_ALARMRECPARA* a = (TREC_ALARMRECPARA*)send.data();
			shift(a->recchannel);
		}
		break;
	case OPT_REC_ENABLE:
		msg = NETCOM_SETRECPORT_CTRL;
		size = sizeof(DWORD);
		memcpy(send, stuff, size);
		break;
	case OPT_TITLE:

		msg = NETCOM_SETPORTTITLE_CTRL;
		size = sizeof(TREC_CHANNELTITLE);
		memcpy(send, stuff, size);
		break;
	case OPT_DEFAULT:
		
		msg = NETCOM_SETDEFAULT_CTRL;
		size = 0;
		break;
	case OPT_CAMERA:
		msg = NETCOM_CAMERA_CTRL;
		size = sizeof(TREC_CAMERA);
		memcpy(send, stuff, size);
		{
			TREC_CAMERA* c = (TREC_CAMERA*)send.data();
			c->cmd = trans_camera_cmd((CAMERA_CMD)c->cmd);
			if (c->cmd == 0x1aa4 || c->cmd == 0x1aa5)  {
				c->preset ++ ;
			}
		}
		break;
	case OPT_VIDEO:
		msg = NETCOM_SET_VIDEO;
		size = sizeof(TREC_VIDEO);
		memcpy(send, stuff, size);
		break;

	case OPT_BAUDRATE:
		msg = NETCOM_SET_BAUDRATE;
		size = sizeof(TREC_BAUDRATE);
		memcpy(send, stuff, size);
		break;

	case OPT_VIDEOPARA :
		msg = NETCOM_SET_VIDEOPARA ;
		size = sizeof(TREC_VIDEOPARA) ;
		memcpy(send, stuff, size) ;
		break ;

	default:	// 未知参数
		return;
	}

	if( cb )
		sc = cb;
	send_cmd(rip, rport, msg, (char*)send.data(), size) ;
}

//##ModelId=3F9A1D230307
void net_cmdtcp::get_option(IPPORT, NET_OPTIONS no, int channel, OPT_GET_CALLEE cb)
{
	int msg = 0;
	int chnl = channel;
	/*
	 *	如果chnl == -1, size 为0
	 *	也即发送的数据为TMVD + CMD, 共5字节 (例如取得系统时间，与通道无关)
	 *	否则发送的数据为TMVD + CMD + chnl, 共6字节
	 */
	int size = (chnl==-1)?0:1;
	
	
	switch(no)
	{
	case OPT_SYS_TIME:
		msg = NETCOM_GETSYSTIME_CTRL;
		break;
	case OPT_SYS_IP:
		msg = NETCOM_GETNETADDR_CTRL;
		break;
	case OPT_REC:
		msg = NETCOM_GETRECPARA_CTRL;
		break;
	case OPT_SCHED:
		msg = NETCOM_GETSCHDREC_CTRL;
		break;
	case OPT_MD:
		msg = NETCOM_GETMOVEREC_CTRL;
		break;
	case OPT_ALARM:
		msg = NETCOM_GETALARMREC_CTRL;
		break;
	case OPT_REC_ENABLE:
		msg = NETCOM_GETRECPORT_CTRL;
		break;
	case OPT_TITLE:
		msg = NETCOM_GETPORTTITLE_CTRL;
		break;
	case OPT_VOD_DATE:
		msg = NETCOM_QUERY_RECDATE;
		break;
	case OPT_VOD_BACKUP_DATE:
		msg = NETCOM_QUERY_BACKUP_DATE;
		break;
	case OPT_VOD_FILE:
		msg = NETCOM_QUERY_RECFILE;
		size = sizeof(DWORD);
		break;
	case OPT_VOD_BACKUP_FILE:
		msg = NETCOM_QUERY_BACKUP_FILE;
		size = sizeof(DWORD);
		break; 
	case OPT_VIDEO:
		msg = NETCOM_GET_VIDEO;
		break;
	case OPT_BAUDRATE:
		msg = NETCOM_GET_BAUDRATE;
		break;
	case OPT_VIDEOPARA:
		msg = NETCOM_GET_VIDEOPARA;
		break;
	default:	// 未知参数
		return;
	}
//	last_ip = rip;
//	last_port = rport;
	if( cb )
		gc = cb ;
    
	send_cmd(rip, rport, msg, (char*)&chnl, size) ;
}

void net_cmdtcp::get_options_file(IPPORT, byte * m_byte, OPT_GET_CALLEE cb)
{
	if( cb ) gc = cb ;
	send_cmd(rip, rport, NETCOM_QUERY_RECFILE, (char*)m_byte, 5) ;
}

void net_cmdtcp::get_options_backup_file(IPPORT, byte * m_byte, OPT_GET_CALLEE cb)
{
	if( cb ) gc = cb ;
	send_cmd(rip, rport, NETCOM_QUERY_BACKUP_FILE, (char*)m_byte, 5) ;
}

//##ModelId=3F9A1D23032F
void net_cmdtcp::switch_audio(int group)
{
	net_avtcp::switch_audio(group);
}

//##ModelId=3F9A1D23034E
VOD_SPEED net_cmdtcp::get_vod_speed(ULONG ip,int group)
{
	return (VOD_SPEED) avtcp[group]->get_play_mode();	
}

int net_cmdtcp::get_vod_windows_counts(ULONG ip, USHORT port)
{
	int counts = 0;
	for( int i=0; i<max_channel; i++ )
	{
		if( !avtcp[i]->is_vod() )
			continue;

		ULONG rip = avtcp[i]->svr_ip();
		USHORT rport = avtcp[i]->svr_port();
		
		if( rip == ip && rport == port)
			counts++;
	}

	return counts;
}

void net_cmdtcp::send_vodcmd_speed(int group, LONG rspeed)
{
		int speed, type;
		switch(rspeed)
		{
			case VS_PLAYx1:
				vod_mute[group] = false ;type = 0;
				nVodLostVideoNum[group] = nVodListRr[group] = nVodListWr[group] = 0 ;
				break ;
			case  VS_PAUSE :
				type = 1;
				vod_mute[group] = true ;
				break ;
		
			case  VS_FFx1 :
				type = 2;speed = 0;
				vod_mute[group] = true ;
				break ;
			case  VS_FFx2 :
				type = 2;speed = 1;
				vod_mute[group] = true ;
				break ;
			case  VS_FFx3 :
				type = 2;speed = 2;
				vod_mute[group] = true ;
				break ;
			case VS_FFx4 :
				type = 2;speed = 3;
				vod_mute[group] = true ;
				break ;
			case  VS_FBx1 :
				type = 3;speed = 0;
				vod_mute[group] = true ;
				break ;
			case  VS_FBx2 :
				type = 3;speed = 1;
				vod_mute[group] = true ;
				break ;
			case  VS_FBx3 :
				type = 3;speed = 2;
				vod_mute[group] = true ;
				break ;
			case  VS_FBx4 :
				type = 3;speed = 3;
				vod_mute[group] = true ;
				break ;

			case  VS_FRAME :
				type = 4;
				vod_mute[group] = true ;
				break ;
			default :
				type = 0;speed = 0;
				vod_mute[group] = false ;
				break ;
		}

		avtcp[group]->set_play_mode(rspeed) ;
		ULONG id = avtcp[group]->get_vod_id();
		if(!id)	return;
		
		unsigned char cmdbuf[10];

		cmdbuf[0] = 0;
		cmdbuf[1] = type;
		cmdbuf[2] = speed;

		send_vodcmd_data(group, NETCOM_VOD_RECFILE_CTL, (char*)cmdbuf, 3);  
}

//##ModelId=3F9A1D230357
void net_cmdtcp::request_vod(ULONG rip, LONG rport,
						  const TREC_FILETIME* ft, 
						  VOD_CMD cmd, 
						  int group, 
						  VIDEO_CALLEE cb,BOOL bUdpav)
{
	if( cmd == VOD_REQ )
	{
		if(avtcp[group]->is_opened())
			return;

		if(get_vod_windows_counts(rip, rport) >= VOD_WINDOWS_COUNTS)
			return;

		avtcp[group]->set_cb(cb);
		nCurVodGroup[group] = group ;
		
	    if(!avtcp[group]->open_channel(rip, rport, VOD_GROUP,bUdpav))
			return;
		
		vod_group = group;
		nVodLostVideoNum[group] = nVodListRr[group] = nVodListWr[group] = 0 ;

		send_cmd_data(group, NETCOM_VOD_RECFILE_REQ, (char*)ft, sizeof(TREC_FILETIME));
		avtcp[group]->set_play_mode(VS_PLAYx1);
		avtcp[group]->shutdownsocket();
	}
	if( cmd == VOD_SET_SPEED )
	{	
		if(!avtcp[group]->is_vod())
			return;
		if( cb )
			POST_NOTIFY(cb, NTM_VOD_SET_SPEED, rip, rport);
		
		send_vodcmd_speed(group, rport);
	
	}
	if (cmd == VOD_END)
	{
		if(!avtcp[group]->is_vod())
			return;
	    
		close_vod(group) ;	
	}
}

//##ModelId=3F9A1D230393
void net_cmdtcp::start_local_record(int group, TCHAR drive)
{
	if (group == VOD_GROUP)
		group = vod_group ;
	avtcp[group]->lr_begin(drive);
}

//##ModelId=3F9A1D2303A7
void net_cmdtcp::stop_local_record(int group)
{
	if( group == VOD_GROUP )
		group = vod_group;
	
	avtcp[group]->lr_end();
}

//##ModelId=3F9A1D2303BB
void net_cmdtcp::get_local_record(int group, TCHAR* drive)
{
	if( group == VOD_GROUP )
		group = vod_group;

	avtcp[group]->lr_get_drive(drive);
}

//##ModelId=3F9A1D2303CF
void net_cmdtcp::start_talk(IPPORT,int channel, BACKUP_CALLEE cb)
{	
	dbit ddit = find_bak_talk_inf(rip, rport, talk_list);
	if(ddit)
		return ;

	net_bktcp *p = new net_bktcp ;
	if(!p->create(rip, rport))
	{
		delete p;
		return;
	}

	talkcb = cb ;
	p->set_bkcb(cb);
	p->m_send_buf.ClearAudioBuffer();

	if(!m_psoundtcp.is_record()) 
		m_psoundtcp.Start();
	
	insert_bak_talk_inf(rip, rport, p, talk_list);

	char chnlstr[1] = {(char)channel};
	send_cmd_bak(rip, rport, NETCOM_TALK_REQ, chnlstr, 1, talk_list) ;

	POST_NOTIFY(talkcb, NTM_TALK_BEGIN, rip, rport);
}

void net_cmdtcp::stop_talk(ULONG rip, USHORT rport)
{
	send_cmd_bak(rip, rport, NETCOM_TALK_END, NULL, 0, talk_list) ;
	delete_bak_talk_inf(rip, rport, talk_list, true) ;
}

void net_cmdtcp::get_disk_info(ULONG rip, ULONG rport)
{
	send_cmd(rip, rport, NETCOM_GET_DISKINFO, NULL, 0) ;
}

void net_cmdtcp::start_backup(ULONG rip, USHORT rport, TREC_BACKUPTIME* opt, BACKUP_CALLEE cb)
{
	dbit ddit = find_bak_talk_inf(rip, rport, bak_list);
	if(ddit)
		return ;

	net_bktcp *p = new net_bktcp ;
	if(!p->create(rip, rport))
	{
		delete p;
		return;
	}

	bkcb = cb ;
	p->set_bkcb(cb) ;
	p->set_path(opt->sBackDir) ;

	insert_bak_talk_inf(rip, rport, p, bak_list);
	send_cmd_bak(rip, rport, NETCOM_BACKUP_RECFILE_REQ, (char*)opt, 10, bak_list) ;
}

//##ModelId=3F9A1D240005
void net_cmdtcp::stop_backup(ULONG rip, USHORT rport)
{
	send_cmd_bak(rip, rport, NETCOM_BACKUP_STOP_REQ, NULL, 0, bak_list) ;
	delete_bak_talk_inf(rip, rport, bak_list, true) ;
	POST_NOTIFY(bkcb, NTM_BK_CANCELED, rip, rport);
}

//##ModelId=3F9A1D230339
void net_cmdtcp::mute(BOOL mute)
{
	if (mute)
		net_avtcp::mute();
	else
		net_avtcp::unmute();
}

kit net_cmdtcp::find_login(ULONG ip, USHORT port)
{
	for(kit bit = login_list.begin(); bit!= login_list.end(); bit++)
	{
		login_information & ref = *bit ;

		if(ref.ip == ip && ref.port == port)
			return bit;
	}
	return NULL;
}

void net_cmdtcp::insert_login(ULONG ip, USHORT port, ULONG id, PRIVILEGE priv)
{