3050 lines
108 KiB
C++
3050 lines
108 KiB
C++
// ScreenSpyDlg.cpp : 实现文件
|
||
//
|
||
|
||
#include "stdafx.h"
|
||
#include "2015Remote.h"
|
||
#include "ScreenSpyDlg.h"
|
||
#include "afxdialogex.h"
|
||
#include <imm.h>
|
||
#pragma comment(lib, "imm32.lib")
|
||
#include <WinUser.h>
|
||
#include <mmsystem.h>
|
||
#pragma comment(lib, "winmm.lib")
|
||
#include "CGridDialog.h"
|
||
#include "2015RemoteDlg.h"
|
||
#include "CPasswordDlg.h"
|
||
#include "CDlgFileSend.h"
|
||
#include <file_upload.h>
|
||
#include <md5.h>
|
||
#include <cstdint> // for uint16_t
|
||
#include <vector>
|
||
#include "WebService.h"
|
||
|
||
// 文件接收消息数据结构
|
||
struct FileV2MsgData {
|
||
std::vector<BYTE> data; // 原始数据
|
||
uint64_t transferID;
|
||
FileV2MsgData(const BYTE* buf, size_t len, uint64_t tid)
|
||
: data(buf, buf + len), transferID(tid) {}
|
||
};
|
||
|
||
// CScreenSpyDlg 对话框
|
||
|
||
// IDM_* enum 已移至 ScreenSpyDlg.h
|
||
|
||
IMPLEMENT_DYNAMIC(CScreenSpyDlg, CDialog)
|
||
|
||
// 算法标识 (与客户端 CursorInfo.h 保持一致)
|
||
#define ALGORITHM_GRAY 0
|
||
#define ALGORITHM_DIFF 1
|
||
#define ALGORITHM_H264 2
|
||
#define ALGORITHM_HOME 3
|
||
#define ALGORITHM_RGB565 3
|
||
|
||
#define TIMER_ID 132
|
||
|
||
// 静态成员变量定义
|
||
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);
|
||
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);
|
||
Mprintf("[ScreenSpyDlg] Parsed clientID in constructor: %llu\n", m_ClientID);
|
||
}
|
||
|
||
// 从客户端配置初始化自适应质量状态 (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;
|
||
}
|
||
|
||
|
||
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_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();
|
||
|
||
// 清理所有文件接收对话框
|
||
for (auto& pair : m_FileRecvDlgs) {
|
||
if (pair.second) {
|
||
pair.second->DestroyWindow();
|
||
delete pair.second;
|
||
}
|
||
}
|
||
m_FileRecvDlgs.clear();
|
||
|
||
SAFE_DELETE(m_pToolbar);
|
||
SAFE_DELETE(m_pStatusInfoWnd);
|
||
}
|
||
|
||
void CScreenSpyDlg::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
__super::DoDataExchange(pDX);
|
||
}
|
||
|
||
// ========== CStatusInfoWnd 实现 ==========
|
||
|
||
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, 170, 24), pParent, 0))
|
||
return FALSE;
|
||
|
||
SetLayeredWindowAttributes(0, 220, LWA_ALPHA);
|
||
LoadSettings();
|
||
return TRUE;
|
||
}
|
||
|
||
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());
|
||
|
||
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)
|
||
{
|
||
int width = 170, height = 24;
|
||
int monWidth = rcMonitor.right - rcMonitor.left;
|
||
|
||
int x, y;
|
||
if (m_bHasCustomPosition) {
|
||
x = rcMonitor.left + (int)(monWidth * m_dOffsetXRatio) - width / 2;
|
||
y = rcMonitor.top + m_nOffsetY;
|
||
x = max((int)rcMonitor.left, min(x, (int)rcMonitor.right - width));
|
||
y = max((int)rcMonitor.top, min(y, (int)rcMonitor.bottom - height));
|
||
} else {
|
||
x = rcMonitor.left + (monWidth - width) / 2;
|
||
y = rcMonitor.top + 50;
|
||
}
|
||
SetWindowPos(&wndTopMost, x, y, width, height, SWP_NOACTIVATE);
|
||
}
|
||
|
||
void CStatusInfoWnd::LoadSettings()
|
||
{
|
||
m_bHasCustomPosition = THIS_CFG.GetInt("statusinfo", "HasCustomPos", 0) != 0;
|
||
if (m_bHasCustomPosition) {
|
||
m_dOffsetXRatio = THIS_CFG.GetDouble("statusinfo", "OffsetXRatio", 0.5);
|
||
m_nOffsetY = THIS_CFG.GetInt("statusinfo", "OffsetY", 50);
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::SaveSettings()
|
||
{
|
||
THIS_CFG.SetInt("statusinfo", "HasCustomPos", m_bHasCustomPosition ? 1 : 0);
|
||
THIS_CFG.SetDouble("statusinfo", "OffsetXRatio", m_dOffsetXRatio);
|
||
THIS_CFG.SetInt("statusinfo", "OffsetY", m_nOffsetY);
|
||
}
|
||
|
||
// 检查父窗口是否处于控制模式
|
||
bool CStatusInfoWnd::IsParentInControlMode()
|
||
{
|
||
CScreenSpyDlg* pParent = (CScreenSpyDlg*)GetParent();
|
||
return pParent && pParent->m_bIsCtrl;
|
||
}
|
||
|
||
void CStatusInfoWnd::OnLButtonDown(UINT nFlags, CPoint point)
|
||
{
|
||
// 控制模式下不处理拖拽，让消息传递到父窗口
|
||
if (IsParentInControlMode()) {
|
||
// 转换为屏幕坐标后发送给父窗口
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_LBUTTONDOWN, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
m_bDragging = true;
|
||
m_ptDragStart = point;
|
||
SetCapture();
|
||
}
|
||
|
||
void CStatusInfoWnd::OnLButtonUp(UINT nFlags, CPoint point)
|
||
{
|
||
if (IsParentInControlMode()) {
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_LBUTTONUP, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_bDragging) {
|
||
m_bDragging = false;
|
||
ReleaseCapture();
|
||
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
HMONITOR hMon = MonitorFromWindow(pParent->GetSafeHwnd(), MONITOR_DEFAULTTONEAREST);
|
||
MONITORINFO mi = { sizeof(mi) };
|
||
if (GetMonitorInfo(hMon, &mi)) {
|
||
CRect rcWnd;
|
||
GetWindowRect(&rcWnd);
|
||
|
||
int monWidth = mi.rcMonitor.right - mi.rcMonitor.left;
|
||
int wndCenterX = rcWnd.left + rcWnd.Width() / 2;
|
||
|
||
m_dOffsetXRatio = (double)(wndCenterX - mi.rcMonitor.left) / monWidth;
|
||
m_nOffsetY = rcWnd.top - mi.rcMonitor.top;
|
||
m_bHasCustomPosition = true;
|
||
SaveSettings();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::OnMouseMove(UINT nFlags, CPoint point)
|
||
{
|
||
if (IsParentInControlMode()) {
|
||
CPoint ptScreen = point;
|
||
ClientToScreen(&ptScreen);
|
||
CWnd* pParent = GetParent();
|
||
if (pParent) {
|
||
pParent->ScreenToClient(&ptScreen);
|
||
pParent->PostMessage(WM_MOUSEMOVE, nFlags, MAKELPARAM(ptScreen.x, ptScreen.y));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_bDragging) {
|
||
CRect rcWnd;
|
||
GetWindowRect(&rcWnd);
|
||
|
||
int dx = point.x - m_ptDragStart.x;
|
||
int dy = point.y - m_ptDragStart.y;
|
||
|
||
SetWindowPos(&wndTopMost, rcWnd.left + dx, rcWnd.top + dy,
|
||
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
|
||
}
|
||
}
|
||
|
||
void CStatusInfoWnd::OnPaint()
|
||
{
|
||
CPaintDC dc(this);
|
||
CRect rc;
|
||
GetClientRect(&rc);
|
||
|
||
// 背景
|
||
dc.FillSolidRect(rc, RGB(40, 40, 40));
|
||
|
||
// 文字
|
||
dc.SetBkMode(TRANSPARENT);
|
||
dc.SetTextColor(RGB(220, 220, 220));
|
||
CFont font;
|
||
font.CreatePointFont(90, _T("Segoe UI"));
|
||
CFont* pOldFont = dc.SelectObject(&font);
|
||
dc.DrawText(m_strInfo, rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
|
||
dc.SelectObject(pOldFont);
|
||
}
|
||
|
||
BOOL CStatusInfoWnd::OnEraseBkgnd(CDC* pDC)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
// ========== CScreenSpyDlg 实现 ==========
|
||
|
||
BEGIN_MESSAGE_MAP(CScreenSpyDlg, CDialog)
|
||
ON_WM_CLOSE()
|
||
ON_WM_PAINT()
|
||
ON_WM_SETCURSOR()
|
||
ON_WM_SYSCOMMAND()
|
||
ON_WM_HSCROLL()
|
||
ON_WM_VSCROLL()
|
||
ON_WM_LBUTTONDOWN()
|
||
ON_WM_LBUTTONUP()
|
||
ON_WM_MOUSEWHEEL()
|
||
ON_WM_MOUSEMOVE()
|
||
ON_WM_MOUSELEAVE()
|
||
ON_WM_KILLFOCUS()
|
||
ON_WM_SIZE()
|
||
ON_WM_LBUTTONDBLCLK()
|
||
ON_WM_ACTIVATE()
|
||
ON_WM_TIMER()
|
||
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(WM_RECVFILEV2_CHUNK, &CScreenSpyDlg::OnRecvFileV2Chunk)
|
||
ON_MESSAGE(WM_RECVFILEV2_COMPLETE, &CScreenSpyDlg::OnRecvFileV2Complete)
|
||
ON_WM_DROPFILES()
|
||
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);
|
||
}
|
||
|
||
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", m_IPAddress, 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);
|
||
m_wZoom = ((double)bmp->bmiHeader.biWidth) / ((double)(m_CRect.Width()));
|
||
m_hZoom = ((double)bmp->bmiHeader.biHeight) / ((double)(m_CRect.Height()));
|
||
}
|
||
|
||
BOOL CScreenSpyDlg::OnInitDialog()
|
||
{
|
||
__super::OnInitDialog();
|
||
SetIcon(m_hIcon,FALSE);
|
||
|
||
// 获取默认 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_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_bUseCustomCursor ? 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)"));
|
||
}
|
||
// 音频菜单项
|
||
SysMenu->AppendMenuL(MF_STRING, IDM_AUDIO_TOGGLE, "系统音频(&U)");
|
||
SysMenu->CheckMenuItem(IDM_AUDIO_TOGGLE, m_Settings.AudioEnabled ? MF_CHECKED : MF_UNCHECKED);
|
||
|
||
// 初始化勾选状态
|
||
UpdateQualityMenuCheck(SysMenu);
|
||
|
||
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 = FALSE; //不是跟踪
|
||
m_ClientCursorPos.x = 0;
|
||
m_ClientCursorPos.y = 0;
|
||
m_bCursorIndex = 0;
|
||
|
||
m_hRemoteCursor = LoadCursor(NULL, IDC_ARROW);
|
||
ICONINFO CursorInfo;
|
||
::GetIconInfo(m_hRemoteCursor, &CursorInfo);
|
||
SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
||
SysMenu->CheckMenuItem(IDM_ADAPTIVE_SIZE, m_bAdaptiveSize ? MF_CHECKED : MF_UNCHECKED);
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
|
||
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;
|
||
SetWindowPlacement(&wp);
|
||
|
||
// 同时初始化 m_struOldWndpl，供全屏退出时使用
|
||
m_struOldWndpl = wp;
|
||
m_Settings.FullScreen ? EnterFullScreen() : LeaveFullScreen();
|
||
|
||
// 启动传输速率更新定时器 (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++) {
|
||
memcpy(profileCmd + 1 + i * sizeof(QualityProfile),
|
||
&GetQualityProfile(i), sizeof(QualityProfile));
|
||
}
|
||
m_ContextObject->Send2Client(profileCmd, sizeof(profileCmd));
|
||
}
|
||
|
||
// 发送初始质量配置给客户端
|
||
if (m_Settings.QualityLevel == QUALITY_DISABLED) {
|
||
// 关闭模式：不发送任何质量命令，保持客户端原有设置
|
||
} else {
|
||
// 自适应或固定等级模式：发送质量等级和分辨率
|
||
BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)m_AdaptiveQuality.currentLevel, 0 };
|
||
m_ContextObject->Send2Client(cmd, sizeof(cmd));
|
||
|
||
// 始终发送 CMD_SCREEN_SIZE，让客户端同步分辨率策略
|
||
// maxWidth=0 表示使用默认分辨率（1080p 限制）
|
||
BYTE sizeCmd[16] = { CMD_SCREEN_SIZE, 2 }; // strategy=2 表示自适应质量
|
||
memcpy(sizeCmd + 2, &m_AdaptiveQuality.currentMaxWidth, sizeof(int));
|
||
m_ContextObject->Send2Client(sizeCmd, 10);
|
||
}
|
||
|
||
SendNext();
|
||
|
||
// 通知主窗口：设置为活动的远程桌面会话（用于 Ctrl+V 文件接收）
|
||
if (pMain)
|
||
::PostMessage(pMain->GetSafeHwnd(), WM_SESSION_ACTIVATED, (WPARAM)this, 0);
|
||
|
||
// 注册屏幕上下文到 WebService（用于 Web 端鼠标/键盘控制）
|
||
WebService().RegisterScreenContext(m_ClientID, m_ContextObject);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
VOID CScreenSpyDlg::OnClose()
|
||
{
|
||
// 注销屏幕上下文（Web 端控制）
|
||
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);
|
||
extern CMy2015RemoteDlg *g_2015RemoteDlg;
|
||
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 管理）
|
||
CDlgFileSend*& dlg = m_FileRecvDlgs[transferID];
|
||
if (dlg == nullptr) {
|
||
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; // 不断开连接
|
||
}
|
||
|
||
// 接收文件
|
||
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()) {
|
||
it->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;
|
||
}
|
||
case TOKEN_FIRSTSCREEN: {
|
||
DrawFirstScreen();
|
||
m_ulFramesThisSecond++;
|
||
break;
|
||
}
|
||
case TOKEN_NEXTSCREEN: {
|
||
DrawNextScreenDiff(false);
|
||
m_ulFramesThisSecond++;
|
||
break;
|
||
}
|
||
case TOKEN_KEYFRAME: {
|
||
if (!m_bIsFirst) {
|
||
DrawNextScreenDiff(true);
|
||
}
|
||
m_ulFramesThisSecond++;
|
||
break;
|
||
}
|
||
case TOKEN_SCROLL_FRAME: {
|
||
if (!m_bIsFirst) {
|
||
DrawScrollFrame();
|
||
}
|
||
m_ulFramesThisSecond++;
|
||
break;
|
||
}
|
||
case TOKEN_CLIPBOARD_TEXT: {
|
||
Buffer str = m_ContextObject->InDeCompressedBuffer.GetMyBuffer(1);
|
||
UpdateServerClipboard(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);
|
||
if (len >= 1 + sizeof(BITMAPINFOHEADER) + sizeof(uint64_t)) {
|
||
m_ClientID = *((uint64_t*)(m_ContextObject->InDeCompressedBuffer.GetBuffer(1 + sizeof(BITMAPINFOHEADER))));
|
||
}
|
||
PrepareDrawing(m_BitmapInfor_Full);
|
||
// 分辨率切换完成，允许解码
|
||
m_bResolutionChanging = false;
|
||
// Notify web clients of resolution change
|
||
if (WebService().IsRunning()) {
|
||
int width = m_BitmapInfor_Full->bmiHeader.biWidth;
|
||
int height = abs(m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
WebService().NotifyResolutionChange(m_ClientID, width, height);
|
||
|
||
// Hide window if this session was triggered by web client (and hiding is enabled)
|
||
if (WebService().IsWebTriggered(m_ClientID) && WebService().GetHideWebSessions()) {
|
||
m_bHide = true;
|
||
ShowWindow(SW_HIDE);
|
||
Mprintf("[ScreenSpyDlg] Web-triggered session, hiding window for device %llu\n", m_ClientID);
|
||
}
|
||
}
|
||
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_bUseCustomCursor) {
|
||
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消息
|
||
}
|
||
|
||
VOID CScreenSpyDlg::DrawNextScreenDiff(bool keyFrame)
|
||
{
|
||
//该函数不是直接画到屏幕上，而是更新一下变化部分的屏幕数据然后调用
|
||
//OnPaint画上去
|
||
//根据鼠标是否移动和屏幕是否变化判断是否重绘鼠标，防止鼠标闪烁
|
||
BOOL bChange = FALSE;
|
||
ULONG ulHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 标识 + 算法 + 光标 位置 + 光标类型索引
|
||
#if SCREENYSPY_IMPROVE
|
||
int frameID = -1;
|
||
memcpy(&frameID, m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength), sizeof(int));
|
||
ulHeadLength += sizeof(int);
|
||
if (++m_FrameID != frameID) {
|
||
TRACE("DrawNextScreenDiff [%d] bmp is lost from %d\n", frameID-m_FrameID, m_FrameID);
|
||
m_FrameID = frameID;
|
||
}
|
||
#else
|
||
m_FrameID++;
|
||
#endif
|
||
LPVOID FirstScreenData = m_BitmapData_Full;
|
||
if (FirstScreenData == NULL) return;
|
||
LPVOID NextScreenData = m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength);
|
||
ULONG NextScreenLength = m_ContextObject->InDeCompressedBuffer.GetBufferLength() - ulHeadLength;
|
||
|
||
POINT OldClientCursorPos;
|
||
memcpy(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT));
|
||
memcpy(&m_ClientCursorPos, m_ContextObject->InDeCompressedBuffer.GetBuffer(2), sizeof(POINT));
|
||
|
||
// 鼠标移动了
|
||
if (memcmp(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT)) != 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
// 光标类型发生变化
|
||
BYTE bOldCursorIndex = m_bCursorIndex;
|
||
m_bCursorIndex = m_ContextObject->InDeCompressedBuffer.GetBuffer(2+sizeof(POINT))[0];
|
||
if (bOldCursorIndex != m_bCursorIndex) {
|
||
bChange = TRUE;
|
||
if (m_bIsCtrl && !m_bIsTraceCursor) {//替换指定窗口所属类的WNDCLASSEX结构
|
||
HCURSOR cursor;
|
||
if (m_bCursorIndex == 254) { // -2: 使用自定义光标
|
||
cursor = (m_bUseCustomCursor && 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
|
||
}
|
||
}
|
||
|
||
// 屏幕是否变化
|
||
if (NextScreenLength > 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
BYTE algorithm = m_ContextObject->InDeCompressedBuffer.GetBYTE(1);
|
||
LPBYTE dst = (LPBYTE)FirstScreenData, p = (LPBYTE)NextScreenData;
|
||
if (keyFrame) {
|
||
switch (algorithm) {
|
||
case ALGORITHM_DIFF:
|
||
case ALGORITHM_GRAY: {
|
||
if (m_BitmapInfor_Full->bmiHeader.biSizeImage == NextScreenLength)
|
||
memcpy(dst, p, m_BitmapInfor_Full->bmiHeader.biSizeImage);
|
||
break;
|
||
}
|
||
case ALGORITHM_RGB565: {
|
||
// RGB565 关键帧：将 RGB565 整帧还原为 BGRA
|
||
ULONG pixelCount = m_BitmapInfor_Full->bmiHeader.biSizeImage / 4;
|
||
if (pixelCount * 2 == NextScreenLength)
|
||
ConvertRGB565ToBGRA((const uint16_t*)p, dst, pixelCount);
|
||
break;
|
||
}
|
||
case ALGORITHM_H264: {
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
} else if (0 != NextScreenLength) {
|
||
switch (algorithm) {
|
||
case ALGORITHM_DIFF: {
|
||
for (LPBYTE end = p + NextScreenLength; p < end; ) {
|
||
ULONG ulCount = *(LPDWORD(p + sizeof(ULONG)));
|
||
memcpy(dst + *(LPDWORD)p, p + 2 * sizeof(ULONG), ulCount);
|
||
|
||
p += 2 * sizeof(ULONG) + ulCount;
|
||
}
|
||
break;
|
||
}
|
||
case ALGORITHM_GRAY: {
|
||
for (LPBYTE end = p + NextScreenLength; p < end; ) {
|
||
ULONG ulCount = *(LPDWORD(p + sizeof(ULONG)));
|
||
LPBYTE p1 = dst + *(LPDWORD)p, p2 = p + 2 * sizeof(ULONG);
|
||
for (int i = 0; i < ulCount; ++i, p1 += 4)
|
||
memset(p1, *p2++, sizeof(DWORD));
|
||
|
||
p += 2 * sizeof(ULONG) + ulCount;
|
||
}
|
||
break;
|
||
}
|
||
case ALGORITHM_RGB565: {
|
||
// RGB565 差分帧：解码每个差异块
|
||
for (LPBYTE end = p + NextScreenLength; p < end; ) {
|
||
ULONG pos = *(LPDWORD)p; // BGRA 字节偏移
|
||
ULONG pixelCount = *(LPDWORD)(p + sizeof(ULONG)); // 像素数量
|
||
p += 2 * sizeof(ULONG);
|
||
|
||
// RGB565 → BGRA 还原到目标位置
|
||
ConvertRGB565ToBGRA((const uint16_t*)p, dst + pos, pixelCount);
|
||
p += pixelCount * 2; // RGB565 每像素 2 字节
|
||
}
|
||
break;
|
||
}
|
||
case ALGORITHM_H264: {
|
||
// Only decode locally if dialog is visible (skip when hidden for web-only viewing)
|
||
if (!m_bHide) {
|
||
if (Decode((LPBYTE)NextScreenData, NextScreenLength)) {
|
||
bChange = TRUE;
|
||
}
|
||
}
|
||
// Broadcast H264 frame to web clients
|
||
// Format: [DeviceID:4][FrameType:1][DataLen:4][H264Data:N]
|
||
if (NextScreenLength > 0 && WebService().IsRunning()) {
|
||
// Detect H264 keyframe by checking NAL unit type
|
||
// NAL type 5 = IDR slice (keyframe), NAL type 7 = SPS, NAL type 8 = PPS
|
||
bool isKeyFrame = false;
|
||
LPBYTE h264Data = (LPBYTE)NextScreenData;
|
||
for (ULONG i = 0; i + 4 < NextScreenLength; i++) {
|
||
// Look for start code: 0x00 0x00 0x00 0x01 or 0x00 0x00 0x01
|
||
if ((h264Data[i] == 0 && h264Data[i+1] == 0 && h264Data[i+2] == 0 && h264Data[i+3] == 1) ||
|
||
(h264Data[i] == 0 && h264Data[i+1] == 0 && h264Data[i+2] == 1)) {
|
||
int nalOffset = (h264Data[i+2] == 1) ? i + 3 : i + 4;
|
||
if (nalOffset < (int)NextScreenLength) {
|
||
int nalType = h264Data[nalOffset] & 0x1F;
|
||
if (nalType == 5 || nalType == 7 || nalType == 8) {
|
||
isKeyFrame = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
std::vector<uint8_t> packet(4 + 1 + 4 + NextScreenLength);
|
||
uint32_t deviceIdLow = (uint32_t)(m_ClientID & 0xFFFFFFFF);
|
||
uint8_t frameType = isKeyFrame ? 1 : 0;
|
||
uint32_t dataLen = (uint32_t)NextScreenLength;
|
||
|
||
memcpy(packet.data(), &deviceIdLow, 4);
|
||
packet[4] = frameType;
|
||
memcpy(packet.data() + 5, &dataLen, 4);
|
||
memcpy(packet.data() + 9, NextScreenData, NextScreenLength);
|
||
|
||
WebService().BroadcastH264Frame(m_ClientID, packet.data(), packet.size());
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
#if SCREENSPY_WRITE
|
||
if (!WriteBitmap(m_BitmapInfor_Full, m_BitmapData_Full, "YAMA", frameID)) {
|
||
TRACE("WriteBitmap [%d] failed!!!\n", frameID);
|
||
}
|
||
#endif
|
||
|
||
if (bChange && !m_bHide) {
|
||
PostMessage(WM_PAINT);
|
||
}
|
||
}
|
||
|
||
|
||
VOID CScreenSpyDlg::DrawScrollFrame()
|
||
{
|
||
// 滚动帧消息格式:
|
||
// 字节 0: TOKEN_SCROLL_FRAME (99)
|
||
// 字节 1: 算法类型
|
||
// 字节 2-5: 光标 X
|
||
// 字节 6-9: 光标 Y
|
||
// 字节 10: 光标类型
|
||
// 字节 11: 滚动方向 (0=上, 1=下)
|
||
// 字节 12-15: 滚动距离 (像素)
|
||
// 字节 16-19: 边缘数据偏移 (字节)
|
||
// 字节 20-23: 边缘数据长度 (像素数)
|
||
// 字节 24+: 边缘像素数据
|
||
|
||
BOOL bChange = FALSE;
|
||
ULONG ulHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 11 字节
|
||
|
||
LPVOID FirstScreenData = m_BitmapData_Full;
|
||
if (FirstScreenData == NULL) return;
|
||
|
||
// 读取光标位置
|
||
POINT OldClientCursorPos;
|
||
memcpy(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT));
|
||
memcpy(&m_ClientCursorPos, m_ContextObject->InDeCompressedBuffer.GetBuffer(2), sizeof(POINT));
|
||
|
||
if (memcmp(&OldClientCursorPos, &m_ClientCursorPos, sizeof(POINT)) != 0) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
// 读取光标类型
|
||
BYTE bOldCursorIndex = m_bCursorIndex;
|
||
m_bCursorIndex = m_ContextObject->InDeCompressedBuffer.GetBuffer(2 + sizeof(POINT))[0];
|
||
if (bOldCursorIndex != m_bCursorIndex) {
|
||
bChange = TRUE;
|
||
}
|
||
|
||
// 读取滚动参数
|
||
LPBYTE buffer = m_ContextObject->InDeCompressedBuffer.GetBuffer(ulHeadLength);
|
||
BYTE direction = buffer[0];
|
||
int scrollAmount = *(int*)(buffer + 1);
|
||
int edgeOffset = *(int*)(buffer + 5);
|
||
int edgePixelCount = *(int*)(buffer + 9);
|
||
LPBYTE edgeData = buffer + 13;
|
||
|
||
BYTE algorithm = m_ContextObject->InDeCompressedBuffer.GetBYTE(1);
|
||
LPBYTE dst = (LPBYTE)FirstScreenData;
|
||
|
||
// 1. 滚动现有位图缓冲区
|
||
// BMP is bottom-up: row 0 = screen bottom, row height-1 = screen top
|
||
int stride = m_BitmapInfor_Full->bmiHeader.biWidth * 4;
|
||
int height = m_BitmapInfor_Full->bmiHeader.biHeight;
|
||
int copyHeight = height - scrollAmount;
|
||
|
||
if (direction == SCROLL_DIR_UP) {
|
||
// 向上滚动：屏幕内容向下移，BMP 中高地址移到低地址
|
||
// 新内容填充到 BMP 高地址（屏幕顶部）
|
||
memmove(dst, dst + scrollAmount * stride, copyHeight * stride);
|
||
} else {
|
||
// 向下滚动：屏幕内容向上移，BMP 中低地址移到高地址
|
||
// 新内容填充到 BMP 低地址（屏幕底部）
|
||
memmove(dst + scrollAmount * stride, dst, copyHeight * stride);
|
||
}
|
||
|
||
// 2. 复制边缘数据
|
||
LPBYTE edgeDst = dst + edgeOffset;
|
||
switch (algorithm) {
|
||
case ALGORITHM_RGB565:
|
||
ConvertRGB565ToBGRA((const uint16_t*)edgeData, edgeDst, edgePixelCount);
|
||
break;
|
||
case ALGORITHM_GRAY:
|
||
for (int i = 0; i < edgePixelCount; ++i, edgeDst += 4) {
|
||
memset(edgeDst, edgeData[i], 3);
|
||
edgeDst[3] = 0xFF;
|
||
}
|
||
break;
|
||
case ALGORITHM_DIFF:
|
||
default:
|
||
memcpy(edgeDst, edgeData, edgePixelCount * 4);
|
||
break;
|
||
}
|
||
|
||
bChange = TRUE;
|
||
m_FrameID++;
|
||
|
||
if (bChange && !m_bHide) {
|
||
PostMessage(WM_PAINT);
|
||
}
|
||
}
|
||
|
||
bool CScreenSpyDlg::Decode(LPBYTE Buffer, int size)
|
||
{
|
||
// 分辨率切换中，跳过解码避免访问无效缓冲区
|
||
// 但加入超时保护：5秒内客户端未响应则恢复（防止卡死）
|
||
if (m_bResolutionChanging) {
|
||
if (GetTickCount64() - m_AdaptiveQuality.lastResChangeTime > 5000) {
|
||
m_bResolutionChanging = false; // 超时恢复
|
||
// 刷新解码器状态，丢弃之前的参考帧，等待下一个 I 帧
|
||
if (m_pCodecContext) {
|
||
avcodec_flush_buffers(m_pCodecContext);
|
||
}
|
||
Mprintf("分辨率切换超时，刷新解码器并恢复\n");
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
if (!m_BitmapData_Full || !m_BitmapInfor_Full) {
|
||
return false;
|
||
}
|
||
|
||
// 解码数据.
|
||
av_init_packet(&m_AVPacket);
|
||
|
||
m_AVPacket.data = (uint8_t*)Buffer;
|
||
m_AVPacket.size = size;
|
||
|
||
int err = avcodec_send_packet(m_pCodecContext, &m_AVPacket);
|
||
if (!err) {
|
||
err = avcodec_receive_frame(m_pCodecContext, &m_AVFrame);
|
||
if (err == AVERROR(EAGAIN)) {
|
||
Mprintf("avcodec_receive_frame error: EAGAIN\n");
|
||
return false;
|
||
}
|
||
|
||
// 解码数据前会清除m_AVFrame的内容.
|
||
if (!err) {
|
||
LPVOID Image[2] = { 0 };
|
||
LPVOID CursorInfo[2] = { 0 };
|
||
//成功.
|
||
//I420 ---> ARGB.
|
||
//WaitForSingleObject(m_hMutex,INFINITE);
|
||
|
||
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,
|
||
m_BitmapInfor_Full->bmiHeader.biWidth*4,
|
||
m_BitmapInfor_Full->bmiHeader.biWidth,
|
||
m_BitmapInfor_Full->bmiHeader.biHeight);
|
||
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;
|
||
}
|
||
|
||
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;
|
||
if (m_bAdaptiveSize) {
|
||
int dstW = m_CRect.Width();
|
||
int dstH = m_CRect.Height();
|
||
// 尺寸相同时用 BitBlt（更快），否则用 StretchBlt
|
||
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 {
|
||
BitBlt(m_hFullDC, 0, 0, srcW, srcH, m_hFullMemDC, m_ulHScrollPos, m_ulVScrollPos, SRCCOPY);
|
||
}
|
||
|
||
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_ClientCursorPos.x - m_ulHScrollPos);
|
||
int drawY = m_bAdaptiveSize ? (int)(m_ClientCursorPos.y / m_hZoom) : (m_ClientCursorPos.y - m_ulVScrollPos);
|
||
|
||
// 2. 获取光标句柄（支持自定义光标）
|
||
HCURSOR hCursor;
|
||
if (m_bCursorIndex == 254) { // -2: 使用自定义光标
|
||
hCursor = (m_bUseCustomCursor && 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)
|
||
{
|
||
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;
|
||
SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
|
||
// 控制模式：禁用本地 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_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)) {
|
||
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_bUseCustomCursor = !m_bUseCustomCursor;
|
||
SysMenu->CheckMenuItem(IDM_CUSTOM_CURSOR, m_bUseCustomCursor ? MF_CHECKED : MF_UNCHECKED);
|
||
// 如果当前是自定义光标，立即更新显示
|
||
if (m_bCursorIndex == 254 && m_bIsCtrl) {
|
||
HCURSOR cursor = (m_bUseCustomCursor && m_hCustomCursor) ? m_hCustomCursor : LoadCursor(NULL, IDC_ARROW);
|
||
if (m_Settings.RemoteCursor) {
|
||
Invalidate(FALSE);
|
||
} else {
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)cursor);
|
||
}
|
||
}
|
||
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);
|
||
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;
|
||
}
|
||
}
|
||
|
||
__super::OnSysCommand(nID, lParam);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnTimer(UINT_PTR nIDEvent)
|
||
{
|
||
if (!m_aviFile.IsEmpty()) {
|
||
LPCTSTR lpTipsString = _T("●");
|
||
|
||
m_aviStream.Write((BYTE*)m_BitmapData_Full);
|
||
|
||
// 提示正在录像
|
||
SetTextColor(m_hFullDC, RGB(0xff, 0x00, 0x00));
|
||
TextOut(m_hFullDC, 0, 0, lpTipsString, lstrlen(lpTipsString));
|
||
}
|
||
if (nIDEvent == 1 && m_Settings.FullScreen && m_pToolbar) {
|
||
m_pToolbar->CheckMousePosition();
|
||
}
|
||
if (nIDEvent == 2) {
|
||
KillTimer(2);
|
||
if (m_bConnected) {
|
||
return;
|
||
}
|
||
CWnd* pMain = AfxGetMainWnd();
|
||
if (pMain)
|
||
::PostMessageA(pMain->GetSafeHwnd(), WM_SHOWNOTIFY, (WPARAM)new CharMsg(_TR("连接已断开")),
|
||
(LPARAM)new CharMsg(m_IPAddress + _TR(" - 远程桌面连接已断开")));
|
||
this->PostMessageA(WM_CLOSE, 0, 0);
|
||
return;
|
||
}
|
||
if (nIDEvent == 3) {
|
||
KillTimer(3);
|
||
PostMessageA(WM_PAINT);
|
||
}
|
||
if (nIDEvent == 4) {
|
||
// 计算传输速率并更新标题
|
||
m_dTransferRate = m_ulBytesThisSecond / 1024.0; // KB/s
|
||
m_ulBytesThisSecond = 0;
|
||
// 使用EMA平滑帧率 (alpha=0.3)，避免跳跃
|
||
double currentFPS = (double)m_ulFramesThisSecond;
|
||
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") :
|
||
CString(GetQualityName(m_AdaptiveQuality.currentLevel));
|
||
m_pStatusInfoWnd->UpdateInfo(m_dFrameRate, m_dTransferRate, qualityName);
|
||
}
|
||
}
|
||
__super::OnTimer(nIDEvent);
|
||
}
|
||
|
||
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(" | ") + GetQualityName(m_AdaptiveQuality.currentLevel);
|
||
|
||
CString strTitle;
|
||
UINT fps = (UINT)(m_dFrameRate + 0.5); // 四舍五入显示
|
||
if (m_dTransferRate >= 1024) {
|
||
strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.1f MB/s%s",
|
||
m_IPAddress, width, height, fps, m_dTransferRate / 1024, qualityName.GetString());
|
||
} else {
|
||
strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.0f KB/s%s",
|
||
m_IPAddress, 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";
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
void CScreenSpyDlg::EvaluateQuality()
|
||
{
|
||
if (!m_AdaptiveQuality.enabled) return;
|
||
|
||
// 0. 启动延迟：1分钟内不进行自适应调整
|
||
ULONGLONG now = GetTickCount64();
|
||
if (now - m_AdaptiveQuality.startTime < 60000) return;
|
||
|
||
// 1. 获取RTT
|
||
int rtt = GetClientRTT();
|
||
if (rtt <= 0) return;
|
||
m_AdaptiveQuality.lastRTT = rtt;
|
||
|
||
// 2. 计算目标等级
|
||
int targetLevel = GetTargetQualityLevel(rtt, m_bUsingFRP);
|
||
int currentLevel = m_AdaptiveQuality.currentLevel;
|
||
|
||
if (targetLevel == currentLevel) {
|
||
m_AdaptiveQuality.stableCount = 0;
|
||
return;
|
||
}
|
||
|
||
// 3. 检查是否涉及分辨率变化
|
||
int currentMaxWidth = GetQualityProfile(currentLevel).maxWidth;
|
||
int targetMaxWidth = GetQualityProfile(targetLevel).maxWidth;
|
||
bool resolutionChange = (currentMaxWidth != targetMaxWidth);
|
||
|
||
// 4. 冷却时间检查
|
||
// - 分辨率变化：降级15秒，升级30秒
|
||
// - 纯FPS/算法变化：3秒
|
||
ULONGLONG cooldown = 3000;
|
||
if (resolutionChange) {
|
||
cooldown = (targetLevel > currentLevel) ? 15000 : 30000;
|
||
if (now - m_AdaptiveQuality.lastResChangeTime < cooldown)
|
||
return;
|
||
} else {
|
||
if (now - m_AdaptiveQuality.lastChangeTime < cooldown)
|
||
return;
|
||
}
|
||
|
||
// 5. 降级：快速响应 (连续2次)
|
||
if (targetLevel > currentLevel) {
|
||
m_AdaptiveQuality.stableCount++;
|
||
if (m_AdaptiveQuality.stableCount >= 2) {
|
||
ApplyQualityLevel(targetLevel);
|
||
}
|
||
}
|
||
// 6. 升级：谨慎处理 (连续5次，且只升一级)
|
||
else if (targetLevel < currentLevel) {
|
||
m_AdaptiveQuality.stableCount++;
|
||
if (m_AdaptiveQuality.stableCount >= 5) {
|
||
ApplyQualityLevel(currentLevel - 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CScreenSpyDlg::ApplyQualityLevel(int level, bool persist)
|
||
{
|
||
if (level < 0 || level >= QUALITY_COUNT) return;
|
||
|
||
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;
|
||
|
||
// 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) {
|
||
// 标记分辨率切换中，阻止 Decode 访问旧缓冲区
|
||
m_bResolutionChanging = true;
|
||
// 自适应调整且分辨率变化时不显示"请等待"，手动切换时显示
|
||
if (!persist) m_bQualitySwitch = true;
|
||
m_AdaptiveQuality.currentMaxWidth = newMaxWidth;
|
||
m_AdaptiveQuality.lastResChangeTime = GetTickCount64();
|
||
|
||
BYTE sizeCmd[16] = { CMD_SCREEN_SIZE, 2 }; // strategy=2 表示自定义maxWidth
|
||
memcpy(sizeCmd + 2, &newMaxWidth, sizeof(int));
|
||
m_ContextObject->Send2Client(sizeCmd, 10);
|
||
|
||
Mprintf("发送 CMD_SCREEN_SIZE: strategy=2, maxWidth=%d\n", newMaxWidth);
|
||
} else {
|
||
Mprintf("分辨率未变化，不发送 CMD_SCREEN_SIZE\n");
|
||
}
|
||
|
||
Mprintf("质量切换: %s (FPS=%d, Algo=%d)\n", GetQualityName(level), profile.maxFPS, profile.algorithm);
|
||
}
|
||
|
||
BOOL CScreenSpyDlg::PreTranslateMessage(MSG* pMsg)
|
||
{
|
||
#define MAKEDWORD(h,l) (((unsigned long)h << 16) | l)
|
||
switch (pMsg->message) {
|
||
case WM_LBUTTONDOWN:
|
||
case WM_LBUTTONUP:
|
||
case WM_RBUTTONDOWN:
|
||
case WM_RBUTTONUP:
|
||
case WM_LBUTTONDBLCLK:
|
||
case WM_RBUTTONDBLCLK:
|
||
case WM_MBUTTONDBLCLK:
|
||
case WM_MBUTTONDOWN:
|
||
case WM_MBUTTONUP:
|
||
case WM_MOUSEMOVE:
|
||
SendScaledMouseMessage(pMsg, true);
|
||
break;
|
||
case WM_MOUSEWHEEL: {
|
||
// WM_MOUSEWHEEL 的 lParam 是屏幕坐标，需要转换为客户区坐标
|
||
POINT pt = { GET_X_LPARAM(pMsg->lParam), GET_Y_LPARAM(pMsg->lParam) };
|
||
ScreenToClient(&pt);
|
||
MSG wheelMsg = *pMsg;
|
||
wheelMsg.lParam = MAKELPARAM(pt.x, pt.y);
|
||
SendScaledMouseMessage(&wheelMsg, true);
|
||
}
|
||
break;
|
||
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 = m_bAdaptiveSize ? x * m_wZoom : x + m_ulHScrollPos;
|
||
LONG high = m_bAdaptiveSize ? y * m_hZoom : y + m_ulVScrollPos;
|
||
if (makeLP) msg.lParam = MAKELPARAM(low, high);
|
||
msg.pt.x = low;
|
||
msg.pt.y = high;
|
||
SendCommand(&msg);
|
||
}
|
||
|
||
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 (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->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 (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::OnLButtonDown(UINT nFlags, CPoint point)
|
||
{
|
||
__super::OnLButtonDown(nFlags, point);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnLButtonUp(UINT nFlags, CPoint point)
|
||
{
|
||
__super::OnLButtonUp(nFlags, point);
|
||
}
|
||
|
||
|
||
BOOL CScreenSpyDlg::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
|
||
{
|
||
return __super::OnMouseWheel(nFlags, zDelta, pt);
|
||
}
|
||
|
||
|
||
void CScreenSpyDlg::OnMouseMove(UINT nFlags, CPoint point)
|
||
{
|
||
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);
|
||
}
|
||
} else if (!m_bMouseTracking) {
|
||
m_bMouseTracking = true;
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
|
||
}
|
||
|
||
__super::OnMouseMove(nFlags, point);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnMouseLeave()
|
||
{
|
||
CWnd::OnMouseLeave();
|
||
|
||
m_bMouseTracking = false;
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
|
||
}
|
||
|
||
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);
|
||
m_wZoom = ((double)m_BitmapInfor_Full->bmiHeader.biWidth) / ((double)(m_CRect.Width()));
|
||
m_hZoom = ((double)m_BitmapInfor_Full->bmiHeader.biHeight) / ((double)(m_CRect.Height()));
|
||
}
|
||
|
||
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;
|
||
SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
|
||
// 控制模式：禁用本地 IME；查看模式：启用本地 IME
|
||
ImmAssociateContext(m_hWnd, m_bIsCtrl ? NULL : m_hOldIMC);
|
||
}
|
||
|
||
void CScreenSpyDlg::OnDropFiles(HDROP hDropInfo)
|
||
{
|
||
if (m_bIsCtrl && m_bConnected) {
|
||
UINT nFiles = DragQueryFile(hDropInfo, 0xFFFFFFFF, NULL, 0);
|
||
std::vector<std::string> list;
|
||
for (UINT i = 0; i < nFiles; i++) {
|
||
TCHAR szPath[MAX_PATH];
|
||
DragQueryFile(hDropInfo, i, szPath, MAX_PATH);
|
||
list.push_back(szPath);
|
||
}
|
||
std::string GetPwdHash();
|
||
std::string GetHMAC(int offset);
|
||
auto files = PreprocessFilesSimple(list);
|
||
|
||
// 检查客户端是否支持 V2
|
||
uint64_t clientID = GetClientID();
|
||
context* mainCtx = m_pParent->FindHost(clientID);
|
||
|
||
if (mainCtx && SupportsFileTransferV2(mainCtx)) {
|
||
// V2 传输
|
||
m_pParent->SendFilesToClientV2(mainCtx, files);
|
||
Mprintf("【拖拽】 [本地 -> 远程] V2 传输: %zu 个文件\n", files.size());
|
||
} else {
|
||
// V1 传输（兼容旧客户端）
|
||
auto str = BuildMultiStringPath(files);
|
||
BYTE* szBuffer = new BYTE[1 + 80 + str.size()];
|
||
szBuffer[0] = { COMMAND_GET_FOLDER };
|
||
std::string masterId = GetPwdHash(), hmac = GetHMAC(100);
|
||
memcpy((char*)szBuffer + 1, masterId.c_str(), masterId.length());
|
||
memcpy((char*)szBuffer + 1 + masterId.length(), hmac.c_str(), hmac.length());
|
||
memcpy(szBuffer + 1 + 80, str.data(), str.size());
|
||
auto md5 = CalcMD5FromBytes((BYTE*)str.data(), str.size());
|
||
m_pParent->m_CmdList.PutCmd(md5);
|
||
m_ContextObject->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::InitAudioPlayback(const AudioFormat* fmt)
|
||
{
|
||
if (m_bAudioPlaying) return TRUE;
|
||
|
||
// 保存压缩类型
|
||
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) {
|
||
Mprintf("[ScreenSpy] waveOutOpen 失败: %d\n", result);
|
||
return FALSE;
|
||
}
|
||
|
||
// 分配 waveOut 缓冲区
|
||
for (int i = 0; i < AUDIO_BUFFER_COUNT; 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;
|
||
waveOutPrepareHeader(m_hWaveOut, &m_WaveHdr[i], sizeof(WAVEHDR));
|
||
}
|
||
|
||
// 分配环形缓冲区
|
||
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()
|
||
{
|
||
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;
|
||
|
||
Mprintf("[ScreenSpy] 音频播放已停止\n");
|
||
}
|
||
|
||
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;
|
||
|
||
// 如果带有格式信息，初始化播放
|
||
if (hasFormat && len >= 1 + sizeof(AudioFormat)) {
|
||
AudioFormat* fmt = (AudioFormat*)(pData + 1);
|
||
if (!m_bAudioPlaying) {
|
||
InitAudioPlayback(fmt);
|
||
}
|
||
offset = 1 + sizeof(AudioFormat);
|
||
|
||
// 检测到音频数据，更新菜单状态
|
||
if (!m_Settings.AudioEnabled) {
|
||
m_Settings.AudioEnabled = TRUE;
|
||
CMenu* SysMenu = GetSystemMenu(FALSE);
|
||
if (SysMenu) {
|
||
SysMenu->CheckMenuItem(IDM_AUDIO_TOGGLE, MF_CHECKED);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!m_bAudioPlaying || !m_hWaveOut || !m_pRingBuf) return;
|
||
|
||
// 获取音频数据
|
||
BYTE* pAudioData = pData + offset;
|
||
UINT32 audioLen = len - offset;
|
||
if (audioLen == 0) return;
|
||
|
||
// 帧对齐参数
|
||
DWORD blockAlign = m_AudioFormat.nBlockAlign;
|
||
if (blockAlign == 0) blockAlign = 4; // 默认 stereo 16-bit
|
||
|
||
#if USING_OPUS
|
||
// Opus 解码
|
||
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;
|
||
|
||
// 检查环形缓冲区是否有足够空间
|
||
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 缓冲区
|
||
FeedAudioBuffers();
|
||
}
|
||
|
||
void CScreenSpyDlg::FeedAudioBuffers()
|
||
{
|
||
if (!m_bAudioPlaying || !m_hWaveOut || !m_pRingBuf) return;
|
||
|
||
// 帧对齐参数
|
||
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) {
|
||
Mprintf("[Audio] waveOutWrite 失败: %d\n", mr);
|
||
}
|
||
}
|
||
|
||
// 更新下一个缓冲区索引（找到第一个空闲的）
|
||
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;
|
||
}
|
||
}
|
||
|
||
LRESULT CScreenSpyDlg::OnWaveOutDone(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
// waveOut 缓冲区播放完成，尝试填充更多数据
|
||
if (m_bAudioPlaying && m_nRingDataLen > 0) {
|
||
FeedAudioBuffers();
|
||
}
|
||
return 0;
|
||
}
|