wf_dxgi.c

 
#include <freerdp/config.h>
 
#include "wf_interface.h"
 
#ifdef WITH_DXGI_1_2
 
#define CINTERFACE
 
#include <D3D11.h>
#include <dxgi1_2.h>
 
#include <tchar.h>
#include "wf_dxgi.h"
 
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
 
/* Driver types supported */
D3D_DRIVER_TYPE DriverTypes[] = {
  D3D_DRIVER_TYPE_HARDWARE,
  D3D_DRIVER_TYPE_WARP,
  D3D_DRIVER_TYPE_REFERENCE,
};
UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
 
/* Feature levels supported */
D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
                                    D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_1 };
 
UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
 
D3D_FEATURE_LEVEL FeatureLevel;
 
ID3D11Device* gDevice = NULL;
ID3D11DeviceContext* gContext = NULL;
IDXGIOutputDuplication* gOutputDuplication = NULL;
ID3D11Texture2D* gAcquiredDesktopImage = NULL;
 
IDXGISurface* surf;
ID3D11Texture2D* sStage;
 
DXGI_OUTDUPL_FRAME_INFO FrameInfo;
 
int wf_dxgi_init(wfInfo* wfi)
{
  gAcquiredDesktopImage = NULL;
 
  if (wf_dxgi_createDevice(wfi) != 0)
  {
    return 1;
  }
 
  if (wf_dxgi_getDuplication(wfi) != 0)
  {
    return 1;
  }
 
  return 0;
}
 
int wf_dxgi_createDevice(wfInfo* wfi)
{
  HRESULT status;
  UINT DriverTypeIndex;
 
  for (DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex)
  {
    status = D3D11CreateDevice(NULL, DriverTypes[DriverTypeIndex], NULL, 0, FeatureLevels,
                               NumFeatureLevels, D3D11_SDK_VERSION, &gDevice, &FeatureLevel,
                               &gContext);
    if (SUCCEEDED(status))
      break;
 
    WLog_INFO(TAG, "D3D11CreateDevice returned [%ld] for Driver Type %d", status,
              DriverTypes[DriverTypeIndex]);
  }
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to create device in InitializeDx");
    return 1;
  }
 
  return 0;
}
 
int wf_dxgi_getDuplication(wfInfo* wfi)
{
  HRESULT status;
  UINT dTop, i = 0;
  DXGI_OUTPUT_DESC desc = { 0 };
  IDXGIOutput* pOutput;
  IDXGIDevice* DxgiDevice = NULL;
  IDXGIAdapter* DxgiAdapter = NULL;
  IDXGIOutput* DxgiOutput = NULL;
  IDXGIOutput1* DxgiOutput1 = NULL;
 
  status = gDevice->lpVtbl->QueryInterface(gDevice, &IID_IDXGIDevice, (void**)&DxgiDevice);
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to get QI for DXGI Device");
    return 1;
  }
 
  status = DxgiDevice->lpVtbl->GetParent(DxgiDevice, &IID_IDXGIAdapter, (void**)&DxgiAdapter);
  DxgiDevice->lpVtbl->Release(DxgiDevice);
  DxgiDevice = NULL;
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to get parent DXGI Adapter");
    return 1;
  }
 
  pOutput = NULL;
 
  while (DxgiAdapter->lpVtbl->EnumOutputs(DxgiAdapter, i, &pOutput) != DXGI_ERROR_NOT_FOUND)
  {
    DXGI_OUTPUT_DESC* pDesc = &desc;
 
    status = pOutput->lpVtbl->GetDesc(pOutput, pDesc);
 
    if (FAILED(status))
    {
      WLog_ERR(TAG, "Failed to get description");
      return 1;
    }
 
    WLog_INFO(TAG, "Output %u: [%s] [%d]", i, pDesc->DeviceName, pDesc->AttachedToDesktop);
 
    if (pDesc->AttachedToDesktop)
      dTop = i;
 
    pOutput->lpVtbl->Release(pOutput);
    ++i;
  }
 
  dTop = wfi->screenID;
 
  status = DxgiAdapter->lpVtbl->EnumOutputs(DxgiAdapter, dTop, &DxgiOutput);
  DxgiAdapter->lpVtbl->Release(DxgiAdapter);
  DxgiAdapter = NULL;
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to get output");
    return 1;
  }
 
  status =
      DxgiOutput->lpVtbl->QueryInterface(DxgiOutput, &IID_IDXGIOutput1, (void**)&DxgiOutput1);
  DxgiOutput->lpVtbl->Release(DxgiOutput);
  DxgiOutput = NULL;
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to get IDXGIOutput1");
    return 1;
  }
 
  status =
      DxgiOutput1->lpVtbl->DuplicateOutput(DxgiOutput1, (IUnknown*)gDevice, &gOutputDuplication);
  DxgiOutput1->lpVtbl->Release(DxgiOutput1);
  DxgiOutput1 = NULL;
 
  if (FAILED(status))
  {
    if (status == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE)
    {
      WLog_ERR(
          TAG,
          "There is already the maximum number of applications using the Desktop Duplication "
          "API running, please close one of those applications and then try again.");
      return 1;
    }
 
    WLog_ERR(TAG, "Failed to get duplicate output. Status = %ld", status);
    return 1;
  }
 
  return 0;
}
 
int wf_dxgi_cleanup(wfInfo* wfi)
{
  if (wfi->framesWaiting > 0)
  {
    wf_dxgi_releasePixelData(wfi);
  }
 
  if (gAcquiredDesktopImage)
  {
    gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
    gAcquiredDesktopImage = NULL;
  }
 
  if (gOutputDuplication)
  {
    gOutputDuplication->lpVtbl->Release(gOutputDuplication);
    gOutputDuplication = NULL;
  }
 
  if (gContext)
  {
    gContext->lpVtbl->Release(gContext);
    gContext = NULL;
  }
 
  if (gDevice)
  {
    gDevice->lpVtbl->Release(gDevice);
    gDevice = NULL;
  }
 
  return 0;
}
 
int wf_dxgi_nextFrame(wfInfo* wfi, UINT timeout)
{
  HRESULT status = 0;
  UINT i = 0;
  UINT DataBufferSize = 0;
  BYTE* DataBuffer = NULL;
  IDXGIResource* DesktopResource = NULL;
 
  if (wfi->framesWaiting > 0)
  {
    wf_dxgi_releasePixelData(wfi);
  }
 
  if (gAcquiredDesktopImage)
  {
    gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
    gAcquiredDesktopImage = NULL;
  }
 
  status = gOutputDuplication->lpVtbl->AcquireNextFrame(gOutputDuplication, timeout, &FrameInfo,
                                                        &DesktopResource);
 
  if (status == DXGI_ERROR_WAIT_TIMEOUT)
  {
    return 1;
  }
 
  if (FAILED(status))
  {
    if (status == DXGI_ERROR_ACCESS_LOST)
    {
      WLog_ERR(TAG, "Failed to acquire next frame with status=%ld", status);
      WLog_ERR(TAG, "Trying to reinitialize due to ACCESS LOST...");
 
      if (gAcquiredDesktopImage)
      {
        gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
        gAcquiredDesktopImage = NULL;
      }
 
      if (gOutputDuplication)
      {
        gOutputDuplication->lpVtbl->Release(gOutputDuplication);
        gOutputDuplication = NULL;
      }
 
      wf_dxgi_getDuplication(wfi);
 
      return 1;
    }
    else
    {
      WLog_ERR(TAG, "Failed to acquire next frame with status=%ld", status);
      status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
 
      if (FAILED(status))
      {
        WLog_ERR(TAG, "Failed to release frame with status=%ld", status);
      }
 
      return 1;
    }
  }
 
  status = DesktopResource->lpVtbl->QueryInterface(DesktopResource, &IID_ID3D11Texture2D,
                                                   (void**)&gAcquiredDesktopImage);
  DesktopResource->lpVtbl->Release(DesktopResource);
  DesktopResource = NULL;
 
  if (FAILED(status))
  {
    return 1;
  }
 
  wfi->framesWaiting = FrameInfo.AccumulatedFrames;
 
  if (FrameInfo.AccumulatedFrames == 0)
  {
    status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
 
    if (FAILED(status))
    {
      WLog_ERR(TAG, "Failed to release frame with status=%ld", status);
    }
  }
 
  return 0;
}
 
int wf_dxgi_getPixelData(wfInfo* wfi, BYTE** data, int* pitch, RECT* invalid)
{
  HRESULT status;
  D3D11_BOX Box;
  DXGI_MAPPED_RECT mappedRect;
  D3D11_TEXTURE2D_DESC tDesc;
 
  tDesc.Width = (invalid->right - invalid->left);
  tDesc.Height = (invalid->bottom - invalid->top);
  tDesc.MipLevels = 1;
  tDesc.ArraySize = 1;
  tDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
  tDesc.SampleDesc.Count = 1;
  tDesc.SampleDesc.Quality = 0;
  tDesc.Usage = D3D11_USAGE_STAGING;
  tDesc.BindFlags = 0;
  tDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
  tDesc.MiscFlags = 0;
 
  Box.top = invalid->top;
  Box.left = invalid->left;
  Box.right = invalid->right;
  Box.bottom = invalid->bottom;
  Box.front = 0;
  Box.back = 1;
 
  status = gDevice->lpVtbl->CreateTexture2D(gDevice, &tDesc, NULL, &sStage);
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to create staging surface");
    exit(1);
    return 1;
  }
 
  gContext->lpVtbl->CopySubresourceRegion(gContext, (ID3D11Resource*)sStage, 0, 0, 0, 0,
                                          (ID3D11Resource*)gAcquiredDesktopImage, 0, &Box);
 
  status = sStage->lpVtbl->QueryInterface(sStage, &IID_IDXGISurface, (void**)&surf);
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to QI staging surface");
    exit(1);
    return 1;
  }
 
  surf->lpVtbl->Map(surf, &mappedRect, DXGI_MAP_READ);
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to map staging surface");
    exit(1);
    return 1;
  }
 
  *data = mappedRect.pBits;
  *pitch = mappedRect.Pitch;
 
  return 0;
}
 
int wf_dxgi_releasePixelData(wfInfo* wfi)
{
  HRESULT status;
 
  surf->lpVtbl->Unmap(surf);
  surf->lpVtbl->Release(surf);
  surf = NULL;
  sStage->lpVtbl->Release(sStage);
  sStage = NULL;
 
  status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
 
  if (FAILED(status))
  {
    WLog_ERR(TAG, "Failed to release frame");
    return 1;
  }
 
  wfi->framesWaiting = 0;
 
  return 0;
}
 
int wf_dxgi_getInvalidRegion(RECT* invalid)
{
  HRESULT status;
  UINT dirty;
  UINT BufSize;
  RECT* pRect;
  BYTE* DirtyRects;
  UINT DataBufferSize = 0;
  BYTE* DataBuffer = NULL;
 
  if (FrameInfo.AccumulatedFrames == 0)
  {
    return 1;
  }
 
  if (FrameInfo.TotalMetadataBufferSize)
  {
 
    if (FrameInfo.TotalMetadataBufferSize > DataBufferSize)
    {
      if (DataBuffer)
      {
        free(DataBuffer);
        DataBuffer = NULL;
      }
 
      DataBuffer = (BYTE*)malloc(FrameInfo.TotalMetadataBufferSize);
 
      if (!DataBuffer)
      {
        DataBufferSize = 0;
        WLog_ERR(TAG, "Failed to allocate memory for metadata");
        exit(1);
      }
 
      DataBufferSize = FrameInfo.TotalMetadataBufferSize;
    }
 
    BufSize = FrameInfo.TotalMetadataBufferSize;
 
    status = gOutputDuplication->lpVtbl->GetFrameMoveRects(
        gOutputDuplication, BufSize, (DXGI_OUTDUPL_MOVE_RECT*)DataBuffer, &BufSize);
 
    if (FAILED(status))
    {
      WLog_ERR(TAG, "Failed to get frame move rects");
      return 1;
    }
 
    DirtyRects = DataBuffer + BufSize;
    BufSize = FrameInfo.TotalMetadataBufferSize - BufSize;
 
    status = gOutputDuplication->lpVtbl->GetFrameDirtyRects(gOutputDuplication, BufSize,
                                                            (RECT*)DirtyRects, &BufSize);
 
    if (FAILED(status))
    {
      WLog_ERR(TAG, "Failed to get frame dirty rects");
      return 1;
    }
    dirty = BufSize / sizeof(RECT);
 
    pRect = (RECT*)DirtyRects;
 
    for (UINT i = 0; i < dirty; ++i)
    {
      UnionRect(invalid, invalid, pRect);
      ++pRect;
    }
  }
 
  return 0;
}
 
#endif