devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ScreenCapture：通过DirectX 库进行屏幕捕获

作者：Monodyee | 2024-03-21 10:38:00

赞

踩

screencapture

具有音频混合功能的 DirectX 硬件屏幕捕获和编码。 H264/H265/VP80/VP90/FLAC/MP3。

以硬件方式捕获视频和屏幕截图。

介绍

有很多关于它的东西。 这是一个简单的单头文件，硬件加速。 如果使用 Windows 8 或更高版本，您可以轻松地将其包含在您的项目中。

要求

Windows 8 或更高版本。

视频截取

我们需要在 DXGI 的帮助下枚举我们的适配器和监视器的数量：

  1. static void GetAdapters(std::vector<CComPtr<IDXGIAdapter1>>& a)
  2. {
  3.     CComPtr<IDXGIFactory1> df;
  4.     CreateDXGIFactory1(__uuidof(IDXGIFactory1),(void**)&df);
  5.     a.clear();
  6.     if (!df)
  7.         return;
  8.     int L = 0;
  9.     for (;;)
  10.     {
  11.         CComPtr<IDXGIAdapter1> lDxgiAdapter;
  12.         df->EnumAdapters1(L, &lDxgiAdapter);
  13.         if (!lDxgiAdapter)
  14.             break;
  15.         L++;
  16.         a.push_back(lDxgiAdapter);
  17.     }
  18. }

然后，我们将使用其中一个或默认值来实例化 DirectX 11 设备：

  1. HRESULT CreateDirect3DDevice(IDXGIAdapter1* g)
  2. {
  3.     HRESULT hr = S_OK;
  4.  
  5.     // 支持的驱动程序类型
  6.     D3D_DRIVER_TYPE DriverTypes[] =
  7.     {
  8.         D3D_DRIVER_TYPE_HARDWARE,
  9.         D3D_DRIVER_TYPE_WARP,
  10.         D3D_DRIVER_TYPE_REFERENCE,
  11.     };
  12.     UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
  13.  
  14.     // 支持的功能级别
  15.     D3D_FEATURE_LEVEL FeatureLevels[] =
  16.     {
  17.         D3D_FEATURE_LEVEL_11_0,
  18.         D3D_FEATURE_LEVEL_10_1,
  19.         D3D_FEATURE_LEVEL_10_0,
  20.         D3D_FEATURE_LEVEL_9_3,
  21.         D3D_FEATURE_LEVEL_9_2,
  22.         D3D_FEATURE_LEVEL_9_1
  23.     };
  24.     UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
  25.  
  26.     D3D_FEATURE_LEVEL FeatureLevel;
  27.  
  28.     // 创建设备
  29.     for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex)
  30.     {
  31.         hr = D3D11CreateDevice(g, DriverTypes[DriverTypeIndex], 
  32.              nullptr, D3D11_CREATE_DEVICE_VIDEO_SUPPORT, FeatureLevels, NumFeatureLevels,
  33.              D3D11_SDK_VERSION, &device, &FeatureLevel, &context);
  34.         if (SUCCEEDED(hr))
  35.         {
  36.             // 设备创建成功，无需循环
  37.             break;
  38.         }
  39.     }
  40.     if (FAILED(hr))
  41.         return hr;
  42.  
  43.     return S_OK;
  44. }

我们要创建输出的桌面副本，然后：

  1. bool Prepare(UINT Output = 0)
  2. {
  3.     // 获取 DXGI 设备
  4.     CComPtr<IDXGIDevice> lDxgiDevice;
  5.     lDxgiDevice = device;
  6.     if (!lDxgiDevice)
  7.         return 0;
  8.  
  9.     // 获取 DXGI 适配器
  10.     CComPtr<IDXGIAdapter> lDxgiAdapter;
  11.     auto hr = lDxgiDevice->GetParent(
  12.         __uuidof(IDXGIAdapter),
  13.         reinterpret_cast<void**>(&lDxgiAdapter));
  14.  
  15.     if (FAILED(hr))
  16.         return 0;
  17.  
  18.     lDxgiDevice = 0;
  19.  
  20.     // 获取输出
  21.     CComPtr<IDXGIOutput> lDxgiOutput;
  22.     hr = lDxgiAdapter->EnumOutputs(Output, &lDxgiOutput);
  23.     if (FAILED(hr))
  24.         return 0;
  25.  
  26.     lDxgiAdapter = 0;
  27.  
  28.     DXGI_OUTPUT_DESC lOutputDesc;
  29.     hr = lDxgiOutput->GetDesc(&lOutputDesc);
  30.  
  31.     // QI for Output 1
  32.     CComPtr<IDXGIOutput1> lDxgiOutput1;
  33.     lDxgiOutput1 = lDxgiOutput;
  34.     if (!lDxgiOutput1)
  35.         return 0;
  36.  
  37.     lDxgiOutput = 0;
  38.  
  39.     // 创建桌面副本
  40.     hr = lDxgiOutput1->DuplicateOutput(
  41.         device,
  42.         &lDeskDupl);
  43.  
  44.     if (FAILED(hr))
  45.         return 0;
  46.  
  47.     lDxgiOutput1 = 0;
  48.  
  49.     // 创建 GUI 绘图纹理
  50.     lDeskDupl->GetDesc(&lOutputDuplDesc);
  51.     D3D11_TEXTURE2D_DESC desc = {};
  52.     desc.Width = lOutputDuplDesc.ModeDesc.Width;
  53.     desc.Height = lOutputDuplDesc.ModeDesc.Height;
  54.     desc.Format = lOutputDuplDesc.ModeDesc.Format;
  55.     desc.ArraySize = 1;
  56.     desc.BindFlags = D3D11_BIND_FLAG::D3D11_BIND_RENDER_TARGET;
  57.     desc.MiscFlags = D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
  58.     desc.SampleDesc.Count = 1;
  59.     desc.SampleDesc.Quality = 0;
  60.     desc.MipLevels = 1;
  61.     desc.CPUAccessFlags = 0;
  62.     desc.Usage = D3D11_USAGE_DEFAULT;
  63.     hr = device->CreateTexture2D(&desc, NULL, &lGDIImage);
  64.     if (FAILED(hr))
  65.         return 0;
  66.  
  67.     if (lGDIImage == nullptr)
  68.         return 0;
  69.  
  70.     // 创建 CPU 访问纹理
  71.     desc.Width = lOutputDuplDesc.ModeDesc.Width;
  72.     desc.Height = lOutputDuplDesc.ModeDesc.Height;
  73.     desc.Format = lOutputDuplDesc.ModeDesc.Format;
  74.     desc.ArraySize = 1;
  75.     desc.BindFlags = 0;
  76.     desc.MiscFlags = 0;
  77.     desc.SampleDesc.Count = 1;
  78.     desc.SampleDesc.Quality = 0;
  79.     desc.MipLevels = 1;
  80.     desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
  81.     desc.Usage = D3D11_USAGE_STAGING;
  82.     hr = device->CreateTexture2D(&desc, NULL, &lDestImage);
  83.     if (FAILED(hr))
  84.         return 0;
  85.  
  86.     if (lDestImage == nullptr)
  87.         return 0;
  88.  
  89.     return 1;
  90. }

要获取屏幕截图，我们循环：

  1. hr = cap.lDeskDupl->AcquireNextFrame(
  2.     0,
  3.     &lFrameInfo,
  4.     &lDesktopResource);
  5. if (hr == DXGI_ERROR_WAIT_TIMEOUT)
  6.     hr = S_OK;
  7. if (FAILED(hr))
  8.     break;
  9. if (lDesktopResource && !cap.Get(lDesktopResource, dp.Cursor, 
  10.                                  dp.rx.right && dp.rx.bottom ? &dp.rx : 0))
  11.     break;

get() 方法将返回位图，可选地包含和裁剪的光标：

  1. bool Get(IDXGIResource* lDesktopResource,bool Curs,RECT* rcx = 0)
  2. {
  3.     // ID3D11Texture2D 的 QI
  4.     CComPtr<ID3D11Texture2D> lAcquiredDesktopImage;
  5.     if (!lDesktopResource)
  6.         return 0;
  7.     auto hr = lDesktopResource->QueryInterface(IID_PPV_ARGS(&lAcquiredDesktopImage));
  8.     if (!lAcquiredDesktopImage)
  9.         return 0;
  10.     lDesktopResource = 0;
  11.  
  12.     // 将图像复制到 GDI 绘图纹理中
  13.     context->CopyResource(lGDIImage, lAcquiredDesktopImage);
  14.  
  15.     // 将光标图像绘制到 GDI 绘图纹理中
  16.     CComPtr<IDXGISurface1> lIDXGISurface1;
  17.  
  18.     lIDXGISurface1 = lGDIImage;
  19.  
  20.     if (!lIDXGISurface1)
  21.         return 0;
  22.  
  23.     CURSORINFO lCursorInfo = { 0 };
  24.     lCursorInfo.cbSize = sizeof(lCursorInfo);
  25.     auto lBoolres = GetCursorInfo(&lCursorInfo);
  26.     if (lBoolres == TRUE)
  27.     {
  28.         if (lCursorInfo.flags == CURSOR_SHOWING && Curs)
  29.         {
  30.             auto lCursorPosition = lCursorInfo.ptScreenPos;
  31. //                auto lCursorSize = lCursorInfo.cbSize;
  32.             HDC  lHDC;
  33.             lIDXGISurface1->GetDC(FALSE, &lHDC);
  34.             DrawIconEx(
  35.                 lHDC,
  36.                 lCursorPosition.x,
  37.                 lCursorPosition.y,
  38.                 lCursorInfo.hCursor,
  39.                 0,
  40.                 0,
  41.                 0,
  42.                 0,
  43.                 DI_NORMAL | DI_DEFAULTSIZE);
  44.             lIDXGISurface1->ReleaseDC(nullptr);
  45.         }
  46.     }
  47.  
  48.     // 将图像复制到 CPU 访问纹理中
  49.     context->CopyResource(lDestImage, lGDIImage);
  50.  
  51.     // Copy from CPU access texture to bitmap buffer
  52.     D3D11_MAPPED_SUBRESOURCE resource;
  53.     UINT subresource = D3D11CalcSubresource(0, 0, 0);
  54.     hr = context->Map(lDestImage, subresource, D3D11_MAP_READ_WRITE, 0, &resource);
  55.     if (FAILED(hr))
  56.         return 0;
  57.  
  58.     auto sz = lOutputDuplDesc.ModeDesc.Width
  59.         * lOutputDuplDesc.ModeDesc.Height * 4;
  60.     auto sz2 = sz;
  61.     buf.resize(sz);
  62.     if (rcx)
  63.     {
  64.         sz2 = (rcx->right - rcx->left) * (rcx->bottom - rcx->top) * 4;
  65.         buf.resize(sz2);
  66.         sz = sz2;
  67.     }
  68.  
  69.     UINT lBmpRowPitch = lOutputDuplDesc.ModeDesc.Width * 4;
  70.     if (rcx)
  71.         lBmpRowPitch = (rcx->right - rcx->left) * 4;
  72.     UINT lRowPitch = std::min<UINT>(lBmpRowPitch, resource.RowPitch);
  73.  
  74.     BYTE* sptr = reinterpret_cast<BYTE*>(resource.pData);
  75.     BYTE* dptr = buf.data() + sz - lBmpRowPitch;
  76.     if (rcx)
  77.         sptr += rcx->left * 4;
  78.     for (size_t h = 0; h < lOutputDuplDesc.ModeDesc.Height; ++h)
  79.     {
  80.         if (rcx && h < (size_t)rcx->top)
  81.         {
  82.             sptr += resource.RowPitch;
  83.             continue;
  84.         }
  85.         if (rcx && h >= (size_t)rcx->bottom)
  86.             break;
  87.         memcpy_s(dptr, lBmpRowPitch, sptr, lRowPitch);
  88.         sptr += resource.RowPitch;
  89.         dptr -= lBmpRowPitch;
  90.     }
  91.     context->Unmap(lDestImage, subresource);
  92.     return 1;
  93. }

之后，您可以将“buf”数据输入媒体基金会的接收器写入器。

音频捕捉

您将使用 IAudioClient 获取 IAudioCaptureClient 以在单独的线程中录制音频。

  1. void ThreadLoopCapture()
  2. {
  3.     UINT64 up, uq;
  4.     while (Capturing)
  5.     {
  6.         if (hEv)
  7.             WaitForSingleObject(hEv, INFINITE);
  8.  
  9.         if (!Capturing)
  10.             break;
  11.         auto hr = cap->GetBuffer(&pData, &framesAvailable, &flags, &up, &uq);
  12.         if (FAILED(hr))
  13.             break;
  14.         if (framesAvailable == 0)
  15.             continue;
  16.  
  17.         auto ThisAudioBytes = framesAvailable * wfx.Format.nChannels * 
  18.                                                 wfx.Format.wBitsPerSample/8 ;
  19.  
  20.         AudioDataX->PushX((const char*)pData, ThisAudioBytes);
  21.         cap->ReleaseBuffer(framesAvailable);
  22.     }
  23.     CapturingFin1 = true;
  24. }

如果录音设备是通过 loopback 的播放设备，则必须确保播放了某些内容，否则 Core Audio API 什么也不记录。 所以我们必须玩沉默：

  1. void PlaySilence(REFERENCE_TIME rt)
  2. {
  3.     // ns
  4.     rt /= 10000;
  5.     // in SR , 1000 ms
  6.     //  ?    , rt ms
  7.     auto ns = (wfx.Format.nSamplesPerSec * rt);
  8.     ns /= 1000;
  9.     while (Capturing)
  10.     {
  11.         if (!ren)
  12.             break;
  13.  
  14.         Sleep((DWORD)(rt / 2));
  15.  
  16.         if (!Capturing)
  17.             break;
  18.  
  19.         // 查看有多少可用的缓冲区空间。
  20.         UINT32 numFramesPadding = 0;
  21.         auto hr = ac2->GetCurrentPadding(&numFramesPadding);
  22.         if (FAILED(hr))
  23.             break;
  24.  
  25.         auto numFramesAvailable = ns - numFramesPadding;
  26.         if (!numFramesAvailable)
  27.             continue;
  28.  
  29.         BYTE* db = 0;
  30.         hr = ren->GetBuffer((UINT32)numFramesAvailable, &db);
  31.         if (FAILED(hr))
  32.             break;
  33.         auto bs = numFramesAvailable * wfx.Format.nChannels * wfx.Format.wBitsPerSample / 8;
  34.         memset(db, 0,(size_t) bs);
  35.         ren->ReleaseBuffer((UINT32)numFramesAvailable, 0); //AUDCLNT_BUFFERFLAGS_SILENT
  36.     }
  37.     CapturingFin2 = true;
  38. }

当有许多音频流时，您必须将它们混合在一个缓冲区中。 这是使用我自己的 REBUFFER 和 MIXBUFFER 完成的：

  1. struct REBUFFER
  2. {
  3.     std::recursive_mutex m;
  4.     std::vector<char> d;
  5.     AHANDLE Has = CreateEvent(0, TRUE, 0, 0);
  6.     MIXBUFFER<float> mb;
  7.  
  8.     void FinMix(size_t sz, float* A = 0)
  9.     {
  10.         mb.Fin(sz / sizeof(float), A);
  11.     }
  12.  
  13.     size_t PushX(const char* dd, size_t sz, float* A = 0, float V = 1.0f)
  14.     {
  15.         REBUFFERLOCK l(m);
  16.         auto s = d.size();
  17.         d.resize(s + sz);
  18.         if (dd)
  19.             memcpy(d.data() + s, dd, sz);
  20.         else
  21.             memset(d.data() + s, 0, sz);
  22.  
  23.         char* a1 = d.data();
  24.         a1 += s;
  25.         mb.Set((float*)a1);
  26.         mb.count = 1;
  27.  
  28.         SetEvent(Has);
  29.  
  30.         float* b = (float*)(d.data() + s);
  31.         if (V > 1.01f || V < 0.99f)
  32.         {
  33.             auto st = sz / sizeof(float);
  34.             for (size_t i = 0; i < st; i++)
  35.                 b[i] *= V;
  36.         }
  37.         if (A)
  38.         {
  39.             *A = Peak<float>(b, sz / sizeof(float));
  40.         }
  41.  
  42.         return s + sz;
  43.     }
  44.  
  45.     size_t Av()
  46.     {
  47.         REBUFFERLOCK l(m);
  48.         return d.size();
  49.     }
  50.  
  51.     size_t PopX(char* trg, size_t sz, DWORD wi = 0, bool NR = false)
  52.     {
  53.         if (wi)
  54.             WaitForSingleObject(Has, wi);
  55.         REBUFFERLOCK l(m);
  56.         if (sz >= d.size())
  57.             sz = d.size();
  58.         if (sz == 0)
  59.             return 0;
  60.         if (trg)
  61.             memcpy(trg, d.data(), sz);
  62.         if (NR == false)
  63.             d.erase(d.begin(), d.begin() + sz);
  64.         if (d.size() == 0)
  65.             ResetEvent(Has);
  66.         return sz;
  67.     }
  68.  
  69.     void Clear()
  70.     {
  71.         REBUFFERLOCK l(m);
  72.         d.clear();
  73.     }
  74. };

如果您有音频，则视频会与之同步。

使用库

  1. #include "stdafx.h"
  2. #include "capture.hpp"
  3. #include <iostream>
  4.  
  5. int wmain()
  6. {
  7.     CoInitializeEx(0, COINIT_APARTMENTTHREADED);
  8.     MFStartup(MF_VERSION);
  9.     std::cout << "Capturing screen for 10 seconds...";
  10.     DESKTOPCAPTUREPARAMS dp;
  11.     dp.f = L"capture.mp4";
  12.     dp.EndMS = 10000;
  13.     DesktopCapture(dp);
  14.     std::cout << "Done.\r\n";
  15.     return 0;
  16. }

DESKTOPCAPTUREPARAMS 的定义如下：

  1. struct DESKTOPCAPTUREPARAMS
  2. {
  3.     bool HasVideo = 1;
  4.     bool HasAudio = 1;
  5.     std::vector<std::tuple<std::wstring, std::vector<int>>> AudioFrom;
  6.     GUID VIDEO_ENCODING_FORMAT = MFVideoFormat_H264;
  7.     GUID AUDIO_ENCODING_FORMAT = MFAudioFormat_MP3;
  8.     std::wstring f;
  9.     void* cb = 0;
  10.     std::function<HRESULT(const BYTE* d, size_t sz,void* cb)> Streamer;
  11.     std::function<HRESULT(const BYTE* d, size_t sz,void* cb)> Framer;
  12.     std::function<void(IMFAttributes* a)> PrepareAttributes;
  13.     int fps = 25;
  14.     int NumThreads = 0;
  15.     int Qu = -1;
  16.     int vbrm = 0;
  17.     int vbrq = 0;
  18.     int BR = 4000;
  19.     int NCH = 2;
  20.     int SR = 44100;
  21.     int ABR = 192;
  22.     bool Cursor = true;
  23.     RECT rx = { 0,0,0,0 };
  24.     HWND hWnd = 0;
  25.     IDXGIAdapter1* ad = 0;
  26.     UINT nOutput = 0;
  27.  
  28.     unsigned long long StartMS = 0; // 0, none
  29.     unsigned long long EndMS = 0; // 0, none
  30.     bool MustEnd = false;
  31.     bool Pause = false;
  32. };

说明：

HasVideo = 1 -> 您正在捕捉视频。如果设置了此项，则无论您是否有音频，输出文件都必须是 MP4 或 ASF。
HasAudio = 1 -> 您正在捕获音频。如果已设置并且您没有视频，则输出文件必须是 MP3 或 FLAC。
AudioFrom = 要捕获的音频设备的向量。每个元素都是设备唯一 ID 的元组（由枚举返回，请参阅 VISTAMIXERS::EnumVistaMixers()）和您要记录的通道的向量。
该库还可以在环回中从播放设备（例如您的扬声器）进行录制。您可以指定多个录制源，库会将它们全部混合到最终的音频流中。

VIDEO_ENCODING_FORMAT -> MFVideoFormat_H264、MFVideoFormat_HEVC、MFVideoFormat_VP90、MFVideoFormat_VP80 之一。
AUDIO_ENCODING_FORMAT -> MFAudioFormat_MP3 或 MFAudioFormat_FLAC 或 MFAudioFormat_AAC 之一。 MP3 和 AAC 仅支持 44100/48000 2 通道输出。
f -> 目标文件名（MP3/FLAC 仅用于音频，MP4/ASF 其他）
fps -> 每秒帧数
NumThreads -> 视频编码器的线程，默认为 0。可以是 0-16。
Qu -> 如果 >= 0 且 <= 0，质量与速度的视频因素
vbrm 和 vbrq -> 如果为 2，则 vbrq 是介于 0 和 100 之间的质量值（BR 被忽略）
BR -> 以 KBps 为单位的视频比特率，默认 4000。如果 vbrm 为 2，则忽略 BR
NCH -> 音频输出通道
SR -> 音频输出采样率
ABR -> MP3 的音频比特率（Kbps）
Cursor -> true 捕获光标
rx -> 如果不是 {0}，则仅捕获此特定矩形
hWnd -> 如果不是 {0}，则仅捕获此 HWND。如果 HWND 为 0 且 rx = {0}，则捕获整个屏幕
ad -> 如果不是 0，则指定如果您有超过 1 个适配器，您要捕获哪个适配器
nOutput -> 要捕获的监视器的索引。 0 是第一个监视器。对于多个监视器，这指定了监视器。
EndMS -> 如果不为 0，则库在 EndMs 毫秒被捕获时停止。否则，您必须通过将“MustEnd”设置为 true 来停止库。
MustEnd -> 设置为 true 以使库停止捕获
暂停 -> 如果为真，则暂停捕获
如果要捕获到缓冲区，则必须将“f”参数留空并使用 Streamer 参数。只要您返回 S_OK，这就会调用您的回调。如果您使用 ASF 容器，则无需执行任何操作。如果您想使用 MP4 流，则必须准备流示例描述（请参阅此帖子）。您可以使用它通过 HTTP 流式传输您的桌面。

捕获帧

您可以使用“Framer”回调，而不是捕获压缩视频。 只要您返回 S_FALSE，这将返回您请求的分辨率的原始 RGBA 倒置数组。 一旦你返回 S_OK，函数就会返回。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/280534
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号