/*++ Copyright (c) Microsoft Corporation Abstract: This module contains a sample implementation of an indirect display driver. See the included README.md file and the various TODO blocks throughout this file and all accompanying files for information on building a production driver. MSDN documentation on indirect displays can be found at https://msdn.microsoft.com/en-us/library/windows/hardware/mt761968(v=vs.85).aspx. Environment: User Mode, UMDF --*/ #include "Driver.h" #include "Driver.tmh" using namespace std; using namespace Microsoft::IndirectDisp; using namespace Microsoft::WRL; extern "C" DRIVER_INITIALIZE DriverEntry; EVT_WDF_DRIVER_DEVICE_ADD IddSampleDeviceAdd; EVT_WDF_DEVICE_D0_ENTRY IddSampleDeviceD0Entry; EVT_IDD_CX_ADAPTER_INIT_FINISHED IddSampleAdapterInitFinished; EVT_IDD_CX_ADAPTER_COMMIT_MODES IddSampleAdapterCommitModes; EVT_IDD_CX_PARSE_MONITOR_DESCRIPTION IddSampleParseMonitorDescription; EVT_IDD_CX_MONITOR_GET_DEFAULT_DESCRIPTION_MODES IddSampleMonitorGetDefaultModes; EVT_IDD_CX_MONITOR_QUERY_TARGET_MODES IddSampleMonitorQueryModes; EVT_IDD_CX_MONITOR_ASSIGN_SWAPCHAIN IddSampleMonitorAssignSwapChain; EVT_IDD_CX_MONITOR_UNASSIGN_SWAPCHAIN IddSampleMonitorUnassignSwapChain; struct IndirectDeviceContextWrapper { IndirectDeviceContext* pContext; void Cleanup() { delete pContext; pContext = nullptr; } }; // This macro creates the methods for accessing an IndirectDeviceContextWrapper as a context for a WDF object WDF_DECLARE_CONTEXT_TYPE(IndirectDeviceContextWrapper); extern "C" BOOL WINAPI DllMain( _In_ HINSTANCE hInstance, _In_ UINT dwReason, _In_opt_ LPVOID lpReserved) { UNREFERENCED_PARAMETER(hInstance); UNREFERENCED_PARAMETER(lpReserved); UNREFERENCED_PARAMETER(dwReason); return TRUE; } _Use_decl_annotations_ extern "C" NTSTATUS DriverEntry( PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath ) { WDF_DRIVER_CONFIG Config; NTSTATUS Status; WDF_OBJECT_ATTRIBUTES Attributes; WDF_OBJECT_ATTRIBUTES_INIT(&Attributes); WDF_DRIVER_CONFIG_INIT(&Config, IddSampleDeviceAdd ); Status = WdfDriverCreate(pDriverObject, pRegistryPath, &Attributes, &Config, WDF_NO_HANDLE); if (!NT_SUCCESS(Status)) { return Status; } return Status; } _Use_decl_annotations_ NTSTATUS IddSampleDeviceAdd(WDFDRIVER Driver, PWDFDEVICE_INIT pDeviceInit) { NTSTATUS Status = STATUS_SUCCESS; WDF_PNPPOWER_EVENT_CALLBACKS PnpPowerCallbacks; UNREFERENCED_PARAMETER(Driver); // Register for power callbacks - in this sample only power-on is needed WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpPowerCallbacks); PnpPowerCallbacks.EvtDeviceD0Entry = IddSampleDeviceD0Entry; WdfDeviceInitSetPnpPowerEventCallbacks(pDeviceInit, &PnpPowerCallbacks); IDD_CX_CLIENT_CONFIG IddConfig; IDD_CX_CLIENT_CONFIG_INIT(&IddConfig); // If the driver wishes to handle custom IoDeviceControl requests, it's necessary to use this callback since IddCx // redirects IoDeviceControl requests to an internal queue. This sample does not need this. // IddConfig.EvtIddCxDeviceIoControl = IddSampleIoDeviceControl; IddConfig.EvtIddCxAdapterInitFinished = IddSampleAdapterInitFinished; IddConfig.EvtIddCxParseMonitorDescription = IddSampleParseMonitorDescription; IddConfig.EvtIddCxMonitorGetDefaultDescriptionModes = IddSampleMonitorGetDefaultModes; IddConfig.EvtIddCxMonitorQueryTargetModes = IddSampleMonitorQueryModes; IddConfig.EvtIddCxAdapterCommitModes = IddSampleAdapterCommitModes; IddConfig.EvtIddCxMonitorAssignSwapChain = IddSampleMonitorAssignSwapChain; IddConfig.EvtIddCxMonitorUnassignSwapChain = IddSampleMonitorUnassignSwapChain; Status = IddCxDeviceInitConfig(pDeviceInit, &IddConfig); if (!NT_SUCCESS(Status)) { return Status; } WDF_OBJECT_ATTRIBUTES Attr; WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attr, IndirectDeviceContextWrapper); Attr.EvtCleanupCallback = [](WDFOBJECT Object) { // Automatically cleanup the context when the WDF object is about to be deleted auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(Object); if (pContext) { pContext->Cleanup(); } }; WDFDEVICE Device = nullptr; Status = WdfDeviceCreate(&pDeviceInit, &Attr, &Device); if (!NT_SUCCESS(Status)) { return Status; } Status = IddCxDeviceInitialize(Device); // Create a new device context object and attach it to the WDF device object auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(Device); pContext->pContext = new IndirectDeviceContext(Device); return Status; } _Use_decl_annotations_ NTSTATUS IddSampleDeviceD0Entry(WDFDEVICE Device, WDF_POWER_DEVICE_STATE PreviousState) { UNREFERENCED_PARAMETER(PreviousState); // This function is called by WDF to start the device in the fully-on power state. auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(Device); pContext->pContext->InitAdapter(); return STATUS_SUCCESS; } #pragma region Direct3DDevice Direct3DDevice::Direct3DDevice(LUID AdapterLuid) : AdapterLuid(AdapterLuid) { } Direct3DDevice::Direct3DDevice() { AdapterLuid = LUID{}; } HRESULT Direct3DDevice::Init() { // The DXGI factory could be cached, but if a new render adapter appears on the system, a new factory needs to be // created. If caching is desired, check DxgiFactory->IsCurrent() each time and recreate the factory if !IsCurrent. HRESULT hr = CreateDXGIFactory2(0, IID_PPV_ARGS(&DxgiFactory)); if (FAILED(hr)) { return hr; } // Find the specified render adapter hr = DxgiFactory->EnumAdapterByLuid(AdapterLuid, IID_PPV_ARGS(&Adapter)); if (FAILED(hr)) { return hr; } // Create a D3D device using the render adapter. BGRA support is required by the WHQL test suite. hr = D3D11CreateDevice(Adapter.Get(), D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0, D3D11_SDK_VERSION, &Device, nullptr, &DeviceContext); if (FAILED(hr)) { // If creating the D3D device failed, it's possible the render GPU was lost (e.g. detachable GPU) or else the // system is in a transient state. return hr; } return S_OK; } #pragma endregion #pragma region SwapChainProcessor SwapChainProcessor::SwapChainProcessor(IDDCX_SWAPCHAIN hSwapChain, shared_ptr Device, HANDLE NewFrameEvent) : m_hSwapChain(hSwapChain), m_Device(Device), m_hAvailableBufferEvent(NewFrameEvent) { m_hTerminateEvent.Attach(CreateEvent(nullptr, FALSE, FALSE, nullptr)); // Immediately create and run the swap-chain processing thread, passing 'this' as the thread parameter m_hThread.Attach(CreateThread(nullptr, 0, RunThread, this, 0, nullptr)); } SwapChainProcessor::~SwapChainProcessor() { // Alert the swap-chain processing thread to terminate SetEvent(m_hTerminateEvent.Get()); if (m_hThread.Get()) { // Wait for the thread to terminate WaitForSingleObject(m_hThread.Get(), INFINITE); } } DWORD CALLBACK SwapChainProcessor::RunThread(LPVOID Argument) { reinterpret_cast(Argument)->Run(); return 0; } void SwapChainProcessor::Run() { // For improved performance, make use of the Multimedia Class Scheduler Service, which will intelligently // prioritize this thread for improved throughput in high CPU-load scenarios. DWORD AvTask = 0; HANDLE AvTaskHandle = AvSetMmThreadCharacteristics(L"Distribution", &AvTask); RunCore(); // Always delete the swap-chain object when swap-chain processing loop terminates in order to kick the system to // provide a new swap-chain if necessary. WdfObjectDelete((WDFOBJECT)m_hSwapChain); m_hSwapChain = nullptr; AvRevertMmThreadCharacteristics(AvTaskHandle); } void SwapChainProcessor::RunCore() { // Get the DXGI device interface ComPtr DxgiDevice; HRESULT hr = m_Device->Device.As(&DxgiDevice); if (FAILED(hr)) { return; } IDARG_IN_SWAPCHAINSETDEVICE SetDevice = {}; SetDevice.pDevice = DxgiDevice.Get(); hr = IddCxSwapChainSetDevice(m_hSwapChain, &SetDevice); if (FAILED(hr)) { return; } // Acquire and release buffers in a loop for (;;) { ComPtr AcquiredBuffer; // Ask for the next buffer from the producer IDARG_OUT_RELEASEANDACQUIREBUFFER Buffer = {}; hr = IddCxSwapChainReleaseAndAcquireBuffer(m_hSwapChain, &Buffer); // AcquireBuffer immediately returns STATUS_PENDING if no buffer is yet available if (hr == E_PENDING) { // We must wait for a new buffer HANDLE WaitHandles [] = { m_hAvailableBufferEvent, m_hTerminateEvent.Get() }; DWORD WaitResult = WaitForMultipleObjects(ARRAYSIZE(WaitHandles), WaitHandles, FALSE, 16); if (WaitResult == WAIT_OBJECT_0 || WaitResult == WAIT_TIMEOUT) { // We have a new buffer, so try the AcquireBuffer again continue; } else if (WaitResult == WAIT_OBJECT_0 + 1) { // We need to terminate break; } else { // The wait was cancelled or something unexpected happened hr = HRESULT_FROM_WIN32(WaitResult); break; } } else if (SUCCEEDED(hr)) { AcquiredBuffer.Attach(Buffer.MetaData.pSurface); // ============================== // TODO: Process the frame here // // This is the most performance-critical section of code in an IddCx driver. It's important that whatever // is done with the acquired surface be finished as quickly as possible. This operation could be: // * a GPU copy to another buffer surface for later processing (such as a staging surface for mapping to CPU memory) // * a GPU encode operation // * a GPU VPBlt to another surface // * a GPU custom compute shader encode operation // ============================== AcquiredBuffer.Reset(); hr = IddCxSwapChainFinishedProcessingFrame(m_hSwapChain); if (FAILED(hr)) { break; } // ============================== // TODO: Report frame statistics once the asynchronous encode/send work is completed // // Drivers should report information about sub-frame timings, like encode time, send time, etc. // ============================== // IddCxSwapChainReportFrameStatistics(m_hSwapChain, ...); } else { // The swap-chain was likely abandoned (e.g. DXGI_ERROR_ACCESS_LOST), so exit the processing loop break; } } } #pragma endregion #pragma region IndirectDeviceContext const UINT64 MHZ = 1000000; const UINT64 KHZ = 1000; // A list of modes exposed by the sample monitor EDID - FOR SAMPLE PURPOSES ONLY const DISPLAYCONFIG_VIDEO_SIGNAL_INFO IndirectDeviceContext::s_KnownMonitorModes[] = { // 800 x 600 @ 60Hz { 40 * MHZ, // pixel clock rate [Hz] { 40 * MHZ, 800 + 256 }, // fractional horizontal refresh rate [Hz] { 40 * MHZ, (800 + 256) * (600 + 28) }, // fractional vertical refresh rate [Hz] { 800, 600 }, // (horizontal, vertical) active pixel resolution { 800 + 256, 600 + 28 }, // (horizontal, vertical) total pixel resolution { { 255, 0 }}, // video standard and vsync divider DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE }, // 640 x 480 @ 60Hz { 25175 * KHZ, // pixel clock rate [Hz] { 25175 * KHZ, 640 + 160 }, // fractional horizontal refresh rate [Hz] { 25175 * KHZ, (640 + 160) * (480 + 46) }, // fractional vertical refresh rate [Hz] { 640, 480 }, // (horizontal, vertical) active pixel resolution { 640 + 160, 480 + 46 }, // (horizontal, vertical) blanking pixel resolution { { 255, 0 } }, // video standard and vsync divider DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE }, }; // This is a sample monitor EDID - FOR SAMPLE PURPOSES ONLY const BYTE IndirectDeviceContext::s_KnownMonitorEdid[] = { 0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x79,0x5E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA6,0x01,0x03,0x80,0x28, 0x1E,0x78,0x0A,0xEE,0x91,0xA3,0x54,0x4C,0x99,0x26,0x0F,0x50,0x54,0x20,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01, 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xA0,0x0F,0x20,0x00,0x31,0x58,0x1C,0x20,0x28,0x80,0x14,0x00, 0x90,0x2C,0x11,0x00,0x00,0x1E,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x6E }; IndirectDeviceContext::IndirectDeviceContext(_In_ WDFDEVICE WdfDevice) : m_WdfDevice(WdfDevice) { m_Adapter = {}; m_Monitor = {}; } IndirectDeviceContext::~IndirectDeviceContext() { m_ProcessingThread.reset(); } void IndirectDeviceContext::InitAdapter() { // ============================== // TODO: Update the below diagnostic information in accordance with the target hardware. The strings and version // numbers are used for telemetry and may be displayed to the user in some situations. // // This is also where static per-adapter capabilities are determined. // ============================== IDDCX_ADAPTER_CAPS AdapterCaps = {}; AdapterCaps.Size = sizeof(AdapterCaps); // Declare basic feature support for the adapter (required) AdapterCaps.MaxMonitorsSupported = 1; AdapterCaps.EndPointDiagnostics.Size = sizeof(AdapterCaps.EndPointDiagnostics); AdapterCaps.EndPointDiagnostics.GammaSupport = IDDCX_FEATURE_IMPLEMENTATION_NONE; AdapterCaps.EndPointDiagnostics.TransmissionType = IDDCX_TRANSMISSION_TYPE_WIRED_OTHER; // Declare your device strings for telemetry (required) AdapterCaps.EndPointDiagnostics.pEndPointFriendlyName = L"IddSample Device"; AdapterCaps.EndPointDiagnostics.pEndPointManufacturerName = L"Microsoft"; AdapterCaps.EndPointDiagnostics.pEndPointModelName = L"IddSample Model"; // Declare your hardware and firmware versions (required) IDDCX_ENDPOINT_VERSION Version = {}; Version.Size = sizeof(Version); Version.MajorVer = 1; AdapterCaps.EndPointDiagnostics.pFirmwareVersion = &Version; AdapterCaps.EndPointDiagnostics.pHardwareVersion = &Version; // Initialize a WDF context that can store a pointer to the device context object WDF_OBJECT_ATTRIBUTES Attr; WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attr, IndirectDeviceContextWrapper); IDARG_IN_ADAPTER_INIT AdapterInit = {}; AdapterInit.WdfDevice = m_WdfDevice; AdapterInit.pCaps = &AdapterCaps; AdapterInit.ObjectAttributes = &Attr; // Start the initialization of the adapter, which will trigger the AdapterFinishInit callback later IDARG_OUT_ADAPTER_INIT AdapterInitOut; NTSTATUS Status = IddCxAdapterInitAsync(&AdapterInit, &AdapterInitOut); if (NT_SUCCESS(Status)) { // Store a reference to the WDF adapter handle m_Adapter = AdapterInitOut.AdapterObject; // Store the device context object into the WDF object context auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(AdapterInitOut.AdapterObject); pContext->pContext = this; } } void IndirectDeviceContext::FinishInit() { // ============================== // TODO: In a real driver, the EDID should be retrieved dynamically from a connected physical monitor. The EDID // provided here is purely for demonstration, as it describes only 640x480 @ 60 Hz and 800x600 @ 60 Hz. Monitor // manufacturers are required to correctly fill in physical monitor attributes in order to allow the OS to optimize // settings like viewing distance and scale factor. Manufacturers should also use a unique serial number every // single device to ensure the OS can tell the monitors apart. // ============================== WDF_OBJECT_ATTRIBUTES Attr; WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attr, IndirectDeviceContextWrapper); IDDCX_MONITOR_INFO MonitorInfo = {}; MonitorInfo.Size = sizeof(MonitorInfo); MonitorInfo.MonitorType = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI; MonitorInfo.ConnectorIndex = 0; MonitorInfo.MonitorDescription.Size = sizeof(MonitorInfo.MonitorDescription); MonitorInfo.MonitorDescription.Type = IDDCX_MONITOR_DESCRIPTION_TYPE_EDID; MonitorInfo.MonitorDescription.DataSize = sizeof(s_KnownMonitorEdid); MonitorInfo.MonitorDescription.pData = const_cast(s_KnownMonitorEdid); // ============================== // TODO: The monitor's container ID should be distinct from "this" device's container ID if the monitor is not // permanently attached to the display adapter device object. The container ID is typically made unique for each // monitor and can be used to associate the monitor with other devices, like audio or input devices. In this // sample we generate a random container ID GUID, but it's best practice to choose a stable container ID for a // unique monitor or to use "this" device's container ID for a permanent/integrated monitor. // ============================== // Create a container ID CoCreateGuid(&MonitorInfo.MonitorContainerId); IDARG_IN_MONITORCREATE MonitorCreate = {}; MonitorCreate.ObjectAttributes = &Attr; MonitorCreate.pMonitorInfo = &MonitorInfo; // Create a monitor object with the specified monitor descriptor IDARG_OUT_MONITORCREATE MonitorCreateOut; NTSTATUS Status = IddCxMonitorCreate(m_Adapter, &MonitorCreate, &MonitorCreateOut); if (NT_SUCCESS(Status)) { m_Monitor = MonitorCreateOut.MonitorObject; // Associate the monitor with this device context auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(MonitorCreateOut.MonitorObject); pContext->pContext = this; // Tell the OS that the monitor has been plugged in IDARG_OUT_MONITORARRIVAL ArrivalOut; Status = IddCxMonitorArrival(m_Monitor, &ArrivalOut); } } void IndirectDeviceContext::AssignSwapChain(IDDCX_SWAPCHAIN SwapChain, LUID RenderAdapter, HANDLE NewFrameEvent) { m_ProcessingThread.reset(); auto Device = make_shared(RenderAdapter); if (FAILED(Device->Init())) { // It's important to delete the swap-chain if D3D initialization fails, so that the OS knows to generate a new // swap-chain and try again. WdfObjectDelete(SwapChain); } else { // Create a new swap-chain processing thread m_ProcessingThread.reset(new SwapChainProcessor(SwapChain, Device, NewFrameEvent)); } } void IndirectDeviceContext::UnassignSwapChain() { // Stop processing the last swap-chain m_ProcessingThread.reset(); } #pragma endregion #pragma region DDI Callbacks _Use_decl_annotations_ NTSTATUS IddSampleAdapterInitFinished(IDDCX_ADAPTER AdapterObject, const IDARG_IN_ADAPTER_INIT_FINISHED* pInArgs) { // This is called when the OS has finished setting up the adapter for use by the IddCx driver. It's now possible // to report attached monitors. auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(AdapterObject); if (NT_SUCCESS(pInArgs->AdapterInitStatus)) { pContext->pContext->FinishInit(); } return STATUS_SUCCESS; } _Use_decl_annotations_ NTSTATUS IddSampleAdapterCommitModes(IDDCX_ADAPTER AdapterObject, const IDARG_IN_COMMITMODES* pInArgs) { UNREFERENCED_PARAMETER(AdapterObject); UNREFERENCED_PARAMETER(pInArgs); // For the sample, do nothing when modes are picked - the swap-chain is taken care of by IddCx // ============================== // TODO: In a real driver, this function would be used to reconfigure the device to commit the new modes. Loop // through pInArgs->pPaths and look for IDDCX_PATH_FLAGS_ACTIVE. Any path not active is inactive (e.g. the monitor // should be turned off). // ============================== return STATUS_SUCCESS; } _Use_decl_annotations_ NTSTATUS IddSampleParseMonitorDescription(const IDARG_IN_PARSEMONITORDESCRIPTION* pInArgs, IDARG_OUT_PARSEMONITORDESCRIPTION* pOutArgs) { // ============================== // TODO: In a real driver, this function would be called to generate monitor modes for an EDID by parsing it. In // this sample driver, we hard-code the EDID, so this function can generate known modes. // ============================== pOutArgs->MonitorModeBufferOutputCount = ARRAYSIZE(IndirectDeviceContext::s_KnownMonitorModes); if (pInArgs->MonitorModeBufferInputCount < ARRAYSIZE(IndirectDeviceContext::s_KnownMonitorModes)) { // Return success if there was no buffer, since the caller was only asking for a count of modes return (pInArgs->MonitorModeBufferInputCount > 0) ? STATUS_BUFFER_TOO_SMALL : STATUS_SUCCESS; } else { // Copy the known modes to the output buffer for (DWORD ModeIndex = 0; ModeIndex < ARRAYSIZE(IndirectDeviceContext::s_KnownMonitorModes); ModeIndex++) { pInArgs->pMonitorModes[ModeIndex].Size = sizeof(IDDCX_MONITOR_MODE); pInArgs->pMonitorModes[ModeIndex].Origin = IDDCX_MONITOR_MODE_ORIGIN_MONITORDESCRIPTOR; pInArgs->pMonitorModes[ModeIndex].MonitorVideoSignalInfo = IndirectDeviceContext::s_KnownMonitorModes[ModeIndex]; } // Set the preferred mode as represented in the EDID pOutArgs->PreferredMonitorModeIdx = 0; return STATUS_SUCCESS; } } _Use_decl_annotations_ NTSTATUS IddSampleMonitorGetDefaultModes(IDDCX_MONITOR MonitorObject, const IDARG_IN_GETDEFAULTDESCRIPTIONMODES* pInArgs, IDARG_OUT_GETDEFAULTDESCRIPTIONMODES* pOutArgs) { UNREFERENCED_PARAMETER(MonitorObject); UNREFERENCED_PARAMETER(pInArgs); UNREFERENCED_PARAMETER(pOutArgs); // Should never be called since we create a single monitor with a known EDID in this sample driver. // ============================== // TODO: In a real driver, this function would be called to generate monitor modes for a monitor with no EDID. // Drivers should report modes that are guaranteed to be supported by the transport protocol and by nearly all // monitors (such 640x480, 800x600, or 1024x768). If the driver has access to monitor modes from a descriptor other // than an EDID, those modes would also be reported here. // ============================== return STATUS_NOT_IMPLEMENTED; } /// /// Creates a target mode from the fundamental mode attributes. /// void CreateTargetMode(DISPLAYCONFIG_VIDEO_SIGNAL_INFO& Mode, UINT Width, UINT Height, UINT VSync) { Mode.totalSize.cx = Mode.activeSize.cx = Width; Mode.totalSize.cy = Mode.activeSize.cy = Height; Mode.AdditionalSignalInfo.vSyncFreqDivider = 1; Mode.AdditionalSignalInfo.videoStandard = 255; Mode.vSyncFreq.Numerator = VSync; Mode.vSyncFreq.Denominator = Mode.hSyncFreq.Denominator = 1; Mode.hSyncFreq.Numerator = VSync * Height; Mode.scanLineOrdering = DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE; Mode.pixelRate = ((UINT64) VSync) * ((UINT64) Width) * ((UINT64) Height); } void CreateTargetMode(IDDCX_TARGET_MODE& Mode, UINT Width, UINT Height, UINT VSync) { Mode.Size = sizeof(Mode); CreateTargetMode(Mode.TargetVideoSignalInfo.targetVideoSignalInfo, Width, Height, VSync); } _Use_decl_annotations_ NTSTATUS IddSampleMonitorQueryModes(IDDCX_MONITOR MonitorObject, const IDARG_IN_QUERYTARGETMODES* pInArgs, IDARG_OUT_QUERYTARGETMODES* pOutArgs) { UNREFERENCED_PARAMETER(MonitorObject); vector TargetModes(4); // Create a set of modes supported for frame processing and scan-out. These are typically not based on the // monitor's descriptor and instead are based on the static processing capability of the device. The OS will // report the available set of modes for a given output as the intersection of monitor modes with target modes. CreateTargetMode(TargetModes[0], 1920, 1080, 60); CreateTargetMode(TargetModes[1], 1024, 768, 60); CreateTargetMode(TargetModes[2], 800, 600, 60); CreateTargetMode(TargetModes[3], 640, 480, 60); pOutArgs->TargetModeBufferOutputCount = (UINT)TargetModes.size(); if (pInArgs->TargetModeBufferInputCount >= TargetModes.size()) { copy(TargetModes.begin(), TargetModes.end(), pInArgs->pTargetModes); } return STATUS_SUCCESS; } _Use_decl_annotations_ NTSTATUS IddSampleMonitorAssignSwapChain(IDDCX_MONITOR MonitorObject, const IDARG_IN_SETSWAPCHAIN* pInArgs) { auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(MonitorObject); pContext->pContext->AssignSwapChain(pInArgs->hSwapChain, pInArgs->RenderAdapterLuid, pInArgs->hNextSurfaceAvailable); return STATUS_SUCCESS; } _Use_decl_annotations_ NTSTATUS IddSampleMonitorUnassignSwapChain(IDDCX_MONITOR MonitorObject) { auto* pContext = WdfObjectGet_IndirectDeviceContextWrapper(MonitorObject); pContext->pContext->UnassignSwapChain(); return STATUS_SUCCESS; } #pragma endregion