Files
SimpleRemoter/test/unit/screen/QualityLoadTest.cpp
T
yuanyuanxiang d6b04a98f0 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.
2026-11-05 14:24:42 +01:00

144 lines
7.2 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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));
}