### Example Dual-Monitor Configuration

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

A sample XML configuration for a dual-monitor setup, specifying monitor count, GPU, global refresh rates, resolutions, and advanced options.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <monitors>
        <count>2</count>
    </monitors>
    <gpu>
        <friendlyname>NVIDIA RTX 3060</friendlyname>
    </gpu>
    <global>
        <g_refresh_rate>60</g_refresh_rate>
        <g_refresh_rate>120</g_refresh_rate>
    </global>
    <resolutions>
        <resolution>
            <width>1920</width>
            <height>1080</height>
            <refresh_rate>60</refresh_rate>
        </resolution>
        <resolution>
            <width>2560</width>
            <height>1440</height>
            <refresh_rate>120</refresh_rate>
        </resolution>
    </resolutions>
    <options>
        <CustomEdid>false</CustomEdid>
        <PreventSpoof>true</PreventSpoof>
        <EdidCeaOverride>true</EdidCeaOverride>
        <HardwareCursor>true</HardwareCursor>
        <SDR10bit>true</SDR10bit>
        <HDRPlus>false</HDRPlus>
        <logging>true</logging>
        <debuglogging>false</debuglogging>
    </options>
</vdd_settings>
```

--------------------------------

### Complete Multi-Monitor Configuration Example

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Full XML configuration for a dual-monitor HDR streaming setup. Adjust monitor count, GPU, refresh rates, resolutions, logging, color settings, cursor properties, EDID, and HDR advanced metadata.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <monitors>
        <count>2</count>
    </monitors>

    <gpu>
        <friendlyname>NVIDIA GeForce RTX 3060</friendlyname>
    </gpu>

    <global>
        <g_refresh_rate>60</g_refresh_rate>
        <g_refresh_rate>120</g_refresh_rate>
        <g_refresh_rate>144</g_refresh_rate>
    </global>

    <resolutions>
        <resolution>
            <width>1920</width>
            <height>1080</height>
            <refresh_rate>144</refresh_rate>
        </resolution>
        <resolution>
            <width>2560</width>
            <height>1440</height>
            <refresh_rate>120</refresh_rate>
        </resolution>
        <resolution>
            <width>3840</width>
            <height>2160</height>
            <refresh_rate>60</refresh_rate>
        </resolution>
    </resolutions>

    <logging>
        <SendLogsThroughPipe>true</SendLogsThroughPipe>
        <logging>true</logging>
        <debuglogging>false</debuglogging>
    </logging>

    <colour>
        <SDR10bit>false</SDR10bit>
        <HDRPlus>true</HDRPlus>
        <ColourFormat>RGB</ColourFormat>
    </colour>

    <cursor>
        <HardwareCursor>true</HardwareCursor>
        <CursorMaxX>128</CursorMaxX>
        <CursorMaxY>128</CursorMaxY>
        <AlphaCursorSupport>true</AlphaCursorSupport>
    </cursor>

    <edid>
        <CustomEdid>false</CustomEdid>
        <PreventSpoof>false</PreventSpoof>
        <EdidCeaOverride>true</EdidCeaOverride>
    </edid>

    <hdr_advanced>
        <hdr10_static_metadata>
            <enabled>true</enabled>
            <max_display_mastering_luminance>1000.0</max_display_mastering_luminance>
            <min_display_mastering_luminance>0.05</min_display_mastering_luminance>
            <max_content_light_level>1000</max_content_light_level>
            <max_frame_avg_light_level>400</max_frame_avg_light_level>
        </hdr10_static_metadata>
    </hdr_advanced>
</vdd_settings>
```

--------------------------------

### Example GPU Configuration with Friendly Name

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

An example of how to specify a particular GPU using its friendly name in the XML configuration.

```xml
<gpu>
    <friendlyname>NVIDIA GeForce RTX 2060</friendlyname>
</gpu>
```

--------------------------------

### Example XML Structure for vdd_settings

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

This is the basic structure of the vdd_settings XML file, outlining the main configuration sections.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <monitors>...</monitors>
    <gpu>...</gpu>
    <global>...</global>
    <resolutions>...</resolutions>
    <options>...</options>
</vdd_settings>
```

--------------------------------

### Install Virtual Display Driver via Winget

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Use this command to install the Virtual Display Driver using the Windows Package Manager. Ensure Winget is available on your system.

```powershell
# Install Virtual Display Driver via winget
winget install --id=VirtualDrivers.Virtual-Display-Driver -e
```

--------------------------------

### Set Virtual Display as Primary

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configures the virtual display as the primary monitor in Windows. This is useful for headless streaming setups, VR, and remote desktop sessions. The script requires administrator privileges and installs necessary dependencies.

```powershell
# primary-VDD.ps1 - Set VDD as primary display
# Self-elevate if required
if (-Not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator')) {
    $CommandLine = "-File `" + $MyInvocation.MyCommand.Path + " `" " + $MyInvocation.UnboundArguments
    Start-Process -FilePath PowerShell.exe -Verb Runas -ArgumentList $CommandLine
    Exit
}

# Install dependencies if required
. "$PSScriptRoot\set-dependencies.ps1"

# Set VDD as the primary display
$disp = Get-DisplayInfo | Where-Object { $_.DisplayName -eq "VDD by MTT" }
Set-DisplayPrimary -DisplayId $disp.DisplayId

# This is essential for:
# - Headless server streaming via Sunshine/Parsec
# - VR desktop streaming to Oculus/SteamVR
# - Remote desktop sessions requiring primary display
```

--------------------------------

### Silent Installation of Virtual Display Driver

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Automated PowerShell script for silent installation of the signed driver. It downloads and extracts necessary components, installs certificates, and uses NefCon to install the driver. Run this script with Administrator rights.

```powershell
# silent-install.ps1 - Run in PowerShell with Administrator rights
[CmdletBinding()]
param(
    [Parameter(Mandatory=$false)]
    [string]$NefConURL = "https://github.com/nefarius/nefcon/releases/download/v1.14.0/nefcon_v1.14.0.zip",

    [Parameter(Mandatory=$false)]
    [string]$DriverURL = "https://github.com/VirtualDrivers/Virtual-Display-Driver/releases/download/25.7.23/VirtualDisplayDriver-x86.Driver.Only.zip"
)

# Create temp directory
$tempDir = Join-Path $env:TEMP "VDDInstall"
New-Item -ItemType Directory -Path $tempDir -Force | Out-Null

# Download and extract NefCon installer utility
Write-Host "Downloading and extracting NefCon..." -ForegroundColor Cyan
$NefConZipPath = Join-Path $tempDir "nefcon.zip"
Invoke-WebRequest -Uri $NefConURL -OutFile $NefConZipPath -UseBasicParsing
Expand-Archive -Path $NefConZipPath -DestinationPath $tempDir -Force
$NefConExe = Join-Path $tempDir "x64\nefconw.exe"

# Download and extract VDD driver
Write-Host "Downloading and extracting VDD..." -ForegroundColor Cyan
$driverZipPath = Join-Path $tempDir 'driver.zip'
Invoke-WebRequest -Uri $DriverURL -OutFile $driverZipPath
Expand-Archive -Path $driverZipPath -DestinationPath $tempDir -Force

# Extract and install SignPath certificates from catalog file
$catFile = Join-Path $tempDir 'VirtualDisplayDriver\mttvdd.cat'
$catBytes = [System.IO.File]::ReadAllBytes($catFile)
$certificates = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2Collection
$certificates.Import($catBytes)

$certsFolder = Join-Path $tempDir "ExportedCerts"
New-Item -ItemType Directory -Path $certsFolder -Force | Out-Null

foreach ($cert in $certificates) {
    $certFilePath = Join-Path -Path $certsFolder -ChildPath "$($cert.Thumbprint).cer"
    $cert.Export([System.Security.Cryptography.X509Certificates.X509ContentType]::Cert) | Set-Content -Path $certFilePath -Encoding Byte
    Import-Certificate -FilePath $certFilePath -CertStoreLocation "Cert:\LocalMachine\TrustedPublisher"
}

# Install VDD using NefCon
Write-Host "Installing Virtual Display Driver silently..." -ForegroundColor Cyan
Push-Location $tempDir
& $NefConExe install .\VirtualDisplayDriver\MttVDD.inf "Root\MttVDD"
Start-Sleep -Seconds 10
Pop-Location

Write-Host "Driver installation completed." -ForegroundColor Green
Remove-Item -Path $tempDir -Recurse -Force -ErrorAction SilentlyContinue
```

--------------------------------

### Manage Virtual Display Driver Lifecycle

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Comprehensive PowerShell script for managing the complete driver lifecycle including install, uninstall, enable, disable, toggle, and status operations. Use the -Json parameter for automated status checks.

```powershell
# virtual-driver-manager.ps1 usage examples

# Interactive mode - prompts for action selection
.\virtual-driver-manager.ps1

# Install the latest driver version
.\virtual-driver-manager.ps1 -Action install

# Install a specific driver version
.\virtual-driver-manager.ps1 -Action install -DriverVersion "25.7.22"

# Uninstall the driver silently (window closes automatically)
.\virtual-driver-manager.ps1 -Action uninstall -Silent

# Check driver status with JSON output for automation
powershell.exe -ExecutionPolicy Bypass -File .\virtual-driver-manager.ps1 -Action status -Json
# Output: {"installed":true,"status":"enabled","details":{"friendlyName":"Virtual Display Driver","instanceId":"ROOT\MTTVDD\0000"}}

# Enable the driver
.\virtual-driver-manager.ps1 -Action enable -Silent

# Disable the driver
.\virtual-driver-manager.ps1 -Action disable -Silent
```

--------------------------------

### Query IddCx Version Compatibility

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Utility to query the installed IddCx version and check feature support against Windows versions. Lists requirements for HDR10, GPU Priority, Precise Present Regions, and System Memory SwapChain.

```powershell
# Query IddCx version using included utility
& "C:\VirtualDisplayDriver\GetIddCx\IddCxVersionQuery.exe"
```

```powershell
# IddCx Version Requirements:
# 1.10 (0x1A00+) - HDR10, SDR Wide Color Gamut - Windows 11 23H2+
# 1.9  (0x1900)  - GPU Priority - Windows 11 22H2
# 1.8  (0x1800)  - Precise Present Regions - Windows 11 21H2
# 1.5  (0x1500)  - System Memory SwapChain - Windows 10 20H1+

# Feature availability by Windows version:
# Windows 11 24H2 (Build 26100): Full HDR support, 8/10/12-bit
# Windows 11 23H2 (Build 22631): HDR10 support, 8/10/12-bit
# Windows 11 22H2 (Build 22621): SDR only, 8/10-bit
# Windows 10 (All versions):     SDR only, 8-bit
```

--------------------------------

### Get Color Profile

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Retrieves the color profile information for the display, including the primary colorspace, gamma, and chromaticity coordinates.

```cpp
const ColorProfile& get_color_profile() const {
        return color_profile;
    }
```

--------------------------------

### Get Video Modes as Tuples

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Converts a list of VideoMode objects into a vector of tuples, each containing resolution, color depth, and refresh rate. This format is useful for returning display modes.

```cpp
std::vector<std::tuple<int, int, int, int>> get_video_modes() const {
        std::vector<std::tuple<int, int, int, int>> modes;
        for (const auto& mode : video_modes) {
            modes.emplace_back(mode.x, mode.y, mode.Z, mode.refresh);
        }
        return modes;
    }
```

--------------------------------

### Get HDR Metadata

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Returns the HDR metadata associated with the display. This includes information about HDR10, Dolby Vision, and HDR10+ support, as well as luminance values.

```cpp
const HDRMetadata& get_hdr_metadata() const {
        return hdr_metadata;
    }
```

--------------------------------

### Main Function for EDID Parser Usage

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

This is the main entry point for the EDID parser application. It handles command-line arguments, loads EDID data from a specified file, parses it, prints a summary, generates an IDDCX profile, and saves it to a file. Ensure the correct path to the EDID binary file is provided as a command-line argument.

```cpp
int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " <edid.bin>" << std::endl;
        return 1;
    }
    
    EDIDParser parser;
    
    if (!parser.load_edid_file(argv[1])) {
        return 1;
    }
    
    parser.parse_edid();
    
    // Get video modes as requested tuple format
    auto modes = parser.get_video_modes();
    
    std::cout << "Video modes in tuple format {x, y, Z, refresh}:" << std::endl;
    for (const auto& mode : modes) {
        std::cout << "{" << std::get<0>(mode) << ", " << std::get<1>(mode) 
                  << ", " << std::get<2>(mode) << ", " << std::get<3>(mode) << "}" << std::endl;
    }
    
    std::cout << std::endl;
    parser.print_summary();
    
    // Generate IDDCX profile
    std::cout << "\n=== IDDCX Profile ===" << std::endl;
    std::cout << parser.generate_iddcx_profile() << std::endl;
    
    // Save profile to file
    std::ofstream profile_file("monitor_profile.xml");
    if (profile_file.is_open()) {
        profile_file << parser.generate_iddcx_profile();
        profile_file.close();
        std::cout << "\nIDDCX profile saved to monitor_profile.xml" << std::endl;
    }
    
    return 0;
}

```

--------------------------------

### Basic Driver Settings

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configure the number of virtual monitors, GPU selection, and global/custom resolutions and refresh rates. Ensure the 'count' is between 1 and 8.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- Number of virtual monitors to create (1-8) -->
    <monitors>
        <count>1</count>
    </monitors>

    <!-- GPU selection - use "default" or specific GPU friendly name -->
    <gpu>
        <friendlyname>default</friendlyname>
        <!-- Example: <friendlyname>NVIDIA GeForce RTX 3060</friendlyname> -->
    </gpu>

    <!-- Global refresh rates applied to ALL resolutions -->
    <global>
        <g_refresh_rate>60</g_refresh_rate>
        <g_refresh_rate>90</g_refresh_rate>
        <g_refresh_rate>120</g_refresh_rate>
        <g_refresh_rate>144</g_refresh_rate>
        <g_refresh_rate>165</g_refresh_rate>
        <g_refresh_rate>240</g_refresh_rate>
    </global>

    <!-- Custom resolutions with specific refresh rates -->
    <resolutions>
        <resolution>
            <width>1920</width>
            <height>1080</height>
            <refresh_rate>60</refresh_rate>
        </resolution>
        <resolution>
            <width>2560</width>
            <height>1440</height>
            <refresh_rate>144</refresh_rate>
        </resolution>
        <resolution>
            <width>3840</width>
            <height>2160</height>
            <refresh_rate>60</refresh_rate>
        </resolution>
    </resolutions>
</vdd_settings>
```

--------------------------------

### XML Configuration for Custom EDID

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configure custom EDID profiles to emulate specific monitor characteristics. Ensure 'user_edid.bin' is in the driver directory.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- ... other settings ... -->

    <edid>
        <!-- Enable custom EDID - requires user_edid.bin in driver directory -->
        <CustomEdid>true</CustomEdid>

        <!-- Prevent manufacturer spoofing (for Windows color profile downloads) -->
        <PreventSpoof>false</PreventSpoof>

        <!-- Override EDID CEA extension block for HDR on unsupported EDIDs -->
        <EdidCeaOverride>false</EdidCeaOverride>
    </edid>

    <!-- EDID integration system for automatic configuration -->
    <edid_integration>
        <enabled>true</enabled>
        <auto_configure_from_edid>true</auto_configure_from_edid>
        <edid_profile_path>EDID/monitor_profile.xml</edid_profile_path>
        <override_manual_settings>false</override_manual_settings>
        <fallback_on_error>true</fallback_on_error>
    </edid_integration>
</vdd_settings>
```

--------------------------------

### Add Certificate to Trusted Root Store

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/Build-your-own-version-of-VDD

Import the generated test certificate into the local machine's trusted root certificate store to allow the driver to be trusted.

```bash
CertMgr /add LocalVDD.cer /s /r localMachine root
```

--------------------------------

### Create Test Certificate with MakeCert

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/Build-your-own-version-of-VDD

Use MakeCert to generate a self-signed certificate for driver testing. Ensure MakeCert is in your system's PATH or use the full executable path.

```bash
"C:\Program Files (x86)\Windows Kits\10\bin\10.0.26100.0\x64\MakeCert" -r -pe -ss PrivateCertStore -n CN=LocalVDD(Test) LocalVDD.cer
```

--------------------------------

### Registry Overrides for Virtual Display Driver

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configure driver settings via Windows Registry. Registry settings take priority over XML configuration.

```powershell
# Registry path: HKEY_LOCAL_MACHINE\SOFTWARE\MikeTheTech\VirtualDisplayDriver

# Create registry keys if they don't exist
$regPath = "HKLM:\SOFTWARE\MikeTheTech\VirtualDisplayDriver"
if (-not (Test-Path $regPath)) {
    New-Item -Path $regPath -Force
}

# Enable logging (DWORD: 1 = enabled, 0 = disabled)
Set-ItemProperty -Path $regPath -Name "LOGS" -Value 1 -Type DWord

# Enable debug logging
Set-ItemProperty -Path $regPath -Name "DEBUGLOGS" -Value 1 -Type DWord

# Enable HDR Plus (12-bit HDR)
Set-ItemProperty -Path $regPath -Name "HDRPLUS" -Value 1 -Type DWord

# Enable SDR 10-bit
Set-ItemProperty -Path $regPath -Name "SDR10BIT" -Value 1 -Type DWord

# Enable custom EDID
Set-ItemProperty -Path $regPath -Name "CUSTOMEDID" -Value 1 -Type DWord

# Enable hardware cursor
Set-ItemProperty -Path $regPath -Name "HARDWARECURSOR" -Value 1 -Type DWord

# Prevent monitor spoofing
Set-ItemProperty -Path $regPath -Name "PREVENTMONITORSPOOF" -Value 1 -Type DWord

# Enable EDID CEA override
Set-ItemProperty -Path $regPath -Name "EDIDCEAOVERRIDE" -Value 1 -Type DWord

# Set custom configuration directory path
Set-ItemProperty -Path $regPath -Name "VDDPATH" -Value "D:\\DriverConfig" -Type String

# Registry settings take priority over XML configuration
# If registry value is 0, driver falls back to XML settings

```

--------------------------------

### Parse CEA Extension Block

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Parses a CEA extension block from EDID data. It checks for the correct block type and revision, and prints debugging information including the DTD start offset and the data block collection.

```cpp
void parse_cea_extension(const uint8_t* cea_block) {
        if (cea_block[0] != 0x02) return; // Not a CEA extension
        
        uint8_t dtd_start = cea_block[2];
        if (dtd_start < 4) return;
        
        std::cout << "=== CEA Extension Block Debug ===" << std::endl;
        std::cout << "CEA revision: " << (int)cea_block[1] << std::endl;
        std::cout << "DTD start offset: " << (int)dtd_start << std::endl;
        
        // Dump the entire data block collection for debugging
        std::cout << "Data block collection bytes (" << (dtd_start - 4) << " bytes): ";
        for (uint8_t i = 4; i < dtd_start; i++) {

```

--------------------------------

### Enable Test Signing

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual-Audio-Driver (Latest Stable)/README.md

Use this command to enable test signing mode on Windows. This is optional and may be required if you are using a test-signed driver.

```powershell
bcdedit /set testsigning on
```

--------------------------------

### Change Virtual Display Refresh Rate

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Dynamically changes the refresh rate of the virtual display driver. It supports a predefined set of refresh rates from 30Hz to 500Hz. The script requires administrator privileges and installs necessary dependencies.

```powershell
# refreshrate-VDD.ps1 - Change refresh rate
param(
    [Parameter(Mandatory, Position = 0)]
    [ValidateSet(30, 60, 75, 90, 120, 144, 165, 240, 480, 500)]
    [int]$refreshrate
)

# Self-elevate if required
if (-Not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator')) {
    $CommandLine = "-File `" + $MyInvocation.MyCommand.Path + " `" "
    $MyInvocation.BoundParameters.GetEnumerator() | ForEach-Object { $CommandLine += "-$($_.Key):$($_.Value) " }
    Start-Process -WorkingDirectory $PSScriptRoot -FilePath PowerShell.exe -Verb Runas -ArgumentList $CommandLine
    exit
}

# Install dependencies if required
. "$PSScriptRoot\set-dependencies.ps1"

# Get the VDD display and set refresh rate
$disp = Get-DisplayInfo | Where-Object { $_.DisplayName -eq "VDD by MTT" }
Set-DisplayRefreshRate -DisplayId $disp.DisplayId -RefreshRate $refreshrate

# Usage examples:
# .\refreshrate-VDD.ps1 60     # Set to 60Hz
# .\refreshrate-VDD.ps1 144    # Set to 144Hz for gaming
# .\refreshrate-VDD.ps1 240    # Set to 240Hz for high refresh streaming
```

--------------------------------

### Logging Configuration

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Enable or disable logging features for troubleshooting. Basic logging tracks driver activity, while debug logging provides more detailed information but can create large files.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- ... other settings ... -->

    <logging>
        <!-- Enable pipe communication with companion app -->
        <SendLogsThroughPipe>true</SendLogsThroughPipe>

        <!-- Basic logging - monitor driver activity, GPU selection, IddCx version -->
        <logging>true</logging>

        <!-- Debug logging - detailed logs, WARNING: creates large files -->
        <debuglogging>false</debuglogging>
    </logging>
</vdd_settings>
```

--------------------------------

### Change Virtual Display Resolution

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Dynamically changes the resolution of the virtual display driver without requiring a restart. This script requires administrator privileges and installs necessary dependencies. It identifies the VDD display and sets the specified width and height.

```powershell
# changeres-VDD.ps1 - Change resolution dynamically
param(
    [Parameter(Mandatory, Position=0)]
    [Alias("X","HorizontalResolution")]
    [int]$xres,

    [Parameter(Mandatory, Position=1)]
    [Alias("Y","VerticalResolution")]
    [int]$yres
)

# Self-elevate if required
if (-Not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator')) {
    $CommandLine = "-File `" + $MyInvocation.MyCommand.Path + " `" "
    $MyInvocation.BoundParameters.GetEnumerator() | ForEach-Object { $CommandLine += "-$($_.Key):$($_.Value) " }
    Start-Process -WorkingDirectory $PSScriptRoot -FilePath PowerShell.exe -Verb Runas -ArgumentList $CommandLine
    exit
}

# Install dependencies if required
. "$PSScriptRoot\set-dependencies.ps1"

# Get the VDD display and set resolution
$disp = Get-DisplayInfo | Where-Object { $_.DisplayName -eq "VDD by MTT" }
Set-DisplayResolution -DisplayId $disp.DisplayId -Width $xres -Height $yres

# Usage examples:
# .\changeres-VDD.ps1 1920 1080    # Set to 1080p
# .\changeres-VDD.ps1 2560 1440    # Set to 1440p
# .\changeres-VDD.ps1 3840 2160    # Set to 4K
```

--------------------------------

### Configure Global Refresh Rates

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

Sets global refresh rates that will be available across all resolutions. Add or modify '<g_refresh_rate>' tags to specify supported refresh rates in Hz.

```xml
<global>
    <g_refresh_rate>60</g_refresh_rate>
    <g_refresh_rate>90</g_refresh_rate>
    <g_refresh_rate>120</g_refresh_rate>
</global>
```

--------------------------------

### Print EDID Parser Summary to Console

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

This method prints a detailed summary of the parsed EDID information to the standard output. It includes the number of video modes found, HDR support status, luminance values, and color profile details. This is useful for debugging and verifying parsed data.

```cpp
void print_summary() const {
        std::cout << "=== EDID Parser Results ===" << std::endl;
        std::cout << "Video Modes Found: " << video_modes.size() << std::endl;
        
        for (const auto& mode : video_modes) {
            double actual_refresh = (mode.Z * mode.refresh) / 1000.0;
            std::cout << "  " << mode.x << "x" << mode.y << "@" 
                      << std::fixed << std::setprecision(2) << actual_refresh << "Hz"
                      << " (Z=" << mode.Z << ", nominal=" << mode.refresh << "Hz)" << std::endl;
        }
        
        std::cout << "\nHDR Support:" << std::endl;
        std::cout << "  HDR10: " << (hdr_metadata.hdr10_supported ? "Yes" : "No") << std::endl;
        std::cout << "  Dolby Vision: " << (hdr_metadata.dolby_vision_supported ? "Yes" : "No") << std::endl;
        std::cout << "  HDR10+: " << (hdr_metadata.hdr10_plus_supported ? "Yes" : "No") << std::endl;
        
        if (hdr_metadata.max_luminance > 0) {
            std::cout << "  Max Luminance: " << hdr_metadata.max_luminance << " nits" << std::endl;
        }
        if (hdr_metadata.min_luminance > 0) {
            std::cout << "  Min Luminance: " << hdr_metadata.min_luminance << " nits" << std::endl;
        }
        
        std::cout << "\nColor Profile:" << std::endl;
        std::string colorspace_name;
        switch (color_profile.primary_colorspace) {
            case ColorProfile::sRGB:
            case ColorProfile::Rec709:
                colorspace_name = "sRGB/Rec.709";
                break;
            case ColorProfile::Rec2020:
                colorspace_name = "Rec.2020";
                break;
            case ColorProfile::DCI_P3:
                colorspace_name = "DCI-P3";
                break;
            case ColorProfile::Adobe_RGB:
                colorspace_name = "Adobe RGB";
                break;
            default:
                colorspace_name = "Unknown";
                break;
        }
        std::cout << "  Primary Colorspace: " << colorspace_name << std::endl;
        std::cout << "  Gamma: " << color_profile.gamma << std::endl;
        std::cout << "  Chromaticity - Red: (" << std::fixed << std::setprecision(3) 
                  << color_profile.red_x << ", " << color_profile.red_y << ")" << std::endl;
        std::cout << "  Chromaticity - Green: (" << color_profile.green_x << ", " << color_profile.green_y << ")" << std::endl;
        std::cout << "  Chromaticity - Blue: (" << color_profile.blue_x << ", " << color_profile.blue_y << ")" << std::endl;
        std::cout << "  Chromaticity - White: (" << color_profile.white_x << ", " << color_profile.white_y << ")" << std::endl;
    }

```

--------------------------------

### Configure Monitor Count

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

Defines the total number of virtual monitors to be created by the driver. Set the 'count' tag to the desired number of monitors.

```xml
<monitors>
    <count>1</count>
</monitors>
```

--------------------------------

### Define Specific Resolutions and Refresh Rates

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

Lists specific display resolutions and their corresponding refresh rates. Each '<resolution>' block defines width, height, and refresh rate in Hz.

```xml
<resolutions>
    <resolution>
        <width>1920</width>
        <height>1080</height>
        <refresh_rate>30</refresh_rate>
    </resolution>
    ...
</resolutions>
```

--------------------------------

### XML Configuration for Auto Resolution System

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Automatically generate display modes from EDID data. Configure resolution filtering and preferred mode settings.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- ... other settings ... -->

    <auto_resolutions>
        <enabled>true</enabled>
        <!-- Priority: "manual", "edid", or "combined" -->
        <source_priority>combined</source_priority>

        <edid_mode_filtering>
            <min_refresh_rate>24</min_refresh_rate>
            <max_refresh_rate>240</max_refresh_rate>
            <exclude_fractional_rates>false</exclude_fractional_rates>
            <min_resolution_width>640</min_resolution_width>
            <min_resolution_height>480</min_resolution_height>
            <max_resolution_width>7680</max_resolution_width>
            <max_resolution_height>4320</max_resolution_height>
        </edid_mode_filtering>

        <preferred_mode>
            <use_edid_preferred>true</use_edid_preferred>
            <fallback_width>1920</fallback_width>
            <fallback_height>1080</fallback_height>
            <fallback_refresh>60</fallback_refresh>
        </preferred_mode>
    </auto_resolutions>
</vdd_settings>
```

--------------------------------

### Driver Options Configuration

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

Defines advanced settings for the virtual display driver's behavior. Ensure correct values are set for your specific display and streaming needs.

```xml
<options>
    <CustomEdid>false</CustomEdid>
    <PreventSpoof>false</PreventSpoof>
    <EdidCeaOverride>false</EdidCeaOverride>
    <HardwareCursor>true</HardwareCursor>
    <SDR10bit>false</SDR10bit>
    <HDRPlus>false</HDRPlus>
    <logging>false</logging>
    <debuglogging>false</debuglogging>
</options>
```

--------------------------------

### Parse HDR Dynamic Metadata

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Initializes parsing for HDR dynamic metadata. Checks for minimum length of 1 byte. Further processing depends on the 'type_support' byte.

```cpp
    void parse_hdr_dynamic_metadata(const uint8_t* hdr_data, uint8_t length) {
        std::cout << "      HDR Dynamic Metadata parsing:" << std::endl;
        std::cout << "      Length: " << (int)length << " bytes" << std::endl;
        
        if (length < 1) {
            std::cout << "      ERROR: HDR Dynamic Metadata too short!" << std::endl;
            return;
        }
        
        uint8_t type_support = hdr_data[0];
        
```

--------------------------------

### Cursor Settings

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configure hardware cursor settings to prevent double cursor issues in streaming applications. Options include enabling hardware cursor, setting maximum dimensions, and configuring alpha transparency and XOR cursor support.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- ... other settings ... -->

    <cursor>
        <!-- Enable hardware cursor for streaming (prevents double cursor) -->
        <HardwareCursor>true</HardwareCursor>

        <!-- Maximum cursor dimensions -->
        <CursorMaxX>128</CursorMaxX>
        <CursorMaxY>128</CursorMaxY>

        <!-- Enable alpha transparency for cursors -->
        <AlphaCursorSupport>true</AlphaCursorSupport>

        <!-- XOR cursor support level (0-2) -->
        <XorCursorSupportLevel>2</XorCursorSupportLevel>
    </cursor>
</vdd_settings>
```

--------------------------------

### Load EDID File into Memory

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

Loads the content of an EDID file into a byte vector. Ensures the file can be opened and reads its entire content. Handles file opening errors and checks for minimum file size.

```cpp
bool load_edid_file(const std::string& filename) {
        std::ifstream file(filename, std::ios::binary);
        if (!file.is_open()) {
            std::cerr << "Error: Cannot open file " << filename << std::endl;
            return false;
        }
        
        file.seekg(0, std::ios::end);
        size_t file_size = file.tellg();
        file.seekg(0, std::ios::beg);
        
        edid_data.resize(file_size);
        file.read(reinterpret_cast<char*>(edid_data.data()), file_size);
        
        if (file_size < 128) {
            std::cerr << "Error: EDID file too small" << std::endl;
            return false;
        }
        
        return true;
    }
```

--------------------------------

### Generate IDDCX Monitor Configuration Profile

Source: https://github.com/virtualdrivers/virtual-display-driver/blob/master/Virtual Display Driver (HDR)/EDID/edid_parser.txt

This function generates an XML string representing the monitor configuration for IDDCX. It includes details like color profile, preferred mode, and other display characteristics. Ensure all necessary data members are populated before calling.

```cpp
std::string generate_iddcx_profile() const {
        std::stringstream profile;
        profile << "<IddCxMonitorConfig>";
        
        // Color Profile
        profile << "  <ColorProfile>";
        profile << "    <PrimaryColorspace>";
        switch (color_profile.primary_colorspace) {
            case ColorProfile::sRGB:
            case ColorProfile::Rec709:
                profile << "sRGB/Rec.709";
                break;
            case ColorProfile::Rec2020:
                profile << "Rec.2020";
                break;
            case ColorProfile::DCI_P3:
                profile << "DCI-P3";
                break;
            case ColorProfile::Adobe_RGB:
                profile << "Adobe RGB";
                break;
            default:
                profile << "Unknown";
                break;
        }
        profile << "</PrimaryColorspace>";
        profile << "    <Gamma>" << color_profile.gamma << "</Gamma>";
        
        // Chromaticity
        profile << "    <Chromaticity>";
        profile << "      <RedX>" << color_profile.red_x << "</RedX>";
        profile << "      <RedY>" << color_profile.red_y << "</RedY>";
        profile << "      <GreenX>" << color_profile.green_x << "</GreenX>";
        profile << "      <GreenY>" << color_profile.green_y << "</GreenY>";
        profile << "      <BlueX>" << color_profile.blue_x << "</BlueX>";
        profile << "      <BlueY>" << color_profile.blue_y << "</BlueY>";

```

--------------------------------

### Specify GPU Friendly Name

Source: https://github.com/virtualdrivers/virtual-display-driver/wiki/How-to-configure-the-driver

Configures the GPU that the virtual display driver will use. The 'friendlyname' tag should contain the exact name of the GPU as it appears in Device Manager.

```xml
<gpu>
    <friendlyname>default</friendlyname>
</gpu>
```

--------------------------------

### Color and HDR Settings

Source: https://context7.com/virtualdrivers/virtual-display-driver/llms.txt

Configure color depth, HDR support, and color formats. Supports SDR 10-bit, HDR10+ 12-bit, and custom color formats. Advanced HDR10 static metadata and custom color primaries are available for Windows 11 23H2+.

```xml
<?xml version='1.0' encoding='utf-8'?>
<vdd_settings>
    <!-- ... other settings ... -->

    <!-- Color format configuration -->
    <colour>
        <!-- Enable 10-bit SDR (disables HDRPlus) -->
        <SDR10bit>false</SDR10bit>

        <!-- Enable HDR10+ 12-bit mode (cannot be used with SDR10bit) -->
        <HDRPlus>false</HDRPlus>

        <!-- Color format: RGB, YCbCr444, YCbCr422, YCbCr420 -->
        <ColourFormat>RGB</ColourFormat>
    </colour>

    <!-- Advanced HDR10 static metadata (Windows 11 23H2+ required) -->
    <hdr_advanced>
        <hdr10_static_metadata>
            <enabled>true</enabled>
            <max_display_mastering_luminance>1000.0</max_display_mastering_luminance>
            <min_display_mastering_luminance>0.05</min_display_mastering_luminance>
            <max_content_light_level>1000</max_content_light_level>
            <max_frame_avg_light_level>400</max_frame_avg_light_level>
        </hdr10_static_metadata>

        <!-- Custom color primaries for advanced color accuracy -->
        <color_primaries>
            <enabled>false</enabled>
            <red_x>0.640</red_x>
            <red_y>0.330</red_y>
            <green_x>0.300</green_x>
            <green_y>0.600</green_y>
            <blue_x>0.150</blue_x>
            <blue_y>0.060</blue_y>
            <white_x>0.3127</white_x>  <!-- D65 white point -->
            <white_y>0.3290</white_y>
        </color_primaries>
    </hdr_advanced>

    <!-- Advanced color processing -->
    <color_advanced>
        <bit_depth_management>
            <auto_select_from_color_space>false</auto_select_from_color_space>
            <force_bit_depth>8</force_bit_depth>  <!-- 8, 10, or 12 -->
            <fp16_surface_support>true</fp16_surface_support>
        </bit_depth_management>
        <color_format_extended>
            <sdr_white_level>80.0</sdr_white_level>
        </color_format_extended>
    </color_advanced>
</vdd_settings>
```