Code Structure

Virtual-Display-Driver/
├── Virtual Display Driver (HDR)/  # Main driver (IddCx 1.10)
├── Virtual-Audio-Driver/          # Companion audio driver
├── Common/                        # Shared headers and utilities
├── ThirdParty/                    # External dependencies
├── Community Scripts/             # User-contributed utilities
├── scripts/                       # Build and deployment scripts
└── .github/                       # GitHub workflows and templates

Virtual Display Driver (HDR)/
├── MttVDD/                 # Driver project
│   ├── Driver.cpp          # Main driver implementation (5000+ lines)
│   ├── Driver.h            # Driver header and class definitions
│   ├── Trace.h             # WPP tracing configuration
│   ├── MttVDD.inf          # Driver installation file
│   ├── MttVDD.vcxproj      # Visual Studio project file
│   └── MttVDD.sln          # Solution file
├── EDID/                   # EDID profile binaries
├── GetIddCx/               # IddCx version query utility
├── vdd_settings.xml        # Default driver configuration
├── option.txt              # Legacy configuration file
└── MttVDD.sln              # Root solution file

// Driver entry point - called when driver loads
extern "C" DRIVER_INITIALIZE DriverEntry;

// Device context initialization
IndirectDeviceContext::IndirectDeviceContext(_In_ WDFDEVICE WdfDevice)

void IndirectDeviceContext::CreateMonitor(unsigned int index)

class SwapChainProcessor
{
    DWORD CALLBACK RunThread(LPVOID Argument);
    void RunCore();
};

struct Direct3DDevice
{
    Direct3DDevice(LUID AdapterLuid);
    HRESULT Init();
};

NTSTATUS ValidateEdidIntegration();
NTSTATUS PerformanceMonitor();
NTSTATUS CreateFallbackConfiguration();
NTSTATUS ValidateAndSanitizeConfiguration();
NTSTATUS RunComprehensiveDiagnostics();
NTSTATUS InitializePhase5Integration();

namespace Microsoft::IndirectDisp {
    // Direct3D device manager
    struct Direct3DDevice {
        LUID AdapterLuid;
        ComPtr<IDXGIFactory5> DxgiFactory;
        ComPtr<IDXGIAdapter1> Adapter;
        ComPtr<ID3D11Device> Device;
        ComPtr<ID3D11DeviceContext> DeviceContext;
    };
    
    // SwapChain frame processor
    class SwapChainProcessor {
        IDDCX_SWAPCHAIN m_hSwapChain;
        std::shared_ptr<Direct3DDevice> m_Device;
        HANDLE m_hAvailableBufferEvent;
        Microsoft::WRL::Wrappers::Thread m_hThread;
    };
    
    // Main driver context
    class IndirectDeviceContext {
        WDFDEVICE m_WdfDevice;
        IDDCX_ADAPTER m_Adapter;
        IDDCX_MONITOR m_Monitor;
        IDDCX_MONITOR m_Monitor2;
        std::unique_ptr<SwapChainProcessor> m_ProcessingThread;
    };
}

std::vector<std::string> split(std::string& input, char delimiter);
std::string WStringToString(const std::wstring& wstr);

// Tracing GUID and configuration
// Enables diagnostic logging via ETW

TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DRIVER, "Monitor created");
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DRIVER, "Failed: 0x%x", status);

UmdfLibraryVersion = $UMDFVERSION$
ServiceBinary = %12%\UMDF\MttVDD.dll
UmdfExtensions = IddCx0102
HKR,, "UpperFilters", %REG_MULTI_SZ%, "IndirectKmd"

struct GPUInfo {
    wstring name;
    ComPtr<IDXGIAdapter> adapter;
    DXGI_ADAPTER_DESC desc;
};

class AdapterOption {
    bool hasTargetAdapter;
    LUID adapterLuid;
    wstring target_name;
    
    wstring selectBestGPU();
    void load(const wchar_t* path);
    void xmlprovide(const wstring& xtarg);
    void apply(const IDDCX_ADAPTER& adapter);
};

std::optional<LUID> ResolveAdapterLuidFromPciBus(uint32_t targetBusIndex);

<VirtualDisplayDriver>
  <Monitors>
    <Monitor id="0">
      <Enabled>true</Enabled>
      <Resolution>1920x1080</Resolution>
      <RefreshRate>60</RefreshRate>
      <EDID>path/to/edid.bin</EDID>
    </Monitor>
  </Monitors>
  <Adapter>
    <TargetGPU>NVIDIA GeForce RTX 3080</TargetGPU>
  </Adapter>
</VirtualDisplayDriver>

// Load EDID from file
std::vector<BYTE> s_KnownMonitorEdid = ReadEdidFromFile("EDID/profile.bin");

GetIddCx.exe
# Output: IddCx version 1.10.0.0

$(ProjectDir)..\..\ThirdParty\Windows-Driver-Frameworks\src\publicinc\wdf\umdf\2.15

1. DriverEntry()
   └─> Create WDFDRIVER object
       └─> Set device callbacks

2. DeviceAdd callback
   └─> Create IndirectDeviceContext
       └─> InitAdapter()
           ├─> Create IDDCX_ADAPTER
           ├─> Load configuration (vdd_settings.xml)
           ├─> Apply GPU adapter settings
           └─> IddCxAdapterInitAsync()

3. AdapterInit callback
   └─> FinishInit()
       └─> CreateMonitor(0), CreateMonitor(1), ...
           ├─> Load EDID profile
           ├─> Configure display modes
           └─> IddCxMonitorArrival()

1. Application renders to virtual display
   └─> IddCx provides IDDCX_SWAPCHAIN

2. SwapChain assigned to monitor
   └─> AssignSwapChain()
       └─> Create SwapChainProcessor
           └─> Start processing thread

3. SwapChainProcessor::RunCore()
   └─> Loop:
       ├─> IddCxSwapChainReleaseAndAcquireBuffer()
       ├─> Process frame (if needed)
       └─> IddCxSwapChainFinishedProcessingFrame()

static std::map<LUID, std::shared_ptr<Direct3DDevice>, LuidComparator> s_DeviceCache;
static std::mutex s_DeviceCacheMutex;