Fix: React to slow-frame congestion and keep remote audio recoverable #6

Merged
yuanyuanxiang merged 1 commits from fix/slow-frame-congestion-audio-recovery into main 2026-11-08 12:22:36 +00:00
6 changed files with 688 additions and 31 deletions

No files matched your search

+171 -1
View File
@@ -29,6 +29,7 @@
// WASAPI 音频捕获
#include <mmdeviceapi.h>
#include <audioclient.h>
#include <audiopolicy.h>
#include <functiondiscoverykeys_devpkey.h>
#include <cstdint>
@@ -2486,6 +2487,82 @@ static ULONGLONG NowFileTime100ns()
return ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
}
// 这个输出端点上是否还有应用在渲染音频?
//
// 用它区分两种「一包数据都没有」:端点上没有任何活动会话时,共享模式 loopback
// 捕获本来就是空的 —— 那是设备空闲,不是捕获客户端聋了;只有「有会话在播,却
// 依然一包不进来」才是真的聋了(现场:初始化成功、播放视频音乐两分钟没声音,
// 关/开一次音频立刻恢复)。没有这个判断,空闲时每 3 秒重建一次捕获纯属空转。
//
// 出错一律返回 TRUE(按「有活动会话」处理):宁可多探几次,也不能漏掉真聋的。
static bool IsRenderingAudioActive(IMMDevice* pDevice)
{
if (!pDevice) return true;
IAudioSessionManager2* pMgr = nullptr;
if (FAILED(pDevice->Activate(__uuidof(IAudioSessionManager2), CLSCTX_ALL, NULL, (void**)&pMgr)) || !pMgr) {
return true;
}
bool active = true; // 拿不到会话列表时保持原来的探测行为
IAudioSessionEnumerator* pEnum = nullptr;
if (SUCCEEDED(pMgr->GetSessionEnumerator(&pEnum)) && pEnum) {
int count = 0;
if (SUCCEEDED(pEnum->GetCount(&count))) {
active = false;
for (int i = 0; i < count; i++) {
IAudioSessionControl* pCtrl = nullptr;
if (FAILED(pEnum->GetSession(i, &pCtrl)) || !pCtrl) continue;
AudioSessionState state = AudioSessionStateInactive;
IAudioSessionControl2* pCtrl2 = nullptr;
if (SUCCEEDED(pCtrl->QueryInterface(__uuidof(IAudioSessionControl2), (void**)&pCtrl2)) && pCtrl2) {
pCtrl2->GetState(&state);
pCtrl2->Release();
} else {
pCtrl->GetState(&state);
}
pCtrl->Release();
if (state == AudioSessionStateActive) { active = true; break; }
}
}
pEnum->Release();
}
pMgr->Release();
return active;
}
// 捕获客户端绑的那个端点还是不是系统默认输出设备?
//
// 用户插耳机/切换播放设备后,Windows 把渲染会话迁到新端点,旧端点上就没有任何
// 活动会话了 —— 只问旧端点 IsRenderingAudioActive 永远是否,看门狗会一直认为
// 「没人放音」而不再重建,远端音频从此静音(本来重建一次就能重新抓到默认设备)。
// 所以这种情况必须单独识别:设备换了,就必须重建。
//
// 查询失败一律返回 FALSE(按「没换」处理),退回到「看会话、看数据」的原有行为,
// 不能因为枚举失败把重建门槛放开成每 3 秒一次。
static bool IsCapturedDeviceStale(IMMDevice* pDevice)
{
if (!pDevice) return true; // 连端点都没有,只能重建
LPWSTR curId = nullptr;
if (FAILED(pDevice->GetId(&curId)) || !curId) return false;
bool stale = false;
IMMDeviceEnumerator* pEnum = nullptr;
if (SUCCEEDED(CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL,
__uuidof(IMMDeviceEnumerator), (void**)&pEnum)) && pEnum) {
IMMDevice* pDefault = nullptr;
if (SUCCEEDED(pEnum->GetDefaultAudioEndpoint(eRender, eConsole, &pDefault)) && pDefault) {
LPWSTR defId = nullptr;
if (SUCCEEDED(pDefault->GetId(&defId)) && defId) {
stale = (wcscmp(defId, curId) != 0);
CoTaskMemFree(defId);
}
pDefault->Release();
}
pEnum->Release();
}
CoTaskMemFree(curId);
return stale;
}
Review

非阻塞建议:CoCreateInstance 频率

IsCapturedDeviceStale 每 3 秒在空闲端点上创建一次 MMDeviceEnumerator 实例。虽然开销很小(只是 COM 对象,不涉及设备打开),但如果想优化可以考虑缓存 enumerator 或在 InitWASAPILoopback 时创建一次、在 UninitWASAPI 时释放。

不影响正确性,不阻塞合并。

**非阻塞建议:`CoCreateInstance` 频率** `IsCapturedDeviceStale` 每 3 秒在空闲端点上创建一次 `MMDeviceEnumerator` 实例。虽然开销很小(只是 COM 对象,不涉及设备打开),但如果想优化可以考虑缓存 enumerator 或在 `InitWASAPILoopback` 时创建一次、在 `UninitWASAPI` 时释放。 不影响正确性,不阻塞合并。
BOOL CScreenManager::InitWASAPILoopback()
{
if (m_bAudioInitialized) return TRUE;
@@ -2663,6 +2740,7 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
BOOL opusInitialized = FALSE;
int opusChannels = 0; // 编码器当前声道数(设备切换后可能变化)
BOOL warnedUnsupportedRate = FALSE;
BOOL warnedOpusInitFail = FALSE;
const int OPUS_FRAME_SIZE = 960; // 20ms @ 48kHz
short* pOpusAccumBuffer = new short[OPUS_FRAME_SIZE * 2]; // 最多立体声
int nAccumSamples = 0; // 已累积的样本数(每声道)
@@ -2679,8 +2757,25 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
ULONGLONG lastTick = GetTickCount64();
ULONGLONG lastWall = NowFileTime100ns();
// 还有一种「活着的聋子」:Initialize/Start 全部成功、GetNextPacketSize 不返回任何
// 错误码,但永远返回 0 个包,之后端点开始播放也照样不出一包(现场日志:09:46:37
// 初始化成功后整整两分钟,播放视频音乐一个音频包都没有;关掉再打开音频、重建一次
// 捕获立刻恢复)。实测「在空闲端点上新建 loopback 客户端」本身没问题——同机探针
// 每秒都能拿到包——所以这是端点当时所处的状态(刚被系统重建/休眠过)导致的,没有
// 任何 API 能问出来。只能按「长时间没有数据」重建捕获客户端:每 3 秒看一眼
// 端点上有没有应用在出声(IsRenderingAudioActive),有活动会话却一包不进来才重建,
// 代价只是一次 COM 初始化,换来的是播放开始后最多三四秒就有声音;空闲时只查会话、
// 不折腾采集客户端(见下面的判定)。日志限量,别让空闲端点把日志刷满。
ULONGLONG silentSince = GetTickCount64(); // 这轮「没有数据」从什么时候开始
ULONGLONG lastRebuildTick = silentSince; // 上次重建的时刻,刚建好别又拆
const ULONGLONG NODATA_PROBE_DELAY = 3000;
int noDataRebuilds = 0; // 本轮已重建次数(只用于日志)
while (pThis->m_bAudioThreadRunning) {
// 阈值 2 秒:远大于正常循环周期,也不会误伤 1000ms 的初始化重试等待。
// lastTick 在「进入空闲等待之前」刷新(见循环末尾),所以这里量的只是
// 等待时间段 —— 不含发送阻塞的工作时间。下面再刷一次,是给不走循环末尾、
// 直接 continue 的几条失败路径用的。
ULONGLONG tickNow = GetTickCount64();
ULONGLONG wallNow = NowFileTime100ns();
BOOL woken = (tickNow - lastTick > 2000) || (wallNow - lastWall > 20000000ULL);
@@ -2693,6 +2788,9 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
pThis->m_bAudioDeviceDirty = FALSE;
pThis->UninitWASAPI();
firstFrame = TRUE; // 新采集要重新下发格式,主控那边才有机会核对设备状态
// 休眠恢复/重开音频是新的起点:重新计「多久没数据」
silentSince = lastRebuildTick = GetTickCount64();
noDataRebuilds = 0;
#if USING_OPUS
nAccumSamples = 0;
#endif
@@ -2707,13 +2805,22 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
// 这次等待可能跨越休眠或很长一段关闭期,别算进上面的时间差检测
lastTick = GetTickCount64();
lastWall = NowFileTime100ns();
silentSince = lastRebuildTick = lastTick;
noDataRebuilds = 0;
if (!pThis->m_bAudioThreadRunning) break;
continue;
}
// 如果 WASAPI 未初始化,尝试初始化(在音频线程中初始化确保 COM 正确)
if (!pThis->m_bAudioInitialized || !pThis->m_pCaptureClient) {
if (!pThis->InitWASAPILoopback()) {
const BOOL inited = pThis->InitWASAPILoopback();
// 初始化本身也要从休眠检测里排除:音频服务重启/设备重建时 Initialize
// 可能卡上两三秒,算进去就是又一条「检测到系统休眠后恢复」的假日志。
// 失败路径同样要刷:失败重试一卡两秒也会被当成睡醒,而且那个假路径还会
// 重置 silentSince/noDataRebuilds,让「多久没数据」永远攒不起来。
lastTick = GetTickCount64();
lastWall = NowFileTime100ns();
if (!inited) {
// 初始化失败,等待后重试
WaitForSingleObject(pThis->m_hAudioEvent, 1000);
continue;
@@ -2732,6 +2839,54 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
continue;
}
// 长时间收不到任何包:见上面 silentSince 的说明。重建是唯一被现场验证有效的
// 恢复手段(工具栏关/开音频做的就是这一步)。
ULONGLONG dataNow = GetTickCount64();
if (packetLength > 0) {
if (noDataRebuilds > 0) {
Mprintf("音频捕获恢复:重建 %d 次之后拿到数据\n", noDataRebuilds);
noDataRebuilds = 0;
}
silentSince = lastRebuildTick = dataNow;
} else if (dataNow - lastRebuildTick >= NODATA_PROBE_DELAY) {
// 正在停止时别再碰采集对象:析构最多等 2 秒就会自己调 UninitWASAPI,
// 两边同时 Stop/Release 同一组指针就是 use-after-free。(下面查会话
// 状态也要走 m_pAudioDevice,所以这个检查必须放在最前面。)
if (!pThis->m_bAudioThreadRunning) break;
// 端点上没有活动会话 = 没有任何应用在出声,loopback 本来就该是空的:
// 重建捕获不解决问题,只会每 3 秒折腾一次 COM。等有会话开始播放再看。
// 但「没有活动会话」也可能是默认输出设备被换走了(旧端点自然没人用):
// 那种情况必须重建才能跟到新设备,否则远端音频永久静音。
const bool active = IsRenderingAudioActive(pThis->m_pAudioDevice);
const bool stale = !active && IsCapturedDeviceStale(pThis->m_pAudioDevice);
if (!active && !stale) {
lastRebuildTick = dataNow; // 3 秒后再问一次,silentSince 继续累计
continue;
}
if (stale) {
Mprintf("默认输出设备已切换,重建 WASAPI 捕获\n");
}
++noDataRebuilds;
// 每 3 秒一次的重建不该刷屏:第一次必打,之后每分钟左右一条。
if (noDataRebuilds == 1 || noDataRebuilds % 20 == 0) {
Mprintf("音频捕获 %llu ms 无数据,重建 WASAPI 捕获(第 %d 次:端点可能在初始化之后才开始播放)\n",
(unsigned long long)(dataNow - silentSince), noDataRebuilds);
}
pThis->UninitWASAPI();
firstFrame = TRUE; // 新采集要重新下发格式
pThis->m_bAudioFormatResend = TRUE;
#if USING_OPUS
nAccumSamples = 0;
#endif
// 让系统把旧客户端彻底拆掉再建:抢着建会拿到「初始化成功但永远没数据」的客户端
Sleep(1000);
// Uninit/Stop 万一卡住超过 2 秒,别让上面把这次停顿误报成「休眠恢复」
lastTick = GetTickCount64();
lastWall = NowFileTime100ns();
lastRebuildTick = lastTick;
continue;
}
while (packetLength > 0 && pThis->m_bAudioThreadRunning && pThis->m_ScreenSettings.AudioEnabled) {
BYTE* pData = nullptr;
UINT32 numFramesAvailable = 0;
@@ -2816,7 +2971,14 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
opusChannels = encChannels;
firstFrame = TRUE; // 让主控按新格式重建解码器/播放设备
nAccumSamples = 0;
warnedOpusInitFail = FALSE;
Mprintf("Opus 编码器初始化成功: 48000 Hz, %d ch, 64 kbps\n", encChannels);
} else if (!warnedOpusInitFail) {
// 初始化失败时下面整段不发包,以前一个字都不打,排查时只能看到
// 「WASAPI 初始化成功」之后彻底安静。打一次,别每包刷屏。
warnedOpusInitFail = TRUE;
Mprintf("Opus 编码器初始化失败: %u Hz, %d ch,本轮不发音频\n",
pWaveFmt->nSamplesPerSec, encChannels);
}
}
if (!opusInitialized && pWaveFmt->nSamplesPerSec != 48000 && !warnedUnsupportedRate) {
@@ -2934,6 +3096,14 @@ DWORD WINAPI CScreenManager::AudioThreadProc(LPVOID lpParam)
}
}
// 休眠检测只量「空闲等待」这一段,不要把循环里的工作算进来:本线程的
// Send2Server 是阻塞的(IOCPClient 整个发送过程持 m_Locker),链路被屏幕
// 大帧占满时一次要好几秒 —— 算进去就会把正常排队误判成「系统休眠后恢复」,
// 于是每 2 秒重建一次捕获:日志刷屏、每次重建还顺带丢一段声音。
// 真正进待机时本线程被冻结在下面这个 Sleep 或上面的 INFINITE 等待里,
// 照样能检测到;退出早的几个 continue 分支各自的等待都不超过 1 秒。
lastTick = GetTickCount64();
lastWall = NowFileTime100ns();
Sleep(10); // ~100Hz 采集
}
+130
View File
@@ -1549,6 +1549,136 @@ inline int GetTargetQualityLevelByLoad(int fps, int baselineFps, int kbps, int n
return QUALITY_MINIMAL;
}
// 慢流量的吞吐采样:把「最近 seconds 秒累计的帧数/字节数」换算成吞吐判据要的三个数。
//
// 为什么需要窗口:大帧把链路堵住时,一帧要好几秒才发得完,而控制端只在整帧收全后
// 才计数(ScreenSpyDlg.cpp 的 m_ulFramesThisSecond)—— 这类现场每秒的帧数都是 0,
// 1 秒窗口的样本为空,判据只能弃权;偶尔收到一帧的那一秒又被下一 0 帧秒清零,
// 连续 3 次永远凑不齐,档位一次也降不下来。用窗口均值才能表达 0.2fps 这种速率。
//
// 帧率与基线同时放大 100 倍:判据里只用两者的比值(帧率缺口、每帧字节数),
// 两边同乘不改变结论,但避开了整数帧率把 0.3fps 截成 0 的问题。
// kbps 用 1024 进制,与调用方 m_dScreenKBps * 8 的口径保持一致。
inline void GetWindowedLoadSample(unsigned long long frames,
unsigned long long bytes,
int seconds,
int baselineFps,
int& fps, int& baseline, int& kbps)
{
if (seconds <= 0) {
fps = 0;
baseline = 0;
kbps = 0;
return;
}
fps = (int)(frames * 100 / (unsigned long long)seconds);
baseline = baselineFps * 100;
kbps = (int)(bytes * 8 / (1024ULL * (unsigned long long)seconds));
}
// 慢流量窗口能不能作为「链路拥塞」的证据。
//
// 窗口均值本身分不清「链路交付不动」和「内容本来就是一阵一阵的」,直接喂给
// GetTargetQualityLevelByLoad 会误降档。以下三条必须同时成立:
//
// ① 窗口里至少 3 帧,且分布在至少 3 个不同的秒里:一两个大帧只是内容闪了一下
// (滚动一下、开个窗口)。「3 个不同的秒」专门挡「3 帧挤在同一秒」的短促突发
// —— 那种现场窗口均值同样是低帧率,但链路一秒就交完了,不是交付不动。
// 真拥塞时一帧要好几秒,帧必然散落在大半窗口里;代价是 0.3fps 这种极慢流
// 偶尔凑不满 3 个秒(两帧落在同一秒),这一拍弃权,下一拍窗口滑动后会再判。
// ② 最后一帧就在 4 秒内:滚动/播放停下之后画面静止,客户端 memcmp 跳帧,
// 窗口里剩下的是停顿前那段流量 —— 均值同样是「低帧率 + 高吞吐」,但这说明
// 内容停了,不是链路慢。真拥塞时帧在持续到达(一帧几秒),不会触发这一条。
// ③ 没有任何一秒交付过接近满速的帧:滚动 2 秒发 20 帧然后停住,10 秒窗口把
// 5fps 摊成 1fps;但这种现场里总有一秒交付过 ≥0.6 基线的帧 —— 链路明明
// 能交付满速,就不是带宽问题(这与判据「每帧字节数」的用意一致)。
// 「某一秒侥幸收全两帧」不会因此让判据沉默:0.6 基线的门槛远高于 1~2 帧。
//
// minFrameBytes 是唯一的绝对量,用于排除「画面几乎静止、只有几 KB 的时钟/进度条
// 补丁」这类小帧;只该对没有码率控制的档位(DIFF/RGB565)设它 —— 有码率控制的
// 档位由判据自己的「每帧是否明显超过标称」把关,再加一道绝对下限只会误伤
// 小屏/慢链路(1024×768 的 30KB 增量帧在 300kbps 上确实堵,但不该被当成小补丁)。
//
// 已知覆盖不到的一档:低于 0.3fps 的链路(一帧要 3 秒以上,1.5~2Mbps 上的
// 1~2MB DIFF 帧就是这种)窗口里最多两帧,①②③ 凑不齐,这里仍然弃权 ——
// 两帧撑不起「持续交付不动」的结论(两次孤立点击也是两帧)。这类现场靠 RTT
// 判据、±2 限幅和升档失败封顶兜底,不会失控,只是降档可能要来得晚一些。
//
// 仍然分不清的一种现场:3 帧摊在 3 秒里然后停住。从控制端能看到的证据(低帧率、
// 大帧、内容还在来)看,它和「链路真的交付不动」完全一样,只能靠降档后的效果来
// 分辨 —— 所以调用方要用本机瓶颈探测 + 升档失败封顶兜底,限幅(最多比 RTT 判据
// 再低 2 档)也限制了误判的代价。
//
// 返回 TRUE 表示可以拿 fps/baseline/kbps 去调 GetTargetQualityLevelByLoad。
inline bool GetCongestedLoadSample(unsigned long long framesInWindow,
unsigned long long bytesInWindow,
int activeSeconds,
unsigned int busiestSecondFrames,
int seconds,
int lastFrameAgeSec,
int baselineFps,
int minFrameBytes,
int& fps, int& baseline, int& kbps)
{
fps = 0;
baseline = 0;
kbps = 0;
if (seconds <= 0 || baselineFps <= 0) return false;
if (framesInWindow < 3 || activeSeconds < 3) return false; // ①
if (lastFrameAgeSec < 0 || lastFrameAgeSec > 4) return false; // ②
if ((long long)busiestSecondFrames * 5 >= (long long)baselineFps * 3) return false; // ③
if (minFrameBytes > 0 && bytesInWindow / framesInWindow < (unsigned long long)minFrameBytes)
return false;
GetWindowedLoadSample(framesInWindow, bytesInWindow, seconds, baselineFps, fps, baseline, kbps);
return true;
}
// 1 秒样本的可用性判定(窗口不可用时的退路)。
//
// 必须和窗口样本过同一道小帧下限:Ultra/High(bitRate == 0,DIFF/RGB565)上画面
// 静止时,客户端每秒只发一两帧几 KB 的时钟/光标补丁 —— 帧率低、吞吐低,判据会
// 反查出最低档,把 LAN 上的画质一路压到 Minimal。窗口路径用 minFrameBytes 挡掉的
// 正是它;窗口被拒后恰好退到这条路,1 秒样本不过门槛就等于白挡。
//
// 帧率/基线同样放大 100 倍,与 GetWindowedLoadSample 保持同一比例。
//
// elapsedMs 是这批计数实际覆盖的时间:WM_TIMER 会被 UI 线程阻塞推迟,一格可能
// 代表两秒多的流量,按 1000ms 算会把速率高估。
inline bool GetSecondLoadSample(unsigned long long frames,
unsigned long long bytes,
unsigned int elapsedMs,
int baselineFps,
int minFrameBytes,
int& fps, int& baseline, int& kbps)
{
fps = 0;
baseline = 0;
kbps = 0;
// frames 上限只是防下面乘 100 * 1000 溢出;真实会话每秒最多几十帧。
if (frames == 0 || frames > 10000ULL || baselineFps <= 0) return false;
if (bytes == 0 || elapsedMs == 0) return false; // 没有实测吞吐/时长,判据没法算
if (minFrameBytes > 0 && bytes / frames < (unsigned long long)minFrameBytes) return false;
fps = (int)(frames * 100 * 1000 / elapsedMs);
baseline = baselineFps * 100;
kbps = (int)(bytes * 8 * 1000 / (1024ULL * elapsedMs));
return true;
}
// 降档后的「本机瓶颈」判定:帧率仍低于基线,但按同一套判据管道并没有满
// (帧不大却发不出来 → 瓶颈在抓屏/编码,而不在链路)。
//
// 这两个条件在画面静止时也会同时成立 —— 客户端 memcmp 跳帧,窗口均值就是
// 「帧率低 + 吞吐小」,notSaturated 必然为真。所以还要一道「最近一秒真的在发帧」
// 的门槛:一次静止就永久停用吞吐判据,代价比漏判一次本机瓶颈大得多。
inline bool IsLocalBottleneck(int fps, int baseline, int kbps, int nominalKbps,
unsigned int lastSecondFrames)
{
if (lastSecondFrames < 2) return false;
if ((long long)fps * 5 >= (long long)baseline * 3) return false;
return GetTargetQualityLevelByLoad(fps, baseline, kbps, nominalKbps) < 0;
}
typedef struct ScreenSettings {
int MaxFPS; // 偏移 0, 最大帧率
int CompressThread; // 偏移 4, 压缩线程数
+160 -30
View File
@@ -1277,12 +1277,14 @@ VOID CScreenSpyDlg::OnReceiveComplete()
DrawFirstScreen();
m_ulFramesThisSecond++;
m_ulScreenBytesThisSecond += len;
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
break;
}
case TOKEN_NEXTSCREEN: {
DrawNextScreenDiff(false);
m_ulFramesThisSecond++;
m_ulScreenBytesThisSecond += len;
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
break;
}
case TOKEN_KEYFRAME: {
@@ -1291,6 +1293,7 @@ VOID CScreenSpyDlg::OnReceiveComplete()
}
m_ulFramesThisSecond++;
m_ulScreenBytesThisSecond += len;
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
break;
}
case TOKEN_SCROLL_FRAME: {
@@ -1299,6 +1302,7 @@ VOID CScreenSpyDlg::OnReceiveComplete()
}
m_ulFramesThisSecond++;
m_ulScreenBytesThisSecond += len;
m_AdaptiveQuality.lastFrameTick = GetTickCount(); // 慢流量窗口用它判断内容是否还在来
break;
}
case TOKEN_CLIPBOARD_TEXT: {
@@ -2666,6 +2670,38 @@ void CScreenSpyDlg::OnTimer(UINT_PTR nIDEvent)
// 屏幕数据速率单独留存给吞吐判据:上面那个总量混了文件传输/音频/剪贴板,
// 传大文件时会让判据误判"链路塞满"。
m_dScreenKBps = m_ulScreenBytesThisSecond / 1024.0;
// 慢流量窗口:这一秒的原始样本进环形缓冲,供 CollectLoadSample 取均值。
// 采样断档(服务端休眠/线程被挂起)时窗口里的样本已经和现在无关,直接清空:
// 不清的话恢复后前 10 秒还在用旧现场判定降档。
{
ULONGLONG sampleNow = GetTickCount64();
// 这一格覆盖的是「上次采样到现在」这段时间,不是整一秒:WM_TIMER 会被
// UI 线程里的阻塞(录像、慢绘制、对话框)推迟,按一格算一秒会把帧率和
// 吞吐整体高估。把实际毫秒数一起存下来,窗口的分母用它。
ULONGLONG gap = (m_AdaptiveQuality.loadWindowLastTick == 0)
? 1000 : (sampleNow - m_AdaptiveQuality.loadWindowLastTick);
m_AdaptiveQuality.loadWindowLastTick = sampleNow;
if (gap > 3000) {
// 采样断档(服务端休眠/线程被挂起):窗口里的样本已经和现在无关,
// 这一格累计的计数同样跨越了断档,一并丢弃,从下一格重新开始。
memset(m_AdaptiveQuality.loadWindowFrames, 0, sizeof(m_AdaptiveQuality.loadWindowFrames));
memset(m_AdaptiveQuality.loadWindowBytes, 0, sizeof(m_AdaptiveQuality.loadWindowBytes));
memset(m_AdaptiveQuality.loadWindowMs, 0, sizeof(m_AdaptiveQuality.loadWindowMs));
m_AdaptiveQuality.loadWindowPos = 0;
m_AdaptiveQuality.loadWindowFilled = 0;
m_AdaptiveQuality.lastLoadSampleMs = 0; // 这一秒的样本也不可信
} else {
m_AdaptiveQuality.lastLoadSampleMs = (ULONG)gap;
const int pos = m_AdaptiveQuality.loadWindowPos;
m_AdaptiveQuality.loadWindowFrames[pos] = m_ulFramesThisSecond;
m_AdaptiveQuality.loadWindowBytes[pos] = m_ulScreenBytesThisSecond;
m_AdaptiveQuality.loadWindowMs[pos] = (ULONG)gap;
if (++m_AdaptiveQuality.loadWindowPos >= m_AdaptiveQuality.LOAD_WINDOW_SECONDS)
m_AdaptiveQuality.loadWindowPos = 0;
if (m_AdaptiveQuality.loadWindowFilled < m_AdaptiveQuality.LOAD_WINDOW_SECONDS)
m_AdaptiveQuality.loadWindowFilled++;
}
}
m_ulScreenBytesThisSecond = 0;
// 使用EMA平滑帧率 (alpha=0.3),避免跳跃
double currentFPS = (double)m_ulFramesThisSecond;
@@ -2797,6 +2833,72 @@ int CScreenSpyDlg::GetClientRTT()
return 0;
}
// 采一份吞吐判据的输入样本:窗口均值优先,窗口不足以证明拥塞时退回 1 秒样本。
//
// 两处判据(吞吐降档、降档后的本机瓶颈探测)必须用同一份样本。原来两处各采各的,
// 在「一帧要两秒」的现场会交替给出相反结论 —— 0 帧秒走窗口说拥塞、收全帧的那一秒
// 走 1 秒计数又算出 4Mbps「没事」,确认计数被反复清零,三拍永远凑不齐。
//(1 秒样本在大帧现场还会高估吞吐:一帧实际传了 2 秒,它只算收全那一秒的字节。)
CScreenSpyDlg::LoadSample CScreenSpyDlg::CollectLoadSample()
{
LoadSample s;
int sampleBaseline = (int)(m_AdaptiveQuality.baselineFps + 0.5);
// 帧龄用 32 位无符号差值算,跨 GetTickCount 回绕(49.7 天)仍是对的;
// 字段本身是 DWORD,避免 x86 上 64 位读被撕裂(见 ScreenSpyDlg.h)。
int lastFrameAge = (m_AdaptiveQuality.lastFrameTick == 0)
? -1 : (int)((DWORD)(GetTickCount() - m_AdaptiveQuality.lastFrameTick) / 1000);
// 每帧字节下限只对没有码率控制的档位生效,理由见 GetCongestedLoadSample;
// 窗口路径和 1 秒样本共用同一道门槛。
const int minFrameBytes =
(GetQualityProfile(m_AdaptiveQuality.currentLevel).bitRate == 0) ? 64 * 1024 : 0;
const int n = m_AdaptiveQuality.loadWindowFilled;
if (n > 0) {
unsigned long long winFrames = 0, winBytes = 0, winMs = 0;
unsigned int busiest = 0;
int activeSeconds = 0;
for (int i = 0; i < n; i++) {
const ULONG f = m_AdaptiveQuality.loadWindowFrames[i];
winFrames += f;
winBytes += m_AdaptiveQuality.loadWindowBytes[i];
winMs += m_AdaptiveQuality.loadWindowMs[i];
if (f > busiest) busiest = f;
if (f > 0) activeSeconds++;
}
// 分母用实际经过的毫秒数,不是格子数:WM_TIMER 被 UI 阻塞推迟时,
// 一格代表两秒多的流量,按一格一秒算会把速率高估。
int seconds = (int)((winMs + 500) / 1000);
if (seconds < 1) seconds = 1;
int fps = 0, baseline = 0, kbps = 0;
if (GetCongestedLoadSample(winFrames, winBytes, activeSeconds, busiest, seconds, lastFrameAge,
sampleBaseline, minFrameBytes, fps, baseline, kbps)) {
s.fps = fps;
s.baseline = baseline;
s.kbps = kbps;
s.usable = true;
s.windowed = true;
s.seconds = seconds;
s.frames = winFrames;
return s;
}
}
// 正常会话(帧够快、有满速秒)走的多是这条路:1 秒样本,对抖动更敏感。
// 帧率/基线同样放大 100 倍:判据只用两者的比值,这里统一比例是为了让日志和
// 其它消费方不必区分两种采样。
{
unsigned long long bytesLastSecond = (unsigned long long)(m_dScreenKBps * 1024.0);
if (GetSecondLoadSample(m_ulFramesLastSecond, bytesLastSecond,
m_AdaptiveQuality.lastLoadSampleMs, sampleBaseline,
minFrameBytes, s.fps, s.baseline, s.kbps)) {
s.usable = true;
}
}
return s;
}
void CScreenSpyDlg::EvaluateQuality()
{
if (!m_AdaptiveQuality.enabled) return;
@@ -2820,6 +2922,10 @@ void CScreenSpyDlg::EvaluateQuality()
m_AdaptiveQuality.baselineFps = floorFps;
}
// 一次评估只采一次样本:降档判据和下面的本机瓶颈探测必须用同一份数据,
// 各采各的会在慢流量现场交替给出相反结论(见 CollectLoadSample)。
const LoadSample load = CollectLoadSample();
// 0.5 降档后观察:真带宽受限时降档同时降低分辨率和码率,管道立刻缓解、帧率必须回升;
// 本机受限(抓屏/编码慢)时降码率对帧率几乎没帮助。10 秒后帧率仍不达标、
// 且管道明显没被填满,就判定瓶颈在本机,本次会话停用吞吐判据。
@@ -2828,28 +2934,25 @@ void CScreenSpyDlg::EvaluateQuality()
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);
// 观察窗里必须真的拿到了样本,否则既不能证明降档奏效也不能证明没奏效:
// 此时若照常判定,"帧率低 + 帧很小"会被误读成"本机瓶颈",一次静止就永久
// 停用吞吐判据。宁可放弃这次探测。
// 用 CollectLoadSample 而不是 1 秒计数:慢流量现场每秒帧数基本都是 0,
// 拿 1 秒计数去卡门槛只会每次都弃权 —— 判据现在覆盖的场景正好是它。
if (!load.usable) {
Mprintf("[Adaptive] 降档观察窗内没有可用样本,放弃本次本机瓶颈判定\n");
} 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) {
// 不再另写一套阈值,避免两处口径不一致;「画面静止不算证据」的门槛
// 也放在同一个 helper 里(见 IsLocalBottleneck)。
const int needKbps = GetQualityProfile(m_AdaptiveQuality.currentLevel).bitRate;
if (IsLocalBottleneck(load.fps, load.baseline, load.kbps, needKbps,
m_ulFramesLastSecond)) {
m_AdaptiveQuality.loadPinned = true;
Mprintf("[Adaptive] 降档后帧率未回升 (%.1f < %.1f) 且帧已不大 (%d/%dkbps),"
"判定瓶颈在本机,本次会话停用吞吐判据\n",
m_dFrameRate, m_AdaptiveQuality.baselineFps * 0.6, nowKbps, needKbps);
load.fps / 100.0, load.baseline * 0.6 / 100.0, load.kbps, needKbps);
}
}
}
@@ -2893,23 +2996,38 @@ void CScreenSpyDlg::EvaluateQuality()
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);
// 一次评估只采一次样本,窗口路径的可用性判定全在 CollectLoadSample 里:
// 大帧把链路堵住时 1 秒窗口是空的(整帧收全才计数),要靠 10 秒均值才表达得出
// 0.2fps;但只有「内容还在持续来、且没有任何一秒交付过满速」才算拥塞证据,
// 否则滚动一下停住、或画面本来就没变化,都会被误判成带宽不足。
if (load.usable) {
levelLoad = GetTargetQualityLevelByLoad(load.fps, load.baseline, load.kbps, 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);
// 判据每秒评估一次,而降档要等冷却和连续确认,期间每一拍都可能满足
// levelLoad > levelRTT(甚至 targetLevel 就等于 currentLevel)。慢流量现场
// 窗口采样让判据几乎每秒都可用,不限流一次会话能刷几千行;10 秒一条既够
// 追踪演进,又不至于把日志打满。限流只作用于日志,不影响计数和应用逻辑。
if (levelLoad >= 0 && levelLoad > levelRTT &&
now - m_AdaptiveQuality.lastLoadLogTime >= 10000) {
m_AdaptiveQuality.lastLoadLogTime = now;
if (load.windowed) {
Mprintf("[Adaptive] 吞吐判据: %d 秒窗口 %llu 帧(≈%.1ffps, 基线%.0f) "
"屏幕≈%dkbps 本档标称=%dkbps → level %d(RTT 判据给 %d)\n",
load.seconds, load.frames, load.fps / 100.0,
load.baseline / 100.0, load.kbps, prof.bitRate,
levelLoad, levelRTT);
} else {
Mprintf("[Adaptive] 吞吐判据: fps=%u(基线%.0f) 屏幕=%.0fKB/s(≈%dkbps) "
"本档标称=%dkbps → level %d(RTT 判据给 %d)\n",
m_ulFramesLastSecond, m_AdaptiveQuality.baselineFps,
m_dScreenKBps, load.kbps, prof.bitRate, levelLoad, levelRTT);
}
}
}
@@ -2926,12 +3044,16 @@ void CScreenSpyDlg::EvaluateQuality()
targetLevel = QUALITY_GOOD;
}
// 3.5 升档失败封顶:升档后 20 秒内又降回升档前的档位或更差,说明那次升档是错的
// 3.5 升档失败封顶:升档后 40 秒内又降回升档前的档位或更差,说明那次升档是错的
// (典型是"降档→队列排空→RTT 变好→升档→队列又满→RTT 变差"的 bufferbloat 循环,
// 跨洲际 + frp 大缓冲链路最容易出现)。记下升档前的档位,3 分钟内不再尝试好于它。
// 宁可停在低一档,也不要在两个档位之间每 30 秒重建一次编码器和分辨率。
// 思路同 TCP 的 ssthresh:失败一次就把天花板降下来,而不是继续试探。
// 惩罚期取 3 分钟:够长以压住振荡,又不至于网络真恢复后一直卡在低档。
// 窗口取 40 秒而不是 20 秒:升档本身会刷新 lastResChangeTime,回到升档前的
// 档位多半要跨分辨率,得先等 15 秒冷却,再叠上吞吐判据的连续 3 拍确认,
// 20 秒经常在降档被允许之前就过期 —— 于是"升上去→卡住→降回来"每次都被
// 判成新情况,封顶永远不触发,循环一直重复。
if (dual && m_AdaptiveQuality.levelCeiling >= 0) {
if (now >= m_AdaptiveQuality.ceilingUntil) {
m_AdaptiveQuality.levelCeiling = -1; // 惩罚期结束,恢复自由升档
@@ -2990,9 +3112,10 @@ void CScreenSpyDlg::EvaluateQuality()
const int need = byLoad ? 3 : 2;
const int have = byLoad ? m_AdaptiveQuality.loadCount : m_AdaptiveQuality.stableCount;
if (have >= need) {
// 升档失败检测:上一次升档后 20 秒内就降回升档前的档位或更差
// 升档失败检测:上一次升档后 40 秒内就降回升档前的档位或更差
// (40 秒的由来见 3.5 节:要等过升档刷新的 15 秒分辨率冷却)
if (dual && m_AdaptiveQuality.lastUpFromLevel >= 0 &&
now - m_AdaptiveQuality.lastUpTime < 20000 &&
now - m_AdaptiveQuality.lastUpTime < 40000 &&
targetLevel >= m_AdaptiveQuality.lastUpFromLevel) {
m_AdaptiveQuality.levelCeiling = m_AdaptiveQuality.lastUpFromLevel;
m_AdaptiveQuality.ceilingUntil = now + 180000;
@@ -3072,6 +3195,13 @@ void CScreenSpyDlg::ApplyQualityLevel(int level, bool persist)
m_AdaptiveQuality.lastChangeTime = GetTickCount64();
m_AdaptiveQuality.stableCount = 0;
m_AdaptiveQuality.loadCount = 0; // 吞吐判据的确认计数同样清零,避免跨档位累积
// 换档前的流量属于旧档位(帧更大更慢、分辨率不同),留在窗口里会继续参与新档位
// 的判定:清空,让新档位重新积累 10 秒样本。
memset(m_AdaptiveQuality.loadWindowFrames, 0, sizeof(m_AdaptiveQuality.loadWindowFrames));
memset(m_AdaptiveQuality.loadWindowBytes, 0, sizeof(m_AdaptiveQuality.loadWindowBytes));
memset(m_AdaptiveQuality.loadWindowMs, 0, sizeof(m_AdaptiveQuality.loadWindowMs));
m_AdaptiveQuality.loadWindowPos = 0;
m_AdaptiveQuality.loadWindowFilled = 0;
// 手动选档(persist=1)时清掉升档封顶和锁档:那是自适应在本会话里试探出来的结论,
// 用户显式指定的档位不该被它压住,否则会出现"选了高档却一直被拉回去"。
+35
View File
@@ -390,6 +390,20 @@ public:
ULONG m_ulFramesLastSecond = 0; // 上一秒的原始帧数(吞吐判据用,不用 EMA)
double m_dFrameRate = 0; // 平滑后的帧率 (FPS)
// 吞吐判据的输入样本:窗口均值和 1 秒样本二选一,一次评估只采一次,
// 判据和「本机瓶颈探测」都用同一份 —— 两处各采各的会出现
// 「窗口说拥塞、1 秒样本说没事」交替,确认计数永远凑不齐(见 CollectLoadSample)。
struct LoadSample {
int fps = 0; // 帧率,100 倍表示(窗口与 1 秒样本统一比例,见 CollectLoadSample)
int baseline = 0; // 基线(与 fps 同比例)
int kbps = 0;
bool usable = false; // false = 两个样本都不可用,判据必须弃权
bool windowed = false; // true = 用的是窗口均值
int seconds = 0; // 窗口秒数(windowed 时有效,日志用)
unsigned long long frames = 0; // 窗口内帧数(日志用)
};
LoadSample CollectLoadSample();
// 自适应质量
struct {
bool enabled = false; // 是否启用自适应 (默认关闭)
@@ -405,6 +419,27 @@ public:
int loadCount = 0; // 吞吐判据的确认计数(字节速率抖动大,比 RTT 多等一拍)
ULONGLONG loadProbeTime = 0; // 降档后的观察起点,0=未在观察
bool loadPinned = false; // 判定瓶颈在本机,本次会话停用吞吐判据
ULONGLONG lastLoadLogTime = 0; // 吞吐判据日志的上次打印时刻(只用于限流,不参与判定)
// ===== 慢流量采样 =====
// 整帧收全才计数,所以「一帧传好几秒」的现场每秒帧数都是 0,1 秒窗口采不到
// 样本。按秒保留原始样本,窗口可用时(判据见 GetCongestedLoadSample)优先用它,
// 否则退回 1 秒样本,见 EvaluateQuality。
enum { LOAD_WINDOW_SECONDS = 10 };
ULONG loadWindowFrames[LOAD_WINDOW_SECONDS] = {};
ULONG loadWindowBytes[LOAD_WINDOW_SECONDS] = {};
// 每格实际覆盖的毫秒数:WM_TIMER 会被 UI 线程的阻塞推迟,按「一格 = 一秒」
// 做分母会把帧率/吞吐整体高估(推迟 3 秒的格子会把速率算成 3 倍)。
ULONG loadWindowMs[LOAD_WINDOW_SECONDS] = {};
// 上一格(1 秒样本)实际覆盖的毫秒数;0 = 这一格不可信(采样断档),
// 判据和本机瓶颈探测这次都弃权。
ULONG lastLoadSampleMs = 0;
int loadWindowPos = 0; // 下一个写入位置
int loadWindowFilled = 0; // 已填入的有效秒数(窗口未满时用它做分母)
ULONGLONG loadWindowLastTick = 0; // 上次采样的时刻(识别采样断档:休眠/挂起)
// 最近一次收全帧的时刻(区分「内容停了」)。写方是网络收包线程、读方是 UI
// 线程,用 32 位的 GetTickCount 而不是 64 位:x86 上一次未加锁的 64 位读
// 可能被撕裂成两个时刻,算出的帧龄会瞬间变成天文数字或负数。
volatile DWORD lastFrameTick = 0;
Review

非阻塞建议:volatile → std::atomic<DWORD>

volatile 在 C++ 标准里不保证跨线程可见性(那是 std::atomic 的职责)。在 MSVC/x86 上对对齐的 32 位 DWORD 读写实际是原子的,所以当前代码安全。但如果将来移植到 ARM 或换编译器,volatile 的语义可能不够。

建议后续用 std::atomic<DWORD> 或 InterlockedExchange/InterlockedCompareExchange 替代,让线程安全意图更明确。不阻塞本次合并。

**非阻塞建议:`volatile` → `std::atomic<DWORD>`** `volatile` 在 C++ 标准里不保证跨线程可见性(那是 `std::atomic` 的职责)。在 MSVC/x86 上对对齐的 32 位 `DWORD` 读写实际是原子的,所以当前代码安全。但如果将来移植到 ARM 或换编译器,`volatile` 的语义可能不够。 建议后续用 `std::atomic<DWORD>` 或 `InterlockedExchange`/`InterlockedCompareExchange` 替代,让线程安全意图更明确。不阻塞本次合并。
// ===== 防振荡状态(只双判据模式下使用)=====
// 升档失败封顶:升档后短时间内又降回来,说明那次升档是错的,
// 在 ceilingUntil 之前不再尝试好于 levelCeiling 的档位(-1 = 无封顶)。
+8
View File
@@ -331,6 +331,14 @@ if(WIN32)
target_compile_definitions(quality_load_test PRIVATE _WIN32)
endif()
if(MSVC)
# CMake 默认给所有目标加 /D_WINDOWS,commands.h 见到它就 include <afxwin.h>;
# 测试用 /MD 又没定义 _AFXDLL,于是直接编译失败(这个目标因此一直没在 Windows
# 上跑起来)。判据本身不需要 MFC,去掉它不是二选一:commands.h 会退回 windows.h。
# 只对 MSVC 生效:MinGW/GCC 不认 /U_WINDOWS。
target_compile_options(quality_load_test PRIVATE /U_WINDOWS)
endif()
if(UNIX)
target_link_libraries(quality_load_test Threads::Threads)
endif()
+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));
Review

测试质量优秀

16 个新用例逐个覆盖了三道防误判门槛的每种假阳性现场(滚动停住、单帧突发、过期窗口),以及 1 秒退路的小帧下限和耗时归一。

特别欣赏 ShortBurstInOneSecondIsNotCongestion 这个用例——3 帧挤在同一秒 vs 散在 3 个秒里的对比测试,精确验证了条件 ① 的设计意图。

**测试质量优秀** 16 个新用例逐个覆盖了三道防误判门槛的每种假阳性现场(滚动停住、单帧突发、过期窗口),以及 1 秒退路的小帧下限和耗时归一。 特别欣赏 `ShortBurstInOneSecondIsNotCongestion` 这个用例——3 帧挤在同一秒 vs 散在 3 个秒里的对比测试,精确验证了条件 ① 的设计意图。
}
// ③ 最后一帧已经过去 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)
{