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.
This commit is contained in:
yuanyuanxiang committed 2026-11-05 14:24:42 +01:00
1 parent ab83f5d685
commit d6b04a98f0
12 files changed
+543 -23

No files matched your search

+93 -3
View File
@@ -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, 压缩线程数
Binary file not shown.
+19
View File
@@ -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
{
+11 -2
View File
@@ -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(首次=启动 / 覆盖=重启 / 撤销=停止),并在主对话框信息列表中给出友好提示。
+220 -15
View File
@@ -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 };
+24 -1
View File
@@ -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); // 更新质量菜单勾选状态
+1
View File
@@ -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
+1
View File
@@ -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
+1
View File
@@ -2088,6 +2088,7 @@ HTTPS
x264 码率封顶 (VBV)=x264 位元率上限 (VBV)
GDI 抓屏去分段延时=GDI 擷取去除分段延遲
发送节流帧率下限=傳送節流影格率下限
自适应加吞吐判据=自適應加吞吐判據
等级=等級
帧率(FPS)=幀率(FPS)
最大宽度=最大寬度
+3 -1
View File
@@ -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
+27 -1
View File
@@ -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
)
+143
View File
@@ -0,0 +1,143 @@
// QualityLoadTest.cpp - 吞吐判据(自适应质量的第二判据)单元测试
//
// 这个测试直接 include 真实的 common/commands.h,不复制实现。
// 对比:同目录的 QualityAdaptiveTest.cpp 把阈值表和 GetTargetQualityLevel 抄了一份,
// 测的是副本 —— 改了 commands.h 它不会失败。新增的判据不要再走那条路。
//
// 判据的核心不是"传了多少字节",而是"链路是否拒绝交付要求的东西":
// 帧率低于基线,同时字节速率仍贴着该档标称码率,才说明管道满了。
#include <gtest/gtest.h>
#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));
}