Capture-Bildschirm mit DirectX

Ist hier einige Beispiel-code auf dem Bildschirm erfassen mit DirectX 9.
Sie sollten sich nicht installieren-SDK (mit Ausnahme der standard-Dateien, die mit Visual Studio, obwohl ich es nicht getestet, VS 2010).

Einfach erstellen Sie eine einfache Win32-Konsolen-Anwendung, fügen Sie den folgenden in der stdafx.h-Datei:

  #include <Wincodec.h>             //we use WIC for saving images
  #include <d3d9.h>                 //DirectX 9 header
  #pragma comment(lib, "d3d9.lib")  //link to DirectX 9 library

Hier ist die Probe Hauptprobleme bei der Umsetzung

  int _tmain(int argc, _TCHAR* argv[])
  {
    HRESULT hr = Direct3D9TakeScreenshots(D3DADAPTER_DEFAULT, 10);
    return 0;
  }

Was wird dies tun, ist die capture 10 mal den Bildschirm, und speichern Sie "cap%ich.png" Bilder auf der Festplatte. Es zeigt auch die Zeit für diese genommen (speichern von Bildern wird nicht gezählt in dieser Zeit nur von screenshots).
Auf meinem (desktop-windows 8 - Dell Precision M2800/i7-4810MQ-2,80 GHz/Intel HD 4600, die ist ziemlich beschissen Maschine...) Maschine, dauert es 100 1920x1080 fängt in ~4sec, so um die 20/25 fps.

  HRESULT Direct3D9TakeScreenshots(UINT adapter, UINT count)
  {
    HRESULT hr = S_OK;
    IDirect3D9 *d3d = nullptr;
    IDirect3DDevice9 *device = nullptr;
    IDirect3DSurface9 *surface = nullptr;
    D3DPRESENT_PARAMETERS parameters = { 0 };
    D3DDISPLAYMODE mode;
    D3DLOCKED_RECT rc;
    UINT pitch;
    SYSTEMTIME st;
    LPBYTE *shots = nullptr;

    //init D3D and get screen size
    d3d = Direct3DCreate9(D3D_SDK_VERSION);
    HRCHECK(d3d->GetAdapterDisplayMode(adapter, &mode));

    parameters.Windowed = TRUE;
    parameters.BackBufferCount = 1;
    parameters.BackBufferHeight = mode.Height;
    parameters.BackBufferWidth = mode.Width;
    parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    parameters.hDeviceWindow = NULL;

    //create device & capture surface
    HRCHECK(d3d->CreateDevice(adapter, D3DDEVTYPE_HAL, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &parameters, &device));
    HRCHECK(device->CreateOffscreenPlainSurface(mode.Width, mode.Height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, nullptr));

    //compute the required buffer size
    HRCHECK(surface->LockRect(&rc, NULL, 0));
    pitch = rc.Pitch;
    HRCHECK(surface->UnlockRect());

    //allocate screenshots buffers
    shots = new LPBYTE[count];
    for (UINT i = 0; i < count; i++)
    {
      shots[i] = new BYTE[pitch * mode.Height];
    }

    GetSystemTime(&st); //measure the time we spend doing <count> captures
    wprintf(L"%i:%i:%i.%i\n", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    for (UINT i = 0; i < count; i++)
    {
      //get the data
      HRCHECK(device->GetFrontBufferData(0, surface));

      //copy it into our buffers
      HRCHECK(surface->LockRect(&rc, NULL, 0));
      CopyMemory(shots[i], rc.pBits, rc.Pitch * mode.Height);
      HRCHECK(surface->UnlockRect());
    }
    GetSystemTime(&st);
    wprintf(L"%i:%i:%i.%i\n", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);

    //save all screenshots
    for (UINT i = 0; i < count; i++)
    {
      WCHAR file[100];
      wsprintf(file, L"cap%i.png", i);
      HRCHECK(SavePixelsToFile32bppPBGRA(mode.Width, mode.Height, pitch, shots[i], file, GUID_ContainerFormatPng));
    }

  cleanup:
    if (shots != nullptr)
    {
      for (UINT i = 0; i < count; i++)
      {
        delete shots[i];
      }
      delete[] shots;
    }
    RELEASE(surface);
    RELEASE(device);
    RELEASE(d3d);
    return hr;
  }

Hinweis: dieser code implizit links zu WIC (imaging library im Lieferumfang von Windows für eine Weile jetzt) zum speichern der image-Dateien (so brauchen Sie nicht, die berühmten D3DXSaveSurfaceToFile, die erfordern, dass alte DirectX-SDKs installiert werden):

  HRESULT SavePixelsToFile32bppPBGRA(UINT width, UINT height, UINT stride, LPBYTE pixels, LPWSTR filePath, const GUID &format)
  {
    if (!filePath || !pixels)
      return E_INVALIDARG;

    HRESULT hr = S_OK;
    IWICImagingFactory *factory = nullptr;
    IWICBitmapEncoder *encoder = nullptr;
    IWICBitmapFrameEncode *frame = nullptr;
    IWICStream *stream = nullptr;
    GUID pf = GUID_WICPixelFormat32bppPBGRA;
    BOOL coInit = CoInitialize(nullptr);

    HRCHECK(CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&factory)));
    HRCHECK(factory->CreateStream(&stream));
    HRCHECK(stream->InitializeFromFilename(filePath, GENERIC_WRITE));
    HRCHECK(factory->CreateEncoder(format, nullptr, &encoder));
    HRCHECK(encoder->Initialize(stream, WICBitmapEncoderNoCache));
    HRCHECK(encoder->CreateNewFrame(&frame, nullptr)); //we don't use options here
    HRCHECK(frame->Initialize(nullptr)); //we dont' use any options here
    HRCHECK(frame->SetSize(width, height));
    HRCHECK(frame->SetPixelFormat(&pf));
    HRCHECK(frame->WritePixels(height, stride, stride * height, pixels));
    HRCHECK(frame->Commit());
    HRCHECK(encoder->Commit());

  cleanup:
    RELEASE(stream);
    RELEASE(frame);
    RELEASE(encoder);
    RELEASE(factory);
    if (coInit) CoUninitialize();
    return hr;
  }

Und einige Makros, die ich verwendet habe:

  #define WIDEN2(x) L ## x
  #define WIDEN(x) WIDEN2(x)
  #define __WFILE__ WIDEN(__FILE__)
  #define HRCHECK(__expr) {hr=(__expr);if(FAILED(hr)){wprintf(L"FAILURE 0x%08X (%i)\n\tline: %u file: '%s'\n\texpr: '" WIDEN(#__expr) L"'\n",hr, hr, __LINE__,__WFILE__);goto cleanup;}}
  #define RELEASE(__p) {if(__p!=nullptr){__p->Release();__p=nullptr;}}

Hinweis: für Windows 8 - + - clients, alle diese (außer WIC) sollten fallen gelassen werden zu Gunsten der Desktop-Duplikation API.

InformationsquelleAutor Simon Mourier

Können Sie die DirectX SDK von microsoft.com/en-ca/download/details.aspx?id=6812 (gepostet von @yms). Dieses SDK ist kompatibel mit allen Versionen von Windows, einschließlich XP. Finden Sie in der zugehörigen Dokumentation darüber, wie man include/link mit D3D9.

In deinem Beispiel Device ist ein IDirect3DDevice9. Jeder D3D9-Anwendung erstellen müssen, einer von Ihnen. Es ist sehr leicht zu finden, Beispiel-code auf, wie Sie einen erstellen (zB. https://msdn.microsoft.com/en-us/library/windows/desktop/bb204867%28v=vs.85%29.aspx).

In deinem Beispiel-code, nur der Inhalt gerendert wird, im DirectX-Aufnahme, die ich annehmen, ist nicht Ihre Absicht. Um den gesamten Bildschirm erfassen (die ich nehme an, das ist das Ziel), anstatt IDirect3DDevice9::GetRenderTarget verwenden, sollten Sie IDirect3DDevice9::GetFrontBufferData wie in diesem tutorial (http://dim-i.net/2008/01/29/taking-screenshots-with-directx-and-dev-cpp/). Wenn Sie auf der Suche nach Geschwindigkeit, sollten Sie nicht erstellen Sie die offscreen-Oberfläche jeden Rahmen, als in deinem Beispiel und diesem tutorial. Der Speicher-pool-sollte D3DPOOL_SYSTEMMEM in diesem Fall nicht D3DPOOL_SCRATCH. Abhängig von der Größe des Bildschirms, die wahrscheinlich Engpass sein wird, das schreiben der Bilder auf die Festplatte.

Beachten Sie auch, dass der Bildschirm erfasst haben, werden diese für den adapter verwendet um die IDirect3DDevice9. Dies ist der erste parameter IDirect3D9::CreateDevice. Dies ist nur eine Sorge, wenn die Erfassung mehrerer Monitore ist eine Möglichkeit.

InformationsquelleAutor MuertoExcobito