Files
SimpleRemoter/server/2015Remote/ScreenSpyDlg.cpp
T
yuanyuanxianganddeepseek-flash 5f40f3726c Fix: React to slow-frame congestion and keep remote audio recoverable
The adaptive quality controller counted only complete frames per second, so when
a single frame took several seconds to arrive the sample was 0 fps and the
throughput criterion abstained forever: Ultra and High kept flipping while a
foreground video played. The audio watchdog had the opposite problem: it rebuilt
the WASAPI capture every three seconds on an idle endpoint, and its sleep
detector measured the whole loop including a blocking send.

Sample the last ten seconds in a ring buffer and feed the criterion a windowed
rate, guarded so a scroll burst, a stale window or a few KB clock patch is not
mistaken for congestion. Apply the same per-frame floor to the one-second
fallback and to the post-downgrade local-bottleneck probe. Normalize delayed
timer ticks by real elapsed milliseconds, and make the 40 second
upgrade-failure window outlast the resolution cooldown it has to cross.

On the client, rebuild only when an audio session is actually rendering, and
rebuild immediately when the captured endpoint is no longer the default output;
refresh the sleep timestamps on failed as well as successful init.

Tests cover the window and fallback helpers directly; the full suite passes
845/845, and both the Debug server and Debug client build.

Co-Authored-By: deepseek-flash
2026-11-08 11:45:19 +01:00

5088 lines
207 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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);
// 逐主机鼠标坐标补偿。必须在用户开始操作前加载;默认 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) {
// 关闭模式:不发送任何质量命令,保持客户端原有设置
} 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);
m_ulFramesThisSecond++;
m_ulScreenBytesThisSecond += len;
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
break;
}
case TOKEN_KEYFRAME: {
if (!m_bIsFirst) {
DrawNextScreenDiff(true);
}
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);
// 调优开关紧随位图信息下发:此刻客户端的截屏对象刚建好、编码器还没创建
// (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);
}
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) return;
LPVOID NextScreenData = m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength);
ULONG NextScreenLength = m_ContextObject->InDeCompressedBuffer.GetBufferLength() - 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);
LPBYTE dst = (LPBYTE)FirstScreenData, p = (LPBYTE)NextScreenData;
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;
}
}
// 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) {
case ALGORITHM_DIFF: {
for (LPBYTE end = p + NextScreenLength; p < end; ) {
ULONG ulCount = *(LPDWORD(p + sizeof(ULONG)));
memcpy(dst + *(LPDWORD)p, p + 2 * sizeof(ULONG), ulCount);
p += 2 * sizeof(ULONG) + ulCount;
}
break;
}
case ALGORITHM_GRAY: {
for (LPBYTE end = p + NextScreenLength; p < end; ) {
ULONG ulCount = *(LPDWORD(p + sizeof(ULONG)));
LPBYTE p1 = dst + *(LPDWORD)p, p2 = p + 2 * sizeof(ULONG);
for (int i = 0; i < ulCount; ++i, p1 += 4)
memset(p1, *p2++, sizeof(DWORD));
p += 2 * sizeof(ULONG) + ulCount;
}
break;
}
case ALGORITHM_RGB565: {
// RGB565 差分帧:解码每个差异块
for (LPBYTE end = p + NextScreenLength; p < end; ) {
ULONG pos = *(LPDWORD)p; // BGRA 字节偏移
ULONG pixelCount = *(LPDWORD)(p + sizeof(ULONG)); // 像素数量
p += 2 * sizeof(ULONG);
// RGB565 → BGRA 还原到目标位置
ConvertRGB565ToBGRA((const uint16_t*)p, dst + pos, pixelCount);
p += pixelCount * 2; // RGB565 每像素 2 字节
}
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) 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;
int copyHeight = height - scrollAmount;
if (direction == SCROLL_DIR_UP) {
// 向上滚动:屏幕内容向下移,BMP 中高地址移到低地址
// 新内容填充到 BMP 高地址(屏幕顶部)
memmove(dst, dst + scrollAmount * stride, copyHeight * stride);
} else {
// 向下滚动:屏幕内容向上移,BMP 中低地址移到高地址
// 新内容填充到 BMP 低地址(屏幕底部)
memmove(dst + scrollAmount * stride, dst, 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);
}
}
bool CScreenSpyDlg::Decode(LPBYTE Buffer, int size)
{
// 分辨率切换中,跳过解码避免访问无效缓冲区。
// 正常情况下客户端的 TOKEN_BITMAPINFO 会把它清掉(见 OnReceive);真正不会重启
// 截屏的档位切换(例如 1920 屏 High→Good)已在 ApplyQualityLevel 里按客户端的
// needRestart 判据排除,不会置这个标记。这里保留超时是兜底:客户端重启失败或
// 异常慢时不能让画面永久冻结。超时后必须主动要一个关键帧——解码器已被 flush,
// 只能等下一个 IDR,而客户端的自然 IDR 最长要等 15 秒(x264 keyint)。
if (m_bResolutionChanging) {
if (GetTickCount64() - m_AdaptiveQuality.lastResChangeTime > 1000) {
m_bResolutionChanging = false; // 超时恢复
// 刷新解码器状态,丢弃之前的参考帧
if (m_pCodecContext) {
avcodec_flush_buffers(m_pCodecContext);
}
// 没有新的位图信息说明没重启(或重启没完成),画面还停在旧算法的那一帧上,
// 必须让客户端立刻补一个 IDR 才能继续,否则要等自然 GOP。
RequestClientKeyFrame();
Mprintf("分辨率切换超时(无位图信息),刷新解码器并请求关键帧\n");
} else {
return false;
}
}
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) {
// 计算传输速率并更新标题
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:
case WM_MOUSEMOVE:
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;
}