diff --git a/client/ScreenManager.cpp b/client/ScreenManager.cpp index 87a6be9..27ff7b3 100644 --- a/client/ScreenManager.cpp +++ b/client/ScreenManager.cpp @@ -29,6 +29,7 @@ // WASAPI 音频捕获 #include #include +#include #include #include @@ -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; +} + 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 采集 } diff --git a/common/commands.h b/common/commands.h index eef7bab..522531d 100644 --- a/common/commands.h +++ b/common/commands.h @@ -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, 压缩线程数 diff --git a/server/2015Remote/ScreenSpyDlg.cpp b/server/2015Remote/ScreenSpyDlg.cpp index fac8450..b87b828 100644 --- a/server/2015Remote/ScreenSpyDlg.cpp +++ b/server/2015Remote/ScreenSpyDlg.cpp @@ -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)时清掉升档封顶和锁档:那是自适应在本会话里试探出来的结论, // 用户显式指定的档位不该被它压住,否则会出现"选了高档却一直被拉回去"。 diff --git a/server/2015Remote/ScreenSpyDlg.h b/server/2015Remote/ScreenSpyDlg.h index e8f9704..d8b398d 100644 --- a/server/2015Remote/ScreenSpyDlg.h +++ b/server/2015Remote/ScreenSpyDlg.h @@ -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; // ===== 防振荡状态(只双判据模式下使用)===== // 升档失败封顶:升档后短时间内又降回来,说明那次升档是错的, // 在 ceilingUntil 之前不再尝试好于 levelCeiling 的档位(-1 = 无封顶)。 diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 496a7d5..6d78968 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -331,6 +331,14 @@ if(WIN32) target_compile_definitions(quality_load_test PRIVATE _WIN32) endif() +if(MSVC) + # CMake 默认给所有目标加 /D_WINDOWS,commands.h 见到它就 include ; + # 测试用 /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() diff --git a/test/unit/screen/QualityLoadTest.cpp b/test/unit/screen/QualityLoadTest.cpp index b473d4c..eca3afa 100644 --- a/test/unit/screen/QualityLoadTest.cpp +++ b/test/unit/screen/QualityLoadTest.cpp @@ -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) {