[d3d11] Add ID3D11VideoContext stub

src/d3d11/d3d11_context_imm.cpp

@@ -13,7 +13,8 @@ namespace dxvk {
           D3D11Device*    pParent,
     const Rc<DxvkDevice>& Device)
   : D3D11DeviceContext(pParent, Device, DxvkCsChunkFlag::SingleUse),
-    m_csThread(Device->createContext()) {
+    m_csThread(Device->createContext()),
+    m_videoContext(this) {
     EmitCs([
       cDevice          = m_device,
       cRelaxedBarriers = pParent->GetOptions()->relaxedBarriers
@@ -35,6 +36,16 @@ namespace dxvk {
   }
   
   
+  HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::QueryInterface(REFIID riid, void** ppvObject) {
+    if (riid == __uuidof(ID3D11VideoContext)) {
+      *ppvObject = ref(&m_videoContext);
+      return S_OK;
+    }
+
+    return D3D11DeviceContext::QueryInterface(riid, ppvObject);
+  }
+
+
   D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE D3D11ImmediateContext::GetType() {
     return D3D11_DEVICE_CONTEXT_IMMEDIATE;
   }

src/d3d11/d3d11_context_imm.h

@@ -6,6 +6,7 @@
 
 #include "d3d11_context.h"
 #include "d3d11_state_object.h"
+#include "d3d11_video.h"
 
 namespace dxvk {
   
@@ -21,6 +22,10 @@ namespace dxvk {
       const Rc<DxvkDevice>& Device);
     ~D3D11ImmediateContext();
     
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID  riid,
+            void**  ppvObject);
+
     D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType();
     
     UINT STDMETHODCALLTYPE GetContextFlags();
@@ -118,6 +123,7 @@ namespace dxvk {
     dxvk::high_resolution_clock::time_point m_lastFlush
       = dxvk::high_resolution_clock::now();
     
+    D3D11VideoContext            m_videoContext;
     Com<D3D11DeviceContextState> m_stateObject;
     
     HRESULT MapBuffer(

src/d3d11/d3d11_video.cpp

@@ -299,4 +299,588 @@ namespace dxvk {
     *pDesc = m_desc;
   }
 
+
+
+  D3D11VideoContext::D3D11VideoContext(
+          D3D11ImmediateContext*   pContext)
+  : m_ctx(pContext) {
+
+  }
+
+
+  D3D11VideoContext::~D3D11VideoContext() {
+
+  }
+
+
+  ULONG STDMETHODCALLTYPE D3D11VideoContext::AddRef() {
+    return m_ctx->AddRef();
+  }
+
+
+  ULONG STDMETHODCALLTYPE D3D11VideoContext::Release() {
+    return m_ctx->Release();
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::QueryInterface(
+          REFIID                  riid,
+          void**                  ppvObject) {
+    return m_ctx->QueryInterface(riid, ppvObject);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::GetPrivateData(
+          REFGUID                 Name,
+          UINT*                   pDataSize,
+          void*                   pData) {
+    return m_ctx->GetPrivateData(Name, pDataSize, pData);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::SetPrivateData(
+          REFGUID                 Name,
+          UINT                    DataSize,
+    const void*                   pData)  {
+    return m_ctx->SetPrivateData(Name, DataSize, pData);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::SetPrivateDataInterface(
+          REFGUID                 Name,
+    const IUnknown*               pUnknown) {
+    return m_ctx->SetPrivateDataInterface(Name, pUnknown);
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::GetDevice(
+          ID3D11Device**          ppDevice) {
+    return m_ctx->GetDevice(ppDevice);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::GetDecoderBuffer(
+          ID3D11VideoDecoder*             pDecoder,
+          D3D11_VIDEO_DECODER_BUFFER_TYPE Type,
+          UINT*                           BufferSize,
+          void**                          ppBuffer) {
+    Logger::err("D3D11VideoContext::GetDecoderBuffer: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::ReleaseDecoderBuffer(
+          ID3D11VideoDecoder*             pDecoder,
+          D3D11_VIDEO_DECODER_BUFFER_TYPE Type) {
+    Logger::err("D3D11VideoContext::ReleaseDecoderBuffer: Stub");
+    return E_NOTIMPL;
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::DecoderBeginFrame(
+          ID3D11VideoDecoder*             pDecoder,
+          ID3D11VideoDecoderOutputView*   pView,
+          UINT                            KeySize,
+    const void*                           pKey) {
+    Logger::err("D3D11VideoContext::DecoderBeginFrame: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::DecoderEndFrame(
+          ID3D11VideoDecoder*             pDecoder) {
+    Logger::err("D3D11VideoContext::DecoderEndFrame: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::SubmitDecoderBuffers(
+          ID3D11VideoDecoder*             pDecoder,
+          UINT                            BufferCount,
+    const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDescs) {
+    Logger::err("D3D11VideoContext::SubmitDecoderBuffers: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::DecoderExtension(
+          ID3D11VideoDecoder*             pDecoder,
+    const D3D11_VIDEO_DECODER_EXTENSION*  pExtension) {
+    Logger::err("D3D11VideoContext::DecoderExtension: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputTargetRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL                            Enable,
+    const RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputTargetRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputBackgroundColor(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL                            YCbCr,
+    const D3D11_VIDEO_COLOR*              pColor) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputBackgroundColor: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputColorSpace(
+          ID3D11VideoProcessor*           pVideoProcessor,
+    const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputColorSpace: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputAlphaFillMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE AlphaFillMode,
+          UINT                            StreamIndex) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputAlphaFillMode: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputConstriction(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL                            Enable,
+          SIZE                            Size) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputConstriction: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputStereoMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL                            Enable) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputStereoMode: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetOutputExtension(
+          ID3D11VideoProcessor*           pVideoProcessor,
+    const GUID*                           pExtensionGuid,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetOutputExtension: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamFrameFormat(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_FRAME_FORMAT        Format) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamFrameFormat: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamColorSpace(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+    const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamColorSpace: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamOutputRate(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_PROCESSOR_OUTPUT_RATE Rate,
+          BOOL                            Repeat,
+    const DXGI_RATIONAL*                  CustomRate) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamOutputRate: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamSourceRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+    const RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamSourceRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamDestRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+    const RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamDestRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamAlpha(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+          FLOAT                           Alpha) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamAlpha: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamPalette(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          UINT                            EntryCount,
+    const UINT*                           pEntries) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamPalette: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamPixelAspectRatio(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+    const DXGI_RATIONAL*                  pSrcAspectRatio,
+    const DXGI_RATIONAL*                  pDstAspectRatio) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamPixelAspectRatio: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamLumaKey(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+          FLOAT                           Lower,
+          FLOAT                           Upper) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamLumaKey: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamStereoFormat(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+          D3D11_VIDEO_PROCESSOR_STEREO_FORMAT Format,
+          BOOL                            LeftViewFrame0,
+          BOOL                            BaseViewFrame0,
+          D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode,
+          int                             MonoOffset) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamStereoFormat: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamAutoProcessingMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamAutoProcessingMode: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamFilter(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_PROCESSOR_FILTER    Filter,
+          BOOL                            Enable,
+          int                             Level) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamFilter: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamExtension(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+    const GUID*                           pExtensionGuid,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamExtension: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorSetStreamRotation(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL                            Enable,
+          D3D11_VIDEO_PROCESSOR_ROTATION  Rotation) {
+    Logger::err("D3D11VideoContext::VideoProcessorSetStreamRotation: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputTargetRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL*                           pEnabled,
+          RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputTargetRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputBackgroundColor(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL*                           pYCbCr,
+          D3D11_VIDEO_COLOR*              pColor) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputBackgroundColor: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputColorSpace(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputColorSpace: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputAlphaFillMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE* pAlphaFillMode,
+          UINT*                           pStreamIndex) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputAlphaFillMode: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputConstriction(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL*                           pEnabled,
+          SIZE*                           pSize) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputConstriction: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputStereoMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          BOOL*                           pEnabled) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputStereoMode: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetOutputExtension(
+          ID3D11VideoProcessor*           pVideoProcessor,
+    const GUID*                           pExtensionGuid,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetOutputExtension: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamFrameFormat(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_FRAME_FORMAT*       pFormat) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamFrameFormat: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamColorSpace(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamColorSpace: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamOutputRate(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_PROCESSOR_OUTPUT_RATE* pRate,
+          BOOL*                           pRepeat,
+          DXGI_RATIONAL*                  pCustomRate) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamOutputRate: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamSourceRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamSourceRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamDestRect(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          RECT*                           pRect) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamDestRect: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamAlpha(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          FLOAT*                          pAlpha) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamAlpha: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamPalette(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          UINT                            EntryCount,
+          UINT*                           pEntries) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamPalette: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamPixelAspectRatio(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          DXGI_RATIONAL*                  pSrcAspectRatio,
+          DXGI_RATIONAL*                  pDstAspectRatio) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamPixelAspectRatio: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamLumaKey(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          FLOAT*                          pLower,
+          FLOAT*                          pUpper) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamLumaKey: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamStereoFormat(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled,
+          D3D11_VIDEO_PROCESSOR_STEREO_FORMAT* pFormat,
+          BOOL*                           pLeftViewFrame0,
+          BOOL*                           pBaseViewFrame0,
+          D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE* pFlipMode,
+          int*                            pMonoOffset) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamStereoFormat: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamAutoProcessingMode(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnabled) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamAutoProcessingMode: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamFilter(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          D3D11_VIDEO_PROCESSOR_FILTER    Filter,
+          BOOL*                           pEnabled,
+          int*                            pLevel) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamFilter: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamExtension(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+    const GUID*                           pExtensionGuid,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamExtension: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorGetStreamRotation(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          UINT                            StreamIndex,
+          BOOL*                           pEnable,
+          D3D11_VIDEO_PROCESSOR_ROTATION* pRotation) {
+    Logger::err("D3D11VideoContext::VideoProcessorGetStreamRotation: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::VideoProcessorBlt(
+          ID3D11VideoProcessor*           pVideoProcessor,
+          ID3D11VideoProcessorOutputView* pOutputView,
+          UINT                            FrameIdx,
+          UINT                            StreamCount,
+    const D3D11_VIDEO_PROCESSOR_STREAM*   pStreams) {
+    Logger::err("D3D11VideoContext::VideoProcessorBlt: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::NegotiateCryptoSessionKeyExchange(
+          ID3D11CryptoSession*            pSession,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::NegotiateCryptoSessionKeyExchange: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::EncryptionBlt(
+          ID3D11CryptoSession*            pSession,
+          ID3D11Texture2D*                pSrcSurface,
+          ID3D11Texture2D*                pDstSurface,
+          UINT                            IVSize,
+          void*                           pIV) {
+    Logger::err("D3D11VideoContext::EncryptionBlt: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::DecryptionBlt(
+          ID3D11CryptoSession*            pSession,
+          ID3D11Texture2D*                pSrcSurface,
+          ID3D11Texture2D*                pDstSurface,
+          D3D11_ENCRYPTED_BLOCK_INFO*     pBlockInfo,
+          UINT                            KeySize,
+    const void*                           pKey,
+          UINT                            IVSize,
+          void*                           pIV) {
+    Logger::err("D3D11VideoContext::DecryptionBlt: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::StartSessionKeyRefresh(
+          ID3D11CryptoSession*            pSession,
+          UINT                            RandomNumberSize,
+          void*                           pRandomNumber) {
+    Logger::err("D3D11VideoContext::StartSessionKeyRefresh: Stub");
+  }
+
+
+  void STDMETHODCALLTYPE D3D11VideoContext::FinishSessionKeyRefresh(
+          ID3D11CryptoSession*            pSession) {
+    Logger::err("D3D11VideoContext::FinishSessionKeyRefresh: Stub");
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::GetEncryptionBltKey(
+          ID3D11CryptoSession*            pSession,
+          UINT                            KeySize,
+          void*                           pKey) {
+    Logger::err("D3D11VideoContext::GetEncryptionBltKey: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::NegotiateAuthenticatedChannelKeyExchange(
+          ID3D11AuthenticatedChannel*     pChannel,
+          UINT                            DataSize,
+          void*                           pData) {
+    Logger::err("D3D11VideoContext::NegotiateAuthenticatedChannelKeyExchange: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::QueryAuthenticatedChannel(
+          ID3D11AuthenticatedChannel*     pChannel,
+          UINT                            InputSize,
+    const void*                           pInput,
+          UINT                            OutputSize,
+          void*                           pOutput) {
+    Logger::err("D3D11VideoContext::QueryAuthenticatedChannel: Stub");
+    return E_NOTIMPL;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11VideoContext::ConfigureAuthenticatedChannel(
+          ID3D11AuthenticatedChannel*     pChannel,
+          UINT                            InputSize,
+    const void*                           pInput,
+          D3D11_AUTHENTICATED_CONFIGURE_OUTPUT* pOutput) {
+    Logger::err("D3D11VideoContext::ConfigureAuthenticatedChannel: Stub");
+    return E_NOTIMPL;
+  }
+
 }

src/d3d11/d3d11_video.h

@@ -146,4 +146,382 @@ namespace dxvk {
 
   };
 
+
+
+  class D3D11VideoContext : public ID3D11VideoContext {
+
+  public:
+
+    D3D11VideoContext(
+            D3D11ImmediateContext*   pContext);
+
+    ~D3D11VideoContext();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+
+    ULONG STDMETHODCALLTYPE Release();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    HRESULT STDMETHODCALLTYPE GetPrivateData(
+            REFGUID                 Name,
+            UINT*                   pDataSize,
+            void*                   pData);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateData(
+            REFGUID                 Name,
+            UINT                    DataSize,
+      const void*                   pData);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
+            REFGUID                 Name,
+      const IUnknown*               pUnknown);
+
+    void STDMETHODCALLTYPE GetDevice(
+            ID3D11Device**          ppDevice);
+
+    HRESULT STDMETHODCALLTYPE GetDecoderBuffer(
+            ID3D11VideoDecoder*             pDecoder,
+            D3D11_VIDEO_DECODER_BUFFER_TYPE Type,
+            UINT*                           BufferSize,
+            void**                          ppBuffer);
+
+    HRESULT STDMETHODCALLTYPE ReleaseDecoderBuffer(
+            ID3D11VideoDecoder*             pDecoder,
+            D3D11_VIDEO_DECODER_BUFFER_TYPE Type);
+
+    HRESULT STDMETHODCALLTYPE DecoderBeginFrame(
+            ID3D11VideoDecoder*             pDecoder,
+            ID3D11VideoDecoderOutputView*   pView,
+            UINT                            KeySize,
+      const void*                           pKey);
+
+    HRESULT STDMETHODCALLTYPE DecoderEndFrame(
+            ID3D11VideoDecoder*             pDecoder);
+
+    HRESULT STDMETHODCALLTYPE SubmitDecoderBuffers(
+            ID3D11VideoDecoder*             pDecoder,
+            UINT                            BufferCount,
+      const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDescs);
+
+    HRESULT STDMETHODCALLTYPE DecoderExtension(
+            ID3D11VideoDecoder*             pDecoder,
+      const D3D11_VIDEO_DECODER_EXTENSION*  pExtension);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputTargetRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL                            Enable,
+      const RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputBackgroundColor(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL                            YCbCr,
+      const D3D11_VIDEO_COLOR*              pColor);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputColorSpace(
+            ID3D11VideoProcessor*           pVideoProcessor,
+      const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputAlphaFillMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE AlphaFillMode,
+            UINT                            StreamIndex);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputConstriction(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL                            Enable,
+            SIZE                            Size);
+
+    void STDMETHODCALLTYPE VideoProcessorSetOutputStereoMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL                            Enable);
+
+    HRESULT STDMETHODCALLTYPE VideoProcessorSetOutputExtension(
+            ID3D11VideoProcessor*           pVideoProcessor,
+      const GUID*                           pExtensionGuid,
+            UINT                            DataSize,
+            void*                           pData);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamFrameFormat(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_FRAME_FORMAT        Format);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamColorSpace(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+      const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamOutputRate(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_PROCESSOR_OUTPUT_RATE Rate,
+            BOOL                            Repeat,
+      const DXGI_RATIONAL*                  CustomRate);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamSourceRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+      const RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamDestRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+      const RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamAlpha(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+            FLOAT                           Alpha);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamPalette(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            UINT                            EntryCount,
+      const UINT*                           pEntries);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamPixelAspectRatio(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+      const DXGI_RATIONAL*                  pSrcAspectRatio,
+      const DXGI_RATIONAL*                  pDstAspectRatio);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamLumaKey(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+            FLOAT                           Lower,
+            FLOAT                           Upper);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamStereoFormat(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+            D3D11_VIDEO_PROCESSOR_STEREO_FORMAT Format,
+            BOOL                            LeftViewFrame0,
+            BOOL                            BaseViewFrame0,
+            D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode,
+            int                             MonoOffset);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamAutoProcessingMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamFilter(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_PROCESSOR_FILTER    Filter,
+            BOOL                            Enable,
+            int                             Level);
+
+    HRESULT STDMETHODCALLTYPE VideoProcessorSetStreamExtension(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+      const GUID*                           pExtensionGuid,
+            UINT                            DataSize,
+            void*                           pData);
+
+    void STDMETHODCALLTYPE VideoProcessorSetStreamRotation(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL                            Enable,
+            D3D11_VIDEO_PROCESSOR_ROTATION  Rotation);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputTargetRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL*                           pEnabled,
+            RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputBackgroundColor(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL*                           pYCbCr,
+            D3D11_VIDEO_COLOR*              pColor);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputColorSpace(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputAlphaFillMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE* pAlphaFillMode,
+            UINT*                           pStreamIndex);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputConstriction(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL*                           pEnabled,
+            SIZE*                           pSize);
+
+    void STDMETHODCALLTYPE VideoProcessorGetOutputStereoMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            BOOL*                           pEnabled);
+
+    HRESULT STDMETHODCALLTYPE VideoProcessorGetOutputExtension(
+            ID3D11VideoProcessor*           pVideoProcessor,
+      const GUID*                           pExtensionGuid,
+            UINT                            DataSize,
+            void*                           pData);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamFrameFormat(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_FRAME_FORMAT*       pFormat);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamColorSpace(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamOutputRate(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_PROCESSOR_OUTPUT_RATE* pRate,
+            BOOL*                           pRepeat,
+            DXGI_RATIONAL*                  pCustomRate);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamSourceRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamDestRect(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            RECT*                           pRect);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamAlpha(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            FLOAT*                          pAlpha);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamPalette(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            UINT                            EntryCount,
+            UINT*                           pEntries);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamPixelAspectRatio(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            DXGI_RATIONAL*                  pSrcAspectRatio,
+            DXGI_RATIONAL*                  pDstAspectRatio);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamLumaKey(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            FLOAT*                          pLower,
+            FLOAT*                          pUpper);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamStereoFormat(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled,
+            D3D11_VIDEO_PROCESSOR_STEREO_FORMAT* pFormat,
+            BOOL*                           pLeftViewFrame0,
+            BOOL*                           pBaseViewFrame0,
+            D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE* pFlipMode,
+            int*                            pMonoOffset);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamAutoProcessingMode(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnabled);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamFilter(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            D3D11_VIDEO_PROCESSOR_FILTER    Filter,
+            BOOL*                           pEnabled,
+            int*                            pLevel);
+
+    HRESULT STDMETHODCALLTYPE VideoProcessorGetStreamExtension(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+      const GUID*                           pExtensionGuid,
+            UINT                            DataSize,
+            void*                           pData);
+
+    void STDMETHODCALLTYPE VideoProcessorGetStreamRotation(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            UINT                            StreamIndex,
+            BOOL*                           pEnable,
+            D3D11_VIDEO_PROCESSOR_ROTATION* pRotation);
+
+    HRESULT STDMETHODCALLTYPE VideoProcessorBlt(
+            ID3D11VideoProcessor*           pVideoProcessor,
+            ID3D11VideoProcessorOutputView* pOutputView,
+            UINT                            FrameIdx,
+            UINT                            StreamCount,
+      const D3D11_VIDEO_PROCESSOR_STREAM*   pStreams);
+
+    HRESULT STDMETHODCALLTYPE NegotiateCryptoSessionKeyExchange(
+            ID3D11CryptoSession*            pSession,
+            UINT                            DataSize,
+            void*                           pData);
+
+    void STDMETHODCALLTYPE EncryptionBlt(
+            ID3D11CryptoSession*            pSession,
+            ID3D11Texture2D*                pSrcSurface,
+            ID3D11Texture2D*                pDstSurface,
+            UINT                            IVSize,
+            void*                           pIV);
+
+    void STDMETHODCALLTYPE DecryptionBlt(
+            ID3D11CryptoSession*            pSession,
+            ID3D11Texture2D*                pSrcSurface,
+            ID3D11Texture2D*                pDstSurface,
+            D3D11_ENCRYPTED_BLOCK_INFO*     pBlockInfo,
+            UINT                            KeySize,
+      const void*                           pKey,
+            UINT                            IVSize,
+            void*                           pIV);
+
+    void STDMETHODCALLTYPE StartSessionKeyRefresh(
+            ID3D11CryptoSession*            pSession,
+            UINT                            RandomNumberSize,
+            void*                           pRandomNumber);
+
+    void STDMETHODCALLTYPE FinishSessionKeyRefresh(
+            ID3D11CryptoSession*            pSession);
+
+    HRESULT STDMETHODCALLTYPE GetEncryptionBltKey(
+            ID3D11CryptoSession*            pSession,
+            UINT                            KeySize,
+            void*                           pKey);
+
+    HRESULT STDMETHODCALLTYPE NegotiateAuthenticatedChannelKeyExchange(
+            ID3D11AuthenticatedChannel*     pChannel,
+            UINT                            DataSize,
+            void*                           pData);
+
+    HRESULT STDMETHODCALLTYPE QueryAuthenticatedChannel(
+            ID3D11AuthenticatedChannel*     pChannel,
+            UINT                            InputSize,
+      const void*                           pInput,
+            UINT                            OutputSize,
+            void*                           pOutput);
+
+    HRESULT STDMETHODCALLTYPE ConfigureAuthenticatedChannel(
+            ID3D11AuthenticatedChannel*     pChannel,
+            UINT                            InputSize,
+      const void*                           pInput,
+            D3D11_AUTHENTICATED_CONFIGURE_OUTPUT* pOutput);
+
+  private:
+
+      D3D11ImmediateContext* m_ctx;
+
+  };
+
 }