桌面端(非触摸)控制 Android TV/盒子时,鼠标悬停会被客户端翻译成焦点移动, 鼠标划过画面就改变焦点。改为只在按住左键拖动时控制;触摸浏览器行为不变。 - MFC 主控:按 clientID 在主连接上解析并缓存客户端类型(新增线程安全的 GetHostClientType,类型值在 m_cs 内读取);APK 主机的 WM_MOUSEMOVE 仅在 MK_LBUTTON 按下时转发,不再每次移动都查主连接。 - Web 控制台:桌面 mousemove 对 Android 主机(优先使用服务端 isAndroidRemote, 设备 os/clientType 只作兜底)只在左键按下时发 move;检查放在发送节流之后。 touchstart/touchmove/touchend 未改动,触摸屏的单指移动、点按、拖拽、滚动 和边缘手势保持原状。 - 安卓客户端未修改:TV 模式仍把带按键的 move 翻译成焦点导航,触摸浏览器 发出的不带按键 move 继续可用。 验证:MFC Debug 服务端、Go 服务端构建通过;内联 JS 通过 node --check。 Model: deepseek-flash Co-Authored-By: Claude Code <noreply@anthropic.com>
5272 lines
219 KiB
C++
5272 lines
219 KiB
C++
// ScreenSpyDlg.cpp : 实现文件
|
||
//
|
||
|
||
#include "stdafx.h"
|
||
#include "2015Remote.h"
|
||
#include "ScreenSpyDlg.h"
|
||
#include "afxdialogex.h"
|
||
#include <imm.h>
|
||
#pragma comment(lib, "imm32.lib")
|
||
#include <WinUser.h>
|
||
#include <mmsystem.h>
|
||
#pragma comment(lib, "winmm.lib")
|
||
#include "CGridDialog.h"
|
||
#include "2015RemoteDlg.h"
|
||
#include "CPasswordDlg.h"
|
||
#include "InputDlg.h"
|
||
#include "CDlgFileSend.h"
|
||
#include <file_upload.h>
|
||
#include <md5.h>
|
||
#include <cstdint> // for uint16_t
|
||
|
||
extern CMy2015RemoteDlg* g_2015RemoteDlg;
|
||
|
||
extern "C" uint32_t licenseGetBuildTag() { volatile uint32_t tag = 0xC0DE2026u; return tag; }
|
||
#include <vector>
|
||
#include <mutex> // for std::mutex, std::lock_guard
|
||
#include "WebService.h"
|
||
|
||
// 文件接收消息数据结构
|
||
struct FileV2MsgData {
|
||
std::vector<BYTE> data; // 原始数据
|
||
uint64_t transferID;
|
||
FileV2MsgData(const BYTE* buf, size_t len, uint64_t tid)
|
||
: data(buf, buf + len), transferID(tid) {}
|
||
};
|
||
|
||
// CScreenSpyDlg 对话框
|
||
|
||
// IDM_* enum 已移至 ScreenSpyDlg.h
|
||
|
||
IMPLEMENT_DYNAMIC(CScreenSpyDlg, CDialog)
|
||
|
||
// 算法标识 (与客户端 CursorInfo.h 保持一致)
|
||
#define ALGORITHM_GRAY 0
|
||
#define ALGORITHM_DIFF 1
|
||
#define ALGORITHM_H264 2
|
||
#define ALGORITHM_HOME 3
|
||
#define ALGORITHM_RGB565 3
|
||
|
||
#define TIMER_ID 132
|
||
|
||
// H.264 Annex B keyframe 探测:扫描 start code (00 00 01 / 00 00 00 01),
|
||
// 取后续 NAL header low 5 bits,命中 5 (IDR) / 7 (SPS) / 8 (PPS) 即认定为关键帧。
|
||
static bool IsH264Keyframe(const uint8_t* data, size_t len)
|
||
{
|
||
for (size_t i = 0; i + 4 < len; ++i) {
|
||
size_t nalOffset = 0;
|
||
if (data[i] == 0 && data[i+1] == 0 && data[i+2] == 0 && data[i+3] == 1) {
|
||
nalOffset = i + 4;
|
||
} else if (data[i] == 0 && data[i+1] == 0 && data[i+2] == 1) {
|
||
nalOffset = i + 3;
|
||
} else {
|
||
continue;
|
||
}
|
||
if (nalOffset >= len) continue;
|
||
uint8_t nalType = data[nalOffset] & 0x1F;
|
||
if (nalType == 5 || nalType == 7 || nalType == 8) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// AV1 OBU keyframe 探测:扫描 OBU 链,遇到 OBU_SEQUENCE_HEADER (type 1) 即认定为关键帧。
|
||
// FFmpeg AV1 编码器在每个 IDR 前必定插入 SEQ HDR,因此该判定与 H.264 NAL 5/7/8 语义对齐。
|
||
static bool IsAv1Keyframe(const uint8_t* data, size_t len)
|
||
{
|
||
size_t pos = 0;
|
||
while (pos < len) {
|
||
uint8_t hdr = data[pos];
|
||
uint8_t obu_type = (hdr >> 3) & 0x0F;
|
||
bool has_ext = (hdr & 0x04) != 0;
|
||
bool has_size = (hdr & 0x02) != 0;
|
||
if (obu_type == 1 /*OBU_SEQUENCE_HEADER*/) return true;
|
||
pos++;
|
||
if (has_ext) {
|
||
if (pos >= len) return false;
|
||
pos++;
|
||
}
|
||
if (!has_size) return false; // 无 size 字段:OBU 占满到包尾,无法继续解析
|
||
// LEB128 size
|
||
uint64_t sz = 0;
|
||
for (int i = 0; i < 8; ++i) {
|
||
if (pos >= len) return false;
|
||
uint8_t b = data[pos++];
|
||
sz |= (uint64_t)(b & 0x7F) << (7 * i);
|
||
if ((b & 0x80) == 0) break;
|
||
}
|
||
if (pos + sz > len) return false;
|
||
pos += (size_t)sz;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 首字节嗅探:H.264 Annex B 首字节恒为 0x00(起始码);AV1 OBU header 首字节
|
||
// bit7=0、bits[3:6]=obu_type 1-15,典型值 0x08-0x78,绝不为 0x00。
|
||
// 一字节即可干净区分两套码流,无需协议字段或编码端协商。
|
||
static bool IsAnyKeyframe(const uint8_t* data, size_t len)
|
||
{
|
||
if (len == 0) return false;
|
||
return data[0] == 0x00 ? IsH264Keyframe(data, len) : IsAv1Keyframe(data, len);
|
||
}
|
||
|
||
// 静态成员变量定义
|
||
int CScreenSpyDlg::s_nFastStretch = -1; // -1 表示未初始化
|
||
|
||
bool CScreenSpyDlg::GetFastStretchMode()
|
||
{
|
||
if (s_nFastStretch < 0) {
|
||
s_nFastStretch = THIS_CFG.GetInt("settings", "FastStretch", 0);
|
||
}
|
||
return s_nFastStretch != 0;
|
||
}
|
||
|
||
void CScreenSpyDlg::SetFastStretchMode(bool bFast)
|
||
{
|
||
s_nFastStretch = bFast ? 1 : 0;
|
||
THIS_CFG.SetInt("settings", "FastStretch", s_nFastStretch);
|
||
}
|
||
|
||
// RGB565 → BGRA32 转换函数
|
||
// 输入: RGB565 像素数据 (每像素 2 字节)
|
||
// 输出: BGRA 像素数据 (每像素 4 字节)
|
||
// RGB565 格式: RRRRRGGG GGGBBBBB (R:5位, G:6位, B:5位)
|
||
inline void ConvertRGB565ToBGRA(const uint16_t* src, BYTE* dst, ULONG pixelCount)
|
||
{
|
||
for (ULONG i = 0; i < pixelCount; i++, src++, dst += 4) {
|
||
uint16_t c = *src;
|
||
// 位复制填充低位,还原更精确
|
||
BYTE r5 = (c >> 11) & 0x1F;
|
||
BYTE g6 = (c >> 5) & 0x3F;
|
||
BYTE b5 = c & 0x1F;
|
||
dst[2] = (r5 << 3) | (r5 >> 2); // R: 5→8位
|
||
dst[1] = (g6 << 2) | (g6 >> 4); // G: 6→8位
|
||
dst[0] = (b5 << 3) | (b5 >> 2); // B: 5→8位
|
||
dst[3] = 0xFF; // A: 不透明
|
||
}
|
||
}
|
||
|
||
#ifdef _WIN64
|
||
#ifdef _DEBUG
|
||
#pragma comment(lib, "FileUpload_Libx64d.lib")
|
||
#pragma comment(lib, "PrivateDesktop_Libx64d.lib")
|
||
#else
|
||
#pragma comment(lib, "FileUpload_Libx64.lib")
|
||
#pragma comment(lib, "PrivateDesktop_Libx64.lib")
|
||
#endif
|
||
#else
|
||
#ifdef _DEBUG
|
||
#pragma comment(lib, "FileUpload_Libd.lib")
|
||
#pragma comment(lib, "PrivateDesktop_Libd.lib")
|
||
#else
|
||
#pragma comment(lib, "FileUpload_Lib.lib")
|
||
#pragma comment(lib, "PrivateDesktop_Lib.lib")
|
||
#endif
|
||
#endif
|
||
|
||
extern "C" void* x265_api_get_192()
|
||
{
|
||
return nullptr;
|
||
}
|
||
|
||
extern "C" char* __imp_strtok(char* str, const char* delim)
|
||
{
|
||
return strtok(str, delim);
|
||
}
|
||
|
||
CScreenSpyDlg::CScreenSpyDlg(CMy2015RemoteDlg* Parent, Server* IOCPServer, CONTEXT_OBJECT* ContextObject)
|
||
: DialogBase(CScreenSpyDlg::IDD, Parent, IOCPServer, ContextObject, 0)
|
||
{
|
||
m_bUsingFRP = THIS_CFG.GetInt("frp", "UseFrp", 0);
|
||
if (m_bUsingFRP != 0 && m_bUsingFRP != 1)
|
||
m_bUsingFRP = 1;
|
||
m_pParent = Parent;
|
||
m_hFullDC = NULL;
|
||
m_hFullMemDC = NULL;
|
||
m_BitmapHandle = NULL;
|
||
|
||
m_lastMouseMove = 0;
|
||
m_lastMousePoint = {};
|
||
m_pCodec = nullptr;
|
||
m_pCodecContext = nullptr;
|
||
memset(&m_AVPacket, 0, sizeof(AVPacket));
|
||
memset(&m_AVFrame, 0, sizeof(AVFrame));
|
||
|
||
//创建解码器.
|
||
bool succeed = false;
|
||
m_pCodec = avcodec_find_decoder(AV_CODEC_ID_H264);
|
||
if (m_pCodec) {
|
||
m_pCodecContext = avcodec_alloc_context3(m_pCodec);
|
||
if (m_pCodecContext) {
|
||
succeed = (0 == avcodec_open2(m_pCodecContext, m_pCodec, 0));
|
||
}
|
||
}
|
||
m_FrameID = 0;
|
||
// 不在构造函数中禁用 IME,改为在 OnInitDialog 中仅禁用此窗口的 IME
|
||
|
||
CHAR szFullPath[MAX_PATH];
|
||
GetSystemDirectory(szFullPath, MAX_PATH);
|
||
lstrcat(szFullPath, "\\shell32.dll"); //图标
|
||
m_hIcon = ExtractIcon(THIS_APP->m_hInstance, szFullPath, 17);
|
||
|
||
m_bIsFirst = TRUE;
|
||
m_ulHScrollPos = 0;
|
||
m_ulVScrollPos = 0;
|
||
|
||
const ULONG ulBitmapInforLength = sizeof(BITMAPINFOHEADER);
|
||
m_BitmapInfor_Full = (BITMAPINFO *) new BYTE[ulBitmapInforLength];
|
||
m_ContextObject->InDeCompressedBuffer.CopyBuffer(m_BitmapInfor_Full, ulBitmapInforLength, 1);
|
||
// CopyBuffer 用 ULONG 相减做长度检查,缓冲比偏移 57 还短时会下溢成一个大数而
|
||
// “通过”检查;所以这里先确认整块 ScreenSettings 都在。超短包保留默认值。
|
||
if (m_ContextObject->InDeCompressedBuffer.GetBufferLength() >= 57 + (int)sizeof(ScreenSettings))
|
||
m_ContextObject->InDeCompressedBuffer.CopyBuffer(&m_Settings, sizeof(ScreenSettings), 57);
|
||
|
||
// 解析 clientID (在 BITMAPINFOHEADER 之后,偏移 41)
|
||
// 格式: [TOKEN_BITMAPINFO:1][BITMAPINFOHEADER:40][clientID:8][dlgID:8][ScreenSettings:...]
|
||
LPBYTE pClientID = m_ContextObject->InDeCompressedBuffer.GetBuffer(41);
|
||
if (pClientID) {
|
||
m_ClientID = *((uint64_t*)pClientID);
|
||
|
||
// Notify web clients of resolution (only for Web sessions, not MFC sessions)
|
||
// At this point, IsMfcTriggered is still set if MFC triggered this dialog
|
||
if (WebService().IsRunning() && !WebService().IsMfcTriggered(m_ClientID)) {
|
||
int width = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int height = abs(m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
bool topDown = (m_BitmapInfor_Full->bmiHeader.biClrImportant == 1);
|
||
// m_ContextObject is the screen sub-connection; client_type lives on the
|
||
// main login connection. Look it up via the peer IP (same pattern as GetClientEncoding).
|
||
std::string clientType;
|
||
if (g_2015RemoteDlg) {
|
||
context* main = g_2015RemoteDlg->FindHostByClientID(m_ClientID);
|
||
if (main) clientType = main->GetAdditionalData(RES_CLIENT_TYPE).GetString();
|
||
}
|
||
WebService().NotifyResolutionChange(m_ClientID, width, height, topDown, clientType);
|
||
// 透传客户端初始的音频开/关状态给 web,让前端按钮显示正确
|
||
WebService().NotifyAudioState(m_ClientID, m_Settings.AudioEnabled != 0);
|
||
}
|
||
}
|
||
|
||
// 逐客户端的调优开关:对话框建立时读回本客户端的设置,之后打开远程桌面即按此下发。
|
||
LoadScreenTuning();
|
||
|
||
// 从客户端配置初始化自适应质量状态 (QualityLevel: -2=关闭, -1=自适应, 0-5=具体等级)
|
||
m_AdaptiveQuality.startTime = GetTickCount64(); // 记录启动时间
|
||
if (m_Settings.QualityLevel == QUALITY_DISABLED) {
|
||
m_AdaptiveQuality.enabled = false;
|
||
m_AdaptiveQuality.currentLevel = QUALITY_GOOD; // 关闭模式时不使用等级
|
||
} else if (m_Settings.QualityLevel == QUALITY_ADAPTIVE) {
|
||
m_AdaptiveQuality.enabled = true;
|
||
m_AdaptiveQuality.currentLevel = QUALITY_GOOD; // 自适应默认从 Good 开始
|
||
} else if (m_Settings.QualityLevel >= 0 && m_Settings.QualityLevel < QUALITY_COUNT) {
|
||
m_AdaptiveQuality.enabled = false;
|
||
m_AdaptiveQuality.currentLevel = m_Settings.QualityLevel;
|
||
}
|
||
// 初始化当前分辨率限制(关闭模式时为0,不限制)
|
||
if (m_Settings.QualityLevel != QUALITY_DISABLED) {
|
||
m_AdaptiveQuality.currentMaxWidth = GetQualityProfile(m_AdaptiveQuality.currentLevel).maxWidth;
|
||
} else {
|
||
m_AdaptiveQuality.currentMaxWidth = 0;
|
||
}
|
||
|
||
m_bIsCtrl = FALSE;
|
||
m_bIsTraceCursor = FALSE;
|
||
}
|
||
|
||
|
||
// 下发本会话「远程桌面调优」的开关位:[cmd:1][flags:4 LE][version:1]。
|
||
// 四位全发:低三位让客户端立刻生效,bit3 是主控端自用判据,客户端只原样存进
|
||
// 本机配置,下次随 ScreenSettings.TuningFlags 回报。全 0 也照发,客户端据此把
|
||
// 可能残留的旧标志清掉(同一客户端先后被不同主控端打开时)。
|
||
// 末尾的版本字节让新客户端区分本端和老主控端(负载只有 5 字节):老主控端不认识
|
||
// bit3,新客户端收到时就只让低三位生效、不落盘。
|
||
// 老客户端不认识这条命令,OnReceive 的 switch 无 default 分支,直接忽略。
|
||
VOID CScreenSpyDlg::SendScreenTuning(void)
|
||
{
|
||
int flags = GetScreenTuningFlags();
|
||
BYTE cmd[1 + sizeof(int) + 1] = { CMD_SCREEN_TUNING };
|
||
memcpy(cmd + 1, &flags, sizeof(int));
|
||
cmd[1 + sizeof(int)] = SCREEN_TUNING_CMD_VERSION;
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
Mprintf("[ScreenSpy] 下发调优开关: 0x%08X\n", flags);
|
||
}
|
||
|
||
// 当前开关位。bit3(自适应吞吐判据)也包含在内:客户端不解释它,只负责保存并回报,
|
||
// 这样四个开关能共用 ScreenSettings.TuningFlags 一个字段实现逐客户端持久化。
|
||
int CScreenSpyDlg::GetScreenTuningFlags() const
|
||
{
|
||
int flags = 0;
|
||
if (m_bTuningX264Vbv) flags |= TUNING_X264_VBV;
|
||
if (m_bTuningGdiNoSleep) flags |= TUNING_GDI_NO_SLEEP;
|
||
if (m_bTuningPaceFpsFloor) flags |= TUNING_PACE_FPS_FLOOR;
|
||
if (m_bTuningAdaptiveDual) flags |= TUNING_ADAPTIVE_DUAL;
|
||
return flags;
|
||
}
|
||
|
||
// 恢复顺序:客户端随 ScreenSettings 上报的值为准(新客户端,逐客户端、跨主控端一致),
|
||
// 老客户端没有 SCREEN_CAP_TUNING_FLAGS,退回主控端 THIS_CFG [screen_tuning] 里按
|
||
// 客户端 ID 保存的副本(与 mouse_scale 同一种做法);两者都没有时沿用旧版全局
|
||
// [settings] Tuning* 的选择,最后才落到默认值。旧版全局项不能直接丢掉:用户可能
|
||
// 在那里显式关过某一项,迁移后第一次打开远程桌面应当尊重它。
|
||
void CScreenSpyDlg::LoadScreenTuning()
|
||
{
|
||
int v = -1;
|
||
if (m_Settings.Capabilities & SCREEN_CAP_TUNING_FLAGS) {
|
||
v = m_Settings.TuningFlags;
|
||
Mprintf("[Tuning] device %llu: 客户端上报调优开关 0x%X\n", m_ClientID, v);
|
||
} else if (m_ClientID != 0) {
|
||
v = THIS_CFG.GetInt("screen_tuning", std::to_string(m_ClientID), -1);
|
||
}
|
||
if (v < 0) {
|
||
v = 0;
|
||
if (THIS_CFG.GetInt("settings", "TuningX264Vbv", 0)) v |= TUNING_X264_VBV;
|
||
if (THIS_CFG.GetInt("settings", "TuningGdiNoSleep", 1)) v |= TUNING_GDI_NO_SLEEP;
|
||
if (THIS_CFG.GetInt("settings", "TuningPaceFpsFloor", 1)) v |= TUNING_PACE_FPS_FLOOR;
|
||
if (THIS_CFG.GetInt("settings", "AdaptiveDualCriteria", 1)) v |= TUNING_ADAPTIVE_DUAL;
|
||
Mprintf("[Tuning] device %llu: 无本机记录,沿用旧版全局设置 0x%X\n", m_ClientID, v);
|
||
}
|
||
m_bTuningX264Vbv = (v & TUNING_X264_VBV) != 0;
|
||
m_bTuningGdiNoSleep = (v & TUNING_GDI_NO_SLEEP) != 0;
|
||
m_bTuningPaceFpsFloor = (v & TUNING_PACE_FPS_FLOOR) != 0;
|
||
m_bTuningAdaptiveDual = (v & TUNING_ADAPTIVE_DUAL) != 0;
|
||
}
|
||
|
||
// 主控端副本只对老客户端有意义(新客户端自己存),但仍照写:万一客户端换回老版本,
|
||
// 至少主控端还记得上次的勾选。
|
||
void CScreenSpyDlg::SaveScreenTuning() const
|
||
{
|
||
if (m_ClientID == 0) return;
|
||
int v = GetScreenTuningFlags();
|
||
THIS_CFG.SetInt("screen_tuning", std::to_string(m_ClientID), v);
|
||
Mprintf("[Tuning] device %llu: 保存调优开关 0x%X\n", m_ClientID, v);
|
||
}
|
||
|
||
// 调优项全在「远程桌面调优」子菜单里,顶级系统菜单上 CheckMenuItem 找不到,得先定位子菜单。
|
||
void CScreenSpyDlg::SyncTuningMenuChecks()
|
||
{
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
if (!SysMenu) return;
|
||
CMenu* tuningMenu = nullptr;
|
||
for (UINT i = 0; i < (UINT)SysMenu->GetMenuItemCount(); i++) {
|
||
CMenu* sub = SysMenu->GetSubMenu(i);
|
||
if (sub && sub->GetMenuState(IDM_TUNING_X264_VBV, MF_BYCOMMAND) != 0xFFFFFFFF) {
|
||
tuningMenu = sub;
|
||
break;
|
||
}
|
||
}
|
||
if (!tuningMenu) return;
|
||
tuningMenu->CheckMenuItem(IDM_TUNING_X264_VBV, m_bTuningX264Vbv ? MF_CHECKED : MF_UNCHECKED);
|
||
tuningMenu->CheckMenuItem(IDM_TUNING_GDI_SLEEP, m_bTuningGdiNoSleep ? MF_CHECKED : MF_UNCHECKED);
|
||
tuningMenu->CheckMenuItem(IDM_TUNING_PACE_FPS_FLOOR, m_bTuningPaceFpsFloor ? MF_CHECKED : MF_UNCHECKED);
|
||
tuningMenu->CheckMenuItem(IDM_TUNING_ADAPTIVE_LOAD, m_bTuningAdaptiveDual ? MF_CHECKED : MF_UNCHECKED);
|
||
}
|
||
|
||
// 要求客户端下一帧强制 IDR。客户端在 SetAlgorithm 换算法时也会自己丢编码器,
|
||
// 这里是兜底:解码器被 flush 过之后必须拿到 IDR 才能恢复,不能等自然 GOP。
|
||
VOID CScreenSpyDlg::RequestClientKeyFrame(void)
|
||
{
|
||
BYTE bToken = COMMAND_SCREEN_KEYFRAME_REQ;
|
||
m_ContextObject->Send2Client(&bToken, sizeof(bToken));
|
||
Mprintf("[ScreenSpy] 请求客户端关键帧\n");
|
||
}
|
||
|
||
VOID CScreenSpyDlg::SendNext(void)
|
||
{
|
||
BYTE bToken[32] = { COMMAND_NEXT };
|
||
uint64_t dlg = (uint64_t)this;
|
||
memcpy(bToken+1, &dlg, sizeof(uint64_t));
|
||
// 附加服务端能力标志
|
||
uint32_t capabilities = CAP_SCROLL_DETECT; // 支持滚动检测优化
|
||
memcpy(bToken + 9, &capabilities, sizeof(uint32_t));
|
||
// 附加滚动检测间隔(0=禁用, 2=每2帧, ...)
|
||
int scrollInterval = m_Settings.ScrollDetectInterval;
|
||
memcpy(bToken + 9 + sizeof(uint32_t), &scrollInterval, sizeof(int));
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
}
|
||
|
||
|
||
CScreenSpyDlg::~CScreenSpyDlg()
|
||
{
|
||
if (m_BitmapInfor_Full!=NULL) {
|
||
delete m_BitmapInfor_Full;
|
||
m_BitmapInfor_Full = NULL;
|
||
}
|
||
|
||
::ReleaseDC(m_hWnd, m_hFullDC); //GetDC
|
||
::DeleteDC(m_hFullMemDC); //Create匹配内存DC
|
||
|
||
::DeleteObject(m_BitmapHandle);
|
||
|
||
if (m_hComposeDC) {
|
||
SelectObject(m_hComposeDC, m_hComposeOldBmp);
|
||
DeleteObject(m_hComposeBmp);
|
||
DeleteDC(m_hComposeDC);
|
||
m_hComposeDC = NULL;
|
||
}
|
||
if (m_BitmapData_Full!=NULL) {
|
||
m_BitmapData_Full = NULL;
|
||
}
|
||
if (m_pCodecContext) {
|
||
avcodec_free_context(&m_pCodecContext);
|
||
m_pCodecContext = 0;
|
||
}
|
||
|
||
m_pCodec = 0;
|
||
// AVFrame需要清除
|
||
av_frame_unref(&m_AVFrame);
|
||
|
||
// 清理自定义光标
|
||
if (m_hCustomCursor) {
|
||
DestroyCursor(m_hCustomCursor);
|
||
m_hCustomCursor = NULL;
|
||
}
|
||
|
||
// 清理音频播放
|
||
StopAudioPlayback();
|
||
|
||
// 清理所有文件接收对话框
|
||
// 注意:对话框可能已经被用户关闭并自我销毁(PostNcDestroy 中 delete this)
|
||
// 存储了 HWND 用于安全检查,避免访问野指针
|
||
for (auto& entry : m_FileRecvDlgs) {
|
||
HWND hWnd = entry.second.first;
|
||
if (hWnd && ::IsWindow(hWnd)) {
|
||
// 通过 HWND 同步发送关闭消息,确保对话框在析构前完全关闭
|
||
// 使用 SendMessage 而非 PostMessage,避免异步问题
|
||
::SendMessage(hWnd, WM_CLOSE, 0, 0);
|
||
}
|
||
}
|
||
m_FileRecvDlgs.clear();
|
||
|
||
SAFE_DELETE(m_pToolbar);
|
||
SAFE_DELETE(m_pStatusInfoWnd);
|
||
}
|
||
|
||
void CScreenSpyDlg::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
__super::DoDataExchange(pDX);
|
||
}
|
||
|
||
// ========== CStatusInfoWnd 实现 ==========
|
||
|
||
namespace {
|
||
// 原来宽度是写死的 170:档位名后面一旦跟出「(链路改善)」「(带宽不足)」这类
|
||
// 切档原因,文本就被截掉。改成按文本实测宽度,170 退化成下限。
|
||
const int kStatusInfoMinWidth = 170;
|
||
const int kStatusInfoHeight = 24;
|
||
const int kStatusInfoPadX = 16; // 文本左右留白
|
||
// 宽度按 16px 取整:FPS / KB/s 每秒都在变,位数进位会让窗口每秒抖动一两个像素
|
||
const int kStatusInfoWidthStep = 16;
|
||
}
|
||
|
||
BEGIN_MESSAGE_MAP(CStatusInfoWnd, CWnd)
|
||
ON_WM_PAINT()
|
||
ON_WM_ERASEBKGND()
|
||
ON_WM_LBUTTONDOWN()
|
||
ON_WM_LBUTTONUP()
|
||
ON_WM_MOUSEMOVE()
|
||
END_MESSAGE_MAP()
|
||
|
||
BOOL CStatusInfoWnd::Create(CWnd* pParent)
|
||
{
|
||
DWORD dwStyle = WS_POPUP;
|
||
DWORD dwExStyle = WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW;
|
||
|
||
// 注册窗口类
|
||
static LPCTSTR szClassName = _T("StatusInfoWnd");
|
||
static bool bRegistered = false;
|
||
if (!bRegistered) {
|
||
WNDCLASS wc = { 0 };
|
||
wc.lpfnWndProc = ::DefWindowProc;
|
||
wc.hInstance = AfxGetInstanceHandle();
|
||
wc.lpszClassName = szClassName;
|
||
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
||
AfxRegisterClass(&wc);
|
||
bRegistered = true;
|
||
}
|
||
|
||
if (!CreateEx(dwExStyle, szClassName, _T(""), dwStyle,
|
||
CRect(0, 0, m_nWidth, kStatusInfoHeight), pParent, 0))
|
||
return FALSE;
|
||
|
||
// 字体建一次给绘制和测量共用:两边字体不一致的话,算出来的宽度和画出来的宽度
|
||
// 就对不上,仍然会截字。
|
||
m_infoFont.CreatePointFont(90, _T("Segoe UI"));
|
||
|
||
SetLayeredWindowAttributes(0, 220, LWA_ALPHA);
|
||
LoadSettings();
|
||
return TRUE;
|
||
}
|
||
|
||
int CStatusInfoWnd::MeasureWidth()
|
||
{
|
||
if (m_strInfo.IsEmpty())
|
||
return kStatusInfoMinWidth;
|
||
|
||
CClientDC dc(this);
|
||
CFont* pOldFont = dc.SelectObject(&m_infoFont);
|
||
CSize sz = dc.GetTextExtent(m_strInfo);
|
||
dc.SelectObject(pOldFont);
|
||
|
||
int w = sz.cx + kStatusInfoPadX * 2;
|
||
if (w < kStatusInfoMinWidth)
|
||
w = kStatusInfoMinWidth;
|
||
w = (w + kStatusInfoWidthStep - 1) / kStatusInfoWidthStep * kStatusInfoWidthStep;
|
||
return w;
|
||
}
|
||
|
||
void CStatusInfoWnd::ResizeToFit()
|
||
{
|
||
if (!GetSafeHwnd())
|
||
return;
|
||
|
||
const int w = MeasureWidth();
|
||
if (w == m_nWidth)
|
||
return;
|
||
|
||
CRect rc;
|
||
GetWindowRect(&rc);
|
||
m_nWidth = w;
|
||
// 两边各让一半,保持中心不动:默认位置是屏幕居中,拖动过的是用户选的中心点,
|
||
// 只往右边长会让这两种情况都偏。
|
||
const int dx = (rc.Width() - w) / 2;
|
||
SetWindowPos(NULL, rc.left + dx, rc.top, w, rc.Height(),
|
||
SWP_NOZORDER | SWP_NOACTIVATE);
|
||
}
|
||
|
||
void CStatusInfoWnd::UpdateInfo(double fps, double kbps, const CString& quality)
|
||
{
|
||
if (kbps >= 1024)
|
||
m_strInfo.Format(_T("%.0f FPS | %.1f MB/s | %s"), fps, kbps / 1024, quality.GetString());
|
||
else
|
||
m_strInfo.Format(_T("%.0f FPS | %.0f KB/s | %s"), fps, kbps, quality.GetString());
|
||
|
||
// 文本变了宽度就可能变(切档原因的四种文案长度不同),隐藏时也算,
|
||
// 免得下次 Show 出来先窄一帧再撑开。
|
||
ResizeToFit();
|
||
|
||
if (m_bVisible)
|
||
Invalidate(FALSE);
|
||
}
|
||
|
||
void CStatusInfoWnd::Show()
|
||
{
|
||
m_bVisible = true;
|
||
ShowWindow(SW_SHOWNOACTIVATE);
|
||
}
|
||
|
||
void CStatusInfoWnd::Hide()
|
||
{
|
||
m_bVisible = false;
|
||
ShowWindow(SW_HIDE);
|
||
}
|
||
|
||
void CStatusInfoWnd::SetOpacityLevel(int level)
|
||
{
|
||
m_nOpacityLevel = level;
|
||
BYTE opacity;
|
||
switch (level) {
|
||
case 1: opacity = 191; break; // 75%
|
||
case 2: opacity = 128; break; // 50%
|
||
default: opacity = 220; break; // 默认略透明
|
||
}
|
||
SetLayeredWindowAttributes(0, opacity, LWA_ALPHA);
|
||
}
|
||
|
||
void CStatusInfoWnd::UpdatePosition(const RECT& rcMonitor)
|
||
{
|
||
const int width = m_nWidth, height = kStatusInfoHeight;
|
||
int monWidth = rcMonitor.right - rcMonitor.left;
|
||
|
||
int x, y;
|
||
if (m_bHasCustomPosition) {
|
||
x = rcMonitor.left + (int)(monWidth * m_dOffsetXRatio) - width / 2;
|
||
y = rcMonitor.top + m_nOffsetY;
|
||
x = max((int)rcMonitor.left, min(x, (int)rcMonitor.right - width));
|
||
y = max((int)rcMonitor.top, min(y, (int)rcMonitor.bottom - height));
|
||
} else {
|
||
x = rcMonitor.left + (monWidth - width) / 2;
|
||
y = rcMonitor.top + 50;
|
||
}
|
||
SetWindowPos(&wndTopMost, x, y, width, height, SWP_NOACTIVATE);
|
||
}
|
||
|
||
void CStatusInfoWnd::LoadSettings()
|
||
{
|
||
m_bHasCustomPosition = THIS_CFG.GetInt("statusinfo", "HasCustomPos", 0) != 0;
|
||
if (m_bHasCustomPosition) {
|
||
m_dOffsetXRatio = THIS_CFG.GetDouble("statusinfo", "OffsetXRatio", 0.5);
|
||
m_nOffsetY = THIS_CFG.GetInt("statusinfo", "OffsetY", 50);
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::SaveSettings()
|
||
{
|
||
THIS_CFG.SetInt("statusinfo", "HasCustomPos", m_bHasCustomPosition ? 1 : 0);
|
||
THIS_CFG.SetDouble("statusinfo", "OffsetXRatio", m_dOffsetXRatio);
|
||
THIS_CFG.SetInt("statusinfo", "OffsetY", m_nOffsetY);
|
||
}
|
||
|
||
// 检查父窗口是否处于控制模式
|
||
bool CStatusInfoWnd::IsParentInControlMode()
|
||
{
|
||
CScreenSpyDlg* pParent = (CScreenSpyDlg*)GetParent();
|
||
return pParent && pParent->m_bIsCtrl;
|
||
}
|
||
|
||
void CStatusInfoWnd::OnLButtonDown(UINT nFlags, CPoint point)
|
||
{
|
||
// 控制模式下不处理拖拽,让消息传递到父窗口
|
||
if (IsParentInControlMode()) {
|
||
// 转换为屏幕坐标后发送给父窗口
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_LBUTTONDOWN, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
m_bDragging = true;
|
||
m_ptDragStart = point;
|
||
SetCapture();
|
||
}
|
||
|
||
void CStatusInfoWnd::OnLButtonUp(UINT nFlags, CPoint point)
|
||
{
|
||
if (IsParentInControlMode()) {
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_LBUTTONUP, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_bDragging) {
|
||
m_bDragging = false;
|
||
ReleaseCapture();
|
||
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
HMONITOR hMon = MonitorFromWindow(pParent->GetSafeHwnd(), MONITOR_DEFAULTTONEAREST);
|
||
MONITORINFO mi = { sizeof(mi) };
|
||
if (GetMonitorInfo(hMon, &mi)) {
|
||
CRect rcWnd;
|
||
GetWindowRect(&rcWnd);
|
||
|
||
int monWidth = mi.rcMonitor.right - mi.rcMonitor.left;
|
||
int wndCenterX = rcWnd.left + rcWnd.Width() / 2;
|
||
|
||
m_dOffsetXRatio = (double)(wndCenterX - mi.rcMonitor.left) / monWidth;
|
||
m_nOffsetY = rcWnd.top - mi.rcMonitor.top;
|
||
m_bHasCustomPosition = true;
|
||
SaveSettings();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::OnMouseMove(UINT nFlags, CPoint point)
|
||
{
|
||
if (IsParentInControlMode()) {
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_MOUSEMOVE, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_bDragging) {
|
||
CRect rcWnd;
|
||
GetWindowRect(&rcWnd);
|
||
|
||
int dx = point.x - m_ptDragStart.x;
|
||
int dy = point.y - m_ptDragStart.y;
|
||
|
||
SetWindowPos(&wndTopMost, rcWnd.left + dx, rcWnd.top + dy,
|
||
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::OnPaint()
|
||
{
|
||
CPaintDC dc(this);
|
||
CRect rc;
|
||
GetClientRect(&rc);
|
||
|
||
// 背景
|
||
dc.FillSolidRect(rc, RGB(40, 40, 40));
|
||
|
||
// 文字
|
||
dc.SetBkMode(TRANSPARENT);
|
||
dc.SetTextColor(RGB(220, 220, 220));
|
||
CFont* pOldFont = dc.SelectObject(&m_infoFont);
|
||
dc.DrawText(m_strInfo, rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
|
||
dc.SelectObject(pOldFont);
|
||
}
|
||
|
||
BOOL CStatusInfoWnd::OnEraseBkgnd(CDC* pDC)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
// ========== CScreenSpyDlg 实现 ==========
|
||
|
||
BEGIN_MESSAGE_MAP(CScreenSpyDlg, CDialog)
|
||
ON_WM_CLOSE()
|
||
ON_WM_PAINT()
|
||
ON_WM_SETCURSOR()
|
||
ON_WM_SYSCOMMAND()
|
||
ON_WM_HSCROLL()
|
||
ON_WM_VSCROLL()
|
||
ON_WM_LBUTTONDOWN()
|
||
ON_WM_LBUTTONUP()
|
||
ON_WM_RBUTTONDOWN()
|
||
ON_WM_RBUTTONUP()
|
||
ON_WM_MOUSEWHEEL()
|
||
ON_WM_MOUSEMOVE()
|
||
ON_WM_MOUSELEAVE()
|
||
ON_WM_KILLFOCUS()
|
||
ON_WM_SIZE()
|
||
ON_WM_LBUTTONDBLCLK()
|
||
ON_WM_ACTIVATE()
|
||
ON_WM_TIMER()
|
||
ON_WM_ERASEBKGND()
|
||
ON_COMMAND(ID_EXIT_FULLSCREEN, &CScreenSpyDlg::OnExitFullscreen)
|
||
ON_COMMAND(ID_SHOW_STATUS_INFO, &CScreenSpyDlg::OnShowStatusInfo)
|
||
ON_COMMAND(ID_HIDE_STATUS_INFO, &CScreenSpyDlg::OnHideStatusInfo)
|
||
ON_MESSAGE(WM_DISCONNECT, &CScreenSpyDlg::OnDisconnect)
|
||
ON_MESSAGE(MM_WOM_DONE, &CScreenSpyDlg::OnWaveOutDone)
|
||
ON_MESSAGE(MM_WOM_CLOSE, &CScreenSpyDlg::OnWaveOutClose)
|
||
ON_MESSAGE(WM_AUDIO_INIT_DEVICE, &CScreenSpyDlg::OnAudioInitDevice)
|
||
ON_MESSAGE(WM_POWERBROADCAST, &CScreenSpyDlg::OnPowerResume)
|
||
ON_MESSAGE(WM_RECVFILEV2_CHUNK, &CScreenSpyDlg::OnRecvFileV2Chunk)
|
||
ON_MESSAGE(WM_RECVFILEV2_COMPLETE, &CScreenSpyDlg::OnRecvFileV2Complete)
|
||
ON_MESSAGE(WM_AUDIO_TOGGLE_FROM_WEB, &CScreenSpyDlg::OnAudioToggleFromWeb)
|
||
ON_WM_DROPFILES()
|
||
ON_WM_CAPTURECHANGED()
|
||
END_MESSAGE_MAP()
|
||
|
||
|
||
// CScreenSpyDlg 消息处理程序
|
||
|
||
void CScreenSpyDlg::OnLButtonDblClk(UINT nFlags, CPoint point)
|
||
{
|
||
if (!m_bIsCtrl) {
|
||
CWnd* parent = GetParent();
|
||
if (parent) {
|
||
// 通知父对话框,传递点击点
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
GetParent()->ScreenToClient(&ptScreen);
|
||
GetParent()->SendMessage(WM_LBUTTONDBLCLK, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
}
|
||
__super::OnLButtonDblClk(nFlags, point);
|
||
}
|
||
|
||
// 计算自适应模式的等比缩放布局。
|
||
// 纯计算,无副作用,供 OnPaint / OnSize / PrepareDrawing 共用。
|
||
static void ComputeAdaptiveLayout(
|
||
int srcW, int srcH, int dstW, int dstH,
|
||
int& renderW, int& renderH, int& offsetX, int& offsetY,
|
||
double& wZoom, double& hZoom)
|
||
{
|
||
if (srcW <= 0 || srcH <= 0 || dstW <= 0 || dstH <= 0) {
|
||
renderW = dstW; renderH = dstH;
|
||
offsetX = offsetY = 0;
|
||
wZoom = hZoom = 1.0;
|
||
return;
|
||
}
|
||
if ((long long)srcW * dstH > (long long)srcH * dstW) {
|
||
renderW = dstW;
|
||
renderH = (int)((long long)dstW * srcH / srcW);
|
||
} else {
|
||
renderH = dstH;
|
||
renderW = (int)((long long)dstH * srcW / srcH);
|
||
}
|
||
if (renderW < 1) renderW = 1;
|
||
if (renderH < 1) renderH = 1;
|
||
offsetX = (dstW - renderW) / 2;
|
||
offsetY = (dstH - renderH) / 2;
|
||
wZoom = (double)srcW / renderW;
|
||
hZoom = (double)srcH / renderH;
|
||
}
|
||
|
||
void CScreenSpyDlg::PrepareDrawing(const LPBITMAPINFO bmp)
|
||
{
|
||
if (m_hFullDC) ::ReleaseDC(m_hWnd, m_hFullDC);
|
||
if (m_hFullMemDC) ::DeleteDC(m_hFullMemDC);
|
||
if (m_BitmapHandle) ::DeleteObject(m_BitmapHandle);
|
||
m_BitmapData_Full = NULL;
|
||
|
||
CString strString;
|
||
strString.FormatL("%s - 远程桌面控制 %d×%d", GetTitleHostName().GetString(), bmp->bmiHeader.biWidth, bmp->bmiHeader.biHeight);
|
||
SetWindowText(strString);
|
||
uint64_t dlg = (uint64_t)this;
|
||
Mprintf("%s [对话框ID: %llu]\n", strString.GetString(), dlg);
|
||
|
||
m_hFullDC = ::GetDC(m_hWnd);
|
||
SetStretchBltMode(m_hFullDC, GetFastStretchMode() ? COLORONCOLOR : HALFTONE);
|
||
if (!GetFastStretchMode()) SetBrushOrgEx(m_hFullDC, 0, 0, NULL);
|
||
m_hFullMemDC = CreateCompatibleDC(m_hFullDC);
|
||
m_BitmapHandle = CreateDIBSection(m_hFullDC, bmp, DIB_RGB_COLORS, &m_BitmapData_Full, NULL, NULL);
|
||
|
||
SelectObject(m_hFullMemDC, m_BitmapHandle);
|
||
|
||
// 仅在滚动条已可见时更新范围(不会闪现,只是刷新范围值)
|
||
// 全屏或自适应模式下不调用,避免隐式添加 WS_HSCROLL/WS_VSCROLL 导致闪现
|
||
if (!m_Settings.FullScreen && !m_bAdaptiveSize) {
|
||
SetScrollRange(SB_HORZ, 0, bmp->bmiHeader.biWidth);
|
||
SetScrollRange(SB_VERT, 0, bmp->bmiHeader.biHeight);
|
||
}
|
||
|
||
GetClientRect(&m_CRect);
|
||
if (m_bAdaptiveSize) {
|
||
int renderW, renderH;
|
||
ComputeAdaptiveLayout(bmp->bmiHeader.biWidth, bmp->bmiHeader.biHeight,
|
||
m_CRect.Width(), m_CRect.Height(),
|
||
renderW, renderH, m_offsetX, m_offsetY,
|
||
m_wZoom, m_hZoom);
|
||
} else {
|
||
m_offsetX = m_offsetY = 0;
|
||
m_wZoom = m_CRect.Width() > 0 ? (double)bmp->bmiHeader.biWidth / m_CRect.Width() : 1.0;
|
||
m_hZoom = m_CRect.Height() > 0 ? (double)bmp->bmiHeader.biHeight / m_CRect.Height() : 1.0;
|
||
}
|
||
}
|
||
|
||
BOOL CScreenSpyDlg::OnInitDialog()
|
||
{
|
||
__super::OnInitDialog();
|
||
SetIcon(m_hIcon,FALSE);
|
||
|
||
// Determine session type FIRST so the window-show machinery below
|
||
// (SetWindowPlacement with showCmd=SW_MAXIMIZE, EnterFullScreen) can be
|
||
// skipped for hidden web sessions. Without this, the dialog briefly
|
||
// flashes on-screen — the hide used to happen ~200 lines later, after
|
||
// a chain of init work that the user could see in the meantime.
|
||
bool isMfcSession = WebService().IsMfcTriggered(m_ClientID);
|
||
if (isMfcSession) {
|
||
// MFC-triggered: clear the flag, don't register with WebService.
|
||
WebService().ClearMfcTriggered(m_ClientID);
|
||
// m_bIsWebSession remains false (default)
|
||
} else if (WebService().IsWebTriggered(m_ClientID) && WebService().GetHideWebSessions()) {
|
||
// Web-triggered: register and hide upfront.
|
||
WebService().RegisterScreenContext(m_ClientID, m_ContextObject);
|
||
m_bHide = true;
|
||
m_bIsWebSession = true;
|
||
ShowWindow(SW_HIDE);
|
||
}
|
||
Mprintf("[ScreenSpy] Dialog created for device %llu, isMfcSession=%d, isWebSession=%d\n",
|
||
m_ClientID, isMfcSession ? 1 : 0, m_bIsWebSession.load() ? 1 : 0);
|
||
|
||
// Web 会话只能解 H.264,档位必须 >= Good。会话类型到这一步才确定(构造函数里
|
||
// m_bIsWebSession 还是 false),而固定档位模式下 m_AdaptiveQuality.enabled 为
|
||
// false、EvaluateQuality 一次都不跑,ApplyQualityLevel 里的兜底 clamp 就永远不
|
||
// 生效;下面下发的初始档位也压根不经过 ApplyQualityLevel。所以要在这里单独
|
||
// clamp:否则"质量等级=High"会把 web 会话的客户端直接顶到 RGB565,服务端只在
|
||
// ALGORITHM_H264 分支里给 web 转发视频 → 前端永久黑屏、fps=0,而 MFC 窗口走
|
||
// RGB565 解码一切正常,排查时极易误判成分辨率或网络问题。
|
||
if (m_bIsWebSession && m_AdaptiveQuality.currentLevel >= 0 &&
|
||
m_AdaptiveQuality.currentLevel < QUALITY_GOOD) {
|
||
Mprintf("[ScreenSpy] Web session quality %d is not H264, clamp to %d (Good)\n",
|
||
m_AdaptiveQuality.currentLevel, QUALITY_GOOD);
|
||
m_AdaptiveQuality.currentLevel = QUALITY_GOOD;
|
||
if (m_Settings.QualityLevel != QUALITY_DISABLED) {
|
||
m_AdaptiveQuality.currentMaxWidth = GetQualityProfile(QUALITY_GOOD).maxWidth;
|
||
}
|
||
}
|
||
|
||
// 逐主机鼠标坐标补偿。必须在用户开始操作前加载;默认 1.0 不影响任何主机。
|
||
LoadMouseScale();
|
||
|
||
// 获取默认 IME 上下文(ImmAssociateContext 返回之前关联的上下文)
|
||
// 先禁用再恢复,以获取原始上下文句柄
|
||
m_hOldIMC = ImmAssociateContext(m_hWnd, NULL);
|
||
if (m_hOldIMC) {
|
||
ImmAssociateContext(m_hWnd, m_hOldIMC); // 立即恢复
|
||
}
|
||
|
||
DragAcceptFiles(TRUE);
|
||
ChangeWindowMessageFilter(WM_DROPFILES, MSGFLT_ADD);
|
||
ChangeWindowMessageFilter(0x0049, MSGFLT_ADD);
|
||
|
||
PrepareDrawing(m_BitmapInfor_Full);
|
||
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
if (SysMenu != NULL) {
|
||
SysMenu->AppendMenuSeparator(MF_SEPARATOR);
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_CONTROL, "控制屏幕(&Y)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_FULLSCREEN, "全屏(&F)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_REMOTE_CURSOR, "使用远程光标(&C)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_ADAPTIVE_SIZE, "自适应窗口大小(&A)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_TRACE_CURSOR, "跟踪被控端鼠标(&T)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_MOUSE_CALIB, "鼠标坐标校准(&M)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_BLOCK_INPUT, "锁定被控端鼠标和键盘(&L)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_RESTORE_CONSOLE, "RDP会话归位(&R)");
|
||
// 只在虚拟桌面模式下显示重置选项
|
||
if (m_Settings.ScreenType == USING_VIRTUAL) {
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_RESET_VIRTUAL_DESKTOP, "重置虚拟桌面(&V)");
|
||
}
|
||
SysMenu->AppendMenuSeparator(MF_SEPARATOR);
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SAVEDIB, "保存快照(&S)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SAVEAVI, _T("录像(MJPEG)"));
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SAVEAVI_H264, _T("录像(H264)"));
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_GET_CLIPBOARD, "获取剪贴板(&R)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SET_CLIPBOARD, "设置剪贴板(&L)");
|
||
SysMenu->AppendMenuSeparator(MF_SEPARATOR);
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SWITCHSCREEN, "切换显示器(&1)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_MULTITHREAD_COMPRESS, "多线程压缩(&2)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_ORIGINAL_SIZE, "原始分辨率(&3)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_SCREEN_1080P, "限制为1080P(&4)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_ENABLE_SSE2, "启用SSE2指令集(&5)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_FAST_STRETCH, "服务端快速缩放(降低CPU)(&6)");
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_CUSTOM_CURSOR, "使用自定义光标(&7)");
|
||
SysMenu->AppendMenuSeparator(MF_SEPARATOR);
|
||
|
||
SysMenu->CheckMenuItem(IDM_FULLSCREEN, m_Settings.FullScreen ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_REMOTE_CURSOR, m_Settings.RemoteCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_SSE2, m_Settings.CpuSpeedup == 1 ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_FAST_STRETCH, GetFastStretchMode() ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_CUSTOM_CURSOR, m_Settings.CustomCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
|
||
CMenu fpsMenu;
|
||
if (fpsMenu.CreatePopupMenu()) {
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_10, "最大帧率FPS:10");
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_15, "最大帧率FPS:15");
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_20, "最大帧率FPS:20");
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_25, "最大帧率FPS:25");
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_30, "最大帧率FPS:30");
|
||
fpsMenu.AppendMenuL(MF_STRING, IDM_FPS_UNLIMITED, "最大帧率无限制");
|
||
SysMenu->AppendMenuL(MF_STRING | MF_POPUP, (UINT_PTR)fpsMenu.Detach(), _T("帧率设置"));
|
||
}
|
||
|
||
// 滚动检测间隔菜单
|
||
// 滚动检测菜单(用户友好描述)
|
||
CMenu scrollMenu;
|
||
if (scrollMenu.CreatePopupMenu()) {
|
||
scrollMenu.AppendMenuL(MF_STRING, IDM_SCROLL_DETECT_OFF, "关闭(局域网)");
|
||
scrollMenu.AppendMenuL(MF_STRING, IDM_SCROLL_DETECT_2, "跨网推荐(最省流量)");
|
||
scrollMenu.AppendMenuL(MF_STRING, IDM_SCROLL_DETECT_4, "标准模式");
|
||
scrollMenu.AppendMenuL(MF_STRING, IDM_SCROLL_DETECT_8, "低频模式(省CPU)");
|
||
SysMenu->AppendMenuL(MF_STRING | MF_POPUP, (UINT_PTR)scrollMenu.Detach(), _T("滚动优化"));
|
||
}
|
||
|
||
// 屏幕质量子菜单
|
||
CMenu qualityMenu;
|
||
if (qualityMenu.CreatePopupMenu()) {
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_OFF, "关闭(&O)");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_ADAPTIVE_QUALITY, "自适应(&A)");
|
||
qualityMenu.AppendMenuSeparator(MF_SEPARATOR);
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_ULTRA, "Ultra (25FPS, DIFF - 企业级/高速局域网)");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_HIGH, "High (20FPS, RGB565 - 家庭级/标准局域网)");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_GOOD, "Good (20FPS, H264) - 跨网/默认办公标配");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_MEDIUM, "Medium (15FPS, H264) - 跨国/跨境远控");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_LOW, "Low (12FPS, H264) - 洲际/弱网远控");
|
||
qualityMenu.AppendMenuL(MF_STRING, IDM_QUALITY_MINIMAL, "Minimal (8FPS, H264) - 极差/极低带宽");
|
||
SysMenu->AppendMenuL(MF_STRING | MF_POPUP, (UINT_PTR)qualityMenu.Detach(), _T("屏幕质量(&Q)"));
|
||
}
|
||
|
||
// 远程桌面调优子菜单(逐客户端设置,紧跟「屏幕质量」之后)
|
||
CMenu tuningMenu;
|
||
if (tuningMenu.CreatePopupMenu()) {
|
||
tuningMenu.AppendMenuL(MF_STRING, IDM_TUNING_X264_VBV, "x264 码率封顶 (VBV,仅限洲际弱网)");
|
||
tuningMenu.AppendMenuL(MF_STRING, IDM_TUNING_GDI_SLEEP, "GDI 抓屏去分段延时");
|
||
tuningMenu.AppendMenuL(MF_STRING, IDM_TUNING_PACE_FPS_FLOOR, "发送节流帧率下限");
|
||
tuningMenu.AppendMenuL(MF_STRING, IDM_TUNING_ADAPTIVE_LOAD, "自适应加吞吐判据");
|
||
SysMenu->AppendMenuL(MF_STRING | MF_POPUP, (UINT_PTR)tuningMenu.Detach(), _T("远程桌面调优(&T)"));
|
||
}
|
||
// 音频菜单项
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_AUDIO_TOGGLE, "系统音频(&U)");
|
||
SysMenu->CheckMenuItem(IDM_AUDIO_TOGGLE, m_Settings.AudioEnabled ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_ENABLE_H264_HARD, "启用 H264 硬编码");
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_GRAYED : MF_ENABLED);
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_ENABLE_AV1_HARD, "启用 AV1 硬编码");
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_GRAYED : MF_ENABLED);
|
||
|
||
// 初始化勾选状态
|
||
UpdateQualityMenuCheck(SysMenu);
|
||
SyncTuningMenuChecks();
|
||
|
||
BOOL all = THIS_CFG.GetInt("settings", "MultiScreen", TRUE);
|
||
SysMenu->EnableMenuItem(IDM_SWITCHSCREEN, all ? MF_ENABLED : MF_GRAYED);
|
||
SysMenu->CheckMenuItem(IDM_MULTITHREAD_COMPRESS, m_Settings.CompressThread ? MF_CHECKED : MF_UNCHECKED);
|
||
if (m_Settings.ScreenStrategy == 0) {
|
||
SysMenu->CheckMenuItem(IDM_SCREEN_1080P, MF_CHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ORIGINAL_SIZE, MF_UNCHECKED);
|
||
} else if (m_Settings.ScreenStrategy == 1) {
|
||
SysMenu->CheckMenuItem(IDM_SCREEN_1080P, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ORIGINAL_SIZE, MF_CHECKED);
|
||
}
|
||
int fpsIndex = IDM_FPS_10 + (m_Settings.MaxFPS - 10)/5;
|
||
for (int i = IDM_FPS_10; i <= IDM_FPS_UNLIMITED; i++) {
|
||
SysMenu->CheckMenuItem(i, MF_UNCHECKED);
|
||
}
|
||
SysMenu->CheckMenuItem(fpsIndex, MF_CHECKED);
|
||
|
||
// 设置滚动检测间隔选中状态
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_OFF, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_2, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_4, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_8, MF_UNCHECKED);
|
||
int scrollInterval = m_Settings.ScrollDetectInterval;
|
||
int scrollMenuID = scrollInterval <= 0 ? IDM_SCROLL_DETECT_OFF :
|
||
scrollInterval <= 2 ? IDM_SCROLL_DETECT_2 :
|
||
scrollInterval <= 4 ? IDM_SCROLL_DETECT_4 : IDM_SCROLL_DETECT_8;
|
||
SysMenu->CheckMenuItem(scrollMenuID, MF_CHECKED);
|
||
}
|
||
|
||
m_bIsCtrl = m_Settings.ScreenType == USING_VIRTUAL;
|
||
// 根据初始控制状态设置 IME
|
||
if (m_bIsCtrl) {
|
||
ImmAssociateContext(m_hWnd, NULL); // 控制模式:禁用 IME
|
||
}
|
||
m_bIsTraceCursor = !m_bIsCtrl; // 非控制状态,则跟踪鼠标
|
||
m_ClientCursorPos.x = 0;
|
||
m_ClientCursorPos.y = 0;
|
||
m_bCursorIndex = 0;
|
||
|
||
SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ADAPTIVE_SIZE, m_bAdaptiveSize ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
ShowScrollBar(SB_BOTH, !m_bAdaptiveSize);
|
||
|
||
// 设置合理的"正常"窗口大小,显示在主程序所在的显示器上
|
||
RECT rcMon = { 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) };
|
||
CWnd* pMain = AfxGetMainWnd();
|
||
if (pMain) {
|
||
HMONITOR hMon = MonitorFromWindow(pMain->GetSafeHwnd(), MONITOR_DEFAULTTONEAREST);
|
||
MONITORINFO mi = { sizeof(mi) };
|
||
if (GetMonitorInfo(hMon, &mi))
|
||
rcMon = mi.rcWork;
|
||
}
|
||
int monW = rcMon.right - rcMon.left;
|
||
int monH = rcMon.bottom - rcMon.top;
|
||
int normalWidth = (int)(monW * 0.382);
|
||
int normalHeight = (int)(monH * 0.382);
|
||
int normalX = rcMon.left + (monW - normalWidth) / 2;
|
||
int normalY = rcMon.top + (monH - normalHeight) / 2;
|
||
|
||
// 使用 WINDOWPLACEMENT 确保 rcNormalPosition 被正确设置
|
||
WINDOWPLACEMENT wp = { sizeof(WINDOWPLACEMENT) };
|
||
GetWindowPlacement(&wp);
|
||
wp.rcNormalPosition.left = normalX;
|
||
wp.rcNormalPosition.top = normalY;
|
||
wp.rcNormalPosition.right = normalX + normalWidth;
|
||
wp.rcNormalPosition.bottom = normalY + normalHeight;
|
||
wp.showCmd = SW_MAXIMIZE;
|
||
|
||
// Skip the placement + fullscreen machinery for hidden web sessions —
|
||
// those calls would briefly flash the dialog on the user's desktop
|
||
// before the early ShowWindow(SW_HIDE) above takes effect at WM_PAINT
|
||
// time. m_struOldWndpl still gets a sane snapshot so any defensive
|
||
// LeaveFullScreen path later has something to restore against.
|
||
if (!m_bIsWebSession) {
|
||
SetWindowPlacement(&wp);
|
||
m_struOldWndpl = wp;
|
||
m_Settings.FullScreen ? EnterFullScreen() : LeaveFullScreen();
|
||
} else {
|
||
m_struOldWndpl = wp;
|
||
}
|
||
|
||
// 启动传输速率更新定时器 (1秒)
|
||
SetTimer(4, 1000, NULL);
|
||
|
||
// 下发质量配置表(让客户端可以持久化保存)。
|
||
// 优先使用主控端在「高级 → 远程桌面质量等级」里自定义的档位;无主控端时回落内置默认表。
|
||
{
|
||
BYTE profileCmd[1 + sizeof(QualityProfile) * QUALITY_COUNT];
|
||
profileCmd[0] = CMD_QUALITY_PROFILES;
|
||
for (int i = 0; i < QUALITY_COUNT; i++) {
|
||
const QualityProfile& prof = (m_pParent != nullptr)
|
||
? m_pParent->GetQualityProfileCfg(i)
|
||
: GetQualityProfile(i);
|
||
memcpy(profileCmd + 1 + i * sizeof(QualityProfile),
|
||
&prof, sizeof(QualityProfile));
|
||
}
|
||
m_ContextObject->Send2Client(profileCmd, sizeof(profileCmd));
|
||
}
|
||
|
||
// 发送初始质量配置给客户端
|
||
if (m_Settings.QualityLevel == QUALITY_DISABLED && !m_bIsWebSession) {
|
||
// 关闭模式:不发送任何质量命令,保持客户端原有设置。
|
||
// web 会话例外:客户端自己保存的档位可能是 High/Ultra,浏览器解不了,
|
||
// 必须显式顶到 H.264 档位(上面的 clamp 已把 currentLevel 定成 Good)。
|
||
} else {
|
||
// 自适应或固定等级模式:发送质量等级和分辨率
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)m_AdaptiveQuality.currentLevel, 0 };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
|
||
// 仅在自适应模式且有缓存宽度时同步分辨率,固定等级分辨率由 profile 决定无需重发
|
||
if (m_Settings.QualityLevel == QUALITY_ADAPTIVE && m_AdaptiveQuality.currentMaxWidth > 0) {
|
||
BYTE sizeCmd[16] = { CMD_SCREEN_SIZE, 2 }; // strategy=2 = 自适应质量
|
||
memcpy(sizeCmd + 2, &m_AdaptiveQuality.currentMaxWidth, sizeof(int));
|
||
m_ContextObject->Send2Client(sizeCmd, 10);
|
||
}
|
||
}
|
||
std::string signMessage(const std::string& privateKey, BYTE* msg, int len);
|
||
BYTE bToken[1 + sizeof(SignatureResp)] = { COMMAND_SCREEN_SIGNATURE };
|
||
std::string msg = ToPekingTimeAsString(0);
|
||
auto signature = signMessage("", (BYTE*)msg.c_str(), msg.length());
|
||
SignatureResp resp = { 0 };
|
||
memcpy(resp.msg, msg.data(), msg.size());
|
||
memcpy(resp.signature, signature.data(), signature.size());
|
||
memcpy(bToken + 1, &resp, sizeof(SignatureResp));
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
|
||
SendNext();
|
||
|
||
// 通知主窗口:设置为活动的远程桌面会话(用于 Ctrl+V 文件接收)
|
||
if (pMain)
|
||
::PostMessage(pMain->GetSafeHwnd(), WM_SESSION_ACTIVATED, (WPARAM)this, 0);
|
||
|
||
// Session type detection and visibility moved to the top of this function
|
||
// (right after __super::OnInitDialog) so SetWindowPlacement / EnterFullScreen
|
||
// above can be skipped for web sessions and avoid a visible flash.
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
VOID CScreenSpyDlg::OnClose()
|
||
{
|
||
// Only unregister if this is a Web session (we only registered for Web sessions)
|
||
if (m_bIsWebSession) {
|
||
WebService().UnregisterScreenContext(m_ClientID);
|
||
}
|
||
|
||
m_bIsClosed = true;
|
||
m_bIsCtrl = FALSE;
|
||
CWnd* pMain = AfxGetMainWnd();
|
||
if (pMain)
|
||
::PostMessage(pMain->GetSafeHwnd(), WM_SESSION_ACTIVATED, (WPARAM)nullptr, 0);
|
||
KillTimer(1);
|
||
KillTimer(2);
|
||
KillTimer(3);
|
||
KillTimer(4);
|
||
if (!m_aviFile.IsEmpty()) {
|
||
KillTimer(TIMER_ID);
|
||
m_aviFile = "";
|
||
m_aviStream.Close();
|
||
}
|
||
bool needCancel = (ShouldReconnect() && SayByeBye());
|
||
|
||
// 恢复鼠标状态
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)LoadCursor(NULL, IDC_ARROW));
|
||
// 通知父窗口
|
||
CWnd* parent = GetParent();
|
||
if (parent)
|
||
parent->SendMessage(WM_CHILD_CLOSED, (WPARAM)this, 0);
|
||
if(g_2015RemoteDlg)
|
||
g_2015RemoteDlg->RemoveRemoteWindow(GetSafeHwnd());
|
||
|
||
// 等待数据处理完毕
|
||
if (IsProcessing()) {
|
||
m_bHide = true;
|
||
ShowWindow(SW_HIDE);
|
||
if (needCancel) { BeginWaitCursor(); Sleep(500); CancelIO(); EndWaitCursor(); }
|
||
return;
|
||
}
|
||
|
||
if (needCancel) { BeginWaitCursor(); Sleep(500); CancelIO(); EndWaitCursor(); }
|
||
DialogBase::OnClose();
|
||
}
|
||
|
||
afx_msg LRESULT CScreenSpyDlg::OnDisconnect(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
m_bConnected = FALSE;
|
||
m_nDisconnectTime = GetTickCount64();
|
||
// Close the dialog if reconnect not succeed in 15 seconds
|
||
SetTimer(2, 15000, NULL);
|
||
SetTimer(3, 3000, NULL);
|
||
PostMessage(WM_PAINT);
|
||
return S_OK;
|
||
}
|
||
|
||
// 处理文件块接收(主线程)
|
||
LRESULT CScreenSpyDlg::OnRecvFileV2Chunk(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
FileV2MsgData* msgData = (FileV2MsgData*)wParam;
|
||
if (!msgData) return 0;
|
||
|
||
BYTE* szBuffer = msgData->data.data();
|
||
size_t len = msgData->data.size();
|
||
FileChunkPacketV2* pkt = (FileChunkPacketV2*)szBuffer;
|
||
uint64_t transferID = msgData->transferID;
|
||
|
||
// 创建或获取进度对话框(按 transferID 管理)
|
||
auto& entry = m_FileRecvDlgs[transferID];
|
||
CDlgFileSend* dlg = entry.second;
|
||
if (dlg == nullptr || !::IsWindow(entry.first)) {
|
||
dlg = new CDlgFileSend(m_pParent, m_ContextObject->GetServer(), m_ContextObject, FALSE);
|
||
dlg->Create(IDD_DIALOG_FILESEND, GetDesktopWindow());
|
||
dlg->SetWindowTextA(_TR("接收文件"));
|
||
dlg->ShowWindow(SW_SHOW);
|
||
dlg->m_bKeepConnection = TRUE; // 不断开连接
|
||
entry = { dlg->GetSafeHwnd(), dlg };
|
||
}
|
||
|
||
// 接收文件
|
||
std::string hash = GetPwdHash(), hmac = GetHMAC(100);
|
||
int n = RecvFileChunkV2((char*)szBuffer, len, nullptr, nullptr, hash, hmac, 0);
|
||
if (n) {
|
||
Mprintf("[ScreenSpy] RecvFileChunkV2 failed: %d\n", n);
|
||
}
|
||
|
||
// 更新进度
|
||
BYTE* name = szBuffer + sizeof(FileChunkPacketV2);
|
||
dlg->UpdateProgress(CString((char*)name, (int)pkt->nameLength), FileProgressInfo(pkt));
|
||
|
||
// 最后一个文件的最后一个包
|
||
if (pkt->fileIndex + 1 == pkt->totalFiles &&
|
||
pkt->offset + pkt->dataLength >= pkt->fileSize) {
|
||
// 等待 COMMAND_FILE_COMPLETE_V2 来最终确认
|
||
// dlg->FinishFileSend(TRUE);
|
||
// m_FileRecvDlgs.erase(transferID);
|
||
}
|
||
|
||
delete msgData;
|
||
return 0;
|
||
}
|
||
|
||
// 处理文件完成校验(主线程)
|
||
LRESULT CScreenSpyDlg::OnRecvFileV2Complete(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
FileV2MsgData* msgData = (FileV2MsgData*)wParam;
|
||
if (!msgData) return 0;
|
||
|
||
BYTE* szBuffer = msgData->data.data();
|
||
size_t len = msgData->data.size();
|
||
uint64_t transferID = msgData->transferID;
|
||
|
||
// 本地校验
|
||
bool verifyOk = HandleFileCompleteV2((const char*)szBuffer, len, 0);
|
||
Mprintf("[ScreenSpy] 文件校验%s\n", verifyOk ? "通过" : "失败");
|
||
|
||
// 关闭进度对话框
|
||
auto it = m_FileRecvDlgs.find(transferID);
|
||
if (it != m_FileRecvDlgs.end()) {
|
||
// 只有窗口有效时才调用 FinishFileSend
|
||
if (::IsWindow(it->second.first)) {
|
||
it->second.second->FinishFileSend(verifyOk);
|
||
}
|
||
// 无论窗口是否有效,都要移除条目(避免累积无效条目)
|
||
m_FileRecvDlgs.erase(it);
|
||
}
|
||
|
||
delete msgData;
|
||
return 0;
|
||
}
|
||
|
||
VOID CScreenSpyDlg::OnReceiveComplete()
|
||
{
|
||
if (m_bIsClosed) return;
|
||
assert (m_ContextObject);
|
||
auto cmd = m_ContextObject->InDeCompressedBuffer.GetBYTE(0);
|
||
LPBYTE szBuffer = m_ContextObject->InDeCompressedBuffer.GetBuffer();
|
||
unsigned len = m_ContextObject->InDeCompressedBuffer.GetBufferLen();
|
||
m_ulBytesThisSecond += len; // 累计传输字节
|
||
switch(cmd) {
|
||
case COMMAND_GET_FOLDER: {
|
||
std::string folder;
|
||
if (GetCurrentFolderPath(folder)) {
|
||
// 发送目录并准备接收文件
|
||
std::string files(szBuffer + 1, szBuffer + len);
|
||
int len = 1 + folder.length() + files.length() + 1;
|
||
BYTE* cmd = new BYTE[len];
|
||
cmd[0] = COMMAND_GET_FILE;
|
||
memcpy(cmd + 1, folder.c_str(), folder.length());
|
||
cmd[1 + folder.length()] = 0;
|
||
memcpy(cmd + 1 + folder.length() + 1, files.data(), files.length());
|
||
cmd[1 + folder.length() + files.length()] = 0;
|
||
m_ContextObject->Send2Client(cmd, len);
|
||
SAFE_DELETE_ARRAY(cmd);
|
||
}
|
||
break;
|
||
}
|
||
// 下面四个帧 TOKEN 都累加屏幕字节:吞吐判据只看屏幕数据,不含文件/音频/剪贴板
|
||
case TOKEN_FIRSTSCREEN: {
|
||
DrawFirstScreen();
|
||
m_ulFramesThisSecond++;
|
||
m_ulScreenBytesThisSecond += len;
|
||
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
|
||
break;
|
||
}
|
||
case TOKEN_NEXTSCREEN: {
|
||
DrawNextScreenDiff(false);
|
||
// Web 隐藏会话既不发 TOKEN_FIRSTSCREEN(H264 下客户端
|
||
// GetFirstScreenData() 直接返回 nullptr),也不跑本地 Decode(),
|
||
// 原有两条解锁路径一条都走不到。收到第一帧视频就视为首帧已到,
|
||
// 否则 TOKEN_SCROLL_FRAME 等门控会一直把帧吞掉。
|
||
if (m_bIsFirst && m_bIsWebSession)
|
||
m_bIsFirst = FALSE;
|
||
m_ulFramesThisSecond++;
|
||
m_ulScreenBytesThisSecond += len;
|
||
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
|
||
break;
|
||
}
|
||
case TOKEN_KEYFRAME: {
|
||
// IDR 是重建参考链的唯一起点,不能被 m_bIsFirst 门控:TOKEN_BITMAPINFO
|
||
// 每次分辨率变化都会把它重新置 TRUE,而 Web 会话拿不到首屏包、也不跑
|
||
// 本地解码。旧写法下切换后所有 TOKEN_KEYFRAME 都被静默丢弃,浏览器按新
|
||
// 尺寸重建 VideoDecoder 后只能收到 P 帧 → 永久黑屏。无条件转发与 Go
|
||
// 服务端 handleScreenFrame(ctx, data, true) 的行为一致。
|
||
DrawNextScreenDiff(true);
|
||
if (m_bIsFirst && m_bIsWebSession)
|
||
m_bIsFirst = FALSE;
|
||
m_ulFramesThisSecond++;
|
||
m_ulScreenBytesThisSecond += len;
|
||
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
|
||
break;
|
||
}
|
||
case TOKEN_SCROLL_FRAME: {
|
||
if (!m_bIsFirst) {
|
||
DrawScrollFrame();
|
||
}
|
||
m_ulFramesThisSecond++;
|
||
m_ulScreenBytesThisSecond += len;
|
||
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
|
||
break;
|
||
}
|
||
case TOKEN_CLIPBOARD_TEXT: {
|
||
Buffer str = m_ContextObject->InDeCompressedBuffer.GetMyBuffer(1);
|
||
UpdateServerClipboard(str.c_str(), str.length());
|
||
// 反向回传:远程剪贴板文本(UTF-8)→ Web 客户端
|
||
if (m_bIsWebSession && WebService().IsRunning()) {
|
||
WebService().NotifyClipboardText(m_ClientID, std::string(str.c_str(), str.length()));
|
||
}
|
||
break;
|
||
}
|
||
case TOKEN_BITMAPINFO: {
|
||
SAFE_DELETE(m_BitmapInfor_Full);
|
||
m_bIsFirst = TRUE;
|
||
const ULONG ulBitmapInforLength = sizeof(BITMAPINFOHEADER);
|
||
m_BitmapInfor_Full = (BITMAPINFO*) new BYTE[ulBitmapInforLength];
|
||
m_ContextObject->InDeCompressedBuffer.CopyBuffer(m_BitmapInfor_Full, ulBitmapInforLength, 1);
|
||
// 供 UI 线程(ApplyQualityLevel)无锁预判客户端是否变宽,避免跨线程解引用
|
||
m_nClientBitmapWidth.store(m_BitmapInfor_Full->bmiHeader.biWidth, std::memory_order_relaxed);
|
||
if (len >= 1 + sizeof(BITMAPINFOHEADER) + sizeof(uint64_t)) {
|
||
m_ClientID = *((uint64_t*)(m_ContextObject->InDeCompressedBuffer.GetBuffer(1 + sizeof(BITMAPINFOHEADER))));
|
||
}
|
||
PrepareDrawing(m_BitmapInfor_Full);
|
||
// 新一包位图信息 = 新会话/重新协商:算法快照作废,下一帧重新告知前端
|
||
m_nLastWebAlgo = -1;
|
||
m_nWebQualityNudges = 0;
|
||
m_nLastWebAlgoPush = 0;
|
||
// 调优开关紧随位图信息下发:此刻客户端的截屏对象刚建好、编码器还没创建
|
||
// (ensureEncoder 是 lazy 的),标志赶在第一帧编码前到位,不需要重建编码器。
|
||
SendScreenTuning();
|
||
// 重连或切换显示器后重新校验鼠标补偿(客户端上报分辨率可能已变化)。
|
||
LoadMouseScale();
|
||
// 分辨率切换完成,允许解码
|
||
m_bResolutionChanging = false;
|
||
// Notify web clients of resolution change (only for Web session dialogs)
|
||
if (m_bIsWebSession && WebService().IsRunning()) {
|
||
int width = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int height = abs(m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
bool topDown = (m_BitmapInfor_Full->bmiHeader.biClrImportant == 1);
|
||
std::string clientType;
|
||
if (g_2015RemoteDlg) {
|
||
context* main = g_2015RemoteDlg->FindHostByClientID(m_ClientID);
|
||
if (main) clientType = main->GetAdditionalData(RES_CLIENT_TYPE).GetString();
|
||
}
|
||
WebService().NotifyResolutionChange(m_ClientID, width, height, topDown, clientType);
|
||
}
|
||
// Web 会话核对客户端自己上报的档位:OnInitDialog 下发的 CMD_QUALITY_LEVEL 可能
|
||
// 与客户端的 BITMAPINFO 交叉(客户端在收到命令前就把自己保存的档位报了上来),
|
||
// 也可能客户端根本没接受(老客户端)。只要报上来的档位低于 Good,就再推一次,
|
||
// 否则这条会话永远不会有 H.264 帧,web 端就是黑屏。
|
||
if (m_bIsWebSession && WebService().IsRunning() &&
|
||
len >= 1 + sizeof(BITMAPINFOHEADER) + 2 * sizeof(uint64_t) + sizeof(ScreenSettings)) {
|
||
const ULONG ulSettingsOffset = 1 + sizeof(BITMAPINFOHEADER) + 2 * sizeof(uint64_t);
|
||
int reportedQuality = -1;
|
||
// 偏移不是 4 字节对齐,走 memcpy 避免非对齐指针解引用
|
||
memcpy(&reportedQuality,
|
||
m_ContextObject->InDeCompressedBuffer.GetBuffer(
|
||
ulSettingsOffset + offsetof(ScreenSettings, QualityLevel)),
|
||
sizeof(int));
|
||
if (reportedQuality >= QUALITY_GOOD) {
|
||
// 客户端已按 Good 以上上报:清掉去重记录,下次若再降档仍会重推。
|
||
m_nLastEchoedQuality = -1;
|
||
} else if (reportedQuality >= 0 && reportedQuality != m_nLastEchoedQuality) {
|
||
// 只在上报值变化时推一次:不认 CMD_QUALITY_LEVEL 或在编码器里自己降级
|
||
// 却仍按原值上报的客户端,每次 BITMAPINFO(连接/切屏/RestartScreen)
|
||
// 都会走这里,重复推送只是白发命令。
|
||
m_nLastEchoedQuality = reportedQuality;
|
||
Mprintf("[ScreenSpy] Client reports quality %d on a web session, forcing %d (Good)\n",
|
||
reportedQuality, QUALITY_GOOD);
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)QUALITY_GOOD, 0 };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_FILE_QUERY_RESUME: {
|
||
// V2 续传查询 - 根据 dstClientID 决定路由
|
||
FileQueryResumeV2* query = (FileQueryResumeV2*)szBuffer;
|
||
|
||
if (query->dstClientID == 0) {
|
||
// 目标是主控端 - 本地处理
|
||
auto response = HandleResumeQuery((const char*)szBuffer, len);
|
||
if (!response.empty()) {
|
||
m_ContextObject->Send2Client((LPBYTE)response.data(), (int)response.size());
|
||
Mprintf("[ScreenSpy] 已响应续传查询: %zu 字节\n", response.size());
|
||
}
|
||
} else {
|
||
// C2C - 转发到目标客户端的主连接
|
||
context* dstCtx = m_pParent->FindHost(query->dstClientID);
|
||
if (dstCtx) {
|
||
dstCtx->Send2Client(szBuffer, len);
|
||
Mprintf("[ScreenSpy] 转发续传查询: -> %llu\n", query->dstClientID);
|
||
} else {
|
||
Mprintf("[ScreenSpy] 续传查询目标不在线: %llu\n", query->dstClientID);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_C2C_TEXT: {
|
||
// C2C 文本剪贴板: [cmd:1][dstClientID:8][textLen:4][text:N]
|
||
if (len < 13) break;
|
||
uint64_t dstClientID;
|
||
uint32_t textLen;
|
||
memcpy(&dstClientID, szBuffer + 1, 8);
|
||
memcpy(&textLen, szBuffer + 9, 4);
|
||
|
||
Mprintf("[ScreenSpy] C2C 文本转发: -> %llu (%u 字节)\n", dstClientID, textLen);
|
||
|
||
// 转发到目标客户端的主连接
|
||
context* dstCtx = m_pParent->FindHost(dstClientID);
|
||
if (dstCtx) {
|
||
dstCtx->Send2Client(szBuffer, len);
|
||
} else {
|
||
Mprintf("[ScreenSpy] 文本目标不在线: %llu\n", dstClientID);
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_SEND_FILE_V2: {
|
||
// V2 文件传输
|
||
if (len < sizeof(FileChunkPacketV2)) break;
|
||
FileChunkPacketV2* pkt = (FileChunkPacketV2*)szBuffer;
|
||
|
||
if (pkt->dstClientID == 0) {
|
||
// 目标是服务端:本地接收
|
||
// 使用 PostMessage 将数据转发到主线程处理,避免在工作线程中操作 UI
|
||
FileV2MsgData* msgData = new FileV2MsgData(szBuffer, len, pkt->transferID);
|
||
PostMessage(WM_RECVFILEV2_CHUNK, (WPARAM)msgData, 0);
|
||
} else {
|
||
// C2C:转发到目标客户端
|
||
context* dstCtx = m_pParent->FindHost(pkt->dstClientID);
|
||
if (dstCtx) {
|
||
dstCtx->Send2Client(szBuffer, len);
|
||
} else {
|
||
Mprintf("[ScreenSpy] C2C 目标不在线: %llu\n", pkt->dstClientID);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_FILE_COMPLETE_V2: {
|
||
// V2 文件完成校验
|
||
if (len < sizeof(FileCompletePacketV2)) break;
|
||
FileCompletePacketV2* pkt = (FileCompletePacketV2*)szBuffer;
|
||
|
||
if (pkt->dstClientID == 0) {
|
||
// 目标是服务端:使用 PostMessage 转发到主线程处理
|
||
FileV2MsgData* msgData = new FileV2MsgData(szBuffer, len, pkt->transferID);
|
||
PostMessage(WM_RECVFILEV2_COMPLETE, (WPARAM)msgData, 0);
|
||
} else {
|
||
// C2C:转发到目标客户端
|
||
context* dstCtx = m_pParent->FindHost(pkt->dstClientID);
|
||
if (dstCtx) {
|
||
dstCtx->Send2Client(szBuffer, len);
|
||
Mprintf("[ScreenSpy] 转发校验包: -> %llu, transferID=%llu\n",
|
||
pkt->dstClientID, pkt->transferID);
|
||
} else {
|
||
Mprintf("[ScreenSpy] 校验包目标不在线: %llu\n", pkt->dstClientID);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_FILE_RESUME: {
|
||
// V2 断点续传控制 - 转发
|
||
// 注意:有两种格式的包共用此命令:
|
||
// - FileResumePacketV2 (49 bytes): 单文件续传请求/响应
|
||
// - FileResumeResponseV2 (23 bytes): 批量续传查询响应
|
||
// 需要根据包大小区分
|
||
|
||
if (len >= sizeof(FileResumePacketV2)) {
|
||
// 大包: FileResumePacketV2
|
||
FileResumePacketV2* pkt = (FileResumePacketV2*)szBuffer;
|
||
context* dstCtx = m_pParent->FindHost(pkt->dstClientID);
|
||
if (dstCtx) {
|
||
dstCtx->Send2Client(szBuffer, len);
|
||
Mprintf("[ScreenSpy] 转发续传包: -> %llu, transferID=%llu\n",
|
||
pkt->dstClientID, pkt->transferID);
|
||
}
|
||
} else if (len >= sizeof(FileResumeResponseV2)) {
|
||
// 小包: FileResumeResponseV2 (批量响应)
|
||
// 注意:响应要发回给 srcClientID(原始发送方)
|
||
FileResumeResponseV2* resp = (FileResumeResponseV2*)szBuffer;
|
||
context* srcCtx = m_pParent->FindHost(resp->srcClientID);
|
||
if (srcCtx) {
|
||
srcCtx->Send2Client(szBuffer, len);
|
||
Mprintf("[ScreenSpy] 转发续传响应: -> srcClient=%llu, %u 个文件\n",
|
||
resp->srcClientID, resp->fileCount);
|
||
} else {
|
||
Mprintf("[ScreenSpy] 续传响应目标不在线: %llu\n", resp->srcClientID);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case CMD_CURSOR_IMAGE: {
|
||
// 自定义光标图像: [cmd:1][hash:4][hotX:2][hotY:2][w:1][h:1][BGRA:w*h*4]
|
||
if (len < 11) break;
|
||
DWORD hash = *(DWORD*)(szBuffer + 1);
|
||
if (hash == m_dwCustomCursorHash && m_hCustomCursor) break; // 相同光标且已创建,忽略
|
||
|
||
WORD hotX = *(WORD*)(szBuffer + 5);
|
||
WORD hotY = *(WORD*)(szBuffer + 7);
|
||
BYTE width = szBuffer[9];
|
||
BYTE height = szBuffer[10];
|
||
|
||
// 检查尺寸有效性
|
||
if (width == 0 || height == 0 || width > 64 || height > 64) break;
|
||
|
||
LPBYTE bgraData = szBuffer + 11;
|
||
DWORD dataSize = width * height * 4;
|
||
|
||
if (len < 11 + dataSize) break; // 数据不完整
|
||
|
||
// 创建位图
|
||
HDC hScreenDC = ::GetDC(NULL);
|
||
if (!hScreenDC) break;
|
||
|
||
HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
|
||
if (!hMemDC) {
|
||
::ReleaseDC(NULL, hScreenDC);
|
||
break;
|
||
}
|
||
|
||
BITMAPINFO bmi = { 0 };
|
||
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
||
bmi.bmiHeader.biWidth = width;
|
||
bmi.bmiHeader.biHeight = -height; // 负数表示从上到下
|
||
bmi.bmiHeader.biPlanes = 1;
|
||
bmi.bmiHeader.biBitCount = 32;
|
||
bmi.bmiHeader.biCompression = BI_RGB;
|
||
|
||
void* pColorBits = NULL;
|
||
HBITMAP hColorBmp = CreateDIBSection(hScreenDC, &bmi, DIB_RGB_COLORS, &pColorBits, NULL, 0);
|
||
if (!hColorBmp || !pColorBits) {
|
||
::DeleteDC(hMemDC);
|
||
::ReleaseDC(NULL, hScreenDC);
|
||
break;
|
||
}
|
||
memcpy(pColorBits, bgraData, dataSize);
|
||
|
||
// 创建掩码位图(1bpp,行宽度 WORD 对齐)
|
||
int maskStride = ((width + 15) / 16) * 2; // 每行字节数,16位对齐
|
||
int maskSize = maskStride * height;
|
||
BYTE* maskBits = new BYTE[maskSize];
|
||
memset(maskBits, 0, maskSize);
|
||
|
||
// 根据 Alpha 通道生成掩码(内存操作,比 SetPixel 快 100 倍)
|
||
for (int y = 0; y < height; y++) {
|
||
for (int x = 0; x < width; x++) {
|
||
BYTE alpha = bgraData[(y * width + x) * 4 + 3];
|
||
if (alpha < 128) {
|
||
// 透明像素:掩码位=1
|
||
maskBits[y * maskStride + x / 8] |= (0x80 >> (x % 8));
|
||
}
|
||
}
|
||
}
|
||
|
||
HBITMAP hMaskBmp = ::CreateBitmap(width, height, 1, 1, maskBits);
|
||
delete[] maskBits;
|
||
|
||
if (!hMaskBmp) {
|
||
::DeleteObject(hColorBmp);
|
||
::DeleteDC(hMemDC);
|
||
::ReleaseDC(NULL, hScreenDC);
|
||
break;
|
||
}
|
||
|
||
// 创建光标
|
||
ICONINFO iconInfo = { 0 };
|
||
iconInfo.fIcon = FALSE;
|
||
iconInfo.xHotspot = hotX;
|
||
iconInfo.yHotspot = hotY;
|
||
iconInfo.hbmMask = hMaskBmp;
|
||
iconInfo.hbmColor = hColorBmp;
|
||
|
||
HCURSOR hNewCursor = CreateIconIndirect(&iconInfo);
|
||
|
||
// 清理位图(CreateIconIndirect 会复制)
|
||
::DeleteObject(hColorBmp);
|
||
::DeleteObject(hMaskBmp);
|
||
::DeleteDC(hMemDC);
|
||
::ReleaseDC(NULL, hScreenDC);
|
||
|
||
// 只有成功创建才更新
|
||
if (hNewCursor) {
|
||
if (m_hCustomCursor) {
|
||
DestroyCursor(m_hCustomCursor);
|
||
}
|
||
m_hCustomCursor = hNewCursor;
|
||
m_dwCustomCursorHash = hash;
|
||
|
||
// 如果当前正在使用自定义光标,立即更新显示
|
||
if (m_bCursorIndex == 254 && m_bIsCtrl && m_Settings.CustomCursor) {
|
||
if (m_Settings.RemoteCursor) {
|
||
// RemoteCursor 模式:触发重绘以显示新光标
|
||
Invalidate(FALSE);
|
||
} else {
|
||
// 窗口类光标模式:更新窗口类光标(避免引用已销毁的光标)
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)m_hCustomCursor);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case TOKEN_SCREEN_AUDIO: {
|
||
// 音频数据: [token:1][hasFormat:1][AudioFormat?][data...]
|
||
if (len > 2) {
|
||
OnAudioData(szBuffer + 1, len - 1);
|
||
}
|
||
break;
|
||
}
|
||
default: {
|
||
Mprintf("CScreenSpyDlg unknown command: %d!!!\n", int(cmd));
|
||
}
|
||
}
|
||
}
|
||
|
||
VOID CScreenSpyDlg::DrawFirstScreen(void)
|
||
{
|
||
m_bIsFirst = FALSE;
|
||
m_bQualitySwitch = false;
|
||
|
||
//得到被控端发来的数据 ,将他拷贝到HBITMAP的缓冲区中,这样一个图像就出现了
|
||
|
||
m_ContextObject->InDeCompressedBuffer.CopyBuffer(m_BitmapData_Full, m_BitmapInfor_Full->bmiHeader.biSizeImage, 1);
|
||
PostMessage(WM_PAINT);//触发WM_PAINT消息
|
||
}
|
||
|
||
// 把远程光标的位置/类型同步给 Web 客户端。抓屏画面本身不含光标(GDI/DXGI 都不合成),
|
||
// 非控制态的浏览器靠这条消息在画面上自己画一个光标。
|
||
// 类型变化 → 立即发(force=true);
|
||
// 位置变化 → 50ms 节流;
|
||
// 完全静止 → 每秒重发一次,让刚打开页面的观察者也能立刻看到光标位置
|
||
// (否则要等远程鼠标下一次移动)。
|
||
void CScreenSpyDlg::BroadcastCursorToWeb(bool force)
|
||
{
|
||
if (!m_bIsWebSession || !WebService().IsRunning()) return;
|
||
ULONGLONG now = GetTickCount64();
|
||
ULONGLONG since = now - m_nLastCursorBroadcast;
|
||
bool reshaped = force || m_bCursorIndex != m_bBroadcastCursorIndex;
|
||
bool moved = m_ClientCursorPos.x != m_ptBroadcastCursor.x ||
|
||
m_ClientCursorPos.y != m_ptBroadcastCursor.y;
|
||
if (!reshaped) {
|
||
if (since < 50) return; // 位置变化节流
|
||
if (!moved && since < 1000) return; // 静止时每秒兜底一次
|
||
}
|
||
m_nLastCursorBroadcast = now;
|
||
m_bBroadcastCursorIndex = m_bCursorIndex;
|
||
m_ptBroadcastCursor = m_ClientCursorPos;
|
||
WebService().BroadcastCursor(m_ClientID, m_bCursorIndex,
|
||
(int)m_ClientCursorPos.x, (int)m_ClientCursorPos.y);
|
||
}
|
||
|
||
VOID CScreenSpyDlg::DrawNextScreenDiff(bool keyFrame)
|
||
{
|
||
//该函数不是直接画到屏幕上,而是更新一下变化部分的屏幕数据然后调用
|
||
//OnPaint画上去
|
||
//根据鼠标是否移动和屏幕是否变化判断是否重绘鼠标,防止鼠标闪烁
|
||
BOOL bChange = FALSE;
|
||
ULONG ulHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 标识 + 算法 + 光标 位置 + 光标类型索引
|
||
#if SCREENYSPY_IMPROVE
|
||
int frameID = -1;
|
||
memcpy(&frameID, m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength), sizeof(int));
|
||
ulHeadLength += sizeof(int);
|
||
if (++m_FrameID != frameID) {
|
||
TRACE("DrawNextScreenDiff [%d] bmp is lost from %d\n", frameID-m_FrameID, m_FrameID);
|
||
m_FrameID = frameID;
|
||
}
|
||
#else
|
||
m_FrameID++;
|
||
#endif
|
||
LPVOID FirstScreenData = m_BitmapData_Full;
|
||
if (FirstScreenData == NULL || m_BitmapInfor_Full == NULL) return;
|
||
// 短包防护:ULONG 无符号相减会在包比头部还短时回绕成一个巨大的长度,后面
|
||
// 既可能被当成"整帧"memcpy,也会让 web 广播分配一个 4GB 的 vector。抓屏失败时
|
||
// 客户端(Linux 侧)会发只带光标的 11 字节包,正好卡在这个边界上。
|
||
const ULONG ulBufferLength = m_ContextObject->InDeCompressedBuffer.GetBufferLength();
|
||
if (ulBufferLength < ulHeadLength) {
|
||
return;
|
||
}
|
||
LPVOID NextScreenData = m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength);
|
||
ULONG NextScreenLength = ulBufferLength - ulHeadLength;
|
||
|
||
POINT OldClientCursorPos;
|
||
memcpy(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT));
|
||
memcpy(&m_ClientCursorPos, m_ContextObject->InDeCompressedBuffer.GetBuffer(2), sizeof(POINT));
|
||
|
||
// 鼠标移动了
|
||
if (memcmp(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT)) != 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
// 光标类型发生变化
|
||
BYTE bOldCursorIndex = m_bCursorIndex;
|
||
m_bCursorIndex = m_ContextObject->InDeCompressedBuffer.GetBuffer(2+sizeof(POINT))[0];
|
||
if (bOldCursorIndex != m_bCursorIndex) {
|
||
bChange = TRUE;
|
||
if (m_bIsCtrl && !m_bIsTraceCursor) {//替换指定窗口所属类的WNDCLASSEX结构
|
||
HCURSOR cursor;
|
||
if (m_bCursorIndex == 254) { // -2: 使用自定义光标
|
||
cursor = (m_Settings.CustomCursor && m_hCustomCursor) ? m_hCustomCursor : LoadCursor(NULL, IDC_ARROW);
|
||
} else if (m_bCursorIndex == 255) { // -1: 不支持,回退到箭头
|
||
cursor = LoadCursor(NULL, IDC_ARROW);
|
||
} else {
|
||
cursor = m_CursorInfo.getCursorHandle(m_bCursorIndex);
|
||
if (!cursor) cursor = LoadCursor(NULL, IDC_ARROW);
|
||
}
|
||
#ifdef _WIN64
|
||
SetClassLongPtrA(m_hWnd, GCLP_HCURSOR, (ULONG_PTR)cursor);
|
||
#else
|
||
SetClassLongA(m_hWnd, GCL_HCURSOR, (LONG)cursor);
|
||
#endif
|
||
}
|
||
}
|
||
// 通知 Web 客户端光标位置/类型(内部按类型变化/位置节流/每秒兜底决定是否真发)
|
||
BroadcastCursorToWeb(false);
|
||
|
||
// 屏幕是否变化
|
||
if (NextScreenLength > 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
BYTE algorithm = m_ContextObject->InDeCompressedBuffer.GetBYTE(1);
|
||
// Web 会话只转发 H.264:客户端按别的算法推帧时这边一条视频帧都不会发给浏览器,
|
||
// 前端表现是永久黑屏 + fps=0,而 MFC 窗口一切正常(它什么算法都能画)。这里做两件事:
|
||
// 1) 告诉前端"当前算法不能网页预览",让它给个明确提示,而不是留一块黑屏;
|
||
// 2) 节流地要求客户端切回 H.264,覆盖住"服务端档位设置/客户端自己保存的档位"
|
||
// 没能纠正过来的情况(老客户端、客户端 x264 初始化失败后降级等)。
|
||
if (m_bIsWebSession) {
|
||
if (algorithm != m_nLastWebAlgo) {
|
||
m_nLastWebAlgo = algorithm;
|
||
// 只有真正回到 H.264 才算成功、重置催切计数。若在 H.264 与非 H.264 之间
|
||
// 抖动的客户端也靠"算法变了"清零,下面的"最多 3 次"就永远到不了 3 次,
|
||
// 变成每 5 秒催一次、无限催(每次催都会重建客户端编码器)。
|
||
// 计数只在 TOKEN_BITMAPINFO(新一轮协商)和切回 H.264 时重置。
|
||
if (algorithm == ALGORITHM_H264) {
|
||
m_nWebQualityNudges = 0;
|
||
}
|
||
Mprintf("[ScreenSpy] Web session stream algorithm changed to %d\n", algorithm);
|
||
if (WebService().IsRunning()) {
|
||
WebService().NotifyStreamAlgorithm(m_ClientID, algorithm);
|
||
}
|
||
}
|
||
// 最多催 3 次(每 5 秒一次):客户端如果压根没有可用的 H.264 编码器
|
||
// (libx264 缺失/初始化失败),无限催下去只是每 5 秒重建一次编码器。
|
||
if (algorithm != ALGORITHM_H264 && m_nWebQualityNudges < 3) {
|
||
const ULONGLONG now = GetTickCount64();
|
||
if (m_nLastWebAlgoPush == 0 || now - m_nLastWebAlgoPush >= 5000) {
|
||
m_nLastWebAlgoPush = now;
|
||
m_nWebQualityNudges++;
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)QUALITY_GOOD, 0 };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
}
|
||
}
|
||
}
|
||
LPBYTE dst = (LPBYTE)FirstScreenData, p = (LPBYTE)NextScreenData;
|
||
const ULONG ulDstSize = (ULONG)m_BitmapInfor_Full->bmiHeader.biSizeImage;
|
||
if (keyFrame) {
|
||
switch (algorithm) {
|
||
case ALGORITHM_DIFF:
|
||
case ALGORITHM_GRAY: {
|
||
if (m_BitmapInfor_Full->bmiHeader.biSizeImage == NextScreenLength)
|
||
memcpy(dst, p, m_BitmapInfor_Full->bmiHeader.biSizeImage);
|
||
break;
|
||
}
|
||
case ALGORITHM_RGB565: {
|
||
// RGB565 关键帧:将 RGB565 整帧还原为 BGRA
|
||
ULONG pixelCount = m_BitmapInfor_Full->bmiHeader.biSizeImage / 4;
|
||
if (pixelCount * 2 == NextScreenLength)
|
||
ConvertRGB565ToBGRA((const uint16_t*)p, dst, pixelCount);
|
||
break;
|
||
}
|
||
case ALGORITHM_H264: {
|
||
// Decode locally if dialog is visible
|
||
if (!m_bHide && NextScreenLength > 0) {
|
||
if (Decode((LPBYTE)NextScreenData, NextScreenLength)) {
|
||
bChange = TRUE;
|
||
// IDR 解码成功即参考链已建立,与差分帧解码成功同样解除首帧门控。
|
||
// 可见会话分辨率切换后的首个包可能就是 forced IDR,不清的话
|
||
// OnPaint 还要再等一帧差分帧才停止显示"请等待"。
|
||
if (m_bIsFirst)
|
||
m_bIsFirst = FALSE;
|
||
}
|
||
}
|
||
// Broadcast H264 keyframe to web clients (only for Web session dialogs)
|
||
if (m_bIsWebSession && NextScreenLength > 0 && WebService().IsRunning()) {
|
||
std::vector<uint8_t> packet(4 + 1 + 4 + NextScreenLength);
|
||
uint32_t deviceIdLow = (uint32_t)(m_ClientID & 0xFFFFFFFF);
|
||
uint8_t frameType = 1; // Keyframe
|
||
uint32_t dataLen = (uint32_t)NextScreenLength;
|
||
memcpy(packet.data(), &deviceIdLow, 4);
|
||
packet[4] = frameType;
|
||
memcpy(packet.data() + 5, &dataLen, 4);
|
||
memcpy(packet.data() + 9, NextScreenData, NextScreenLength);
|
||
WebService().BroadcastH264Frame(m_ClientID, packet.data(), packet.size());
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
} else if (0 != NextScreenLength) {
|
||
switch (algorithm) {
|
||
// 差分帧的块头(目标偏移/块长度)全部由客户端给出,这里必须逐块夹到包的
|
||
// 有效长度和 DIB 尺寸之内:以前直接 memcpy(dst + 对端偏移, ..., 对端长度),
|
||
// 一个截断或损坏的包就是一次任意偏移、任意长度的堆写,足以打崩整个主控端。
|
||
case ALGORITHM_DIFF: {
|
||
bool bad = false;
|
||
for (LPBYTE end = p + NextScreenLength; p + 2 * sizeof(ULONG) <= end; ) {
|
||
ULONG dstOffset = *(LPDWORD)p;
|
||
ULONG ulCount = *(LPDWORD)(p + sizeof(ULONG));
|
||
if (ulCount > (ULONG)(end - (p + 2 * sizeof(ULONG))) ||
|
||
dstOffset > ulDstSize || ulCount > ulDstSize - dstOffset) {
|
||
bad = true;
|
||
break;
|
||
}
|
||
memcpy(dst + dstOffset, p + 2 * sizeof(ULONG), ulCount);
|
||
|
||
p += 2 * sizeof(ULONG) + ulCount;
|
||
}
|
||
if (bad) Mprintf("[ScreenSpy] 丢弃越界的 DIFF 差分块\n");
|
||
break;
|
||
}
|
||
case ALGORITHM_GRAY: {
|
||
bool bad = false;
|
||
for (LPBYTE end = p + NextScreenLength; p + 2 * sizeof(ULONG) <= end; ) {
|
||
ULONG dstOffset = *(LPDWORD)p;
|
||
ULONG ulCount = *(LPDWORD)(p + sizeof(ULONG));
|
||
if (ulCount > (ULONG)(end - (p + 2 * sizeof(ULONG))) ||
|
||
dstOffset > ulDstSize ||
|
||
ulCount > (ulDstSize - dstOffset) / sizeof(DWORD)) {
|
||
bad = true;
|
||
break;
|
||
}
|
||
LPBYTE p1 = dst + dstOffset, p2 = p + 2 * sizeof(ULONG);
|
||
for (ULONG i = 0; i < ulCount; ++i, p1 += 4)
|
||
memset(p1, *p2++, sizeof(DWORD));
|
||
|
||
p += 2 * sizeof(ULONG) + ulCount;
|
||
}
|
||
if (bad) Mprintf("[ScreenSpy] 丢弃越界的 GRAY 差分块\n");
|
||
break;
|
||
}
|
||
case ALGORITHM_RGB565: {
|
||
// RGB565 差分帧:解码每个差异块
|
||
bool bad = false;
|
||
for (LPBYTE end = p + NextScreenLength; p + 2 * sizeof(ULONG) <= end; ) {
|
||
ULONG pos = *(LPDWORD)p; // BGRA 字节偏移
|
||
ULONG pixelCount = *(LPDWORD)(p + sizeof(ULONG)); // 像素数量
|
||
LPBYTE pixelData = p + 2 * sizeof(ULONG);
|
||
if (pixelCount > (ULONG)(end - pixelData) / 2 || // 源数据 2 字节/像素
|
||
pos > ulDstSize ||
|
||
pixelCount > (ulDstSize - pos) / sizeof(DWORD)) { // 目标 4 字节/像素
|
||
bad = true;
|
||
break;
|
||
}
|
||
|
||
// RGB565 → BGRA 还原到目标位置
|
||
ConvertRGB565ToBGRA((const uint16_t*)pixelData, dst + pos, pixelCount);
|
||
p = pixelData + pixelCount * 2;
|
||
}
|
||
if (bad) Mprintf("[ScreenSpy] 丢弃越界的 RGB565 差分块\n");
|
||
break;
|
||
}
|
||
case ALGORITHM_H264: {
|
||
// Only decode locally if dialog is visible (skip when hidden for web-only viewing)
|
||
if (!m_bHide) {
|
||
if (Decode((LPBYTE)NextScreenData, NextScreenLength)) {
|
||
bChange = TRUE;
|
||
// 解码成功即代表 IDR 参考帧已建立(编码器首帧强制 IDR),解除门控。
|
||
// 不依赖 IsAnyKeyframe:某些硬编输出格式或解码器首帧 EAGAIN 延迟会导致
|
||
// 关键帧检测误判,进而让 m_bIsFirst 永久为 TRUE("请等待"卡死)。
|
||
if (m_bIsFirst)
|
||
m_bIsFirst = FALSE;
|
||
}
|
||
}
|
||
// Broadcast video frame to web clients (only for Web session dialogs)
|
||
// Format: [DeviceID:4][FrameType:1][DataLen:4][VideoData:N]
|
||
// 浏览器侧按首字节嗅探区分 H.264 / AV1,因此 packet 内不需要 codec 字段。
|
||
if (m_bIsWebSession && NextScreenLength > 0 && WebService().IsRunning()) {
|
||
bool isKeyFrame = IsAnyKeyframe((const uint8_t*)NextScreenData, NextScreenLength);
|
||
|
||
std::vector<uint8_t> packet(4 + 1 + 4 + NextScreenLength);
|
||
uint32_t deviceIdLow = (uint32_t)(m_ClientID & 0xFFFFFFFF);
|
||
uint8_t frameType = isKeyFrame ? 1 : 0;
|
||
uint32_t dataLen = (uint32_t)NextScreenLength;
|
||
|
||
memcpy(packet.data(), &deviceIdLow, 4);
|
||
packet[4] = frameType;
|
||
memcpy(packet.data() + 5, &dataLen, 4);
|
||
memcpy(packet.data() + 9, NextScreenData, NextScreenLength);
|
||
|
||
WebService().BroadcastH264Frame(m_ClientID, packet.data(), packet.size());
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
#if SCREENSPY_WRITE
|
||
if (!WriteBitmap(m_BitmapInfor_Full, m_BitmapData_Full, "YAMA", frameID)) {
|
||
TRACE("WriteBitmap [%d] failed!!!\n", frameID);
|
||
}
|
||
#endif
|
||
|
||
if (bChange && !m_bHide) {
|
||
PostMessage(WM_PAINT);
|
||
}
|
||
}
|
||
|
||
|
||
VOID CScreenSpyDlg::DrawScrollFrame()
|
||
{
|
||
// 滚动帧消息格式:
|
||
// 字节 0: TOKEN_SCROLL_FRAME (99)
|
||
// 字节 1: 算法类型
|
||
// 字节 2-5: 光标 X
|
||
// 字节 6-9: 光标 Y
|
||
// 字节 10: 光标类型
|
||
// 字节 11: 滚动方向 (0=上, 1=下)
|
||
// 字节 12-15: 滚动距离 (像素)
|
||
// 字节 16-19: 边缘数据偏移 (字节)
|
||
// 字节 20-23: 边缘数据长度 (像素数)
|
||
// 字节 24+: 边缘像素数据
|
||
|
||
BOOL bChange = FALSE;
|
||
ULONG ulHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 11 字节
|
||
|
||
LPVOID FirstScreenData = m_BitmapData_Full;
|
||
if (FirstScreenData == NULL || m_BitmapInfor_Full == NULL) return;
|
||
|
||
// 滚动参数(方向/距离/边缘偏移/边缘像素数,共 13 字节)在包头之后。包不足
|
||
// 24 字节时下面的 buffer[0..12] 读的是未初始化/越界内存,GetBuffer 还可能
|
||
// 直接返回 NULL。822eb1c 之后 web 会话首帧即解除 m_bIsFirst 门控,滚动帧不
|
||
// 再只有 MFC 会话能走到,先把长度卡住。
|
||
const ULONG ulBufferLength = m_ContextObject->InDeCompressedBuffer.GetBufferLength();
|
||
if (ulBufferLength < ulHeadLength + 13) return;
|
||
|
||
// 读取光标位置
|
||
POINT OldClientCursorPos;
|
||
memcpy(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT));
|
||
memcpy(&m_ClientCursorPos, m_ContextObject->InDeCompressedBuffer.GetBuffer(2), sizeof(POINT));
|
||
|
||
if (memcmp(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT)) != 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
// 读取光标类型
|
||
BYTE bOldCursorIndex = m_bCursorIndex;
|
||
m_bCursorIndex = m_ContextObject->InDeCompressedBuffer.GetBuffer(2 + sizeof(POINT))[0];
|
||
if (bOldCursorIndex != m_bCursorIndex) {
|
||
bChange = TRUE;
|
||
}
|
||
// 通知 Web 客户端光标位置/类型(内部按类型变化/位置节流/每秒兜底决定是否真发)
|
||
BroadcastCursorToWeb(false);
|
||
|
||
// 读取滚动参数
|
||
LPBYTE buffer = m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength);
|
||
BYTE direction = buffer[0];
|
||
int scrollAmount = *(int*)(buffer + 1);
|
||
int edgeOffset = *(int*)(buffer + 5);
|
||
int edgePixelCount = *(int*)(buffer + 9);
|
||
LPBYTE edgeData = buffer + 13;
|
||
|
||
BYTE algorithm = m_ContextObject->InDeCompressedBuffer.GetBYTE(1);
|
||
LPBYTE dst = (LPBYTE)FirstScreenData;
|
||
|
||
// 1. 滚动现有位图缓冲区
|
||
// BMP is bottom-up: row 0 = screen bottom, row height-1 = screen top
|
||
int stride = m_BitmapInfor_Full->bmiHeader.biWidth * 4;
|
||
int height = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
const ULONG ulDstSize = (ULONG)m_BitmapInfor_Full->bmiHeader.biSizeImage;
|
||
|
||
// 滚动参数全部来自客户端:scrollAmount 超出 [0, height) 会让 copyHeight 为负,
|
||
// copyHeight * stride 转成 size_t 后是一次数 GB 的越界 memmove(直接崩主控端);
|
||
// 边缘块同理必须落在 DIB 内、且数据确实在包里。宁可丢这一帧等下一个关键帧。
|
||
const int srcBpp = (algorithm == ALGORITHM_RGB565) ? 2
|
||
: (algorithm == ALGORITHM_GRAY) ? 1 : 4;
|
||
const ULONG ulEdgeBytes = ulBufferLength - (ulHeadLength + 13);
|
||
if (height <= 0 || stride <= 0 ||
|
||
scrollAmount < 0 || scrollAmount >= height ||
|
||
edgeOffset < 0 || edgePixelCount < 0 ||
|
||
(ULONG)edgeOffset > ulDstSize ||
|
||
(ULONG)edgePixelCount > (ulDstSize - (ULONG)edgeOffset) / sizeof(DWORD) ||
|
||
(ULONG)edgePixelCount * (ULONG)srcBpp > ulEdgeBytes) {
|
||
Mprintf("[ScreenSpy] 丢弃越界的滚动帧 (dir=%d, scroll=%d, h=%d, edgeOffset=%d, edgePixels=%d)\n",
|
||
direction, scrollAmount, height, edgeOffset, edgePixelCount);
|
||
return;
|
||
}
|
||
int copyHeight = height - scrollAmount;
|
||
|
||
if (direction == SCROLL_DIR_UP) {
|
||
// 向上滚动:屏幕内容向下移,BMP 中高地址移到低地址
|
||
// 新内容填充到 BMP 高地址(屏幕顶部)
|
||
memmove(dst, dst + (size_t)scrollAmount * stride, (size_t)copyHeight * stride);
|
||
} else {
|
||
// 向下滚动:屏幕内容向上移,BMP 中低地址移到高地址
|
||
// 新内容填充到 BMP 低地址(屏幕底部)
|
||
memmove(dst + (size_t)scrollAmount * stride, dst, (size_t)copyHeight * stride);
|
||
}
|
||
|
||
// 2. 复制边缘数据
|
||
LPBYTE edgeDst = dst + edgeOffset;
|
||
switch (algorithm) {
|
||
case ALGORITHM_RGB565:
|
||
ConvertRGB565ToBGRA((const uint16_t*)edgeData, edgeDst, edgePixelCount);
|
||
break;
|
||
case ALGORITHM_GRAY:
|
||
for (int i = 0; i < edgePixelCount; ++i, edgeDst += 4) {
|
||
memset(edgeDst, edgeData[i], 3);
|
||
edgeDst[3] = 0xFF;
|
||
}
|
||
break;
|
||
case ALGORITHM_DIFF:
|
||
default:
|
||
memcpy(edgeDst, edgeData, edgePixelCount * 4);
|
||
break;
|
||
}
|
||
|
||
bChange = TRUE;
|
||
m_FrameID++;
|
||
|
||
if (bChange && !m_bHide) {
|
||
PostMessage(WM_PAINT);
|
||
}
|
||
}
|
||
|
||
// 分辨率切换超时的统一兜底。必须放在 UI 定时器里,不能放进 Decode():
|
||
// Web 隐藏会话 m_bHide=true 时 DrawNextScreenDiff() 会跳过本地解码,那段逻辑
|
||
// 永远不执行;切换失败后 Web 端既收不到新位图信息也拿不到 IDR,只能一直黑屏。
|
||
void CScreenSpyDlg::CheckResolutionChangeTimeout()
|
||
{
|
||
if (!m_bResolutionChanging) return;
|
||
// 正常情况下客户端的 TOKEN_BITMAPINFO 会把它清掉(见 OnReceive);真正不会
|
||
// 重启截屏的档位切换(例如 1920 屏 High→Good)已在 ApplyQualityLevel 里按
|
||
// 客户端的 needRestart 判据排除,不会置这个标记。
|
||
if (GetTickCount64() - m_AdaptiveQuality.lastResChangeTime <= 1000) return;
|
||
m_bResolutionChanging = false; // 超时恢复
|
||
// flush 交给解码线程消费,避免 UI 线程与 Decode() 并发访问 AVCodecContext。
|
||
m_bNeedFlushDecoder.store(true);
|
||
// 没有新的位图信息说明没重启(或重启没完成),画面还停在旧算法的那一帧上,
|
||
// 必须让客户端立刻补一个 IDR,否则要等自然 GOP(x264 keyint 最长 15 秒)。
|
||
RequestClientKeyFrame();
|
||
Mprintf("分辨率切换超时(无位图信息),刷新解码器并请求关键帧\n");
|
||
}
|
||
|
||
bool CScreenSpyDlg::Decode(LPBYTE Buffer, int size)
|
||
{
|
||
// 分辨率切换中,跳过解码避免访问无效缓冲区;超时恢复见 OnTimer(4)。
|
||
if (m_bResolutionChanging) {
|
||
return false;
|
||
}
|
||
// 参考帧已失效:刷新解码器状态,丢弃旧参考帧后再喂新 IDR。Web 隐藏会话不
|
||
// 解码,这个标记留着也无害(下一次可见会话的解码会消费掉)。
|
||
if (m_bNeedFlushDecoder.exchange(false)) {
|
||
if (m_pCodecContext) {
|
||
avcodec_flush_buffers(m_pCodecContext);
|
||
}
|
||
}
|
||
if (!m_BitmapData_Full || !m_BitmapInfor_Full) {
|
||
return false;
|
||
}
|
||
|
||
// 解码数据.
|
||
av_init_packet(&m_AVPacket);
|
||
|
||
m_AVPacket.data = (uint8_t*)Buffer;
|
||
m_AVPacket.size = size;
|
||
|
||
int err = avcodec_send_packet(m_pCodecContext, &m_AVPacket);
|
||
if (!err) {
|
||
err = avcodec_receive_frame(m_pCodecContext, &m_AVFrame);
|
||
if (err == AVERROR(EAGAIN)) {
|
||
Mprintf("avcodec_receive_frame error: EAGAIN\n");
|
||
return false;
|
||
}
|
||
|
||
// 解码数据前会清除m_AVFrame的内容.
|
||
if (!err) {
|
||
LPVOID Image[2] = { 0 };
|
||
LPVOID CursorInfo[2] = { 0 };
|
||
//成功.
|
||
//I420 ---> ARGB.
|
||
//WaitForSingleObject(m_hMutex,INFINITE);
|
||
|
||
{
|
||
int W = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int H = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
// biClrImportant==1: top-down H264 (Android MediaCodec standard output).
|
||
// 精确匹配 1,避免调色板 DIB(biClrImportant=N 表示重要色数量)被误判。
|
||
// libyuv 负高度只翻转目标写入方向,源指针不变,data[0] 仍指向第一行。
|
||
bool topDown = (m_BitmapInfor_Full->bmiHeader.biClrImportant == 1);
|
||
libyuv::I420ToARGB(
|
||
m_AVFrame.data[0], m_AVFrame.linesize[0],
|
||
m_AVFrame.data[1], m_AVFrame.linesize[1],
|
||
m_AVFrame.data[2], m_AVFrame.linesize[2],
|
||
(uint8_t*)m_BitmapData_Full,
|
||
W * 4,
|
||
W,
|
||
topDown ? -H : H);
|
||
}
|
||
return true;
|
||
}
|
||
Mprintf("avcodec_receive_frame failed with error: %d\n", err);
|
||
} else {
|
||
Mprintf("avcodec_send_packet failed with error: %d\n", err);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 跳过默认背景擦除:随帧重绘时若先 FillRect 灰色再 BitBlt 帧,会在两步之间
|
||
// 出现"瞬时灰背景",启用远程光标(应用层 DrawIconEx)时尤其明显——光标随每帧重绘,
|
||
// 灰一闪 → 帧覆盖 → 重画光标,循环看上去就是光标频繁闪烁。
|
||
// adaptive/zoom 模式下 BitBlt/StretchBlt 覆盖整个客户区,本就不需要先擦;
|
||
// m_bIsFirst(首帧未到达)仍走默认擦除以避免显示残留内容。
|
||
BOOL CScreenSpyDlg::OnEraseBkgnd(CDC* pDC)
|
||
{
|
||
if (m_bIsFirst) {
|
||
return __super::OnEraseBkgnd(pDC);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void CScreenSpyDlg::OnPaint()
|
||
{
|
||
if (m_bIsClosed) return;
|
||
CPaintDC dc(this); // device context for painting
|
||
|
||
if (m_bIsFirst) {
|
||
if (!m_bQualitySwitch)
|
||
DrawTipString(_TR("请等待......"));
|
||
return;
|
||
}
|
||
|
||
int srcW = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int srcH = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
|
||
// 放大模式渲染
|
||
if (m_bZoomedIn && !m_rcZoomSrc.IsRectEmpty()) {
|
||
// 使用放大区域作为源进行StretchBlt
|
||
StretchBlt(m_hFullDC, 0, 0, dstW, dstH,
|
||
m_hFullMemDC,
|
||
m_rcZoomSrc.left, m_rcZoomSrc.top,
|
||
m_rcZoomSrc.Width(), m_rcZoomSrc.Height(),
|
||
SRCCOPY);
|
||
} else if (m_bAdaptiveSize) {
|
||
// 保持宽高比居中缩放,多余区域填黑(信箱 / 柱状黑边)
|
||
// 同步更新 m_offsetX/Y 和 m_wZoom/hZoom,供坐标映射使用
|
||
int renderW, renderH;
|
||
ComputeAdaptiveLayout(srcW, srcH, dstW, dstH,
|
||
renderW, renderH, m_offsetX, m_offsetY,
|
||
m_wZoom, m_hZoom);
|
||
|
||
// 图像未填满窗口(含整除截断 renderH=dstH-1 导致 offset=0 的情况)时走合成路径
|
||
if (renderW < dstW || renderH < dstH) {
|
||
// 先在内存 DC 合成完整帧再一次性上屏,避免"先黑后图"的闪烁
|
||
// 按窗口尺寸缓存 DC/Bitmap,尺寸不变时直接复用,不重复分配 GDI 资源
|
||
if (!m_hComposeDC || m_nComposeCX != dstW || m_nComposeCY != dstH) {
|
||
if (m_hComposeDC) {
|
||
SelectObject(m_hComposeDC, m_hComposeOldBmp);
|
||
DeleteObject(m_hComposeBmp);
|
||
DeleteDC(m_hComposeDC);
|
||
m_hComposeDC = NULL; m_hComposeBmp = NULL; m_hComposeOldBmp = NULL;
|
||
}
|
||
m_hComposeDC = CreateCompatibleDC(m_hFullDC);
|
||
if (m_hComposeDC) {
|
||
m_hComposeBmp = CreateCompatibleBitmap(m_hFullDC, dstW, dstH);
|
||
if (m_hComposeBmp) {
|
||
m_hComposeOldBmp = (HBITMAP)SelectObject(m_hComposeDC, m_hComposeBmp);
|
||
m_nComposeCX = dstW;
|
||
m_nComposeCY = dstH;
|
||
} else {
|
||
DeleteDC(m_hComposeDC);
|
||
m_hComposeDC = NULL;
|
||
}
|
||
}
|
||
}
|
||
if (m_hComposeDC) {
|
||
SetStretchBltMode(m_hComposeDC, GetFastStretchMode() ? COLORONCOLOR : HALFTONE);
|
||
if (!GetFastStretchMode()) SetBrushOrgEx(m_hComposeDC, 0, 0, NULL);
|
||
RECT rcFull = { 0, 0, dstW, dstH };
|
||
FillRect(m_hComposeDC, &rcFull, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
||
StretchBlt(m_hComposeDC, m_offsetX, m_offsetY, renderW, renderH,
|
||
m_hFullMemDC, 0, 0, srcW, srcH, SRCCOPY);
|
||
BitBlt(m_hFullDC, 0, 0, dstW, dstH, m_hComposeDC, 0, 0, SRCCOPY);
|
||
} else {
|
||
// GDI 资源不足,退化为直接渲染(可能闪一帧黑边,但不崩溃)
|
||
RECT rcFull = { 0, 0, dstW, dstH };
|
||
FillRect(m_hFullDC, &rcFull, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
||
StretchBlt(m_hFullDC, m_offsetX, m_offsetY, renderW, renderH,
|
||
m_hFullMemDC, 0, 0, srcW, srcH, SRCCOPY);
|
||
}
|
||
} else if (srcW == dstW && srcH == dstH) {
|
||
BitBlt(m_hFullDC, 0, 0, srcW, srcH, m_hFullMemDC, 0, 0, SRCCOPY);
|
||
} else {
|
||
StretchBlt(m_hFullDC, 0, 0, dstW, dstH, m_hFullMemDC, 0, 0, srcW, srcH, SRCCOPY);
|
||
}
|
||
} else {
|
||
// 实际可见的位图像素数 = 位图剩余宽高(去掉滚动偏移后)与窗口的较小值
|
||
int visW = max(0, min(srcW - (int)m_ulHScrollPos, dstW));
|
||
int visH = max(0, min(srcH - (int)m_ulVScrollPos, dstH));
|
||
if (visW > 0 && visH > 0)
|
||
BitBlt(m_hFullDC, 0, 0, visW, visH, m_hFullMemDC, m_ulHScrollPos, m_ulVScrollPos, SRCCOPY);
|
||
// 位图未覆盖的区域(远程分辨率小于窗口 / 滚动到边缘)填黑,防止残影
|
||
if (visW < dstW) {
|
||
RECT rc = { visW, 0, dstW, dstH };
|
||
FillRect(m_hFullDC, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
||
}
|
||
if (visH < dstH) {
|
||
RECT rc = { 0, visH, dstW, dstH };
|
||
FillRect(m_hFullDC, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
||
}
|
||
}
|
||
|
||
// 绘制框选矩形(左键放大用红色,右键截图用绿色,ROI用蓝色)
|
||
if (m_bSelectingZoom || m_bSelectingShot) {
|
||
CPoint ptStart = m_bSelectingZoom ? m_ptZoomStart : m_ptShotStart;
|
||
CPoint ptCur = m_bSelectingZoom ? m_ptZoomCurrent : m_ptShotCurrent;
|
||
COLORREF clr = m_bSelectingZoom ? RGB(255, 0, 0) : RGB(0, 180, 0);
|
||
|
||
CRect rcSelect;
|
||
rcSelect.left = min(ptStart.x, ptCur.x);
|
||
rcSelect.top = min(ptStart.y, ptCur.y);
|
||
rcSelect.right = max(ptStart.x, ptCur.x);
|
||
rcSelect.bottom = max(ptStart.y, ptCur.y);
|
||
|
||
HPEN hPen = CreatePen(PS_DASH, 1, clr);
|
||
HPEN hOldPen = (HPEN)SelectObject(m_hFullDC, hPen);
|
||
HBRUSH hOldBrush = (HBRUSH)SelectObject(m_hFullDC, GetStockObject(NULL_BRUSH));
|
||
Rectangle(m_hFullDC, rcSelect.left, rcSelect.top, rcSelect.right, rcSelect.bottom);
|
||
SelectObject(m_hFullDC, hOldBrush);
|
||
SelectObject(m_hFullDC, hOldPen);
|
||
DeleteObject(hPen);
|
||
}
|
||
|
||
if (m_bSelectingROI) {
|
||
CRect rcSelect;
|
||
rcSelect.left = min(m_ptROIStart.x, m_ptROICurrent.x);
|
||
rcSelect.top = min(m_ptROIStart.y, m_ptROICurrent.y);
|
||
rcSelect.right = max(m_ptROIStart.x, m_ptROICurrent.x);
|
||
rcSelect.bottom = max(m_ptROIStart.y, m_ptROICurrent.y);
|
||
HPEN hPen = CreatePen(PS_DASH, 1, RGB(0, 120, 215));
|
||
HPEN hOldPen = (HPEN)SelectObject(m_hFullDC, hPen);
|
||
HBRUSH hOldBrush = (HBRUSH)SelectObject(m_hFullDC, GetStockObject(NULL_BRUSH));
|
||
Rectangle(m_hFullDC, rcSelect.left, rcSelect.top, rcSelect.right, rcSelect.bottom);
|
||
SelectObject(m_hFullDC, hOldBrush);
|
||
SelectObject(m_hFullDC, hOldPen);
|
||
DeleteObject(hPen);
|
||
}
|
||
|
||
if ((m_bIsCtrl && m_Settings.RemoteCursor) || m_bIsTraceCursor) {
|
||
CPoint ptLocal;
|
||
GetCursorPos(&ptLocal);
|
||
ScreenToClient(&ptLocal);
|
||
|
||
CRect rcToolbar(0, 0, 0, 0);
|
||
if (m_pToolbar) m_pToolbar->GetWindowRect(&rcToolbar), ScreenToClient(&rcToolbar);
|
||
// 只有当本地鼠标不在工具栏区域时,才绘制远程位图光标
|
||
if (!rcToolbar.PtInRect(ptLocal)) {
|
||
|
||
// 1. 计算缩放位置(自适应模式需加黑边偏移)
|
||
int drawX = m_bAdaptiveSize ? (int)(m_ClientCursorPos.x / m_wZoom) + m_offsetX : (m_ClientCursorPos.x - m_ulHScrollPos);
|
||
int drawY = m_bAdaptiveSize ? (int)(m_ClientCursorPos.y / m_hZoom) + m_offsetY : (m_ClientCursorPos.y - m_ulVScrollPos);
|
||
|
||
// 2. 获取光标句柄(支持自定义光标)
|
||
HCURSOR hCursor;
|
||
if (m_bCursorIndex == 254) { // -2: 使用自定义光标
|
||
hCursor = (m_Settings.CustomCursor && m_hCustomCursor) ? m_hCustomCursor : LoadCursor(NULL, IDC_ARROW);
|
||
} else if (m_bCursorIndex == 255) { // -1: 不支持,回退到箭头
|
||
hCursor = LoadCursor(NULL, IDC_ARROW);
|
||
} else {
|
||
hCursor = m_CursorInfo.getCursorHandle(m_bCursorIndex);
|
||
if (!hCursor) hCursor = LoadCursor(NULL, IDC_ARROW);
|
||
}
|
||
|
||
// 3. 强制绘制
|
||
DrawIconEx(
|
||
m_hFullDC,
|
||
drawX,
|
||
drawY,
|
||
hCursor,
|
||
0, 0, 0, NULL, DI_NORMAL | DI_COMPAT
|
||
);
|
||
}
|
||
}
|
||
if (!m_bConnected && GetTickCount64() - m_nDisconnectTime>2000) {
|
||
DrawTipString(_TR("正在重连......"), 2);
|
||
}
|
||
// 截图保存提示 (显示3秒,断线重连时不显示避免重叠)
|
||
if (m_bConnected && !m_strSaveNotice.empty() && GetTickCount64() - m_nSaveNoticeTime < 3000) {
|
||
RECT rcClient;
|
||
GetClientRect(&rcClient);
|
||
int cw = rcClient.right - rcClient.left;
|
||
int ch = rcClient.bottom - rcClient.top;
|
||
|
||
CString tipText;
|
||
tipText.FormatL("已保存: %s", m_strSaveNotice.c_str());
|
||
|
||
// 计算文字尺寸
|
||
HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
|
||
HFONT hOldFont = (HFONT)SelectObject(m_hFullDC, hFont);
|
||
SIZE textSize;
|
||
GetTextExtentPoint32(m_hFullDC, tipText, tipText.GetLength(), &textSize);
|
||
|
||
int padding = 10;
|
||
int bannerW = textSize.cx + padding * 2;
|
||
int bannerH = textSize.cy + padding * 2;
|
||
int bannerX = (cw - bannerW) / 2;
|
||
int bannerY = ch - bannerH - 40;
|
||
|
||
// 半透明黑色背景
|
||
HDC hMemDC = CreateCompatibleDC(m_hFullDC);
|
||
HBITMAP hBmp = CreateCompatibleBitmap(m_hFullDC, bannerW, bannerH);
|
||
HBITMAP hOldBmp = (HBITMAP)SelectObject(hMemDC, hBmp);
|
||
HBRUSH hBrush = CreateSolidBrush(RGB(0, 0, 0));
|
||
RECT rcBanner = { 0, 0, bannerW, bannerH };
|
||
FillRect(hMemDC, &rcBanner, hBrush);
|
||
DeleteObject(hBrush);
|
||
|
||
BLENDFUNCTION blend = { 0 };
|
||
blend.BlendOp = AC_SRC_OVER;
|
||
blend.SourceConstantAlpha = 180;
|
||
AlphaBlend(m_hFullDC, bannerX, bannerY, bannerW, bannerH,
|
||
hMemDC, 0, 0, bannerW, bannerH, blend);
|
||
|
||
SelectObject(hMemDC, hOldBmp);
|
||
DeleteObject(hBmp);
|
||
DeleteDC(hMemDC);
|
||
|
||
// 绘制白色文字
|
||
int oldBkMode = SetBkMode(m_hFullDC, TRANSPARENT);
|
||
COLORREF oldTextClr = SetTextColor(m_hFullDC, RGB(255, 255, 255));
|
||
RECT rcText = { bannerX + padding, bannerY + padding,
|
||
bannerX + bannerW - padding, bannerY + bannerH - padding };
|
||
DrawText(m_hFullDC, tipText, -1, &rcText, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
|
||
SetBkMode(m_hFullDC, oldBkMode);
|
||
SetTextColor(m_hFullDC, oldTextClr);
|
||
SelectObject(m_hFullDC, hOldFont);
|
||
} else if (!m_strSaveNotice.empty()) {
|
||
m_strSaveNotice.clear();
|
||
}
|
||
}
|
||
|
||
BOOL CScreenSpyDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
|
||
{
|
||
// 查看模式(未开启远程控制):客户区显示禁止图标;标题栏及系统按钮保持正常箭头,
|
||
// 便于拖动窗口或通过标题栏右键菜单开启远程控制。
|
||
// 这里按窗口自身状态判断,避免用窗口类光标(GCLP_HCURSOR)时被同类的其他对话框实例
|
||
// 共享串扰——打开第二个未控制的对话框后,第一个已控制的对话框也被误显示成禁止图标。
|
||
if (!m_bIsCtrl && nHitTest == HTCLIENT) {
|
||
::SetCursor(LoadCursor(NULL, IDC_NO));
|
||
return TRUE;
|
||
}
|
||
if (!m_bIsCtrl &&
|
||
(nHitTest == HTCAPTION || nHitTest == HTSYSMENU || nHitTest == HTMENU ||
|
||
nHitTest == HTCLOSE || nHitTest == HTMINBUTTON || nHitTest == HTMAXBUTTON ||
|
||
nHitTest == HTHELP)) {
|
||
::SetCursor(LoadCursor(NULL, IDC_ARROW));
|
||
return TRUE;
|
||
}
|
||
// 控制模式:保持原有逻辑——显示远程光标时客户区隐藏本地物理光标,否则交父类显示远程形状
|
||
if (m_bIsCtrl && m_Settings.RemoteCursor && nHitTest == HTCLIENT) {
|
||
::SetCursor(NULL); // 只要在客户区,始终隐藏系统光标
|
||
return TRUE; // 告诉 Windows 我们处理过了
|
||
}
|
||
return __super::OnSetCursor(pWnd, nHitTest, message);
|
||
}
|
||
|
||
VOID CScreenSpyDlg::DrawTipString(CString strString, int fillMode)
|
||
{
|
||
// fillMode: 0=不填充, 1=全黑, 2=半透明
|
||
RECT Rect;
|
||
GetClientRect(&Rect);
|
||
int width = Rect.right - Rect.left;
|
||
int height = Rect.bottom - Rect.top;
|
||
|
||
if (fillMode == 1) {
|
||
// 原来的全黑效果
|
||
COLORREF BackgroundColor = RGB(0x00, 0x00, 0x00);
|
||
SetBkColor(m_hFullDC, BackgroundColor);
|
||
ExtTextOut(m_hFullDC, 0, 0, ETO_OPAQUE, &Rect, NULL, 0, NULL);
|
||
} else if (fillMode == 2) {
|
||
// 半透明效果
|
||
HDC hMemDC = CreateCompatibleDC(m_hFullDC);
|
||
HBITMAP hBitmap = CreateCompatibleBitmap(m_hFullDC, width, height);
|
||
HBITMAP hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap);
|
||
|
||
HBRUSH hBrush = CreateSolidBrush(RGB(0, 0, 0));
|
||
FillRect(hMemDC, &Rect, hBrush);
|
||
DeleteObject(hBrush);
|
||
|
||
BLENDFUNCTION blend = { 0 };
|
||
blend.BlendOp = AC_SRC_OVER;
|
||
blend.SourceConstantAlpha = 150;
|
||
blend.AlphaFormat = 0;
|
||
|
||
AlphaBlend(m_hFullDC, 0, 0, width, height,
|
||
hMemDC, 0, 0, width, height, blend);
|
||
|
||
SelectObject(hMemDC, hOldBitmap);
|
||
DeleteObject(hBitmap);
|
||
DeleteDC(hMemDC);
|
||
}
|
||
|
||
SetBkMode(m_hFullDC, TRANSPARENT);
|
||
SetTextColor(m_hFullDC, RGB(0xff, 0x00, 0x00));
|
||
DrawText(m_hFullDC, strString, -1, &Rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
|
||
}
|
||
|
||
bool DirectoryExists(const char* path)
|
||
{
|
||
DWORD attr = GetFileAttributesA(path);
|
||
return (attr != INVALID_FILE_ATTRIBUTES &&
|
||
(attr & FILE_ATTRIBUTE_DIRECTORY));
|
||
}
|
||
|
||
std::string GetScreenShotPath(CWnd *parent, const CString& ip, const CString &filter, const CString& suffix)
|
||
{
|
||
std::string path;
|
||
std::string folder = THIS_CFG.GetStr("settings", "ScreenShot", "");
|
||
if (folder.empty() || !DirectoryExists(folder.c_str())) {
|
||
CString strFileName = ip + CTime::GetCurrentTime().FormatL(_T("_%Y%m%d%H%M%S.")) + suffix;
|
||
CFileDialog dlg(FALSE, suffix, strFileName, OFN_OVERWRITEPROMPT, filter, parent);
|
||
if (dlg.DoModal() != IDOK)
|
||
return "";
|
||
folder = dlg.GetFolderPath();
|
||
if (!folder.empty() && folder.back() != '\\') {
|
||
folder += '\\';
|
||
}
|
||
path = dlg.GetPathName();
|
||
THIS_CFG.SetStr("settings", "ScreenShot", folder);
|
||
} else {
|
||
if (!folder.empty() && folder.back() != '\\') {
|
||
folder += '\\';
|
||
}
|
||
path = folder + std::string(ip) + "_" + ToPekingDateTime(0) + "." + std::string(suffix);
|
||
}
|
||
return path;
|
||
}
|
||
|
||
void CScreenSpyDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
||
{
|
||
// TODO: 在此添加消息处理程序代码和/或调用默认值
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
|
||
switch (nID) {
|
||
case IDM_CONTROL: {
|
||
m_bIsCtrl = !m_bIsCtrl;
|
||
m_bIsTraceCursor = !m_bIsCtrl;
|
||
// 进入控制模式时重置放大状态
|
||
if (m_bIsCtrl && m_bZoomedIn) {
|
||
ResetZoom();
|
||
}
|
||
SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
// 控制模式:禁用本地 IME;查看模式:启用本地 IME
|
||
ImmAssociateContext(m_hWnd, m_bIsCtrl ? NULL : m_hOldIMC);
|
||
break;
|
||
}
|
||
case IDM_FULLSCREEN: { // 全屏
|
||
EnterFullScreen();
|
||
SysMenu->CheckMenuItem(IDM_FULLSCREEN, MF_CHECKED); //菜单样式
|
||
BYTE cmd[4] = { CMD_FULL_SCREEN, m_Settings.FullScreen = TRUE };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
break;
|
||
}
|
||
case IDM_REMOTE_CURSOR: {
|
||
BYTE cmd[4] = { CMD_REMOTE_CURSOR, m_Settings.RemoteCursor = !m_Settings.RemoteCursor };
|
||
SysMenu->CheckMenuItem(IDM_REMOTE_CURSOR, m_Settings.RemoteCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
break;
|
||
}
|
||
case IDM_MOUSE_CALIB: { // 鼠标坐标校准(逐主机,默认 1.0)
|
||
ShowMouseCalibration();
|
||
break;
|
||
}
|
||
case IDM_TUNING_X264_VBV:
|
||
case IDM_TUNING_GDI_SLEEP:
|
||
case IDM_TUNING_PACE_FPS_FLOOR: {
|
||
if (nID == IDM_TUNING_X264_VBV) m_bTuningX264Vbv = !m_bTuningX264Vbv;
|
||
else if (nID == IDM_TUNING_GDI_SLEEP) m_bTuningGdiNoSleep = !m_bTuningGdiNoSleep;
|
||
else m_bTuningPaceFpsFloor = !m_bTuningPaceFpsFloor;
|
||
SaveScreenTuning();
|
||
SyncTuningMenuChecks();
|
||
// 客户端按新标志即时生效:影响编码器参数的那一项会重建编码器(丢一个 IDR,
|
||
// 画面闪一下),其余两项由抓屏/发送线程下次现读,不必重开会话。
|
||
SendScreenTuning();
|
||
break;
|
||
}
|
||
case IDM_TUNING_ADAPTIVE_LOAD: { // 服务端判据立即生效;同时下发让客户端存进本机配置
|
||
m_bTuningAdaptiveDual = !m_bTuningAdaptiveDual;
|
||
SaveScreenTuning();
|
||
SyncTuningMenuChecks();
|
||
SendScreenTuning();
|
||
break;
|
||
}
|
||
case IDM_SAVEDIB: { // 快照保存
|
||
SaveSnapshot();
|
||
break;
|
||
}
|
||
case IDM_SAVEAVI:
|
||
case IDM_SAVEAVI_H264: {
|
||
if (SysMenu->GetMenuState(nID, MF_BYCOMMAND) & MF_CHECKED) {
|
||
KillTimer(TIMER_ID);
|
||
SysMenu->CheckMenuItem(nID, MF_UNCHECKED);
|
||
SysMenu->EnableMenuItem(IDM_SAVEAVI, MF_ENABLED);
|
||
SysMenu->EnableMenuItem(IDM_SAVEAVI_H264, MF_ENABLED);
|
||
m_aviFile = "";
|
||
m_aviStream.Close();
|
||
return;
|
||
}
|
||
m_aviFile = GetScreenShotPath(this, m_IPAddress, "Video(*.avi)|*.avi|", "avi").c_str();
|
||
const int duration = 250, rate = 1000 / duration;
|
||
FCCHandler handler = nID == IDM_SAVEAVI ? ENCODER_MJPEG : ENCODER_H264;
|
||
int code;
|
||
if (code = m_aviStream.Open(m_aviFile, m_BitmapInfor_Full, rate, handler)) {
|
||
DeleteFile(m_aviFile); // 删除 AVIFileOpen 残留的 0 字节文件
|
||
MessageBoxL(CString("Create Video(*.avi) Failed:\n") + m_aviFile + "\r\n" + _TR("错误代码: ") +
|
||
CBmpToAvi::GetErrMsg(code).c_str(), "提示", MB_ICONINFORMATION);
|
||
m_aviFile = _T("");
|
||
} else {
|
||
::SetTimer(m_hWnd, TIMER_ID, duration, NULL);
|
||
SysMenu->CheckMenuItem(nID, MF_CHECKED);
|
||
SysMenu->EnableMenuItem(nID == IDM_SAVEAVI ? IDM_SAVEAVI_H264 : IDM_SAVEAVI, MF_DISABLED);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case IDM_SWITCHSCREEN: {
|
||
BYTE bToken[2] = { COMMAND_SWITCH_SCREEN };
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
break;
|
||
}
|
||
|
||
case IDM_MULTITHREAD_COMPRESS: {
|
||
int threadNum = m_Settings.CompressThread;
|
||
threadNum = 4 - threadNum;
|
||
BYTE bToken[2] = { CMD_MULTITHREAD_COMPRESS, (BYTE)threadNum };
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
SysMenu->CheckMenuItem(nID, threadNum ? MF_CHECKED : MF_UNCHECKED);
|
||
m_Settings.CompressThread = threadNum;
|
||
break;
|
||
}
|
||
|
||
case IDM_ORIGINAL_SIZE: {
|
||
const int strategy = 1;
|
||
BYTE cmd[16] = { CMD_SCREEN_SIZE, (BYTE)strategy };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
m_Settings.ScreenStrategy = strategy;
|
||
SysMenu->CheckMenuItem(IDM_ORIGINAL_SIZE, MF_CHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCREEN_1080P, MF_UNCHECKED);
|
||
break;
|
||
}
|
||
|
||
case IDM_SCREEN_1080P: {
|
||
const int strategy = 0;
|
||
BYTE cmd[16] = { CMD_SCREEN_SIZE, (BYTE)strategy };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
m_Settings.ScreenStrategy = strategy;
|
||
SysMenu->CheckMenuItem(IDM_SCREEN_1080P, MF_CHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ORIGINAL_SIZE, MF_UNCHECKED);
|
||
break;
|
||
}
|
||
|
||
case IDM_ENABLE_SSE2: {
|
||
BYTE cmd[4] = { CMD_INSTRUCTION_SET, m_Settings.CpuSpeedup = !m_Settings.CpuSpeedup };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_SSE2, m_Settings.CpuSpeedup == 1 ? MF_CHECKED : MF_UNCHECKED);
|
||
break;
|
||
}
|
||
case IDM_FAST_STRETCH: {
|
||
bool bFast = !GetFastStretchMode();
|
||
SetFastStretchMode(bFast);
|
||
SysMenu->CheckMenuItem(IDM_FAST_STRETCH, bFast ? MF_CHECKED : MF_UNCHECKED);
|
||
// 更新当前窗口的 StretchBltMode
|
||
SetStretchBltMode(m_hFullDC, bFast ? COLORONCOLOR : HALFTONE);
|
||
if (!bFast) SetBrushOrgEx(m_hFullDC, 0, 0, NULL);
|
||
break;
|
||
}
|
||
case IDM_CUSTOM_CURSOR: {
|
||
m_Settings.CustomCursor = m_Settings.CustomCursor ? FALSE : TRUE;
|
||
SysMenu->CheckMenuItem(IDM_CUSTOM_CURSOR, m_Settings.CustomCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
// 如果当前是自定义光标,立即更新显示
|
||
if (m_bCursorIndex == 254 && m_bIsCtrl) {
|
||
HCURSOR cursor = (m_Settings.CustomCursor && m_hCustomCursor) ? m_hCustomCursor : LoadCursor(NULL, IDC_ARROW);
|
||
if (m_Settings.RemoteCursor) {
|
||
Invalidate(FALSE);
|
||
} else {
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)cursor);
|
||
}
|
||
}
|
||
BYTE cmd[4] = { CMD_CUSTOM_CURSOR, m_Settings.CustomCursor };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
break;
|
||
}
|
||
|
||
case IDM_FPS_10:
|
||
case IDM_FPS_15:
|
||
case IDM_FPS_20:
|
||
case IDM_FPS_25:
|
||
case IDM_FPS_30:
|
||
case IDM_FPS_UNLIMITED: {
|
||
int fps = 10 + (nID - IDM_FPS_10) * 5;
|
||
BYTE bToken[2] = { CMD_FPS, nID == IDM_FPS_UNLIMITED ? 255 : fps };
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
m_Settings.MaxFPS = nID == IDM_FPS_UNLIMITED ? 255 : fps;
|
||
for (int i = IDM_FPS_10; i <= IDM_FPS_UNLIMITED; i++) {
|
||
SysMenu->CheckMenuItem(i, MF_UNCHECKED);
|
||
}
|
||
SysMenu->CheckMenuItem(nID, MF_CHECKED);
|
||
break;
|
||
}
|
||
|
||
case IDM_SCROLL_DETECT_OFF:
|
||
case IDM_SCROLL_DETECT_2:
|
||
case IDM_SCROLL_DETECT_4:
|
||
case IDM_SCROLL_DETECT_8: {
|
||
// 菜单ID到间隔值的映射
|
||
int interval = nID == IDM_SCROLL_DETECT_OFF ? 0 :
|
||
nID == IDM_SCROLL_DETECT_2 ? 2 :
|
||
nID == IDM_SCROLL_DETECT_4 ? 4 : 8;
|
||
m_Settings.ScrollDetectInterval = interval;
|
||
// 更新菜单选中状态
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_OFF, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_2, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_4, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_SCROLL_DETECT_8, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(nID, MF_CHECKED);
|
||
// 实时通知客户端更新间隔
|
||
BYTE cmd[8] = { CMD_SCROLL_INTERVAL };
|
||
memcpy(cmd + 1, &interval, sizeof(int));
|
||
m_ContextObject->Send2Client(cmd, 1 + sizeof(int));
|
||
break;
|
||
}
|
||
|
||
case IDM_QUALITY_OFF: { // 关闭质量控制
|
||
m_AdaptiveQuality.enabled = false;
|
||
m_Settings.QualityLevel = QUALITY_DISABLED;
|
||
UpdateQualityMenuCheck(SysMenu);
|
||
// 发送给客户端保存 (QualityLevel=-2 表示关闭)
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)QUALITY_DISABLED, 1 }; // persist=1
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
UpdateWindowTitle();
|
||
Mprintf("关闭质量控制,使用原有算法设置\n");
|
||
break;
|
||
}
|
||
|
||
case IDM_ADAPTIVE_QUALITY: { // 自适应质量开关
|
||
m_AdaptiveQuality.enabled = true;
|
||
m_Settings.QualityLevel = QUALITY_ADAPTIVE;
|
||
UpdateQualityMenuCheck(SysMenu);
|
||
// 发送给客户端保存 (QualityLevel=-1 表示自适应)
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)QUALITY_ADAPTIVE, 1 }; // persist=1
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
// 启用时立即评估一次
|
||
EvaluateQuality();
|
||
UpdateWindowTitle();
|
||
break;
|
||
}
|
||
|
||
case IDM_QUALITY_ULTRA:
|
||
case IDM_QUALITY_HIGH:
|
||
case IDM_QUALITY_GOOD:
|
||
case IDM_QUALITY_MEDIUM:
|
||
case IDM_QUALITY_LOW:
|
||
case IDM_QUALITY_MINIMAL: {
|
||
// 手动设置质量等级
|
||
int level = nID - IDM_QUALITY_ULTRA;
|
||
// 关闭自适应模式
|
||
m_AdaptiveQuality.enabled = false;
|
||
m_Settings.QualityLevel = level;
|
||
// 应用选择的等级 (persist=true 保存到客户端)
|
||
ApplyQualityLevel(level, true);
|
||
UpdateQualityMenuCheck(SysMenu);
|
||
UpdateWindowTitle();
|
||
Mprintf("手动设置质量: %s\n", GetQualityName(level));
|
||
break;
|
||
}
|
||
|
||
case IDM_TRACE_CURSOR: { // 跟踪被控端鼠标
|
||
m_bIsTraceCursor = !m_bIsTraceCursor;
|
||
SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
// 不再强制切换自适应模式,两种模式都支持跟踪光标
|
||
// 重绘消除或显示鼠标
|
||
Invalidate(FALSE);
|
||
break;
|
||
}
|
||
case IDM_BLOCK_INPUT: { // 锁定服务端鼠标和键盘
|
||
BOOL bIsChecked = SysMenu->GetMenuState(IDM_BLOCK_INPUT, MF_BYCOMMAND) & MF_CHECKED;
|
||
SysMenu->CheckMenuItem(IDM_BLOCK_INPUT, bIsChecked ? MF_UNCHECKED : MF_CHECKED);
|
||
|
||
BYTE bToken[2];
|
||
bToken[0] = COMMAND_SCREEN_BLOCK_INPUT;
|
||
bToken[1] = !bIsChecked;
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
|
||
// 同步工具栏按钮状态
|
||
if (m_pToolbar) {
|
||
m_pToolbar->m_bBlockInput = !bIsChecked;
|
||
m_pToolbar->UpdateButtonIcons();
|
||
}
|
||
break;
|
||
}
|
||
case IDM_RESTORE_CONSOLE: { // RDP会话归位
|
||
BYTE bToken = CMD_RESTORE_CONSOLE;
|
||
m_ContextObject->Send2Client(&bToken, 1);
|
||
break;
|
||
}
|
||
case IDM_RESET_VIRTUAL_DESKTOP: { // 重置虚拟桌面
|
||
BYTE bToken = CMD_RESET_VIRTUAL_DESKTOP;
|
||
m_ContextObject->Send2Client(&bToken, 1);
|
||
break;
|
||
}
|
||
case IDM_GET_CLIPBOARD: { //想要Client的剪贴板内容
|
||
BYTE bToken = COMMAND_SCREEN_GET_CLIPBOARD;
|
||
m_ContextObject->Send2Client(&bToken, sizeof(bToken));
|
||
break;
|
||
}
|
||
case IDM_SET_CLIPBOARD: { //给他
|
||
SendServerClipboard();
|
||
break;
|
||
}
|
||
case IDM_ADAPTIVE_SIZE: {
|
||
m_bAdaptiveSize = !m_bAdaptiveSize;
|
||
if (!m_bAdaptiveSize && m_BitmapInfor_Full) {
|
||
SetScrollRange(SB_HORZ, 0, m_BitmapInfor_Full->bmiHeader.biWidth);
|
||
SetScrollRange(SB_VERT, 0, m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
}
|
||
ShowScrollBar(SB_BOTH, !m_bAdaptiveSize);
|
||
SysMenu->CheckMenuItem(IDM_ADAPTIVE_SIZE, m_bAdaptiveSize ? MF_CHECKED : MF_UNCHECKED);
|
||
Invalidate(FALSE); // 立即重绘,清除旧模式的残留画面
|
||
break;
|
||
}
|
||
case IDM_AUDIO_TOGGLE: {
|
||
m_Settings.AudioEnabled = !m_Settings.AudioEnabled;
|
||
SendAudioCtrl(m_Settings.AudioEnabled ? CYCLEAUDIO_ENABLE : CYCLEAUDIO_DISABLE, 1);
|
||
SysMenu->CheckMenuItem(IDM_AUDIO_TOGGLE, m_Settings.AudioEnabled ? MF_CHECKED : MF_UNCHECKED);
|
||
if (!m_Settings.AudioEnabled) {
|
||
StopAudioPlayback();
|
||
}
|
||
break;
|
||
}
|
||
case IDM_ENABLE_H264_HARD: {
|
||
m_Settings.EncodeLevel = m_Settings.EncodeLevel ? LEVEL_H264_SOFT : LEVEL_H264_HARD;
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_GRAYED : MF_ENABLED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_GRAYED : MF_ENABLED);
|
||
BYTE bToken[] = {COMMAND_ENCODE_LEVEL, m_Settings.EncodeLevel };
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
break;
|
||
}
|
||
case IDM_ENABLE_AV1_HARD: {
|
||
m_Settings.EncodeLevel = m_Settings.EncodeLevel ? LEVEL_H264_SOFT : LEVEL_AV1_HARD;
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_H264_HARD, m_Settings.EncodeLevel == LEVEL_AV1_HARD ? MF_GRAYED : MF_ENABLED);
|
||
SysMenu->EnableMenuItem(IDM_ENABLE_AV1_HARD, m_Settings.EncodeLevel == LEVEL_H264_HARD ? MF_GRAYED : MF_ENABLED);
|
||
BYTE bToken[] = { COMMAND_ENCODE_LEVEL, m_Settings.EncodeLevel };
|
||
m_ContextObject->Send2Client(bToken, sizeof(bToken));
|
||
break;
|
||
}
|
||
}
|
||
|
||
__super::OnSysCommand(nID, lParam);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnTimer(UINT_PTR nIDEvent)
|
||
{
|
||
if (!m_aviFile.IsEmpty()) {
|
||
LPCTSTR lpTipsString = _T("●");
|
||
|
||
m_aviStream.Write((BYTE*)m_BitmapData_Full);
|
||
|
||
// 提示正在录像
|
||
SetTextColor(m_hFullDC, RGB(0xff, 0x00, 0x00));
|
||
TextOut(m_hFullDC, 0, 0, lpTipsString, lstrlen(lpTipsString));
|
||
}
|
||
if (nIDEvent == 1 && m_Settings.FullScreen && m_pToolbar) {
|
||
m_pToolbar->CheckMousePosition();
|
||
}
|
||
if (nIDEvent == 2) {
|
||
KillTimer(2);
|
||
if (m_bConnected) {
|
||
return;
|
||
}
|
||
CWnd* pMain = AfxGetMainWnd();
|
||
if (pMain)
|
||
::PostMessageA(pMain->GetSafeHwnd(), WM_SHOWNOTIFY, (WPARAM)new CharMsg(_TR("连接已断开")),
|
||
(LPARAM)new CharMsg(m_IPAddress + _TR(" - 远程桌面连接已断开")));
|
||
this->PostMessageA(WM_CLOSE, 0, 0);
|
||
return;
|
||
}
|
||
if (nIDEvent == 3) {
|
||
KillTimer(3);
|
||
PostMessageA(WM_PAINT);
|
||
}
|
||
if (nIDEvent == 4) {
|
||
// 分辨率切换超时兜底与本地解码解耦,Web 隐藏会话也能触发。
|
||
CheckResolutionChangeTimeout();
|
||
// 计算传输速率并更新标题
|
||
m_dTransferRate = m_ulBytesThisSecond / 1024.0; // KB/s
|
||
m_ulBytesThisSecond = 0;
|
||
// 屏幕数据速率单独留存给吞吐判据:上面那个总量混了文件传输/音频/剪贴板,
|
||
// 传大文件时会让判据误判"链路塞满"。
|
||
m_dScreenKBps = m_ulScreenBytesThisSecond / 1024.0;
|
||
// 慢流量窗口:这一秒的原始样本进环形缓冲,供 CollectLoadSample 取均值。
|
||
// 采样断档(服务端休眠/线程被挂起)时窗口里的样本已经和现在无关,直接清空:
|
||
// 不清的话恢复后前 10 秒还在用旧现场判定降档。
|
||
{
|
||
ULONGLONG sampleNow = GetTickCount64();
|
||
// 这一格覆盖的是「上次采样到现在」这段时间,不是整一秒:WM_TIMER 会被
|
||
// UI 线程里的阻塞(录像、慢绘制、对话框)推迟,按一格算一秒会把帧率和
|
||
// 吞吐整体高估。把实际毫秒数一起存下来,窗口的分母用它。
|
||
ULONGLONG gap = (m_AdaptiveQuality.loadWindowLastTick == 0)
|
||
? 1000 : (sampleNow - m_AdaptiveQuality.loadWindowLastTick);
|
||
m_AdaptiveQuality.loadWindowLastTick = sampleNow;
|
||
if (gap > 3000) {
|
||
// 采样断档(服务端休眠/线程被挂起):窗口里的样本已经和现在无关,
|
||
// 这一格累计的计数同样跨越了断档,一并丢弃,从下一格重新开始。
|
||
memset(m_AdaptiveQuality.loadWindowFrames, 0, sizeof(m_AdaptiveQuality.loadWindowFrames));
|
||
memset(m_AdaptiveQuality.loadWindowBytes, 0, sizeof(m_AdaptiveQuality.loadWindowBytes));
|
||
memset(m_AdaptiveQuality.loadWindowMs, 0, sizeof(m_AdaptiveQuality.loadWindowMs));
|
||
m_AdaptiveQuality.loadWindowPos = 0;
|
||
m_AdaptiveQuality.loadWindowFilled = 0;
|
||
m_AdaptiveQuality.lastLoadSampleMs = 0; // 这一秒的样本也不可信
|
||
} else {
|
||
m_AdaptiveQuality.lastLoadSampleMs = (ULONG)gap;
|
||
const int pos = m_AdaptiveQuality.loadWindowPos;
|
||
m_AdaptiveQuality.loadWindowFrames[pos] = m_ulFramesThisSecond;
|
||
m_AdaptiveQuality.loadWindowBytes[pos] = m_ulScreenBytesThisSecond;
|
||
m_AdaptiveQuality.loadWindowMs[pos] = (ULONG)gap;
|
||
if (++m_AdaptiveQuality.loadWindowPos >= m_AdaptiveQuality.LOAD_WINDOW_SECONDS)
|
||
m_AdaptiveQuality.loadWindowPos = 0;
|
||
if (m_AdaptiveQuality.loadWindowFilled < m_AdaptiveQuality.LOAD_WINDOW_SECONDS)
|
||
m_AdaptiveQuality.loadWindowFilled++;
|
||
}
|
||
}
|
||
m_ulScreenBytesThisSecond = 0;
|
||
// 使用EMA平滑帧率 (alpha=0.3),避免跳跃
|
||
double currentFPS = (double)m_ulFramesThisSecond;
|
||
m_ulFramesLastSecond = m_ulFramesThisSecond; // 原始值给吞吐判据,EMA 对判据太迟钝
|
||
if (m_dFrameRate == 0) {
|
||
m_dFrameRate = currentFPS; // 首次直接赋值
|
||
} else {
|
||
m_dFrameRate = 0.3 * currentFPS + 0.7 * m_dFrameRate;
|
||
}
|
||
m_ulFramesThisSecond = 0;
|
||
// 自适应质量评估
|
||
EvaluateQuality();
|
||
UpdateWindowTitle();
|
||
|
||
// 更新全屏状态信息窗口
|
||
if (m_pStatusInfoWnd && m_pStatusInfoWnd->IsVisible()) {
|
||
CString qualityName = m_Settings.QualityLevel == QUALITY_DISABLED ? _T("Off") :
|
||
GetQualityDisplayName();
|
||
m_pStatusInfoWnd->UpdateInfo(m_dFrameRate, m_dTransferRate, qualityName);
|
||
}
|
||
}
|
||
__super::OnTimer(nIDEvent);
|
||
}
|
||
|
||
CString CScreenSpyDlg::GetTitleHostName() const
|
||
{
|
||
// 标题栏显示的主机名:有备注用备注,否则用 IP
|
||
if (m_pParent && m_pParent->m_ClientMap) {
|
||
CString note = m_pParent->m_ClientMap->GetClientMapData(GetClientID(), MAP_NOTE);
|
||
if (!note.IsEmpty())
|
||
return note;
|
||
}
|
||
return m_IPAddress;
|
||
}
|
||
|
||
void CScreenSpyDlg::UpdateWindowTitle()
|
||
{
|
||
if (!m_BitmapInfor_Full) return;
|
||
|
||
int width = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int height = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
|
||
// 构建质量名称:关闭显示 "Off",自适应和手动都会显示 "当前等级"
|
||
CString qualityName = m_Settings.QualityLevel == QUALITY_DISABLED ? "" :
|
||
CString(" | ") + GetQualityDisplayName();
|
||
|
||
CString strTitle;
|
||
UINT fps = (UINT)(m_dFrameRate + 0.5); // 四舍五入显示
|
||
if (m_dTransferRate >= 1024) {
|
||
strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.1f MB/s%s",
|
||
GetTitleHostName().GetString(), width, height, fps, m_dTransferRate / 1024, qualityName.GetString());
|
||
} else {
|
||
strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.0f KB/s%s",
|
||
GetTitleHostName().GetString(), width, height, fps, m_dTransferRate, qualityName.GetString());
|
||
}
|
||
// 追加剪贴板操作提示
|
||
strTitle += (m_Settings.ScreenType == 2) ?
|
||
_TR(" [远程右键复制, 本地 Ctrl+V 粘贴]") : _TR(" [远程 Ctrl+C 复制, 本地 Ctrl+V 粘贴]");
|
||
SetWindowText(strTitle);
|
||
}
|
||
|
||
const char* CScreenSpyDlg::GetQualityName(int level)
|
||
{
|
||
static const char* names[] = {
|
||
"Ultra", "High", "Good", "Medium", "Low", "Minimal"
|
||
};
|
||
if (level == QUALITY_DISABLED)
|
||
return "Off";
|
||
if (level == QUALITY_ADAPTIVE)
|
||
return "Auto";
|
||
if (level >= 0 && level < QUALITY_COUNT)
|
||
return names[level];
|
||
return "Unknown";
|
||
}
|
||
|
||
// 记下"为什么切档"。只影响界面显示,不参与任何判据 —— 判据仍然只看 RTT / 吞吐。
|
||
// 20 秒后自动失效:档位稳定在低档时用户更需要知道"链路一直差",而不是一直挂着
|
||
// 一个已经过时的原因。手动选档时由 ApplyQualityLevel(persist=true) 清空。
|
||
void CScreenSpyDlg::SetQualityChangeReason(LPCTSTR key)
|
||
{
|
||
m_AdaptiveQuality.reason = _L(key);
|
||
m_AdaptiveQuality.reasonUntil = GetTickCount64() + 20000;
|
||
}
|
||
|
||
CString CScreenSpyDlg::GetQualityDisplayName()
|
||
{
|
||
CString name = GetQualityName(m_AdaptiveQuality.currentLevel);
|
||
if (!m_AdaptiveQuality.reason.IsEmpty() &&
|
||
GetTickCount64() < m_AdaptiveQuality.reasonUntil) {
|
||
name += _T(" (");
|
||
name += m_AdaptiveQuality.reason;
|
||
name += _T(")");
|
||
}
|
||
return name;
|
||
}
|
||
|
||
void CScreenSpyDlg::UpdateQualityMenuCheck(CMenu* SysMenu)
|
||
{
|
||
if (!SysMenu) SysMenu = GetSystemMenu(FALSE);
|
||
// 先全部取消勾选
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_OFF, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ADAPTIVE_QUALITY, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_ULTRA, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_HIGH, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_GOOD, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_MEDIUM, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_LOW, MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_MINIMAL, MF_UNCHECKED);
|
||
// 勾选当前项
|
||
if (m_Settings.QualityLevel == QUALITY_DISABLED) {
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_OFF, MF_CHECKED);
|
||
} else if (m_AdaptiveQuality.enabled) {
|
||
SysMenu->CheckMenuItem(IDM_ADAPTIVE_QUALITY, MF_CHECKED);
|
||
} else if (m_AdaptiveQuality.currentLevel >= 0 && m_AdaptiveQuality.currentLevel < QUALITY_COUNT) {
|
||
SysMenu->CheckMenuItem(IDM_QUALITY_ULTRA + m_AdaptiveQuality.currentLevel, MF_CHECKED);
|
||
}
|
||
}
|
||
|
||
int CScreenSpyDlg::GetClientRTT()
|
||
{
|
||
if (!m_pParent || !m_ClientID) return 0;
|
||
|
||
// 遍历列表查找对应的 ClientID
|
||
auto ctx = m_pParent->FindHost(m_ClientID);
|
||
if (ctx) {
|
||
auto pingStr = ctx->GetClientData(ONLINELIST_PING);
|
||
return _ttoi(pingStr);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 采一份吞吐判据的输入样本:窗口均值优先,窗口不足以证明拥塞时退回 1 秒样本。
|
||
//
|
||
// 两处判据(吞吐降档、降档后的本机瓶颈探测)必须用同一份样本。原来两处各采各的,
|
||
// 在「一帧要两秒」的现场会交替给出相反结论 —— 0 帧秒走窗口说拥塞、收全帧的那一秒
|
||
// 走 1 秒计数又算出 4Mbps「没事」,确认计数被反复清零,三拍永远凑不齐。
|
||
//(1 秒样本在大帧现场还会高估吞吐:一帧实际传了 2 秒,它只算收全那一秒的字节。)
|
||
CScreenSpyDlg::LoadSample CScreenSpyDlg::CollectLoadSample()
|
||
{
|
||
LoadSample s;
|
||
|
||
int sampleBaseline = (int)(m_AdaptiveQuality.baselineFps + 0.5);
|
||
// 帧龄用 32 位无符号差值算,跨 GetTickCount 回绕(49.7 天)仍是对的;
|
||
// 字段本身是 DWORD,避免 x86 上 64 位读被撕裂(见 ScreenSpyDlg.h)。
|
||
int lastFrameAge = (m_AdaptiveQuality.lastFrameTick == 0)
|
||
? -1 : (int)((DWORD)(GetTickCount() - m_AdaptiveQuality.lastFrameTick) / 1000);
|
||
|
||
// 每帧字节下限只对没有码率控制的档位生效,理由见 GetCongestedLoadSample;
|
||
// 窗口路径和 1 秒样本共用同一道门槛。
|
||
const int minFrameBytes =
|
||
(GetQualityProfile(m_AdaptiveQuality.currentLevel).bitRate == 0) ? 64 * 1024 : 0;
|
||
|
||
const int n = m_AdaptiveQuality.loadWindowFilled;
|
||
if (n > 0) {
|
||
unsigned long long winFrames = 0, winBytes = 0, winMs = 0;
|
||
unsigned int busiest = 0;
|
||
int activeSeconds = 0;
|
||
for (int i = 0; i < n; i++) {
|
||
const ULONG f = m_AdaptiveQuality.loadWindowFrames[i];
|
||
winFrames += f;
|
||
winBytes += m_AdaptiveQuality.loadWindowBytes[i];
|
||
winMs += m_AdaptiveQuality.loadWindowMs[i];
|
||
if (f > busiest) busiest = f;
|
||
if (f > 0) activeSeconds++;
|
||
}
|
||
// 分母用实际经过的毫秒数,不是格子数:WM_TIMER 被 UI 阻塞推迟时,
|
||
// 一格代表两秒多的流量,按一格一秒算会把速率高估。
|
||
int seconds = (int)((winMs + 500) / 1000);
|
||
if (seconds < 1) seconds = 1;
|
||
int fps = 0, baseline = 0, kbps = 0;
|
||
if (GetCongestedLoadSample(winFrames, winBytes, activeSeconds, busiest, seconds, lastFrameAge,
|
||
sampleBaseline, minFrameBytes, fps, baseline, kbps)) {
|
||
s.fps = fps;
|
||
s.baseline = baseline;
|
||
s.kbps = kbps;
|
||
s.usable = true;
|
||
s.windowed = true;
|
||
s.seconds = seconds;
|
||
s.frames = winFrames;
|
||
return s;
|
||
}
|
||
}
|
||
|
||
// 正常会话(帧够快、有满速秒)走的多是这条路:1 秒样本,对抖动更敏感。
|
||
// 帧率/基线同样放大 100 倍:判据只用两者的比值,这里统一比例是为了让日志和
|
||
// 其它消费方不必区分两种采样。
|
||
{
|
||
unsigned long long bytesLastSecond = (unsigned long long)(m_dScreenKBps * 1024.0);
|
||
if (GetSecondLoadSample(m_ulFramesLastSecond, bytesLastSecond,
|
||
m_AdaptiveQuality.lastLoadSampleMs, sampleBaseline,
|
||
minFrameBytes, s.fps, s.baseline, s.kbps)) {
|
||
s.usable = true;
|
||
}
|
||
}
|
||
return s;
|
||
}
|
||
|
||
void CScreenSpyDlg::EvaluateQuality()
|
||
{
|
||
if (!m_AdaptiveQuality.enabled) return;
|
||
|
||
ULONGLONG now = GetTickCount64();
|
||
|
||
// 0. 启动延迟兼基线学习:前 1 分钟不调整,但用这段时间实测本会话的健康帧率。
|
||
// 客户端发送循环的基线是 8fps(ScreenManager.cpp 里 sleep = 1000/8),链路好时
|
||
// 会自己按 1.03 倍加速,所以用实测峰值,而不是把客户端常量抄到服务端来。
|
||
if (now - m_AdaptiveQuality.startTime < 60000) {
|
||
if (m_dFrameRate > m_AdaptiveQuality.baselineFps)
|
||
m_AdaptiveQuality.baselineFps = m_dFrameRate;
|
||
return;
|
||
}
|
||
if (m_AdaptiveQuality.baselineFps < 1.0) {
|
||
// 学习窗口内几乎没收到帧(画面一直静止),退回发送循环的基线 8fps;
|
||
// 该档 MaxFPS 配得比 8 更低时以 MaxFPS 为准,不能把基线抬到用户上限之上。
|
||
double floorFps = 8.0;
|
||
int lvlMaxFps = GetQualityProfile(m_AdaptiveQuality.currentLevel).maxFPS;
|
||
if (lvlMaxFps > 0 && lvlMaxFps < 8) floorFps = (double)lvlMaxFps;
|
||
m_AdaptiveQuality.baselineFps = floorFps;
|
||
}
|
||
|
||
// 一次评估只采一次样本:降档判据和下面的本机瓶颈探测必须用同一份数据,
|
||
// 各采各的会在慢流量现场交替给出相反结论(见 CollectLoadSample)。
|
||
const LoadSample load = CollectLoadSample();
|
||
|
||
// 0.5 降档后观察:真带宽受限时降档同时降低分辨率和码率,管道立刻缓解、帧率必须回升;
|
||
// 本机受限(抓屏/编码慢)时降码率对帧率几乎没帮助。10 秒后帧率仍不达标、
|
||
// 且管道明显没被填满,就判定瓶颈在本机,本次会话停用吞吐判据。
|
||
// 停用后就是加这个判据之前的行为,所以误判的代价只是"这一项没生效",
|
||
// 不会把画质永久压低,也顺带掐掉"降档→抓屏变快→升档→又变慢"的慢速振荡。
|
||
if (m_AdaptiveQuality.loadProbeTime != 0 &&
|
||
now - m_AdaptiveQuality.loadProbeTime >= 10000) {
|
||
m_AdaptiveQuality.loadProbeTime = 0;
|
||
// 观察窗里必须真的拿到了样本,否则既不能证明降档奏效也不能证明没奏效:
|
||
// 此时若照常判定,"帧率低 + 帧很小"会被误读成"本机瓶颈",一次静止就永久
|
||
// 停用吞吐判据。宁可放弃这次探测。
|
||
// 用 CollectLoadSample 而不是 1 秒计数:慢流量现场每秒帧数基本都是 0,
|
||
// 拿 1 秒计数去卡门槛只会每次都弃权 —— 判据现在覆盖的场景正好是它。
|
||
if (!load.usable) {
|
||
Mprintf("[Adaptive] 降档观察窗内没有可用样本,放弃本次本机瓶颈判定\n");
|
||
} else {
|
||
// 帧率仍然不达标、但按同一套判据已经不算饱和 → 帧并不大却发不出来,
|
||
// 说明瓶颈在本机(抓屏/编码),而不是链路。这里复用同一个判据,
|
||
// 不再另写一套阈值,避免两处口径不一致;「画面静止不算证据」的门槛
|
||
// 也放在同一个 helper 里(见 IsLocalBottleneck)。
|
||
const int needKbps = GetQualityProfile(m_AdaptiveQuality.currentLevel).bitRate;
|
||
if (IsLocalBottleneck(load.fps, load.baseline, load.kbps, needKbps,
|
||
m_ulFramesLastSecond)) {
|
||
m_AdaptiveQuality.loadPinned = true;
|
||
Mprintf("[Adaptive] 降档后帧率未回升 (%.1f < %.1f) 且帧已不大 (%d/%dkbps),"
|
||
"判定瓶颈在本机,本次会话停用吞吐判据\n",
|
||
load.fps / 100.0, load.baseline * 0.6 / 100.0, load.kbps, needKbps);
|
||
}
|
||
}
|
||
}
|
||
|
||
int currentLevel = m_AdaptiveQuality.currentLevel;
|
||
const bool dual = m_bTuningAdaptiveDual;
|
||
|
||
// 0.9 锁档检查(放在所有判据之前,锁档期间一次评估都不做)。
|
||
// 上面的措施各自针对一种具体成因,这一条是不依赖成因的兜底。
|
||
if (dual) {
|
||
if (m_AdaptiveQuality.lockUntil != 0) {
|
||
if (now < m_AdaptiveQuality.lockUntil) return;
|
||
m_AdaptiveQuality.lockUntil = 0;
|
||
m_AdaptiveQuality.changeWindowStart = now;
|
||
m_AdaptiveQuality.changeCountInWindow = 0;
|
||
}
|
||
}
|
||
|
||
// 1. RTT 判据:延迟预算 → 质量上限
|
||
int rtt = GetClientRTT();
|
||
if (rtt > 0) m_AdaptiveQuality.lastRTT = rtt;
|
||
int levelRTT;
|
||
if (dual) {
|
||
// 双判据模式下沿用上次 RTT:ping 偶尔丢包、frp 隧道抖动时取不到值,
|
||
// 不能让整个评估停摆(原来直接 return,会话会一直卡在当前档位)。
|
||
// 并且改用带迟滞的版本:硬阈值在 78↔82 这种边界抖动下会让档位每秒翻一次,
|
||
// 每次都是编码器重建 + 整屏重传。迟滞把升降阈值错开 ±15%,死区内保持不动。
|
||
levelRTT = (m_AdaptiveQuality.lastRTT > 0)
|
||
? GetTargetQualityLevelHysteresis(m_AdaptiveQuality.lastRTT,
|
||
m_bUsingFRP, currentLevel)
|
||
: -1;
|
||
} else {
|
||
// 开关没开时保持原样:拿不到 RTT 就不评估。
|
||
if (rtt <= 0) return;
|
||
levelRTT = GetTargetQualityLevel(rtt, m_bUsingFRP);
|
||
}
|
||
|
||
// 2. 吞吐判据:带宽预算 → 质量下限
|
||
// 与 RTT 判据取 max() 合并。两个约束方向相反,任一都能单独压低档位,
|
||
// 加权平均会让"RTT 好"掩盖"带宽窄"(短 RTT + 窄链路是本判据唯一能抓住的场景)。
|
||
int levelLoad = -1;
|
||
if (dual && !m_AdaptiveQuality.loadPinned) {
|
||
const QualityProfile& prof = GetQualityProfile(currentLevel);
|
||
// 一次评估只采一次样本,窗口路径的可用性判定全在 CollectLoadSample 里:
|
||
// 大帧把链路堵住时 1 秒窗口是空的(整帧收全才计数),要靠 10 秒均值才表达得出
|
||
// 0.2fps;但只有「内容还在持续来、且没有任何一秒交付过满速」才算拥塞证据,
|
||
// 否则滚动一下停住、或画面本来就没变化,都会被误判成带宽不足。
|
||
if (load.usable) {
|
||
levelLoad = GetTargetQualityLevelByLoad(load.fps, load.baseline, load.kbps, prof.bitRate);
|
||
}
|
||
// 最多比 RTT 判据再压低 2 级。判据本身分不清"链路慢"和"本机慢",限幅保证
|
||
// 误判时只掉两档,不会被某一秒的抖动打到最低。
|
||
if (levelLoad >= 0) {
|
||
int cap = (levelRTT >= 0 ? levelRTT : currentLevel) + 2;
|
||
if (levelLoad > cap) levelLoad = cap;
|
||
}
|
||
// 判据每秒评估一次,而降档要等冷却和连续确认,期间每一拍都可能满足
|
||
// levelLoad > levelRTT(甚至 targetLevel 就等于 currentLevel)。慢流量现场
|
||
// 窗口采样让判据几乎每秒都可用,不限流一次会话能刷几千行;10 秒一条既够
|
||
// 追踪演进,又不至于把日志打满。限流只作用于日志,不影响计数和应用逻辑。
|
||
if (levelLoad >= 0 && levelLoad > levelRTT &&
|
||
now - m_AdaptiveQuality.lastLoadLogTime >= 10000) {
|
||
m_AdaptiveQuality.lastLoadLogTime = now;
|
||
if (load.windowed) {
|
||
Mprintf("[Adaptive] 吞吐判据: %d 秒窗口 %llu 帧(≈%.1ffps, 基线%.0f) "
|
||
"屏幕≈%dkbps 本档标称=%dkbps → level %d(RTT 判据给 %d)\n",
|
||
load.seconds, load.frames, load.fps / 100.0,
|
||
load.baseline / 100.0, load.kbps, prof.bitRate,
|
||
levelLoad, levelRTT);
|
||
} else {
|
||
Mprintf("[Adaptive] 吞吐判据: fps=%u(基线%.0f) 屏幕=%.0fKB/s(≈%dkbps) "
|
||
"本档标称=%dkbps → level %d(RTT 判据给 %d)\n",
|
||
m_ulFramesLastSecond, m_AdaptiveQuality.baselineFps,
|
||
m_dScreenKBps, load.kbps, prof.bitRate, levelLoad, levelRTT);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. 合并:取更保守者(档位数字越大越差)
|
||
int targetLevel = (levelRTT > levelLoad) ? levelRTT : levelLoad;
|
||
if (targetLevel < 0) return; // 两个判据都拿不到数据
|
||
|
||
// Web 会话只解码 H264。levels 0 (Ultra/DIFF) 和 1 (High/RGB565) 在网络好的时候
|
||
// 会被自适应控制器选中,但 device 切到那两个算法后浏览器的 WebCodecs decoder
|
||
// 就吃不下了,画面冻在最后一个 H264 帧上 (用户感受是 ~1 分钟后卡死,
|
||
// 因为 EvaluateQuality 启动 1 分钟才开始评估)。Clamp 到最高质量的 H264 等级
|
||
// 让自适应在 H264 区间内继续工作.
|
||
if (m_bIsWebSession && targetLevel < QUALITY_GOOD) {
|
||
targetLevel = QUALITY_GOOD;
|
||
}
|
||
|
||
// 3.5 升档失败封顶:升档后 40 秒内又降回升档前的档位或更差,说明那次升档是错的
|
||
// (典型是"降档→队列排空→RTT 变好→升档→队列又满→RTT 变差"的 bufferbloat 循环,
|
||
// 跨洲际 + frp 大缓冲链路最容易出现)。记下升档前的档位,3 分钟内不再尝试好于它。
|
||
// 宁可停在低一档,也不要在两个档位之间每 30 秒重建一次编码器和分辨率。
|
||
// 思路同 TCP 的 ssthresh:失败一次就把天花板降下来,而不是继续试探。
|
||
// 惩罚期取 3 分钟:够长以压住振荡,又不至于网络真恢复后一直卡在低档。
|
||
// 窗口取 40 秒而不是 20 秒:升档本身会刷新 lastResChangeTime,回到升档前的
|
||
// 档位多半要跨分辨率,得先等 15 秒冷却,再叠上吞吐判据的连续 3 拍确认,
|
||
// 20 秒经常在降档被允许之前就过期 —— 于是"升上去→卡住→降回来"每次都被
|
||
// 判成新情况,封顶永远不触发,循环一直重复。
|
||
if (dual && m_AdaptiveQuality.levelCeiling >= 0) {
|
||
if (now >= m_AdaptiveQuality.ceilingUntil) {
|
||
m_AdaptiveQuality.levelCeiling = -1; // 惩罚期结束,恢复自由升档
|
||
} else if (targetLevel < m_AdaptiveQuality.levelCeiling &&
|
||
m_AdaptiveQuality.levelCeiling <= currentLevel) {
|
||
// 只压升档方向。加 levelCeiling <= currentLevel 的守卫是为了防止状态异常时
|
||
// 反过来强制降档 —— 封顶的语义是"不许更好",不是"必须更差"。
|
||
targetLevel = m_AdaptiveQuality.levelCeiling;
|
||
}
|
||
}
|
||
|
||
if (targetLevel == currentLevel) {
|
||
m_AdaptiveQuality.stableCount = 0;
|
||
m_AdaptiveQuality.loadCount = 0;
|
||
return;
|
||
}
|
||
|
||
// 4. 检查是否涉及分辨率变化
|
||
int currentMaxWidth = GetQualityProfile(currentLevel).maxWidth;
|
||
int targetMaxWidth = GetQualityProfile(targetLevel).maxWidth;
|
||
bool resolutionChange = (currentMaxWidth != targetMaxWidth);
|
||
|
||
// 5. 冷却时间检查
|
||
// - 分辨率变化:降级15秒,升级30秒
|
||
// - 纯FPS/算法变化:3秒(双判据下放宽,见下)
|
||
ULONGLONG cooldown = 3000;
|
||
if (resolutionChange) {
|
||
cooldown = (targetLevel > currentLevel) ? 15000 : 30000;
|
||
if (now - m_AdaptiveQuality.lastResChangeTime < cooldown)
|
||
return;
|
||
} else {
|
||
if (dual) {
|
||
// 纯 FPS/算法变化的档位对里,0↔1 是 DIFF↔RGB565 —— 带宽差一个数量级
|
||
// (差分 vs 原始像素 4MB/帧)。原来 3 秒的冷却意味着 RTT 在 30ms 边界上
|
||
// 抖动时每 3 秒就能翻一次算法,用户看到的是持续花屏。双判据下放宽到
|
||
// 10 秒降 / 15 秒升:至少十次采样才动一次,抖动被彻底吸收。
|
||
cooldown = (targetLevel > currentLevel) ? 10000 : 15000;
|
||
}
|
||
if (now - m_AdaptiveQuality.lastChangeTime < cooldown)
|
||
return;
|
||
}
|
||
|
||
// 6. 降级:RTT 判据连续 2 次即降(原有行为);吞吐判据要连续 3 次,
|
||
// 因为它是 1 秒窗口的字节数,比 RTT 抖得多。
|
||
if (targetLevel > currentLevel) {
|
||
const bool byLoad = (levelLoad > levelRTT);
|
||
// 两个判据各自连续计数,互相打断。交替出现说明两个判据都卡在临界点上,
|
||
// 此时保持现状比动档位安全 —— 否则就是"RTT 说降、吞吐说没事"的来回拉扯。
|
||
if (byLoad) {
|
||
m_AdaptiveQuality.loadCount++;
|
||
m_AdaptiveQuality.stableCount = 0;
|
||
} else {
|
||
m_AdaptiveQuality.stableCount++;
|
||
m_AdaptiveQuality.loadCount = 0;
|
||
}
|
||
const int need = byLoad ? 3 : 2;
|
||
const int have = byLoad ? m_AdaptiveQuality.loadCount : m_AdaptiveQuality.stableCount;
|
||
if (have >= need) {
|
||
// 升档失败检测:上一次升档后 40 秒内就降回升档前的档位或更差
|
||
// (40 秒的由来见 3.5 节:要等过升档刷新的 15 秒分辨率冷却)
|
||
if (dual && m_AdaptiveQuality.lastUpFromLevel >= 0 &&
|
||
now - m_AdaptiveQuality.lastUpTime < 40000 &&
|
||
targetLevel >= m_AdaptiveQuality.lastUpFromLevel) {
|
||
m_AdaptiveQuality.levelCeiling = m_AdaptiveQuality.lastUpFromLevel;
|
||
m_AdaptiveQuality.ceilingUntil = now + 180000;
|
||
Mprintf("[Adaptive] 升档失败(%d → %d,%.1f 秒后回到 %d),"
|
||
"3 分钟内封顶在 level %d\n",
|
||
m_AdaptiveQuality.lastUpFromLevel,
|
||
m_AdaptiveQuality.lastUpFromLevel - 1,
|
||
(now - m_AdaptiveQuality.lastUpTime) / 1000.0,
|
||
targetLevel, m_AdaptiveQuality.levelCeiling);
|
||
}
|
||
if (dual) NoteAdaptiveChange(now);
|
||
// 原因只在这里可得:再往下就没有 byLoad / levelRTT 了
|
||
SetQualityChangeReason(byLoad ? _T("带宽不足") : _T("延迟高"));
|
||
ApplyQualityLevel(targetLevel);
|
||
if (byLoad) m_AdaptiveQuality.loadProbeTime = GetTickCount64();
|
||
}
|
||
}
|
||
// 7. 升级:谨慎处理 (连续5次,且只升一级)
|
||
// 只用 RTT 判据。吞吐判据的"有余量"不可靠(画面静止时永远显示有余量),
|
||
// 让它参与升档会变成"静止就升、一动就降"的慢速振荡,所以吞吐只做单向约束:只压不抬。
|
||
else if (targetLevel < currentLevel) {
|
||
m_AdaptiveQuality.loadCount = 0;
|
||
m_AdaptiveQuality.stableCount++;
|
||
if (m_AdaptiveQuality.stableCount >= 5) {
|
||
if (dual) {
|
||
// 记下升档前的位置,供"升档失败封顶"判断
|
||
m_AdaptiveQuality.lastUpTime = now;
|
||
m_AdaptiveQuality.lastUpFromLevel = currentLevel;
|
||
NoteAdaptiveChange(now);
|
||
}
|
||
SetQualityChangeReason(_T("链路改善"));
|
||
ApplyQualityLevel(currentLevel - 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 自适应切换的频率硬上限:5 分钟内最多 6 次,超了就锁档 5 分钟。
|
||
//
|
||
// 前面几条措施(RTT 迟滞、升档失败封顶、冷却时间、判据互相打断)各自针对一种具体成因,
|
||
// 这一条不依赖成因,纯粹按"切换次数"兜底。理由是代价不对称:每次切档都要重建编码器,
|
||
// 分辨率档还要整屏重传,用户感知的代价远大于"画质差一档"。所以宁可锁在低档,
|
||
// 也不允许出现任何没预料到的振荡模式。
|
||
void CScreenSpyDlg::NoteAdaptiveChange(ULONGLONG now)
|
||
{
|
||
if (m_AdaptiveQuality.changeWindowStart == 0 ||
|
||
now - m_AdaptiveQuality.changeWindowStart > 300000) {
|
||
m_AdaptiveQuality.changeWindowStart = now;
|
||
m_AdaptiveQuality.changeCountInWindow = 0;
|
||
}
|
||
if (++m_AdaptiveQuality.changeCountInWindow > 6) {
|
||
m_AdaptiveQuality.lockUntil = now + 300000;
|
||
Mprintf("[Adaptive] 5 分钟内已切换 %d 次,锁档 5 分钟(防止档位反复重建)\n",
|
||
m_AdaptiveQuality.changeCountInWindow);
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::ApplyQualityLevel(int level, bool persist)
|
||
{
|
||
if (level < 0 || level >= QUALITY_COUNT) return;
|
||
|
||
// Defense in depth: ALL paths that set quality level (adaptive controller,
|
||
// manual menu pick, restore from config, …) flow through here. Web
|
||
// sessions cannot use non-H264 levels — see EvaluateQuality for the
|
||
// failure mode explanation.
|
||
if (m_bIsWebSession && level < QUALITY_GOOD) {
|
||
level = QUALITY_GOOD;
|
||
}
|
||
|
||
const QualityProfile& profile = GetQualityProfile(level);
|
||
int oldMaxWidth = m_AdaptiveQuality.currentMaxWidth;
|
||
int newMaxWidth = profile.maxWidth;
|
||
|
||
Mprintf("ApplyQualityLevel: level=%d, oldMaxWidth=%d, newMaxWidth=%d, algo=%d\n",
|
||
level, oldMaxWidth, newMaxWidth, profile.algorithm);
|
||
|
||
m_AdaptiveQuality.currentLevel = level;
|
||
m_AdaptiveQuality.lastChangeTime = GetTickCount64();
|
||
m_AdaptiveQuality.stableCount = 0;
|
||
m_AdaptiveQuality.loadCount = 0; // 吞吐判据的确认计数同样清零,避免跨档位累积
|
||
// 换档前的流量属于旧档位(帧更大更慢、分辨率不同),留在窗口里会继续参与新档位
|
||
// 的判定:清空,让新档位重新积累 10 秒样本。
|
||
memset(m_AdaptiveQuality.loadWindowFrames, 0, sizeof(m_AdaptiveQuality.loadWindowFrames));
|
||
memset(m_AdaptiveQuality.loadWindowBytes, 0, sizeof(m_AdaptiveQuality.loadWindowBytes));
|
||
memset(m_AdaptiveQuality.loadWindowMs, 0, sizeof(m_AdaptiveQuality.loadWindowMs));
|
||
m_AdaptiveQuality.loadWindowPos = 0;
|
||
m_AdaptiveQuality.loadWindowFilled = 0;
|
||
|
||
// 手动选档(persist=1)时清掉升档封顶和锁档:那是自适应在本会话里试探出来的结论,
|
||
// 用户显式指定的档位不该被它压住,否则会出现"选了高档却一直被拉回去"。
|
||
if (persist) {
|
||
m_AdaptiveQuality.levelCeiling = -1;
|
||
m_AdaptiveQuality.ceilingUntil = 0;
|
||
m_AdaptiveQuality.lastUpFromLevel = -1;
|
||
m_AdaptiveQuality.lockUntil = 0;
|
||
m_AdaptiveQuality.changeWindowStart = 0;
|
||
m_AdaptiveQuality.changeCountInWindow = 0;
|
||
// 用户自己点的档位,不需要解释"为什么变";顺手清掉上一次自适应留下的原因
|
||
m_AdaptiveQuality.reason.Empty();
|
||
m_AdaptiveQuality.reasonUntil = 0;
|
||
}
|
||
|
||
// 1. 发送 FPS 和算法 (persist=1 表示手动选择需要保存)
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)level, (BYTE)persist };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
|
||
// 2. 如果分辨率变化,发送 CMD_SCREEN_SIZE
|
||
if (newMaxWidth != oldMaxWidth) {
|
||
// 先判断客户端会不会真的重启截屏。客户端 CMD_SCREEN_SIZE 的判据是
|
||
// strategy=2 且 maxWidth>0 时 needRestart = (maxWidth != 当前发送宽度)
|
||
// (client/ScreenManager.cpp),而"当前发送宽度"就是 TOKEN_BITMAPINFO 里的
|
||
// biWidth,服务端手里有同一个值。相等时客户端不重启、不会发位图信息,
|
||
// 这里若照样置 m_bResolutionChanging,就会白等超时并丢掉新流的首帧 IDR——
|
||
// 正是"从 RGB565 切回 H264 卡住"的那条路径(比如 1920 屏从 High 切到 Good)。
|
||
// maxWidth==0 时客户端回退到它自己保存的 ScreenStrategy(0=1080p / 1=原始),
|
||
// 服务端不知道,按"可能重启"保守处理。
|
||
// m_bResolutionChanging 仍为真说明上一次切换的重启还没收到位图信息,缓存宽度
|
||
// 可能已经过时(客户端正在改宽度),同样按"可能重启"处理。
|
||
const int currentWidth = m_nClientBitmapWidth.load(std::memory_order_relaxed);
|
||
const bool willRestart = m_bResolutionChanging || (newMaxWidth <= 0) ||
|
||
(currentWidth <= 0) || (newMaxWidth != currentWidth);
|
||
if (willRestart) {
|
||
// 标记分辨率切换中,阻止 Decode 访问旧缓冲区
|
||
m_bResolutionChanging = true;
|
||
// 自适应调整且分辨率变化时不显示"请等待",手动切换时显示
|
||
if (!persist) m_bQualitySwitch = true;
|
||
m_AdaptiveQuality.lastResChangeTime = GetTickCount64();
|
||
} else {
|
||
Mprintf("客户端当前宽度已是 %d,不会重启截屏,不置分辨率切换标记\n", currentWidth);
|
||
}
|
||
m_AdaptiveQuality.currentMaxWidth = newMaxWidth;
|
||
|
||
BYTE sizeCmd[16] = { CMD_SCREEN_SIZE, 2 }; // strategy=2 表示自定义maxWidth
|
||
memcpy(sizeCmd + 2, &newMaxWidth, sizeof(int));
|
||
m_ContextObject->Send2Client(sizeCmd, 10);
|
||
|
||
Mprintf("发送 CMD_SCREEN_SIZE: strategy=2, maxWidth=%d\n", newMaxWidth);
|
||
} else {
|
||
Mprintf("分辨率未变化,不发送 CMD_SCREEN_SIZE\n");
|
||
}
|
||
|
||
Mprintf("质量切换: %s (FPS=%d, Algo=%d)\n", GetQualityName(level), profile.maxFPS, profile.algorithm);
|
||
}
|
||
|
||
BOOL CScreenSpyDlg::PreTranslateMessage(MSG* pMsg)
|
||
{
|
||
#define MAKEDWORD(h,l) (((unsigned long)h << 16) | l)
|
||
switch (pMsg->message) {
|
||
case WM_LBUTTONDOWN:
|
||
case WM_LBUTTONUP:
|
||
case WM_RBUTTONDOWN:
|
||
case WM_RBUTTONUP:
|
||
case WM_LBUTTONDBLCLK:
|
||
case WM_RBUTTONDBLCLK:
|
||
case WM_MBUTTONDBLCLK:
|
||
case WM_MBUTTONDOWN:
|
||
case WM_MBUTTONUP:
|
||
SendScaledMouseMessage(pMsg, true);
|
||
break;
|
||
case WM_MOUSEMOVE:
|
||
// Android(含 TV/盒子)把悬停的 mousemove 翻译成焦点移动;MFC 控制端只在
|
||
// 按住左键拖动时转发,避免鼠标划过画面时远程焦点乱跳。触摸屏浏览器的输入
|
||
// 走 Web 前端的 touch 处理器,不经过这里。
|
||
if (m_bIsCtrl) {
|
||
if (m_androidHost < 0 && m_ClientID != 0 && g_2015RemoteDlg) {
|
||
CString clientType;
|
||
if (g_2015RemoteDlg->GetHostClientType(m_ClientID, clientType))
|
||
m_androidHost = clientType.CompareNoCase(_T("APK")) == 0 ? 1 : 0;
|
||
}
|
||
if (m_androidHost == 1 && !(pMsg->wParam & MK_LBUTTON))
|
||
break;
|
||
}
|
||
SendScaledMouseMessage(pMsg, true);
|
||
break;
|
||
case WM_MOUSEWHEEL: {
|
||
// WM_MOUSEWHEEL 的 lParam 是屏幕坐标,需要转换为客户区坐标
|
||
POINT pt = { GET_X_LPARAM(pMsg->lParam), GET_Y_LPARAM(pMsg->lParam) };
|
||
ScreenToClient(&pt);
|
||
MSG wheelMsg = *pMsg;
|
||
wheelMsg.lParam = MAKELPARAM(pt.x, pt.y);
|
||
SendScaledMouseMessage(&wheelMsg, true);
|
||
return TRUE; // 已处理,阻止继续分发到 OnMouseWheel
|
||
}
|
||
case WM_KEYDOWN:
|
||
case WM_KEYUP:
|
||
case WM_SYSKEYDOWN:
|
||
case WM_SYSKEYUP:
|
||
if (pMsg->message == WM_KEYDOWN && m_Settings.FullScreen) {
|
||
// Ctrl+Alt+Home 退出全屏(备用)
|
||
if (pMsg->wParam == VK_HOME &&
|
||
(GetKeyState(VK_CONTROL) & 0x8000) &&
|
||
(GetKeyState(VK_MENU) & 0x8000)) {
|
||
LeaveFullScreen();
|
||
BYTE cmd[4] = { CMD_FULL_SCREEN, m_Settings.FullScreen = FALSE };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
return TRUE;
|
||
}
|
||
}
|
||
if (pMsg->wParam != VK_LWIN && pMsg->wParam != VK_RWIN) {
|
||
SendScaledMouseMessage(pMsg, false); // false: 保留键盘 lParam
|
||
}
|
||
if (pMsg->message == WM_SYSKEYDOWN && pMsg->wParam == VK_F4) {
|
||
return TRUE; // 屏蔽 Alt + F4
|
||
}
|
||
if (pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE)
|
||
return TRUE;// 屏蔽Enter和ESC关闭对话
|
||
break;
|
||
}
|
||
|
||
return __super::PreTranslateMessage(pMsg);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::SendScaledMouseMessage(MSG* pMsg, bool makeLP)
|
||
{
|
||
if (!m_bIsCtrl || !m_bConnected)
|
||
return;
|
||
|
||
MYMSG msg(*pMsg);
|
||
LONG x = LOWORD(pMsg->lParam), y = HIWORD(pMsg->lParam);
|
||
LONG low, high;
|
||
if (m_bAdaptiveSize) {
|
||
// 减去黑边偏移后映射到远端坐标,并 clamp 到合法范围
|
||
// 防止黑边区域的点击转换为负数后经 MAKELPARAM 截断为 WORD 大正数
|
||
int srcW = m_BitmapInfor_Full ? m_BitmapInfor_Full->bmiHeader.biWidth : 0;
|
||
int srcH = m_BitmapInfor_Full ? abs(m_BitmapInfor_Full->bmiHeader.biHeight) : 0;
|
||
low = max(0L, min((LONG)((x - m_offsetX) * m_wZoom), (LONG)(srcW - 1)));
|
||
high = max(0L, min((LONG)((y - m_offsetY) * m_hZoom), (LONG)(srcH - 1)));
|
||
} else {
|
||
low = x + m_ulHScrollPos;
|
||
high = y + m_ulVScrollPos;
|
||
}
|
||
|
||
// 逐主机鼠标坐标补偿(系统菜单「鼠标坐标校准」)。默认 1.0,对所有主机无影响。
|
||
// 客户端若用错误的逻辑分辨率换算坐标(见 macos/ScreenHandler.mm),注入点会随
|
||
// 离左上角的距离线性偏移;这里先按 真实分辨率 ÷ 上报分辨率 缩放,抵消其换算。
|
||
// 注意:补偿后坐标可以超出位图尺寸(例如 y 需要 1096 才能落到 1023 行),
|
||
// 因此不按位图边界裁剪,只做 16 位协议范围裁剪。
|
||
if (m_mouseScaleX != 1.0)
|
||
low = (LONG)(low * m_mouseScaleX + 0.5);
|
||
if (m_mouseScaleY != 1.0)
|
||
high = (LONG)(high * m_mouseScaleY + 0.5);
|
||
low = max(0L, min(low, 65535L));
|
||
high = max(0L, min(high, 65535L));
|
||
|
||
if (makeLP) msg.lParam = MAKELPARAM(low, high);
|
||
msg.pt.x = low;
|
||
msg.pt.y = high;
|
||
SendCommand(&msg);
|
||
}
|
||
|
||
// 解析客户端上报的分辨率 "N:WxH"(N=显示器数)。失败返回 false。
|
||
static bool ParseReportedResolution(const CString& res, int& w, int& h)
|
||
{
|
||
int colon = res.Find(':');
|
||
if (colon < 0) return false;
|
||
CString dims = res.Mid(colon + 1);
|
||
int sep = dims.FindOneOf(_T("xX*,"));
|
||
if (sep <= 0) return false;
|
||
w = _ttoi(dims.Left(sep));
|
||
h = _ttoi(dims.Mid(sep + 1));
|
||
return w > 0 && h > 0;
|
||
}
|
||
|
||
// 自动建议补偿系数。只针对已确诊的情形:Mac 客户端 + 画面与上报分辨率在两轴上
|
||
// 比例不一致(旧 Mac 客户端用 [NSScreen mainScreen] 的逻辑尺寸做坐标换算)。
|
||
// 建议值 = 画面尺寸 ÷ 上报尺寸,前提是抓屏显示器为标准 1× 分辨率(非 Retina)且
|
||
// 画质档位没有压缩画面宽度;两者任一不成立时用户需手工修正。
|
||
// 两轴比例一致说明客户端换算正常(Retina 下画面与上报同为一个缩放倍数),不补偿。
|
||
static bool SuggestMouseScale(const CString& clientType, int imgW, int imgH,
|
||
int repW, int repH, double& sx, double& sy)
|
||
{
|
||
if (clientType != _T("MAC"))
|
||
return false;
|
||
if (imgW <= 0 || imgH <= 0 || repW <= 0 || repH <= 0)
|
||
return false;
|
||
double rx = (double)imgW / repW;
|
||
double ry = (double)imgH / repH;
|
||
double lo = min(rx, ry), hi = max(rx, ry);
|
||
if (lo <= 0.0 || hi / lo <= 1.02) // 两轴一致:正常客户端,无需补偿
|
||
return false;
|
||
if (rx < 0.2 || rx > 5.0 || ry < 0.2 || ry > 5.0)
|
||
return false;
|
||
sx = rx;
|
||
sy = ry;
|
||
return true;
|
||
}
|
||
|
||
void CScreenSpyDlg::LoadMouseScale()
|
||
{
|
||
m_mouseScaleX = m_mouseScaleY = 1.0;
|
||
m_mouseScaleFromConfig = false;
|
||
|
||
std::string raw = THIS_CFG.GetStr("mouse_scale", std::to_string(m_ClientID));
|
||
if (raw.empty()) return;
|
||
|
||
// 格式: "sx,sy,refRepW,refRepH[,refImgW,refImgH]"。后两项是校准时的画面尺寸,
|
||
// 用于识别抓屏显示器是否已切换;旧记录没有后两项,退化为按上报/画面比例判断。
|
||
double sx = 1.0, sy = 1.0;
|
||
int refW = 0, refH = 0, refImgW = 0, refImgH = 0;
|
||
int fields = sscanf_s(raw.c_str(), "%lf,%lf,%d,%d,%d,%d",
|
||
&sx, &sy, &refW, &refH, &refImgW, &refImgH);
|
||
if (fields != 4 && fields != 6) {
|
||
Mprintf("[MouseScale] device %llu: invalid config '%s'\n", m_ClientID, raw.c_str());
|
||
return;
|
||
}
|
||
if (!(sx >= 0.2 && sx <= 5.0 && sy >= 0.2 && sy <= 5.0)) {
|
||
Mprintf("[MouseScale] device %llu: out of range %.4f,%.4f\n", m_ClientID, sx, sy);
|
||
return;
|
||
}
|
||
// 1.0 等价于“无补偿”(用户复位后留下的记录),按未校准处理,允许重新自动建议。
|
||
if (sx == 1.0 && sy == 1.0)
|
||
return;
|
||
|
||
// 校准记录绑定当时的「客户端上报分辨率」。客户端修复后上报值会变,旧系数会变成
|
||
// 二次补偿(反而更偏),因此上报值不一致时自动失效。refW/refH=0 表示上报值不可用,
|
||
// 无法校验,按配置生效。
|
||
int curW = 0, curH = 0;
|
||
bool haveRep = false;
|
||
context* mainCtx = m_pParent ? m_pParent->FindHost(m_ClientID) : nullptr;
|
||
if (mainCtx && ParseReportedResolution(mainCtx->GetAdditionalData(RES_RESOLUTION), curW, curH))
|
||
haveRep = true;
|
||
if (refW > 0 && refH > 0 && haveRep && (curW != refW || curH != refH)) {
|
||
Mprintf("[MouseScale] device %llu: reported %dx%d != calibrated %dx%d, override disabled\n",
|
||
m_ClientID, curW, curH, refW, refH);
|
||
return;
|
||
}
|
||
|
||
// 校准记录还绑定当时的「画面(抓屏)宽高比」。切换显示器后(例如外接屏切回内置屏)
|
||
// 画面比例会变,旧系数不能再套用;切回原显示器时比例恢复,系数自动重新生效。
|
||
// 客户端修复后同一次会话内画面比例不变,但上报值会变,仍由上面的检查兜底。
|
||
int curImgW = m_BitmapInfor_Full ? m_BitmapInfor_Full->bmiHeader.biWidth : 0;
|
||
int curImgH = m_BitmapInfor_Full ? abs(m_BitmapInfor_Full->bmiHeader.biHeight) : 0;
|
||
if (curImgW > 0 && curImgH > 0) {
|
||
if (refImgW > 0 && refImgH > 0) {
|
||
double refAspect = (double)refImgW / refImgH;
|
||
double curAspect = (double)curImgW / curImgH;
|
||
if (fabs(curAspect / refAspect - 1.0) > 0.02) {
|
||
Mprintf("[MouseScale] device %llu: frame %dx%d (aspect %.3f) != calibrated aspect %.3f, override disabled\n",
|
||
m_ClientID, curImgW, curImgH, curAspect, refAspect);
|
||
return;
|
||
}
|
||
} else if (haveRep && curW > 0 && curH > 0) {
|
||
// 旧格式没记录画面比例:只有当前画面与上报分辨率两轴比例不一致(即客户端
|
||
// 仍存在换算偏差)时才套用;两轴一致说明换算正常(例如切回内置屏),不补偿。
|
||
double rx = (double)curImgW / curW;
|
||
double ry = (double)curImgH / curH;
|
||
double lo = min(rx, ry), hi = max(rx, ry);
|
||
if (lo <= 0.0 || hi / lo <= 1.02) {
|
||
Mprintf("[MouseScale] device %llu: frame %dx%d matches reported %dx%d, override disabled\n",
|
||
m_ClientID, curImgW, curImgH, curW, curH);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
m_mouseScaleX = sx;
|
||
m_mouseScaleY = sy;
|
||
m_mouseScaleFromConfig = true;
|
||
Mprintf("[MouseScale] device %llu: apply x%.4f y%.4f\n", m_ClientID, sx, sy);
|
||
}
|
||
|
||
void CScreenSpyDlg::ShowMouseCalibration()
|
||
{
|
||
int imgW = m_BitmapInfor_Full ? m_BitmapInfor_Full->bmiHeader.biWidth : 0;
|
||
int imgH = m_BitmapInfor_Full ? abs(m_BitmapInfor_Full->bmiHeader.biHeight) : 0;
|
||
|
||
CString reported, clientType;
|
||
int repW = 0, repH = 0;
|
||
context* mainCtx = m_pParent ? m_pParent->FindHost(m_ClientID) : nullptr;
|
||
if (mainCtx) {
|
||
reported = mainCtx->GetAdditionalData(RES_RESOLUTION);
|
||
ParseReportedResolution(reported, repW, repH);
|
||
clientType = mainCtx->GetAdditionalData(RES_CLIENT_TYPE);
|
||
}
|
||
|
||
// 没有保存过系数时,按「画面 ÷ 上报」自动填入建议值(无需手工计算);
|
||
// 保存过的系数优先展示,避免覆盖用户手工微调的结果。
|
||
double sx = m_mouseScaleX, sy = m_mouseScaleY;
|
||
bool autoFilled = !m_mouseScaleFromConfig
|
||
&& SuggestMouseScale(clientType, imgW, imgH, repW, repH, sx, sy);
|
||
|
||
// 提示文本走 CInputDialog 的 m_sTipInfo(DDV 上限 64 字符),保持简短。
|
||
CString tip;
|
||
if (autoFilled)
|
||
tip = _TR("已按 画面/上报 自动填写,可修改");
|
||
else
|
||
tip.Format(_TR("画面 %dx%d;上报 %s;系数为真实除以上报"),
|
||
imgW, imgH, reported.IsEmpty() ? _T("-") : reported.GetString());
|
||
|
||
CString xStr, yStr;
|
||
xStr.Format(_T("%.4f"), sx);
|
||
yStr.Format(_T("%.4f"), sy);
|
||
|
||
CInputDialog dlg(this);
|
||
dlg.Init(_TR("鼠标坐标校准"), _TR("X 轴缩放系数"));
|
||
dlg.m_str = xStr;
|
||
dlg.Init2(_TR("Y 轴缩放系数"), yStr);
|
||
dlg.m_sTipInfo = tip;
|
||
if (dlg.DoModal() != IDOK)
|
||
return;
|
||
|
||
sx = _ttof(dlg.m_str);
|
||
sy = _ttof(dlg.m_sSecondInput);
|
||
if (!(sx >= 0.2 && sx <= 5.0 && sy >= 0.2 && sy <= 5.0)) {
|
||
MessageBox(_TR("缩放系数需在 0.2 到 5.0 之间。"), _TR("鼠标坐标校准"), MB_ICONWARNING);
|
||
return;
|
||
}
|
||
|
||
// 记录上报分辨率 + 画面尺寸,供下次加载时判断系数是否仍然适用(切换显示器后失效)。
|
||
CString val;
|
||
if (sx == 1.0 && sy == 1.0) {
|
||
// 1.0 表示不补偿;写成等价的空记录,下次打开对话框仍会按当前画面自动建议。
|
||
val = _T("1.0,1.0,0,0");
|
||
m_mouseScaleFromConfig = false;
|
||
} else {
|
||
val.Format(_T("%.6f,%.6f,%d,%d,%d,%d"), sx, sy, repW, repH, imgW, imgH);
|
||
m_mouseScaleFromConfig = true;
|
||
}
|
||
THIS_CFG.SetStr("mouse_scale", std::to_string(m_ClientID), val.GetString());
|
||
m_mouseScaleX = sx;
|
||
m_mouseScaleY = sy;
|
||
Mprintf("[MouseScale] device %llu: saved x%.4f y%.4f (reported %dx%d)\n",
|
||
m_ClientID, sx, sy, repW, repH);
|
||
}
|
||
|
||
VOID CScreenSpyDlg::SendCommand(const MYMSG* Msg)
|
||
{
|
||
if (!m_bIsCtrl)
|
||
return;
|
||
|
||
if (Msg->message == WM_MOUSEMOVE) {
|
||
auto now = clock();
|
||
auto time_elapsed = now - m_lastMouseMove;
|
||
int dx = abs(Msg->pt.x - m_lastMousePoint.x);
|
||
int dy = abs(Msg->pt.y - m_lastMousePoint.y);
|
||
int dist_sq = dx * dx + dy * dy;
|
||
|
||
bool fastMove = dist_sq > 50 * 50;
|
||
int minInterval = fastMove ? 33 : 16;
|
||
int minDistSq = fastMove ? 10 * 10 : 3 * 3;
|
||
if (time_elapsed < minInterval && dist_sq < minDistSq) {
|
||
return;
|
||
}
|
||
m_lastMouseMove = now;
|
||
m_lastMousePoint = Msg->pt;
|
||
}
|
||
|
||
const int length = sizeof(MSG64) + 1;
|
||
BYTE szData[length + 3];
|
||
szData[0] = COMMAND_SCREEN_CONTROL;
|
||
memcpy(szData + 1, Msg, sizeof(MSG64));
|
||
szData[length] = 0;
|
||
m_ContextObject->Send2Client(szData, length);
|
||
}
|
||
|
||
void CScreenSpyDlg::SaveSnapshot(void)
|
||
{
|
||
auto path = GetScreenShotPath(this, m_IPAddress, _TR("位图文件(*.bmp)|*.bmp|"), "bmp");
|
||
if (path.empty())
|
||
return;
|
||
|
||
if (!WriteBitmap(m_BitmapInfor_Full, m_BitmapData_Full, path.c_str()))
|
||
return;
|
||
|
||
m_strSaveNotice = path;
|
||
m_nSaveNoticeTime = GetTickCount64();
|
||
}
|
||
|
||
|
||
VOID CScreenSpyDlg::UpdateServerClipboard(char* szBuffer, ULONG ulLength)
|
||
{
|
||
if (!::OpenClipboard(NULL))
|
||
return;
|
||
|
||
::EmptyClipboard();
|
||
|
||
// UTF-8 转 Unicode
|
||
int wlen = MultiByteToWideChar(CP_UTF8, 0, szBuffer, ulLength, nullptr, 0);
|
||
if (wlen > 0) {
|
||
// 分配 Unicode 缓冲区(+1 确保 null 结尾)
|
||
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, (wlen + 1) * sizeof(wchar_t));
|
||
if (hGlobal != NULL) {
|
||
wchar_t* pWideStr = (wchar_t*)GlobalLock(hGlobal);
|
||
if (pWideStr) {
|
||
MultiByteToWideChar(CP_UTF8, 0, szBuffer, ulLength, pWideStr, wlen);
|
||
pWideStr[wlen] = L'\0'; // 确保 null 结尾
|
||
GlobalUnlock(hGlobal);
|
||
|
||
if (SetClipboardData(CF_UNICODETEXT, hGlobal) == NULL) {
|
||
GlobalFree(hGlobal);
|
||
}
|
||
} else {
|
||
GlobalFree(hGlobal);
|
||
}
|
||
}
|
||
}
|
||
|
||
CloseClipboard();
|
||
}
|
||
|
||
VOID CScreenSpyDlg::SendServerClipboard(void)
|
||
{
|
||
if (!::OpenClipboard(NULL)) //打开剪切板设备
|
||
return;
|
||
HGLOBAL hGlobal = GetClipboardData(CF_TEXT); //代表着一个内存
|
||
if (hGlobal == NULL) {
|
||
::CloseClipboard();
|
||
return;
|
||
}
|
||
int iPacketLength = GlobalSize(hGlobal) + 1;
|
||
char* szClipboardVirtualAddress = (LPSTR) GlobalLock(hGlobal); //锁定
|
||
LPBYTE szBuffer = new BYTE[iPacketLength];
|
||
|
||
szBuffer[0] = COMMAND_SCREEN_SET_CLIPBOARD;
|
||
memcpy(szBuffer + 1, szClipboardVirtualAddress, iPacketLength - 1);
|
||
::GlobalUnlock(hGlobal);
|
||
::CloseClipboard();
|
||
m_ContextObject->Send2Client((PBYTE)szBuffer, iPacketLength);
|
||
delete[] szBuffer;
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
||
{
|
||
if (m_bAdaptiveSize) return;
|
||
|
||
SCROLLINFO si = {sizeof(si)};
|
||
si.fMask = SIF_ALL;
|
||
GetScrollInfo(SB_HORZ, &si);
|
||
|
||
int nPrevPos = si.nPos;
|
||
switch(nSBCode) {
|
||
case SB_LEFT:
|
||
si.nPos = si.nMin;
|
||
break;
|
||
case SB_RIGHT:
|
||
si.nPos = si.nMax;
|
||
break;
|
||
case SB_LINELEFT:
|
||
si.nPos -= 8;
|
||
break;
|
||
case SB_LINERIGHT:
|
||
si.nPos += 8;
|
||
break;
|
||
case SB_PAGELEFT:
|
||
si.nPos -= si.nPage;
|
||
break;
|
||
case SB_PAGERIGHT:
|
||
si.nPos += si.nPage;
|
||
break;
|
||
case SB_THUMBTRACK:
|
||
si.nPos = si.nTrackPos;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
si.fMask = SIF_POS;
|
||
SetScrollInfo(SB_HORZ, &si, TRUE);
|
||
if (si.nPos != nPrevPos) {
|
||
m_ulHScrollPos += si.nPos - nPrevPos;
|
||
ScrollWindow(nPrevPos - si.nPos, 0, NULL, NULL);
|
||
}
|
||
|
||
__super::OnHScroll(nSBCode, nPrevPos, pScrollBar);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
||
{
|
||
if (m_bAdaptiveSize) return;
|
||
|
||
SCROLLINFO si = {sizeof(si)};
|
||
si.fMask = SIF_ALL;
|
||
GetScrollInfo(SB_VERT, &si);
|
||
|
||
int nPrevPos = si.nPos;
|
||
switch(nSBCode) {
|
||
case SB_TOP:
|
||
si.nPos = si.nMin;
|
||
break;
|
||
case SB_BOTTOM:
|
||
si.nPos = si.nMax;
|
||
break;
|
||
case SB_LINEUP:
|
||
si.nPos -= 8;
|
||
break;
|
||
case SB_LINEDOWN:
|
||
si.nPos += 8;
|
||
break;
|
||
case SB_PAGEUP:
|
||
si.nPos -= si.nPage;
|
||
break;
|
||
case SB_PAGEDOWN:
|
||
si.nPos += si.nPage;
|
||
break;
|
||
case SB_THUMBTRACK:
|
||
si.nPos = si.nTrackPos;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
si.fMask = SIF_POS;
|
||
SetScrollInfo(SB_VERT, &si, TRUE);
|
||
if (si.nPos != nPrevPos) {
|
||
m_ulVScrollPos += si.nPos - nPrevPos;
|
||
ScrollWindow(0, nPrevPos - si.nPos, NULL, NULL);
|
||
}
|
||
|
||
__super::OnVScroll(nSBCode, nPrevPos, pScrollBar);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::EnterFullScreen()
|
||
{
|
||
// 进入全屏时重置放大状态
|
||
if (m_bZoomedIn) {
|
||
ResetZoom();
|
||
}
|
||
|
||
if (1) {
|
||
// 1. 获取对话框当前所在的显示器
|
||
HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
|
||
MONITORINFO mi = { sizeof(mi) };
|
||
if (!GetMonitorInfo(hMonitor, &mi))
|
||
return;
|
||
|
||
RECT rcMonitor = mi.rcMonitor;
|
||
|
||
// 3. 记录当前窗口状态
|
||
GetWindowPlacement(&m_struOldWndpl);
|
||
|
||
// 4. 修改窗口样式,移除标题栏、边框
|
||
LONG lStyle = GetWindowLong(m_hWnd, GWL_STYLE);
|
||
lStyle &= ~(WS_CAPTION | WS_THICKFRAME | WS_BORDER);
|
||
SetWindowLong(m_hWnd, GWL_STYLE, lStyle);
|
||
|
||
// 5. 全屏无条件隐藏滚动条
|
||
ShowScrollBar(SB_BOTH, FALSE);
|
||
|
||
// 6. 重新调整窗口大小并更新
|
||
SetWindowPos(&CWnd::wndTop, rcMonitor.left, rcMonitor.top, rcMonitor.right - rcMonitor.left,
|
||
rcMonitor.bottom - rcMonitor.top, SWP_NOZORDER | SWP_FRAMECHANGED);
|
||
|
||
if (!m_pToolbar) {
|
||
m_pToolbar = new CToolbarDlg(this);
|
||
m_pToolbar->Create(IDD_TOOLBAR_DLG, this);
|
||
// OnInitDialog() 会根据 m_bLocked 和 m_nPosition 设置正确的位置和可见性
|
||
// 如果未锁定,隐藏在屏幕边缘(尺寸为1像素,不跑到相邻屏幕)
|
||
if (!m_pToolbar->m_bLocked) {
|
||
int monWidth = rcMonitor.right - rcMonitor.left;
|
||
int monHeight = rcMonitor.bottom - rcMonitor.top;
|
||
int hw = 480; // 水平工具栏宽度
|
||
int vh = 480; // 垂直工具栏高度
|
||
int hx = rcMonitor.left + (monWidth - hw) / 2;
|
||
switch (m_pToolbar->m_nPosition) {
|
||
case 0:
|
||
m_pToolbar->SetWindowPos(&wndTopMost, hx, rcMonitor.top, hw, 1, SWP_HIDEWINDOW);
|
||
break;
|
||
case 1:
|
||
m_pToolbar->SetWindowPos(&wndTopMost, hx, rcMonitor.bottom - 1, hw, 1, SWP_HIDEWINDOW);
|
||
break;
|
||
case 2: {
|
||
int vy = rcMonitor.top + (monHeight - vh) / 2;
|
||
m_pToolbar->SetWindowPos(&wndTopMost, rcMonitor.left, vy, 1, vh, SWP_HIDEWINDOW);
|
||
break;
|
||
}
|
||
case 3: {
|
||
int vy = rcMonitor.top + (monHeight - vh) / 2;
|
||
m_pToolbar->SetWindowPos(&wndTopMost, rcMonitor.right - 1, vy, 1, vh, SWP_HIDEWINDOW);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// 同步系统菜单的锁定输入状态到工具栏
|
||
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
||
if (pSysMenu) {
|
||
BOOL bBlockInput = pSysMenu->GetMenuState(IDM_BLOCK_INPUT, MF_BYCOMMAND) & MF_CHECKED;
|
||
m_pToolbar->m_bBlockInput = (bBlockInput != 0);
|
||
m_pToolbar->UpdateButtonIcons();
|
||
}
|
||
}
|
||
|
||
// 创建状态信息窗口
|
||
if (!m_pStatusInfoWnd) {
|
||
m_pStatusInfoWnd = new CStatusInfoWnd();
|
||
m_pStatusInfoWnd->Create(this);
|
||
}
|
||
// 先把宽度按当前文本算出来再定位,否则第一次显示会先窄一帧再撑开
|
||
m_pStatusInfoWnd->UpdateInfo(m_dFrameRate, m_dTransferRate,
|
||
m_Settings.QualityLevel == QUALITY_DISABLED ? _T("Off") : GetQualityDisplayName());
|
||
m_pStatusInfoWnd->UpdatePosition(rcMonitor);
|
||
// 同步工具栏透明度
|
||
if (m_pToolbar) {
|
||
m_pStatusInfoWnd->SetOpacityLevel(m_pToolbar->m_nOpacityLevel);
|
||
}
|
||
if (m_pToolbar && m_pToolbar->m_bShowStatusInfo) {
|
||
m_pStatusInfoWnd->Show();
|
||
}
|
||
|
||
// 7. 标记全屏模式
|
||
m_Settings.FullScreen = true;
|
||
|
||
SetTimer(1, 50, NULL);
|
||
}
|
||
}
|
||
|
||
// 全屏退出成功则返回true
|
||
bool CScreenSpyDlg::LeaveFullScreen()
|
||
{
|
||
// 退出全屏时重置放大状态
|
||
if (m_bZoomedIn) {
|
||
ResetZoom();
|
||
}
|
||
|
||
if (1) {
|
||
KillTimer(1);
|
||
if (m_pToolbar) {
|
||
m_pToolbar->DestroyWindow();
|
||
delete m_pToolbar;
|
||
m_pToolbar = nullptr;
|
||
}
|
||
|
||
// 隐藏状态信息窗口
|
||
if (m_pStatusInfoWnd) {
|
||
m_pStatusInfoWnd->Hide();
|
||
}
|
||
|
||
// 1. 恢复窗口样式
|
||
LONG lStyle = GetWindowLong(m_hWnd, GWL_STYLE);
|
||
lStyle |= (WS_CAPTION | WS_THICKFRAME | WS_BORDER);
|
||
SetWindowLong(m_hWnd, GWL_STYLE, lStyle);
|
||
|
||
// 2. 恢复窗口大小
|
||
SetWindowPlacement(&m_struOldWndpl);
|
||
SetWindowPos(&CWnd::wndTop, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);
|
||
|
||
// 3. 显示滚动条(全屏期间可能发生了质量切换,需要补设范围)
|
||
if (!m_bAdaptiveSize && m_BitmapInfor_Full) {
|
||
SetScrollRange(SB_HORZ, 0, m_BitmapInfor_Full->bmiHeader.biWidth);
|
||
SetScrollRange(SB_VERT, 0, m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
}
|
||
ShowScrollBar(SB_BOTH, !m_bAdaptiveSize);
|
||
|
||
// 4. 标记退出全屏
|
||
m_Settings.FullScreen = false;
|
||
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
SysMenu->CheckMenuItem(IDM_FULLSCREEN, MF_UNCHECKED); //菜单样式
|
||
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ========== 局部放大功能辅助函数 ==========
|
||
|
||
// 重置放大状态
|
||
void CScreenSpyDlg::ResetZoom()
|
||
{
|
||
m_bZoomedIn = false;
|
||
m_bSelectingZoom = false;
|
||
m_bZoomDragging = false;
|
||
m_rcZoomSrc.SetRectEmpty();
|
||
Invalidate();
|
||
}
|
||
|
||
void CScreenSpyDlg::SendROICommand(const RECT& rc)
|
||
{
|
||
if (!m_bConnected) return;
|
||
BYTE buf[1 + sizeof(RECT)];
|
||
buf[0] = COMMAND_SCREEN_ROI;
|
||
memcpy(buf + 1, &rc, sizeof(RECT));
|
||
m_ContextObject->Send2Client(buf, sizeof(buf));
|
||
}
|
||
|
||
void CScreenSpyDlg::ResetROI()
|
||
{
|
||
bool wasActive = m_bROIActive;
|
||
m_bROIArmed = false;
|
||
m_bROIActive = false;
|
||
m_bSelectingROI = false;
|
||
if (GetCapture() == this) ReleaseCapture();
|
||
if (wasActive) { // ROI 未曾激活则不通知远程,避免不必要的 RestartScreen
|
||
RECT rc = {0};
|
||
SendROICommand(rc);
|
||
}
|
||
if (m_pToolbar) m_pToolbar->UpdateButtonIcons();
|
||
Invalidate();
|
||
}
|
||
|
||
// 屏幕坐标转原图坐标(考虑放大状态)
|
||
CPoint CScreenSpyDlg::ScreenToImage(CPoint pt)
|
||
{
|
||
if (!m_BitmapInfor_Full) return pt;
|
||
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
if (dstW <= 0 || dstH <= 0) return pt; // 防止除零
|
||
|
||
if (m_bZoomedIn && !m_rcZoomSrc.IsRectEmpty()) {
|
||
// 放大状态:从显示区域映射到放大区域
|
||
double scaleX = (double)m_rcZoomSrc.Width() / dstW;
|
||
double scaleY = (double)m_rcZoomSrc.Height() / dstH;
|
||
return CPoint(
|
||
(int)(m_rcZoomSrc.left + pt.x * scaleX),
|
||
(int)(m_rcZoomSrc.top + pt.y * scaleY)
|
||
);
|
||
} else if (m_bAdaptiveSize) {
|
||
// 自适应模式:先减去黑边偏移,再乘缩放比
|
||
return CPoint((int)((pt.x - m_offsetX) * m_wZoom),
|
||
(int)((pt.y - m_offsetY) * m_hZoom));
|
||
} else {
|
||
// 滚动模式:加上滚动偏移
|
||
return CPoint(pt.x + m_ulHScrollPos, pt.y + m_ulVScrollPos);
|
||
}
|
||
}
|
||
|
||
// 原图坐标转屏幕坐标(考虑放大状态)
|
||
CPoint CScreenSpyDlg::ImageToScreen(CPoint pt)
|
||
{
|
||
if (!m_BitmapInfor_Full) return pt;
|
||
|
||
int zoomW = m_rcZoomSrc.Width();
|
||
int zoomH = m_rcZoomSrc.Height();
|
||
|
||
if (m_bZoomedIn && zoomW > 0 && zoomH > 0) {
|
||
// 放大状态:从放大区域映射到显示区域
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
double scaleX = (double)dstW / zoomW;
|
||
double scaleY = (double)dstH / zoomH;
|
||
return CPoint(
|
||
(int)((pt.x - m_rcZoomSrc.left) * scaleX),
|
||
(int)((pt.y - m_rcZoomSrc.top) * scaleY)
|
||
);
|
||
} else if (m_bAdaptiveSize) {
|
||
// 自适应模式:除以缩放比,再加黑边偏移
|
||
if (m_wZoom > 0 && m_hZoom > 0) {
|
||
return CPoint((int)(pt.x / m_wZoom) + m_offsetX,
|
||
(int)(pt.y / m_hZoom) + m_offsetY);
|
||
}
|
||
return pt;
|
||
} else {
|
||
return CPoint(pt.x - m_ulHScrollPos, pt.y - m_ulVScrollPos);
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::OnLButtonDown(UINT nFlags, CPoint point)
|
||
{
|
||
// 非控制模式下的放大功能
|
||
if (!m_bIsCtrl && !m_bIsFirst && m_BitmapInfor_Full) {
|
||
if (m_bROIArmed) {
|
||
// ROI 待选状态:开始拖选 ROI 区域
|
||
m_bROIArmed = false;
|
||
m_bSelectingROI = true;
|
||
m_ptROIStart = point;
|
||
m_ptROICurrent = point;
|
||
SetCapture();
|
||
return;
|
||
}
|
||
if (m_bZoomedIn) {
|
||
// 放大状态:开始拖拽平移
|
||
m_bZoomDragging = true;
|
||
m_ptZoomDragStart = point; // 保存起点用于点击检测
|
||
m_ptZoomDragLast = point; // 用于增量拖拽计算
|
||
SetCapture();
|
||
return;
|
||
} else {
|
||
// 正常状态:开始框选放大区域
|
||
m_bSelectingZoom = true;
|
||
m_ptZoomStart = point;
|
||
m_ptZoomCurrent = point;
|
||
SetCapture();
|
||
return;
|
||
}
|
||
}
|
||
__super::OnLButtonDown(nFlags, point);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnLButtonUp(UINT nFlags, CPoint point)
|
||
{
|
||
// 处理放大功能的鼠标释放
|
||
if (!m_bIsCtrl && !m_bIsFirst && m_BitmapInfor_Full) {
|
||
if (m_bSelectingROI) {
|
||
ReleaseCapture();
|
||
m_bSelectingROI = false;
|
||
CRect rcSelect;
|
||
rcSelect.left = min(m_ptROIStart.x, point.x);
|
||
rcSelect.top = min(m_ptROIStart.y, point.y);
|
||
rcSelect.right = max(m_ptROIStart.x, point.x);
|
||
rcSelect.bottom = max(m_ptROIStart.y, point.y);
|
||
if (rcSelect.Width() < 20 || rcSelect.Height() < 20) {
|
||
m_bROIArmed = true; // 框选太小,重新进入待选状态
|
||
return;
|
||
}
|
||
CRect rcImage;
|
||
if (ScreenRectToImageRect(rcSelect, rcImage)) {
|
||
RECT rc = { rcImage.left, rcImage.top, rcImage.right, rcImage.bottom };
|
||
SendROICommand(rc);
|
||
m_bROIActive = true;
|
||
}
|
||
if (m_pToolbar) m_pToolbar->UpdateButtonIcons();
|
||
return;
|
||
}
|
||
|
||
if (m_bSelectingZoom) {
|
||
// 完成框选
|
||
ReleaseCapture();
|
||
m_bSelectingZoom = false;
|
||
|
||
// 计算选择区域(确保left<right, top<bottom)
|
||
CRect rcSelect;
|
||
rcSelect.left = min(m_ptZoomStart.x, point.x);
|
||
rcSelect.top = min(m_ptZoomStart.y, point.y);
|
||
rcSelect.right = max(m_ptZoomStart.x, point.x);
|
||
rcSelect.bottom = max(m_ptZoomStart.y, point.y);
|
||
|
||
// 框选区域太小时视为点击,如果已放大则还原
|
||
if (rcSelect.Width() < 20 || rcSelect.Height() < 20) {
|
||
if (m_bZoomedIn) {
|
||
ResetZoom();
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 将屏幕坐标转换为原图坐标
|
||
if (!ScreenRectToImageRect(rcSelect, m_rcZoomSrc)) {
|
||
return;
|
||
}
|
||
|
||
// 进入放大状态
|
||
m_bZoomedIn = true;
|
||
Invalidate();
|
||
return;
|
||
}
|
||
|
||
if (m_bZoomDragging) {
|
||
// 完成拖拽
|
||
ReleaseCapture();
|
||
m_bZoomDragging = false;
|
||
|
||
// 检查是否为点击(几乎没有移动)
|
||
int dx = abs(point.x - m_ptZoomDragStart.x);
|
||
int dy = abs(point.y - m_ptZoomDragStart.y);
|
||
if (dx < 5 && dy < 5) {
|
||
// 点击还原
|
||
ResetZoom();
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
__super::OnLButtonUp(nFlags, point);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnRButtonDown(UINT nFlags, CPoint point)
|
||
{
|
||
// 非控制模式下:右键框选 → 截图保存。控制模式下右键由 PreTranslateMessage 转发给客户端。
|
||
if (!m_bIsCtrl && !m_bIsFirst && m_BitmapInfor_Full) {
|
||
// 与左键互斥:左键正在框选/拖拽时不接管右键,避免冲突
|
||
if (m_bSelectingZoom || m_bZoomDragging || m_bROIArmed || m_bSelectingROI) {
|
||
return;
|
||
}
|
||
m_bSelectingShot = true;
|
||
m_ptShotStart = point;
|
||
m_ptShotCurrent = point;
|
||
SetCapture();
|
||
return;
|
||
}
|
||
__super::OnRButtonDown(nFlags, point);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnRButtonUp(UINT nFlags, CPoint point)
|
||
{
|
||
if (!m_bIsCtrl && !m_bIsFirst && m_BitmapInfor_Full && m_bSelectingShot) {
|
||
ReleaseCapture();
|
||
m_bSelectingShot = false;
|
||
|
||
CRect rcSelect;
|
||
rcSelect.left = min(m_ptShotStart.x, point.x);
|
||
rcSelect.top = min(m_ptShotStart.y, point.y);
|
||
rcSelect.right = max(m_ptShotStart.x, point.x);
|
||
rcSelect.bottom = max(m_ptShotStart.y, point.y);
|
||
|
||
// 太小视为误触(与左键放大同阈值)
|
||
if (rcSelect.Width() < 20 || rcSelect.Height() < 20) {
|
||
Invalidate(FALSE);
|
||
return;
|
||
}
|
||
|
||
CRect rcImage;
|
||
if (ScreenRectToImageRect(rcSelect, rcImage) &&
|
||
rcImage.Width() > 0 && rcImage.Height() > 0)
|
||
{
|
||
SaveRegionScreenshot(rcImage);
|
||
}
|
||
Invalidate(FALSE); // 清掉绿色选框
|
||
return;
|
||
}
|
||
__super::OnRButtonUp(nFlags, point);
|
||
}
|
||
|
||
|
||
// 屏幕(窗口)选框 → 原图坐标,考虑放大状态、自适应、滚动
|
||
bool CScreenSpyDlg::ScreenRectToImageRect(const CRect& rcScreen, CRect& rcImage)
|
||
{
|
||
if (!m_BitmapInfor_Full) return false;
|
||
int srcW = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int srcH = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
if (srcW <= 0 || srcH <= 0) return false;
|
||
|
||
if (m_bZoomedIn && !m_rcZoomSrc.IsRectEmpty()) {
|
||
// 放大状态:屏幕坐标 → 当前可视的子区域内的原图坐标
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
if (dstW <= 0 || dstH <= 0) return false;
|
||
double scaleX = (double)m_rcZoomSrc.Width() / dstW;
|
||
double scaleY = (double)m_rcZoomSrc.Height() / dstH;
|
||
rcImage.left = (int)(m_rcZoomSrc.left + rcScreen.left * scaleX);
|
||
rcImage.top = (int)(m_rcZoomSrc.top + rcScreen.top * scaleY);
|
||
rcImage.right = (int)(m_rcZoomSrc.left + rcScreen.right * scaleX);
|
||
rcImage.bottom = (int)(m_rcZoomSrc.top + rcScreen.bottom * scaleY);
|
||
} else if (m_bAdaptiveSize) {
|
||
// 先减去黑边偏移,再乘缩放比,得到原图坐标
|
||
rcImage.left = (int)((rcScreen.left - m_offsetX) * m_wZoom);
|
||
rcImage.top = (int)((rcScreen.top - m_offsetY) * m_hZoom);
|
||
rcImage.right = (int)((rcScreen.right - m_offsetX) * m_wZoom);
|
||
rcImage.bottom = (int)((rcScreen.bottom - m_offsetY) * m_hZoom);
|
||
} else {
|
||
rcImage.left = rcScreen.left + m_ulHScrollPos;
|
||
rcImage.top = rcScreen.top + m_ulVScrollPos;
|
||
rcImage.right = rcScreen.right + m_ulHScrollPos;
|
||
rcImage.bottom = rcScreen.bottom + m_ulVScrollPos;
|
||
}
|
||
|
||
// 限制在原图范围内
|
||
rcImage.left = max(0L, min(rcImage.left, (LONG)srcW));
|
||
rcImage.top = max(0L, min(rcImage.top, (LONG)srcH));
|
||
rcImage.right = max(0L, min(rcImage.right, (LONG)srcW));
|
||
rcImage.bottom = max(0L, min(rcImage.bottom, (LONG)srcH));
|
||
return true;
|
||
}
|
||
|
||
|
||
// 把原图中 [rcImage] 区域裁出来,写成独立 BMP(24bpp 或 32bpp 由源图决定)
|
||
void CScreenSpyDlg::SaveRegionScreenshot(const CRect& rcImage)
|
||
{
|
||
if (!m_BitmapInfor_Full || !m_BitmapData_Full) return;
|
||
if (rcImage.Width() <= 0 || rcImage.Height() <= 0) return;
|
||
|
||
auto path = GetScreenShotPath(this, m_IPAddress, _TR("位图文件(*.bmp)|*.bmp|"), "bmp");
|
||
if (path.empty()) return;
|
||
|
||
// 源 DIB 是 BGR 24bpp 或 BGRA 32bpp,bottom-up(biHeight > 0)
|
||
const BITMAPINFOHEADER& srcHdr = m_BitmapInfor_Full->bmiHeader;
|
||
int bpp = srcHdr.biBitCount;
|
||
if (bpp != 24 && bpp != 32) return; // 仅支持当前实际使用的两种位深
|
||
int srcW = srcHdr.biWidth;
|
||
int srcH = srcHdr.biHeight;
|
||
int srcStride = ((srcW * bpp + 31) / 32) * 4;
|
||
|
||
int dstW = rcImage.Width();
|
||
int dstH = rcImage.Height();
|
||
int dstStride = ((dstW * bpp + 31) / 32) * 4;
|
||
int dstSize = dstStride * dstH;
|
||
|
||
std::vector<BYTE> dstPixels(dstSize, 0);
|
||
const BYTE* srcBase = (const BYTE*)m_BitmapData_Full;
|
||
|
||
// bottom-up:原图第 y 行(从顶起算)位于 srcBase + (srcH - 1 - y) * srcStride
|
||
int byteX = rcImage.left * (bpp / 8);
|
||
int copyBytes = dstW * (bpp / 8);
|
||
for (int y = 0; y < dstH; ++y) {
|
||
int srcRowFromTop = rcImage.top + y;
|
||
int srcRowOffset = (srcH - 1 - srcRowFromTop) * srcStride + byteX;
|
||
int dstRowOffset = (dstH - 1 - y) * dstStride;
|
||
memcpy(&dstPixels[dstRowOffset], &srcBase[srcRowOffset], copyBytes);
|
||
}
|
||
|
||
// 拼装 BITMAPINFO(裁剪后只需要 BITMAPINFOHEADER;24/32bpp 不需要调色板)
|
||
BITMAPINFO dstBmi = {};
|
||
dstBmi.bmiHeader = srcHdr;
|
||
dstBmi.bmiHeader.biWidth = dstW;
|
||
dstBmi.bmiHeader.biHeight = dstH;
|
||
dstBmi.bmiHeader.biSizeImage = dstSize;
|
||
dstBmi.bmiHeader.biCompression = BI_RGB;
|
||
|
||
if (WriteBitmap(&dstBmi, dstPixels.data(), path)) {
|
||
m_strSaveNotice = path;
|
||
m_nSaveNoticeTime = GetTickCount64();
|
||
}
|
||
}
|
||
|
||
|
||
BOOL CScreenSpyDlg::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
|
||
{
|
||
// Convert screen coordinates to client coordinates
|
||
ScreenToClient(&pt);
|
||
|
||
// Build MSG structure for SendScaledMouseMessage
|
||
MSG msg = {};
|
||
msg.hwnd = m_hWnd;
|
||
msg.message = WM_MOUSEWHEEL;
|
||
msg.wParam = MAKEWPARAM(nFlags, zDelta);
|
||
msg.lParam = MAKELPARAM(pt.x, pt.y);
|
||
msg.time = GetTickCount();
|
||
msg.pt = { pt.x, pt.y };
|
||
|
||
SendScaledMouseMessage(&msg, true);
|
||
return TRUE; // Message handled, don't pass to parent
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnMouseMove(UINT nFlags, CPoint point)
|
||
{
|
||
// 处理放大功能的鼠标移动
|
||
if (!m_bIsCtrl && !m_bIsFirst && m_BitmapInfor_Full) {
|
||
if (m_bSelectingROI) {
|
||
m_ptROICurrent = point;
|
||
Invalidate(FALSE);
|
||
return;
|
||
}
|
||
if (m_bSelectingZoom) {
|
||
// 框选中:更新当前点并重绘选择框
|
||
m_ptZoomCurrent = point;
|
||
Invalidate(FALSE); // FALSE表示不擦除背景,减少闪烁
|
||
return;
|
||
}
|
||
if (m_bSelectingShot) {
|
||
m_ptShotCurrent = point;
|
||
Invalidate(FALSE);
|
||
return;
|
||
}
|
||
|
||
if (m_bZoomDragging) {
|
||
// 拖拽平移:计算偏移量并移动放大区域
|
||
int dx = point.x - m_ptZoomDragLast.x;
|
||
int dy = point.y - m_ptZoomDragLast.y;
|
||
m_ptZoomDragLast = point; // 更新上一点(保持m_ptZoomDragStart不变用于点击检测)
|
||
|
||
// 计算缩放比例(添加除零保护)
|
||
int srcW = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int srcH = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
int zoomW = m_rcZoomSrc.Width();
|
||
int zoomH = m_rcZoomSrc.Height();
|
||
|
||
if (dstW <= 0 || dstH <= 0 || zoomW <= 0 || zoomH <= 0) {
|
||
return; // 防止除零
|
||
}
|
||
|
||
double scaleX = (double)zoomW / dstW;
|
||
double scaleY = (double)zoomH / dstH;
|
||
|
||
// 将屏幕偏移转换为原图偏移(方向相反)
|
||
int imgDx = (int)(-dx * scaleX);
|
||
int imgDy = (int)(-dy * scaleY);
|
||
|
||
// 移动放大区域
|
||
m_rcZoomSrc.OffsetRect(imgDx, imgDy);
|
||
|
||
// 限制在原图范围内
|
||
if (m_rcZoomSrc.left < 0) {
|
||
m_rcZoomSrc.right -= m_rcZoomSrc.left;
|
||
m_rcZoomSrc.left = 0;
|
||
}
|
||
if (m_rcZoomSrc.top < 0) {
|
||
m_rcZoomSrc.bottom -= m_rcZoomSrc.top;
|
||
m_rcZoomSrc.top = 0;
|
||
}
|
||
if (m_rcZoomSrc.right > srcW) {
|
||
m_rcZoomSrc.left -= (m_rcZoomSrc.right - srcW);
|
||
m_rcZoomSrc.right = srcW;
|
||
}
|
||
if (m_rcZoomSrc.bottom > srcH) {
|
||
m_rcZoomSrc.top -= (m_rcZoomSrc.bottom - srcH);
|
||
m_rcZoomSrc.bottom = srcH;
|
||
}
|
||
|
||
Invalidate(FALSE);
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (m_Settings.RemoteCursor) {
|
||
if (m_pToolbar != NULL && ::IsWindow(m_pToolbar->m_hWnd) && m_pToolbar->IsWindowVisible()) {
|
||
CRect rcToolbar;
|
||
m_pToolbar->GetWindowRect(&rcToolbar);
|
||
ScreenToClient(&rcToolbar); // 转换到主窗口坐标系
|
||
|
||
if (rcToolbar.PtInRect(point)) {
|
||
// 如果鼠标在工具栏区域,直接显示本地光标并返回,不发送远程指令
|
||
::SetCursor(LoadCursor(NULL, IDC_ARROW));
|
||
return;
|
||
}
|
||
}
|
||
if (m_bIsCtrl) {
|
||
// 关键:在控制模式下,强制设置光标为空,隐藏本地物理箭头
|
||
::SetCursor(NULL);
|
||
}
|
||
}
|
||
|
||
__super::OnMouseMove(nFlags, point);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnMouseLeave()
|
||
{
|
||
CWnd::OnMouseLeave();
|
||
}
|
||
|
||
void CScreenSpyDlg::OnKillFocus(CWnd* pNewWnd)
|
||
{
|
||
__super::OnKillFocus(pNewWnd);
|
||
|
||
// 清理远程修饰键状态,防止 Alt/Ctrl/Shift 卡住
|
||
// 场景:用户按住 Alt 后切换窗口,KEYUP 不会发送到远程,导致修饰键卡住
|
||
if (m_bIsCtrl && m_ContextObject) {
|
||
static const WORD modifierKeys[] = { VK_MENU, VK_CONTROL, VK_SHIFT, VK_LWIN, VK_RWIN };
|
||
for (WORD vk : modifierKeys) {
|
||
MYMSG msg;
|
||
memset(&msg, 0, sizeof(msg));
|
||
msg.message = WM_KEYUP;
|
||
msg.wParam = vk;
|
||
msg.lParam = (MapVirtualKey(vk, MAPVK_VK_TO_VSC) << 16) | 0xC0000001; // 扫描码 + 释放标志
|
||
SendCommand(&msg);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnSize(UINT nType, int cx, int cy)
|
||
{
|
||
__super::OnSize(nType, cx, cy);
|
||
|
||
// TODO: Add your message handler code here
|
||
if (!IsWindowVisible())
|
||
return;
|
||
|
||
GetClientRect(&m_CRect);
|
||
if (!m_BitmapInfor_Full) return;
|
||
if (m_bAdaptiveSize) {
|
||
int renderW, renderH;
|
||
ComputeAdaptiveLayout(m_BitmapInfor_Full->bmiHeader.biWidth, m_BitmapInfor_Full->bmiHeader.biHeight,
|
||
m_CRect.Width(), m_CRect.Height(),
|
||
renderW, renderH, m_offsetX, m_offsetY,
|
||
m_wZoom, m_hZoom);
|
||
} else {
|
||
m_offsetX = m_offsetY = 0;
|
||
m_wZoom = m_CRect.Width() > 0 ? (double)m_BitmapInfor_Full->bmiHeader.biWidth / m_CRect.Width() : 1.0;
|
||
m_hZoom = m_CRect.Height() > 0 ? (double)m_BitmapInfor_Full->bmiHeader.biHeight / m_CRect.Height() : 1.0;
|
||
}
|
||
|
||
// 尺寸变化后必须主动请求重绘。系统只在客户区"变大"时给出整块无效区;
|
||
// 最大化后还原(客户区变小)不会产生任何无效区,而本对话框显示首帧后
|
||
// OnEraseBkgnd 不再擦背景,也没有周期性重绘定时器,唯一的另一个重绘源
|
||
// 是远端画面变化(DrawNextScreenDiff -> WM_PAINT)。少了这句,还原后
|
||
// 会保留最大化尺寸的画面(被裁切、不跟随窗口),直到远端画面发生变化。
|
||
if (cx > 0 && cy > 0)
|
||
InvalidateRect(NULL, FALSE);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized)
|
||
{
|
||
CDialogBase::OnActivate(nState, pWndOther, bMinimized);
|
||
|
||
CWnd* pMain = AfxGetMainWnd();
|
||
if (!pMain)
|
||
return;
|
||
|
||
if (nState != WA_INACTIVE) {
|
||
// 通知主窗口:远程窗口获得焦点
|
||
::PostMessage(pMain->GetSafeHwnd(), WM_SESSION_ACTIVATED, (WPARAM)this, 0);
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::UpdateCtrlStatus(BOOL ctrl)
|
||
{
|
||
m_bIsCtrl = ctrl;
|
||
m_bIsTraceCursor = !m_bIsCtrl;
|
||
// 进入控制模式时重置放大状态 + 中止任何正在进行的右键截图/ROI框选
|
||
if (m_bIsCtrl) {
|
||
if (m_bZoomedIn) ResetZoom();
|
||
if (m_bSelectingShot) {
|
||
m_bSelectingShot = false;
|
||
if (GetCapture() == this) ReleaseCapture();
|
||
Invalidate(FALSE);
|
||
}
|
||
if (m_bROIArmed || m_bSelectingROI) {
|
||
m_bROIArmed = false;
|
||
m_bSelectingROI = false;
|
||
if (GetCapture() == this) ReleaseCapture();
|
||
if (m_pToolbar) m_pToolbar->UpdateButtonIcons();
|
||
Invalidate(FALSE);
|
||
}
|
||
}
|
||
// 控制模式:禁用本地 IME;查看模式:启用本地 IME
|
||
ImmAssociateContext(m_hWnd, m_bIsCtrl ? NULL : m_hOldIMC);
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
if (SysMenu) {
|
||
SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::OnCaptureChanged(CWnd* pWnd)
|
||
{
|
||
// 捕获丢失时重置框选/拖拽状态
|
||
if (m_bSelectingZoom || m_bZoomDragging || m_bSelectingShot || m_bSelectingROI) {
|
||
m_bSelectingZoom = false;
|
||
m_bZoomDragging = false;
|
||
m_bSelectingShot = false;
|
||
if (m_bSelectingROI) {
|
||
m_bSelectingROI = false;
|
||
m_bROIArmed = true; // 保留待选状态,让用户可以重试
|
||
}
|
||
Invalidate();
|
||
}
|
||
__super::OnCaptureChanged(pWnd);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnDropFiles(HDROP hDropInfo)
|
||
{
|
||
if (m_bIsCtrl && m_bConnected) {
|
||
UINT nFiles = DragQueryFile(hDropInfo, 0xFFFFFFFF, NULL, 0);
|
||
std::vector<std::string> list;
|
||
for (UINT i = 0; i < nFiles; i++) {
|
||
TCHAR szPath[MAX_PATH];
|
||
DragQueryFile(hDropInfo, i, szPath, MAX_PATH);
|
||
list.push_back(szPath);
|
||
}
|
||
std::string GetPwdHash();
|
||
std::string GetHMAC(int offset);
|
||
auto files = PreprocessFilesSimple(list);
|
||
|
||
// 检查客户端是否支持 V2
|
||
uint64_t clientID = GetClientID();
|
||
context* mainCtx = m_pParent->FindHost(clientID);
|
||
|
||
if (mainCtx && SupportsFileTransferV2(mainCtx)) {
|
||
// V2 传输
|
||
m_pParent->SendFilesToClientV2(mainCtx, files);
|
||
Mprintf("【拖拽】 [本地 -> 远程] V2 传输: %zu 个文件\n", files.size());
|
||
} else {
|
||
// V1 传输(兼容旧客户端)
|
||
auto str = BuildMultiStringPath(files);
|
||
BYTE* szBuffer = new BYTE[1 + 80 + str.size()];
|
||
szBuffer[0] = { COMMAND_GET_FOLDER };
|
||
std::string masterId = GetPwdHash(), hmac = GetHMAC(100);
|
||
memcpy((char*)szBuffer + 1, masterId.c_str(), masterId.length());
|
||
memcpy((char*)szBuffer + 1 + masterId.length(), hmac.c_str(), hmac.length());
|
||
memcpy(szBuffer + 1 + 80, str.data(), str.size());
|
||
auto md5 = CalcMD5FromBytes((BYTE*)str.data(), str.size());
|
||
m_pParent->m_CmdList.PutCmd(md5, m_ContextObject->GetPeerName());
|
||
m_ContextObject->Send2Client(szBuffer, 81 + str.size());
|
||
Mprintf("【拖拽】 [本地 -> 远程] V1 传输: %s\n", md5.c_str());
|
||
SAFE_DELETE_ARRAY(szBuffer);
|
||
}
|
||
}
|
||
|
||
DragFinish(hDropInfo);
|
||
|
||
CDialogBase::OnDropFiles(hDropInfo);
|
||
}
|
||
|
||
// ========== 音频播放实现 ==========
|
||
|
||
void CScreenSpyDlg::SendAudioCtrl(BYTE enable, BYTE persist)
|
||
{
|
||
AudioCtrlCmd cmd;
|
||
cmd.cmd = CMD_AUDIO_CTRL;
|
||
cmd.enable = enable;
|
||
cmd.persist = persist;
|
||
m_ContextObject->Send2Client((LPBYTE)&cmd, sizeof(cmd));
|
||
Mprintf("[ScreenSpy] 发送音频控制: enable=%d, persist=%d\n", enable, persist);
|
||
}
|
||
|
||
#if USING_OPUS
|
||
#include "../../compress/opus/opus_wrapper.h"
|
||
#endif
|
||
|
||
BOOL CScreenSpyDlg::InitAudioPlaybackLocked(const AudioFormat* fmt)
|
||
{
|
||
if (m_bAudioPlaying) return TRUE;
|
||
m_nLastAudioInitTick = GetTickCount64();
|
||
|
||
// 保存压缩类型
|
||
m_nAudioCompression = fmt->compression;
|
||
|
||
// 设置波形格式 (waveOut 始终使用 PCM)
|
||
memset(&m_AudioFormat, 0, sizeof(m_AudioFormat));
|
||
m_AudioFormat.wFormatTag = WAVE_FORMAT_PCM;
|
||
m_AudioFormat.nChannels = fmt->channels;
|
||
m_AudioFormat.nSamplesPerSec = fmt->sampleRate;
|
||
m_AudioFormat.wBitsPerSample = fmt->bitsPerSample;
|
||
m_AudioFormat.nBlockAlign = fmt->blockAlign;
|
||
m_AudioFormat.nAvgBytesPerSec = fmt->sampleRate * fmt->blockAlign;
|
||
m_AudioFormat.cbSize = 0;
|
||
|
||
// 打开波形输出设备 (使用 CALLBACK_WINDOW 接收播放完成通知)
|
||
MMRESULT result = waveOutOpen(&m_hWaveOut, WAVE_MAPPER, &m_AudioFormat,
|
||
(DWORD_PTR)m_hWnd, 0, CALLBACK_WINDOW);
|
||
if (result != MMSYSERR_NOERROR) {
|
||
// 主控没有输出设备时会每 2 秒重试一次,日志按分钟节流,避免刷屏
|
||
ULONGLONG now = GetTickCount64();
|
||
if (now - m_nLastAudioErrLog >= 60000) {
|
||
m_nLastAudioErrLog = now;
|
||
Mprintf("[ScreenSpy] waveOutOpen 失败: %d\n", result);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
// 分配 waveOut 缓冲区
|
||
BOOL prepareFailed = FALSE;
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT && !prepareFailed; i++) {
|
||
m_pAudioBuf[i] = new BYTE[AUDIO_BUF_SIZE];
|
||
memset(&m_WaveHdr[i], 0, sizeof(WAVEHDR));
|
||
m_WaveHdr[i].lpData = (LPSTR)m_pAudioBuf[i];
|
||
m_WaveHdr[i].dwBufferLength = AUDIO_BUF_SIZE;
|
||
if (waveOutPrepareHeader(m_hWaveOut, &m_WaveHdr[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR) {
|
||
prepareFailed = TRUE;
|
||
}
|
||
}
|
||
if (prepareFailed) {
|
||
// 准备失败的句柄之后每次 waveOutWrite 都会失败,重建也救不回来,
|
||
// 只会在 UI 线程上反复开关设备。这里直接放弃,交给 2 秒重试。
|
||
Mprintf("[ScreenSpy] waveOutPrepareHeader 失败,关闭设备稍后重试\n");
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT; i++) {
|
||
if (m_pAudioBuf[i] && (m_WaveHdr[i].dwFlags & WHDR_PREPARED)) {
|
||
waveOutUnprepareHeader(m_hWaveOut, &m_WaveHdr[i], sizeof(WAVEHDR));
|
||
}
|
||
delete[] m_pAudioBuf[i];
|
||
m_pAudioBuf[i] = nullptr;
|
||
}
|
||
waveOutClose(m_hWaveOut);
|
||
m_hWaveOut = NULL;
|
||
return FALSE;
|
||
}
|
||
|
||
// 分配环形缓冲区
|
||
m_pRingBuf = new BYTE[RING_BUF_SIZE];
|
||
m_nRingHead = m_nRingTail = m_nRingDataLen = 0;
|
||
m_nPrebufferCount = 0;
|
||
|
||
#if USING_OPUS
|
||
// 初始化 Opus 解码器
|
||
if (m_nAudioCompression == AUDIO_COMPRESS_OPUS) {
|
||
COpusDecoder* pDecoder = new COpusDecoder();
|
||
if (pDecoder->Init(fmt->sampleRate, fmt->channels)) {
|
||
m_pOpusDecoder = pDecoder;
|
||
m_pOpusDecodeBuffer = new short[960 * 2 * 2]; // 最大 960 samples * 2 channels * 2 (安全余量)
|
||
Mprintf("[ScreenSpy] Opus 解码器初始化成功\n");
|
||
} else {
|
||
delete pDecoder;
|
||
Mprintf("[ScreenSpy] Opus 解码器初始化失败\n");
|
||
}
|
||
}
|
||
#endif
|
||
|
||
m_nAudioBufIndex = 0;
|
||
m_bAudioPlaying = TRUE;
|
||
Mprintf("[ScreenSpy] 音频播放已初始化: %d Hz, %d ch, %d bit, 压缩=%d\n",
|
||
fmt->sampleRate, fmt->channels, fmt->bitsPerSample, fmt->compression);
|
||
return TRUE;
|
||
}
|
||
|
||
void CScreenSpyDlg::StopAudioPlayback()
|
||
{
|
||
std::lock_guard<std::recursive_mutex> lock(m_AudioMutex);
|
||
StopAudioPlaybackLocked();
|
||
}
|
||
|
||
void CScreenSpyDlg::StopAudioPlaybackLocked()
|
||
{
|
||
// 作废排队中的重建请求,避免停用后又被拉起来(未播放时也要清)
|
||
m_bAudioInitPending = FALSE;
|
||
if (!m_bAudioPlaying) return;
|
||
|
||
m_bAudioPlaying = FALSE;
|
||
|
||
if (m_hWaveOut) {
|
||
waveOutReset(m_hWaveOut);
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT; i++) {
|
||
if (m_pAudioBuf[i]) {
|
||
waveOutUnprepareHeader(m_hWaveOut, &m_WaveHdr[i], sizeof(WAVEHDR));
|
||
delete[] m_pAudioBuf[i];
|
||
m_pAudioBuf[i] = nullptr;
|
||
}
|
||
}
|
||
waveOutClose(m_hWaveOut);
|
||
m_hWaveOut = NULL;
|
||
}
|
||
|
||
// 清理环形缓冲区
|
||
if (m_pRingBuf) {
|
||
delete[] m_pRingBuf;
|
||
m_pRingBuf = nullptr;
|
||
}
|
||
m_nRingHead = m_nRingTail = m_nRingDataLen = 0;
|
||
m_nPrebufferCount = 0;
|
||
|
||
#if USING_OPUS
|
||
// 清理 Opus 解码器
|
||
if (m_pOpusDecoder) {
|
||
delete (COpusDecoder*)m_pOpusDecoder;
|
||
m_pOpusDecoder = nullptr;
|
||
}
|
||
if (m_pOpusDecodeBuffer) {
|
||
delete[] m_pOpusDecodeBuffer;
|
||
m_pOpusDecodeBuffer = nullptr;
|
||
}
|
||
#endif
|
||
m_nAudioCompression = 0;
|
||
|
||
// 重置网页端音频格式标志(线程安全的清理)
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_AudioWebMutex);
|
||
m_bAudioFormatSent = FALSE;
|
||
memset(&m_AudioFormatWeb, 0, sizeof(m_AudioFormatWeb));
|
||
}
|
||
|
||
Mprintf("[ScreenSpy] 音频播放已停止\n");
|
||
}
|
||
|
||
void CScreenSpyDlg::DisableAudio()
|
||
{
|
||
// 复用 IDM_AUDIO_TOGGLE 的逻辑,但仅禁用
|
||
if (m_Settings.AudioEnabled) {
|
||
m_Settings.AudioEnabled = FALSE;
|
||
SendAudioCtrl(CYCLEAUDIO_DISABLE, 1);
|
||
StopAudioPlayback();
|
||
|
||
// 清理网页端格式状态(在 mutex 保护下)
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_AudioWebMutex);
|
||
m_bAudioFormatSent = FALSE;
|
||
memset(&m_AudioFormatWeb, 0, sizeof(m_AudioFormatWeb));
|
||
}
|
||
|
||
Mprintf("[Audio Web] 禁用音频(来自 web 命令)\n");
|
||
|
||
// 广播状态给所有正在观看本设备的 web 客户端
|
||
if (WebService().IsRunning()) {
|
||
WebService().NotifyAudioState(m_ClientID, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::EnableAudio()
|
||
{
|
||
// 复用 IDM_AUDIO_TOGGLE 的逻辑,但仅启用
|
||
if (!m_Settings.AudioEnabled) {
|
||
m_Settings.AudioEnabled = TRUE;
|
||
SendAudioCtrl(CYCLEAUDIO_ENABLE, 1);
|
||
|
||
// 强制重新发送格式信息(清理缓存)
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_AudioWebMutex);
|
||
m_bAudioFormatSent = FALSE;
|
||
memset(&m_AudioFormatWeb, 0, sizeof(m_AudioFormatWeb));
|
||
}
|
||
|
||
Mprintf("[Audio Web] 启用音频(来自 web 命令)\n");
|
||
|
||
if (WebService().IsRunning()) {
|
||
WebService().NotifyAudioState(m_ClientID, true);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 由 PostMessage 从 WS 线程派发到 UI 线程;根据当前状态翻转
|
||
LRESULT CScreenSpyDlg::OnAudioToggleFromWeb(WPARAM /*wParam*/, LPARAM /*lParam*/)
|
||
{
|
||
if (m_Settings.AudioEnabled) {
|
||
DisableAudio();
|
||
} else {
|
||
EnableAudio();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void CScreenSpyDlg::OnAudioData(BYTE* pData, UINT32 len)
|
||
{
|
||
if (len < 1) return;
|
||
|
||
// 包计数(仅用于调试,可移除)
|
||
// static int s_audioPacketCount = 0;
|
||
// if (++s_audioPacketCount <= 5 || s_audioPacketCount % 500 == 0) {
|
||
// Mprintf("[Audio] 收到音频包 #%d, len=%u\n", s_audioPacketCount, len);
|
||
// }
|
||
|
||
BYTE hasFormat = pData[0];
|
||
UINT32 offset = 1;
|
||
|
||
// 串行化:本函数在 IOCP worker 线程执行,OnWaveOutDone 在 UI 线程执行,
|
||
// 两者都会改写环形缓冲区与 WAVEHDR(详见 m_AudioMutex 的注释)。
|
||
// 网页转发在锁外做:SendAudioToWeb 是阻塞 socket 写,不能压在 m_AudioMutex 上。
|
||
BYTE* pWireData = nullptr;
|
||
UINT32 wireLen = 0;
|
||
WAVEFORMATEX fmtForWeb = {};
|
||
BYTE compForWeb = 0;
|
||
std::unique_lock<std::recursive_mutex> lock(m_AudioMutex);
|
||
|
||
// 如果带有格式信息,记录格式并请求 UI 线程打开/重建播放设备
|
||
if (hasFormat && len >= 1 + sizeof(AudioFormat)) {
|
||
AudioFormat* fmt = (AudioFormat*)(pData + 1);
|
||
BOOL formatChanged = !m_bHasAudioFormat ||
|
||
memcmp(fmt, &m_LastAudioFormat, sizeof(AudioFormat)) != 0;
|
||
m_LastAudioFormat = *fmt;
|
||
m_bHasAudioFormat = TRUE;
|
||
offset = 1 + sizeof(AudioFormat);
|
||
|
||
// 设备的打开/重建一律交给 UI 线程(见 OnAudioInitDevice 的说明)
|
||
if (formatChanged && m_bAudioPlaying) {
|
||
Mprintf("[Audio] 音频格式变化,重建播放设备\n");
|
||
}
|
||
if (formatChanged || !m_bAudioPlaying) {
|
||
RequestAudioRebuildLocked();
|
||
}
|
||
|
||
// 检测到音频数据,更新菜单状态
|
||
if (!m_Settings.AudioEnabled) {
|
||
m_Settings.AudioEnabled = TRUE;
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
if (SysMenu) {
|
||
SysMenu->CheckMenuItem(IDM_AUDIO_TOGGLE, MF_CHECKED);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 格式包丢失:客户端的音频线程在子连接建立时就开始跑,带格式的首包常常比
|
||
// TOKEN_BITMAPINFO 先到 —— 那时远程桌面对话框还没创建,主窗口把这批包当未知命令
|
||
// 丢掉(见 CMy2015RemoteDlg::MessageHandle 的 default 分支)。没有格式就开不了设备,
|
||
// 客户端又只在「关→开」时才重发格式,于是整场会话无声,直到用户手动拨一次音频开关。
|
||
// 这里借后续数据包主动请客户端重发格式:enable + persist=0,只唤醒音频线程、
|
||
// 不改客户端配置。次数封顶,老客户端不认这个请求时不会无限发。
|
||
// 触发点是「已经路由到本对话框的包」,所以对话框必然已就绪,不存在再次丢包的窗口。
|
||
if (!m_bHasAudioFormat && m_Settings.AudioEnabled &&
|
||
m_nAudioFmtReqCount < 15 &&
|
||
GetTickCount64() - m_nLastAudioFmtReqTick >= 2000) {
|
||
m_nLastAudioFmtReqTick = GetTickCount64();
|
||
m_nAudioFmtReqCount++;
|
||
SendAudioCtrl(CYCLEAUDIO_ENABLE, 0);
|
||
Mprintf("[Audio] 未收到音频格式包,请求客户端重发 (%d)\n", m_nAudioFmtReqCount);
|
||
}
|
||
|
||
// 播放设备未就绪:首包格式包丢失、或 waveOutOpen 因设备休眠/被独占而一时失败。
|
||
// 有缓存格式就定期请 UI 线程重试,否则整场会话无声,只能关掉重开远程桌面。
|
||
// 只在音频处于启用状态时重试,避免用户关掉后又被残留包拉起来。
|
||
if (!m_bAudioPlaying) {
|
||
if (m_Settings.AudioEnabled && m_bHasAudioFormat &&
|
||
GetTickCount64() - m_nLastAudioInitTick >= 2000) {
|
||
RequestAudioRebuildLocked();
|
||
}
|
||
return;
|
||
}
|
||
// 设备即将重建:旧格式的数据丢掉,等 UI 线程把新设备开好
|
||
if (m_bAudioInitPending) return;
|
||
if (!m_hWaveOut || !m_pRingBuf) return;
|
||
|
||
// 获取音频数据
|
||
BYTE* pAudioData = pData + offset;
|
||
UINT32 audioLen = len - offset;
|
||
if (audioLen == 0) return;
|
||
|
||
// 保存"上线格式"字节(Opus 模式下是原始压缩包,PCM 模式下是原始 PCM)。
|
||
// 这就是要透传给 web 的数据 —— web 端用 MSE+WebM 直接播 Opus,
|
||
// 不需要服务器解码后再发 PCM。本地 waveOut 仍然需要 PCM,因此下面
|
||
// 还是会解码一遍。
|
||
pWireData = pAudioData;
|
||
wireLen = audioLen;
|
||
compForWeb = (BYTE)m_nAudioCompression;
|
||
|
||
// 帧对齐参数
|
||
DWORD blockAlign = m_AudioFormat.nBlockAlign;
|
||
if (blockAlign == 0) blockAlign = 4; // 默认 stereo 16-bit
|
||
|
||
#if USING_OPUS
|
||
// Opus 解码(仅供本地 waveOut 使用;web 仍会收到原始压缩包)
|
||
if (m_nAudioCompression == AUDIO_COMPRESS_OPUS && m_pOpusDecoder && m_pOpusDecodeBuffer) {
|
||
COpusDecoder* pDecoder = (COpusDecoder*)m_pOpusDecoder;
|
||
int decodedSamples = pDecoder->Decode(pAudioData, audioLen, m_pOpusDecodeBuffer, 960 * 2);
|
||
if (decodedSamples > 0) {
|
||
pAudioData = (BYTE*)m_pOpusDecodeBuffer;
|
||
audioLen = decodedSamples * m_AudioFormat.nChannels * sizeof(short);
|
||
} else {
|
||
return; // 解码失败,丢弃此包
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// 帧对齐:确保数据量是 blockAlign 的整数倍
|
||
audioLen = (audioLen / blockAlign) * blockAlign;
|
||
if (audioLen == 0) return;
|
||
|
||
// 检查环形缓冲区是否有足够空间
|
||
SanitizeRingBufferLocked();
|
||
DWORD freeSpace = RING_BUF_SIZE - m_nRingDataLen;
|
||
if (audioLen > freeSpace) {
|
||
// 缓冲区满了,丢弃新数据(避免打断正在播放的音频)
|
||
audioLen = (freeSpace / blockAlign) * blockAlign;
|
||
if (audioLen == 0) return;
|
||
}
|
||
|
||
// 写入数据(可能需要分两次写入,处理环绕)
|
||
DWORD firstPart = min(audioLen, RING_BUF_SIZE - m_nRingHead);
|
||
memcpy(m_pRingBuf + m_nRingHead, pAudioData, firstPart);
|
||
if (audioLen > firstPart) {
|
||
memcpy(m_pRingBuf, pAudioData + firstPart, audioLen - firstPart);
|
||
}
|
||
m_nRingHead = (m_nRingHead + audioLen) % RING_BUF_SIZE;
|
||
m_nRingDataLen += audioLen;
|
||
|
||
// 预缓冲:等待积累足够数据再开始播放
|
||
if (m_nPrebufferCount < PREBUFFER_TARGET) {
|
||
m_nPrebufferCount++;
|
||
if (m_nPrebufferCount < PREBUFFER_TARGET) {
|
||
return; // 还没积累够,等待
|
||
}
|
||
Mprintf("[Audio] 预缓冲完成,开始播放 (缓冲: %u bytes)\n", m_nRingDataLen);
|
||
}
|
||
|
||
// 填充可用的 waveOut 缓冲区(已持有 m_AudioMutex)
|
||
fmtForWeb = m_AudioFormat;
|
||
FeedAudioBuffersLocked();
|
||
lock.unlock();
|
||
|
||
// 发送上线格式(Opus 压缩包 / 或原始 PCM)到网页。
|
||
// 放在锁外:SendAudioToWeb 内部是阻塞 socket 写,慢客户端会卡住锁持有者。
|
||
SendAudioToWeb(pWireData, wireLen, &fmtForWeb, compForWeb);
|
||
}
|
||
|
||
void CScreenSpyDlg::SendAudioToWeb(const BYTE* pAudioData, UINT32 len, const WAVEFORMATEX* pFormat, BYTE compression)
|
||
{
|
||
if (!WebService().IsRunning()) return;
|
||
if (!pAudioData || len == 0) return;
|
||
if (!m_ContextObject) return;
|
||
if (!m_Settings.AudioEnabled) return;
|
||
|
||
std::vector<BYTE> packet;
|
||
BOOL formatChanged = FALSE;
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_AudioWebMutex);
|
||
|
||
if (!m_bAudioFormatSent) {
|
||
formatChanged = TRUE;
|
||
} else if (pFormat && (
|
||
pFormat->nChannels != m_AudioFormatWeb.channels ||
|
||
pFormat->nSamplesPerSec != m_AudioFormatWeb.sampleRate ||
|
||
pFormat->wBitsPerSample != m_AudioFormatWeb.bitsPerSample ||
|
||
compression != m_AudioFormatWeb.compression)) {
|
||
formatChanged = TRUE;
|
||
}
|
||
|
||
// 第1字节:是否包含格式信息
|
||
packet.push_back(formatChanged ? 1 : 0);
|
||
|
||
if (formatChanged && pFormat) {
|
||
if (pFormat->nChannels < 1 || pFormat->nChannels > 8 ||
|
||
pFormat->nSamplesPerSec < 8000 || pFormat->nSamplesPerSec > 48000 ||
|
||
pFormat->wBitsPerSample != 16) {
|
||
Mprintf("[Audio Web] Invalid format: ch=%d, sr=%d, bps=%d\n",
|
||
pFormat->nChannels, pFormat->nSamplesPerSec, pFormat->wBitsPerSample);
|
||
return;
|
||
}
|
||
|
||
// 12-byte AudioFormat 结构(commands.h, pack(1))
|
||
AudioFormat fmt;
|
||
fmt.channels = (WORD)pFormat->nChannels;
|
||
fmt.sampleRate = (DWORD)pFormat->nSamplesPerSec;
|
||
fmt.bitsPerSample = (WORD)pFormat->wBitsPerSample;
|
||
// blockAlign 对 Opus 是 informational 的(包是变长压缩),按 PCM 推算填上即可。
|
||
fmt.blockAlign = (WORD)(fmt.channels * fmt.bitsPerSample / 8);
|
||
fmt.compression = compression;
|
||
fmt.reserved = 0;
|
||
|
||
BYTE* pFmt = (BYTE*)&fmt;
|
||
packet.insert(packet.end(), pFmt, pFmt + sizeof(fmt));
|
||
// padding byte: 保持后续音频数据落在偶数偏移上(PCM 模式下 web 端
|
||
// 需要 Int16 对齐;Opus 模式无所谓但保留兼容旧 web 解析)
|
||
packet.push_back(0);
|
||
|
||
m_AudioFormatWeb = fmt;
|
||
m_bAudioFormatSent = TRUE;
|
||
|
||
Mprintf("[Audio Web] Format sent: ch=%d, sr=%d Hz, compression=%d\n",
|
||
fmt.channels, fmt.sampleRate, fmt.compression);
|
||
}
|
||
} // 释放 mutex
|
||
|
||
// 添加音频数据(此操作不需要 mutex,因为我们已经复制了所有需要的共享状态)
|
||
packet.insert(packet.end(), pAudioData, pAudioData + len);
|
||
|
||
// 构造完整帧:[DeviceID:4][FrameType:1][DataLen:4][audio payload...]
|
||
// FrameType: 96 = TOKEN_SCREEN_AUDIO,用于在网页端识别音频
|
||
std::vector<BYTE> frame;
|
||
|
||
uint64_t deviceID = GetClientID();
|
||
uint32_t audioDataLen = (uint32_t)packet.size();
|
||
uint8_t frameType = 96; // TOKEN_SCREEN_AUDIO
|
||
|
||
// [DeviceID:4] little-endian
|
||
frame.push_back((BYTE)(deviceID & 0xFF));
|
||
frame.push_back((BYTE)((deviceID >> 8) & 0xFF));
|
||
frame.push_back((BYTE)((deviceID >> 16) & 0xFF));
|
||
frame.push_back((BYTE)((deviceID >> 24) & 0xFF));
|
||
|
||
// [FrameType:1]
|
||
frame.push_back(frameType);
|
||
|
||
// [DataLen:4] little-endian
|
||
frame.push_back((BYTE)(audioDataLen & 0xFF));
|
||
frame.push_back((BYTE)((audioDataLen >> 8) & 0xFF));
|
||
frame.push_back((BYTE)((audioDataLen >> 16) & 0xFF));
|
||
frame.push_back((BYTE)((audioDataLen >> 24) & 0xFF));
|
||
|
||
// [audio payload]
|
||
frame.insert(frame.end(), packet.begin(), packet.end());
|
||
|
||
// 广播到所有网页客户端
|
||
WebService().BroadcastH264Frame(deviceID, frame.data(), frame.size());
|
||
}
|
||
|
||
void CScreenSpyDlg::FeedAudioBuffersLocked()
|
||
{
|
||
if (!m_bAudioPlaying || m_bAudioInitPending || !m_hWaveOut || !m_pRingBuf) return;
|
||
|
||
// 防御:旧版本的数据竞争可能让计数下溢,此时缓冲"永远有数据",会一直播陈旧内容
|
||
SanitizeRingBufferLocked();
|
||
|
||
// 帧对齐参数
|
||
DWORD blockAlign = m_AudioFormat.nBlockAlign;
|
||
if (blockAlign == 0) blockAlign = 4; // 默认 stereo 16-bit
|
||
|
||
// 尽可能填满所有空闲的 waveOut 缓冲区
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT; i++) {
|
||
int bufIdx = (m_nAudioBufIndex + i) % AUDIO_BUFFER_COUNT;
|
||
WAVEHDR* pHdr = &m_WaveHdr[bufIdx];
|
||
|
||
// 如果缓冲区正在使用,跳过
|
||
if (pHdr->dwFlags & WHDR_INQUEUE) continue;
|
||
|
||
// 检查环形缓冲区是否有足够数据(至少一帧)
|
||
if (m_nRingDataLen < blockAlign) break;
|
||
|
||
// 计算要读取的数据量(对齐到帧边界)
|
||
DWORD readLen = min(m_nRingDataLen, (DWORD)AUDIO_BUF_SIZE);
|
||
readLen = (readLen / blockAlign) * blockAlign; // 截断到帧边界
|
||
if (readLen == 0) break;
|
||
|
||
// 从环形缓冲区读取(可能需要分两次读取,处理环绕)
|
||
DWORD firstPart = min(readLen, RING_BUF_SIZE - m_nRingTail);
|
||
memcpy(m_pAudioBuf[bufIdx], m_pRingBuf + m_nRingTail, firstPart);
|
||
if (readLen > firstPart) {
|
||
memcpy(m_pAudioBuf[bufIdx] + firstPart, m_pRingBuf, readLen - firstPart);
|
||
}
|
||
m_nRingTail = (m_nRingTail + readLen) % RING_BUF_SIZE;
|
||
m_nRingDataLen -= readLen;
|
||
|
||
// 播放
|
||
pHdr->dwBufferLength = readLen;
|
||
MMRESULT mr = waveOutWrite(m_hWaveOut, pHdr, sizeof(WAVEHDR));
|
||
if (mr != MMSYSERR_NOERROR) {
|
||
// 旧代码只打印后继续用同一个句柄写:设备休眠/被移除后句柄永久失效,
|
||
// 整场会话再无声音,只能关掉重开远程桌面。现在请 UI 线程重建播放设备
|
||
// (worker 线程持锁调用 waveOutReset/Close 会和 UI 线程互相等死)。
|
||
// 重建按 2 秒节流:句柄彻底坏掉时每次写都会失败,不节流就会每 20ms
|
||
// 开关一次设备,把 UI 线程拖死。
|
||
ULONGLONG now = GetTickCount64();
|
||
if (now - m_nLastAudioErrLog >= 60000) {
|
||
m_nLastAudioErrLog = now;
|
||
Mprintf("[Audio] waveOutWrite 失败: %d,稍后重建播放设备\n", mr);
|
||
}
|
||
if (now - m_nLastAudioInitTick >= 2000) {
|
||
RequestAudioRebuildLocked();
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 更新下一个缓冲区索引(找到第一个空闲的)
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT; i++) {
|
||
if (!(m_WaveHdr[m_nAudioBufIndex].dwFlags & WHDR_INQUEUE)) break;
|
||
m_nAudioBufIndex = (m_nAudioBufIndex + 1) % AUDIO_BUFFER_COUNT;
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::RequestAudioRebuildLocked()
|
||
{
|
||
if (m_bAudioInitPending) return;
|
||
m_bAudioInitPending = TRUE;
|
||
// 对话框销毁过程中 PostMessage 会失败。不把这个标志回滚,后面每个音频包都会
|
||
// 在 `if (m_bAudioInitPending)` 处被丢弃,本场会话再无声音,也没有重试机会。
|
||
if (!PostMessage(WM_AUDIO_INIT_DEVICE)) {
|
||
m_bAudioInitPending = FALSE;
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::SanitizeRingBufferLocked()
|
||
{
|
||
if (m_nRingDataLen > RING_BUF_SIZE) {
|
||
Mprintf("[Audio] 环形缓冲计数异常(%u),重置\n", m_nRingDataLen);
|
||
m_nRingHead = m_nRingTail = m_nRingDataLen = 0;
|
||
m_nPrebufferCount = 0;
|
||
}
|
||
}
|
||
|
||
LRESULT CScreenSpyDlg::OnAudioInitDevice(WPARAM, LPARAM)
|
||
{
|
||
// waveOutOpen/Reset/Close 会同步派发 MM_WOM_* 到本窗口,必须在窗口所属线程执行:
|
||
// 若由 worker 线程持着 m_AudioMutex 调用,而 UI 线程恰好正等这把锁(例如用户
|
||
// 手动关音频),两边互等就是硬死锁。因此 worker 线程只登记请求 + PostMessage,
|
||
// 真正的开关设备都在这里做。
|
||
std::lock_guard<std::recursive_mutex> lock(m_AudioMutex);
|
||
if (!m_bAudioInitPending) return 0; // 已被 Stop/其它路径作废
|
||
m_bAudioInitPending = FALSE;
|
||
if (!m_bHasAudioFormat) return 0;
|
||
|
||
if (m_bAudioPlaying) {
|
||
StopAudioPlaybackLocked();
|
||
}
|
||
InitAudioPlaybackLocked(&m_LastAudioFormat);
|
||
return 0;
|
||
}
|
||
|
||
LRESULT CScreenSpyDlg::OnPowerResume(WPARAM wParam, LPARAM wParamUnused)
|
||
{
|
||
// 系统休眠(现代待机)时音频端点会被拆除再重建。waveOut 句柄有时既不派发
|
||
// MM_WOM_CLOSE、waveOutWrite 也照样返回成功,声音却已经没有了 —— 表现为
|
||
// 「闲置一段时间后再放声音没声音,只能重开远程桌面」。恢复后主动重建一次,
|
||
// 打开失败也没关系:m_bAudioPlaying 保持 FALSE,OnAudioData 会每 2 秒重试。
|
||
if (wParam != PBT_APMRESUMEAUTOMATIC && wParam != PBT_APMRESUMESUSPEND) {
|
||
return TRUE;
|
||
}
|
||
|
||
std::lock_guard<std::recursive_mutex> lock(m_AudioMutex);
|
||
if (!m_bHasAudioFormat || !m_Settings.AudioEnabled) return TRUE;
|
||
|
||
Mprintf("[Audio] 系统从休眠恢复,重建播放设备\n");
|
||
if (m_bAudioPlaying) {
|
||
StopAudioPlaybackLocked();
|
||
}
|
||
InitAudioPlaybackLocked(&m_LastAudioFormat);
|
||
return TRUE;
|
||
}
|
||
|
||
LRESULT CScreenSpyDlg::OnWaveOutClose(WPARAM wParam, LPARAM wParamUnused)
|
||
{
|
||
// 设备被移除/切换(显示器休眠、默认输出端点变化等)时,系统会关闭 waveOut 句柄
|
||
// 并派发 MM_WOM_CLOSE。旧代码忽略该消息:句柄失效后 waveOutWrite 可能仍返回成功,
|
||
// 整场会话就是无声的,只能关掉重开远程桌面。这里按新默认设备重建。
|
||
std::lock_guard<std::recursive_mutex> lock(m_AudioMutex);
|
||
|
||
// 只处理当前句柄的通知;自身 Stop/重开过程中产生的陈旧通知(wParam 是旧句柄)忽略
|
||
if (!m_bAudioPlaying || (HWAVEOUT)wParam != m_hWaveOut) return 0;
|
||
|
||
// 自己 waveOutClose 时的 MM_WOM_CLOSE 是异步投递的,可能在我们重开设备之后才到达;
|
||
// 若 winmm 复用了同一个句柄值,就会和真实设备移除无法区分,进而无限「关-开」循环。
|
||
// 刚打开的设备不会立刻被系统移除,忽略这个时间窗内的通知。
|
||
if (GetTickCount64() - m_nLastAudioInitTick < 1000) return 0;
|
||
|
||
Mprintf("[Audio] 音频设备已关闭(设备移除/切换),重建播放设备\n");
|
||
StopAudioPlaybackLocked();
|
||
if (m_bHasAudioFormat) {
|
||
InitAudioPlaybackLocked(&m_LastAudioFormat);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
LRESULT CScreenSpyDlg::OnWaveOutDone(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
// 注意:waveOutReset/waveOutClose 可能在调用线程里同步派发 MM_WOM_DONE。
|
||
// m_AudioMutex 是递归锁,这里重入是合法的;Stop 已经把 m_bAudioPlaying 置 FALSE,
|
||
// 所以重入时会直接跳过填充。
|
||
std::lock_guard<std::recursive_mutex> lock(m_AudioMutex);
|
||
|
||
// waveOut 缓冲区播放完成,尝试填充更多数据
|
||
if (m_bAudioPlaying && m_nRingDataLen > 0) {
|
||
FeedAudioBuffersLocked();
|
||
}
|
||
return 0;
|
||
}
|