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
This commit was merged in pull request #6.
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-08 11:45:19 +01:00
1 parent 2a97471b51
commit 5f40f3726c
6 files changed
+688 -31

No files matched your search

+184
View File
@@ -53,6 +53,190 @@ 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)
{