From d6b04a98f0061dd8e00dfaf39b4df7d40a86189e Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Thu, 5 Nov 2026 14:01:08 +0100 Subject: [PATCH] Feature: throughput criterion for adaptive quality, plus anti-oscillation Adaptive quality only looked at RTT, so a short RTT over a narrow pipe read as "excellent": at 20-40ms it picks Ultra/High (DIFF/RGB565), both with bitRate == 0, and never steps down. One 1080p RGB565 frame is 4.15 MB -- 1.66s of transmission on 20 Mbps. Adds GetTargetQualityLevelByLoad(): congestion needs both fps < 60% of baseline and bytes/frame still near the nominal bitrate, because a static screen has a near-zero byte rate on any link. Merged with the RTT result as max() -- averaging lets a good RTT mask a narrow pipe. Step-down is 3 confirmations and jumps straight to the level the throughput can carry (capped at +2); step-up stays RTT-only, so the criterion is one-way and the worst case is one level too low instead of a 30s/15s oscillation. Anti-oscillation, all inside the switch: RTT hysteresis (85%/115% dead band against the target level's threshold), failed step-up pinned for 3 minutes, cooldowns 3s -> 10s down / 15s up, counters interrupt each other, and a hard limit of 6 changes per 5 minutes. Server-only, no client change. m_ulBytesThisSecond had to be fixed first: it is accumulated before the switch, so file transfer, audio and clipboard counted as screen traffic; added m_ulScreenBytesThisSecond for the four frame cases. Also gates a real bug in the 10s post-step-down probe that disabled the criterion permanently on a static screen. Default on (same migration caveat as the other four). Unticking takes the original path unchanged. Verified on Debug: 27 hysteresis cases and the load cases pass, menu defaults correct; not yet measured end to end. --- common/commands.h | 96 ++++++++++- server/2015Remote/2015Remote.rc | Bin 181066 -> 181220 bytes server/2015Remote/2015RemoteDlg.cpp | 19 +++ server/2015Remote/2015RemoteDlg.h | 13 +- server/2015Remote/ScreenSpyDlg.cpp | 235 +++++++++++++++++++++++++-- server/2015Remote/ScreenSpyDlg.h | 25 ++- server/2015Remote/lang/de_DE.ini | 1 + server/2015Remote/lang/en_US.ini | 1 + server/2015Remote/lang/zh_TW.ini | 1 + server/2015Remote/resource.h | 4 +- test/CMakeLists.txt | 28 +++- test/unit/screen/QualityLoadTest.cpp | 143 ++++++++++++++++ 12 files changed, 543 insertions(+), 23 deletions(-) create mode 100644 test/unit/screen/QualityLoadTest.cpp diff --git a/common/commands.h b/common/commands.h index 152b8e8..54bdb32 100644 --- a/common/commands.h +++ b/common/commands.h @@ -1406,8 +1406,9 @@ inline const PreviewProfile& GetScreenPreviewProfile(int level) { return g_PreviewProfiles[level]; } -// 根据RTT获取目标质量等级 (控制端使用) -inline int GetTargetQualityLevel(int rtt, int usingFRP) { +// RTT 阈值表(毫秒,上界):rtt 小于阈值 i 就落在等级 i。 +// 单独提出来是因为迟滞判据要按当前档位回查阈值,不能再藏在 GetTargetQualityLevel 里。 +inline const int* GetRttThresholds(int usingFRP) { // 根据模式应用不同 RTT阈值 (毫秒) static const int g_RttThresholds[2][QUALITY_COUNT] = { // 直连: ULTRA, HIGH, GOOD, MEDIUM, LOW, MINIMAL @@ -1415,13 +1416,102 @@ inline int GetTargetQualityLevel(int rtt, int usingFRP) { // FRP: /* PROXY */ { 60, 160, 300, 500, 800, INT_MAX }, }; + return g_RttThresholds[(usingFRP != 0) ? 1 : 0]; +} + +// 根据RTT获取目标质量等级 (控制端使用) +inline int GetTargetQualityLevel(int rtt, int usingFRP) { + const int* thr = GetRttThresholds(usingFRP); for (int i = 0; i < QUALITY_COUNT; i++) { - if (rtt < g_RttThresholds[usingFRP][i]) + if (rtt < thr[i]) return i; } return QUALITY_MINIMAL; } +// 带迟滞的 RTT 判据:把"升档"和"降档"的阈值错开,落在死区里就保持当前档位。 +// +// 为什么需要:RTT 是每秒采样一次的抖动量,±5ms 很常见。硬阈值下 rtt 在 78↔82 +// 之间晃就会让目标档在 1↔2 之间反复跳,而 1↔2 正好是"原始分辨率 RGB565" ↔ +// "1920 H264" 的分界 —— 每跳一次都是一次编码器重建 + 整屏重传,用户看到的是 +// 周期性花屏/卡顿。加上死区后,只有 RTT 明显变好或明显变坏才会动档位。 +// +// 死区宽度取 ±15%: +// 想升档到 raw → rtt 必须低于【目标档】阈值(raw) 的 85% +// 想降档 → rtt 必须高于【当前档】阈值 的 115% +// 升档用目标档阈值是必须的:如果拿当前档阈值去比,由于阈值表单调递增, +// "raw < currentLevel" 本身就意味着 rtt 已经低于当前档阈值一大截, +// 85% 那条恒成立,迟滞等于没加(这个坑是写完算例才发现的)。 +// +// currentLevel 不合法时退化成无迟滞的 GetTargetQualityLevel。 +inline int GetTargetQualityLevelHysteresis(int rtt, int usingFRP, int currentLevel) +{ + if (rtt <= 0) return currentLevel; + if (currentLevel < 0 || currentLevel >= QUALITY_COUNT) + return GetTargetQualityLevel(rtt, usingFRP); + + const int* thr = GetRttThresholds(usingFRP); + const int raw = GetTargetQualityLevel(rtt, usingFRP); + + // 升档(数字变小):必须比目标档的边界再好 15%。用 long long 防 INT_MAX 溢出。 + if (raw < currentLevel) { + return ((long long)rtt * 100 < (long long)thr[raw] * 85) ? raw : currentLevel; + } + // 降档(数字变大):必须比当前档的边界再差 15%。 + if (raw > currentLevel) { + return ((long long)rtt * 100 > (long long)thr[currentLevel] * 115) ? raw : currentLevel; + } + return currentLevel; +} + +// 吞吐判据:根据实测帧率与屏幕字节速率,判断链路是否已经饱和(控制端使用)。 +// +// 返回该判据要求的最低质量等级(数字越大越差);链路没在拖后腿时返回 -1(无约束)。 +// 由调用方与 RTT 判据取 max() 合并 —— 两个约束方向相反,任一都能单独压低档位: +// RTT = 延迟预算 → 质量上限(延迟大就别给高清) +// 吞吐 = 带宽预算 → 质量下限(带宽小就装不下高码率) +// 相加/加权平均是错的:两者不互补,取平均会让"RTT 好"掩盖"带宽窄",反之亦然。 +// +// 关键点:这里判断的是"链路是否拒绝交付要求的东西",不是"传了多少字节"。 +// 后者是个陷阱 —— 画面静止时字节速率接近零,哪怕链路是 1Gbps 也会被判成"带宽差"。 +// 所以必须两个条件同时成立: +// ① 帧率明显低于基线(基线由调用方实测学习,见 CScreenSpyDlg::EvaluateQuality) +// ② 每帧字节数明显超过该档标称的每帧字节数 → 一帧要塞很久,帧又大又慢 +// 只满足 ① 是画面本来就没变化(客户端 memcmp 跳帧),不构成带宽问题。 +// +// ② 比的是"每帧字节数"而不是"每秒总字节数",这一点很关键:总字节数会随链路容量 +// 一起变小,容量远低于标称码率时(比如 900kbps 跑 3000kbps 的档)永远达不到 +// "半满",反而漏判。每帧字节数只反映"链路交付一帧要多久",与容量无关, +// 容量略低和远低两种情形都能覆盖。 +// +// nominalKbps == 0 表示该档没有码率控制(Ultra/High 走 DIFF/RGB565 原始像素), +// 此时没有可比的标称码率:帧率缺口本身就是唯一证据,直接按实测吞吐反查目标档。 +inline int GetTargetQualityLevelByLoad(int fps, int baselineFps, int kbps, int nominalKbps) +{ + // kbps <= 0 一并挡掉:没有实测吞吐就没法反查目标档, + // 否则 nominalKbps == 0 的档位会走到反查循环、误返回最低档。 + if (baselineFps <= 0 || fps <= 0 || kbps <= 0) return -1; + + // 帧率缺口:低于基线的 60% 才算,避免正常抖动误触发 + if (fps * 100 >= baselineFps * 60) return -1; + + if (nominalKbps > 0) { + // 实际每帧字节 / 标称每帧字节 = (kbps / fps) / (nominalKbps / baselineFps) + // = kbps * baselineFps / (nominalKbps * fps) + // 不到 2 倍就说明帧本身不大,链路没在拖后腿(只是画面变化少),不构成带宽问题。 + if ((long long)kbps * baselineFps <= 2LL * nominalKbps * fps) return -1; + } + + // 按实测吞吐(饱和时它 ≈ 链路容量)反查能装下的最高档位,允许跨级直达。 + // 逐级降要经历多次分辨率重建,每次都是一次编码器重建 + 可见卡顿; + // 一次跳到对的位置只重建一次。0.85 是给码率波动留的余量。 + for (int level = QUALITY_GOOD; level < QUALITY_COUNT; level++) { + const int need = GetQualityProfile(level).bitRate; + if (need > 0 && need <= kbps * 85 / 100) return level; + } + return QUALITY_MINIMAL; +} + typedef struct ScreenSettings { int MaxFPS; // 偏移 0, 最大帧率 int CompressThread; // 偏移 4, 压缩线程数 diff --git a/server/2015Remote/2015Remote.rc b/server/2015Remote/2015Remote.rc index 36498e6bf1dae23e46c27f4f5b4b415b2ab9a992..a9ad4fabfe96fa67dfddff36635614705cff2bd2 100644 GIT binary patch delta 93 zcmV-j0HXiOh706}3xI?Hv;uS?lMojOmoVA^6cFlx0+5tmpi&-G5L6^mZey3Q-vJ_* zpaKFAmo^~+4iP~BL;yhmPykc_NdQ&=MF3xyPxk>GmpY{Z5|{4%0aUlzAp&rrnExIa delta 29 lcmaFT&V8zlyP<_~3sZ^W^aXlMI@1F_F{*7(P-1FX2mr4P3l#tW diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index 5ea64d2..5127ff1 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -1152,6 +1152,7 @@ BEGIN_MESSAGE_MAP(CMy2015RemoteDlg, CDialogEx) ON_COMMAND(ID_TOOL_TUNING_X264_VBV, &CMy2015RemoteDlg::OnToolTuningX264Vbv) ON_COMMAND(ID_TOOL_TUNING_GDI_SLEEP, &CMy2015RemoteDlg::OnToolTuningGdiSleep) ON_COMMAND(ID_TOOL_TUNING_PACE_FPS_FLOOR, &CMy2015RemoteDlg::OnToolTuningPaceFpsFloor) + ON_COMMAND(ID_TOOL_TUNING_ADAPTIVE_LOAD, &CMy2015RemoteDlg::OnToolTuningAdaptiveLoad) ON_COMMAND(ID_EXECUTE_TESTRUN, &CMy2015RemoteDlg::OnExecuteTestrun) ON_COMMAND(ID_EXECUTE_GHOST, &CMy2015RemoteDlg::OnExecuteGhost) ON_COMMAND(ID_MASTER_TRAIL, &CMy2015RemoteDlg::OnMasterTrail) @@ -2808,6 +2809,10 @@ BOOL CMy2015RemoteDlg::OnInitDialog() m_bTuningX264Vbv = THIS_CFG.GetInt("settings", "TuningX264Vbv", 1) != 0; m_bTuningGdiNoSleep = THIS_CFG.GetInt("settings", "TuningGdiNoSleep", 1) != 0; m_bTuningPaceFpsFloor = THIS_CFG.GetInt("settings", "TuningPaceFpsFloor", 1) != 0; + // 自适应加吞吐判据:纯服务端,默认开。判据分不清"链路慢"和"本机慢", + // 所以配套了三条防振荡措施(RTT 迟滞、升档失败封顶、探测样本门槛), + // 见 CScreenSpyDlg::EvaluateQuality。取消勾选即完全回到只看 RTT 的行为。 + m_bAdaptiveDualCriteria = THIS_CFG.GetInt("settings", "AdaptiveDualCriteria", 1) != 0; if (CMenu* advMenu = m_MainMenu.GetSubMenu(5)) { advMenu->CheckMenuItem(ID_TOOL_EMBED_TLS_ANCHOR, m_bEmbedTlsInDll ? MF_CHECKED : MF_UNCHECKED); @@ -10785,6 +10790,8 @@ void CMy2015RemoteDlg::SyncTuningMenuChecks() m_bTuningGdiNoSleep ? MF_CHECKED : MF_UNCHECKED); tuningMenu->CheckMenuItem(ID_TOOL_TUNING_PACE_FPS_FLOOR, m_bTuningPaceFpsFloor ? MF_CHECKED : MF_UNCHECKED); + tuningMenu->CheckMenuItem(ID_TOOL_TUNING_ADAPTIVE_LOAD, + m_bAdaptiveDualCriteria ? MF_CHECKED : MF_UNCHECKED); } // 高级→远程桌面调优→x264 码率封顶(VBV):默认开,取消勾选即关闭。 @@ -10825,6 +10832,18 @@ void CMy2015RemoteDlg::OnToolTuningPaceFpsFloor() m_bTuningPaceFpsFloor ? 1 : 0); } +// 高级→远程桌面调优→自适应加吞吐判据:默认关,取消/勾选立即对当前会话生效。 +// 与前四项不同,这一项是纯服务端的:只改 CScreenSpyDlg::EvaluateQuality 的判据, +// 不下发任何命令给客户端,所以不需要 CMD_SCREEN_TUNING 位,也不必重开远程桌面窗口。 +void CMy2015RemoteDlg::OnToolTuningAdaptiveLoad() +{ + m_bAdaptiveDualCriteria = !m_bAdaptiveDualCriteria; + THIS_CFG.SetInt("settings", "AdaptiveDualCriteria", m_bAdaptiveDualCriteria ? 1 : 0); + SyncTuningMenuChecks(); + Mprintf("[Tuning] AdaptiveDualCriteria = %d(自适应质量的吞吐判据)\n", + m_bAdaptiveDualCriteria ? 1 : 0); +} + // 当前调优开关位,供 CScreenSpyDlg 打开远程桌面时下发 CMD_SCREEN_TUNING。 int CMy2015RemoteDlg::GetScreenTuningFlags() const { diff --git a/server/2015Remote/2015RemoteDlg.h b/server/2015Remote/2015RemoteDlg.h index 6e9c20d..5fee415 100644 --- a/server/2015Remote/2015RemoteDlg.h +++ b/server/2015Remote/2015RemoteDlg.h @@ -280,19 +280,28 @@ public: void ReloadKernelPayloads(); // 高级→DLL内嵌TLS证书 afx_msg void OnToolEmbedTlsAnchor(); - // 高级→远程桌面调优:三项默认全开,取消勾选即回到加开关前的行为。 - // 勾选后打开远程桌面时经 CMD_SCREEN_TUNING 下发,某项出问题可以只关那一项。 + // 高级→远程桌面调优:四项默认全开,取消勾选即回到加开关前的行为。 + // 前三项勾选后经 CMD_SCREEN_TUNING 下发客户端,某项出问题可以只关那一项。 // 持久化在 [settings] Tuning*;注意默认值只对没写过该键的机器生效。 bool m_bTuningX264Vbv = true; // TUNING_X264_VBV x264 软编加 VBV 码率封顶 bool m_bTuningGdiNoSleep = true; // TUNING_GDI_NO_SLEEP GDI 抓屏去分段延时 bool m_bTuningPaceFpsFloor = true; // TUNING_PACE_FPS_FLOOR 发送节流帧率下限 + // 高级→远程桌面调优→自适应加吞吐判据:这一项是纯服务端的,不下发客户端。 + // 自适应原本只看 RTT,"短 RTT + 窄链路"会被判成网络很好(RTT 20~40ms 时甚至会选到 + // DIFF/RGB565 那两个零码率控制的档位);勾选后增加"链路是否已饱和"作为第二判据, + // 与 RTT 判据取更保守者。持久化在 [settings] AdaptiveDualCriteria,默认开。 + // 防振荡(RTT 迟滞 / 升档失败封顶 / 探测样本门槛)都门控在开关内,见 EvaluateQuality。 + bool m_bAdaptiveDualCriteria = true; afx_msg void OnToolTuningX264Vbv(); afx_msg void OnToolTuningGdiSleep(); afx_msg void OnToolTuningPaceFpsFloor(); + afx_msg void OnToolTuningAdaptiveLoad(); // 把上述各项的勾选状态同步到「远程桌面调优」子菜单 void SyncTuningMenuChecks(); // 当前调优开关位,供 CScreenSpyDlg 下发 CMD_SCREEN_TUNING 用 int GetScreenTuningFlags() const; + // 自适应质量是否启用吞吐判据(双判据),供 CScreenSpyDlg::EvaluateQuality 查询 + bool IsAdaptiveDualCriteria() const { return m_bAdaptiveDualCriteria; } MasterSettings m_settings; // 缓存上次检测到的上级 FRP 配置([settings] FrpConfig),由定时器检测外部模块写入的变更。 // 检出变更后会热切换 FRPC(首次=启动 / 覆盖=重启 / 撤销=停止),并在主对话框信息列表中给出友好提示。 diff --git a/server/2015Remote/ScreenSpyDlg.cpp b/server/2015Remote/ScreenSpyDlg.cpp index 4c9764b..04f731b 100644 --- a/server/2015Remote/ScreenSpyDlg.cpp +++ b/server/2015Remote/ScreenSpyDlg.cpp @@ -1116,14 +1116,17 @@ VOID CScreenSpyDlg::OnReceiveComplete() } break; } + // 下面四个帧 TOKEN 都累加屏幕字节:吞吐判据只看屏幕数据,不含文件/音频/剪贴板 case TOKEN_FIRSTSCREEN: { DrawFirstScreen(); m_ulFramesThisSecond++; + m_ulScreenBytesThisSecond += len; break; } case TOKEN_NEXTSCREEN: { DrawNextScreenDiff(false); m_ulFramesThisSecond++; + m_ulScreenBytesThisSecond += len; break; } case TOKEN_KEYFRAME: { @@ -1131,6 +1134,7 @@ VOID CScreenSpyDlg::OnReceiveComplete() DrawNextScreenDiff(true); } m_ulFramesThisSecond++; + m_ulScreenBytesThisSecond += len; break; } case TOKEN_SCROLL_FRAME: { @@ -1138,6 +1142,7 @@ VOID CScreenSpyDlg::OnReceiveComplete() DrawScrollFrame(); } m_ulFramesThisSecond++; + m_ulScreenBytesThisSecond += len; break; } case TOKEN_CLIPBOARD_TEXT: { @@ -2473,8 +2478,13 @@ void CScreenSpyDlg::OnTimer(UINT_PTR nIDEvent) // 计算传输速率并更新标题 m_dTransferRate = m_ulBytesThisSecond / 1024.0; // KB/s m_ulBytesThisSecond = 0; + // 屏幕数据速率单独留存给吞吐判据:上面那个总量混了文件传输/音频/剪贴板, + // 传大文件时会让判据误判"链路塞满"。 + m_dScreenKBps = m_ulScreenBytesThisSecond / 1024.0; + m_ulScreenBytesThisSecond = 0; // 使用EMA平滑帧率 (alpha=0.3),避免跳跃 double currentFPS = (double)m_ulFramesThisSecond; + m_ulFramesLastSecond = m_ulFramesThisSecond; // 原始值给吞吐判据,EMA 对判据太迟钝 if (m_dFrameRate == 0) { m_dFrameRate = currentFPS; // 首次直接赋值 } else { @@ -2585,17 +2595,121 @@ void CScreenSpyDlg::EvaluateQuality() { if (!m_AdaptiveQuality.enabled) return; - // 0. 启动延迟:1分钟内不进行自适应调整 ULONGLONG now = GetTickCount64(); - if (now - m_AdaptiveQuality.startTime < 60000) return; - // 1. 获取RTT + // 0. 启动延迟兼基线学习:前 1 分钟不调整,但用这段时间实测本会话的健康帧率。 + // 客户端发送循环的基线是 8fps(ScreenManager.cpp 里 sleep = 1000/8),链路好时 + // 会自己按 1.03 倍加速,所以用实测峰值,而不是把客户端常量抄到服务端来。 + if (now - m_AdaptiveQuality.startTime < 60000) { + if (m_dFrameRate > m_AdaptiveQuality.baselineFps) + m_AdaptiveQuality.baselineFps = m_dFrameRate; + return; + } + if (m_AdaptiveQuality.baselineFps < 1.0) { + // 学习窗口内几乎没收到帧(画面一直静止),退回发送循环的基线 8fps; + // 该档 MaxFPS 配得比 8 更低时以 MaxFPS 为准,不能把基线抬到用户上限之上。 + double floorFps = 8.0; + int lvlMaxFps = GetQualityProfile(m_AdaptiveQuality.currentLevel).maxFPS; + if (lvlMaxFps > 0 && lvlMaxFps < 8) floorFps = (double)lvlMaxFps; + m_AdaptiveQuality.baselineFps = floorFps; + } + + // 0.5 降档后观察:真带宽受限时降档同时降低分辨率和码率,管道立刻缓解、帧率必须回升; + // 本机受限(抓屏/编码慢)时降码率对帧率几乎没帮助。10 秒后帧率仍不达标、 + // 且管道明显没被填满,就判定瓶颈在本机,本次会话停用吞吐判据。 + // 停用后就是加这个判据之前的行为,所以误判的代价只是"这一项没生效", + // 不会把画质永久压低,也顺带掐掉"降档→抓屏变快→升档→又变慢"的慢速振荡。 + if (m_AdaptiveQuality.loadProbeTime != 0 && + now - m_AdaptiveQuality.loadProbeTime >= 10000) { + m_AdaptiveQuality.loadProbeTime = 0; + // 样本门槛:这 10 秒里几乎没收到帧,说明画面一直静止(客户端 memcmp 跳帧), + // 既不能证明降档奏效也不能证明没奏效。此时若照常判定,"帧率低 + 帧很小" + // 会被误读成"本机瓶颈",一次静止就永久停用吞吐判据。宁可放弃这次探测。 + if (m_ulFramesLastSecond < 2) { + Mprintf("[Adaptive] 降档观察窗内仅 %u 帧,样本不足,放弃本次本机瓶颈判定\n", + m_ulFramesLastSecond); + } else { + int needKbps = GetQualityProfile(m_AdaptiveQuality.currentLevel).bitRate; + int nowKbps = (int)(m_dScreenKBps * 8); + // 帧率仍然不达标、但按同一套判据已经不算饱和 → 帧并不大却发不出来, + // 说明瓶颈在本机(抓屏/编码),而不是链路。这里复用同一个判据, + // 不再另写一套阈值,避免两处口径不一致。 + bool stillShort = (m_dFrameRate < m_AdaptiveQuality.baselineFps * 0.6); + bool notSaturated = (GetTargetQualityLevelByLoad( + (int)m_ulFramesLastSecond, + (int)(m_AdaptiveQuality.baselineFps + 0.5), + nowKbps, needKbps) < 0); + if (stillShort && notSaturated) { + m_AdaptiveQuality.loadPinned = true; + Mprintf("[Adaptive] 降档后帧率未回升 (%.1f < %.1f) 且帧已不大 (%d/%dkbps)," + "判定瓶颈在本机,本次会话停用吞吐判据\n", + m_dFrameRate, m_AdaptiveQuality.baselineFps * 0.6, nowKbps, needKbps); + } + } + } + + int currentLevel = m_AdaptiveQuality.currentLevel; + const bool dual = (m_pParent && m_pParent->IsAdaptiveDualCriteria()); + + // 0.9 锁档检查(放在所有判据之前,锁档期间一次评估都不做)。 + // 上面的措施各自针对一种具体成因,这一条是不依赖成因的兜底。 + if (dual) { + if (m_AdaptiveQuality.lockUntil != 0) { + if (now < m_AdaptiveQuality.lockUntil) return; + m_AdaptiveQuality.lockUntil = 0; + m_AdaptiveQuality.changeWindowStart = now; + m_AdaptiveQuality.changeCountInWindow = 0; + } + } + + // 1. RTT 判据:延迟预算 → 质量上限 int rtt = GetClientRTT(); - if (rtt <= 0) return; - m_AdaptiveQuality.lastRTT = rtt; + if (rtt > 0) m_AdaptiveQuality.lastRTT = rtt; + int levelRTT; + if (dual) { + // 双判据模式下沿用上次 RTT:ping 偶尔丢包、frp 隧道抖动时取不到值, + // 不能让整个评估停摆(原来直接 return,会话会一直卡在当前档位)。 + // 并且改用带迟滞的版本:硬阈值在 78↔82 这种边界抖动下会让档位每秒翻一次, + // 每次都是编码器重建 + 整屏重传。迟滞把升降阈值错开 ±15%,死区内保持不动。 + levelRTT = (m_AdaptiveQuality.lastRTT > 0) + ? GetTargetQualityLevelHysteresis(m_AdaptiveQuality.lastRTT, + m_bUsingFRP, currentLevel) + : -1; + } else { + // 开关没开时保持原样:拿不到 RTT 就不评估。 + if (rtt <= 0) return; + levelRTT = GetTargetQualityLevel(rtt, m_bUsingFRP); + } - // 2. 计算目标等级 - int targetLevel = GetTargetQualityLevel(rtt, m_bUsingFRP); + // 2. 吞吐判据:带宽预算 → 质量下限 + // 与 RTT 判据取 max() 合并。两个约束方向相反,任一都能单独压低档位, + // 加权平均会让"RTT 好"掩盖"带宽窄"(短 RTT + 窄链路是本判据唯一能抓住的场景)。 + int levelLoad = -1; + if (dual && !m_AdaptiveQuality.loadPinned) { + const QualityProfile& prof = GetQualityProfile(currentLevel); + int nowKbps = (int)(m_dScreenKBps * 8); + levelLoad = GetTargetQualityLevelByLoad( + (int)(m_ulFramesLastSecond + 0.5), + (int)(m_AdaptiveQuality.baselineFps + 0.5), + nowKbps, + prof.bitRate); + // 最多比 RTT 判据再压低 2 级。判据本身分不清"链路慢"和"本机慢",限幅保证 + // 误判时只掉两档,不会被某一秒的抖动打到最低。 + if (levelLoad >= 0) { + int cap = (levelRTT >= 0 ? levelRTT : currentLevel) + 2; + if (levelLoad > cap) levelLoad = cap; + } + if (levelLoad >= 0 && levelLoad > levelRTT) { + Mprintf("[Adaptive] 吞吐判据: fps=%u(基线%.0f) 屏幕=%.0fKB/s(≈%dkbps) " + "本档标称=%dkbps → level %d(RTT 判据给 %d)\n", + m_ulFramesLastSecond, m_AdaptiveQuality.baselineFps, + m_dScreenKBps, nowKbps, prof.bitRate, levelLoad, levelRTT); + } + } + + // 3. 合并:取更保守者(档位数字越大越差) + int targetLevel = (levelRTT > levelLoad) ? levelRTT : levelLoad; + if (targetLevel < 0) return; // 两个判据都拿不到数据 // Web 会话只解码 H264。levels 0 (Ultra/DIFF) 和 1 (High/RGB565) 在网络好的时候 // 会被自适应控制器选中,但 device 切到那两个算法后浏览器的 WebCodecs decoder @@ -2606,47 +2720,126 @@ void CScreenSpyDlg::EvaluateQuality() targetLevel = QUALITY_GOOD; } - int currentLevel = m_AdaptiveQuality.currentLevel; + // 3.5 升档失败封顶:升档后 20 秒内又降回升档前的档位或更差,说明那次升档是错的 + // (典型是"降档→队列排空→RTT 变好→升档→队列又满→RTT 变差"的 bufferbloat 循环, + // 跨洲际 + frp 大缓冲链路最容易出现)。记下升档前的档位,3 分钟内不再尝试好于它。 + // 宁可停在低一档,也不要在两个档位之间每 30 秒重建一次编码器和分辨率。 + // 思路同 TCP 的 ssthresh:失败一次就把天花板降下来,而不是继续试探。 + // 惩罚期取 3 分钟:够长以压住振荡,又不至于网络真恢复后一直卡在低档。 + if (dual && m_AdaptiveQuality.levelCeiling >= 0) { + if (now >= m_AdaptiveQuality.ceilingUntil) { + m_AdaptiveQuality.levelCeiling = -1; // 惩罚期结束,恢复自由升档 + } else if (targetLevel < m_AdaptiveQuality.levelCeiling && + m_AdaptiveQuality.levelCeiling <= currentLevel) { + // 只压升档方向。加 levelCeiling <= currentLevel 的守卫是为了防止状态异常时 + // 反过来强制降档 —— 封顶的语义是"不许更好",不是"必须更差"。 + targetLevel = m_AdaptiveQuality.levelCeiling; + } + } if (targetLevel == currentLevel) { m_AdaptiveQuality.stableCount = 0; + m_AdaptiveQuality.loadCount = 0; return; } - // 3. 检查是否涉及分辨率变化 + // 4. 检查是否涉及分辨率变化 int currentMaxWidth = GetQualityProfile(currentLevel).maxWidth; int targetMaxWidth = GetQualityProfile(targetLevel).maxWidth; bool resolutionChange = (currentMaxWidth != targetMaxWidth); - // 4. 冷却时间检查 + // 5. 冷却时间检查 // - 分辨率变化:降级15秒,升级30秒 - // - 纯FPS/算法变化:3秒 + // - 纯FPS/算法变化:3秒(双判据下放宽,见下) ULONGLONG cooldown = 3000; if (resolutionChange) { cooldown = (targetLevel > currentLevel) ? 15000 : 30000; if (now - m_AdaptiveQuality.lastResChangeTime < cooldown) return; } else { + if (dual) { + // 纯 FPS/算法变化的档位对里,0↔1 是 DIFF↔RGB565 —— 带宽差一个数量级 + // (差分 vs 原始像素 4MB/帧)。原来 3 秒的冷却意味着 RTT 在 30ms 边界上 + // 抖动时每 3 秒就能翻一次算法,用户看到的是持续花屏。双判据下放宽到 + // 10 秒降 / 15 秒升:至少十次采样才动一次,抖动被彻底吸收。 + cooldown = (targetLevel > currentLevel) ? 10000 : 15000; + } if (now - m_AdaptiveQuality.lastChangeTime < cooldown) return; } - // 5. 降级:快速响应 (连续2次) + // 6. 降级:RTT 判据连续 2 次即降(原有行为);吞吐判据要连续 3 次, + // 因为它是 1 秒窗口的字节数,比 RTT 抖得多。 if (targetLevel > currentLevel) { - m_AdaptiveQuality.stableCount++; - if (m_AdaptiveQuality.stableCount >= 2) { + const bool byLoad = (levelLoad > levelRTT); + // 两个判据各自连续计数,互相打断。交替出现说明两个判据都卡在临界点上, + // 此时保持现状比动档位安全 —— 否则就是"RTT 说降、吞吐说没事"的来回拉扯。 + if (byLoad) { + m_AdaptiveQuality.loadCount++; + m_AdaptiveQuality.stableCount = 0; + } else { + m_AdaptiveQuality.stableCount++; + m_AdaptiveQuality.loadCount = 0; + } + const int need = byLoad ? 3 : 2; + const int have = byLoad ? m_AdaptiveQuality.loadCount : m_AdaptiveQuality.stableCount; + if (have >= need) { + // 升档失败检测:上一次升档后 20 秒内就降回升档前的档位或更差 + if (dual && m_AdaptiveQuality.lastUpFromLevel >= 0 && + now - m_AdaptiveQuality.lastUpTime < 20000 && + targetLevel >= m_AdaptiveQuality.lastUpFromLevel) { + m_AdaptiveQuality.levelCeiling = m_AdaptiveQuality.lastUpFromLevel; + m_AdaptiveQuality.ceilingUntil = now + 180000; + Mprintf("[Adaptive] 升档失败(%d → %d,%.1f 秒后回到 %d)," + "3 分钟内封顶在 level %d\n", + m_AdaptiveQuality.lastUpFromLevel, + m_AdaptiveQuality.lastUpFromLevel - 1, + (now - m_AdaptiveQuality.lastUpTime) / 1000.0, + targetLevel, m_AdaptiveQuality.levelCeiling); + } + if (dual) NoteAdaptiveChange(now); ApplyQualityLevel(targetLevel); + if (byLoad) m_AdaptiveQuality.loadProbeTime = GetTickCount64(); } } - // 6. 升级:谨慎处理 (连续5次,且只升一级) + // 7. 升级:谨慎处理 (连续5次,且只升一级) + // 只用 RTT 判据。吞吐判据的"有余量"不可靠(画面静止时永远显示有余量), + // 让它参与升档会变成"静止就升、一动就降"的慢速振荡,所以吞吐只做单向约束:只压不抬。 else if (targetLevel < currentLevel) { + m_AdaptiveQuality.loadCount = 0; m_AdaptiveQuality.stableCount++; if (m_AdaptiveQuality.stableCount >= 5) { + if (dual) { + // 记下升档前的位置,供"升档失败封顶"判断 + m_AdaptiveQuality.lastUpTime = now; + m_AdaptiveQuality.lastUpFromLevel = currentLevel; + NoteAdaptiveChange(now); + } ApplyQualityLevel(currentLevel - 1); } } } +// 自适应切换的频率硬上限:5 分钟内最多 6 次,超了就锁档 5 分钟。 +// +// 前面几条措施(RTT 迟滞、升档失败封顶、冷却时间、判据互相打断)各自针对一种具体成因, +// 这一条不依赖成因,纯粹按"切换次数"兜底。理由是代价不对称:每次切档都要重建编码器, +// 分辨率档还要整屏重传,用户感知的代价远大于"画质差一档"。所以宁可锁在低档, +// 也不允许出现任何没预料到的振荡模式。 +void CScreenSpyDlg::NoteAdaptiveChange(ULONGLONG now) +{ + if (m_AdaptiveQuality.changeWindowStart == 0 || + now - m_AdaptiveQuality.changeWindowStart > 300000) { + m_AdaptiveQuality.changeWindowStart = now; + m_AdaptiveQuality.changeCountInWindow = 0; + } + if (++m_AdaptiveQuality.changeCountInWindow > 6) { + m_AdaptiveQuality.lockUntil = now + 300000; + Mprintf("[Adaptive] 5 分钟内已切换 %d 次,锁档 5 分钟(防止档位反复重建)\n", + m_AdaptiveQuality.changeCountInWindow); + } +} + void CScreenSpyDlg::ApplyQualityLevel(int level, bool persist) { if (level < 0 || level >= QUALITY_COUNT) return; @@ -2669,6 +2862,18 @@ void CScreenSpyDlg::ApplyQualityLevel(int level, bool persist) m_AdaptiveQuality.currentLevel = level; m_AdaptiveQuality.lastChangeTime = GetTickCount64(); m_AdaptiveQuality.stableCount = 0; + m_AdaptiveQuality.loadCount = 0; // 吞吐判据的确认计数同样清零,避免跨档位累积 + + // 手动选档(persist=1)时清掉升档封顶和锁档:那是自适应在本会话里试探出来的结论, + // 用户显式指定的档位不该被它压住,否则会出现"选了高档却一直被拉回去"。 + if (persist) { + m_AdaptiveQuality.levelCeiling = -1; + m_AdaptiveQuality.ceilingUntil = 0; + m_AdaptiveQuality.lastUpFromLevel = -1; + m_AdaptiveQuality.lockUntil = 0; + m_AdaptiveQuality.changeWindowStart = 0; + m_AdaptiveQuality.changeCountInWindow = 0; + } // 1. 发送 FPS 和算法 (persist=1 表示手动选择需要保存) BYTE cmd[4] = { CMD_QUALITY_LEVEL, (BYTE)level, (BYTE)persist }; diff --git a/server/2015Remote/ScreenSpyDlg.h b/server/2015Remote/ScreenSpyDlg.h index 6839b24..17a7146 100644 --- a/server/2015Remote/ScreenSpyDlg.h +++ b/server/2015Remote/ScreenSpyDlg.h @@ -341,10 +341,15 @@ public: CBmpToAvi m_aviStream; // 传输速率统计 - ULONG m_ulBytesThisSecond = 0; // 本秒累计字节 + ULONG m_ulBytesThisSecond = 0; // 本秒累计字节(含文件/音频/剪贴板,仅用于标题显示) double m_dTransferRate = 0; // 当前速率 (KB/s) + // 屏幕数据单独统计:m_ulBytesThisSecond 混入了文件传输、音频、剪贴板, + // 传大文件时会让吞吐判据误判"链路塞满",所以只统计帧 TOKEN 的字节。 + ULONG m_ulScreenBytesThisSecond = 0; + double m_dScreenKBps = 0; // 上一秒的屏幕数据速率 (KB/s) // 帧率统计 (使用EMA平滑) ULONG m_ulFramesThisSecond = 0; // 本秒累计帧数 + ULONG m_ulFramesLastSecond = 0; // 上一秒的原始帧数(吞吐判据用,不用 EMA) double m_dFrameRate = 0; // 平滑后的帧率 (FPS) // 自适应质量 @@ -357,6 +362,23 @@ public: ULONGLONG lastResChangeTime = 0; // 上次分辨率变化时间 ULONGLONG startTime = 0; // 启动时间 (用于延迟启动自适应) int stableCount = 0; // 稳定计数 (用于防抖) + // ===== 吞吐判据(双判据)状态 ===== + double baselineFps = 0; // 本会话健康帧率基线,启动后 60 秒内实测学习 + int loadCount = 0; // 吞吐判据的确认计数(字节速率抖动大,比 RTT 多等一拍) + ULONGLONG loadProbeTime = 0; // 降档后的观察起点,0=未在观察 + bool loadPinned = false; // 判定瓶颈在本机,本次会话停用吞吐判据 + // ===== 防振荡状态(只双判据模式下使用)===== + // 升档失败封顶:升档后短时间内又降回来,说明那次升档是错的, + // 在 ceilingUntil 之前不再尝试好于 levelCeiling 的档位(-1 = 无封顶)。 + // 思路同 TCP 的 ssthresh:宁可停在低一档,也不要在两个档位之间来回重建。 + int levelCeiling = -1; + ULONGLONG ceilingUntil = 0; + ULONGLONG lastUpTime = 0; // 上次升档的时间 + int lastUpFromLevel = -1; // 上次升档前的档位(回退到这里就封顶) + // 切换频率硬上限:不依赖具体成因的兜底,防止任何没预料到的振荡模式。 + ULONGLONG changeWindowStart = 0; // 当前统计窗口起点 + int changeCountInWindow = 0; // 窗口内的自适应切换次数 + ULONGLONG lockUntil = 0; // 锁档截止时间(0=未锁) } m_AdaptiveQuality; volatile bool m_bResolutionChanging = false; // 分辨率切换中,阻止解码 @@ -408,6 +430,7 @@ public: int GetClientRTT(); // 获取客户端RTT(ms) void EvaluateQuality(); // 评估并调整质量 void ApplyQualityLevel(int level, bool persist = false); // 应用质量等级 + void NoteAdaptiveChange(ULONGLONG now); // 自适应切换频率计数,超限则锁档 const char* GetQualityName(int level); // 获取质量等级名称 void UpdateQualityMenuCheck(CMenu* SysMenu = nullptr); // 更新质量菜单勾选状态 diff --git a/server/2015Remote/lang/de_DE.ini b/server/2015Remote/lang/de_DE.ini index b22cdaf..04d244b 100644 --- a/server/2015Remote/lang/de_DE.ini +++ b/server/2015Remote/lang/de_DE.ini @@ -2090,6 +2090,7 @@ MCPԶ x264 ÂëÂʷⶥ (VBV)=x264 Bitraten-Deckel (VBV) GDI ץÆÁȥ·ֶÎÑÓʱ=GDI-Aufnahme ohne Segment-Pause ·¢ËͽÚÁ÷֡ÂÊÏÂÏÞ=Mindest-Framerate beim Senden +×ÔÊÊӦ¼ÓÍÌÍÂÅоÝ=Durchsatz-Kriterium (adaptiv) µȼ¶=Stufe ֡ÂÊ(FPS)=FPS ×î´ó¿í¶È=Max. Breite diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 56947c8..d744817 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -2095,6 +2095,7 @@ HTTPS x264 ÂëÂʷⶥ (VBV)=x264 bitrate cap (VBV) GDI ץÆÁȥ·ֶÎÑÓʱ=GDI capture: no per-slice delay ·¢ËͽÚÁ÷֡ÂÊÏÂÏÞ=Send pacing FPS floor +×ÔÊÊӦ¼ÓÍÌÍÂÅоÝ=Adaptive throughput criterion µȼ¶=Level ֡ÂÊ(FPS)=FPS ×î´ó¿í¶È=Max Width diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index 5fb117e..9096f2f 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -2088,6 +2088,7 @@ HTTPS x264 ÂëÂʷⶥ (VBV)=x264 λԪÂÊÉÏÏÞ (VBV) GDI ץÆÁȥ·ֶÎÑÓʱ=GDI ”Xȡȥ³ý·ֶÎÑÓßt ·¢ËͽÚÁ÷֡ÂÊÏÂÏÞ=‚÷Ë͹�Á÷Ӱ¸ñÂÊÏÂÏÞ +×ÔÊÊӦ¼ÓÍÌÍÂÅоÝ=×Ôßm‘ª¼ÓÍÌÍÂÅГþ µȼ¶=µȼ‰ ֡ÂÊ(FPS)=ެÂÊ(FPS) ×î´ó¿í¶È=×î´󌒶È diff --git a/server/2015Remote/resource.h b/server/2015Remote/resource.h index 4877bd4..be3bc89 100644 --- a/server/2015Remote/resource.h +++ b/server/2015Remote/resource.h @@ -1126,6 +1126,8 @@ #define ID_TOOL_TUNING_X264_VBV 33102 #define ID_TOOL_TUNING_GDI_SLEEP 33103 #define ID_TOOL_TUNING_PACE_FPS_FLOOR 33104 +// 高级 → 远程桌面调优:自适应质量加吞吐判据(纯服务端,不下发客户端) +#define ID_TOOL_TUNING_ADAPTIVE_LOAD 33105 #define ID_EXIT_FULLSCREEN 40001 // Next default values for new objects @@ -1133,7 +1135,7 @@ #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 417 -#define _APS_NEXT_COMMAND_VALUE 33105 +#define _APS_NEXT_COMMAND_VALUE 33106 #define _APS_NEXT_CONTROL_VALUE 2621 #define _APS_NEXT_SYMED_VALUE 105 #endif diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index e89c7a2..496a7d5 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -310,6 +310,31 @@ if(UNIX) target_link_libraries(quality_adaptive_test Threads::Threads) endif() +# ============================================ +# 吞吐判据测试(自适应质量的双判据) +# 直接 include 真实 commands.h,不复制实现,所以需要把 common/ 加进头文件搜索路径 +# ============================================ +add_executable(quality_load_test + unit/screen/QualityLoadTest.cpp +) + +target_include_directories(quality_load_test PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/../common + ${CMAKE_CURRENT_SOURCE_DIR}/.. +) + +target_link_libraries(quality_load_test + GTest::gtest_main +) + +if(WIN32) + target_compile_definitions(quality_load_test PRIVATE _WIN32) +endif() + +if(UNIX) + target_link_libraries(quality_load_test Threads::Threads) +endif() + # ============================================ # 时间验证测试 (授权模块) # ============================================ @@ -382,6 +407,7 @@ gtest_discover_tests(diff_algorithm_test) gtest_discover_tests(rgb565_test) gtest_discover_tests(scroll_detector_test) gtest_discover_tests(quality_adaptive_test) +gtest_discover_tests(quality_load_test) gtest_discover_tests(date_verify_test) # 自定义目标:运行所有测试 @@ -391,5 +417,5 @@ add_custom_target(run_tests file_transfer_test chunk_manager_test sha256_verify_test resume_state_test header_test packet_fragment_test http_mask_test diff_algorithm_test rgb565_test scroll_detector_test quality_adaptive_test - date_verify_test + quality_load_test date_verify_test ) diff --git a/test/unit/screen/QualityLoadTest.cpp b/test/unit/screen/QualityLoadTest.cpp new file mode 100644 index 0000000..b473d4c --- /dev/null +++ b/test/unit/screen/QualityLoadTest.cpp @@ -0,0 +1,143 @@ +// QualityLoadTest.cpp - 吞吐判据(自适应质量的第二判据)单元测试 +// +// 这个测试直接 include 真实的 common/commands.h,不复制实现。 +// 对比:同目录的 QualityAdaptiveTest.cpp 把阈值表和 GetTargetQualityLevel 抄了一份, +// 测的是副本 —— 改了 commands.h 它不会失败。新增的判据不要再走那条路。 +// +// 判据的核心不是"传了多少字节",而是"链路是否拒绝交付要求的东西": +// 帧率低于基线,同时字节速率仍贴着该档标称码率,才说明管道满了。 + +#include +#include "commands.h" + +// 帧率达标时不构成带宽问题,传多少字节都无所谓 +TEST(LoadCriterion, NoConstraintWhenFpsHealthy) +{ + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(20, 20, 3000, 3000)); + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(12, 20, 5000, 3000)); // 20*0.6=12,刚好达标 +} + +// 最关键的一条:画面变化少的时候帧率和字节速率一起掉,这不是带宽问题。 +// 如果只看"帧率低"或只看"字节少",这里就会误降档。 +// 判据比的是"每帧字节数",所以 600kbps@8fps(每帧 9.4KB,标称 18.75KB)不会被判成饱和。 +TEST(LoadCriterion, LowMotionIsNotCongestion) +{ + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(1, 20, 160, 3000)); // 静止:12.5KB/帧 + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(8, 20, 600, 3000)); // 变化少:9.4KB/帧 +} + +// 反过来:帧率低且每帧明显超标称(2 倍以上),才是链路交付不动 +TEST(LoadCriterion, OversizedFramesMeanCongestion) +{ + // 2Mbps 链路跑 Good(3000kbps):2fps × 125KB/帧,标称只有 18.75KB/帧 + EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 3000)); + // 容量远低于标称码率时(900kbps 跑 3000kbps 档)同样要能判出来 —— + // 这正是"用每秒总字节数占比"会漏掉的情形:900/3000 只有 30%,永远到不了"半满"。 + EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(2, 20, 900, 3000)); +} + +// 反查表用的是 0.85 余量:kbps*0.85 >= 该档 bitRate 才算装得下 +TEST(LoadCriterion, ReverseLookupMatchesBitrateTable) +{ + EXPECT_EQ(QUALITY_MEDIUM, GetTargetQualityLevelByLoad(2, 20, 2400, 3000)); // 2040 >= 2000 + EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 3000)); // 1700 < 2000 + EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 1500, 3000)); // 1275 >= 1200 + EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(2, 20, 900, 3000)); // 765 < 800 +} + +// Ultra/High 走 DIFF/RGB565,没有码率控制,没有标称码率可比: +// 帧率缺口本身就是唯一证据,直接按实测吞吐反查目标档。 +// 这正是 RTT 判据抓不到的那一类 —— RTT 20~40ms 时它会选到这两个零码率控制的档位。 +TEST(LoadCriterion, ZeroBitrateLevelsTriggerOnFpsAlone) +{ + EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 0)); +} + +// 数据不全时一律返回"无约束",绝不能因为缺数据就降档 +TEST(LoadCriterion, InvalidInputsAreNoConstraint) +{ + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 0, 2000, 3000)); // 基线未学到 + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(0, 20, 2000, 3000)); // 一帧都没收到 + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(-1, 20, 2000, 3000)); // 帧数异常 + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 20, -1, 3000)); // 速率异常 + // 没有实测吞吐时不能反查目标档,否则零码率控制的档位会误返回最低档 + EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 20, 0, 0)); +} + +// 与 RTT 判据的合并语义:取更保守者(档位数字越大越差)。 +// 这里验证两个判据各自的结果可以简单用 max 组合 —— 加权平均会让"RTT 好"掩盖"带宽窄"。 +TEST(LoadCriterion, CombineWithRttByMax) +{ + // 短 RTT(20ms 直连 → ULTRA)但链路只有 2Mbps → 吞吐判据说了算 + int levelRtt = GetTargetQualityLevel(20, 0); + int levelLoad = GetTargetQualityLevelByLoad(2, 20, 2000, 0); + EXPECT_EQ(QUALITY_ULTRA, levelRtt); + EXPECT_EQ(QUALITY_LOW, levelLoad); + EXPECT_EQ(QUALITY_LOW, (levelRtt > levelLoad) ? levelRtt : levelLoad); + + // 长 RTT(400ms 直连 → MINIMAL)但链路很宽 → RTT 判据说了算 + levelRtt = GetTargetQualityLevel(400, 0); + levelLoad = GetTargetQualityLevelByLoad(20, 20, 20000, 3000); + EXPECT_EQ(QUALITY_MINIMAL, levelRtt); + EXPECT_EQ(-1, levelLoad); + EXPECT_EQ(QUALITY_MINIMAL, (levelRtt > levelLoad) ? levelRtt : levelLoad); +} + +// ===== 迟滞:防止 RTT 在阈值边界上抖动导致档位反复切换 ===== +// +// 直连阈值表 {30, 80, 150, 250, 400}。当前档 2(Good) 的两个边界: +// 升到 1(High):rtt 必须 < 80*0.85 = 68 +// 降到 3(Medium):rtt 必须 > 150*1.15 = 172.5 +// 也就是说 rtt 落在 [68, 172] 这段死区里,档位保持不动。 +TEST(RttHysteresis, DeadZoneHoldsCurrentLevel) +{ + // 死区里:raw 已经指向相邻档,但没到"明显变好/变坏",保持不动 + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(70, 0, 2)); // raw=1,70 >= 68 + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(79, 0, 2)); + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(160, 0, 2)); // raw=3,160 <= 172 + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(150, 0, 2)); +} + +// 越过死区才允许动作 +TEST(RttHysteresis, OutsideDeadZoneMoves) +{ + EXPECT_EQ(1, GetTargetQualityLevelHysteresis(60, 0, 2)); // 60 < 68 → 升档 + EXPECT_EQ(3, GetTargetQualityLevelHysteresis(180, 0, 2)); // 180 > 172 → 降档 + // 一次跳多级是允许的:RTT 骤降时没必要逐级爬 + EXPECT_EQ(5, GetTargetQualityLevelHysteresis(1000, 0, 2)); + EXPECT_EQ(0, GetTargetQualityLevelHysteresis(20, 0, 2)); +} + +// 同一 RTT 下,迟滞结果永远不比无迟滞结果更激进(只能保持或更保守) +TEST(RttHysteresis, NeverMovesBeforeRawLevel) +{ + for (int rtt = 5; rtt <= 900; rtt += 5) { + int raw = GetTargetQualityLevel(rtt, 0); + for (int cur = 0; cur < QUALITY_COUNT; cur++) { + int h = GetTargetQualityLevelHysteresis(rtt, 0, cur); + if (h < cur) EXPECT_GE(h, raw); // 升档不会越过 raw + if (h > cur) EXPECT_LE(h, raw); // 降档不会越过 raw + } + } +} + +// 已经稳定的档位不该被迟滞推走;缺数据时保持不动 +TEST(RttHysteresis, StableAndInvalidInputs) +{ + EXPECT_EQ(1, GetTargetQualityLevelHysteresis(70, 0, 1)); // raw == current + EXPECT_EQ(5, GetTargetQualityLevelHysteresis(9999, 0, 5)); + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(0, 0, 2)); // rtt 取不到 + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(-1, 0, 2)); + // currentLevel 非法时退化成无迟滞版本 + EXPECT_EQ(1, GetTargetQualityLevelHysteresis(70, 0, 99)); +} + +// FRP 阈值表更宽松({60,160,300,500,800}),死区跟着一起放宽 +TEST(RttHysteresis, FrpTableIsWider) +{ + // FRP 下当前档 2 的死区是 [160*0.85, 300*1.15] = [136, 345] + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(140, 1, 2)); // raw=1,但 140 >= 136 + EXPECT_EQ(1, GetTargetQualityLevelHysteresis(120, 1, 2)); + EXPECT_EQ(2, GetTargetQualityLevelHysteresis(320, 1, 2)); + EXPECT_EQ(3, GetTargetQualityLevelHysteresis(360, 1, 2)); +}