| // Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef MEDIA_BASE_WIN_D3D11_MOCKS_H_ |
| #define MEDIA_BASE_WIN_D3D11_MOCKS_H_ |
| |
| #include <d3d11_4.h> |
| #include <dxgi1_4.h> |
| #include <dxgi1_6.h> |
| #include <wrl/client.h> |
| #include <wrl/implements.h> |
| |
| #include "media/base/win/test_utils.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| namespace media { |
| |
| class D3D11Texture2DMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11Texture2D> { |
| public: |
| D3D11Texture2DMock(); |
| ~D3D11Texture2DMock() override; |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| MOCK_STDCALL_METHOD1(GetType, void(D3D11_RESOURCE_DIMENSION*)); |
| MOCK_STDCALL_METHOD1(SetEvictionPriority, void(UINT)); |
| MOCK_STDCALL_METHOD0(GetEvictionPriority, UINT()); |
| MOCK_STDCALL_METHOD1(GetDesc, void(D3D11_TEXTURE2D_DESC*)); |
| }; |
| |
| class D3D11MultithreadMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11Multithread> { |
| public: |
| D3D11MultithreadMock(); |
| ~D3D11MultithreadMock() override; |
| MOCK_STDCALL_METHOD0(Enter, void()); |
| MOCK_STDCALL_METHOD0(GetMultithreadProtected, BOOL()); |
| MOCK_STDCALL_METHOD0(Leave, void()); |
| MOCK_STDCALL_METHOD1(SetMultithreadProtected, BOOL(BOOL)); |
| }; |
| |
| class D3D11BufferMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11Buffer> { |
| public: |
| D3D11BufferMock(); |
| ~D3D11BufferMock() override; |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| MOCK_STDCALL_METHOD1(GetType, void(D3D11_RESOURCE_DIMENSION*)); |
| MOCK_STDCALL_METHOD1(SetEvictionPriority, void(UINT)); |
| MOCK_STDCALL_METHOD0(GetEvictionPriority, UINT()); |
| MOCK_STDCALL_METHOD1(GetDesc, void(D3D11_BUFFER_DESC*)); |
| }; |
| |
| // This class must mock QueryInterface, since a lot of things are |
| // QueryInterfac()ed thru this class. |
| class D3D11DeviceMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11Device5> { |
| public: |
| D3D11DeviceMock(); |
| ~D3D11DeviceMock() override; |
| |
| MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv)); |
| |
| MOCK_STDCALL_METHOD3(CreateBuffer, |
| HRESULT(const D3D11_BUFFER_DESC*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Buffer**)); |
| MOCK_STDCALL_METHOD3(CreateTexture1D, |
| HRESULT(const D3D11_TEXTURE1D_DESC*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Texture1D**)); |
| MOCK_STDCALL_METHOD3(CreateTexture2D, |
| HRESULT(const D3D11_TEXTURE2D_DESC*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Texture2D**)); |
| MOCK_STDCALL_METHOD3(CreateTexture3D, |
| HRESULT(const D3D11_TEXTURE3D_DESC*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Texture3D**)); |
| MOCK_STDCALL_METHOD3(CreateShaderResourceView, |
| HRESULT(ID3D11Resource*, |
| const D3D11_SHADER_RESOURCE_VIEW_DESC*, |
| ID3D11ShaderResourceView**)); |
| MOCK_STDCALL_METHOD3(CreateUnorderedAccessView, |
| HRESULT(ID3D11Resource*, |
| const D3D11_UNORDERED_ACCESS_VIEW_DESC*, |
| ID3D11UnorderedAccessView**)); |
| MOCK_STDCALL_METHOD3(CreateRenderTargetView, |
| HRESULT(ID3D11Resource*, |
| const D3D11_RENDER_TARGET_VIEW_DESC*, |
| ID3D11RenderTargetView**)); |
| MOCK_STDCALL_METHOD3(CreateDepthStencilView, |
| HRESULT(ID3D11Resource*, |
| const D3D11_DEPTH_STENCIL_VIEW_DESC*, |
| ID3D11DepthStencilView**)); |
| MOCK_STDCALL_METHOD5(CreateInputLayout, |
| HRESULT(const D3D11_INPUT_ELEMENT_DESC*, |
| UINT, |
| const void*, |
| SIZE_T, |
| ID3D11InputLayout**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateVertexShader, |
| HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11VertexShader**)); |
| |
| MOCK_STDCALL_METHOD4(CreateGeometryShader, |
| HRESULT(const void*, |
| SIZE_T, |
| ID3D11ClassLinkage*, |
| ID3D11GeometryShader**)); |
| |
| MOCK_STDCALL_METHOD9(CreateGeometryShaderWithStreamOutput, |
| HRESULT(const void*, |
| SIZE_T, |
| const D3D11_SO_DECLARATION_ENTRY*, |
| UINT, |
| const UINT*, |
| UINT, |
| UINT, |
| ID3D11ClassLinkage*, |
| ID3D11GeometryShader**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreatePixelShader, |
| HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11PixelShader**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateHullShader, |
| HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11HullShader**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateDomainShader, |
| HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11DomainShader**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateComputeShader, |
| HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11ComputeShader**)); |
| |
| MOCK_STDCALL_METHOD1(CreateClassLinkage, HRESULT(ID3D11ClassLinkage**)); |
| |
| MOCK_STDCALL_METHOD2(CreateBlendState, |
| HRESULT(const D3D11_BLEND_DESC*, ID3D11BlendState**)); |
| |
| MOCK_STDCALL_METHOD2(CreateDepthStencilState, |
| HRESULT(const D3D11_DEPTH_STENCIL_DESC*, |
| ID3D11DepthStencilState**)); |
| |
| MOCK_STDCALL_METHOD2(CreateRasterizerState, |
| HRESULT(const D3D11_RASTERIZER_DESC*, |
| ID3D11RasterizerState**)); |
| |
| MOCK_STDCALL_METHOD2(CreateSamplerState, |
| HRESULT(const D3D11_SAMPLER_DESC*, |
| ID3D11SamplerState**)); |
| |
| MOCK_STDCALL_METHOD2(CreateQuery, |
| HRESULT(const D3D11_QUERY_DESC*, ID3D11Query**)); |
| |
| MOCK_STDCALL_METHOD2(CreatePredicate, |
| HRESULT(const D3D11_QUERY_DESC*, ID3D11Predicate**)); |
| |
| MOCK_STDCALL_METHOD2(CreateCounter, |
| HRESULT(const D3D11_COUNTER_DESC*, ID3D11Counter**)); |
| |
| MOCK_STDCALL_METHOD2(CreateDeferredContext, |
| HRESULT(UINT, ID3D11DeviceContext**)); |
| |
| MOCK_STDCALL_METHOD3(OpenSharedResource, HRESULT(HANDLE, const IID&, void**)); |
| |
| MOCK_STDCALL_METHOD2(CheckFormatSupport, HRESULT(DXGI_FORMAT, UINT*)); |
| |
| MOCK_STDCALL_METHOD3(CheckMultisampleQualityLevels, |
| HRESULT(DXGI_FORMAT, UINT, UINT*)); |
| |
| MOCK_STDCALL_METHOD1(CheckCounterInfo, void(D3D11_COUNTER_INFO*)); |
| |
| MOCK_STDCALL_METHOD9(CheckCounter, |
| HRESULT(const D3D11_COUNTER_DESC*, |
| D3D11_COUNTER_TYPE*, |
| UINT*, |
| LPSTR, |
| UINT*, |
| LPSTR, |
| UINT*, |
| LPSTR, |
| UINT*)); |
| |
| MOCK_STDCALL_METHOD3(CheckFeatureSupport, |
| HRESULT(D3D11_FEATURE, void*, UINT)); |
| |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| |
| MOCK_STDCALL_METHOD0(GetFeatureLevel, D3D_FEATURE_LEVEL()); |
| |
| MOCK_STDCALL_METHOD0(GetCreationFlags, UINT()); |
| |
| MOCK_STDCALL_METHOD0(GetDeviceRemovedReason, HRESULT()); |
| |
| MOCK_STDCALL_METHOD1(GetImmediateContext, void(ID3D11DeviceContext**)); |
| |
| MOCK_STDCALL_METHOD1(SetExceptionMode, HRESULT(UINT)); |
| |
| MOCK_STDCALL_METHOD0(GetExceptionMode, UINT()); |
| |
| // ID3D11Device1 |
| MOCK_STDCALL_METHOD1(GetImmediateContext1, void(ID3D11DeviceContext1**)); |
| |
| MOCK_STDCALL_METHOD2(CreateDeferredContext1, |
| HRESULT(UINT, ID3D11DeviceContext1**)); |
| |
| MOCK_STDCALL_METHOD2(CreateBlendState1, |
| HRESULT(const D3D11_BLEND_DESC1*, ID3D11BlendState1**)); |
| |
| MOCK_STDCALL_METHOD2(CreateRasterizerState1, |
| HRESULT(const D3D11_RASTERIZER_DESC1*, |
| ID3D11RasterizerState1**)); |
| |
| MOCK_STDCALL_METHOD7(CreateDeviceContextState, |
| HRESULT(UINT, |
| const D3D_FEATURE_LEVEL*, |
| UINT, |
| UINT, |
| REFIID, |
| D3D_FEATURE_LEVEL*, |
| ID3DDeviceContextState**)); |
| |
| MOCK_STDCALL_METHOD3(OpenSharedResource1, HRESULT(HANDLE, REFIID, void**)); |
| |
| MOCK_STDCALL_METHOD4(OpenSharedResourceByName, |
| HRESULT(LPCWSTR, DWORD, REFIID, void**)); |
| |
| // ID3D11Device2 |
| MOCK_STDCALL_METHOD4(CheckMultisampleQualityLevels1, |
| HRESULT(DXGI_FORMAT, UINT, UINT, UINT*)); |
| |
| MOCK_STDCALL_METHOD2(CreateDeferredContext2, |
| HRESULT(UINT, ID3D11DeviceContext2**)); |
| |
| MOCK_STDCALL_METHOD1(GetImmediateContext2, void(ID3D11DeviceContext2**)); |
| |
| MOCK_STDCALL_METHOD7(GetResourceTiling, |
| void(ID3D11Resource*, |
| UINT*, |
| D3D11_PACKED_MIP_DESC*, |
| D3D11_TILE_SHAPE*, |
| UINT*, |
| UINT, |
| D3D11_SUBRESOURCE_TILING*)); |
| |
| // ID3D11Device3 |
| MOCK_STDCALL_METHOD3(CreateTexture2D1, |
| HRESULT(const D3D11_TEXTURE2D_DESC1*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Texture2D1**)); |
| |
| MOCK_STDCALL_METHOD3(CreateTexture3D1, |
| HRESULT(const D3D11_TEXTURE3D_DESC1*, |
| const D3D11_SUBRESOURCE_DATA*, |
| ID3D11Texture3D1**)); |
| |
| MOCK_STDCALL_METHOD2(CreateRasterizerState2, |
| HRESULT(const D3D11_RASTERIZER_DESC2*, |
| ID3D11RasterizerState2**)); |
| |
| MOCK_STDCALL_METHOD3(CreateShaderResourceView1, |
| HRESULT(ID3D11Resource*, |
| const D3D11_SHADER_RESOURCE_VIEW_DESC1*, |
| ID3D11ShaderResourceView1**)); |
| |
| MOCK_STDCALL_METHOD3(CreateUnorderedAccessView1, |
| HRESULT(ID3D11Resource*, |
| const D3D11_UNORDERED_ACCESS_VIEW_DESC1*, |
| ID3D11UnorderedAccessView1**)); |
| |
| MOCK_STDCALL_METHOD3(CreateRenderTargetView1, |
| HRESULT(ID3D11Resource*, |
| const D3D11_RENDER_TARGET_VIEW_DESC1*, |
| ID3D11RenderTargetView1**)); |
| |
| MOCK_STDCALL_METHOD2(CreateQuery1, |
| HRESULT(const D3D11_QUERY_DESC1*, ID3D11Query1**)); |
| |
| MOCK_STDCALL_METHOD1(GetImmediateContext3, void(ID3D11DeviceContext3**)); |
| |
| MOCK_STDCALL_METHOD2(CreateDeferredContext3, |
| HRESULT(UINT, ID3D11DeviceContext3**)); |
| |
| MOCK_STDCALL_METHOD6( |
| WriteToSubresource, |
| void(ID3D11Resource*, UINT, const D3D11_BOX*, const void*, UINT, UINT)); |
| |
| MOCK_STDCALL_METHOD6( |
| ReadFromSubresource, |
| void(void*, UINT, UINT, ID3D11Resource*, UINT, const D3D11_BOX*)); |
| |
| // ID3D11Device4 |
| MOCK_STDCALL_METHOD2(RegisterDeviceRemovedEvent, HRESULT(HANDLE, DWORD*)); |
| |
| MOCK_STDCALL_METHOD1(UnregisterDeviceRemoved, void(DWORD)); |
| |
| // ID3D11Device5 |
| MOCK_STDCALL_METHOD3(OpenSharedFence, HRESULT(HANDLE, REFIID, void**)); |
| |
| MOCK_STDCALL_METHOD4(CreateFence, |
| HRESULT(UINT64, D3D11_FENCE_FLAG, REFIID, void**)); |
| }; |
| |
| class DXGIFactoryMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| IDXGIFactory> { |
| public: |
| DXGIFactoryMock(); |
| ~DXGIFactoryMock() override; |
| MOCK_STDCALL_METHOD2(CreateSoftwareAdapter, HRESULT(HMODULE, IDXGIAdapter**)); |
| MOCK_STDCALL_METHOD3(CreateSwapChain, |
| HRESULT(IUnknown*, |
| DXGI_SWAP_CHAIN_DESC*, |
| IDXGISwapChain**)); |
| MOCK_STDCALL_METHOD2(EnumAdapters, HRESULT(UINT, IDXGIAdapter**)); |
| MOCK_STDCALL_METHOD1(GetWindowAssociation, HRESULT(HWND*)); |
| MOCK_STDCALL_METHOD2(MakeWindowAssociation, HRESULT(HWND, UINT)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID, const IUnknown*)); |
| MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*)); |
| }; |
| |
| class DXGIDeviceMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| IDXGIDevice> { |
| public: |
| DXGIDeviceMock(); |
| ~DXGIDeviceMock() override; |
| |
| MOCK_STDCALL_METHOD5(CreateSurface, |
| HRESULT(const DXGI_SURFACE_DESC*, |
| UINT, |
| DXGI_USAGE, |
| const DXGI_SHARED_RESOURCE*, |
| IDXGISurface**)); |
| MOCK_STDCALL_METHOD1(GetAdapter, HRESULT(IDXGIAdapter**)); |
| MOCK_STDCALL_METHOD1(GetGPUThreadPriority, HRESULT(INT*)); |
| MOCK_STDCALL_METHOD3(QueryResourceResidency, |
| HRESULT(IUnknown* const*, DXGI_RESIDENCY*, UINT)); |
| MOCK_STDCALL_METHOD1(SetGPUThreadPriority, HRESULT(INT)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID, const IUnknown*)); |
| MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*)); |
| }; |
| |
| class DXGIAdapterMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| IDXGIAdapter> { |
| public: |
| DXGIAdapterMock(); |
| ~DXGIAdapterMock() override; |
| |
| MOCK_STDCALL_METHOD3(QueryVideoMemoryInfo, |
| HRESULT(UINT, |
| DXGI_MEMORY_SEGMENT_GROUP, |
| DXGI_QUERY_VIDEO_MEMORY_INFO*)); |
| MOCK_STDCALL_METHOD2(RegisterHardwareContentProtectionTeardownStatusEvent, |
| HRESULT(HANDLE, DWORD*)); |
| MOCK_STDCALL_METHOD2(RegisterVideoMemoryBudgetChangeNotificationEvent, |
| HRESULT(HANDLE, DWORD*)); |
| MOCK_STDCALL_METHOD3(SetVideoMemoryReservation, |
| HRESULT(UINT, DXGI_MEMORY_SEGMENT_GROUP, UINT64)); |
| MOCK_STDCALL_METHOD1(UnregisterHardwareContentProtectionTeardownStatus, |
| void(DWORD)); |
| MOCK_STDCALL_METHOD1(UnregisterVideoMemoryBudgetChangeNotification, |
| void(DWORD)); |
| MOCK_STDCALL_METHOD1(GetDesc2, HRESULT(DXGI_ADAPTER_DESC2*)); |
| MOCK_STDCALL_METHOD1(GetDesc1, HRESULT(DXGI_ADAPTER_DESC1*)); |
| MOCK_STDCALL_METHOD2(CheckInterfaceSupport, HRESULT(REFGUID, LARGE_INTEGER*)); |
| MOCK_STDCALL_METHOD2(EnumOutputs, HRESULT(UINT, IDXGIOutput**)); |
| MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_ADAPTER_DESC*)); |
| MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID, const IUnknown*)); |
| }; |
| |
| class DXGIOutputMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| IDXGIOutput> { |
| public: |
| DXGIOutputMock(); |
| ~DXGIOutputMock() override; |
| MOCK_STDCALL_METHOD3(FindClosestMatchingMode, |
| HRESULT(const DXGI_MODE_DESC*, |
| DXGI_MODE_DESC*, |
| IUnknown*)); |
| MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_OUTPUT_DESC*)); |
| MOCK_STDCALL_METHOD4(GetDisplayModeList, |
| HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC*)); |
| MOCK_STDCALL_METHOD1(GetDisplaySurfaceData, HRESULT(IDXGISurface*)); |
| MOCK_STDCALL_METHOD1(GetFrameStatistics, HRESULT(DXGI_FRAME_STATISTICS*)); |
| MOCK_STDCALL_METHOD1(GetGammaControl, HRESULT(DXGI_GAMMA_CONTROL*)); |
| MOCK_STDCALL_METHOD1(GetGammaControlCapabilities, |
| HRESULT(DXGI_GAMMA_CONTROL_CAPABILITIES*)); |
| MOCK_STDCALL_METHOD0(ReleaseOwnership, void()); |
| MOCK_STDCALL_METHOD1(SetDisplaySurface, HRESULT(IDXGISurface*)); |
| MOCK_STDCALL_METHOD1(SetGammaControl, HRESULT(const DXGI_GAMMA_CONTROL*)); |
| MOCK_STDCALL_METHOD2(TakeOwnership, HRESULT(IUnknown*, BOOL)); |
| MOCK_STDCALL_METHOD0(WaitForVBlank, HRESULT()); |
| |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID, const IUnknown*)); |
| MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*)); |
| |
| // IUnknown |
| MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv)); |
| }; |
| |
| class DXGIOutput6Mock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| IDXGIOutput6> { |
| public: |
| DXGIOutput6Mock(); |
| ~DXGIOutput6Mock() override; |
| |
| // IDXGIOutput6 |
| MOCK_STDCALL_METHOD1(GetDesc1, HRESULT(DXGI_OUTPUT_DESC1*)); |
| MOCK_STDCALL_METHOD1(CheckHardwareCompositionSupport, HRESULT(UINT*)); |
| |
| // IDXGIOutput5 |
| MOCK_STDCALL_METHOD5(DuplicateOutput1, |
| HRESULT(IUnknown*, |
| UINT, |
| UINT, |
| const DXGI_FORMAT*, |
| IDXGIOutputDuplication**)); |
| |
| // IDXGIOutput4 |
| MOCK_STDCALL_METHOD4( |
| CheckOverlayColorSpaceSupport, |
| HRESULT(DXGI_FORMAT, DXGI_COLOR_SPACE_TYPE, IUnknown*, UINT*)); |
| |
| // IDXGIOutput3 |
| MOCK_STDCALL_METHOD3(CheckOverlaySupport, |
| HRESULT(DXGI_FORMAT, IUnknown*, UINT*)); |
| |
| // IDXGIOutput2 |
| MOCK_STDCALL_METHOD0(SupportsOverlays, BOOL()); |
| |
| // IDXGIOutput1 |
| MOCK_STDCALL_METHOD2(DuplicateOutput, |
| HRESULT(IUnknown*, IDXGIOutputDuplication**)); |
| MOCK_STDCALL_METHOD3(FindClosestMatchingMode1, |
| HRESULT(const DXGI_MODE_DESC1*, |
| DXGI_MODE_DESC1*, |
| IUnknown*)); |
| MOCK_STDCALL_METHOD4(GetDisplayModeList1, |
| HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC1*)); |
| MOCK_STDCALL_METHOD1(GetDisplaySurfaceData1, HRESULT(IDXGIResource*)); |
| |
| // IDXGIOutput |
| MOCK_STDCALL_METHOD3(FindClosestMatchingMode, |
| HRESULT(const DXGI_MODE_DESC*, |
| DXGI_MODE_DESC*, |
| IUnknown*)); |
| MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_OUTPUT_DESC*)); |
| MOCK_STDCALL_METHOD4(GetDisplayModeList, |
| HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC*)); |
| MOCK_STDCALL_METHOD1(GetDisplaySurfaceData, HRESULT(IDXGISurface*)); |
| MOCK_STDCALL_METHOD1(GetFrameStatistics, HRESULT(DXGI_FRAME_STATISTICS*)); |
| MOCK_STDCALL_METHOD1(GetGammaControl, HRESULT(DXGI_GAMMA_CONTROL*)); |
| MOCK_STDCALL_METHOD1(GetGammaControlCapabilities, |
| HRESULT(DXGI_GAMMA_CONTROL_CAPABILITIES*)); |
| MOCK_STDCALL_METHOD0(ReleaseOwnership, void()); |
| MOCK_STDCALL_METHOD1(SetDisplaySurface, HRESULT(IDXGISurface*)); |
| MOCK_STDCALL_METHOD1(SetGammaControl, HRESULT(const DXGI_GAMMA_CONTROL*)); |
| MOCK_STDCALL_METHOD2(TakeOwnership, HRESULT(IUnknown*, BOOL)); |
| MOCK_STDCALL_METHOD0(WaitForVBlank, HRESULT()); |
| |
| // IDXGIObject |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID, const IUnknown*)); |
| MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*)); |
| }; |
| |
| class D3D11VideoDeviceMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11VideoDevice> { |
| public: |
| D3D11VideoDeviceMock(); |
| ~D3D11VideoDeviceMock() override; |
| MOCK_STDCALL_METHOD3(CreateVideoDecoder, |
| HRESULT(const D3D11_VIDEO_DECODER_DESC*, |
| const D3D11_VIDEO_DECODER_CONFIG*, |
| ID3D11VideoDecoder**)); |
| |
| MOCK_STDCALL_METHOD3(CreateVideoProcessor, |
| HRESULT(ID3D11VideoProcessorEnumerator*, |
| UINT, |
| ID3D11VideoProcessor**)); |
| |
| MOCK_STDCALL_METHOD2(CreateAuthenticatedChannel, |
| HRESULT(D3D11_AUTHENTICATED_CHANNEL_TYPE, |
| ID3D11AuthenticatedChannel**)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateCryptoSession, |
| HRESULT(const GUID*, const GUID*, const GUID*, ID3D11CryptoSession**)); |
| |
| MOCK_STDCALL_METHOD3(CreateVideoDecoderOutputView, |
| HRESULT(ID3D11Resource*, |
| const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC*, |
| ID3D11VideoDecoderOutputView**)); |
| |
| MOCK_STDCALL_METHOD4(CreateVideoProcessorInputView, |
| HRESULT(ID3D11Resource*, |
| ID3D11VideoProcessorEnumerator*, |
| const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC*, |
| ID3D11VideoProcessorInputView**)); |
| |
| MOCK_STDCALL_METHOD4(CreateVideoProcessorOutputView, |
| HRESULT(ID3D11Resource*, |
| ID3D11VideoProcessorEnumerator*, |
| const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC*, |
| ID3D11VideoProcessorOutputView**)); |
| |
| MOCK_STDCALL_METHOD2(CreateVideoProcessorEnumerator, |
| HRESULT(const D3D11_VIDEO_PROCESSOR_CONTENT_DESC*, |
| ID3D11VideoProcessorEnumerator**)); |
| |
| MOCK_STDCALL_METHOD0(GetVideoDecoderProfileCount, UINT()); |
| |
| MOCK_STDCALL_METHOD2(GetVideoDecoderProfile, HRESULT(UINT, GUID*)); |
| |
| MOCK_STDCALL_METHOD3(CheckVideoDecoderFormat, |
| HRESULT(const GUID*, DXGI_FORMAT, BOOL*)); |
| MOCK_STDCALL_METHOD2(GetVideoDecoderConfigCount, |
| HRESULT(const D3D11_VIDEO_DECODER_DESC*, UINT*)); |
| |
| MOCK_STDCALL_METHOD3(GetVideoDecoderConfig, |
| HRESULT(const D3D11_VIDEO_DECODER_DESC*, |
| UINT, |
| D3D11_VIDEO_DECODER_CONFIG*)); |
| |
| MOCK_STDCALL_METHOD3(GetContentProtectionCaps, |
| HRESULT(const GUID*, |
| const GUID*, |
| D3D11_VIDEO_CONTENT_PROTECTION_CAPS*)); |
| MOCK_STDCALL_METHOD4(CheckCryptoKeyExchange, |
| HRESULT(const GUID*, const GUID*, UINT, GUID*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| }; |
| |
| class D3D11VideoProcessorEnumeratorMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11VideoProcessorEnumerator> { |
| public: |
| D3D11VideoProcessorEnumeratorMock(); |
| ~D3D11VideoProcessorEnumeratorMock() override; |
| |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| |
| MOCK_STDCALL_METHOD2(GetVideoProcessorRateConversionCaps, |
| HRESULT(UINT, |
| D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS*)); |
| |
| MOCK_STDCALL_METHOD2(GetVideoProcessorFilterRange, |
| HRESULT(D3D11_VIDEO_PROCESSOR_FILTER, |
| D3D11_VIDEO_PROCESSOR_FILTER_RANGE*)); |
| |
| MOCK_STDCALL_METHOD3(GetVideoProcessorCustomRate, |
| HRESULT(UINT, UINT, D3D11_VIDEO_PROCESSOR_CUSTOM_RATE*)); |
| |
| MOCK_STDCALL_METHOD1(GetVideoProcessorContentDesc, |
| HRESULT(D3D11_VIDEO_PROCESSOR_CONTENT_DESC*)); |
| |
| MOCK_STDCALL_METHOD1(GetVideoProcessorCaps, |
| HRESULT(D3D11_VIDEO_PROCESSOR_CAPS*)); |
| |
| MOCK_STDCALL_METHOD2(CheckVideoProcessorFormat, HRESULT(DXGI_FORMAT, UINT*)); |
| }; |
| |
| class D3D11VideoProcessorMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11VideoProcessor> { |
| public: |
| D3D11VideoProcessorMock(); |
| ~D3D11VideoProcessorMock() override; |
| |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| |
| MOCK_STDCALL_METHOD1(GetContentDesc, |
| void(D3D11_VIDEO_PROCESSOR_CONTENT_DESC*)); |
| |
| MOCK_STDCALL_METHOD1(GetRateConversionCaps, |
| void(D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS*)); |
| }; |
| |
| class D3D11VideoContextMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11VideoContext> { |
| public: |
| D3D11VideoContextMock(); |
| ~D3D11VideoContextMock() override; |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| MOCK_STDCALL_METHOD4(GetDecoderBuffer, |
| HRESULT(ID3D11VideoDecoder*, |
| D3D11_VIDEO_DECODER_BUFFER_TYPE, |
| UINT*, |
| void**)); |
| MOCK_STDCALL_METHOD2(ReleaseDecoderBuffer, |
| HRESULT(ID3D11VideoDecoder*, |
| D3D11_VIDEO_DECODER_BUFFER_TYPE)); |
| MOCK_STDCALL_METHOD4(DecoderBeginFrame, |
| HRESULT(ID3D11VideoDecoder*, |
| ID3D11VideoDecoderOutputView*, |
| UINT, |
| const void*)); |
| MOCK_STDCALL_METHOD1(DecoderEndFrame, HRESULT(ID3D11VideoDecoder*)); |
| MOCK_STDCALL_METHOD3(SubmitDecoderBuffers, |
| HRESULT(ID3D11VideoDecoder*, |
| UINT, |
| const D3D11_VIDEO_DECODER_BUFFER_DESC*)); |
| MOCK_STDCALL_METHOD2( |
| DecoderExtension, |
| APP_DEPRECATED_HRESULT(ID3D11VideoDecoder*, |
| const D3D11_VIDEO_DECODER_EXTENSION*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetOutputTargetRect, |
| void(ID3D11VideoProcessor*, BOOL, const RECT*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetOutputBackgroundColor, |
| void(ID3D11VideoProcessor*, |
| BOOL, |
| const D3D11_VIDEO_COLOR*)); |
| MOCK_STDCALL_METHOD2(VideoProcessorSetOutputColorSpace, |
| void(ID3D11VideoProcessor*, |
| const D3D11_VIDEO_PROCESSOR_COLOR_SPACE*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetOutputAlphaFillMode, |
| void(ID3D11VideoProcessor*, |
| D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE, |
| UINT)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetOutputConstriction, |
| void(ID3D11VideoProcessor*, BOOL, SIZE)); |
| MOCK_STDCALL_METHOD2(VideoProcessorSetOutputStereoMode, |
| void(ID3D11VideoProcessor*, BOOL)); |
| MOCK_STDCALL_METHOD4( |
| VideoProcessorSetOutputExtension, |
| APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, const GUID*, UINT, void*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetOutputTargetRect, |
| void(ID3D11VideoProcessor*, BOOL*, RECT*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetOutputBackgroundColor, |
| void(ID3D11VideoProcessor*, BOOL*, D3D11_VIDEO_COLOR*)); |
| MOCK_STDCALL_METHOD2(VideoProcessorGetOutputColorSpace, |
| void(ID3D11VideoProcessor*, |
| D3D11_VIDEO_PROCESSOR_COLOR_SPACE*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetOutputAlphaFillMode, |
| void(ID3D11VideoProcessor*, |
| D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE*, |
| UINT*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetOutputConstriction, |
| void(ID3D11VideoProcessor*, BOOL*, SIZE*)); |
| MOCK_STDCALL_METHOD2(VideoProcessorGetOutputStereoMode, |
| void(ID3D11VideoProcessor*, BOOL*)); |
| MOCK_STDCALL_METHOD4( |
| VideoProcessorGetOutputExtension, |
| APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, const GUID*, UINT, void*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetStreamFrameFormat, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_FRAME_FORMAT)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetStreamColorSpace, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| const D3D11_VIDEO_PROCESSOR_COLOR_SPACE*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorSetStreamOutputRate, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_PROCESSOR_OUTPUT_RATE, |
| BOOL, |
| const DXGI_RATIONAL*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorSetStreamSourceRect, |
| void(ID3D11VideoProcessor*, UINT, BOOL, const RECT*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorSetStreamDestRect, |
| void(ID3D11VideoProcessor*, UINT, BOOL, const RECT*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorSetStreamAlpha, |
| void(ID3D11VideoProcessor*, UINT, BOOL, FLOAT)); |
| MOCK_STDCALL_METHOD4(VideoProcessorSetStreamPalette, |
| void(ID3D11VideoProcessor*, UINT, UINT, const UINT*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorSetStreamPixelAspectRatio, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| BOOL, |
| const DXGI_RATIONAL*, |
| const DXGI_RATIONAL*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorSetStreamLumaKey, |
| void(ID3D11VideoProcessor*, UINT, BOOL, FLOAT, FLOAT)); |
| MOCK_STDCALL_METHOD8(VideoProcessorSetStreamStereoFormat, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| BOOL, |
| D3D11_VIDEO_PROCESSOR_STEREO_FORMAT, |
| BOOL, |
| BOOL, |
| D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE, |
| int)); |
| MOCK_STDCALL_METHOD3(VideoProcessorSetStreamAutoProcessingMode, |
| void(ID3D11VideoProcessor*, UINT, BOOL)); |
| MOCK_STDCALL_METHOD5(VideoProcessorSetStreamFilter, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_PROCESSOR_FILTER, |
| BOOL, |
| int)); |
| MOCK_STDCALL_METHOD5(VideoProcessorSetStreamExtension, |
| APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, |
| UINT, |
| const GUID*, |
| UINT, |
| void*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetStreamFrameFormat, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_FRAME_FORMAT*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetStreamColorSpace, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_PROCESSOR_COLOR_SPACE*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorGetStreamOutputRate, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_PROCESSOR_OUTPUT_RATE*, |
| BOOL*, |
| DXGI_RATIONAL*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorGetStreamSourceRect, |
| void(ID3D11VideoProcessor*, UINT, BOOL*, RECT*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorGetStreamDestRect, |
| void(ID3D11VideoProcessor*, UINT, BOOL*, RECT*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorGetStreamAlpha, |
| void(ID3D11VideoProcessor*, UINT, BOOL*, FLOAT*)); |
| MOCK_STDCALL_METHOD4(VideoProcessorGetStreamPalette, |
| void(ID3D11VideoProcessor*, UINT, UINT, UINT*)); |
| MOCK_STDCALL_METHOD5( |
| VideoProcessorGetStreamPixelAspectRatio, |
| void(ID3D11VideoProcessor*, UINT, BOOL*, DXGI_RATIONAL*, DXGI_RATIONAL*)); |
| MOCK_STDCALL_METHOD5( |
| VideoProcessorGetStreamLumaKey, |
| void(ID3D11VideoProcessor*, UINT, BOOL*, FLOAT*, FLOAT*)); |
| MOCK_STDCALL_METHOD8(VideoProcessorGetStreamStereoFormat, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| BOOL*, |
| D3D11_VIDEO_PROCESSOR_STEREO_FORMAT*, |
| BOOL*, |
| BOOL*, |
| D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE*, |
| int*)); |
| MOCK_STDCALL_METHOD3(VideoProcessorGetStreamAutoProcessingMode, |
| void(ID3D11VideoProcessor*, UINT, BOOL*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorGetStreamFilter, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| D3D11_VIDEO_PROCESSOR_FILTER, |
| BOOL*, |
| int*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorGetStreamExtension, |
| APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, |
| UINT, |
| const GUID*, |
| UINT, |
| void*)); |
| MOCK_STDCALL_METHOD5(VideoProcessorBlt, |
| HRESULT(ID3D11VideoProcessor*, |
| ID3D11VideoProcessorOutputView*, |
| UINT, |
| UINT, |
| const D3D11_VIDEO_PROCESSOR_STREAM*)); |
| MOCK_STDCALL_METHOD3(NegotiateCryptoSessionKeyExchange, |
| HRESULT(ID3D11CryptoSession*, UINT, void*)); |
| MOCK_STDCALL_METHOD5(EncryptionBlt, |
| void(ID3D11CryptoSession*, |
| ID3D11Texture2D*, |
| ID3D11Texture2D*, |
| UINT, |
| void*)); |
| MOCK_STDCALL_METHOD8(DecryptionBlt, |
| void(ID3D11CryptoSession*, |
| ID3D11Texture2D*, |
| ID3D11Texture2D*, |
| D3D11_ENCRYPTED_BLOCK_INFO*, |
| UINT, |
| const void*, |
| UINT, |
| void*)); |
| MOCK_STDCALL_METHOD3(StartSessionKeyRefresh, |
| void(ID3D11CryptoSession*, UINT, void*)); |
| MOCK_STDCALL_METHOD1(FinishSessionKeyRefresh, void(ID3D11CryptoSession*)); |
| MOCK_STDCALL_METHOD3(GetEncryptionBltKey, |
| HRESULT(ID3D11CryptoSession*, UINT, void*)); |
| MOCK_STDCALL_METHOD3(NegotiateAuthenticatedChannelKeyExchange, |
| HRESULT(ID3D11AuthenticatedChannel*, UINT, void*)); |
| MOCK_STDCALL_METHOD5( |
| QueryAuthenticatedChannel, |
| HRESULT(ID3D11AuthenticatedChannel*, UINT, const void*, UINT, void*)); |
| MOCK_STDCALL_METHOD4(ConfigureAuthenticatedChannel, |
| HRESULT(ID3D11AuthenticatedChannel*, |
| UINT, |
| const void*, |
| D3D11_AUTHENTICATED_CONFIGURE_OUTPUT*)); |
| MOCK_STDCALL_METHOD4( |
| VideoProcessorSetStreamRotation, |
| void(ID3D11VideoProcessor*, UINT, BOOL, D3D11_VIDEO_PROCESSOR_ROTATION)); |
| MOCK_STDCALL_METHOD4(VideoProcessorGetStreamRotation, |
| void(ID3D11VideoProcessor*, |
| UINT, |
| BOOL*, |
| D3D11_VIDEO_PROCESSOR_ROTATION*)); |
| }; |
| |
| class D3D11VideoDecoderMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11VideoDecoder> { |
| public: |
| D3D11VideoDecoderMock(); |
| ~D3D11VideoDecoderMock() override; |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| MOCK_STDCALL_METHOD2(GetCreationParameters, |
| HRESULT(D3D11_VIDEO_DECODER_DESC*, |
| D3D11_VIDEO_DECODER_CONFIG*)); |
| MOCK_STDCALL_METHOD1(GetDriverHandle, HRESULT(HANDLE*)); |
| }; |
| |
| // This classs must mock QueryInterface, since a lot of things are |
| // QueryInterfac()ed thru this class. |
| class D3D11DeviceContextMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11DeviceContext4> { |
| public: |
| D3D11DeviceContextMock(); |
| ~D3D11DeviceContextMock() override; |
| |
| MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv)); |
| |
| // ID3D11DevieChild methods. |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device** ppDevice)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, |
| HRESULT(REFGUID guid, UINT* pDataSize, void* pData)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, |
| HRESULT(REFGUID guid, UINT DataSize, const void* pData)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(REFGUID guid, const IUnknown* pData)); |
| |
| // ID3D11DeviceContext methods. |
| MOCK_STDCALL_METHOD3(VSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3( |
| PSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(PSSetShader, |
| void(ID3D11PixelShader* pPixelShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(PSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(VSSetShader, |
| void(ID3D11VertexShader* pVertexShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(DrawIndexed, |
| void(UINT IndexCount, |
| UINT StartIndexLocation, |
| INT BaseVertexLocation)); |
| |
| MOCK_STDCALL_METHOD2(Draw, void(UINT VertexCount, UINT StartVertexLocation)); |
| |
| MOCK_STDCALL_METHOD5(Map, |
| HRESULT(ID3D11Resource* pResource, |
| UINT Subresource, |
| D3D11_MAP MapType, |
| UINT MapFlags, |
| D3D11_MAPPED_SUBRESOURCE* pMappedResource)); |
| |
| MOCK_STDCALL_METHOD2(Unmap, |
| void(ID3D11Resource* pResource, UINT Subresource)); |
| |
| MOCK_STDCALL_METHOD3(PSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD1(IASetInputLayout, void(ID3D11InputLayout* pInputLayout)); |
| |
| MOCK_STDCALL_METHOD5(IASetVertexBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppVertexBuffers, |
| const UINT* pStrides, |
| const UINT* pOffsets)); |
| |
| MOCK_STDCALL_METHOD3(IASetIndexBuffer, |
| void(ID3D11Buffer* pIndexBuffer, |
| DXGI_FORMAT Format, |
| UINT Offset)); |
| |
| MOCK_STDCALL_METHOD5(DrawIndexedInstanced, |
| void(UINT IndexCountPerInstance, |
| UINT InstanceCount, |
| UINT StartIndexLocation, |
| INT BaseVertexLocation, |
| UINT StartInstanceLocation)); |
| |
| MOCK_STDCALL_METHOD4(DrawInstanced, |
| void(UINT VertexCountPerInstance, |
| UINT InstanceCount, |
| UINT StartVertexLocation, |
| UINT StartInstanceLocation)); |
| |
| MOCK_STDCALL_METHOD3(GSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(GSSetShader, |
| void(ID3D11GeometryShader* pShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD1(IASetPrimitiveTopology, |
| void(D3D11_PRIMITIVE_TOPOLOGY Topology)); |
| |
| MOCK_STDCALL_METHOD3( |
| VSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(VSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD1(Begin, void(ID3D11Asynchronous* pAsync)); |
| |
| MOCK_STDCALL_METHOD1(End, void(ID3D11Asynchronous* pAsync)); |
| |
| MOCK_STDCALL_METHOD4(GetData, |
| HRESULT(ID3D11Asynchronous* pAsync, |
| void* pData, |
| UINT DataSize, |
| UINT GetDataFlags)); |
| |
| MOCK_STDCALL_METHOD2(SetPredication, |
| void(ID3D11Predicate* pPredicate, BOOL PredicateValue)); |
| |
| MOCK_STDCALL_METHOD3( |
| GSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(GSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(OMSetRenderTargets, |
| void(UINT NumViews, |
| ID3D11RenderTargetView* const* ppRenderTargetViews, |
| ID3D11DepthStencilView* pDepthStencilView)); |
| |
| MOCK_STDCALL_METHOD7( |
| OMSetRenderTargetsAndUnorderedAccessViews, |
| void(UINT NumRTVs, |
| ID3D11RenderTargetView* const* ppRenderTargetViews, |
| ID3D11DepthStencilView* pDepthStencilView, |
| UINT UAVStartSlot, |
| UINT NumUAVs, |
| ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, |
| const UINT* pUAVInitialCounts)); |
| |
| MOCK_STDCALL_METHOD3(OMSetBlendState, |
| void(ID3D11BlendState* pBlendState, |
| const FLOAT BlendFactor[4], |
| UINT SampleMask)); |
| |
| MOCK_STDCALL_METHOD2(OMSetDepthStencilState, |
| void(ID3D11DepthStencilState* pDepthStencilState, |
| UINT StencilRef)); |
| |
| MOCK_STDCALL_METHOD3(SOSetTargets, |
| void(UINT NumBuffers, |
| ID3D11Buffer* const* ppSOTargets, |
| const UINT* pOffsets)); |
| |
| MOCK_STDCALL_METHOD0(DrawAuto, void()); |
| |
| MOCK_STDCALL_METHOD2(DrawIndexedInstancedIndirect, |
| void(ID3D11Buffer* pBufferForArgs, |
| UINT AlignedByteOffsetForArgs)); |
| |
| MOCK_STDCALL_METHOD2(DrawInstancedIndirect, |
| void(ID3D11Buffer* pBufferForArgs, |
| UINT AlignedByteOffsetForArgs)); |
| |
| MOCK_STDCALL_METHOD3(Dispatch, |
| void(UINT ThreadGroupCountX, |
| UINT ThreadGroupCountY, |
| UINT ThreadGroupCountZ)); |
| |
| MOCK_STDCALL_METHOD2(DispatchIndirect, |
| void(ID3D11Buffer* pBufferForArgs, |
| UINT AlignedByteOffsetForArgs)); |
| |
| MOCK_STDCALL_METHOD1(RSSetState, |
| void(ID3D11RasterizerState* pRasterizerState)); |
| |
| MOCK_STDCALL_METHOD2(RSSetViewports, |
| void(UINT NumViewports, |
| const D3D11_VIEWPORT* pViewports)); |
| |
| MOCK_STDCALL_METHOD2(RSSetScissorRects, |
| void(UINT NumRects, const D3D11_RECT* pRects)); |
| |
| MOCK_STDCALL_METHOD8(CopySubresourceRegion, |
| void(ID3D11Resource* pDstResource, |
| UINT DstSubresource, |
| UINT DstX, |
| UINT DstY, |
| UINT DstZ, |
| ID3D11Resource* pSrcResource, |
| UINT SrcSubresource, |
| const D3D11_BOX* pSrcBox)); |
| |
| MOCK_STDCALL_METHOD2(CopyResource, |
| void(ID3D11Resource* pDstResource, |
| ID3D11Resource* pSrcResource)); |
| |
| MOCK_STDCALL_METHOD6(UpdateSubresource, |
| void(ID3D11Resource* pDstResource, |
| UINT DstSubresource, |
| const D3D11_BOX* pDstBox, |
| const void* pSrcData, |
| UINT SrcRowPitch, |
| UINT SrcDepthPitch)); |
| |
| MOCK_STDCALL_METHOD3(CopyStructureCount, |
| void(ID3D11Buffer* pDstBuffer, |
| UINT DstAlignedByteOffset, |
| ID3D11UnorderedAccessView* pSrcView)); |
| |
| MOCK_STDCALL_METHOD2(ClearRenderTargetView, |
| void(ID3D11RenderTargetView* pRenderTargetView, |
| const FLOAT ColorRGBA[4])); |
| |
| MOCK_STDCALL_METHOD2(ClearUnorderedAccessViewUint, |
| void(ID3D11UnorderedAccessView* pUnorderedAccessView, |
| const UINT Values[4])); |
| |
| MOCK_STDCALL_METHOD2(ClearUnorderedAccessViewFloat, |
| void(ID3D11UnorderedAccessView* pUnorderedAccessView, |
| const FLOAT Values[4])); |
| |
| MOCK_STDCALL_METHOD4(ClearDepthStencilView, |
| void(ID3D11DepthStencilView* pDepthStencilView, |
| UINT ClearFlags, |
| FLOAT Depth, |
| UINT8 Stencil)); |
| |
| MOCK_STDCALL_METHOD1(GenerateMips, |
| void(ID3D11ShaderResourceView* pShaderResourceView)); |
| |
| MOCK_STDCALL_METHOD2(SetResourceMinLOD, |
| void(ID3D11Resource* pResource, FLOAT MinLOD)); |
| |
| MOCK_STDCALL_METHOD1(GetResourceMinLOD, FLOAT(ID3D11Resource* pResource)); |
| |
| MOCK_STDCALL_METHOD5(ResolveSubresource, |
| void(ID3D11Resource* pDstResource, |
| UINT DstSubresource, |
| ID3D11Resource* pSrcResource, |
| UINT SrcSubresource, |
| DXGI_FORMAT Format)); |
| |
| MOCK_STDCALL_METHOD2(ExecuteCommandList, |
| void(ID3D11CommandList* pCommandList, |
| BOOL RestoreContextState)); |
| |
| MOCK_STDCALL_METHOD3( |
| HSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(HSSetShader, |
| void(ID3D11HullShader* pHullShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(HSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(HSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3( |
| DSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(DSSetShader, |
| void(ID3D11DomainShader* pDomainShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(DSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(DSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3( |
| CSSetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView* const* ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD4( |
| CSSetUnorderedAccessViews, |
| void(UINT StartSlot, |
| UINT NumUAVs, |
| ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, |
| const UINT* pUAVInitialCounts)); |
| |
| MOCK_STDCALL_METHOD3(CSSetShader, |
| void(ID3D11ComputeShader* pComputeShader, |
| ID3D11ClassInstance* const* ppClassInstances, |
| UINT NumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(CSSetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState* const* ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(CSSetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer* const* ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(VSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(PSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(PSGetShader, |
| void(ID3D11PixelShader** ppPixelShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(PSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(VSGetShader, |
| void(ID3D11VertexShader** ppVertexShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(PSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD1(IAGetInputLayout, |
| void(ID3D11InputLayout** ppInputLayout)); |
| |
| MOCK_STDCALL_METHOD5(IAGetVertexBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppVertexBuffers, |
| UINT* pStrides, |
| UINT* pOffsets)); |
| |
| MOCK_STDCALL_METHOD3(IAGetIndexBuffer, |
| void(ID3D11Buffer** pIndexBuffer, |
| DXGI_FORMAT* Format, |
| UINT* Offset)); |
| |
| MOCK_STDCALL_METHOD3(GSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(GSGetShader, |
| void(ID3D11GeometryShader** ppGeometryShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD1(IAGetPrimitiveTopology, |
| void(D3D11_PRIMITIVE_TOPOLOGY* pTopology)); |
| |
| MOCK_STDCALL_METHOD3(VSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(VSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD2(GetPredication, |
| void(ID3D11Predicate** ppPredicate, |
| BOOL* pPredicateValue)); |
| |
| MOCK_STDCALL_METHOD3(GSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(GSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(OMGetRenderTargets, |
| void(UINT NumViews, |
| ID3D11RenderTargetView** ppRenderTargetViews, |
| ID3D11DepthStencilView** ppDepthStencilView)); |
| |
| MOCK_STDCALL_METHOD6( |
| OMGetRenderTargetsAndUnorderedAccessViews, |
| void(UINT NumRTVs, |
| ID3D11RenderTargetView** ppRenderTargetViews, |
| ID3D11DepthStencilView** ppDepthStencilView, |
| UINT UAVStartSlot, |
| UINT NumUAVs, |
| ID3D11UnorderedAccessView** ppUnorderedAccessViews)); |
| |
| MOCK_STDCALL_METHOD3(OMGetBlendState, |
| void(ID3D11BlendState** ppBlendState, |
| FLOAT BlendFactor[4], |
| UINT* pSampleMask)); |
| |
| MOCK_STDCALL_METHOD2(OMGetDepthStencilState, |
| void(ID3D11DepthStencilState** ppDepthStencilState, |
| UINT* pStencilRef)); |
| |
| MOCK_STDCALL_METHOD2(SOGetTargets, |
| void(UINT NumBuffers, ID3D11Buffer** ppSOTargets)); |
| |
| MOCK_STDCALL_METHOD1(RSGetState, |
| void(ID3D11RasterizerState** ppRasterizerState)); |
| |
| MOCK_STDCALL_METHOD2(RSGetViewports, |
| void(UINT* pNumViewports, D3D11_VIEWPORT* pViewports)); |
| |
| MOCK_STDCALL_METHOD2(RSGetScissorRects, |
| void(UINT* pNumRects, D3D11_RECT* pRects)); |
| |
| MOCK_STDCALL_METHOD3(HSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(HSGetShader, |
| void(ID3D11HullShader** ppHullShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(HSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(HSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(DSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3(DSGetShader, |
| void(ID3D11DomainShader** ppDomainShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(DSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(DSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD3(CSGetShaderResources, |
| void(UINT StartSlot, |
| UINT NumViews, |
| ID3D11ShaderResourceView** ppShaderResourceViews)); |
| |
| MOCK_STDCALL_METHOD3( |
| CSGetUnorderedAccessViews, |
| void(UINT StartSlot, |
| UINT NumUAVs, |
| ID3D11UnorderedAccessView** ppUnorderedAccessViews)); |
| |
| MOCK_STDCALL_METHOD3(CSGetShader, |
| void(ID3D11ComputeShader** ppComputeShader, |
| ID3D11ClassInstance** ppClassInstances, |
| UINT* pNumClassInstances)); |
| |
| MOCK_STDCALL_METHOD3(CSGetSamplers, |
| void(UINT StartSlot, |
| UINT NumSamplers, |
| ID3D11SamplerState** ppSamplers)); |
| |
| MOCK_STDCALL_METHOD3(CSGetConstantBuffers, |
| void(UINT StartSlot, |
| UINT NumBuffers, |
| ID3D11Buffer** ppConstantBuffers)); |
| |
| MOCK_STDCALL_METHOD0(ClearState, void()); |
| |
| MOCK_STDCALL_METHOD0(Flush, void()); |
| |
| MOCK_STDCALL_METHOD0(GetType, D3D11_DEVICE_CONTEXT_TYPE()); |
| |
| MOCK_STDCALL_METHOD0(GetContextFlags, UINT()); |
| |
| MOCK_STDCALL_METHOD2(FinishCommandList, |
| HRESULT(BOOL RestoreDeferredContextState, |
| ID3D11CommandList** ppCommandList)); |
| |
| // ID3D11DeviceContext1 |
| MOCK_STDCALL_METHOD9(CopySubresourceRegion1, |
| void(ID3D11Resource*, |
| UINT, |
| UINT, |
| UINT, |
| UINT, |
| ID3D11Resource*, |
| UINT, |
| const D3D11_BOX*, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD7(UpdateSubresource1, |
| void(ID3D11Resource*, |
| UINT, |
| const D3D11_BOX*, |
| const void*, |
| UINT, |
| UINT, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD1(DiscardResource, void(ID3D11Resource*)); |
| |
| MOCK_STDCALL_METHOD1(DiscardView, void(ID3D11View*)); |
| |
| MOCK_STDCALL_METHOD5( |
| VSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5( |
| HSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5( |
| DSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5( |
| GSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5( |
| PSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5( |
| CSSetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*)); |
| |
| MOCK_STDCALL_METHOD5(VSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD5(HSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD5(DSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD5(GSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD5(PSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD5(CSGetConstantBuffers1, |
| void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*)); |
| |
| MOCK_STDCALL_METHOD2(SwapDeviceContextState, |
| void(ID3DDeviceContextState*, ID3DDeviceContextState**)); |
| |
| MOCK_STDCALL_METHOD4( |
| ClearView, |
| void(ID3D11View*, const FLOAT[4], const D3D11_RECT*, UINT)); |
| |
| MOCK_STDCALL_METHOD3(DiscardView1, |
| void(ID3D11View*, const D3D11_RECT*, UINT)); |
| |
| // ID3D11DeviceContext2 |
| MOCK_STDCALL_METHOD10(UpdateTileMappings, |
| HRESULT(ID3D11Resource*, |
| UINT, |
| const D3D11_TILED_RESOURCE_COORDINATE*, |
| const D3D11_TILE_REGION_SIZE*, |
| ID3D11Buffer*, |
| UINT, |
| const UINT*, |
| const UINT*, |
| const UINT*, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD6(CopyTileMappings, |
| HRESULT(ID3D11Resource*, |
| const D3D11_TILED_RESOURCE_COORDINATE*, |
| ID3D11Resource*, |
| const D3D11_TILED_RESOURCE_COORDINATE*, |
| const D3D11_TILE_REGION_SIZE*, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD6(CopyTiles, |
| void(ID3D11Resource*, |
| const D3D11_TILED_RESOURCE_COORDINATE*, |
| const D3D11_TILE_REGION_SIZE*, |
| ID3D11Buffer*, |
| UINT64, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD5(UpdateTiles, |
| void(ID3D11Resource*, |
| const D3D11_TILED_RESOURCE_COORDINATE*, |
| const D3D11_TILE_REGION_SIZE*, |
| const void*, |
| UINT)); |
| |
| MOCK_STDCALL_METHOD2(ResizeTilePool, HRESULT(ID3D11Buffer*, UINT64)); |
| |
| MOCK_STDCALL_METHOD2(TiledResourceBarrier, |
| void(ID3D11DeviceChild*, ID3D11DeviceChild*)); |
| |
| MOCK_STDCALL_METHOD0(IsAnnotationEnabled, BOOL()); |
| |
| MOCK_STDCALL_METHOD2(SetMarkerInt, void(LPCWSTR, INT)); |
| |
| MOCK_STDCALL_METHOD2(BeginEventInt, void(LPCWSTR, INT)); |
| |
| MOCK_STDCALL_METHOD0(EndEvent, void()); |
| |
| // ID3D11DeviceContext3 |
| MOCK_STDCALL_METHOD2(Flush1, void(D3D11_CONTEXT_TYPE, HANDLE)); |
| |
| MOCK_STDCALL_METHOD1(SetHardwareProtectionState, void(BOOL)); |
| |
| MOCK_STDCALL_METHOD1(GetHardwareProtectionState, void(BOOL*)); |
| |
| // ID3D11DeviceContext4 |
| MOCK_STDCALL_METHOD2(Signal, HRESULT(ID3D11Fence*, UINT64)); |
| |
| MOCK_STDCALL_METHOD2(Wait, HRESULT(ID3D11Fence*, UINT64)); |
| }; |
| |
| class D3D11FenceMock |
| : public Microsoft::WRL::RuntimeClass< |
| Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, |
| ID3D11Fence> { |
| public: |
| D3D11FenceMock(); |
| ~D3D11FenceMock() override; |
| |
| MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**)); |
| MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*)); |
| MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*)); |
| MOCK_STDCALL_METHOD2(SetPrivateDataInterface, |
| HRESULT(const GUID&, const IUnknown*)); |
| |
| MOCK_STDCALL_METHOD4( |
| CreateSharedHandle, |
| HRESULT(const SECURITY_ATTRIBUTES*, DWORD, LPCWSTR, HANDLE*)); |
| |
| MOCK_STDCALL_METHOD0(GetCompletedValue, UINT64()); |
| |
| MOCK_STDCALL_METHOD2(SetEventOnCompletion, HRESULT(UINT64, HANDLE)); |
| }; |
| |
| } // namespace media |
| |
| #endif // MEDIA_BASE_WIN_D3D11_MOCKS_H_ |
