net_cmdtcp.cpp

实时监控

#include "stdafx.h"
#include "net_cmdtcp.h"
#include "../NetDef.h"
#include "net_avtcp.h"
#include "../thrd/thrd_decoder.h"
#include "../decoder/g722/G722Player.h"
#include "../../AudioRCVtcp.h"
#include "../notif/notif_alarm.h"
#include "net_factory.h"
#include "ip_port.h"

extern FILE  *fppppp ;
#define vod_window			256
extern int	  nvodtype[vod_window];
extern int    nCurVodGroup[vod_window], nVodLostVideoNum[vod_window] ;
extern unsigned char   nVodDelayList[10][vod_window] ;
extern unsigned char   nVodListRr[vod_window], nVodListWr[vod_window] ;

extern PCALLBACKSTREAMPROD pcallback[vod_window];
extern PCALLBACKDECODEDSTREAMPROD pdecodedcallback[vod_window];
extern pDraw_Add_Image     pdrawcallback[vod_window];

extern DWORD pcallback_user1[vod_window], pcallback_user2[vod_window];
extern DWORD pdecodedcallback_user1[vod_window], pdecodedcallback_user2[vod_window];
extern DWORD pdrawcallback_user1[vod_window], pdrawcallback_user2[vod_window];

CSoundintcp m_psoundtcp;

#define HEADER_SIZE	4
#define ID_SIZE		4
#define LEN_SIZE	2
#define CMD_SIZE	1

#define CMD_POS		10
#define DATA_POS	11

#define LOCAL_PORT	8101
#define REMOTE_PORT	8102

#define CMD_OF(x) ((x)[CMD_POS])
#define DATA_OF(x) ((x)+DATA_POS)

#define IPPORT ULONG rip, USHORT rport
#define IPP rip, rport

#define SAFE_DELETE(x) {delete (x); (x)=NULL;}

#define is ==
#define isnot !=

extern void shift(SHORT& s);
extern NET_OPTIONS trans_net_com(DWORD netcom);
extern USHORT trans_camera_cmd(CAMERA_CMD ccmd);
extern PRIVILEGE get_login_station_version(int m_id);

#define vod_interval_pal	40
#define vod_interval_ntsc	33
 
#define VOD_WINDOWS_COUNTS  8	
extern bool vod_mute[vod_window] ;
extern int time_vod_nub ;

extern net_factory *   ctlcmd;

bool is_cmd_data(byte* buf)
{
	if(buf[0] == 'S' && buf[1] == 'D')
		if(buf[2] == 'V' && buf[3] == 'R')
			return true;

	return false;
}

void set_cmdtcp_header(unsigned char* cmdbuf)
{
	cmdbuf[0] = 'S';
	cmdbuf[1] = 'D';
	cmdbuf[2] = 'V';
	cmdbuf[3] = 'R';
}

void set_idtcp(ULONG id, unsigned char * cmdbuf )
{
	cmdbuf[4] = id;
	cmdbuf[5] = id >> 8;
	cmdbuf[6] = id >> 16;
	cmdbuf[7] = id >> 24;
}

void set_cmdtcp(unsigned char* cmdbuf, char cmd)
{
	cmdbuf[CMD_POS] = cmd;
}

int set_datatcp(unsigned char* cmdbuf, const char* data, int datalen )
{
	cmdbuf[8] = datalen +1;
	cmdbuf[9] = (datalen +1)>>8;
	if( data )
	{
		memcpy(cmdbuf + DATA_POS, data, datalen);
		return datalen;
	}
	return 0;
}
//##ModelId=3F9A1D230162


DWORD CALLBACK shake_hand_tcp(LPVOID dwUser)
{
	net_cmdtcp* cmd = (net_cmdtcp*)dwUser;
	if(!cmd) return 0;
	while(1)
	{
		if(cmd->shake_exit)
			break;
		cmd->tcp_bitrate = 0;
		for(int i=0;i<vod_window;i++)
		{
			cmd->avtcp[i]->bitrate = 0;
			if(cmd->avtcp[i]->is_opened())
			{
				cmd->avtcp[i]->bitrate_1 = cmd->avtcp[i]->bitrate_2;
				cmd->avtcp[i]->bitrate_2 = cmd->avtcp[i]->bitrate_3;
				cmd->avtcp[i]->bitrate_3 = cmd->avtcp[i]->bitrate_4;
				cmd->avtcp[i]->bitrate_4 = cmd->avtcp[i]->bits;
				cmd->avtcp[i]->bitrate = (cmd->avtcp[i]->bitrate_1 + cmd->avtcp[i]->bitrate_2
					+ cmd->avtcp[i]->bitrate_3+ cmd->avtcp[i]->bitrate_4)>>2;// >>2 ＝ ÷4;
				cmd->avtcp[i]->bits = 0;
			}
			cmd->tcp_bitrate += cmd->avtcp[i]->bitrate;
		}
		POST_NOTIFY(cmd->cmdcb, NTM_REFRESH_BITRATE, NULL, NULL);
		cmd->shake_hand();
		Sleep(1000);
	}
	return 0;
}

bool net_cmdtcp::creat_shakehand_thread()
{
	unsigned long id ;

	shake_handle = CreateThread(NULL, 0, shake_hand_tcp, this,	0, &id) ;
	if (!shake_handle)  
		return false;

	SetThreadPriority(shake_handle, THREAD_PRIORITY_NORMAL) ;
	return true;
}

void net_cmdtcp::close_shake_handle()
{
	shake_exit = true;
	if(!shake_handle) return;

	WaitForSingleObject(shake_handle, INFINITE) ;
	CloseHandle(shake_handle);
	shake_handle = NULL;
}


void net_cmdtcp::shake_hand()
{
	if (login_list.empty())
		return ;
	
	for (kit it = login_list.begin(); it != login_list.end(); it++)  
	{
		login_information ref = *it ;
		ULONG channels = send_open_channel(ref.ip, ref.port);
        
		unsigned char portinfo[14];
		portinfo[12] = channels & 0x00ff;
		portinfo[13] = channels >> 8;
		send_cmd(ref.ip, ref.port, NETCOM_SHAKE_HAND, (char *)portinfo, 14);	
	}
}

ULONG net_cmdtcp::send_open_channel(IPPORT)
{
	ULONG m_channels = 0;

     for( int i=0; i<max_channel; i++ )
	 {
		if(!avtcp[i]) continue;

		if( avtcp[i]->svr_ip() == rip && avtcp[i]->svr_port() == rport && avtcp[i]->svr_chnl() != VOD_GROUP)
		{
			m_channels = m_channels | operation_btye(avtcp[i]->svr_chnl());
		}

	 }
	 return m_channels;
}

ULONG net_cmdtcp::operation_btye(int m)
{
	ULONG k = 1;
	return k<<m;
}

//##ModelId=3F9A1D23013A

void net_cmdtcp::send_cmd(ULONG rip, USHORT rport, char cmd, const char* data, int datalen)
{
	int buflen = 0;
	unsigned char cmdbuf[100];
	
	set_cmdtcp_header(cmdbuf);			buflen += HEADER_SIZE;

	kit kkit = find_login(rip, rport);
	if(!kkit)return;

	set_idtcp(kkit->m_id, cmdbuf);		

	set_cmdtcp(cmdbuf, cmd);			buflen += CMD_SIZE;

	buflen += LEN_SIZE;	buflen += ID_SIZE;

	buflen += set_datatcp(cmdbuf, data, datalen);
	
	if(kkit->p)
		kkit->p->send_something((char *)cmdbuf, buflen);	
}

void net_cmdtcp::send_cmd_data(int group, char cmd, const char* data, int datalen)
{
	int buflen = 0;
	unsigned char cmdbuf[100];
	
	kit kkit = find_login(avtcp[group]->svr_ip(), avtcp[group]->svr_port());
	if(!kkit)
		return;

	set_cmdtcp_header(cmdbuf);			buflen += HEADER_SIZE;
	set_idtcp(kkit->m_id, cmdbuf);		buflen += ID_SIZE;

	set_cmdtcp(cmdbuf, cmd);			buflen += CMD_SIZE;
	buflen += LEN_SIZE;

	buflen += set_datatcp(cmdbuf, data, datalen);

	avtcp[group]->send_something((char *)cmdbuf, buflen) ;
}

void net_cmdtcp::send_cmd_bak(ULONG rip, USHORT rport, char cmd, const char* data, int datalen,  bak_talk_list & list)
{
	int buflen = 0;
	unsigned char cmdbuf[100];
	
	kit kkit = find_login(rip, rport);
	if(!kkit)
		return;

	dbit ddit = find_bak_talk_inf(rip, rport, list);
	if(!ddit)
		return;

	set_cmdtcp_header(cmdbuf);			buflen += HEADER_SIZE;
	set_idtcp(kkit->m_id, cmdbuf);		buflen += ID_SIZE;

	set_cmdtcp(cmdbuf, cmd);			buflen += CMD_SIZE;
	buflen += LEN_SIZE;

	buflen += set_datatcp(cmdbuf, data, datalen);

	ddit->p->send_something((char *)cmdbuf, buflen) ;
}
	
void net_cmdtcp::send_vodcmd_data(int group, char cmd, const char* data, int datalen)
{
	ULONG ip = avtcp[group]->svr_ip();
	USHORT port = avtcp[group]->svr_port();

	ULONG id = avtcp[group]->get_vod_id();
	if(!id) return;

	unsigned char cmdbuf[50];
	int length = 0;

	cmdbuf[0] = id;
	cmdbuf[1] = id >> 8;
	cmdbuf[2] = id >> 16;
	cmdbuf[3] = id >> 24;
	length += 4;
	
	memcpy(cmdbuf+length, data, datalen);
	length += datalen;

	send_cmd(ip, port, cmd, (char *)cmdbuf, length);
}

void net_cmdtcp::close_vod(int group)
{
	if(!avtcp[group]->is_vod())
		return ;

	pcallback[group] = NULL;
	pdrawcallback[group] = NULL;

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

	pdrawcallback_user1[group] = 0;
	pdrawcallback_user2[group] = 0;
	send_vodcmd_data(group, NETCOM_VOD_RECFILE_END, NULL, 0);

	avtcp[group]->leave();
	nVodLostVideoNum[group] = nVodListRr[group] = nVodListWr[group] = 0 ;
}

void net_cmdtcp::close_vod()
{
	vod_group = -1 ;
	for(int i=0;i<max_channel;i++)
	{
		nCurVodGroup[i] = -1 ;
		avtcp[i]->destroy();
	}
}

//////////////////////////////////////////////////////////////////////////
// 网络初始化

net_cmdtcp * net_cmdtcp::m_netcmdp = NULL;

net_cmdtcp::net_cmdtcp():  bkcb(NULL) ,vod_group(-1), 
last_group(0), cmdcb(NULL), shake_exit(false)
{
	m_netcmdp = this;
	palarmserver = NULL;
	tcp_bitrate = 0;
	for( int i=0; i<max_channel; i++ )
	{
		avtcp[i] = new net_avtcp(i) ;
		vod_mute[i] = false ;
	}
}

//##ModelId=3F9A1D230217
net_cmdtcp::~net_cmdtcp()
{
	destroy();

	for(int i=0; i<max_channel; i++)
	{
		SAFE_DELETE(avtcp[i]);
	}
	
}


UINT net_cmdtcp::get_bitrate(int group)
{
	return avtcp[group]->bitrate;
}

UINT net_cmdtcp::tcp_get_bitrate()
{
	return tcp_bitrate;
}

//##ModelId=3F9A1D230221
BOOL net_cmdtcp::create(IPPORT, CMD_CALLEE cb)
{
	cmdcb = cb ;
	if(!creat_shakehand_thread())
		return false;

	return true;
}

// 网络注销
void net_cmdtcp::destroy()
{
	extern timer dec_pal_timer;
	extern timer dec_nst_timer;
	dec_pal_timer.stop();
	dec_nst_timer.stop();
	
	for(kit bbit = login_list.begin(); bbit!= login_list.end(); bbit++)
	{
		login_information & ref = *bbit ;
		if(delete_login(ref.ip, ref.port))
			bbit--;
	}

	for(dbit bit = bak_list.begin(); bit != bak_list.end(); bit++)
	{
		bak_talk_information & ref = *bit ;
		if(delete_bak_talk_inf(ref.ip, ref.port, bak_list, true))
			bit--;
	}

	for(bit = talk_list.begin(); bit != talk_list.end(); bit++)
	{
		bak_talk_information & ref = *bit ;
		if(delete_bak_talk_inf(ref.ip, ref.port, talk_list, true))
			bit--;
	}
	
	close_alarm_server();
	close_vod();
	close_shake_handle();
	m_netcmdp = NULL;		
}

// 登录
//##ModelId=3F9A1D230249

BOOL net_cmdtcp::login(IPPORT,LPCTSTR user, LPCTSTR password)
{
	unsigned char logstr[100];

	int m_userlen = strlen(user);
	int m_passlen = strlen(password);
	int m_length = m_userlen + m_passlen + 2;

	logstr[0] = m_userlen ;
	memcpy(logstr+1, user, m_userlen);

	logstr[m_userlen+1] = m_passlen ;
	memcpy(logstr + 2 + m_userlen, password, m_passlen);

	kit ppt = find_login(rip, rport);
	if(!ppt)
	{
		net_logintcp *p = new net_logintcp ;
		if(!p->create(rip, rport, LOCAL_PORT))
		{
			delete p;
			return FALSE;
		}
		
		insert_login(rip, rport, (ULONG)p);
	}

	send_cmd(rip, rport, NETCOM_LOGIN, (char*)logstr, m_length);
	return TRUE;
}

// 登出
//##ModelId=3F9A1D230267
BOOL net_cmdtcp::logout(IPPORT, BOOL close_remote)
{
	for( int i=0; i<max_channel; i++ )
	{
		if( avtcp[i]->svr_ip() == rip && avtcp[i]->svr_port() == rport )
		{
			close_remote_channel(i);
		}
	}

	send_cmd(rip, rport, NETCOM_LOGOUT, NULL, 0);
	delete_login(rip, rport);

	if(ctlcmd)
		ctlcmd->delete_nettype(rip, rport);

	POST_NOTIFY(cmdcb, NTM_CMD_LOGOUT_OK, rip, rport);
	return TRUE;
}

void net_cmdtcp::on_disconnect(ULONG ip, USHORT port)
{
	for( int i=0; i<max_channel; i++ )
	{
		if( avtcp[i]->svr_ip() == ip && avtcp[i]->svr_port() == port )
		{
			close_remote_channel(i);
		}
	}
	delete_login(ip, port);

	if(ctlcmd)
		ctlcmd->delete_nettype(ip, port);
	
	POST_NOTIFY(cmdcb, NTM_CMD_DISCONNECT_TIMEOUT, ip, port);
}

// 打开主机视频通道
//##ModelId=3F9A1D230285
BOOL net_cmdtcp::open_remote_channel(IPPORT, 
								  LONG channel_idx, 
								  LONG group, 
								  VIDEO_CALLEE cb,BOOL bUdpav)
{

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

	for( int i=0; i<max_channel; i++ )
	{
		if( !avtcp[i]->is_opened() )
			continue;

		ULONG ip = avtcp[i]->svr_ip();
		USHORT port = avtcp[i]->svr_port();
		int chnl = avtcp[i]->svr_chnl();
		
		if( ip == rip && port == rport && chnl == channel_idx )
		{
			return FALSE;
		}
	}
	
	avtcp[group]->set_cb(cb);