Files
SimpleRemoter/test/unit/screen/QualityLoadTest.cpp
T
yuanyuanxianganddeepseek-flash 5f40f3726c Fix: React to slow-frame congestion and keep remote audio recoverable
The adaptive quality controller counted only complete frames per second, so when
a single frame took several seconds to arrive the sample was 0 fps and the
throughput criterion abstained forever: Ultra and High kept flipping while a
foreground video played. The audio watchdog had the opposite problem: it rebuilt
the WASAPI capture every three seconds on an idle endpoint, and its sleep
detector measured the whole loop including a blocking send.

Sample the last ten seconds in a ring buffer and feed the criterion a windowed
rate, guarded so a scroll burst, a stale window or a few KB clock patch is not
mistaken for congestion. Apply the same per-frame floor to the one-second
fallback and to the post-downgrade local-bottleneck probe. Normalize delayed
timer ticks by real elapsed milliseconds, and make the 40 second
upgrade-failure window outlast the resolution cooldown it has to cross.

On the client, rebuild only when an audio session is actually rendering, and
rebuild immediately when the captured endpoint is no longer the default output;
refresh the sleep timestamps on failed as well as successful init.

Tests cover the window and fallback helpers directly; the full suite passes
845/845, and both the Debug server and Debug client build.

Co-Authored-By: deepseek-flash
2026-11-08 11:45:19 +01:00

328 lines
17 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));
}
// ===== 慢流量:大帧把链路堵住时,1 秒窗口永远是 0 帧 =====
//
// 控制端只在整帧收全后才计数(m_ulFramesThisSecond),一帧要传好几秒时每秒帧数
// 都是 0;而"帧率明显低于基线"是零码率档位唯一的证据 —— 1 秒样本为空就等于判据
// 弃权,档位永远降不下来(实测现场:Ultra/High 之间来回翻,帧率 0~1)。
// 改用最近 N 秒的窗口均值,0.3fps 这种速率才能表达出来。
TEST(LoadCriterion, SlowStreamUsesWindowedSample)
{
int fps = 0, baseline = 0, kbps = 0;
// 10 秒窗口里只有 3 帧、12MB → 0.3fps、基线 8fps、≈9.8Mbps
GetWindowedLoadSample(3, 12ULL * 1024 * 1024, 10, 8, fps, baseline, kbps);
EXPECT_EQ(30, fps); // 放大 100 倍表示 0.3fps
EXPECT_EQ(800, baseline); // 基线同步放大,比值不变
EXPECT_EQ(9830, kbps);
// 这个样本喂给判据:帧率缺口成立,实测吞吐装得下 Good
EXPECT_EQ(QUALITY_GOOD, GetTargetQualityLevelByLoad(fps, baseline, kbps, 0));
// 同一段流量按"每秒"去看,堵住的那几秒一帧都没有 → 判据弃权(这就是原来的死结)
EXPECT_EQ(-1, GetTargetQualityLevelByLoad(0, 8, 0, 0));
}
// 画面静止时客户端 memcmp 跳帧,窗口里同样一帧都没有:不能因为"没帧"就降档。
TEST(LoadCriterion, IdleWindowIsNotCongestion)
{
int fps = 99, baseline = 99, kbps = 99;
GetWindowedLoadSample(0, 0, 10, 8, fps, baseline, kbps);
EXPECT_EQ(0, fps);
EXPECT_EQ(-1, GetTargetQualityLevelByLoad(fps, baseline, kbps, 0));
}
// ===== 窗口样本的可用性:三种"看着像拥塞其实不是"的现场 =====
//
// 窗口均值本身分不清"链路交付不动"和"内容本来就一阵一阵的"。直接喂给判据,
// 滚动一下停住就会把 LAN 上的 Ultra 降成 Good —— 评审里的假阳性。
// 判定在 GetCongestedLoadSample 里,下面逐个现场验证。
// ① 滚动 3 秒(22 帧)然后停住:窗口均值是"1fps + 22Mbps",但没有任何一秒
// 交付过满速之外的证据 —— 恰恰相反,那些秒都跑在 8fps 附近,链路没问题。
TEST(LoadCriterion, ScrollThenIdleIsNotCongestion)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(22, 22ULL * 1024 * 1024, 3, 8, 10, 3, 8, 64 * 1024, f, b, k));
}
// ② 一个大帧闪了一下(开个窗口、翻一页),谈不上"持续交付不动"
TEST(LoadCriterion, SingleFrameIsNotCongestion)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(1, 4ULL * 1024 * 1024, 1, 1, 10, 1, 8, 64 * 1024, f, b, k));
EXPECT_FALSE(GetCongestedLoadSample(2, 8ULL * 1024 * 1024, 1, 2, 10, 1, 8, 64 * 1024, f, b, k));
}
// 短促突发:3 帧全挤在同一秒(滚一下鼠标、开个窗口),链路一秒就交完了。
// 只看帧数和"最忙那秒有没有到 0.6 基线"(3 < 4.8)都会误判,靠"至少散布在 3 个
// 不同的秒里"挡掉 —— 这一条正是「滚动一下停住」最常见的形态。
TEST(LoadCriterion, ShortBurstInOneSecondIsNotCongestion)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 1, 3, 10, 1, 8, 64 * 1024, f, b, k));
// 同样这 3 帧散在 3 个秒里 → 才是"持续交付不动"
EXPECT_TRUE (GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 1, 8, 64 * 1024, f, b, k));
}
// ③ 最后一帧已经过去 5 秒:窗口里剩的是停顿前的流量,不能拿它判现在
TEST(LoadCriterion, StaleWindowIsNotCongestion)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 5, 8, 64 * 1024, f, b, k));
}
// 现场本身:0.3fps、每帧 4MB、最后一帧刚过去 2 秒 → 可用,且判据给出 Good
TEST(LoadCriterion, SteadySlowStreamIsCongestion)
{
int f = 0, b = 0, k = 0;
ASSERT_TRUE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 2, 8, 64 * 1024, f, b, k));
EXPECT_EQ(30, f); // 0.3fps
EXPECT_EQ(800, b); // 基线 8fps
EXPECT_EQ(9830, k);
EXPECT_EQ(QUALITY_GOOD, GetTargetQualityLevelByLoad(f, b, k, 0));
}
// 边界:某一秒交付到 0.6 基线(8fps 的 0.6 = 4.8 帧)就算"链路能交付满速",
// 不算拥塞。5 帧拒绝、4 帧通过。
TEST(LoadCriterion, BusiestSecondAtThresholdRejects)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(20, 20ULL * 1024 * 1024, 10, 5, 10, 1, 8, 0, f, b, k));
EXPECT_TRUE (GetCongestedLoadSample(20, 20ULL * 1024 * 1024, 10, 4, 10, 1, 8, 0, f, b, k));
}
// 小帧下限只对没有码率控制的档位生效:H264 档位由判据自己的"每帧是否明显超过
// 标称"把关,再加一道绝对下限会误伤小屏/慢链路(1024×768 的 30KB 增量帧
// 在 300kbps 上确实堵,但它不是"几 KB 的时钟补丁")。
TEST(LoadCriterion, MinFrameBytesOnlyForRawLevels)
{
int f = 0, b = 0, k = 0;
// 4 帧 × 2KB 的小补丁:raw 档判不了,H264 档交给判据
EXPECT_FALSE(GetCongestedLoadSample(4, 8ULL * 1024, 4, 2, 10, 1, 8, 64 * 1024, f, b, k));
EXPECT_TRUE (GetCongestedLoadSample(4, 8ULL * 1024, 4, 2, 10, 1, 8, 0, f, b, k));
}
// ===== 1 秒样本(窗口不可用时的退路)=====
//
// 窗口被拒之后不能直接拿 1 秒计数去判:同一道小帧下限必须一起过,否则窗口路径
// 挡掉的「静止桌面上的时钟补丁」会从这条路原样走回来,把 LAN 上的 Ultra 压成
// Minimal。这正是评审挑出来的漏洞。
TEST(LoadCriterion, SecondSampleAppliesMinFrameBytes)
{
int f = 0, b = 0, k = 0;
// raw 档、1 帧/s、每帧 1KB 的时钟补丁 → 不可用
EXPECT_FALSE(GetSecondLoadSample(1, 1024, 1000, 16, 64 * 1024, f, b, k));
// 真拥塞:2 帧/s、每帧 125KB(2Mbps 上跑 Ultra)→ 可用,判据能反查出低档
ASSERT_TRUE(GetSecondLoadSample(2, 250ULL * 1024, 1000, 16, 64 * 1024, f, b, k));
EXPECT_EQ(200, f); // 2fps
EXPECT_EQ(1600, b);
EXPECT_EQ(2000, k); // 250KB/s ≈ 2000kbps
EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(f, b, k, 0));
// 有码率控制的档位不设绝对下限:小帧交给判据自己的「每帧是否超过标称」把关
ASSERT_TRUE(GetSecondLoadSample(1, 1024, 1000, 16, 0, f, b, k));
EXPECT_EQ(100, f);
EXPECT_EQ(8, k);
}
// 定时器被 UI 阻塞推迟时,一格代表的不止一秒:速率要按实际毫秒数摊开,
// 否则 2 秒里到的 2 帧会被算成 2fps,帧率缺口被抹平、拥塞漏判。
TEST(LoadCriterion, SecondSampleScalesByElapsedTime)
{
int f = 0, b = 0, k = 0;
ASSERT_TRUE(GetSecondLoadSample(2, 250ULL * 1024, 2000, 16, 0, f, b, k));
EXPECT_EQ(100, f); // 1fps
EXPECT_EQ(1000, k); // 125KB/s
// 同一批字节按 1 秒算会得出 2fps/2000kbps(→ Low),按真实的 2 秒摊开是
// 1fps/1000kbps(→ Minimal):不按实际时长归一,就会把拥塞程度看轻一档。
EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(f, b, k, 3000));
}
TEST(LoadCriterion, SecondSampleRejectsMissingData)
{
int f = 99, b = 99, k = 99;
EXPECT_FALSE(GetSecondLoadSample(0, 1024, 1000, 16, 0, f, b, k)); // 一帧都没有
EXPECT_FALSE(GetSecondLoadSample(1, 0, 1000, 16, 0, f, b, k)); // 没有吞吐
EXPECT_FALSE(GetSecondLoadSample(1, 1024, 0, 16, 0, f, b, k)); // 时长未知
EXPECT_FALSE(GetSecondLoadSample(1, 1024, 1000, 0, 0, f, b, k)); // 基线未学到
EXPECT_FALSE(GetSecondLoadSample(10001, 1024, 1000, 16, 0, f, b, k)); // 帧数异常
EXPECT_EQ(0, f); // 被拒绝时输出一律清零,调用方不会拿到半份样本
EXPECT_EQ(0, k);
}
// ===== 本机瓶颈判定 =====
//
// 「帧率低 + 帧不大」在画面静止时同样成立(客户端 memcmp 跳帧),必须要求最近
// 一秒真的在发帧 —— 否则一次静止就把吞吐判据永久停用。
TEST(LoadCriterion, LocalBottleneckNeedsActiveScreen)
{
// 静止:窗口样本是「1fps + 小帧」,最后一个完整秒只有 1 帧 → 证据不足
EXPECT_FALSE(IsLocalBottleneck(100, 1600, 10, 3000, 1));
// 本机慢:2fps、每帧 32KB(标称每帧 24KB,没到 2 倍)→ 帧发得出来却不多 → 本机
EXPECT_TRUE(IsLocalBottleneck(200, 1600, 500, 3000, 2));
// 链路拥塞:2fps 但每帧 125KB(标称 2 倍以上)→ 是带宽问题,不能停用吞吐判据
EXPECT_FALSE(IsLocalBottleneck(200, 1600, 2000, 3000, 8));
// 帧率本来就不低
EXPECT_FALSE(IsLocalBottleneck(1600, 1600, 500, 3000, 16));
}
// 缺数据一律不可用
TEST(LoadCriterion, CongestedSampleRejectsMissingData)
{
int f = 0, b = 0, k = 0;
EXPECT_FALSE(GetCongestedLoadSample(0, 0, 0, 0, 10, 1, 8, 0, f, b, k)); // 窗口里没有帧
EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 0, 1, 8, 0, f, b, k));// 没有秒数
EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 10, -1, 8, 0, f, b, k));// 从没收到过帧
EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 10, 1, 0, 0, f, b, k));// 基线未学到
}
// 窗口还没填满时按已填入的秒数做分母,不能按 10 秒算(会把速率摊薄成 1/5)
TEST(LoadCriterion, PartiallyFilledWindow)
{
int fps = 0, baseline = 0, kbps = 0;
GetWindowedLoadSample(2, 2ULL * 1024 * 1024, 2, 8, fps, baseline, kbps);
EXPECT_EQ(100, fps); // 1fps
EXPECT_EQ(800, baseline);
EXPECT_EQ(8192, kbps); // 2MB / 2s
}
// 数据不全时一律返回"无约束",绝不能因为缺数据就降档
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));
}