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