net.cpp

实时监控

#include "stdafx.h"
#include "net.h"
#include "net_cmd.h"
#include "net_cmdtcp.h"
#include "net_factory.h"
#include "string"
#include "../mulapi.h"
#include "../decoder/g722/g722player.h"
#include "reg.h"
#include "net_query.h"
#include "../NetDef.h"

#define IPPORT_TYPE ULONG ip, USHORT port

#define ALLGROUPCOUNTS 256
FILE   *fppppp = NULL ;

ULONG use_mpeg4 = 0 ;
BOOL m_lost_jump_frame = 0;
USHORT network_bindport = 10000;
BOOL m_decode_data_bool = TRUE;

net_cmd	*		udpcmd = NULL; 
net_cmdtcp	*	tcpcmd = NULL;
net_factory *   ctlcmd = NULL;
net_query*		brodcast = NULL;

BOOL port_type[MAX_PORT];
int  start_port;
LPCTSTR rkSettings = _T("Settings");
LPCTSTR rvBindPort = _T("BindPort");

#define TRANS_CHECK_CMD_PRO1(x,y)				if(ctlcmd) { if(ctlcmd->find_network_type(x)) udpcmd->y; else tcpcmd->y;}
#define TRANS_CHECK_CMD_PRO2(x1,x2,y)			if(ctlcmd) { if(ctlcmd->find_network_type(x1,x2)) udpcmd->y; else tcpcmd->y;}
#define TRANS_CHECK_CMD_RETURN_PRO1(x,y)		if(ctlcmd) { if(ctlcmd->find_network_type(x)) return udpcmd->y; else return tcpcmd->y;} 
#define TRANS_CHECK_CMD_RETURN_PRO2(x1,x2,y)	if(ctlcmd) { if(ctlcmd->find_network_type(x1,x2)) return udpcmd->y; else return tcpcmd->y;} 

extern "C" {
NET_HANDLE WINAPI net_create(IPPORT_TYPE, CMD_CALLEE cb, ULONG Mpeg4, BOOL jump_frame, BOOL network_type = TRUE)
{
	fppppp = fopen("info.txt", "wt") ;
	fprintf(fppppp, "Init client sdk...\n") ;
	
	ZeroMemory(&port_type,MAX_PORT);
	start_port = 0;
	start_port = read_dword(rkSettings,rvBindPort,0);

	udpcmd = new net_cmd; 
	if(!udpcmd || !udpcmd->create(ip, port, cb))
		return NULL;

	tcpcmd = new net_cmdtcp;
	if(!tcpcmd || !tcpcmd->create(ip, port, cb))
	{
		udpcmd->destroy();
		delete udpcmd; udpcmd = NULL;
		return NULL;
	}
	
	ctlcmd = new net_factory;
	if(!ctlcmd || !ctlcmd->create())
	{
		udpcmd->destroy(); tcpcmd->destroy(); 
		delete udpcmd; delete tcpcmd;
		udpcmd = NULL; tcpcmd = NULL; ctlcmd = NULL;
		return NULL;
	}

	use_mpeg4 = Mpeg4;
	m_lost_jump_frame = jump_frame;
	
	InitPlayerSound() ;
	initmultidec() ; 

	return (NET_HANDLE)udpcmd;
}

VOID WINAPI set_lost_frame_jump(BOOL jump_frame)
{
	m_lost_jump_frame = jump_frame;
}


VOID WINAPI net_destroy(NET_HANDLE h)
{
	if(udpcmd)
	{
		udpcmd->destroy();
		delete udpcmd;
		udpcmd = NULL;
	}
	if(tcpcmd)
	{
		tcpcmd->destroy();
		delete tcpcmd;
		tcpcmd = NULL;
	}
	if(ctlcmd)
	{
		ctlcmd->destroy();
		delete ctlcmd;
		ctlcmd = NULL;
	}

	if(brodcast)
	{
		brodcast->destroy();
		delete brodcast;
		brodcast = NULL;
	}

	if (fppppp)	 {
		fprintf(fppppp, "Exit client sdk...\n") ;
		fclose(fppppp) ;
	}
	ExitPlayerSound() ;
	exitmultidec() ;
}

VOID WINAPI net_login(NET_HANDLE h, IPPORT_TYPE, LPCTSTR user, LPCTSTR password)
{
	if(ctlcmd)
		ctlcmd->login_net(ip, port, user, password);
}

PRIVILEGE WINAPI net_get_privilege(NET_HANDLE h, ULONG ip, USHORT port)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip,port, get_privilege(ip, port));
}

VOID WINAPI net_logout(NET_HANDLE h, ULONG ip, USHORT port, BOOL close_remote)
{
	TRANS_CHECK_CMD_PRO2(ip, port,logout(ip, port, close_remote));
}

VOID WINAPI net_open_remote_channel(NET_HANDLE h, 
									IPPORT_TYPE, 
									int channel, 
									int group, 
									VIDEO_CALLEE cb,
									BOOL bUdpav)
{
	if(ctlcmd) 
	{ 
		if(ctlcmd->find_network_type(ip,port)) 
			udpcmd->open_remote_channel(ip,port, channel, group, cb); 
		else tcpcmd->open_remote_channel(ip,port, channel, group, cb,bUdpav);
	}
//	TRANS_CHECK_CMD_PRO2(ip, port,open_remote_channel(ip, port, channel, group, cb));
}

VOID WINAPI net_close_remote_channel(NET_HANDLE h, int group)
{
	TRANS_CHECK_CMD_PRO1(group, close_remote_channel(group));
}

VOID WINAPI net_get_disk_info(NET_HANDLE h, ULONG ip, LONG port)
{
	TRANS_CHECK_CMD_PRO2(ip, port, get_disk_info(ip, port));
}

VOID WINAPI net_update_window(NET_HANDLE h, int group)
{
	TRANS_CHECK_CMD_PRO1(group,update_window(group));
}

LONG WINAPI net_get_audio_group(NET_HANDLE h)
{
	if(udpcmd)
	{
		return udpcmd->get_audio_group();
	}
	else if(tcpcmd)
	{
		return tcpcmd->get_audio_group();
	}
}
VOID WINAPI net_switch_audio(NET_HANDLE h, int group)
{
	TRANS_CHECK_CMD_PRO1(group, switch_audio(group));
}

VOID WINAPI net_mute_audio(NET_HANDLE h, BOOL mute)
{
	if(udpcmd)
	{
		udpcmd->mute(mute);
	}
	else if(tcpcmd)
	{
		tcpcmd->mute(mute);
	}
}

/*
VOID net_join_channel(NET_HANDLE h, IPPORT_TYPE, int channel)
{
	TRANS_HANDLE;
	cmd->open_remote_channel(ip, port, channel);
}
*/

VOID WINAPI net_close_local_channel(NET_HANDLE h, int group)
{
	TRANS_CHECK_CMD_PRO1(group, close_local_channel(group));
}

VOID WINAPI net_set_options(NET_HANDLE h, IPPORT_TYPE, 
							NET_OPTIONS opt, void* stuff, OPT_SET_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip, port, set_option(ip, port, opt, stuff, cb));
}

VOID WINAPI net_get_options_file(NET_HANDLE h, ULONG ip, USHORT port, 
							byte * m_byte, OPT_GET_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip, port, get_options_file(ip, port, m_byte, cb));
}

VOID WINAPI net_get_options(NET_HANDLE h, IPPORT_TYPE, 
							NET_OPTIONS opt, int channel, OPT_GET_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip, port, get_option(ip, port, opt, channel, cb));
}

VOID WINAPI net_start_vod(NET_HANDLE h, IPPORT_TYPE, 
						  const TREC_FILETIME* ft, int group, VIDEO_CALLEE cb)
{
	if(ctlcmd) 
	{ 
		if(ctlcmd->find_network_type(ip,port)) 
			udpcmd-> request_vod(ip, port, ft, VOD_REQ, group, cb); 
		else tcpcmd-> request_vod(ip, port, ft, VOD_REQ, group, cb, FALSE);
	}
//	TRANS_CHECK_CMD_PRO2(ip, port, request_vod(ip, port, ft, VOD_REQ, group, cb));
}

VOID WINAPI net_stop_vod(NET_HANDLE h,ULONG ip, USHORT port, int group)
{
	if(ctlcmd) 
	{ 
		if(ctlcmd->find_network_type(ip,port)) 
			udpcmd-> request_vod(ip, port, NULL, VOD_END, group, NULL); 
		else tcpcmd-> request_vod(ip, port, NULL, VOD_END, group, NULL, FALSE);
	}
//	TRANS_CHECK_CMD_PRO2(ip, port, request_vod(ip, port, NULL, VOD_END, group, NULL));
}

VOID WINAPI net_set_vod_mul_speed(NET_HANDLE h,ULONG ip, VOD_SPEED vs,int group)
{
	if(ctlcmd)
	{
		if(ctlcmd->find_network_type(group)) 
			udpcmd-> request_vod(ip, vs, NULL, VOD_SET_SPEED,group,NULL); 
		else tcpcmd-> request_vod(ip, vs, NULL, VOD_SET_SPEED,group,NULL, FALSE);
	}
//	TRANS_CHECK_CMD_PRO1(group, request_vod(ip, vs, NULL, VOD_SET_SPEED,group,NULL));
} 

VOID WINAPI net_set_vod_speed(NET_HANDLE h, VOD_SPEED vs)
{
	//TRANS_CHECK_CMD_PRO(group, request_vod(speed, 0, NULL, VOD_SET_SPEED, 0, NULL));
}

VOD_SPEED WINAPI net_get_vod_speed(NET_HANDLE h,ULONG ip,int group)
{
	TRANS_CHECK_CMD_RETURN_PRO1(group, get_vod_speed(ip,group));
}

VOID WINAPI net_start_local_record(NET_HANDLE h, int group, TCHAR drive)
{
	TRANS_CHECK_CMD_PRO1(group, start_local_record(group, drive));
}

VOID WINAPI net_stop_local_record(NET_HANDLE h, int group)
{
	TRANS_CHECK_CMD_PRO1(group, stop_local_record(group));
}

TCHAR WINAPI net_get_local_record(NET_HANDLE h, int group)
{
	TCHAR drive = 0;
	TRANS_CHECK_CMD_PRO1(group, get_local_record(group, &drive));
	return drive;
}

VOID WINAPI net_start_backup(NET_HANDLE h, IPPORT_TYPE, 
							 TREC_BACKUPTIME* opt, BACKUP_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip, port, start_backup(ip, port, opt, cb));
}

VOID WINAPI net_stop_backup(NET_HANDLE h, IPPORT_TYPE)
{
	TRANS_CHECK_CMD_PRO2(ip, port, stop_backup(ip, port));
}

VOID WINAPI net_start_talk(NET_HANDLE h, IPPORT_TYPE, 
							 int channel, BACKUP_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip, port, start_talk(ip, port, channel, cb));
}

VOID WINAPI net_stop_talk(NET_HANDLE h, IPPORT_TYPE)
{
	TRANS_CHECK_CMD_PRO2(ip, port, stop_talk(ip, port));
}
/*
#ifdef INCL_JPEG
#include "../net_utils.h"
#include "../jpg/jpeg.h"
ULONG WINAPI net_compress_jpg(void* buf, int w, int h, LPCTSTR jpgfile ) 
{
	jpeg_opt jo;
	jo.in_buf = buf;
	jo.bitcount = 16;
	jo.w = 352;
	jo.h = 288;
	jo.st = stYUY2;
	jo.t = to_file;
	jo.tgt.file = (void*)(LPCTSTR)jpgfile;
	jo.size = 352*288*2;
	jo.quality = 80;

	recursive_create_dir(jpgfile);

	return compress_jpeg(&jo);
}
#else
*/
LONG WINAPI net_snapshot(NET_HANDLE h, int group, LPCTSTR bmpfile)
{
	TRANS_CHECK_CMD_RETURN_PRO1(group, snapshot(group, bmpfile));
}

VOID WINAPI net_set_color_space(NET_HANDLE h, COLOR_SPACE cs, BOOL video_mem)
{
	if(udpcmd)
	{
		udpcmd->set_video_renderer(cs, video_mem);
	}
	if(tcpcmd)
	{
		udpcmd->set_video_renderer(cs, video_mem);
	}
}

#define WIDTH	352
#define HEIGHT	288
#include "yuv_mmx.h"
VOID WINAPI yv12_to_rgb24(void* yv12, void* rgb24)
{
	byte* y = (byte*)yv12;
	byte* u = y + WIDTH*HEIGHT;
	byte* v = u + WIDTH/2*HEIGHT/2;
	int ys = WIDTH;
	int uvs = WIDTH/2;
	int w = WIDTH;
	int hi = HEIGHT;
	yv12_to_rgb24_mmx((byte*)rgb24, w, y, v, u, ys, uvs, w, hi);
}
VOID WINAPI yv12_to_rgb32(void* yv12, void* rgb32)
{
	byte* y = (byte*)yv12;
	byte* u = y + WIDTH*HEIGHT;
	byte* v = u + WIDTH/2*HEIGHT/2;
	int ys = WIDTH;
	int uvs = WIDTH/2;
	int w = WIDTH;
	int hi = HEIGHT;
	yv12_to_rgb32_mmx((byte*)rgb32, w, y, v, u, ys, uvs, w, hi);
}
BOOL WINAPI net_is_muted(NET_HANDLE h)
{
	if(udpcmd)
	{
		return udpcmd->is_muted();
	}
	if(tcpcmd)
	{
		return tcpcmd->is_muted();
	}
}

VOID WINAPI  clear_alarm(NET_HANDLE h, ULONG ip, USHORT port)
{
	TRANS_CHECK_CMD_PRO2(ip, port, clear_alarm(ip,port));
}

VOID WINAPI net_get_zh_decstate(NET_HANDLE h, ULONG ip, LONG port, int address)
{
	TRANS_CHECK_CMD_PRO2(ip, port, get_zh_decstate(ip, port, address));
}

ULONG WINAPI net_get_host_by_name(NET_HANDLE h, LPCTSTR m_name)
{
	if(udpcmd)
	{
		return udpcmd->get_host_by_name(m_name);
	}
	if(tcpcmd)
	{
		return tcpcmd->get_host_by_name(m_name);
	}
}

VOID WINAPI net_set_network_begin_port(NET_HANDLE h, USHORT port)
{
	network_bindport = port;
}


BOOL WINAPI SetEncodeStreamProdCallBack(NET_HANDLE h, int group, PCALLBACKSTREAMPROD  p, DWORD duser1, DWORD duser2)
{
	if (group < 0 || group >= ALLGROUPCOUNTS)
		return FALSE;

	if(udpcmd)
	{
		return udpcmd->set_callbackfn(group, p,  duser1, duser2);
	}
	if(tcpcmd)
	{
		return tcpcmd->set_callbackfn(group, p,  duser1, duser2);
	}

	return FALSE ;
}

BOOL WINAPI SetDecodedStreamProdCallBack(NET_HANDLE h, int group, PCALLBACKDECODEDSTREAMPROD  p, DWORD duser1, DWORD duser2)
{
	if (group < 0 || group >= ALLGROUPCOUNTS)
		return FALSE;

	if(udpcmd)
	{
		return udpcmd->set_decodedcallbackfn(group, p,  duser1, duser2);
	}
	if(tcpcmd)
	{
		return tcpcmd->set_decodedcallbackfn(group, p,  duser1, duser2);
	}

	return FALSE ;
}

BOOL WINAPI SetEncodeStreamShowHandle(NET_HANDLE h, int group, VIDEO_CALLEE ImageHandle)
{
	if (group < 0 || group >= ALLGROUPCOUNTS)
		return FALSE;

	if(udpcmd)
	{
		return udpcmd->set_cb_showhandle(group, ImageHandle);
	}
	if(tcpcmd)
	{
		return tcpcmd->set_cb_showhandle(group, ImageHandle);
	}

	return FALSE ;
}

BOOL WINAPI SetDrawAddImageCallBack(NET_HANDLE h, int group, pDraw_Add_Image pimage, DWORD duser1, DWORD duser2)
{
	if (group < 0 || group >= ALLGROUPCOUNTS)
		return FALSE;

	if(udpcmd)
	{
		return udpcmd->setdrawaddimagecallback(group, pimage, duser1, duser2);
	}
	if(tcpcmd)
	{
		return tcpcmd->setdrawaddimagecallback(group, pimage, duser1, duser2);
	}

	return FALSE ;
}

BOOL WINAPI open_alarm_server(NET_HANDLE h, USHORT bindport)
{
	if(udpcmd)
	{
		return udpcmd->open_alarm_server(bindport);
	}
	return FALSE;
}

BOOL WINAPI close_alarm_server(NET_HANDLE h)
{
	if(udpcmd)
	{
		return udpcmd->close_alarm_server();
	}
	return FALSE;
}

BOOL WINAPI SetDvrUpdateStatue(NET_HANDLE h, ULONG ip, LONG port)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, set_update_statue(ip, port));
}

BOOL WINAPI SetDvrNetClubInfo(NET_HANDLE h, ULONG ip, LONG port, void *buf, int len)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, set_netclub_info(ip, port, buf, len));
}

BOOL WINAPI SetDvrRESTART(NET_HANDLE h, ULONG ip, LONG port)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, set_dvrrestart(ip, port));
}

BOOL WINAPI net_sendcardid(NET_HANDLE h, ULONG ip, LONG port, void *buf)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, sendcardid(ip, port, buf));
}

BOOL WINAPI net_opennet_alarm(NET_HANDLE h, ULONG ip, LONG port, int channel)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, opennet_alarm(ip, port, channel));
}

BOOL WINAPI net_closenet_alarm(NET_HANDLE h, ULONG ip, LONG port, int channel)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, closenet_alarm(ip, port, channel));
}

BOOL WINAPI net_openalarm_output(NET_HANDLE h, ULONG ip, USHORT port, int output)
{
	TRANS_CHECK_CMD_RETURN_PRO2(ip, port, openalarm_output(ip, port, output));
}

VOID WINAPI net_set_decode_data(BOOL m_bool)
{
    m_decode_data_bool = m_bool;
}

UINT WINAPI net_get_bitrate(NET_HANDLE h,int group)
{
	if (group < 0 || group >= ALLGROUPCOUNTS)
		return FALSE;
	TRANS_CHECK_CMD_RETURN_PRO1(group, get_bitrate(group));
}

UINT WINAPI net_get_tcp_bitrate(NET_HANDLE h)
{
	return tcpcmd->tcp_get_bitrate();
}

UINT WINAPI net_get_udp_bitrate(NET_HANDLE h)
{
	return udpcmd->udp_get_bitrate();
}

VOID WINAPI net_get_options_backup_file(NET_HANDLE h, ULONG ip, USHORT port, 
										byte * m_byte, OPT_GET_CALLEE cb)
{
	TRANS_CHECK_CMD_PRO2(ip,port,get_options_backup_file(ip, port, m_byte, cb));
}

VOID WINAPI net_query_dvr(CMD_CALLEE cb)
{
	if(!brodcast)
	{
		brodcast = new net_query;
		if(!brodcast || !brodcast->create(cb))
		{
			brodcast->destroy();
			delete brodcast; brodcast = NULL;
			return ;
		}
	}
	
	unsigned char cmdbuf[20];

	memset(cmdbuf,0,20);
	
	cmdbuf[0] = 'S';
	cmdbuf[1] = 'D';
	cmdbuf[2] = 'V';
	cmdbuf[3] = 'R';

	cmdbuf[10] = NETCOM_SEARCH_PCTDVR;
	
	cmdbuf[8] = 1;
	cmdbuf[9] = 1>>8;
	brodcast->send_something((char *)cmdbuf, 11);
}

};
//#endif	// INCL_JPEG