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:
1 parent
2a97471b51
commit
5f40f3726c
6 files changed
+688
-31
No files matched your search
+171
-1
@@ -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;
|
||||
}
|
||||
|
||||
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 采集
|
||||
}
|
||||
|
||||
|
||||
@@ -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, 压缩线程数
|
||||
|
||||
@@ -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)时清掉升档封顶和锁档:那是自适应在本会话里试探出来的结论,
|
||||
// 用户显式指定的档位不该被它压住,否则会出现"选了高档却一直被拉回去"。
|
||||
|
||||
@@ -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 = 无封顶)。
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user