远程控制之原理和实战

已于 2023-08-14 13:40:42 修改
阅读量2.3k 收藏 31
点赞数 3
分类专栏： 数据结构和算法 软件开发 图形学 文章标签： windows 网络 图像处理
于 2023-06-12 00:33:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37567738/article/details/131150783
版权

按理来说，本人不该发表此类专业文章，鄙人零星碎片化的开发经历，让本人斗胆向诸位网友，在远控方面做一点演示说明，谈论一点自己的认识。

程序工程代码地址：点击此处下载。

程序分为两个部分，控制端和被控端，他们之间通过网络来连接和交互，其工作过程大体如下：

被控端每隔20毫秒截屏，图像经过压缩，通过tcp网络传输给控制端，控制端对接收到的视频帧实时刷新显示；被控端实时接收控制端的对屏幕的操作消息（主要是键盘的按键、鼠标的位置和动作等），并在本端模拟这些键盘鼠标操作。

控制端代码主要在RemoteControlRecver.cpp和RemoteControlListener.cpp中，被控端代码主要在RemoteControlProc.cpp和RemoteControl.cpp中。

程序是自己对远控的一点探索和demo演示，实现过程吻合本文思路，虽然离商用有很远距离，但从实际的使用效果看，已经具备了远控的基础功能和效果。

本文已经被看雪学院引用链接地址：

在这里插入图片描述

（一）原理

经典的远控，比如国外的TeamViewer、国内近几年出现的ToDesk，功能强大且精密复杂，但这并不说明它的高不可攀（远控软件，除非算法上的突破，无论理论和工程技术，恐怕都无法为设计开发者赢得博士学位），它的原理无非就是：将被控端的屏幕实时复制到主控端并保持刷新，主控端就像使用本地的屏幕一样，使用菜单、键盘输入、鼠标点击等视觉交互，主控端在该屏幕上的键盘和鼠标操作，通过网络传输给被控端，转化为被控端相应的键盘和鼠标操作。

当然这是极为简略的描述，实践中要考虑很多其他因素，比如对网络流量的考虑：如果每一帧画面都是截屏数据，要保证动画的连贯逼真，每秒至少要传输24帧以上的画面，每一帧画面如果采用24位真彩色、屏幕分辨率假定是最常用的1920x1080，此时，未压缩前的大小是6220800字节，压缩后一般最少也有150-200kb左右（压缩率跟画面的像素有关，一般来讲，常见的图像压缩算法，越是像素排列无规则、相对速度运动越快、变化率越大的像素值，压缩比越低），这时每秒的带宽压力要达到80M/b（10MB)以上，有些网络环境下，这是一个恐怖的数字，实际环境可能达不到，因此，如何压缩减少视频传输流量，提高控制反应速度和画面的丝滑控制，是此类软件的核心技术之一。

一般来说，要实现此类软件的敏捷开发，最快捷的方式是使用第三方开发包，比如大名鼎鼎的ffmpeg，此开发包中有多种方案可以实现高效的视频传输，如h264、h265协议接口，此类接口可以将传输数据减少1到2个数量级，实际测试数据流量在每秒几百kb甚至100kb/s，已经可以满足实际需要，但是，h264和h265的显示效果和网络流量的综合效果并不够优秀，从测试中发现，微软自带的远程控制软件mstsc.exe，在100kb以内的网速下，画面显示依然清晰、控制依然保持流畅，这就不是第三方开发包可以轻易达到的。另外此类第三方接口中没有键盘鼠标消息的处理，很多定制化需求不能被满足，还需要对开发包进一步定制和开发。

如果对第三方开发包不太满意，那就只有自己动手手撸代码了。

（二）实现细节

魔鬼隐藏在细节中。从经验上来说，就算很简单的理论描述，工程实践中也会有很多细节需要填坑夯实，理学在前挖坑，工程学在后填坑，这也许就是工程学（比如软件工程）存在的意义吧。

下面就是对思路的细节描述。

主控端的具体代码逻辑如下：
每一个被控客户端的远程连接，控制端需要创建两个线程，一个负责与被控端网络通信，一个负责窗口显示刷新和窗口消息。
网络通信线程有两个执行节点，一个节点是执行recv函数，接收被控端的截屏数据；另一个执行节点是执行send函数，发送显示窗口的键盘鼠标消息。窗口显示和消息处理线程主要是实时刷新和显示被控端的截屏，切入点是依靠窗口的WM_PAINT消息，每当网络通信线程接收到一帧截屏后会调用InvalidateRect（参数是显示窗口的HWND句柄），此时窗口程序会执行刷新过程。此线程另外一个功能是，捕获主控端的在显示窗口中的键盘鼠标消息，并存放在全局变量中，这样网络通信线程就可以读取和发送给被控端，被控端模拟点击和键盘输入，将收到的键盘鼠标消息转换为本地的键盘鼠标操作。

另外需要注意的是，两个线程中，资源申请和释放、连接控制等主要是在显示刷新窗口线程中完成的，在主控和被控之间因各种原因断开连接时，要保证所有的资源都有效释放。

两个线程共用的客户端结构体如下：


typedef struct {
	SOCKET					hSockClient;		//被控客户端socket
	sockaddr_in				stAddrClient;		//被控地址
	HWND					hwndWindow;			//窗口线程的窗口句柄，据此可以保存和找到该线程，并交互鼠标键盘消息
	char* lpClientBitmap;						//被控的屏幕像素地址
	char* dibits;								//被控像素处理内存缓冲
	int						bufLimit;			//像素地址块分配大小
	int						lpbmpDataSize;//像素实际大小
	int						dataType;	//像素块的类型，有两种，一种是截屏，一种是屏幕刷新值
	UNIQUECLIENTSYMBOL		unique;		//被控的信息
	STREMOTECONTROLPARAMS	param;		//被控的屏幕宽度高度位数等显示信息
}REMOTE_CONTROL_PARAM, * LPREMOTE_CONTROL_PARAM;

被控端程序比较简单，主要是在一个循环中，获取截屏数据，发送给控制端，然后接收控制端的键盘鼠标消息，并将这些键盘鼠标消息转换为本地的键盘鼠标消息。

代码中的api采用了函数指针的调用方式，去掉前面的lp前缀就可以理解了。主要的功能模块如下：

  1. 被控端截屏发送给控制端。从网上的资料来看，截屏功能的实现方法如下：

int GetScreenFrame(int ibits, char* szScreenDCName, int left, int top, int ScrnResolutionX, int ScrnResolutionY, char* lpBuf, char** lppixel, int* pixelsize) {

	int iRes = 0;

	HWND hwnd = lpGetDesktopWindow();

	HDC hdc = lpGetDC(hwnd);

	//HDC hdc = lpCreateDCA(szScreenDCName, 0, 0, 0);

	//HDC hdc = lpGetDC(0);
	if (hdc == 0)
	{
		writeLog("GetScreenFrame lpCreateDCA error:%d\r\n", GetLastError());
		return FALSE;
	}

	HDC hdcmem = lpCreateCompatibleDC(hdc);

	HBITMAP hbitmap = lpCreateCompatibleBitmap(hdc, ScrnResolutionX, ScrnResolutionY);

	lpSelectObject(hdcmem, hbitmap);

	iRes = lpBitBlt(hdcmem, 0, 0, ScrnResolutionX, ScrnResolutionY, hdc, 0, 0, SRCCOPY);

	if (hbitmap == 0)
	{
		lpReleaseDC(0, hdc);
		lpDeleteDC(hdcmem);
		lpDeleteObject(hbitmap);

		writeLog("GetScreenFrame lpCreateCompatibleBitmap error:%d\r\n", GetLastError());
		return FALSE;
	}

	int wbitcount = 0;
	if (ibits <= 1) {
		wbitcount = 1;
	}
	else if (ibits <= 4) {
		wbitcount = 4;
	}
	else if (ibits <= 8) {
		wbitcount = 8;
	}
	else if (ibits <= 16) {
		wbitcount = 16;
	}
	else if (ibits <= 24) {
		wbitcount = 24;
	}
	else {
		wbitcount = 32;
	}

	DWORD dwpalettesize = 0;
	if (wbitcount <= 8)
	{
		dwpalettesize = (1 << wbitcount) * sizeof(RGBQUAD);
	}

	DWORD dwbmbitssize = ((ScrnResolutionX * wbitcount + 31) / 32) * 4 * ScrnResolutionY;

	DWORD dwBufSize = dwbmbitssize + dwpalettesize + sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);

	LPBITMAPFILEHEADER bmfhdr = (LPBITMAPFILEHEADER)lpBuf;
	bmfhdr->bfType = 0x4d42;
	bmfhdr->bfSize = dwBufSize;
	bmfhdr->bfReserved1 = 0;
	bmfhdr->bfReserved2 = 0;
	bmfhdr->bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwpalettesize;

	LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)(lpBuf + sizeof(BITMAPFILEHEADER));
	lpbi->biSize = sizeof(BITMAPINFOHEADER);
	lpbi->biWidth = ScrnResolutionX;
	lpbi->biHeight = ScrnResolutionY;
	lpbi->biPlanes = 1;
	lpbi->biBitCount = wbitcount;
	lpbi->biCompression = BI_RGB;
	lpbi->biSizeImage = 0;
	lpbi->biXPelsPerMeter = 0;
	lpbi->biYPelsPerMeter = 0;
	lpbi->biClrUsed = 0;
	lpbi->biClrImportant = 0;

	char* lpData = lpBuf + sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + dwpalettesize;

	iRes = lpGetDIBits(hdcmem, hbitmap, 0, ScrnResolutionY, lpData, (BITMAPINFO*)lpbi, DIB_RGB_COLORS);

	lpDeleteDC(hdcmem);
	lpDeleteObject(hbitmap);
	lpReleaseDC(0, hdc);

	if (iRes == 0)
	{
		writeLog("lpGetDIBits error:%d\r\n", GetLastError());
		return FALSE;
	}

	*lppixel = lpData;
	*pixelsize = dwbmbitssize;
	return dwBufSize;
}

上面有几点需要啰嗦几句：
(1) windows上gdi二维图像api都是用DC句柄来实现的。测试发现，GetDC(0)等同于CreateDC(“display”,0, 0, 0)，也等同于GetDC(GetDesktopWindow())，这几种用法都是用来获取桌面的DC。

(2) CreateCompatibleBitmap函数中的HDC要使用桌面的HDC，而不能是新创建的内存hdcmem，这是一个隐蔽的知识盲点，microsoft的解释如下：
在这里插入图片描述
大意是，CreateCompatibleBitmap产生的hBitmap位图中的位数和颜色跟使用的hdc参数中的保持一致，而使用CreateCompatibleDC函数创建的HDC默认都是2位的位图。

(3) GetDIBits函数有文档中未指明的知识盲点。比如lpbi参数指向的BITMAPINFO，在8位256色模式下，要给调色板留下空间，调色板一般需要另外的1024字节大小的空间，否则调用此api会发生内存越界异常。另外，此函数如果不知道如何填写BITMAPINFO位图参数，可以在第一次调用时，lpData参数为空，调用后，函数会自动填充BITMAPINFO结构的参数，然后第二次调用此函数，即可得到相应参数的位图数据。

BITMAPINFO结构体定义如下：



typedef struct tagBITMAPINFOHEADER{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
} BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;

typedef struct tagBITMAPINFO {
    BITMAPINFOHEADER    bmiHeader;
    RGBQUAD             bmiColors[1];
} BITMAPINFO, FAR *LPBITMAPINFO, *PBITMAPINFO;

该函数的官方文档如下：
在这里插入图片描述
注意这里的描述，如果lpvBits参数有效，那么前6个参数必须初始化，并且扫描线的数值必须是Dword对齐。前6个参数是biSizeImage之前的6个参数，biSizeImage的计算比较复杂，不论位图的颜色深度是多少位，扫描线长度必须要4字节对齐。测试中还发现扫描线的行数并不需要dword对齐。

文档中说，函数调用时hbitmap参数不能被SelectObject选中，测试中发现，hbitmap即使已经被调用了SelectObject函数被选中，调用时也可以成功。

截图支持8位、16位、24位、32位颜色值，测试程序使用的16色。从视觉效果上，16位色跟24位，观看起来区别很小，特别是24位色（32位色相对于24位色只是增加了alpha值透明度），已经超过人的眼睛对颜色的识别程度的上限，再高的颜色值已经没有意义。由于传输的是像素值，而不是跟jpeg或者其他视频流算法中使用的近似压缩值（或者近似压缩块），所以画面的清晰度是很好的，这也是相比较于ffmpeg等第三方开发包使用h264、h265压缩视频流的优势。

另外，建议查看文档的英文版，中文版好多翻译不准确或者非常不严谨，长期依赖中文翻译，会导致开发水平得不到提高。

  1. 数据压缩传输。采用zip压缩，压缩参数设置为最大化压缩，压缩比估值大概是6-20倍。如果是8位的位图帧，分辨率1920x1080,每一帧压缩后大约是60-120KB；如果是16位，压缩后大约为100-300KB；32位的话，大约是150-600KB。当然这样的压缩比仍然难以满足实际需求，此文在第三个话题中会详细介绍如何减少视频流量，最终可以将网络流量降低到平均100KB/S。
  2. 控制端对截屏帧的显示刷新。主要代码如下：
		else if (mapit->second->dataType == REMOTE_CLIENT_SCREEN)
		{
			char* lpClientBitmap = mapit->second->lpClientBitmap;
			HDC  hdcScr = CreateDCA("DISPLAY", NULL, NULL, NULL);
			HDC hdcSource = CreateCompatibleDC(hdcScr);
			LPBITMAPFILEHEADER pBMFH = (LPBITMAPFILEHEADER)lpClientBitmap;
			void* pDibts = (void*)(lpClientBitmap + pBMFH->bfOffBits);
			LPBITMAPINFOHEADER pBMIH = (LPBITMAPINFOHEADER)(lpClientBitmap + sizeof(BITMAPFILEHEADER));
			DWORD dwDibtsSize = ((pBMIH->biWidth * pBMIH->biBitCount + 31) / 32) * 4 * pBMIH->biHeight;
			char* pRemoteSrnData = 0;
			HBITMAP hRemoteBM = CreateDIBSection(0, (LPBITMAPINFO)pBMIH, DIB_RGB_COLORS, (void**)&pRemoteSrnData, 0, 0);
			if (hRemoteBM)
			{
				memcpy(pRemoteSrnData, pDibts, dwDibtsSize);
				HBITMAP hSrcBM = (HBITMAP)SelectObject(hdcSource, hRemoteBM);

				int iX = pBMIH->biWidth;
				int iY = pBMIH->biHeight;
				RECT stRect = { 0 };
				int iRet = GetClientRect(hWnd, &stRect);
				//iRet = BitBlt(hdcDst, 0, 0, stRect.right - stRect.left, stRect.bottom - stRect.top,hdcSrc, 0, 0, SRCCOPY);
				iRet = StretchBlt(hdcDst, 0, 0, stRect.right - stRect.left, stRect.bottom - stRect.top, hdcSource, 0, 0, iX, iY, SRCCOPY);
				DeleteObject(hSrcBM);
			}
			else {
				WriteLog("RemoteControl CreateDIBSection error:%u\r\n", GetLastError());
			}

			DeleteObject(hRemoteBM);
			DeleteDC(hdcScr);
			DeleteDC(hdcSource);

			mapit->second->dataType = 0;

			EndPaint(hWnd, &stPS);
			return TRUE;
		}

代码中，lpClientBitmap指向接收到的内存中的bmp文件，调用CreateDIBSection函数是为了创建一个类似于此bmp文件格式和参数的hbitmap句柄后，然后将bmp文件的像素值拷贝到句柄指向的像素内存地址中，并使用StretchBlt将像素值显示在当前窗口中的客户区中，因为客户端和服务器的窗口大小可能不一样，所以使用StretchBlt实现缩放而不是BitBlt函数。
同时要注意，CreateDIBSection函数第一个参数为0，即相当于GetDC(0)，0代表桌面窗口的HDC，这点在官方文档中并未说明，但是可以直接使用。

  1. 处理键盘鼠标消息。控制消息的收发和视频帧是顺序关系，而不是异步关系，被控端每发送一帧截屏后接收控制端的键盘鼠标消息，并将此消息模拟为本机的键盘鼠标操作；与此同时，控制端每接收一帧截屏后发送键盘鼠标消息。由于网络通信使用阻塞模式，此时一定要保证，被控端的先发送和后接收、控制端先接受再发送，主控和被控任何的执行分支都要分别执行这两对代码节点，否则会造成网络收发的死锁。另外，控制端如果发现，键盘鼠标的位置和动作跟上次的值相同，就会向被控端发送一个REMOTE_DUMMY_PACKET数据包，告诉被控端，控制端没有控制消息给你，你可以适当的增加截屏延时（一次增加10毫秒），以便减少网络消耗。主要的键盘鼠标结构体如下：

typedef struct {
	int screenx;
	int screeny;
	int bitsperpix;
}STREMOTECONTROLPARAMS, * LPSTREMOTECONTROLPARAMS;

typedef struct {
	POINT pos;
	POINT size;
}REMOTECONTROLMOUSEPOS, * LPREMOTECONTROLMOUSEPOS;

typedef struct {
	unsigned char key;
	unsigned char shiftkey;
}REMOTECONTROLKEY, * LPREMOTECONTROLKEY;

typedef struct {
	int delta;
	int xy;
}REMOTECONTROLWHEEL, * LPREMOTECONTROLWHEEL;


typedef struct {
	DWORD		dwType;
	POINT		stPT;
	DWORD		dwTickCnt;
	int			iDelta;
}STMOUSEACTION, * LPMOUSEACTION;

该结构由几个全局变量存放：键盘按键值，鼠标左键、中键、右键是否有点击动作，鼠标滚轮的滚动距离，鼠标的坐标位置等。控制端的窗口程序监听鼠标键盘消息，将这些消息填充为上述结构体，并由通信线程发送给被控端。

被控端通过keybd_event和mouse_event将收到的控制信息转换为本机的键盘鼠标消息。例子代码如下：

		if (dwCommand == REMOTE_MOUSE_POS)
		{
			DWORD dwDataSize = lphdr->packlen;
			if (dwDataSize = sizeof(POINT) + sizeof(POINT))
			{
				LPREMOTECONTROLPOS pos = (LPREMOTECONTROLPOS)(lpBuf + sizeof(NETWORKPACKETHEADER));
				POINT stServerCurrent = pos->pos;
				POINT stPtServerMax = pos->size;

				int iXLocalMax = ScrnResolutionX;
				int iYLocalMax = ScrnResolutionY;

				POINT stPtLocalCurrent = { 0 };
				if (stPtServerMax.x != 0 && stPtServerMax.y != 0)
				{
					stPtLocalCurrent.x = (iXLocalMax * stServerCurrent.x) / stPtServerMax.x;
					stPtLocalCurrent.y = (iYLocalMax * stServerCurrent.y) / stPtServerMax.y;
					//mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_MOVE,stPtLocalCurrent.x,stPtLocalCurrent.y,0,0);
					lpSetCursorPos(stPtLocalCurrent.x, stPtLocalCurrent.y);
				}
			}

			actionInterval(&dwSleepTimeValue);

			//checkTime(&dwSleepTimeValue);
			continue;
		}
		else if (dwCommand == REMOTE_KEYBOARD)
		{
			if (lphdr->packlen == 2)
			{
				LPREMOTECONTROLKEY lpkey = (LPREMOTECONTROLKEY)(lpBuf + sizeof(NETWORKPACKETHEADER));
				unsigned char key = lpkey->key;
				unsigned char keyshift = lpkey->shiftkey;

				//unsigned char szKeyboardState[256];
				//memmove(szKeyboardState,pData,256);
				//iRet = SetKeyboardState(pData);

				if (keyshift)
				{
					keybd_event(VK_SHIFT, 0, 0, 0);
					keybd_event(key, 0, 0, 0);
					keybd_event(key, 0, KEYEVENTF_KEYUP, 0);
					keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
				}
				else {
					keybd_event(key, 0, 0, 0);
					keybd_event(key, 0, KEYEVENTF_KEYUP, 0);
				}
			}
			actionInterval(&dwSleepTimeValue);

			//checkTime(&dwSleepTimeValue);

			continue;
		}
		else if (dwCommand == REMOTE_LEFTBUTTONDOWN || dwCommand == REMOTE_LEFTBUTTONDOUBLECLICK ||
			dwCommand == REMOTE_RBUTTONDOWN || dwCommand == REMOTE_RBUTTONDOUBLECLICK)
		{
			DWORD dwDataSize = lphdr->packlen;
			if (dwDataSize = sizeof(POINT) + sizeof(POINT))
			{
				LPREMOTECONTROLPOS pos = (LPREMOTECONTROLPOS)(lpBuf + sizeof(NETWORKPACKETHEADER));
				POINT stServerCurrent = pos->pos;
				POINT stPtServerMax = pos->size;

				int iXLocalMax = ScrnResolutionX;
				int iYLocalMax = ScrnResolutionY;

				POINT stPtLocalCur = { 0 };
				if (stPtServerMax.x != 0 && stPtServerMax.y != 0)
				{
					stPtLocalCur.x = (iXLocalMax * stServerCurrent.x) / stPtServerMax.x;
					stPtLocalCur.y = (iYLocalMax * stServerCurrent.y) / stPtServerMax.y;
					lpSetCursorPos(stPtLocalCur.x, stPtLocalCur.y);
					if (dwCommand == REMOTE_LEFTBUTTONDOWN)
					{
						mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
						mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
					}
					else if (dwCommand == REMOTE_RBUTTONDOWN)
					{
						mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
						mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
					}
					else if (dwCommand == REMOTE_RBUTTONDOUBLECLICK)
					{
						mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
						lpSleep(0);
						mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
					}
					else if (dwCommand == REMOTE_LEFTBUTTONDOUBLECLICK)
					{
						mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
						lpSleep(0);
						mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
					}
				}
			}

			actionInterval(&dwSleepTimeValue);
			//checkTime(&dwSleepTimeValue);
			continue;
		}
		else if (dwCommand == REMOTE_MOUSEWHEEL)
		{
			DWORD dwDataSize = lphdr->packlen;
			if (dwDataSize = sizeof(DWORD) + sizeof(DWORD))
			{
				LPREMOTECONTROLWHEEL wheel = (LPREMOTECONTROLWHEEL)(lpBuf + sizeof(NETWORKPACKETHEADER));
				int key = wheel->delta & 0xffff;
				int delta = wheel->delta >> 16;
				int x = wheel->xy & 0xffff;
				int y = wheel->xy & 0xffff0000;

				mouse_event(MOUSEEVENTF_WHEEL, x, y, delta, 0);
				lpSleep(0);
			}

			actionInterval(&dwSleepTimeValue);

			//checkTime(&dwSleepTimeValue);
			continue;
			//to action more faster not to sleep
		}
		else if (dwCommand == RECV_DATA_OK || dwCommand == REMOTE_DUMMY_PACKET)
		{
			freeInterval(&dwSleepTimeValue);
		}
		else if (dwCommand == REMOTECONTROL_END)
		{
			writeLog("remotecontrol shutdown by server\r\n");
			break;
		}
		else
		{
			writeLog("RemoteControlProc unrecognized command:%u\r\n", dwCommand);
			//break;
		}

		checkTime(&dwSleepTimeValue);

（三）减少网络流量的努力

测试中发现，实际的网速有可能比想象中偏低，比如很多服务器网络带宽只有几百kb/s，上述依靠传输截屏帧的显示方式，按照40ms一帧的延时，8位位图数据帧，经过zip压缩后，网络流量可以平均减少10倍左右也就是大约1~2MB/s左右，依然无法满足实际需求，经过考虑，采用了如下几种改善措施：

  1. 客户端每次截屏后动态延时。当服务端没有鼠标键盘等控制信息后，发送延时消息REMOTE_DUMMY_PACKET给客户端，客户端每收到一个这样的数据包，截屏延时自动增加10ms，最长到2000ms为止，而收到键盘鼠标等控制消息后，延时立刻恢复到默认的REMOTE_CLIENT_SCREEN_MIN_INTERVAL值，这样可以显著的减少网络流量。
  2. 将截屏数据帧的格式由bmp转化为jpeg。bmp是原始像素值格式，jpeg是压缩后的像素格式，同时jpeg压缩算法是对每一块像素块进行压缩，经测试，在保证图像质量80%以上的条件下，其压缩比大约在10-40倍，但是这对zip压缩的优势并不明显（zip的压缩比平均在6-30倍左右），而且jpeg使用起来也较为繁琐，所以弃之未用。当然，如果改为jpeg格式的话，每一帧截屏的网络流量还能减少大约25%。
  3. 发送截屏帧前，执行屏幕像素比对操作。对每一帧截屏的所有像素值保存副本，每次截屏后跟上次的截屏数值比对，如果改变的像素值数量超过一帧像素总数的一半，就发送整个的截屏帧，否则只发送发生变化的像素值（格式是像素位置和像素的值，所有像素点在发送缓冲区中线性排列，并在zip压缩后传输）；如果跟上一帧相比所有，像素点均未发生任何变化（这才是绝大多数情况），则发送延时消息。测试发现，在很短的截屏周期内，被控屏幕每一帧画面，不可能每一个像素都发生变化，改变的只有很少一小部分，甚至80%的监控周期内，整个屏幕的所有像素值未发生任何变化，此时不需要传送任何像素信息。这里还有一个常识，在windows下的截屏是没有鼠标的，因此，鼠标的点击和移动，也不会导致截屏像素点的任何改变。经测试发现，中度操作时，平均每个截屏周期，屏幕上变化的像素值，少的只有几十几百个字节，多的也只有几十kb，此种方法将发送截屏的概率下降了90%以上。当然，我觉得还有一种类似的方法，就是监听WM_PAINT消息，将重绘的像素块发送给主控端，这种方式跟像素值比对原理相同，只是实现方式不同。此段主要代码逻辑如下：
		if (mapit->second->dataType == REMOTE_PIXEL_PACKET)
		{
			char* lpClientBitmap = mapit->second->lpClientBitmap;
			RECT rect;
			GetClientRect(hWnd, &rect);
			HDC  hdcScr = CreateDCA("DISPLAY", 0, 0, 0);
			HDC hdcSource = CreateCompatibleDC(hdcScr);
			HBITMAP hbmp = CreateCompatibleBitmap(hdcScr, mapit->second->param.screenx, mapit->second->param.screeny);
			SelectObject(hdcSource, hbmp);
			result = StretchBlt(hdcSource, 0, 0, mapit->second->param.screenx, mapit->second->param.screeny, hdcDst, 0, 0,
				rect.right - rect.left, rect.bottom - rect.top, SRCCOPY);
			if (result)
			{
				char buf[0x1000];
				LPBITMAPINFO lpbmpinfo = (LPBITMAPINFO)buf;
				memset(lpbmpinfo, 0, sizeof(BITMAPINFO));
				lpbmpinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
				lpbmpinfo->bmiHeader.biBitCount = mapit->second->param.bitsperpix;
				lpbmpinfo->bmiHeader.biPlanes = 1;
				lpbmpinfo->bmiHeader.biWidth = mapit->second->param.screenx;
				lpbmpinfo->bmiHeader.biHeight = mapit->second->param.screeny;
				//DWORD dwbmbitssize = ((lpbmpinfo->bmiHeader.biWidth * lpbmpinfo->bmiHeader.biBitCount + 31) / 32) * 4 * lpbmpinfo->bmiHeader.biHeight;
				lpbmpinfo->bmiHeader.biSizeImage = 0;
				char* data = mapit->second->dibits;

				result = GetDIBits(hdcSource, hbmp, 0, lpbmpinfo->bmiHeader.biHeight, data, lpbmpinfo, DIB_RGB_COLORS);
				if (result && result != ERROR_INVALID_PARAMETER)
				{
					int byteperpix = mapit->second->param.bitsperpix / 8;
					int itemsize = (sizeof(DWORD) + mapit->second->param.bitsperpix / 8);
					int cnt = mapit->second->lpbmpDataSize / itemsize;
					for (int i = 0; i < cnt; i++)
					{
						int index = itemsize * i;
						int offset = *(DWORD*)(lpClientBitmap + index);
						if (offset > mapit->second->bufLimit)
						{
							WriteLog("pixel offset error :%u\r\n", offset);
							break;
						}
						if (byteperpix == 4)
						{
							DWORD color = *(DWORD*)(lpClientBitmap + index + sizeof(DWORD));
							*(DWORD*)(data + offset) = color;
						}
						else if (byteperpix == 3)
						{
							char* color = lpClientBitmap + index + sizeof(DWORD);
							memcpy(data + offset, color, 3);
						}
						else if (byteperpix == 2)
						{
							WORD color = *(WORD*)(lpClientBitmap + index + sizeof(DWORD));
							*(WORD*)(data + offset) = color;
						}
						else if (byteperpix == 1)
						{
							unsigned char color = *(lpClientBitmap + index + sizeof(DWORD));
							*(data + offset) = color;
						}
					}
					result = SetDIBits(hdcSource, hbmp, 0, mapit->second->param.screeny, data, lpbmpinfo, DIB_RGB_COLORS);
					if (result)
					{
						result = StretchBlt(hdcDst, 0, 0, rect.right - rect.left, rect.bottom - rect.top, hdcSource, 0, 0,
							mapit->second->param.screenx, mapit->second->param.screeny, SRCCOPY);
						if (result)
						{

						}
						else {
							WriteLog("RemoteControl StretchBlt error:%u\r\n", GetLastError());
						}
					}
					else {
						WriteLog("RemoteControl SetDIBits error:%u\r\n", GetLastError());
					}
				}
				else {
					WriteLog("RemoteControl GetDIBits error:%u\r\n", GetLastError());
				}

				DeleteObject(hbmp);
				DeleteDC(hdcScr);
				DeleteDC(hdcSource);
			}
			else {
				WriteLog("RemoteControl StretchBlt error:%d\r\n", GetLastError());
			}

			mapit->second->dataType = 0;

			EndPaint(hWnd, &stPS);
			return TRUE;
		}

此处第一个StretchBlt函数的作用是，将主控端显示窗口大小转化为适合被控端宽度高度的大小，原因是，被控端无法得知主控端显示窗口的大小，被控发送的像素值位置是对本窗口的偏移值，如果两边窗口大小不一致，那么被控端的像素位置值就失去了意义。此时通过StretchBlt函数转换后，就可以将像素值直接写入转换后的hbitmap，并再次调用StretchBlt函数，将客户端的窗口大小调整为主控端显示窗口的大小。此处也用到了SetDIBits和GetDIBits函数，该函数上边已经讲过了，功能比较强大，但是使用起来比较复杂。此处有个内存越界的bug，也就是像素的偏移值会大于整个截屏的像素个数总数，会导致WriteLog那一行的执行，原因应该是，两边的窗口大小不一致，若被控的窗口比较大，而主控端窗口比较小，主控端的缓冲区是按照主控窗口大小分配的，转换坐标后，有可能发生内存溢出。

像素值比对函数如下：

int ScreenFrameChecker(char* backup, char* color, int colorlen, char* buf, int bytesperpix) {

	int counter = 0;

	if (bytesperpix == 4)
	{
		DWORD* lpback = (DWORD*)backup;
		DWORD* lpcolor = (DWORD*)color;

		for (int i = 0; i < colorlen / bytesperpix; i++)
		{
			if (lpback[i] != lpcolor[i]) {

				lpback[i] = lpcolor[i];

				char* lppixel = buf + counter * (sizeof(DWORD) + bytesperpix);
				*(DWORD*)lppixel = i * 4;

				*(DWORD*)(lppixel + sizeof(DWORD)) = lpcolor[i];

				counter++;
			}
		}
	}
	else if (bytesperpix == 3)
	{
		char* lpback = (char*)backup;
		char* lpcolor = (char*)color;

		for (int i = 0; i < colorlen / bytesperpix; i += 3)
		{
			if (lpback[i] != lpcolor[i] || lpback[i + 1] != lpcolor[i + 1] || lpback[i + 2] != lpcolor[i + 2]) {

				lpback[i] = lpcolor[i];
				lpback[i + 1] = lpcolor[i + 1];
				lpback[i + 2] = lpcolor[i + 2];

				char* lppixel = buf + counter * (sizeof(DWORD) + bytesperpix);
				*(DWORD*)lppixel = i;

				*(lppixel + sizeof(DWORD)) = lpcolor[i];
				*(lppixel + sizeof(DWORD) + 1) = lpcolor[i + 1];
				*(lppixel + sizeof(DWORD) + 2) = lpcolor[i + 2];

				counter++;
			}
		}
	}
	else if (bytesperpix == 2)
	{
		WORD* lpback = (WORD*)backup;
		WORD* lpcolor = (WORD*)color;

		for (int i = 0; i < colorlen / bytesperpix; i++)
		{
			if (lpback[i] != lpcolor[i]) {

				lpback[i] = lpcolor[i];

				char* lppixel = buf + counter * (sizeof(DWORD) + bytesperpix);
				*(DWORD*)lppixel = i * 2;

				*(WORD*)(lppixel + sizeof(DWORD)) = lpcolor[i];

				counter++;
			}
		}
	}
	else if (bytesperpix == 1)
	{
		char* lpback = (char*)backup;
		char* lpcolor = (char*)color;

		for (int i = 0; i < colorlen / bytesperpix; i++)
		{
			if (lpback[i] != lpcolor[i]) {

				lpback[i] = lpcolor[i];

				char* lppixel = buf + counter * (sizeof(DWORD) + bytesperpix);
				*(DWORD*)lppixel = i;

				*(char*)(lppixel + sizeof(DWORD)) = lpcolor[i];

				counter++;
			}
		}
	}
	else {
		return FALSE;
	}

	return counter;

}

ScreenFrameChecker函数分8位、16位、24位、32位4种颜色深度值，跟上一帧比对截屏像素值，返回发生变化的像素值个数。为了加快速度，也可以按照每种规则，比如每次8个字节比对，或者使用simd指令优化，每次比对16字节。

（四）不足和缺陷

  1. 实例代码中未实现主控端和被控端的剪贴板的共享，以及文件复制粘贴操作。
  2. 使用截屏方式抓取屏幕内容，然后压缩通过网络发送，这种机制太慢了。通过QueryPerformanceCounter高精度时钟测试，一帧截屏时间开销大概率在20-40毫秒之间，加上解压和网络传输的时间损耗，这样的一帧画面时间消耗可能超过50毫秒甚至100毫秒。这样的速度对应于每秒20帧以上的速率来说，将是一个致命缺陷，无法达到设计要求，这可能是因为线程切换或者API接口本身的问题，最好能将一帧抓屏时间消耗减少到10毫秒以内。
  3. 压缩算法使用zip，zip本身时间消耗非常少，测试几百kb的数据、压缩率最高时平均时间消耗在5毫秒左右，zip压缩是无损压缩，图像数据并不需要无损压缩，假如有其他合适的压缩算法，有较小的像素损失和较好的时间消耗，可能会有几毫秒的效率提高，但是不能算一个核心问题。
  4. 其他很多细节处理不足。
satadriver
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
远程桌面基本原理
D0126_的博客
05-12 3009
这种技术可以让用户在不同的地方使用同一台计算机，或者在同一地方使用不同的计算机。这种技术可以让用户在不同的地方使用同一台计算机，或者在同一地方使用不同的计算机。远程桌面技术可以让技术支持人员在不同的地方远程访问用户的计算机，从而解决用户的问题。远程桌面技术可以让技术支持人员在不同的地方远程访问用户的计算机，从而解决用户的问题。这种技术还可以让学校在不同的地方招收学生，因为学生可以在任何地方使用学校的计算机。这种技术还可以让学校在不同的地方招收学生，因为学生可以在任何地方使用学校的计算机。
网络远程控制原理及技术实现
热门推荐
顺其自然~专栏
10-30 3万+
一、网络远程控制技术原理 网络远程控制技术即利用一台电脑远距离控制另一台电脑，在这个控制过程中，将TCP/IP协议网络数据通信作为基础，在控制计算机与被控计算机内运行，确保网络通讯等各项功能可以顺利实现。现在IP协议中主要存在UDP与TCP两种通讯传输协议，且UDP协议采用数据拆分后以数据报传输方式，并未对达到数据有专门要求；TCP 协议则是对待传输数据进行分割、打包处理后，以数据流形式进行传输...
【C++】C++设计远程桌面软件的技术详解
kewaqi618的博客
07-18 819
在当今的数字化时代，远程桌面技术已成为企业远程办公、技术支持、教育培训等领域不可或缺的一部分。它允许用户从任何地点通过互联网安全地访问和控制远程计算机，就像直接坐在那台计算机前一样。C++作为一种高效、灵活且性能强大的编程语言，非常适合用于开发这类对实时性、安全性和稳定性要求极高的应用程序。本文将深入探讨如何使用C++设计并实现一个基本的远程桌面软件，涵盖关键技术点、架构设计、网络通信、图形界面处理及安全策略等方面。
远程控制计算机的原理
书山有路勤为径，学海无涯苦作舟
01-25 6605
远程控制计算机的原理1.         方式l         C/S模式C/S模式类似于PCANYWHERE，需要一个Server和一个client，分别安装在不同的计算上，client计算机控制server所在的计算机上。一般在局域网内使用，使用TCP协议，如果在internet网上使用可能需要代理服务器或一个server，但其受防火墙的影响比较大。l         Web模式是一个B/S
一文了解远程桌面连接：从原理到实现的远程桌面连接全解析
Lion_Long的博客
06-24 3245
远程桌面连接是一种让用户从远程位置访问和控制计算机的技术。通过远程桌面连接，用户可以在自己的电脑上操作远程计算机，就好像坐在那台计算机前一样。这个技术对于需要在不同地点之间协作或是需要遥控其他计算机进行维护、故障排除等操作的人员非常有用。远程桌面连接需要两个端点：一个是本地计算机，另一个是远程计算机。为了建立远程桌面连接，需要使用特定的软件，在本地计算机上输入远程计算机的IP地址或主机名，并输入正确的用户名和密码来验证身份。远程桌面连接通常采用安全加密方式来保证数据传输的安全性。
遠程控制軟件的原理
操作系统开发
12-10 1174
http://www.brianbondy.com/blog/id/87/how-vnc-fog-creek-copilot-and-other-remote-control-software-works About 7 years ago my company and I created a program called Remote Task Manager. It was
远程监控实现原理
10-15
简介屏幕监控的实现原理，文档中有部分核心算法伪代码
计算机远程控制技术的原理与实现
12-21
该文档描述计算机远程控制技术的原理和实现，以论文式介绍远程控制技术中涉及的概念和技术规范。
远程控制原理
hekewangzi
06-27 3883
                                         
远程控制实战演练
03-25
"远程控制实战演练"是一个旨在提升用户对远程控制工具理解和操作能力的实践训练。 在远程控制中，通常会用到各种软件工具，如TeamViewer、AnyDesk、Chrome Remote Desktop等。这些工具提供了安全的加密机制，确保...
java远程控制原理和示例
06-11
我们常看见的远程控制和共享桌面工具如VNC,netMeting,洪恩多媒体教师都是VC做的，其实java也可以做,有兴趣的朋友可以看看
远程桌面算法
10-27
远程桌面算法是易语言远程控制传送优化，提升方法
Python 实战系列-微信或网页远程控制电脑
04-29
使用wxPython编写图形化的程序，并进一步将这个程序发展为远程控制程序。 课程目录: |--|----|----1 微信远控：Python 控制电脑的两种方法 |--|----|----|----1 课程介绍.mp4 |--|----|----|----2 命令提示符 CMD...
简易远控远程控制软件源码
11-20
一、远程控制原理 远程控制软件的核心在于实现两台计算机之间的通信和交互。简易远控利用TCP/IP协议，通过网络连接建立主控端与被控端之间的通道，实现实时屏幕共享、键盘输入模拟以及文件传输等功能。其中，屏幕...
多模态大模型：技术原理与实战 全球多模态大模型介绍
禅与计算机程序设计艺术
06-11 538
关键词：多模态大模型、深度学习、计算机视觉、自然语言处理、跨模态学习、迁移学习、人工智能随着人工智能技术的飞速发展，多模态大模型已经成为了当前AI领域最热门的研究方向之一。多模态大模型能够同时处理和理解多种类型的数据，如文本、图像、音频和视频等，这为AI系统在复杂场景下的应用提供了更加强大和灵活的能力。本文将深入探讨多模态大模型的技术原理，介绍其实战应用，并对全球主要的多模态大模型进行全面的介绍和比较。
模型版本控制原理与代码实战案例讲解
最新发布
禅与计算机程序设计艺术
08-12 378
1. 背景介绍 1.1 机器学习模型版本控制的必要性 在机器学习项目中，模型的版本控制与管理至关重要。随着项目的进展，模型会不断迭代更新，产生大量的版本。如果没有有效的版本控制机制，就会出现以下问题： 难以追踪模型演变过程： 无
手机远程控制原理
sdwdz的专栏
04-27 6130
系统分为3部分：  一：安卓手机部分：
远程控制的原理是什么
2301_79116064的博客
01-19 790
使用时客户端程序向被控端电脑中的服务器端程序发出信号，建立一个特殊的远程服务，然后通过这个远程服务，使用各种远程控制功能发送远程控制命令，控制被控端电脑中的各种应用程序运行。也就是说，控制被控端电脑进行操作似乎是在眼前的电脑上进行的，实质是在远程的电脑中实现的，不论打开文件，还是上网浏览、下载等都是存储在远程的被控端电脑中的。是指管理人员在异地通过计算机网络，连接需要被控制的计算机，将被控计算机的桌面环境显示到自己的计算机上，通过本地计算机对远方计算机进行配置、软件安装程序、修改等工作。
wifi模块远程控制原理
06-12
Wifi模块远程控制的原理是通过将Wifi模块与互联网连接，实现远程控制设备的目的。具体步骤如下： 1. 将Wifi模块与设备连接，通过Wifi模块的控制接口控制设备的开关、调节等操作。 2. 将Wifi模块与互联网连接，通过云端服务将设备信息上传至云端。 3. 用户通过手机或电脑等设备访问云端服务，获取设备信息，并控制设备的开关、调节等操作。 4. 云端服务将用户的控制指令通过网络传到Wifi模块，Wifi模块根据指令控制设备的开关、调节等操作。 总之，通过Wifi模块与互联网连接，实现设备的远程控制。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值