C++ Dxgi快速截屏

要实现 Dxgi 快速截屏，可以使用 Direct3D 11 的 ID3D11DeviceContext::CopyResource 函数。具体步骤如下：

1. 创建一个 ID3D11Texture2D 对象作为截屏的目标纹理，可以使用 DXGI_FORMAT_B8G8R8A8_UNORM 格式。
2. 使用 CreateDesktopDuplication 来捕捉桌面。
3. 当桌面有变化时，获取其中的一个帧，并将它存储到 ID3D11Texture2D 纹理中。
4. 使用 ID3D11DeviceContext::CopyResource 函数将纹理复制到目标纹理中。
5. 释放桌面捕捉资源。

相关问题

C++使用DXGI截图代码

以下是使用DXGI截图的示例代码：

#include <d3d11.h>
#include <dxgi1_2.h>
#include <iostream>

int main()
{
    HRESULT hr = S_OK;

    // 创建DXGI设备
    IDXGIFactory2* pFactory = nullptr;
    hr = CreateDXGIFactory2(0, IID_PPV_ARGS(&pFactory));
    if (FAILED(hr))
    {
        std::cout << "Failed to create DXGI factory." << std::endl;
        return 1;
    }

    // 枚举第一个适配器
    IDXGIAdapter1* pAdapter = nullptr;
    hr = pFactory->EnumAdapters1(0, &pAdapter);
    if (FAILED(hr))
    {
        std::cout << "Failed to enumerate adapters." << std::endl;
        return 1;
    }

    // 创建D3D11设备和设备上下文
    ID3D11Device* pDevice = nullptr;
    ID3D11DeviceContext* pContext = nullptr;
    hr = D3D11CreateDevice(pAdapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, 0, nullptr, 0,
        D3D11_SDK_VERSION, &pDevice, nullptr, &pContext);
    if (FAILED(hr))
    {
        std::cout << "Failed to create D3D11 device and context." << std::endl;
        return 1;
    }

    // 获取DXGI设备
    IDXGIDevice1* pDXGIDevice = nullptr;
    hr = pDevice->QueryInterface(__uuidof(IDXGIDevice1), (void**)&pDXGIDevice);
    if (FAILED(hr))
    {
        std::cout << "Failed to get DXGI device." << std::endl;
        return 1;
    }

    // 获取DXGI适配器
    IDXGIAdapter* pDXGIAdapter = nullptr;
    hr = pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&pDXGIAdapter);
    if (FAILED(hr))
    {
        std::cout << "Failed to get DXGI adapter." << std::endl;
        return 1;
    }

    // 获取DXGI工厂
    IDXGIFactory* pDXGIFactory = nullptr;
    hr = pDXGIAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);
    if (FAILED(hr))
    {
        std::cout << "Failed to get DXGI factory." << std::endl;
        return 1;
    }

    // 获取前缓冲表面
    IDXGISurface* pBackBufferSurface = nullptr;
    hr = pDXGIFactory->CreateSwapChain(pDXGIDevice, &swapChainDesc, &pSwapChain);
    if (FAILED(hr))
    {
        std::cout << "Failed to create swap chain." << std::endl;
        return 1;
    }
    hr = pSwapChain->GetBuffer(0, __uuidof(IDXGISurface), (void**)&pBackBufferSurface);
    if (FAILED(hr))
    {
        std::cout << "Failed to get back buffer surface." << std::endl;
        return 1;
    }

    // 保存图像到文件
    hr = SaveSurfaceToFile(pBackBufferSurface, L"Screenshot.png");
    if (FAILED(hr))
    {
        std::cout << "Failed to save screenshot to file." << std::endl;
        return 1;
    }

    // 释放资源
    pBackBufferSurface->Release();
    pSwapChain->Release();
    pDXGIFactory->Release();
    pDXGIAdapter->Release();
    pDXGIDevice->Release();
    pContext->Release();
    pDevice->Release();
    pAdapter->Release();
    pFactory->Release();

    return 0;
}

在此示例中，我们首先使用`CreateDXGIFactory2`函数创建了一个DXGI工厂对象。然后，我们使用`EnumAdapters1`函数枚举第一个适配器，并使用`D3D11CreateDevice`函数创建了一个D3D11设备和设备上下文对象。接下来，我们使用`QueryInterface`函数获取了设备对象的`IDXGIDevice1`接口，然后使用`GetParent`函数获取了适配器对象的`IDXGIAdapter`接口，最后使用`GetParent`函数获取了工厂对象的`IDXGIFactory`接口。

然后，我们使用`CreateSwapChain`函数创建了一个交换链对象，并使用`GetBuffer`函数获取了前缓冲表面对象。最后，我们使用`SaveSurfaceToFile`函数将表面对象保存为PNG图像文件。

请注意，此示例中省略了一些错误检查和释放资源的代码。在实际应用中，应该对所有函数调用返回值进行错误检查，并在程序结束时释放所有资源。

qt使用dxgi截屏保存

以下是使用Qt和DXGI进行屏幕截图并保存的示例代码：

#include <QCoreApplication>
#include <QImage>
#include <QFile>
#include <QDebug>
#include <d3d11.h>
#include <dxgi1_2.h>

// Helper function to check HRESULTs
#define CHECK_HR(hr, msg) \
    if (FAILED(hr)) { \
        qDebug() << msg << "failed with HRESULT" << hr; \
        return false; \
    }

bool saveScreenshot(const QString& filePath)
{
    HRESULT hr = S_OK;

    // Create DXGI factory
    IDXGIFactory1* pFactory = nullptr;
    hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory);
    CHECK_HR(hr, "Failed to create DXGI factory");

    // Get primary adapter
    IDXGIAdapter1* pAdapter = nullptr;
    hr = pFactory->EnumAdapters1(0, &pAdapter);
    CHECK_HR(hr, "Failed to get primary adapter");

    // Create D3D device and swap chain
    D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
    D3D_FEATURE_LEVEL featureLevels[] = { featureLevel };
    DXGI_SWAP_CHAIN_DESC swapChainDesc = { 0 };
    swapChainDesc.BufferCount = 1;
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapChainDesc.OutputWindow = GetDesktopWindow();
    swapChainDesc.SampleDesc.Count = 1;
    swapChainDesc.Windowed = TRUE;
    ID3D11Device* pDevice = nullptr;
    ID3D11DeviceContext* pContext = nullptr;
    IDXGISwapChain* pSwapChain = nullptr;
    hr = D3D11CreateDeviceAndSwapChain(pAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, 0, featureLevels, 1,
        D3D11_SDK_VERSION, &swapChainDesc, &pSwapChain, &pDevice, &featureLevel, &pContext);
    CHECK_HR(hr, "Failed to create D3D device and swap chain");

    // Get back buffer texture
    ID3D11Texture2D* pBackBuffer = nullptr;
    hr = pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
    CHECK_HR(hr, "Failed to get back buffer texture");

    // Create a CPU-readable texture
    D3D11_TEXTURE2D_DESC textureDesc = { 0 };
    textureDesc.Width = GetSystemMetrics(SM_CXSCREEN);
    textureDesc.Height = GetSystemMetrics(SM_CYSCREEN);
    textureDesc.MipLevels = 1;
    textureDesc.ArraySize = 1;
    textureDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    textureDesc.SampleDesc.Count = 1;
    textureDesc.Usage = D3D11_USAGE_STAGING;
    textureDesc.BindFlags = 0;
    textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    ID3D11Texture2D* pTexture = nullptr;
    hr = pDevice->CreateTexture2D(&textureDesc, NULL, &pTexture);
    CHECK_HR(hr, "Failed to create CPU-readable texture");

    // Copy back buffer to CPU-readable texture
    pContext->CopyResource(pTexture, pBackBuffer);

    // Read texture data
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    hr = pContext->Map(pTexture, 0, D3D11_MAP_READ, 0, &mappedResource);
    CHECK_HR(hr, "Failed to map texture");
    QImage image(mappedResource.pData, textureDesc.Width, textureDesc.Height, QImage::Format_RGB32);
    pContext->Unmap(pTexture, 0);

    // Save image to file
    if (!image.save(filePath)) {
        qDebug() << "Failed to save screenshot to" << filePath;
        return false;
    }

    // Cleanup
    pContext->Release();
    pDevice->Release();
    pSwapChain->Release();
    pAdapter->Release();
    pFactory->Release();
    pTexture->Release();
    pBackBuffer->Release();

    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    if (saveScreenshot("screenshot.png")) {
        qDebug() << "Screenshot saved to screenshot.png";
    }

    return a.exec();
}

该代码使用DXGI和D3D11 API创建设备和交换链，然后获取主适配器和后缓冲器纹理。然后，它创建一个CPU可读的纹理，将后缓冲器纹理复制到该纹理中，然后将其映射到内存中以获取图像数据。最后，它使用Qt的QImage类将图像数据保存到文件中。请注意，此代码需要使用Windows SDK和DirectX SDK来构建。