fix(client): fix DXGI black screen on rotated displays and slow first frame

1. Black screen on rotated displays

Root cause: with DXGI Desktop Duplication on a rotated output,
DXGI_OUTDUPL_DESC.ModeDesc reports the logical desktop size (e.g. 1440x2560)
while the surface returned by AcquireNextFrame is the unrotated landscape
bitmap (2560x1440). The old code created cpuTexture from the ModeDesc size.
On a mismatch ID3D11DeviceContext::CopyResource returns void and silently
copies nothing, leaving the destination texture all zeros, so the first
screen and every H.264 frame were fully black (IDR was only 5KB).
The GDI path does not go through DXGI and was unaffected; the web client uses
the DIFF algorithm and was hit too, but looked different.

Fixes:
- Create cpuTexture from the real D3D11_TEXTURE2D_DESC; when the probe fails,
  derive the real surface size from Rotation instead of falling back to
  ModeDesc, which would reintroduce the black screen
- Add BlitRotated() to upright the image for ROTATE90/180/270, with a whole-row
  memcpy fast path for IDENTITY; m_ulFullWidth/Height now hold the upright
  logical size
- Treat DXGI_ERROR_WAIT_TIMEOUT as "no new frame" instead of a failure, so a
  static desktop reuses the previous frame instead of always returning nullptr
- GetFirstScreenData: fix the write offset (start at +1, previously the color
  channels were all wrong) and report the scaled size instead of the full size,
  which used to send about 8.5MB of garbage
- Validate the frame format against a whitelist; fall back to BGRA and warn for
  formats that are not 4 bytes per pixel

2. Slow first frame (the probe frame consumed the initial frame)

Root cause: the probe frame AcquireNextFrame(500), added to read the real
texture description, was released right after use and therefore discarded.
But the frame DXGI pushes after DuplicateOutput is often the only frame
available on a static desktop. After discarding it, the first-screen
AcquireNextFrame always timed out (and that timeout was 1000ms at the time),
ScreenManager had already set m_SendFirst = TRUE so it never retried, and the
encoder had no input to produce an IDR, so the picture only appeared once the
desktop changed. Symptom: MDLL/EXE builds with this fix took a long time to
show the remote desktop, while the old build without the probe frame was fast.

Fixes:
- Keep the probe frame: stash it in m_probeRes without calling ReleaseFrame and
  let the new ConsumeProbeFrame() fill the first screen once the buffers are
  allocated, so the first screen no longer depends on the desktop changing
- Probe timeout 500 -> 200ms; verify both size and format of the probe frame
  against cpuTexture and skip consumption on mismatch, otherwise a silently
  failed CopyResource would be taken as a valid all-black first screen
- CaptureFrame: drop "reuseOk ? 100 : 1000" and use a fixed 100ms timeout. The
  AcquireNextFrame timeout is an upper bound rather than a fixed wait, and
  blocking on a static desktop only slowed the capture loop down to 1Hz
- Retry the first screen up to 3 times on "no new frame" (100ms timeout plus a
  20ms gap); skip the capture entirely when the probe frame already filled it
- Release m_probeRes in CleanupDXGI and ReinitDuplication so the duplication
  object can be released

3. Incomplete picture

- Add ScreenCapture::FitDefaultSendSize(), which scales proportionally so the
  long edge stays at or below 1920 and the short edge at or below 1080, for
  both landscape and portrait. The old min(1920,w) and min(1080,h) clamped the
  axes independently and broke the aspect ratio: a 1440x2560 portrait desktop
  was squeezed to 1440x1080, keeping only 42% of the height
- Use the same helper for both the GDI and DXGI paths; common landscape
  resolutions (1920x1080, 2560x1440, 3840x2160, 1280x720) are unchanged

4. Incidental fixes

- CaptureFrame leaked desktopResource when QueryInterface failed, one DXGI
  resource per failure
- Drop the frame and warn when the surface size changes, for example after the
  user changed the resolution, so BlitRotated does not read out of bounds using
  stale sizes
This commit is contained in:
yuanyuanxiang committed 2026-10-30 21:18:57 +01:00
1 parent 46f4bf2dfb
commit bc75e1ae99
3 files changed
+304 -34

No files matched your search

+18
View File
@@ -866,6 +866,24 @@ public:
return bmpInfo;
}
// 默认发送尺寸上限:等比缩放,保证长边 ≤1920、短边 ≤1080(横竖屏都成立)。
// 原实现是 min(1920,w) 与 min(1080,h) 各自独立截断,宽高比会被破坏:
// 竖屏 1440×2560 会被压成 1440×1080(高度只剩 42%)。
static void FitDefaultSendSize(LONG& w, LONG& h)
{
const LONG longEdge = (w > h) ? w : h;
const LONG shortEdge = (w > h) ? h : w;
float s = 1.0f;
if (longEdge > 1920)
s = 1920.0f / (float)longEdge;
if ((float)shortEdge * s > 1080.0f)
s = 1080.0f / (float)shortEdge;
if (s < 1.0f) {
w = (LONG)((float)w * s);
h = (LONG)((float)h * s);
}
}
// 编码器 lazy 创建。委托 EncoderFactory 完成"硬编探测 + 软编 fallback"。
void ensureEncoder(int width, int height)
{
+284 -31
View File
@@ -24,6 +24,26 @@ private:
ID3D11Texture2D* cpuTexture = nullptr;
BYTE* m_NextBuffer = nullptr;
// 各缓冲是否已成功抓到过至少一帧。
// DXGI 的语义是「只在桌面有变化时才返回新帧」,静止桌面下 AcquireNextFrame
// 必然超时(DXGI_ERROR_WAIT_TIMEOUT)。超时必须复用上一帧而不是当作失败,
// 否则 ScanNextScreen 恒返回 nullptr → 只发光标帧 → H.264 编码器永远拿不到
// 首帧 IDR → 服务端 Decode() 不执行 → m_bIsFirst 无法解除 → 永久黑屏。
bool m_bFirstValid = false;
bool m_bNextValid = false;
static constexpr int kNoNewFrame = -100; // 无新帧,非错误
// 旋转输出(竖屏)下 DXGI 给的表面是「未旋转」的横向位图,
// 与桌面逻辑尺寸互为宽高交换,需要自行旋转。这里记录表面真实尺寸与旋转角。
int m_surfW = 0;
int m_surfH = 0;
DXGI_MODE_ROTATION m_rotation = DXGI_MODE_ROTATION_IDENTITY;
// InitDXGI 探测阶段抓到的帧。DuplicateOutput 之后 DXGI 会推送一帧当前桌面,
// 静止桌面下这往往就是唯一能拿到的一帧,丢弃它会导致首屏只能等桌面变化。
// 因此探测完先留在手上(不 ReleaseFrame),由 ConsumeProbeFrame() 消费。
IDXGIResource* m_probeRes = nullptr;
public:
ScreenCapturerDXGI(BYTE algo, int gop = DEFAULT_GOP, BOOL all = FALSE, int level = LEVEL_H264_SOFT,
RECT rc = {0}, BOOL switchScreen = TRUE)
@@ -73,7 +93,8 @@ public:
// 4. 获取 DXGI 输出(屏幕)
static UINT screen = 0;
HRESULT r = dxgiAdapter->EnumOutputs(switchScreen ? screen++ : screen, &dxgiOutput);
UINT outIndex = switchScreen ? screen++ : screen;
HRESULT r = dxgiAdapter->EnumOutputs(outIndex, &dxgiOutput);
if (r == DXGI_ERROR_NOT_FOUND && all) {
screen = 0;
idx ++;
@@ -101,16 +122,67 @@ public:
// 7. 获取屏幕大小
DXGI_OUTDUPL_DESC duplDesc;
deskDupl->GetDesc(&duplDesc);
m_ulFullWidth = duplDesc.ModeDesc.Width;
m_ulFullHeight = duplDesc.ModeDesc.Height;
// 8. 创建 CPU 访问纹理
// 旋转输出(竖屏)下 ModeDesc 报告的是逻辑桌面尺寸,而实际捕获表面是
// 「未旋转」的横向位图,两者宽高互换。若按 ModeDesc 建 CPU 纹理,
// CopyResource 会静默不复制(返回 void)→ cpuTexture 全零 → 黑屏。
// 先取一帧读真实纹理描述;取不到时按旋转关系推导,避免退回错误尺寸。
m_rotation = duplDesc.Rotation;
const bool swapWH = (m_rotation == DXGI_MODE_ROTATION_ROTATE90 ||
m_rotation == DXGI_MODE_ROTATION_ROTATE270);
UINT realW = swapWH ? duplDesc.ModeDesc.Height : duplDesc.ModeDesc.Width;
UINT realH = swapWH ? duplDesc.ModeDesc.Width : duplDesc.ModeDesc.Height;
DXGI_FORMAT realFmt = DXGI_FORMAT_B8G8R8A8_UNORM;
{
IDXGIResource* probeRes = nullptr;
DXGI_OUTDUPL_FRAME_INFO probeInfo = {};
HRESULT phr = deskDupl->AcquireNextFrame(200, &probeInfo, &probeRes);
if (SUCCEEDED(phr)) {
if (probeRes) {
ID3D11Texture2D* probeTex = nullptr;
if (SUCCEEDED(probeRes->QueryInterface(__uuidof(ID3D11Texture2D), (void**)&probeTex)) && probeTex) {
D3D11_TEXTURE2D_DESC td = {};
probeTex->GetDesc(&td);
realW = td.Width;
realH = td.Height;
realFmt = td.Format;
probeTex->Release();
}
// 不要丢弃这一帧:暂存起来,等缓冲分配完由 ConsumeProbeFrame()
// 直接填充首屏。否则静止桌面下首屏 AcquireNextFrame 必然超时。
m_probeRes = probeRes;
} else {
deskDupl->ReleaseFrame();
}
}
}
// 内存布局按 4 字节/像素计算,非 4 字节格式回退 BGRA
switch (realFmt) {
case DXGI_FORMAT_B8G8R8A8_UNORM:
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
case DXGI_FORMAT_R8G8B8A8_UNORM:
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
case DXGI_FORMAT_R10G10B10A2_UNORM:
break;
default:
Mprintf("[DXGI] unsupported fmt=%d, fallback BGRA\n", (int)realFmt);
realFmt = DXGI_FORMAT_B8G8R8A8_UNORM;
break;
}
// 后续所有缓冲/位图信息/缩放都按「正立」的逻辑尺寸计算
m_surfW = (int)realW;
m_surfH = (int)realH;
m_ulFullWidth = swapWH ? realH : realW;
m_ulFullHeight = swapWH ? realW : realH;
// 8. 创建 CPU 访问纹理(按表面原始尺寸/格式,保证 CopyResource 成功)
D3D11_TEXTURE2D_DESC desc = {};
desc.Width = m_ulFullWidth;
desc.Height = m_ulFullHeight;
desc.Width = realW;
desc.Height = realH;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
desc.Format = realFmt;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
@@ -135,9 +207,8 @@ public:
((m_BitmapInfor_Send->bmiHeader.biWidth * m_BitmapInfor_Send->bmiHeader.biBitCount + 31) / 32) *
4 * m_BitmapInfor_Send->bmiHeader.biHeight;
} else {
// strategy=0 或 maxWidth=0: 默认 1080p 限制
m_BitmapInfor_Send->bmiHeader.biWidth = min(1920, m_BitmapInfor_Send->bmiHeader.biWidth);
m_BitmapInfor_Send->bmiHeader.biHeight = min(1080, m_BitmapInfor_Send->bmiHeader.biHeight);
// strategy=0 或 maxWidth=0: 默认 1080p 限制(等比,避免竖屏被压扁)
FitDefaultSendSize(m_BitmapInfor_Send->bmiHeader.biWidth, m_BitmapInfor_Send->bmiHeader.biHeight);
m_BitmapInfor_Send->bmiHeader.biSizeImage =
((m_BitmapInfor_Send->bmiHeader.biWidth * m_BitmapInfor_Send->bmiHeader.biBitCount + 31) / 32) *
4 * m_BitmapInfor_Send->bmiHeader.biHeight;
@@ -149,6 +220,12 @@ public:
m_BmpZoomBuffer = new BYTE[m_BitmapInfor_Send->bmiHeader.biSizeImage * 2 + 12];
m_BmpZoomFirst = nullptr;
// 缓冲就绪,把探测阶段暂存的那一帧直接填成首屏内容。
// 这一步让首屏不再依赖「桌面发生变化」,连接后立即可出画面。
if (m_probeRes) {
ConsumeProbeFrame();
}
// ROI
int w = m_ROI.right - m_ROI.left, h = m_ROI.bottom - m_ROI.top;
if (w > 0 && h > 0) {
@@ -158,6 +235,11 @@ public:
m_BitmapInfor_Send->bmiHeader.biHeight = h;
m_BitmapInfor_Send->bmiHeader.biSizeImage = w * h * 4;
}
Mprintf("[DXGI] out=%u mode=%ux%u surf=%ux%u fmt=%d rot=%d -> send=%dx%d\n",
outIndex, duplDesc.ModeDesc.Width, duplDesc.ModeDesc.Height,
m_surfW, m_surfH, (int)realFmt, (int)m_rotation,
(int)m_BitmapInfor_Send->bmiHeader.biWidth,
(int)m_BitmapInfor_Send->bmiHeader.biHeight);
break;
} while (true);
@@ -175,6 +257,12 @@ public:
void CleanupDXGI()
{
// 探测帧若还挂着(例如 InitDXGI 中途失败),必须归还,否则 duplication 无法释放
if (m_probeRes) {
if (deskDupl) deskDupl->ReleaseFrame();
m_probeRes->Release();
m_probeRes = nullptr;
}
if (cpuTexture) cpuTexture->Release();
if (deskDupl) deskDupl->Release();
if (d3dContext) d3dContext->Release();
@@ -196,14 +284,52 @@ public:
LPBYTE GetFirstScreenData(ULONG* ulFirstScreenLength) override
{
int ret = CaptureFrame(m_FirstBuffer, ulFirstScreenLength, 1);
scaleBitmap(m_BmpZoomBuffer, m_FirstBuffer);
memcpy(m_FirstBuffer, m_BmpZoomBuffer, m_BitmapInfor_Send->bmiHeader.biSizeImage);
if (ret)
// 首屏是一次性同步操作:ScreenManager 在调用前已把 m_SendFirst 置 TRUE,
// 一旦返回 nullptr 就不会再重试。所以这里尽量拿到内容——探测阶段暂存的
// 帧通常已填充好,静止桌面下偶尔无新帧时再用短超时补抓几次。
const DWORD startTick = GetTickCount();
int ret = 0;
int attempts = 0;
if (!m_bFirstValid) { // 探测帧已填充时直接用,不再白等一次 AcquireNextFrame
ret = kNoNewFrame;
while (attempts < 3) {
++attempts;
ret = CaptureFrame(m_FirstBuffer, ulFirstScreenLength, 1, &m_bFirstValid);
if (ret != kNoNewFrame) break;
if (m_bFirstValid) { ret = 0; break; }
Sleep(20);
}
}
const DWORD elapsed = GetTickCount() - startTick;
if (elapsed > 300) {
// 只在明显偏慢时记录,正常连接不会产生这行
Mprintf("[DXGI] first screen slow: %ums attempts=%d ok=%d\n",
elapsed, attempts, ret == 0);
}
if (ret == kNoNewFrame) {
// 静态桌面:DXGI 无新帧,m_FirstBuffer 里仍是上一帧,直接复用
if (!m_bFirstValid) {
*ulFirstScreenLength = 0;
return nullptr;
}
ret = 0;
}
if (ret) {
*ulFirstScreenLength = 0;
return nullptr;
}
// reservedBytes=1,实际位图从 m_FirstBuffer+1 开始;
// 服务端也是从偏移 1 开始拷贝,写回时必须保持同样的偏移
scaleBitmap(m_BmpZoomBuffer, m_FirstBuffer + 1);
memcpy(m_FirstBuffer + 1, m_BmpZoomBuffer, m_BitmapInfor_Send->bmiHeader.biSizeImage);
// 缓冲已被缩放图覆盖,+1 处不再是完整帧,后续无新帧时不可再复用
m_bFirstValid = false;
if (m_bAlgorithm == ALGORITHM_GRAY) {
ToGray(1 + m_RectBuffer, 1 + m_RectBuffer, m_BitmapInfor_Send->bmiHeader.biSizeImage);
}
// 长度必须是缩放后的发送尺寸,不能沿用 CaptureFrame 写入的全尺寸,
// 否则会把整帧原始数据(数倍于图像)一并发给服务端
*ulFirstScreenLength = m_BitmapInfor_Send->bmiHeader.biSizeImage;
m_FirstBuffer[0] = TOKEN_FIRSTSCREEN;
return m_FirstBuffer;
}
@@ -211,11 +337,16 @@ public:
LPBYTE ScanNextScreen() override
{
ULONG ulNextScreenLength = 0;
int ret = CaptureFrame(m_NextBuffer, &ulNextScreenLength, 0);
scaleBitmap(m_BmpZoomBuffer, m_NextBuffer);
memcpy(m_NextBuffer, m_BmpZoomBuffer, m_BitmapInfor_Send->bmiHeader.biSizeImage);
int ret = CaptureFrame(m_NextBuffer, &ulNextScreenLength, 0, &m_bNextValid);
if (ret == kNoNewFrame) {
// 无新帧:m_NextBuffer 里已是上次缩放后的结果,必须原样返回,
// 不能再走一遍 scaleBitmap(源已是缩放图,重复缩放会损坏画面)
return m_bNextValid ? m_NextBuffer : nullptr;
}
if (ret)
return nullptr;
scaleBitmap(m_BmpZoomBuffer, m_NextBuffer);
memcpy(m_NextBuffer, m_BmpZoomBuffer, m_BitmapInfor_Send->bmiHeader.biSizeImage);
return m_NextBuffer;
}
@@ -229,6 +360,12 @@ private:
// 重新初始化 Desktop Duplication
BOOL ReinitDuplication()
{
// 重建前必须把暂存帧归还,否则旧的 duplication 无法释放
if (m_probeRes) {
if (deskDupl) deskDupl->ReleaseFrame();
m_probeRes->Release();
m_probeRes = nullptr;
}
if (deskDupl) {
deskDupl->Release();
deskDupl = nullptr;
@@ -263,23 +400,116 @@ private:
return SUCCEEDED(hr) && deskDupl;
}
int CaptureFrame(LPBYTE buffer, ULONG* frameSize, int reservedBytes)
// 把 DXGI 表面(top-down,srcW×srcH,BGRA)按 rotation 摆正后写入目标
// (bottom-up DIB,m_ulFullWidth×m_ulFullHeight)。分块处理保证缓存友好。
void BlitRotated(BYTE* dst, const BYTE* src, int srcPitch,
int srcW, int srcH, DXGI_MODE_ROTATION rot)
{
const int dstW = (int)m_ulFullWidth;
const int dstH = (int)m_ulFullHeight;
const int dstPitch = dstW * 4;
auto put = [&](int x, int y, int sx, int sy) {
memcpy(dst + (size_t)(dstH - 1 - y) * dstPitch + (size_t)x * 4,
src + (size_t)sy * srcPitch + (size_t)sx * 4, 4);
};
if (rot == DXGI_MODE_ROTATION_ROTATE90 || rot == DXGI_MODE_ROTATION_ROTATE270) {
const bool cw = (rot == DXGI_MODE_ROTATION_ROTATE90);
const int T = 32;
for (int y0 = 0; y0 < dstH; y0 += T) {
const int yEnd = (y0 + T < dstH) ? y0 + T : dstH;
for (int x0 = 0; x0 < dstW; x0 += T) {
const int xEnd = (x0 + T < dstW) ? x0 + T : dstW;
for (int y = y0; y < yEnd; y++) {
for (int x = x0; x < xEnd; x++) {
const int sx = cw ? y : (srcW - 1 - y);
const int sy = cw ? (srcH - 1 - x) : x;
put(x, y, sx, sy);
}
}
}
}
} else if (rot == DXGI_MODE_ROTATION_ROTATE180) {
for (int y = 0; y < dstH; y++)
for (int x = 0; x < dstW; x++)
put(x, y, srcW - 1 - x, srcH - 1 - y);
} else {
// IDENTITY:整行拷贝(快路径)
for (int y = 0; y < dstH; y++)
memcpy(dst + (size_t)(dstH - 1 - y) * dstPitch,
src + (size_t)y * srcPitch, (size_t)dstPitch);
}
}
// 消费 InitDXGI 探测阶段暂存的那一帧,直接填充 m_FirstBuffer(偏移 1 起)。
// 无论成败都会释放暂存资源与 DXGI 帧,避免泄漏。
bool ConsumeProbeFrame()
{
if (!m_probeRes) return false;
bool ok = false;
ID3D11Texture2D* tex = nullptr;
if (cpuTexture && m_FirstBuffer &&
SUCCEEDED(m_probeRes->QueryInterface(__uuidof(ID3D11Texture2D), (void**)&tex)) && tex) {
// 尺寸与格式都必须与建 cpuTexture 时一致,否则 CopyResource 静默不复制
// (读出来是全零)。探测阶段 QI 失败会退回推导尺寸、格式白名单也可能把
// 非常见格式回退成 BGRA,这里再核对一次,不符就放弃消费,让
// GetFirstScreenData 走正常抓帧路径,避免把全黑画面当成首屏发出去。
D3D11_TEXTURE2D_DESC sd = {}, dd = {};
tex->GetDesc(&sd);
cpuTexture->GetDesc(&dd);
if (sd.Width == dd.Width && sd.Height == dd.Height && sd.Format == dd.Format) {
d3dContext->CopyResource(cpuTexture, tex);
D3D11_MAPPED_SUBRESOURCE mapped = {};
if (SUCCEEDED(d3dContext->Map(cpuTexture, 0, D3D11_MAP_READ, 0, &mapped))) {
BlitRotated(m_FirstBuffer + 1, (const BYTE*)mapped.pData,
(int)mapped.RowPitch, m_surfW, m_surfH, m_rotation);
d3dContext->Unmap(cpuTexture, 0);
m_bFirstValid = true;
ok = true;
}
} else {
Mprintf("[DXGI] probe %ux%u fmt=%d != cpu %ux%u fmt=%d, skip probe frame\n",
sd.Width, sd.Height, (int)sd.Format, dd.Width, dd.Height, (int)dd.Format);
}
tex->Release();
}
if (deskDupl) deskDupl->ReleaseFrame();
m_probeRes->Release();
m_probeRes = nullptr;
return ok;
}
int CaptureFrame(LPBYTE buffer, ULONG* frameSize, int reservedBytes, bool* valid)
{
if (!deskDupl) {
if (!ReinitDuplication()) return -10;
}
// 超时保持 100ms(与修复前一致)。AcquireNextFrame 的 timeout 是「最多等
// 多久」而不是「一定等这么久」,有帧会立即返回;静止桌面下白等只会拖慢
// 抓屏线程的轮询节奏(曾用 1000ms,导致首屏和之后每一帧都阻塞 1 秒)。
const UINT timeout = 100;
// 1. 获取下一帧
IDXGIResource* desktopResource = nullptr;
DXGI_OUTDUPL_FRAME_INFO frameInfo;
HRESULT hr = deskDupl->AcquireNextFrame(100, &frameInfo, &desktopResource);
HRESULT hr = deskDupl->AcquireNextFrame(timeout, &frameInfo, &desktopResource);
// 处理全屏切换导致的访问丢失
if (hr == DXGI_ERROR_ACCESS_LOST) {
if (ReinitDuplication()) {
hr = deskDupl->AcquireNextFrame(100, &frameInfo, &desktopResource);
hr = deskDupl->AcquireNextFrame(timeout, &frameInfo, &desktopResource);
}
}
// 桌面静止时没有新帧,这是 DXGI 的正常语义,不能当成错误。
// 调用方据此复用上一帧内容,保证编码器持续有输入。
if (hr == DXGI_ERROR_WAIT_TIMEOUT) {
return kNoNewFrame;
}
if (FAILED(hr)) {
return -1;
}
@@ -289,10 +519,40 @@ private:
hr = desktopResource->QueryInterface(__uuidof(ID3D11Texture2D), (void**)&texture);
if (FAILED(hr)) {
deskDupl->ReleaseFrame();
desktopResource->Release(); // 原来漏了,每次失败都会泄漏一个 DXGI 资源
return -2;
}
// 3. 复制到 CPU 纹理
// ID3D11DeviceContext::CopyResource 返回 void:尺寸/格式不匹配时不会报错,
// 只会静默不复制(目标保持原值 = 全零)。这里显式比对描述。
// 尺寸不一致时必须放弃这一帧:BlitRotated 按 m_surfW/H 计算源偏移,
// 表面变小会越界读取(崩溃或花屏),宁可跳过等 ReinitDuplication。
{
D3D11_TEXTURE2D_DESC sd = {};
texture->GetDesc(&sd);
if ((int)sd.Width != m_surfW || (int)sd.Height != m_surfH) {
static LONG s_sizeLog = 0;
if (s_sizeLog++ < 3) {
Mprintf("[DXGI] surface changed %dx%d -> %ux%u, drop frame\n",
m_surfW, m_surfH, sd.Width, sd.Height);
}
deskDupl->ReleaseFrame();
texture->Release();
desktopResource->Release();
return -4;
}
static LONG s_fmtLog = 0;
if (s_fmtLog < 3) {
D3D11_TEXTURE2D_DESC dd = {};
cpuTexture->GetDesc(&dd);
if (sd.Format != dd.Format) {
Mprintf("[DXGI] DESC MISMATCH fmt src=%d dst=%d\n",
(int)sd.Format, (int)dd.Format);
}
s_fmtLog++;
}
}
d3dContext->CopyResource(cpuTexture, texture);
// 4. 释放 DXGI 资源
@@ -307,22 +567,15 @@ private:
return -3;
}
// 6. 复制数据到缓冲区(垂直翻转)
BYTE* pData = (BYTE*)mapped.pData;
int rowSize = m_ulFullWidth * 4; // 每行的字节数(RGBA)
BYTE* dest = buffer + reservedBytes + (m_ulFullHeight - 1) * rowSize;
BYTE* src = pData;
for (int y = 0; y < m_ulFullHeight; y++) {
memcpy(dest, src, rowSize);
dest -= rowSize;
src += mapped.RowPitch;
}
// 6. 复制数据到缓冲区(按旋转角摆正 + 垂直翻转到 bottom-up DIB)
BlitRotated(buffer + reservedBytes, (const BYTE*)mapped.pData,
(int)mapped.RowPitch, m_surfW, m_surfH, m_rotation);
// 7. 清理
d3dContext->Unmap(cpuTexture, 0);
*frameSize = m_ulFullWidth * m_ulFullHeight * 4;
if (valid) *valid = true;
return 0;
}
};
+2 -3
View File
@@ -66,9 +66,8 @@ CScreenSpy::CScreenSpy(ULONG ulbiBitCount, BYTE algo, BOOL vDesk, int gop, BOOL
Mprintf("CScreenSpy: 自定义分辨率 %dx%d\n",
m_BitmapInfor_Send->bmiHeader.biWidth, m_BitmapInfor_Send->bmiHeader.biHeight);
} else {
// strategy=0 或 maxWidth=0: 默认 1080p 限制
m_BitmapInfor_Send->bmiHeader.biWidth = min(1920, m_BitmapInfor_Send->bmiHeader.biWidth);
m_BitmapInfor_Send->bmiHeader.biHeight = min(1080, m_BitmapInfor_Send->bmiHeader.biHeight);
// strategy=0 或 maxWidth=0: 默认 1080p 限制(等比,避免竖屏被压扁)
FitDefaultSendSize(m_BitmapInfor_Send->bmiHeader.biWidth, m_BitmapInfor_Send->bmiHeader.biHeight);
m_BitmapInfor_Send->bmiHeader.biSizeImage =
((m_BitmapInfor_Send->bmiHeader.biWidth * m_BitmapInfor_Send->bmiHeader.biBitCount + 31) / 32) *
4 * m_BitmapInfor_Send->bmiHeader.biHeight;