1261 lines
46 KiB
C++
1261 lines
46 KiB
C++
#pragma once
|
||
#include "common/commands.h"
|
||
#include "client/IOCPClient.h"
|
||
#include "LinuxConfig.h"
|
||
#include "ClipboardHandler.h"
|
||
#include "FileTransferV2.h"
|
||
#include <dlfcn.h>
|
||
#include <sys/stat.h>
|
||
#include <thread>
|
||
#include <mutex>
|
||
#include <atomic>
|
||
#include <vector>
|
||
#include <cstring>
|
||
#include <stdexcept>
|
||
|
||
// 客户端 ID（定义在 main.cpp）
|
||
extern uint64_t g_myClientID;
|
||
|
||
// Linux 端 BITMAPINFOHEADER 定义，与 Windows 完全一致
|
||
#pragma pack(push, 1)
|
||
struct BITMAPINFOHEADER_LNX {
|
||
uint32_t biSize; // 40
|
||
int32_t biWidth;
|
||
int32_t biHeight;
|
||
uint16_t biPlanes; // 1
|
||
uint16_t biBitCount; // 32
|
||
uint32_t biCompression; // 0 (BI_RGB)
|
||
uint32_t biSizeImage;
|
||
int32_t biXPelsPerMeter; // 0
|
||
int32_t biYPelsPerMeter; // 0
|
||
uint32_t biClrUsed; // 0
|
||
uint32_t biClrImportant; // 0
|
||
};
|
||
#pragma pack(pop)
|
||
|
||
// Linux 本地 MSG64 定义（与 Windows MSG64 内存布局完全一致）
|
||
// 用于解析服务端发来的鼠标/键盘控制命令
|
||
#pragma pack(push, 1)
|
||
struct MSG64_LNX {
|
||
uint64_t hwnd;
|
||
uint64_t message;
|
||
uint64_t wParam;
|
||
uint64_t lParam;
|
||
uint64_t time;
|
||
int32_t pt_x;
|
||
int32_t pt_y;
|
||
};
|
||
#pragma pack(pop)
|
||
|
||
// X11 类型前向声明（避免 #include <X11/Xlib.h>）
|
||
typedef struct _XDisplay Display;
|
||
typedef unsigned long XID;
|
||
typedef XID Window;
|
||
typedef XID Drawable;
|
||
typedef XID Pixmap;
|
||
typedef struct _XGC *GC;
|
||
|
||
struct XImage {
|
||
int width, height;
|
||
int xoffset;
|
||
int format;
|
||
char *data;
|
||
int byte_order;
|
||
int bitmap_unit;
|
||
int bitmap_bit_order;
|
||
int bitmap_pad;
|
||
int depth;
|
||
int bytes_per_line;
|
||
int bits_per_pixel;
|
||
unsigned long red_mask;
|
||
unsigned long green_mask;
|
||
unsigned long blue_mask;
|
||
// 后续字段省略，XDestroyImage 通过函数指针释放
|
||
void *obdata;
|
||
struct funcs {
|
||
void *p[8]; // create_image, destroy_image, ...
|
||
} f;
|
||
};
|
||
|
||
// X11 错误处理（防止 BadMatch 等错误导致进程退出）
|
||
static int x11_error_handler(Display* dpy, void* evt)
|
||
{
|
||
// 忽略所有 X11 错误，由调用方检查返回值
|
||
return 0;
|
||
}
|
||
|
||
// XCreateGC 需要的 XGCValues 结构体（布局与 Xlib 一致）
|
||
struct XGCValues_LNX {
|
||
int function;
|
||
unsigned long plane_mask;
|
||
unsigned long foreground;
|
||
unsigned long background;
|
||
int line_width;
|
||
int line_style;
|
||
int cap_style;
|
||
int join_style;
|
||
int fill_style;
|
||
int fill_rule;
|
||
int arc_mode;
|
||
unsigned long tile; // Pixmap = XID
|
||
unsigned long stipple; // Pixmap = XID
|
||
int ts_x_origin;
|
||
int ts_y_origin;
|
||
unsigned long font; // Font = XID
|
||
int subwindow_mode;
|
||
};
|
||
|
||
// X11 GC 常量
|
||
#define GCSubwindowMode (1L<<15)
|
||
#define IncludeInferiors 1
|
||
|
||
// ============== 屏幕算法常量 ==============
|
||
#define ALGORITHM_GRAY 0
|
||
#define ALGORITHM_DIFF 1
|
||
#define ALGORITHM_H264 2
|
||
#define ALGORITHM_RGB565 3
|
||
|
||
// 算法支持表（编译时常量，日后支持 H264 时改为 true）
|
||
static const bool g_SupportedAlgo[] = {
|
||
true, // ALGORITHM_GRAY = 0
|
||
true, // ALGORITHM_DIFF = 1
|
||
false, // ALGORITHM_H264 = 2
|
||
true, // ALGORITHM_RGB565 = 3
|
||
};
|
||
|
||
// 不支持的算法降级为 RGB565
|
||
inline uint8_t GetEffectiveAlgorithm(uint8_t algo) {
|
||
if (algo > 3 || !g_SupportedAlgo[algo]) {
|
||
return ALGORITHM_RGB565;
|
||
}
|
||
return algo;
|
||
}
|
||
|
||
// ============== 颜色转换函数 ==============
|
||
|
||
// BGRA → 灰度 (Y = 0.299R + 0.587G + 0.114B)
|
||
// 使用整数近似: Y = (306*R + 601*G + 117*B) >> 10
|
||
inline void ConvertBGRAtoGray(const uint8_t* src, uint8_t* dst, uint32_t pixelCount)
|
||
{
|
||
for (uint32_t i = 0; i < pixelCount; i++) {
|
||
uint8_t b = src[i * 4 + 0];
|
||
uint8_t g = src[i * 4 + 1];
|
||
uint8_t r = src[i * 4 + 2];
|
||
dst[i] = (uint8_t)((306 * r + 601 * g + 117 * b) >> 10);
|
||
}
|
||
}
|
||
|
||
// BGRA → RGB565 (R:5位, G:6位, B:5位)
|
||
// 格式: RRRRRGGG GGGBBBBB
|
||
inline void ConvertBGRAtoRGB565(const uint8_t* src, uint16_t* dst, uint32_t pixelCount)
|
||
{
|
||
for (uint32_t i = 0; i < pixelCount; i++) {
|
||
uint8_t b = src[i * 4 + 0];
|
||
uint8_t g = src[i * 4 + 1];
|
||
uint8_t r = src[i * 4 + 2];
|
||
uint16_t r5 = (r >> 3) & 0x1F;
|
||
uint16_t g6 = (g >> 2) & 0x3F;
|
||
uint16_t b5 = (b >> 3) & 0x1F;
|
||
dst[i] = (r5 << 11) | (g6 << 5) | b5;
|
||
}
|
||
}
|
||
|
||
// ============== Windows 消息常量（用于解析服务端控制命令）==============
|
||
#define WM_MOUSEMOVE 0x0200
|
||
#define WM_LBUTTONDOWN 0x0201
|
||
#define WM_LBUTTONUP 0x0202
|
||
#define WM_LBUTTONDBLCLK 0x0203
|
||
#define WM_RBUTTONDOWN 0x0204
|
||
#define WM_RBUTTONUP 0x0205
|
||
#define WM_RBUTTONDBLCLK 0x0206
|
||
#define WM_MBUTTONDOWN 0x0207
|
||
#define WM_MBUTTONUP 0x0208
|
||
#define WM_MBUTTONDBLCLK 0x0209
|
||
#define WM_MOUSEWHEEL 0x020A
|
||
|
||
#define WM_KEYDOWN 0x0100
|
||
#define WM_KEYUP 0x0101
|
||
#define WM_SYSKEYDOWN 0x0104
|
||
#define WM_SYSKEYUP 0x0105
|
||
|
||
// Windows 滚轮增量宏
|
||
#define GET_WHEEL_DELTA_WPARAM(wParam) ((short)((wParam) >> 16))
|
||
|
||
// X11 Bool 常量
|
||
#ifndef True
|
||
#define True 1
|
||
#endif
|
||
#ifndef False
|
||
#define False 0
|
||
#endif
|
||
|
||
// X11 按钮常量
|
||
#define Button1 1 // 左键
|
||
#define Button2 2 // 中键
|
||
#define Button3 3 // 右键
|
||
#define Button4 4 // 滚轮上
|
||
#define Button5 5 // 滚轮下
|
||
|
||
// X11 KeySym 常量（常用键）
|
||
#define XK_BackSpace 0xff08
|
||
#define XK_Tab 0xff09
|
||
#define XK_Return 0xff0d
|
||
#define XK_Escape 0xff1b
|
||
#define XK_Delete 0xffff
|
||
#define XK_Home 0xff50
|
||
#define XK_Left 0xff51
|
||
#define XK_Up 0xff52
|
||
#define XK_Right 0xff53
|
||
#define XK_Down 0xff54
|
||
#define XK_Page_Up 0xff55
|
||
#define XK_Page_Down 0xff56
|
||
#define XK_End 0xff57
|
||
#define XK_Insert 0xff63
|
||
#define XK_Shift_L 0xffe1
|
||
#define XK_Shift_R 0xffe2
|
||
#define XK_Control_L 0xffe3
|
||
#define XK_Control_R 0xffe4
|
||
#define XK_Caps_Lock 0xffe5
|
||
#define XK_Alt_L 0xffe9
|
||
#define XK_Alt_R 0xffea
|
||
#define XK_Super_L 0xffeb // Win键
|
||
#define XK_Super_R 0xffec
|
||
#define XK_F1 0xffbe
|
||
#define XK_F2 0xffbf
|
||
#define XK_F3 0xffc0
|
||
#define XK_F4 0xffc1
|
||
#define XK_F5 0xffc2
|
||
#define XK_F6 0xffc3
|
||
#define XK_F7 0xffc4
|
||
#define XK_F8 0xffc5
|
||
#define XK_F9 0xffc6
|
||
#define XK_F10 0xffc7
|
||
#define XK_F11 0xffc8
|
||
#define XK_F12 0xffc9
|
||
#define XK_Num_Lock 0xff7f
|
||
#define XK_Scroll_Lock 0xff14
|
||
#define XK_KP_0 0xffb0
|
||
#define XK_KP_1 0xffb1
|
||
#define XK_KP_2 0xffb2
|
||
#define XK_KP_3 0xffb3
|
||
#define XK_KP_4 0xffb4
|
||
#define XK_KP_5 0xffb5
|
||
#define XK_KP_6 0xffb6
|
||
#define XK_KP_7 0xffb7
|
||
#define XK_KP_8 0xffb8
|
||
#define XK_KP_9 0xffb9
|
||
#define XK_KP_Multiply 0xffaa
|
||
#define XK_KP_Add 0xffab
|
||
#define XK_KP_Subtract 0xffad
|
||
#define XK_KP_Decimal 0xffae
|
||
#define XK_KP_Divide 0xffaf
|
||
#define XK_KP_Enter 0xff8d
|
||
#define XK_Print 0xff61
|
||
#define XK_Pause 0xff13
|
||
#define XK_space 0x0020
|
||
|
||
// Windows VK 码到 X11 KeySym 的映射表
|
||
static unsigned long VKtoKeySym(unsigned int vk)
|
||
{
|
||
// 字母键 A-Z (VK 0x41-0x5A)
|
||
if (vk >= 0x41 && vk <= 0x5A)
|
||
return vk + 0x20; // 'a'-'z' 的 ASCII/KeySym
|
||
|
||
// 数字键 0-9 (VK 0x30-0x39)
|
||
if (vk >= 0x30 && vk <= 0x39)
|
||
return vk; // '0'-'9' 的 ASCII/KeySym
|
||
|
||
// 小键盘数字 VK_NUMPAD0-9 (0x60-0x69)
|
||
if (vk >= 0x60 && vk <= 0x69)
|
||
return XK_KP_0 + (vk - 0x60);
|
||
|
||
// F1-F12 (VK 0x70-0x7B)
|
||
if (vk >= 0x70 && vk <= 0x7B)
|
||
return XK_F1 + (vk - 0x70);
|
||
|
||
// 特殊键映射
|
||
switch (vk) {
|
||
case 0x08:
|
||
return XK_BackSpace; // VK_BACK
|
||
case 0x09:
|
||
return XK_Tab; // VK_TAB
|
||
case 0x0D:
|
||
return XK_Return; // VK_RETURN
|
||
case 0x10:
|
||
return XK_Shift_L; // VK_SHIFT
|
||
case 0x11:
|
||
return XK_Control_L; // VK_CONTROL
|
||
case 0x12:
|
||
return XK_Alt_L; // VK_MENU (Alt)
|
||
case 0x13:
|
||
return XK_Pause; // VK_PAUSE
|
||
case 0x14:
|
||
return XK_Caps_Lock; // VK_CAPITAL
|
||
case 0x1B:
|
||
return XK_Escape; // VK_ESCAPE
|
||
case 0x20:
|
||
return XK_space; // VK_SPACE
|
||
case 0x21:
|
||
return XK_Page_Up; // VK_PRIOR
|
||
case 0x22:
|
||
return XK_Page_Down; // VK_NEXT
|
||
case 0x23:
|
||
return XK_End; // VK_END
|
||
case 0x24:
|
||
return XK_Home; // VK_HOME
|
||
case 0x25:
|
||
return XK_Left; // VK_LEFT
|
||
case 0x26:
|
||
return XK_Up; // VK_UP
|
||
case 0x27:
|
||
return XK_Right; // VK_RIGHT
|
||
case 0x28:
|
||
return XK_Down; // VK_DOWN
|
||
case 0x2C:
|
||
return XK_Print; // VK_SNAPSHOT
|
||
case 0x2D:
|
||
return XK_Insert; // VK_INSERT
|
||
case 0x2E:
|
||
return XK_Delete; // VK_DELETE
|
||
case 0x5B:
|
||
return XK_Super_L; // VK_LWIN
|
||
case 0x5C:
|
||
return XK_Super_R; // VK_RWIN
|
||
case 0x6A:
|
||
return XK_KP_Multiply; // VK_MULTIPLY
|
||
case 0x6B:
|
||
return XK_KP_Add; // VK_ADD
|
||
case 0x6D:
|
||
return XK_KP_Subtract; // VK_SUBTRACT
|
||
case 0x6E:
|
||
return XK_KP_Decimal; // VK_DECIMAL
|
||
case 0x6F:
|
||
return XK_KP_Divide; // VK_DIVIDE
|
||
case 0x90:
|
||
return XK_Num_Lock; // VK_NUMLOCK
|
||
case 0x91:
|
||
return XK_Scroll_Lock; // VK_SCROLL
|
||
case 0xA0:
|
||
return XK_Shift_L; // VK_LSHIFT
|
||
case 0xA1:
|
||
return XK_Shift_R; // VK_RSHIFT
|
||
case 0xA2:
|
||
return XK_Control_L; // VK_LCONTROL
|
||
case 0xA3:
|
||
return XK_Control_R; // VK_RCONTROL
|
||
case 0xA4:
|
||
return XK_Alt_L; // VK_LMENU
|
||
case 0xA5:
|
||
return XK_Alt_R; // VK_RMENU
|
||
// 符号键（美式键盘布局）
|
||
case 0xBA:
|
||
return 0x003b; // VK_OEM_1 (;:)
|
||
case 0xBB:
|
||
return 0x003d; // VK_OEM_PLUS (=+)
|
||
case 0xBC:
|
||
return 0x002c; // VK_OEM_COMMA (,<)
|
||
case 0xBD:
|
||
return 0x002d; // VK_OEM_MINUS (-_)
|
||
case 0xBE:
|
||
return 0x002e; // VK_OEM_PERIOD (.>)
|
||
case 0xBF:
|
||
return 0x002f; // VK_OEM_2 (/?)
|
||
case 0xC0:
|
||
return 0x0060; // VK_OEM_3 (`~)
|
||
case 0xDB:
|
||
return 0x005b; // VK_OEM_4 ([{)
|
||
case 0xDC:
|
||
return 0x005c; // VK_OEM_5 (\|)
|
||
case 0xDD:
|
||
return 0x005d; // VK_OEM_6 (]})
|
||
case 0xDE:
|
||
return 0x0027; // VK_OEM_7 ('")
|
||
default:
|
||
return 0; // 未知键
|
||
}
|
||
}
|
||
|
||
// X11 函数指针类型
|
||
typedef Display* (*fn_XOpenDisplay)(const char*);
|
||
typedef int (*fn_XCloseDisplay)(Display*);
|
||
typedef XImage* (*fn_XGetImage)(Display*, Drawable, int, int, unsigned int, unsigned int, unsigned long, int);
|
||
typedef int (*fn_XDestroyImage)(XImage*);
|
||
typedef int (*fn_XSetErrorHandler)(int (*)(Display*, void*));
|
||
typedef Pixmap (*fn_XCreatePixmap)(Display*, Drawable, unsigned int, unsigned int, unsigned int);
|
||
typedef int (*fn_XFreePixmap)(Display*, Pixmap);
|
||
typedef GC (*fn_XCreateGC)(Display*, Drawable, unsigned long, void*);
|
||
typedef int (*fn_XFreeGC)(Display*, GC);
|
||
typedef int (*fn_XCopyArea)(Display*, Drawable, Drawable, GC, int, int, unsigned int, unsigned int, int, int);
|
||
typedef int (*fn_XDefaultDepth)(Display*, int);
|
||
typedef int (*fn_XSync)(Display*, int);
|
||
typedef unsigned long (*fn_XKeysymToKeycode)(Display*, unsigned long);
|
||
typedef int (*fn_XFlush)(Display*);
|
||
typedef int (*fn_XClearArea)(Display*, Window, int, int, unsigned int, unsigned int, int);
|
||
|
||
// XTest 扩展函数指针类型（用于模拟鼠标/键盘输入）
|
||
typedef int (*fn_XTestFakeMotionEvent)(Display*, int, int, int, unsigned long);
|
||
typedef int (*fn_XTestFakeButtonEvent)(Display*, unsigned int, int, unsigned long);
|
||
typedef int (*fn_XTestFakeKeyEvent)(Display*, unsigned int, int, unsigned long);
|
||
|
||
// X11 动态加载包装
|
||
class X11Loader
|
||
{
|
||
public:
|
||
fn_XOpenDisplay pXOpenDisplay;
|
||
fn_XCloseDisplay pXCloseDisplay;
|
||
fn_XGetImage pXGetImage;
|
||
fn_XDestroyImage pXDestroyImage;
|
||
|
||
// Xlib 宏的替代：通过偏移读取 Display 内部结构
|
||
// 这些函数通过 dlsym 获取
|
||
typedef int (*fn_XDefaultScreen)(Display*);
|
||
typedef int (*fn_XDisplayWidth)(Display*, int);
|
||
typedef int (*fn_XDisplayHeight)(Display*, int);
|
||
typedef Window (*fn_XRootWindow)(Display*, int);
|
||
|
||
fn_XDefaultScreen pXDefaultScreen;
|
||
fn_XDisplayWidth pXDisplayWidth;
|
||
fn_XDisplayHeight pXDisplayHeight;
|
||
fn_XRootWindow pXRootWindow;
|
||
|
||
// Pixmap 相关（解决合成窗口管理器下 XGetImage BadMatch 问题）
|
||
fn_XSetErrorHandler pXSetErrorHandler;
|
||
fn_XCreatePixmap pXCreatePixmap;
|
||
fn_XFreePixmap pXFreePixmap;
|
||
fn_XCreateGC pXCreateGC;
|
||
fn_XFreeGC pXFreeGC;
|
||
fn_XCopyArea pXCopyArea;
|
||
fn_XDefaultDepth pXDefaultDepth;
|
||
fn_XSync pXSync;
|
||
fn_XKeysymToKeycode pXKeysymToKeycode;
|
||
fn_XFlush pXFlush;
|
||
fn_XClearArea pXClearArea;
|
||
|
||
// XTest 扩展（用于模拟输入）
|
||
fn_XTestFakeMotionEvent pXTestFakeMotionEvent;
|
||
fn_XTestFakeButtonEvent pXTestFakeButtonEvent;
|
||
fn_XTestFakeKeyEvent pXTestFakeKeyEvent;
|
||
|
||
X11Loader() : m_handle(nullptr), m_xtst_handle(nullptr)
|
||
{
|
||
pXOpenDisplay = nullptr;
|
||
pXCloseDisplay = nullptr;
|
||
pXGetImage = nullptr;
|
||
pXDestroyImage = nullptr;
|
||
pXDefaultScreen = nullptr;
|
||
pXDisplayWidth = nullptr;
|
||
pXDisplayHeight = nullptr;
|
||
pXRootWindow = nullptr;
|
||
pXSetErrorHandler = nullptr;
|
||
pXCreatePixmap = nullptr;
|
||
pXFreePixmap = nullptr;
|
||
pXCreateGC = nullptr;
|
||
pXFreeGC = nullptr;
|
||
pXCopyArea = nullptr;
|
||
pXDefaultDepth = nullptr;
|
||
pXSync = nullptr;
|
||
pXKeysymToKeycode = nullptr;
|
||
pXFlush = nullptr;
|
||
pXClearArea = nullptr;
|
||
pXTestFakeMotionEvent = nullptr;
|
||
pXTestFakeButtonEvent = nullptr;
|
||
pXTestFakeKeyEvent = nullptr;
|
||
}
|
||
|
||
bool Load()
|
||
{
|
||
m_handle = dlopen("libX11.so.6", RTLD_LAZY);
|
||
if (!m_handle) m_handle = dlopen("libX11.so", RTLD_LAZY);
|
||
if (!m_handle) return false;
|
||
|
||
pXOpenDisplay = (fn_XOpenDisplay)dlsym(m_handle, "XOpenDisplay");
|
||
pXCloseDisplay = (fn_XCloseDisplay)dlsym(m_handle, "XCloseDisplay");
|
||
pXGetImage = (fn_XGetImage)dlsym(m_handle, "XGetImage");
|
||
pXDestroyImage = (fn_XDestroyImage)dlsym(m_handle, "XDestroyImage");
|
||
pXDefaultScreen = (fn_XDefaultScreen)dlsym(m_handle, "XDefaultScreen");
|
||
pXDisplayWidth = (fn_XDisplayWidth)dlsym(m_handle, "XDisplayWidth");
|
||
pXDisplayHeight = (fn_XDisplayHeight)dlsym(m_handle, "XDisplayHeight");
|
||
pXRootWindow = (fn_XRootWindow)dlsym(m_handle, "XRootWindow");
|
||
|
||
// Pixmap 相关函数
|
||
pXSetErrorHandler = (fn_XSetErrorHandler)dlsym(m_handle, "XSetErrorHandler");
|
||
pXCreatePixmap = (fn_XCreatePixmap)dlsym(m_handle, "XCreatePixmap");
|
||
pXFreePixmap = (fn_XFreePixmap)dlsym(m_handle, "XFreePixmap");
|
||
pXCreateGC = (fn_XCreateGC)dlsym(m_handle, "XCreateGC");
|
||
pXFreeGC = (fn_XFreeGC)dlsym(m_handle, "XFreeGC");
|
||
pXCopyArea = (fn_XCopyArea)dlsym(m_handle, "XCopyArea");
|
||
pXDefaultDepth = (fn_XDefaultDepth)dlsym(m_handle, "XDefaultDepth");
|
||
pXSync = (fn_XSync)dlsym(m_handle, "XSync");
|
||
pXKeysymToKeycode = (fn_XKeysymToKeycode)dlsym(m_handle, "XKeysymToKeycode");
|
||
pXFlush = (fn_XFlush)dlsym(m_handle, "XFlush");
|
||
pXClearArea = (fn_XClearArea)dlsym(m_handle, "XClearArea");
|
||
|
||
// 加载 XTest 扩展库（用于模拟鼠标/键盘输入）
|
||
m_xtst_handle = dlopen("libXtst.so.6", RTLD_LAZY);
|
||
if (!m_xtst_handle) m_xtst_handle = dlopen("libXtst.so", RTLD_LAZY);
|
||
if (m_xtst_handle) {
|
||
pXTestFakeMotionEvent = (fn_XTestFakeMotionEvent)dlsym(m_xtst_handle, "XTestFakeMotionEvent");
|
||
pXTestFakeButtonEvent = (fn_XTestFakeButtonEvent)dlsym(m_xtst_handle, "XTestFakeButtonEvent");
|
||
pXTestFakeKeyEvent = (fn_XTestFakeKeyEvent)dlsym(m_xtst_handle, "XTestFakeKeyEvent");
|
||
}
|
||
|
||
// 基本 X11 函数必须全部存在；XTest 函数可选（没有时无法控制输入）
|
||
return pXOpenDisplay && pXCloseDisplay && pXGetImage && pXDestroyImage &&
|
||
pXDefaultScreen && pXDisplayWidth && pXDisplayHeight && pXRootWindow &&
|
||
pXSetErrorHandler && pXCreatePixmap && pXFreePixmap &&
|
||
pXCreateGC && pXFreeGC && pXCopyArea && pXDefaultDepth && pXSync &&
|
||
pXKeysymToKeycode && pXFlush;
|
||
}
|
||
|
||
// 检查 XTest 扩展是否可用
|
||
bool HasXTest() const
|
||
{
|
||
return pXTestFakeMotionEvent && pXTestFakeButtonEvent && pXTestFakeKeyEvent;
|
||
}
|
||
|
||
~X11Loader()
|
||
{
|
||
if (m_xtst_handle) {
|
||
dlclose(m_xtst_handle);
|
||
m_xtst_handle = nullptr;
|
||
}
|
||
if (m_handle) {
|
||
dlclose(m_handle);
|
||
m_handle = nullptr;
|
||
}
|
||
}
|
||
|
||
private:
|
||
void* m_handle;
|
||
void* m_xtst_handle;
|
||
};
|
||
|
||
class ScreenHandler : public IOCPManager
|
||
{
|
||
public:
|
||
ScreenHandler(IOCPClient* client)
|
||
: m_client(client), m_running(false), m_destroyed(false), m_display(nullptr),
|
||
m_inputDisplay(nullptr),
|
||
m_width(0), m_height(0),
|
||
m_pixmap(0), m_gc(nullptr), m_xtestWarned(false),
|
||
m_bAlgorithm(ALGORITHM_DIFF), m_maxFPS(10), m_qualityLevel(QUALITY_ADAPTIVE)
|
||
{
|
||
if (!client) {
|
||
throw std::invalid_argument("IOCPClient pointer cannot be null");
|
||
}
|
||
|
||
// 加载保存的质量等级配置
|
||
LoadQualitySettings();
|
||
|
||
// 动态加载 X11
|
||
if (!m_x11.Load()) {
|
||
throw std::runtime_error("Failed to load libX11.so (X11 not installed)");
|
||
}
|
||
|
||
// 打开 X11 Display（截屏专用）
|
||
m_display = m_x11.pXOpenDisplay(nullptr);
|
||
if (!m_display) {
|
||
throw std::runtime_error("Failed to open X11 display (no desktop environment?)");
|
||
}
|
||
|
||
// 打开独立的 X11 Display（输入控制专用）
|
||
// X11 Display 不是线程安全的，截屏线程和回调线程必须使用各自独立的连接
|
||
if (m_x11.HasXTest()) {
|
||
m_inputDisplay = m_x11.pXOpenDisplay(nullptr);
|
||
}
|
||
|
||
// 设置自定义错误处理器，防止 BadMatch 等错误导致进程退出
|
||
m_x11.pXSetErrorHandler(x11_error_handler);
|
||
|
||
// 获取默认屏幕信息
|
||
int screen = m_x11.pXDefaultScreen(m_display);
|
||
m_width = m_x11.pXDisplayWidth(m_display, screen);
|
||
m_height = m_x11.pXDisplayHeight(m_display, screen);
|
||
m_root = m_x11.pXRootWindow(m_display, screen);
|
||
|
||
// 创建离屏 Pixmap 和 GC（解决合成窗口管理器下 XGetImage 的 BadMatch 问题）
|
||
int depth = m_x11.pXDefaultDepth(m_display, screen);
|
||
m_pixmap = m_x11.pXCreatePixmap(m_display, m_root, m_width, m_height, depth);
|
||
|
||
// GC 必须设置 subwindow_mode = IncludeInferiors，
|
||
// 否则 XCopyArea 会裁剪掉子窗口（应用程序窗口），只拷贝 root 背景
|
||
XGCValues_LNX gcv;
|
||
memset(&gcv, 0, sizeof(gcv));
|
||
gcv.subwindow_mode = IncludeInferiors;
|
||
m_gc = m_x11.pXCreateGC(m_display, m_root, GCSubwindowMode, &gcv);
|
||
if (!m_pixmap || !m_gc) {
|
||
throw std::runtime_error("Failed to create X11 Pixmap/GC for screen capture");
|
||
}
|
||
|
||
// 初始化 BITMAPINFOHEADER
|
||
memset(&m_bmpHeader, 0, sizeof(m_bmpHeader));
|
||
m_bmpHeader.biSize = sizeof(BITMAPINFOHEADER_LNX);
|
||
m_bmpHeader.biWidth = m_width;
|
||
m_bmpHeader.biHeight = m_height;
|
||
m_bmpHeader.biPlanes = 1;
|
||
m_bmpHeader.biBitCount = 32;
|
||
m_bmpHeader.biCompression = 0; // BI_RGB
|
||
m_bmpHeader.biSizeImage = m_width * m_height * 4;
|
||
|
||
// 分配帧缓冲
|
||
m_prevFrame.resize(m_bmpHeader.biSizeImage, 0);
|
||
m_currFrame.resize(m_bmpHeader.biSizeImage, 0);
|
||
|
||
// 差异帧缓冲: token(1) + algo(1) + cursorXY(8) + cursorType(1) + 最大差异数据
|
||
m_diffBuffer.resize(1 + 1 + 8 + 1 + m_bmpHeader.biSizeImage * 2);
|
||
}
|
||
|
||
~ScreenHandler()
|
||
{
|
||
// Mark as destroyed to prevent Start() from creating new thread
|
||
m_destroyed = true;
|
||
m_running = false;
|
||
|
||
// Lock to ensure Start() is not in the middle of creating thread
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_threadMutex);
|
||
if (m_captureThread.joinable()) {
|
||
m_captureThread.join();
|
||
}
|
||
}
|
||
if (m_inputDisplay && m_x11.pXCloseDisplay) {
|
||
m_x11.pXCloseDisplay(m_inputDisplay);
|
||
m_inputDisplay = nullptr;
|
||
}
|
||
if (m_display) {
|
||
if (m_gc && m_x11.pXFreeGC) m_x11.pXFreeGC(m_display, m_gc);
|
||
if (m_pixmap && m_x11.pXFreePixmap) m_x11.pXFreePixmap(m_display, m_pixmap);
|
||
m_pixmap = 0;
|
||
m_gc = nullptr;
|
||
// 强制全屏重绘，恢复 VMware SVGA 等虚拟显卡驱动的显示状态
|
||
// XClearArea(display, window, x, y, w, h, exposures)
|
||
// w=0, h=0 表示整个窗口；exposures=True 触发 Expose 事件强制所有窗口重绘
|
||
if (m_x11.pXClearArea) {
|
||
m_x11.pXClearArea(m_display, m_root, 0, 0, 0, 0, True);
|
||
}
|
||
m_x11.pXSync(m_display, 0);
|
||
if (m_x11.pXCloseDisplay) m_x11.pXCloseDisplay(m_display);
|
||
m_display = nullptr;
|
||
}
|
||
Mprintf(">>> ScreenHandler destroyed, display refreshed\n");
|
||
}
|
||
|
||
void Start()
|
||
{
|
||
// Prevent starting if destructor has begun
|
||
if (m_destroyed) return;
|
||
|
||
// Lock to prevent race with destructor
|
||
std::lock_guard<std::mutex> lock(m_threadMutex);
|
||
|
||
// Double-check after acquiring lock
|
||
if (m_destroyed) return;
|
||
|
||
// Prevent starting if thread is already running or joinable
|
||
if (m_captureThread.joinable()) return;
|
||
|
||
bool expected = false;
|
||
if (!m_running.compare_exchange_strong(expected, true)) return;
|
||
|
||
m_captureThread = std::thread(&ScreenHandler::CaptureLoop, this);
|
||
}
|
||
|
||
// 发送 BITMAPINFOHEADER + ScreenSettings（需在连接后、等待 COMMAND_NEXT 前调用）
|
||
void SendBitmapInfo()
|
||
{
|
||
const uint32_t ulLength = 1 + sizeof(BITMAPINFOHEADER_LNX) + 2 * sizeof(uint64_t) + sizeof(ScreenSettings);
|
||
std::vector<uint8_t> buf(ulLength, 0);
|
||
buf[0] = TOKEN_BITMAPINFO;
|
||
memcpy(&buf[1], &m_bmpHeader, sizeof(BITMAPINFOHEADER_LNX));
|
||
// 第一个 uint64_t 是 clientID，用于服务端识别客户端
|
||
uint64_t clientID = g_myClientID;
|
||
uint64_t zero = 0;
|
||
memcpy(&buf[1 + sizeof(BITMAPINFOHEADER_LNX)], &clientID, sizeof(uint64_t));
|
||
memcpy(&buf[1 + sizeof(BITMAPINFOHEADER_LNX) + sizeof(uint64_t)], &zero, sizeof(uint64_t));
|
||
ScreenSettings settings = {};
|
||
settings.MaxFPS = m_maxFPS.load();
|
||
settings.QualityLevel = m_qualityLevel; // 上报保存的质量等级
|
||
memcpy(&buf[1 + sizeof(BITMAPINFOHEADER_LNX) + 2 * sizeof(uint64_t)], &settings, sizeof(ScreenSettings));
|
||
m_client->Send2Server((char*)buf.data(), ulLength);
|
||
Mprintf(">>> SendBitmapInfo: clientID=%llu, QualityLevel=%d\n", clientID, m_qualityLevel);
|
||
}
|
||
|
||
virtual VOID OnReceive(PBYTE data, ULONG size)
|
||
{
|
||
if (!size) return;
|
||
|
||
switch (data[0]) {
|
||
case COMMAND_NEXT:
|
||
Start();
|
||
break;
|
||
|
||
case COMMAND_SCREEN_CONTROL:
|
||
// 处理鼠标/键盘控制命令
|
||
if (size >= 1 + sizeof(MSG64_LNX)) {
|
||
HandleInputEvent((MSG64_LNX*)(data + 1));
|
||
}
|
||
break;
|
||
|
||
case CMD_QUALITY_LEVEL:
|
||
// 质量等级调整: [cmd:1][level:1][persist:1]
|
||
if (size >= 2) {
|
||
int8_t level = (int8_t)data[1];
|
||
int persist = (size >= 3) ? data[2] : 0;
|
||
ApplyQualityLevel(level, persist);
|
||
}
|
||
break;
|
||
|
||
case COMMAND_SCREEN_SET_CLIPBOARD:
|
||
// 服务端设置剪贴板: [cmd:1][text:N]
|
||
if (size > 1) {
|
||
if (!ClipboardHandler::IsAvailable()) {
|
||
Mprintf("*** Clipboard unavailable (install xclip/xsel, need DISPLAY)\n");
|
||
} else if (ClipboardHandler::SetTextRaw((const char*)(data + 1), size - 1)) {
|
||
Mprintf(">>> Clipboard SET: %zu bytes\n", size - 1);
|
||
} else {
|
||
Mprintf("*** Clipboard SET failed\n");
|
||
}
|
||
}
|
||
break;
|
||
|
||
case COMMAND_SCREEN_GET_CLIPBOARD:
|
||
// 服务端请求剪贴板: [cmd:1][hash:64][hmac:16]
|
||
// 返回: [TOKEN_CLIPBOARD_TEXT:1][text:N] 或 [COMMAND_GET_FOLDER:1][files]
|
||
{
|
||
if (!ClipboardHandler::IsAvailable()) {
|
||
Mprintf("*** Clipboard unavailable (install xclip/xsel, need DISPLAY)\n");
|
||
uint8_t empty = TOKEN_CLIPBOARD_TEXT;
|
||
m_client->Send2Server((char*)&empty, 1);
|
||
break;
|
||
}
|
||
|
||
// 优先检查剪贴板中的文件
|
||
auto files = ClipboardHandler::GetFiles();
|
||
if (!files.empty()) {
|
||
// 返回 COMMAND_GET_FOLDER + 文件列表（多字符串格式：file1\0file2\0\0）
|
||
std::vector<uint8_t> buf;
|
||
buf.push_back(COMMAND_GET_FOLDER);
|
||
for (const auto& f : files) {
|
||
// 文件路径需要转换为 GBK 编码（服务端预期）
|
||
std::string gbkPath = FileTransferV2::utf8ToGbk(f);
|
||
buf.insert(buf.end(), gbkPath.begin(), gbkPath.end());
|
||
buf.push_back(0); // 每个路径后的 null 终止符
|
||
}
|
||
buf.push_back(0); // 结束标记
|
||
m_client->Send2Server((char*)buf.data(), buf.size());
|
||
Mprintf(">>> Clipboard GET: %zu files\n", files.size());
|
||
break;
|
||
}
|
||
|
||
// 没有文件，返回文本
|
||
std::string text = ClipboardHandler::GetText();
|
||
if (!text.empty()) {
|
||
std::vector<uint8_t> buf(1 + text.size());
|
||
buf[0] = TOKEN_CLIPBOARD_TEXT;
|
||
memcpy(&buf[1], text.data(), text.size());
|
||
m_client->Send2Server((char*)buf.data(), buf.size());
|
||
Mprintf(">>> Clipboard GET: %zu bytes text\n", text.size());
|
||
} else {
|
||
// 返回空剪贴板
|
||
uint8_t empty = TOKEN_CLIPBOARD_TEXT;
|
||
m_client->Send2Server((char*)&empty, 1);
|
||
Mprintf(">>> Clipboard GET: empty\n");
|
||
}
|
||
}
|
||
break;
|
||
|
||
case COMMAND_GET_FILE:
|
||
// 服务端请求下载文件: [cmd:1][targetDir\0][file1\0file2\0...\0]
|
||
// 使用 V2 协议上传文件
|
||
{
|
||
if (size < 3) break;
|
||
|
||
// 解析目标目录（GBK 编码）
|
||
const char* ptr = (const char*)(data + 1);
|
||
const char* end = (const char*)(data + size);
|
||
std::string targetDirGbk = ptr;
|
||
std::string targetDir = FileTransferV2::gbkToUtf8(targetDirGbk);
|
||
ptr += targetDirGbk.length() + 1;
|
||
|
||
// 解析文件列表
|
||
std::vector<std::string> files;
|
||
while (ptr < end && *ptr != '\0') {
|
||
std::string fileGbk = ptr;
|
||
files.push_back(FileTransferV2::gbkToUtf8(fileGbk));
|
||
ptr += fileGbk.length() + 1;
|
||
}
|
||
|
||
// 如果没有文件列表，从剪贴板获取
|
||
if (files.empty()) {
|
||
files = ClipboardHandler::GetFiles();
|
||
}
|
||
|
||
if (!files.empty() && !targetDir.empty()) {
|
||
Mprintf(">>> COMMAND_GET_FILE: %zu files -> %s\n", files.size(), targetDir.c_str());
|
||
|
||
// 使用 V2 协议发送文件
|
||
extern uint64_t g_myClientID;
|
||
std::thread([this, files, targetDir]() {
|
||
// 收集所有文件（展开目录）
|
||
std::vector<std::string> allFiles;
|
||
std::vector<std::string> rootCandidates;
|
||
|
||
for (const auto& path : files) {
|
||
struct stat st;
|
||
if (stat(path.c_str(), &st) != 0) continue;
|
||
|
||
if (S_ISDIR(st.st_mode)) {
|
||
std::string dirPath = path;
|
||
if (dirPath.back() != '/') dirPath += '/';
|
||
size_t pos = dirPath.rfind('/', dirPath.length() - 2);
|
||
std::string parentPath = (pos != std::string::npos) ? dirPath.substr(0, pos + 1) : dirPath;
|
||
rootCandidates.push_back(parentPath);
|
||
FileTransferV2::CollectFiles(dirPath, allFiles);
|
||
} else {
|
||
rootCandidates.push_back(path);
|
||
allFiles.push_back(path);
|
||
}
|
||
}
|
||
|
||
if (allFiles.empty()) {
|
||
Mprintf("*** No files to send\n");
|
||
return;
|
||
}
|
||
|
||
std::string commonRoot = FileTransferV2::GetCommonRoot(rootCandidates);
|
||
Mprintf(">>> Sending %zu files, root=%s\n", allFiles.size(), commonRoot.c_str());
|
||
|
||
FileTransferV2::SendFilesV2(allFiles, targetDir, commonRoot, m_client, g_myClientID);
|
||
}).detach();
|
||
} else {
|
||
Mprintf("*** COMMAND_GET_FILE: no files or empty target\n");
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 加载保存的质量设置
|
||
void LoadQualitySettings()
|
||
{
|
||
m_qualityLevel = (int8_t)m_config.GetInt("QualityLevel", QUALITY_ADAPTIVE);
|
||
Mprintf(">>> LoadQualitySettings: level=%d\n", m_qualityLevel);
|
||
|
||
// 如果有保存的具体等级，立即应用
|
||
if (m_qualityLevel >= 0 && m_qualityLevel < QUALITY_COUNT) {
|
||
const QualityProfile& profile = GetQualityProfile(m_qualityLevel);
|
||
m_maxFPS.store(profile.maxFPS);
|
||
m_bAlgorithm.store(GetEffectiveAlgorithm(profile.algorithm));
|
||
}
|
||
}
|
||
|
||
// 应用质量等级配置
|
||
void ApplyQualityLevel(int8_t level, int persist = 0)
|
||
{
|
||
m_qualityLevel = level;
|
||
|
||
// 保存到配置文件
|
||
if (persist) {
|
||
m_config.SetInt("QualityLevel", level);
|
||
Mprintf(">>> Quality saved: level=%d\n", level);
|
||
}
|
||
|
||
if (level == QUALITY_DISABLED) {
|
||
// 关闭模式：保持当前设置
|
||
Mprintf(">>> Quality: Disabled (keep current)\n");
|
||
return;
|
||
}
|
||
|
||
if (level >= 0 && level < QUALITY_COUNT) {
|
||
// 具体等级：从配置表获取并应用
|
||
const QualityProfile& profile = GetQualityProfile(level);
|
||
|
||
// 应用帧率
|
||
m_maxFPS.store(profile.maxFPS);
|
||
|
||
// 应用算法（带降级处理）
|
||
uint8_t algo = GetEffectiveAlgorithm(profile.algorithm);
|
||
m_bAlgorithm.store(algo);
|
||
|
||
Mprintf(">>> Quality: Level=%d, FPS=%d, Algo=%d->%d\n",
|
||
level, profile.maxFPS, profile.algorithm, algo);
|
||
} else {
|
||
// 自适应模式 (level=-1)：由服务端动态调整，不做处理
|
||
Mprintf(">>> Quality: Adaptive mode\n");
|
||
}
|
||
}
|
||
|
||
// 处理来自服务端的鼠标/键盘输入事件
|
||
// 使用独立的 m_inputDisplay，避免与截屏线程的 m_display 产生竞争
|
||
void HandleInputEvent(const MSG64_LNX* msg)
|
||
{
|
||
if (!m_inputDisplay || !m_x11.HasXTest()) {
|
||
if (!m_xtestWarned) {
|
||
Mprintf("*** XTest not available, cannot handle input ***\n");
|
||
m_xtestWarned = true;
|
||
}
|
||
return;
|
||
}
|
||
|
||
unsigned int message = (unsigned int)msg->message;
|
||
// 从 lParam 提取坐标 (MAKELPARAM 格式: low 16 bits = x, high 16 bits = y)
|
||
// 注意：不使用 pt_x/pt_y，因为 Windows MSG64 结构可能有填充导致偏移不一致
|
||
int x = (int)(msg->lParam & 0xFFFF);
|
||
int y = (int)((msg->lParam >> 16) & 0xFFFF);
|
||
|
||
switch (message) {
|
||
// ================== 鼠标事件 ==================
|
||
case WM_MOUSEMOVE:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_LBUTTONDOWN:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, True, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_LBUTTONUP:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_LBUTTONDBLCLK:
|
||
// 双击：快速按下释放两次
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, False, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button1, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_RBUTTONDOWN:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, True, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_RBUTTONUP:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_RBUTTONDBLCLK:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, False, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button3, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_MBUTTONDOWN:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, True, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_MBUTTONUP:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_MBUTTONDBLCLK:
|
||
m_x11.pXTestFakeMotionEvent(m_inputDisplay, -1, x, y, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, False, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, Button2, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
|
||
case WM_MOUSEWHEEL: {
|
||
short delta = GET_WHEEL_DELTA_WPARAM(msg->wParam);
|
||
// 滚轮：正值向上(Button4)，负值向下(Button5)
|
||
unsigned int button = (delta > 0) ? Button4 : Button5;
|
||
int clicks = abs(delta) / 120; // 标准滚轮增量是120
|
||
if (clicks < 1) clicks = 1;
|
||
for (int i = 0; i < clicks; i++) {
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, button, True, 0);
|
||
m_x11.pXTestFakeButtonEvent(m_inputDisplay, button, False, 0);
|
||
}
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
break;
|
||
}
|
||
|
||
// ================== 键盘事件 ==================
|
||
case WM_KEYDOWN:
|
||
case WM_SYSKEYDOWN: {
|
||
unsigned int vk = (unsigned int)msg->wParam;
|
||
unsigned long keysym = VKtoKeySym(vk);
|
||
if (keysym) {
|
||
unsigned int keycode = m_x11.pXKeysymToKeycode(m_inputDisplay, keysym);
|
||
if (keycode) {
|
||
m_x11.pXTestFakeKeyEvent(m_inputDisplay, keycode, True, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
case WM_KEYUP:
|
||
case WM_SYSKEYUP: {
|
||
unsigned int vk = (unsigned int)msg->wParam;
|
||
unsigned long keysym = VKtoKeySym(vk);
|
||
if (keysym) {
|
||
unsigned int keycode = m_x11.pXKeysymToKeycode(m_inputDisplay, keysym);
|
||
if (keycode) {
|
||
m_x11.pXTestFakeKeyEvent(m_inputDisplay, keycode, False, 0);
|
||
m_x11.pXFlush(m_inputDisplay);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
private:
|
||
IOCPClient* m_client;
|
||
std::atomic<bool> m_running;
|
||
std::atomic<bool> m_destroyed; // Flag to prevent Start() after destruction begins
|
||
std::mutex m_threadMutex; // Protects m_captureThread lifecycle
|
||
std::thread m_captureThread;
|
||
bool m_xtestWarned;
|
||
|
||
// X11 动态加载
|
||
X11Loader m_x11;
|
||
Display* m_display; // 截屏线程专用
|
||
Display* m_inputDisplay; // 输入控制专用（OnReceive 回调线程）
|
||
Window m_root;
|
||
Pixmap m_pixmap;
|
||
GC m_gc;
|
||
int m_width;
|
||
int m_height;
|
||
|
||
// 协议
|
||
BITMAPINFOHEADER_LNX m_bmpHeader;
|
||
std::vector<uint8_t> m_prevFrame;
|
||
std::vector<uint8_t> m_currFrame;
|
||
std::vector<uint8_t> m_diffBuffer;
|
||
|
||
// 自适应质量控制
|
||
std::atomic<uint8_t> m_bAlgorithm; // 当前算法 (ALGORITHM_DIFF/RGB565/GRAY)
|
||
std::atomic<int> m_maxFPS; // 最大帧率
|
||
int8_t m_qualityLevel; // 当前质量等级 (-1=自适应, 0-5=具体等级)
|
||
LinuxConfig m_config; // 配置持久化 (~/.config/ghost/config.conf)
|
||
|
||
// X11 截屏，输出 BGRA 格式（自底向上，与 BMP 一致）
|
||
// 使用 XCopyArea 将 root window 拷贝到离屏 Pixmap，再对 Pixmap 调用 XGetImage
|
||
// 这样可以避免合成窗口管理器（Mutter 等）导致的 BadMatch 错误
|
||
bool CaptureScreen(std::vector<uint8_t>& buffer)
|
||
{
|
||
// 先将 root window 内容拷贝到离屏 Pixmap
|
||
m_x11.pXCopyArea(m_display, m_root, m_pixmap, m_gc, 0, 0, m_width, m_height, 0, 0);
|
||
m_x11.pXSync(m_display, 0); // 等待拷贝完成
|
||
|
||
// AllPlanes = ~0UL, ZPixmap = 2
|
||
XImage* img = m_x11.pXGetImage(m_display, m_pixmap, 0, 0, m_width, m_height, ~0UL, 2);
|
||
if (!img) return false;
|
||
|
||
// X11 ZPixmap 通常是 BGRA (bits_per_pixel=32)，但行序是自顶向下
|
||
// BMP 期望自底向上，需要翻转
|
||
int rowBytes = m_width * 4;
|
||
for (int y = 0; y < m_height; y++) {
|
||
int srcRow = y;
|
||
int dstRow = m_height - 1 - y; // 翻转
|
||
uint8_t* src = (uint8_t*)img->data + srcRow * img->bytes_per_line;
|
||
uint8_t* dst = buffer.data() + dstRow * rowBytes;
|
||
|
||
if (img->bits_per_pixel == 32) {
|
||
// X11 通常是 BGRX，需要确保 alpha 通道
|
||
for (int x = 0; x < m_width; x++) {
|
||
dst[x * 4 + 0] = src[x * 4 + 0]; // B
|
||
dst[x * 4 + 1] = src[x * 4 + 1]; // G
|
||
dst[x * 4 + 2] = src[x * 4 + 2]; // R
|
||
dst[x * 4 + 3] = 0xFF; // A
|
||
}
|
||
} else {
|
||
// 不支持非 32 位格式
|
||
m_x11.pXDestroyImage(img);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
m_x11.pXDestroyImage(img);
|
||
return true;
|
||
}
|
||
|
||
// 发送第一帧完整截图
|
||
void SendFirstScreen()
|
||
{
|
||
if (!CaptureScreen(m_currFrame)) return;
|
||
|
||
uint32_t imgSize = m_bmpHeader.biSizeImage;
|
||
std::vector<uint8_t> buf(1 + imgSize);
|
||
buf[0] = TOKEN_FIRSTSCREEN;
|
||
memcpy(&buf[1], m_currFrame.data(), imgSize);
|
||
|
||
m_client->Send2Server((char*)buf.data(), buf.size());
|
||
|
||
// 保存为上一帧
|
||
m_prevFrame = m_currFrame;
|
||
}
|
||
|
||
// 计算差异并发送 TOKEN_NEXTSCREEN
|
||
// 差异格式: 每个变化区域 = offset(4字节) + length(4字节) + pixel data
|
||
void SendDiffFrame()
|
||
{
|
||
if (!CaptureScreen(m_currFrame)) return;
|
||
|
||
uint8_t* out = m_diffBuffer.data();
|
||
out[0] = TOKEN_NEXTSCREEN;
|
||
uint8_t* data = out + 1;
|
||
|
||
// 写入算法类型（使用当前生效的算法）
|
||
uint8_t algo = m_bAlgorithm.load();
|
||
memcpy(data, &algo, sizeof(uint8_t));
|
||
|
||
// 写入光标位置 (Linux 端简单置 0)
|
||
int32_t cursorX = 0, cursorY = 0;
|
||
memcpy(data + 1, &cursorX, sizeof(int32_t));
|
||
memcpy(data + 1 + sizeof(int32_t), &cursorY, sizeof(int32_t));
|
||
|
||
// 写入光标类型
|
||
uint8_t cursorType = 0;
|
||
memcpy(data + 1 + 2 * sizeof(int32_t), &cursorType, sizeof(uint8_t));
|
||
|
||
uint32_t headerSize = 1 + 2 * sizeof(int32_t) + 1; // algo + cursor + cursorType
|
||
uint8_t* diffData = data + headerSize;
|
||
uint32_t diffLen = CompareBitmap(m_currFrame.data(), m_prevFrame.data(),
|
||
diffData, m_bmpHeader.biSizeImage, algo);
|
||
|
||
uint32_t totalLen = 1 + headerSize + diffLen;
|
||
m_client->Send2Server((char*)out, totalLen);
|
||
|
||
// 更新上一帧
|
||
std::swap(m_prevFrame, m_currFrame);
|
||
}
|
||
|
||
// 差异比较算法（支持 DIFF/RGB565/GRAY）
|
||
// 输出格式: [byteOffset(4) + length(4) + pixel data] ...
|
||
// DIFF: length = 字节数, data = BGRA 原始数据
|
||
// RGB565: length = 像素数, data = RGB565 格式
|
||
// GRAY: length = 像素数, data = 灰度值
|
||
uint32_t CompareBitmap(const uint8_t* curr, const uint8_t* prev,
|
||
uint8_t* outBuf, uint32_t totalBytes, uint8_t algo)
|
||
{
|
||
const uint32_t bytesPerPixel = 4;
|
||
const uint32_t totalPixels = totalBytes / bytesPerPixel;
|
||
const uint32_t gapThreshold = 8; // 8 像素间隙容忍
|
||
|
||
// 根据算法确定长度字段的除数
|
||
// GRAY/RGB565: 长度字段存像素数 (ratio=4)
|
||
// DIFF: 长度字段存字节数 (ratio=1)
|
||
const uint32_t ratio = (algo == ALGORITHM_GRAY || algo == ALGORITHM_RGB565) ? 4 : 1;
|
||
|
||
uint32_t outOffset = 0;
|
||
uint32_t i = 0;
|
||
|
||
while (i < totalPixels) {
|
||
// 跳过相同像素
|
||
while (i < totalPixels &&
|
||
*(uint32_t*)(curr + i * 4) == *(uint32_t*)(prev + i * 4)) {
|
||
i++;
|
||
}
|
||
if (i >= totalPixels) break;
|
||
|
||
// 找到变化区域的起始
|
||
uint32_t start = i;
|
||
uint32_t lastDiff = i;
|
||
|
||
// 扫描直到连续 gapThreshold 个像素相同
|
||
while (i < totalPixels) {
|
||
if (*(uint32_t*)(curr + i * 4) != *(uint32_t*)(prev + i * 4)) {
|
||
lastDiff = i;
|
||
} else if (i - lastDiff > gapThreshold) {
|
||
break;
|
||
}
|
||
i++;
|
||
}
|
||
|
||
uint32_t end = lastDiff + 1;
|
||
uint32_t count = end - start; // 像素数
|
||
uint32_t byteOffset = start * bytesPerPixel;
|
||
uint32_t byteCount = count * bytesPerPixel;
|
||
|
||
// 写入 byteOffset
|
||
memcpy(outBuf + outOffset, &byteOffset, sizeof(uint32_t));
|
||
outOffset += sizeof(uint32_t);
|
||
|
||
// 写入 length（根据算法不同）
|
||
uint32_t lengthField = byteCount / ratio;
|
||
memcpy(outBuf + outOffset, &lengthField, sizeof(uint32_t));
|
||
outOffset += sizeof(uint32_t);
|
||
|
||
// 写入像素数据（根据算法转换）
|
||
const uint8_t* srcData = curr + byteOffset;
|
||
if (algo == ALGORITHM_RGB565) {
|
||
ConvertBGRAtoRGB565(srcData, (uint16_t*)(outBuf + outOffset), count);
|
||
outOffset += count * 2; // RGB565: 2 字节/像素
|
||
} else if (algo == ALGORITHM_GRAY) {
|
||
ConvertBGRAtoGray(srcData, outBuf + outOffset, count);
|
||
outOffset += count; // GRAY: 1 字节/像素
|
||
} else {
|
||
// DIFF: 原样复制 BGRA
|
||
memcpy(outBuf + outOffset, srcData, byteCount);
|
||
outOffset += byteCount; // DIFF: 4 字节/像素
|
||
}
|
||
}
|
||
|
||
return outOffset;
|
||
}
|
||
|
||
|
||
// 获取单调时钟毫秒数（墙钟时间，不受系统时间调整影响）
|
||
static uint64_t GetTickMs()
|
||
{
|
||
struct timespec ts;
|
||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||
return (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
|
||
}
|
||
|
||
// 截屏主循环
|
||
void CaptureLoop()
|
||
{
|
||
try {
|
||
Mprintf(">>> ScreenHandler CaptureLoop started (%dx%d)\n", m_width, m_height);
|
||
|
||
// 发送第一帧
|
||
SendFirstScreen();
|
||
|
||
while (m_running) {
|
||
uint64_t start = GetTickMs();
|
||
|
||
SendDiffFrame();
|
||
|
||
// 动态计算帧间隔（根据当前 maxFPS）
|
||
int fps = m_maxFPS.load();
|
||
if (fps <= 0) fps = 10; // 防止除零
|
||
int sleepMs = 1000 / fps;
|
||
|
||
int elapsed = (int)(GetTickMs() - start);
|
||
int wait = sleepMs - elapsed;
|
||
if (wait > 0) {
|
||
usleep(wait * 1000);
|
||
}
|
||
}
|
||
|
||
Mprintf(">>> ScreenHandler CaptureLoop stopped\n");
|
||
} catch (const std::exception& e) {
|
||
Mprintf("*** CaptureLoop exception: %s ***\n", e.what());
|
||
} catch (...) {
|
||
Mprintf("*** CaptureLoop unknown exception ***\n");
|
||
}
|
||
}
|
||
};
|