discstation 0.1.18 → 0.1.21

package/src/win/audio-toc.ps1

@@ -0,0 +1,43 @@
+# Read an audio CD's table of contents via IMAPI2 raw reader. Emits JSON:
+#   {"track_count":N,"leadout":L,"tracks":[o1,o2,...]}   (frame offsets, +150)
+# Usage: audio-toc.ps1 <drive e.g. D:>
+param([Parameter(Mandatory = $true)] [string] $Drive)
+
+$ErrorActionPreference = "Stop"
+. (Join-Path $PSScriptRoot "_json.ps1")
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec } }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$raw = New-Object -ComObject "IMAPI2.MsftDiscFormat2RawCD"
+$raw.Recorder = $rec
+$raw.ClientName = "DiscStation"
+
+$toc = $raw.ReadDiscInformation()   # not always present; fall through to raw TOC
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+$fmt.Recorder = $rec
+
+# MsftDiscFormat2RawCD.get_TocInformation() -> byte array of the raw TOC (MMC-3).
+$bytes = $raw.ReadTocInformation()
+# TOC header: [0..1]=data length, [2]=first track, [3]=last track.
+$first = $bytes[2]; $last = $bytes[3]
+$offsets = @()
+$leadout = 0
+for ($i = 4; $i + 7 -lt $bytes.Length; $i += 8) {
+    $trk = $bytes[$i + 2]
+    # LBA is big-endian in bytes [i+4..i+7]
+    $lba = ($bytes[$i+4] -shl 24) -bor ($bytes[$i+5] -shl 16) -bor ($bytes[$i+6] -shl 8) -bor $bytes[$i+7]
+    if ($trk -eq 0xAA) { $leadout = $lba + 150 }
+    elseif ($trk -ge $first -and $trk -le $last) { $offsets += ($lba + 150) }
+}
+if ($offsets.Count -eq 0) { Write-Error "no audio tracks in TOC"; exit 2 }
+
+Write-Output (ConvertTo-JsonCompat @{ track_count = $offsets.Count; leadout = $leadout; tracks = $offsets })

package/src/win/burn-audio.ps1

@@ -0,0 +1,87 @@
+# Burn an audio CD (Red Book) from a folder of 16-bit / 44.1 kHz stereo WAV
+# files via IMAPI2 Track-At-Once. Streams "PROGRESS:<pct>".
+# Usage: burn-audio.ps1 <drive e.g. D:> <wav folder> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $WavDir,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+$wavs = @(Get-ChildItem -LiteralPath $WavDir -Filter *.wav | Sort-Object Name)
+if ($wavs.Count -eq 0) { Write-Error "no WAV files in $WavDir"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2TrackAtOnce"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+try { $fmt.NumberOfExistingTracks } catch {}
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+$prepared = @()
+foreach ($w in $wavs) {
+    # IMAPI2 wants raw 44100/16/2 PCM. Strip the 44-byte WAV header.
+    $bytes = [System.IO.File]::ReadAllBytes($w.FullName)
+    $offset = 44
+    $idx = -1
+    for ($i = 12; $i -lt [Math]::Min($bytes.Length - 8, 4096); $i++) {
+        if ($bytes[$i] -eq 0x64 -and $bytes[$i+1] -eq 0x61 -and $bytes[$i+2] -eq 0x74 -and $bytes[$i+3] -eq 0x61) {
+            $offset = $i + 8; break
+        }
+    }
+    $rawLen = $bytes.Length - $offset
+    # Red Book requires each track's byte length to be an exact multiple of
+    # the 2352-byte CD-DA sector - real-world track lengths essentially
+    # never land on that boundary naturally. AddAudioTrack rejects anything
+    # else outright ("The provided audio stream is not valid."). Pad with
+    # silence up to the next sector boundary (and up to the 4-second/
+    # 300-sector minimum a track must have) rather than trim real audio.
+    $sectorSize = 2352
+    $minLen = 300 * $sectorSize
+    $paddedLen = [Math]::Ceiling([Math]::Max($rawLen, $minLen) / $sectorSize) * $sectorSize
+    $raw = New-Object byte[] $paddedLen
+    [Array]::Copy($bytes, $offset, $raw, 0, $rawLen)
+    $prepared += ,@{ name = $w.Name; data = $raw }
+}
+
+$total = $prepared.Count
+$done = 0
+try {
+    # AddAudioTrack throws E_IMAPI_DF2TAO_MEDIA_IS_NOT_PREPARED ("only valid
+    # when media has been prepared") without this - PrepareMedia locks the
+    # drive for the write session, ReleaseMedia below hands it back.
+    $fmt.PrepareMedia()
+    foreach ($t in $prepared) {
+        $stream = New-Object -ComObject "ADODB.Stream"
+        $stream.Type = 1; $stream.Open()
+        $stream.Write($t.data)
+        $stream.Position = 0
+        $fmt.AddAudioTrack($stream)
+        $stream.Close()
+        $done++
+        Write-Output ("PROGRESS:" + [int]([math]::Min(99, $done * 100.0 / $total)))
+    }
+    $fmt.ReleaseMedia()
+    $fmt.Recorder.EjectMedia()
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    try { $fmt.ReleaseMedia() } catch {}
+    Write-Error ("audio burn failed: " + $_.Exception.Message)
+    exit 1
+}

package/src/win/burn-data.ps1

@@ -0,0 +1,83 @@
+# Build a data-disc filesystem image from a folder (or single file) and burn it
+# via IMAPI2 - no external mkisofs needed. Streams "PROGRESS:<pct>".
+# Usage: burn-data.ps1 <drive e.g. D:> <source folder-or-file> <label> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $Source,
+    [Parameter(Mandatory = $true)] [string] $Label,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+if (-not (Test-Path $Source)) { Write-Error "source not found: $Source"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+# Without this the disc session never finalizes - the drive reports the
+# disc as still blank afterward even though the data is physically there.
+try { $fmt.ForceMediaToBeClosed = $true } catch {}
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+# Filesystem image: ISO9660 + Joliet + UDF, sized to the loaded media.
+$fsi = New-Object -ComObject "IMAPI2FS.MsftFileSystemImage"
+try { $fsi.ChooseImageDefaultsForMediaType($fmt.CurrentPhysicalMediaType) } catch {}
+$fsi.FileSystemsToCreate = 7          # ISO9660 | Joliet | UDF
+$fsi.VolumeName = ($Label -replace '[^A-Za-z0-9_\- ]', '').Substring(0, [Math]::Min(32, ($Label -replace '[^A-Za-z0-9_\- ]', '').Length))
+$fsi.FreeMediaBlocks = -1            # -1 = use the whole disc
+
+$item = Get-Item -LiteralPath $Source
+if ($item.PSIsContainer) {
+    # AddTree's 2nd arg is IncludeBaseDirectory: $false flattens a folder
+    # child into just its contents at the disc root (dropping the folder
+    # name entirely) - wrong for VIDEO_TS/AUDIO_TS or any subfolder, which
+    # need to keep their own name. $true preserves it as a real subfolder.
+    foreach ($child in Get-ChildItem -LiteralPath $Source) { $fsi.Root.AddTree($child.FullName, $true) }
+} else {
+    $fsi.Root.AddTree($item.FullName, $false)
+}
+
+$result = $fsi.CreateResultImage()
+$stream = $result.ImageStream
+
+# Not fatal if registration fails (seen on some setups: "Cannot register
+# for the specified event... does not exist") - the burn itself doesn't
+# need it, just no live PROGRESS lines.
+try {
+    Register-ObjectEvent -InputObject $fmt -EventName "Update" -SourceIdentifier "burn" -Action {
+        $s = $EventArgs
+        try {
+            $done = [double]$s.LastWrittenLba
+            $tot  = [double]$s.SectorCount
+            if ($tot -gt 0) { Write-Output ("PROGRESS:" + [int]([math]::Min(99, $done * 100.0 / $tot))) }
+        } catch {}
+    } | Out-Null
+} catch {}
+
+try {
+    $fmt.Write($stream)
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    Write-Error ("burn failed: " + $_.Exception.Message)
+    exit 1
+} finally {
+    Unregister-Event -SourceIdentifier "burn" -ErrorAction SilentlyContinue
+    try { $rec.EjectMedia() } catch {}
+}

package/src/win/burn-image.ps1

@@ -0,0 +1,68 @@
+# Burn a pre-built ISO to the optical drive via IMAPI2. Streams "PROGRESS:<pct>"
+# lines to stdout. Usage: burn-image.ps1 <drive e.g. D:> <iso path> [speed]
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $Iso,
+    [string] $Speed = ""
+)
+
+$ErrorActionPreference = "Stop"
+if (-not (Test-Path $Iso)) { Write-Error "ISO not found: $Iso"; exit 2 }
+
+function Get-Recorder([string]$letter) {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        foreach ($p in $rec.VolumePathNames) {
+            if ($p -and $p.TrimEnd('\') -ieq $letter) { return $rec }
+        }
+    }
+    throw "No optical recorder for $letter"
+}
+
+$rec = Get-Recorder $Drive
+$fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+if (-not $fmt.IsRecorderSupported($rec)) { Write-Error "recorder not supported"; exit 3 }
+$fmt.Recorder = $rec
+$fmt.ClientName = "DiscStation"
+try { $fmt.ForceMediaToBeClosed = $true } catch {}
+if ($Speed -and $Speed -match '^\d+') {
+    try { $fmt.SetWriteSpeed([int]($Speed -replace '\D',''), $false) } catch {}
+}
+
+# Progress: IMAPI2 raises an Update event with sector counts. Not fatal if
+# registration fails (seen on some setups: "Cannot register for the
+# specified event... does not exist") - the burn itself doesn't need it,
+# just no live PROGRESS lines.
+try {
+    Register-ObjectEvent -InputObject $fmt -EventName "Update" -SourceIdentifier "burn" -Action {
+        $s = $EventArgs
+        try {
+            $done = [double]$s.LastWrittenLba
+            $tot  = [double]$s.SectorCount
+            if ($tot -gt 0) {
+                $pct = [int]([math]::Min(99, $done * 100.0 / $tot))
+                Write-Output "PROGRESS:$pct"
+            }
+        } catch {}
+    } | Out-Null
+} catch {}
+
+$stream = New-Object -ComObject "ADODB.Stream"
+$stream.Type = 1          # binary
+$stream.Open()
+$stream.LoadFromFile($Iso)
+
+try {
+    $fmt.Write($stream)
+    Write-Output "PROGRESS:100"
+    exit 0
+} catch {
+    Write-Error ("burn failed: " + $_.Exception.Message)
+    exit 1
+} finally {
+    $stream.Close()
+    Unregister-Event -SourceIdentifier "burn" -ErrorAction SilentlyContinue
+    try { $rec.EjectMedia() } catch {}
+}

package/src/win/disc-info.ps1

@@ -0,0 +1,81 @@
+# Optical drive + media state for DiscStation. Emits one JSON line.
+# Works on PowerShell 2.0 (Win7) and later. Optional arg: a drive letter ("D:")
+# to force; otherwise the first optical drive is used.
+param([string]$Drive = "")
+
+$ErrorActionPreference = "Stop"
+. (Join-Path $PSScriptRoot "_json.ps1")
+
+$out = @{ drive = ""; media_loaded = $false; blank = $false; label = "";
+          fs = ""; media_type = ""; rewritable = $false; capacity_bytes = 0 }
+
+try {
+    $cd = @(Get-WmiObject Win32_CDROMDrive)
+    if ($Drive) { $cd = @($cd | Where-Object { $_.Drive -eq $Drive }) }
+    if ($cd.Count -eq 0) { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+    $d = $cd[0]
+    $out.drive = $d.Drive
+    # NOTE: [bool]"False" is $true in PowerShell (any non-empty string casts
+    # truthy) -- compare explicitly instead of casting.
+    $out.media_loaded = ($d.MediaLoaded -eq $true) -or ("$($d.MediaLoaded)" -eq "True")
+} catch { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+
+if (-not $out.media_loaded) { Write-Output (ConvertTo-JsonCompat $out); exit 0 }
+
+# Volume label + filesystem (WMI logical disk).
+$isAudioCd = $false
+try {
+    $ld = Get-WmiObject Win32_LogicalDisk -Filter ("DeviceID='" + $out.drive + "'")
+    if ($ld) {
+        if ($ld.VolumeName) { $out.label = $ld.VolumeName }
+        # Windows presents a synthetic CDFS view (fixed volume name "Audio
+        # CD") for audio discs, purely so Explorer can browse track01.cda
+        # files - it's not a real filesystem. Treating it as one made every
+        # audio CD misclassify as a data disc.
+        if ($ld.VolumeName -eq "Audio CD" -and "$($ld.FileSystem)" -ieq "CDFS") {
+            $isAudioCd = $true
+        } elseif ($ld.FileSystem) {
+            $fs = $ld.FileSystem.ToLower()
+            if ($fs -match "udf") { $out.fs = "udf" }
+            elseif ($fs -match "cdfs|iso9660") { $out.fs = "iso9660" }
+            else { $out.fs = $fs }
+        }
+        if ($ld.Size) { $out.capacity_bytes = [int64]$ld.Size }
+    }
+} catch {}
+
+# IMAPI2: physical media type, blank flag, recordable capacity.
+try {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        $match = $false
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $p.TrimEnd('\') -ieq $out.drive) { $match = $true } }
+        if (-not $match) { continue }
+        $fmt = New-Object -ComObject "IMAPI2.MsftDiscFormat2Data"
+        if (-not $fmt.IsRecorderSupported($rec)) { break }
+        $fmt.Recorder = $rec
+        $fmt.ClientName = "DiscStation"
+        try { $out.blank = ($fmt.MediaHeuristicallyBlank -eq $true) } catch {}
+        try { if ($fmt.MediaPhysicallyBlank) { $out.blank = $true } } catch {}
+        try { $out.capacity_bytes = [int64]$fmt.TotalSectorsOnMedia * 2048 } catch {}
+        $t = 0; try { $t = [int]$fmt.CurrentPhysicalMediaType } catch {}
+        # IMAPI_MEDIA_PHYSICAL_TYPE
+        $map = @{ 1="cd-rom"; 2="cd-r"; 3="cd-rw"; 4="dvd-rom"; 5="dvd-r"; 6="dvd-ram";
+                  7="dvd+r"; 8="dvd+rw"; 9="dvd+r dl"; 10="dvd-r dl"; 12="dvd+rw dl";
+                  16="bd-rom"; 17="bd-r"; 18="bd-re" }
+        if ($map.ContainsKey($t)) { $out.media_type = $map[$t] }
+        if ($out.media_type -match "rw|ram|-re") { $out.rewritable = $true }
+        break
+    }
+} catch {}
+
+# $isAudioCd (Windows' own synthetic "Audio CD" CDFS view, detected above) is
+# authoritative - overrides whatever IMAPI2's physical-media-type guess said,
+# since a finalized audio CD-R still reports as generic "cd-rom" there.
+if ($isAudioCd) {
+    $out.media_type = "audio_cd"
+}
+
+Write-Output (ConvertTo-JsonCompat $out)

package/src/win/eject.ps1

@@ -0,0 +1,30 @@
+# Eject or close the optical tray via IMAPI2, with a Shell.Application fallback.
+# Usage: eject.ps1 <drive letter e.g. D:> [close]
+param([string]$Drive = "", [switch]$Close)
+
+$ErrorActionPreference = "Stop"
+$ok = $false
+
+try {
+    $master = New-Object -ComObject "IMAPI2.MsftDiscMaster2"
+    for ($i = 0; $i -lt $master.Count; $i++) {
+        $rec = New-Object -ComObject "IMAPI2.MsftDiscRecorder2"
+        $rec.InitializeDiscRecorder($master.Item($i))
+        $match = -not $Drive
+        foreach ($p in $rec.VolumePathNames) { if ($p -and $Drive -and $p.TrimEnd('\') -ieq $Drive) { $match = $true } }
+        if (-not $match) { continue }
+        if ($Close) { $rec.CloseTray() } else { $rec.EjectMedia() }
+        $ok = $true
+        break
+    }
+} catch {}
+
+if (-not $ok -and -not $Close -and $Drive) {
+    try {
+        $sh = New-Object -ComObject "Shell.Application"
+        $sh.Namespace(17).ParseName($Drive).InvokeVerb("Eject")
+        $ok = $true
+    } catch {}
+}
+
+if ($ok) { exit 0 } else { Write-Error "eject failed"; exit 1 }

package/src/win/play-audio-cd.ps1

@@ -0,0 +1,94 @@
+# Play a Red Book audio CD via Windows Media Player's COM control - mpv on
+# Windows has no libcdio, so cdda:// is "disabled at compile-time" there.
+# WMPlayer.OCX only actually plays when hosted in a real window with a
+# message pump; a bare `New-Object -ComObject` never leaves playState
+# "Ready". Runs as a tiny persistent process, polled by the caller:
+#
+# Commands: caller writes one command to $CmdFile (PAUSE | STOP | NEXT |
+# PREV | VOL:<0-100>); this script deletes it once consumed. A file-based
+# channel instead of stdin - a background thread reading Console stdin
+# here crashed the whole process outright (a piped stdin under a
+# powershell.exe launched via -File from a console-less pythonw.exe
+# parent apparently isn't safe to read from a second thread).
+# Status (stdout): TRACK:<0-based index> | DONE | ERROR:<message>
+#
+# Usage: play-audio-cd.ps1 <drive e.g. D:> <command file path>
+param(
+    [Parameter(Mandatory = $true)] [string] $Drive,
+    [Parameter(Mandatory = $true)] [string] $CmdFile
+)
+
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.Windows.Forms
+
+# Write-Output through a redirected/piped stdout (SSH, or Python's own
+# subprocess.PIPE) buffers until the process exits instead of flushing
+# per line - confirmed live (only the final "DONE" ever arrived; every
+# "TRACK:" sent during actual playback was stuck in the buffer). Writing
+# straight to the console stream and flushing after each line sidesteps
+# PowerShell's own output-pipeline buffering.
+function Send-Status([string]$msg) {
+    [Console]::Out.WriteLine($msg)
+    [Console]::Out.Flush()
+}
+
+try {
+    $form = New-Object System.Windows.Forms.Form
+    $form.Show()
+    [System.Windows.Forms.Application]::DoEvents()
+
+    $wmp = New-Object -ComObject WMPlayer.OCX.7
+    $drives = $wmp.cdromCollection
+    $target = $null
+    for ($i = 0; $i -lt $drives.count; $i++) {
+        if ($drives.Item($i).driveSpecifier.TrimEnd('\') -ieq $Drive.TrimEnd('\')) { $target = $drives.Item($i); break }
+    }
+    if (-not $target) { Send-Status "ERROR:No CD drive $Drive"; exit 2 }
+
+    $wmp.currentPlaylist = $target.playlist
+    $wmp.controls.play()
+} catch {
+    Send-Status ("ERROR:" + $_.Exception.Message)
+    exit 1
+}
+
+$lastTrack = -1
+while ($true) {
+    Start-Sleep -Milliseconds 200
+    [System.Windows.Forms.Application]::DoEvents()
+
+    if ($wmp.playState -eq 8) { Send-Status "DONE"; break }  # wmppsMediaEnded
+
+    # currentItem.playlistIndex comes back empty on this drive/build -
+    # confirmed live - but .name reliably reads "Track N" for a CD
+    # playlist item, so parse the number out of that instead.
+    $track = -1
+    try {
+        $item = $wmp.controls.currentItem
+        if ($item -and $item.name -match 'Track\s+(\d+)') { $track = [int]$Matches[1] - 1 }
+    } catch {}
+    if ($track -ge 0 -and $track -ne $lastTrack) {
+        $lastTrack = $track
+        Send-Status "TRACK:$track"
+    }
+
+    if (Test-Path -LiteralPath $CmdFile) {
+        $line = (Get-Content -LiteralPath $CmdFile -Raw -ErrorAction SilentlyContinue)
+        Remove-Item -LiteralPath $CmdFile -ErrorAction SilentlyContinue
+        if ($line) {
+            $line = $line.Trim()
+            switch -Regex ($line) {
+                '^PAUSE$' {
+                    if ($wmp.playState -eq 3) { $wmp.controls.pause() } else { $wmp.controls.play() }
+                }
+                '^STOP$' { $wmp.controls.stop(); Send-Status "DONE"; break }
+                '^NEXT$' { $wmp.controls.next() }
+                '^PREV$' { $wmp.controls.previous() }
+                '^VOL:(\d+)$' { $wmp.settings.volume = [Math]::Min(100, [Math]::Max(0, [int]$Matches[1])) }
+            }
+        }
+    }
+}
+
+try { $wmp.controls.stop(); $wmp.close() } catch {}
+try { $form.Close() } catch {}