Bump version

* Gate advanced Redumper options in UI, add read method + sector order

* Update changelog

* Fixed-width text/combo boxes

.editorconfig

@@ -0,0 +1,4 @@
+[*.cs]
+
+# SYSLIB1045: Convert to 'GeneratedRegexAttribute'.
+dotnet_diagnostic.SYSLIB1045.severity = silent

.github/ISSUE_TEMPLATE/feature-request.md

@@ -8,9 +8,9 @@ assignees: mnadareski
 ---
 
 **Before You Submit**
+
 - Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
-- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
-- .NET Core 3.1 and .NET 5.0 have known limitations, so make sure that what you're asking for isn't already in another build.
+- Is it copy protection related? If so, report the issue [here](hhttps://github.com/SabreTools/BinaryObjectScanner/issues) instead.
 - Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
 
 If none of those apply, then continue...

.github/ISSUE_TEMPLATE/informational.md

@@ -8,9 +8,9 @@ assignees: mnadareski
 ---
 
 **Before You Submit**
+
 - Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
-- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
-- .NET Core 3.1 and .NET 5.0 have known limitations, so make sure that what you're giving information on isn't already in another build.
+- Is it copy protection related? If so, report the issue [here](hhttps://github.com/SabreTools/BinaryObjectScanner/issues) instead.
 - Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
 
 If none of those apply, then continue...
@@ -19,4 +19,4 @@ If none of those apply, then continue...
 A clear and concise description of what the information is. Ex. With the latest build of DumpingProgram, it [...]
 
 **Additional context**
-Add any other context or screenshots about the information here.
+Add any other context or screenshots about the information here.

.github/ISSUE_TEMPLATE/issue-report.md

@@ -8,16 +8,16 @@ assignees: mnadareski
 ---
 
 **Before You Submit**
+
 - Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the issue has already been addressed.
-- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
-- .NET Core 3.1 and .NET 5.0 have known issues, please try using another build to reproduce the error
+- Is it copy protection related? If so, report the issue [here](hhttps://github.com/SabreTools/BinaryObjectScanner/issues) instead.
 - Check multiple discs to help narrow down the issue
 - Check the Options to see if changing any of those affects your issue.
 
 If all of those fail, then continue...
 
 **Version**
-What version are you using? 
+What version are you using?
 
 - [ ] Stable release (version here)
 - [ ] WIP release (version here)
@@ -25,15 +25,15 @@ What version are you using?
 **Build**
 What runtime version are you using?
 
-- [ ] .NET Framework 4.7.2 running on (Operating System)
-- [ ] .NET Framework 4.8 running on (Operating System)
-- [ ] .NET Core 3.1 running on (Operating System)
+- [ ] .NET 6.0 running on (Operating System)
+- [ ] .NET 8.0 running on (Operating System)
 
 **Describe the issue**
 A clear and concise description of what the bug is.
 
 **To Reproduce**
 Steps to reproduce the behavior:
+
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'

.github/workflows/build_check.yml

@@ -0,0 +1,50 @@
+name: MPF Check
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        project: [MPF.Check]
+        runtime: [win-x86, win-x64, linux-x64, osx-x64] #[win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64]
+        framework: [net8.0] #[net20, net35, net40, net452, net472, net48, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+        
+    - name: Restore dependencies
+      run: dotnet restore
+      
+    - name: Build
+      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c Debug --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
+        
+    - name: Archive build
+      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
+        
+    - name: Upload build
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug
+        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True

.github/workflows/build_ui.yml

@@ -0,0 +1,57 @@
+name: MPF UI
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        project: [MPF]
+        runtime: [win-x86, win-x64]
+        framework: [net8.0-windows] #[net40, net452, net472, net48, netcoreapp3.1, net5.0-windows, net6.0-windows, net7.0-windows, net8.0-windows]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+        
+    - name: Restore dependencies
+      run: dotnet restore
+      
+    - name: Build
+      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c Debug --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
+      
+    - name: Bundle Redumper
+      run: |
+        wget https://github.com/superg/redumper/releases/download/build_311/redumper-2024.01.08_build311-win64.zip
+        unzip redumper-2024.01.08_build311-win64.zip
+        mkdir -p MPF/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Redumper
+        mv redumper-2024.01.08_build311-win64/bin/redumper.exe MPF/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Redumper/
+
+    - name: Archive build
+      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
+        
+    - name: Upload build
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug
+        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True

.github/workflows/check_pr.yml

@@ -0,0 +1,23 @@
+name: Build PR
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+
+    - name: Restore dependencies
+      run: dotnet restore
+
+    - name: Build
+      run: dotnet build --no-restore
+
+    - name: Test
+      run: dotnet test --no-restore --verbosity normal

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "MPF.Library/Aaru/CICMMetadata"]
-	path = CICMMetadata
-	url = https://github.com/claunia/CICMMetadata

.vscode/launch.json

@@ -10,9 +10,9 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/MPF/bin/Debug/netcoreapp3.1/MPF.dll",
+            "program": "${workspaceFolder}/MPF.Check/bin/Debug/net6.0/MPF.Check.dll",
             "args": [],
-            "cwd": "${workspaceFolder}/MPF",
+            "cwd": "${workspaceFolder}/MPF.Check",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",
             "stopAtEntry": false

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "omnisharp.projectLoadTimeout": 480
+}

.vscode/tasks.json

@@ -7,21 +7,7 @@
             "type": "process",
             "args": [
                 "build",
-                "${workspaceFolder}/MPF/MPF.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
-            ],
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "publish",
-            "command": "dotnet",
-            "type": "process",
-            "args": [
-                "publish",
-                "${workspaceFolder}/MPF/MPF.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
+                "${workspaceFolder}/MPF.sln",
             ],
             "problemMatcher": "$msCompile"
         },

CHANGELIST.md

@@ -1,4 +1,897 @@
+### 3.1.6 (2024-04-27)
+
+- Fix parameter parsing for `=` symbol (Deterous)
+- Define better default categories (Deterous)
+- Custom non-redump Redumper options (Deterous)
+- Update packages
+- Update packages
+
+### 3.1.5 (2024-04-05)
+
+- Handle `.0.physical` files from Redumpers
+- Read C2 error count from Redumper logs
+- Read last instance of hash data from Redumper
+- Add Konami Python 2 system detection
+- Fix outdated information in README
+- Fix missing information in README
+- Language selections unchecked by default
+- Update BinaryObjectScanner to 3.1.3
+- Fix information pulling for redumper (fuzz6001)
+- Update packages
+- Update BinaryObjectScanner to 3.1.4
+- Detect Xbox Series X discs (Deterous)
+- Enable Windows targeting for test project
+- Fix test project project includes
+- Fix CleanRip hash output for Check (Deterous)
+- Enable label-side mastering SID and toolstamp
+- Enable remaining fields for label-side information
+- Update BinaryObjectScanner to 3.1.5
+
+### 3.1.4 (2024-03-16)
+
+- Update BinaryObjectScanner to 3.1.2
+
+### 3.1.3 (2024-03-15)
+
+- Gate debug publishing behind use all flag
+- Hide layerbreaks if value is 0
+- Make GHA debug-only
+- Remove GHA pull request builds
+- Add PR check workflow
+- Don't link to AppVeyor artifacts page anymore
+- Add PS3 CFW support to MPF.Check (Deterous)
+- Hide size if value is 0 (Deterous)
+- Fix title normalization (Deterous)
+- Ensure no labels are empty
+- Use SabreTools.Hashing
+- Update to SabreTools.RedumpLib 1.3.5
+- Update packages to latest
+- Enable LibIRD for all .NET frameworks (Deterous)
+- Try updating PR check action
+- Fix config access persmission (Deterous)
+- Fix Check UI deadlock (Deterous)
+- Fix formatting output formatting
+- Update LibIRD to 0.9.0 (Deterous)
+- Update packages
+- Fix Redumper generic drive type (Deterous)
+- Add MPF version to Submission info (Deterous)
+- Update to RedumpLib 1.3.6
+
+### 3.1.2 (2024-02-27)
+
+- Remove debugging lines from build script
+- Port build script fixes from BOS
+- Fix double git hash version (feat. Deterous)
+- Readd x86 builds by default
+- Hide unavailable dumping programs (Deterous)
+- Remove DIC and Aaru bundles from CI
+- Add x86 builds to AppVeyor
+- Make AppVeyor builds framework-dependent
+- Fix misattributed artifact
+- Update README with current build instructions
+- Opt-in automatic IRD creation after PS3 dump (Deterous)
+- Add CI via Github Workflows (Deterous)
+- Reorganize solution items
+- Split CI workflow files
+- Add GHA CI status badges
+- Rename badges for GHA
+- More tweaks to CI
+- Fix net35 build issue
+- Remove now-unnecessary restore step
+- Remove net35 from MPF... again
+- Fix whitespace that got unwhitespaced
+- Fix link in README
+- Attempt to add CD to existing actions
+- Try fixing the artifact upload
+- Use recommendation from upload-artifact
+- Revert artifact ID, use name?
+- Try using download-artifact
+- Download all artifacts?
+- Use newer download version
+- Build artifact before upload
+- Change link to WIP builds in README
+- Use commit SHA as body of rolling releases
+- Don't omit body when setting body
+- Remove unnecessary empty section
+- Unified tag for rolling release
+- Generate release notes automatically
+- Remove generation, just in case
+- Change link to WIP builds in README
+- Show hashes in readonly data
+- Update to BinaryObjectScanner 3.1.0
+- Add Mattel HyperScan detection
+- Pull PS3 Disc Key from redump (Deterous)
+
+### 3.1.1 (2024-02-20)
+
+- Remove .NET 6 from auto-builds
+- Make Redumper the default for new users
+- Fix DIC log parsing for SS version (Deterous)
+- Write outputs with UTF-8
+- Add funworld Photo Play detection
+- Fix Aaru drive parameter generation
+- Limit DVD protection outputs
+- Add a GUI for PS3 IRD Creation (Deterous)
+- Update LibIRD, disable UI elements when creating IRD (Deterous)
+
+### 3.1.0 (2024-02-06)
+
+- Update RedumpLib
+- Update Redumper to build 294
+- Fix commented out code
+- Make missing hash data clearer
+- Get BD PIC Identifier for redumper (Deterous)
+- Support redumper skeleton and hash files (Deterous)
+- Support ringcode and PIC for triple/quad-layer (fuzz6001)
+- Cleanup !protectionInfo.txt (Deterous)
+- Update Redumper to build 311 (Deterous)
+- Use PSX/PS2 serial as filename when Volume Label not present (Deterous)
+- Allow variables in output path (Deterous)
+- Check for presence of complete dump from other programs (Deterous)
+- Retrieve volume label from logs (Deterous)
+- Correct missing space in PVD (fuzz6001)
+- Prevent crashing on invalid parameters (Deterous)
+- Detect CDTV discs (Deterous)
+- Differentiate CD32 from CDTV (Deterous)
+- Normalise Disc Titles in Submission Info (Deterous)
+- Skip warning line in Redumper log
+- Add a GUI for MPF.Check (Deterous)
+- Fix information pulling for CleanRip and UIC
+- Add UMD handling for the disc info window
+- Detect Photo CD
+- Parse PSX/PS2/KP2 exe date from logs (Deterous)
+- Exclude extra tracks when finding disc matches (Deterous)
+- Verbose Redumper log by default (Deterous)
+- Retrieve serial from Cleanrip
+- Fix build from rushed code
+- Remove `-disc2` from Cleanrip serial
+- Enable Windows builds on Linux and Mac
+- Fix compiler warning (Deterous)
+
+### 3.0.3 (2023-12-04)
+
+- Fix broken tests
+- Fix using SHA-1 for track checks
+- Fix build warning for NRE
+- Remove .NET Framework 3.5 from build script
+- Handle or suppress some messages
+
+### 3.0.2 (2023-12-01)
+
+- Read CSS for some copy protections
+- Add Disc ID and Key fields in info window
+- Replace build script with Powershell
+- Fix Powershell build script
+- Fix cross-framework UI rendering
+- Fix most .NET Framework 3.5 issues
+- Fix cross-framework UI styles
+- Update Redumper to build 271
+- Update USE_ALL in Powershell script
+- Import WinFX for .NET Framework 3.5
+- Reference .NET Framework 3.0 for 3.5
+- Handle most VS and dotnet differences
+
+### 3.0.1 (2023-11-30)
+
+- Add Bandai Pippin detection
+- Zip manufacturer files for Redumper
+- Fix BE flag logic bug in DIC
+- Support ancient .NET in Core
+- Support ancient .NET in UI Core
+- Support C# 12 syntax
+- Support ancient .NET in Check
+- Support ancient .NET in UI
+- Fix TLS for older .NET
+- Perform more ancient .NET support work
+- Prepare XAML for ancient .NET support
+- Suppress deprecation warnings
+- Fix reversed ringcode test
+- Add C#12 syntax to tests
+- Trim PS3 serial and add unrelated notes
+- Update RedumpLib and use moved methods
+- Perform some post-move cleanup
+- More C# 12 cleanup in Core
+- Update to BinaryObjectScanner 3.0.1
+- Update Xunit packages
+- Get Core building with Framework 4.0
+- Get UI.Core building with Framework 4.0
+- Get Check building with Framework 4.0
+- Use TryGetValue on dictionaries
+- Support proper async in .NET Framework 4.0
+- Temporarily remove .NET Framework 4.0
+- Update to BinaryObjectScanner 3.0.2
+- Re-enable .NET Framework 4.0 building in Core
+- Re-enable .NET Framework 4.0 building in UI.Core
+- Re-enable .NET Framework 4.0 building in Check
+- Support .NET Framework 3.5
+- Update compatibility libraries
+- Support .NET Framework 2.0
+- Support .NET Framework 3.5 in UI.Core
+- Get UI building with Framework 4.0
+- Temporarily remove .NET Framework 4.0 from UI
+- Get UI building with Framework 4.0 again
+- Support .NET Framework 3.5 in UI
+- Update Redumper to build 268
+
+### 3.0.0 (2023-11-14)
+
+- Remove .NET Framework 4.8 from build
+- Remove .NET Framework 4.8 from projects
+- Remove .NET Framework 4.8 gated code
+- Address lingering modern .NET syntax
+- Update README for Legacy
+- Remove redundant information
+- Remove 4.8 note from build script
+- Even more README cleanup
+- Consolidate build script information
+- Remove lingering script reference
+- Make releases less verbose
+- Remove .NET Framework 4.8 from issue report
+- Remove Unshield reference
+- Update documentation for BOS change
+- Bump library versions
+- Update to .NET 8
+
+### 2.7.5 (2023-11-06)
+
+- Remove psxt001z Pkg Ref in MPF.Test (Deterous)
+- Update Redumper to build 247
+- Focus main window after child window closes (Deterous)
+- Try to get PS3 data from SFB
+- Fix PS3 version finding
+- Pull PS3 Firmware Version (Deterous)
+- Fix default layerbreak output
+- Enable browsing for Redumper path (Deterous)
+- Update to MMI 3.0.0 (Deterous)
+
+### 2.7.4 (2023-10-31)
+
+- Move Hash enum and simplify
+- Add other non-cryptographic hashes
+- Avoid unncessary allocation in hashing
+- Make Hasher more consistent
+- Move all hashing to Hasher
+- Separate out static hashing
+- Remove unncessary summary
+- Version-gate new switch statement
+- Ignore empty protection results
+- Remove and Sort Usings
+- Update Redumper to build 244
+- Enable Bluray dumping with Redumper
+- Add Bluray layerbreak support for Redumper
+- Remove now-obsolete notes
+- Compile most regex statements
+- Handle a couple of messages
+- Remove .manufacturer for Bluray
+- Fix typo that disables DIC during media check (Deterous)
+- Fix build
+- Remove duplicate check
+- Add PIC output for Redumper
+- Update Redumper to build 246
+- Enable HD-DVD for Redumper in UI
+- Attempt to fix window owner issue
+
+### 2.7.3 (2023-10-26)
+
+- Split InfoTool into 2 classes
+- Add path variants for PlayStation info
+- Convert Drive to use paths internally
+- Create skeleton for first-run
+- Show options window on first run
+- Fix drive letter issue in UI
+- Add first-run Options title, fix saving bug
+- Fix multiple handler invocation
+- Create method for applying theme
+- Fix drive letter check
+- Simply theme application
+- Add framework for deleteable files
+- Add deleteable file lists for Redumper and DIC
+- Add optional file deletion
+- Rearrange OptionsWindow to be easier to navigate
+- Fix up DumpEnvironment a bit
+- Add filename suffix setting (nw)
+- Wire through filename suffix
+- Expose suffix setting
+- Set UDF CD threshold at 800MB (Deterous)
+- Update package versions
+- Attempt to parse out PS5 params.json
+- Fix CRC32 hashing
+- Update XUnit packages
+- Update to BurnOutSharp 2.9.0
+- Update to MMI 3.0.0-preview.4
+- Fix two small nullability issues
+- Use Array.Empty in hasher
+- Always use relative path internally (Deterous)
+
+### 2.7.2 (2023-10-17)
+
+- Fix options loading for Check
+- Cleanup and gated code
+- Gate some switch expressions
+- Suppress some unnecessary messages
+- Disable dumping button when Redumper selected with unsupported media type (Deterous)
+- Improve check for which program supports which media (Deterous)
+- Remove code for getting Universal Hash from DIC logs (Deterous)
+- Fix Redumper retry count not showing
+- Enable parameters checkbox by default
+- Update Redumper to build 230
+- Fix GetPVD in dic (fuzz6001)
+- Get SecuROM data from Redumper
+- Clean up issue templates
+- Support Redumper 231 outputs
+
+### 2.7.1 (2023-10-11)
+
+- Add pull-all flag for Check
+- Fix errant version detection issue
+- Allow user-supplied information in Check
+- Add BE read flag for Redumper
+- Add generic drive flag for Redumper
+- Handle numeric disc titles as issue numbers
+- Unify handling of enable/disable events
+- Enable nullability in Check
+- Remove all but .NET 6 for AppVeyor packaging
+- Place message boxes at center of main window (Deterous)
+- Enable nullability in MPF
+- Enable nullability in MPF.UI.Core
+- Enable nullability in MPF.Test
+- Handle some suggested changes
+- Var-ify many instances
+- Version-gate some newer syntax
+- Fix Check always showing Help text
+- Version-gate some more newer syntax
+- Enable path browse button by default
+- Remove unnecessary namespacing
+
+### 2.7.0 (2023-10-11)
+
+- Attempt to replace NRT
+- Try alternate archive naming
+- Publish, but don't package, release builds
+- Add note about git being required
+- Try out using version number in AppVeyor
+- Job number not build ID
+- Fix errant space in variable name
+- Build number not job number
+- Use System.IO.Hashing for CRC32
+- Don't reverse the CRC32 output
+- Add submission info preamble
+- Fix missing comma
+- Remove IMAPI2 with no substitution
+- Remove framework exceptions
+- Slight reorganization of code
+- Update README with support information
+- Remove msbuild-specific AppVeyor items
+- Be trickier when it comes to type from size
+- Fix "detected" message
+- Be smarter about media type based on system
+- Consolidate into MPF.Core
+- Fix failing tests
+- Remove debug symbols in release builds (Deterous)
+- Allow nullability for modern .NET
+- Fix failing tests
+- Remove unnecessary include
+- Move element items to Core
+- Move LogLevel enumeration
+- Split logging code a bit more
+- Split info window code a bit more
+- Clarify build instructions in README (Deterous)
+- Split options window code a bit more
+- Use binding for more disc info textboxes
+- Handle Redump password changing better
+- Refine options window bindings
+- Refine options window bindings further
+- Refine info window bindings further
+- Move decoupled view models
+- Fix log output
+- Start migrating MainViewModel
+- Perform most of MainViewModel changes
+- Small updtes to MainViewModel
+- Remove MainWindow from MainViewModel
+- Use callback for logging, fix Options window
+- Remove WinForms from MainViewModel
+- Remove some message boxes from MainViewModel
+- Remove more Windows from MainViewModel
+- Fix null reference exception in disc type
+- Detected type and selected type are different
+- Remove message boxes from MainViewModel
+- Move MainViewModel to Core
+- Remove LogOutputViewModel
+- Consolidate some constants
+- Fix media type ordering
+- Fix dumping button not enabling
+- Recentralize some Check functionality
+- Fix media combobox not updating (Deterous)
+
+### 2.6.6 (2023-10-04)
+
+- Update Nuget packages
+- Update to MMI 3.0.0-preview.2
+- Remove errant character from script
+- Add placeholders for release builds
+- Fully sync AppVeyor build with script
+- Stop compiling Chime finally
+- Address some warnings and infos
+- Add setting for pulling comment/contents
+- Move to config.json
+- Omit track 0.2 and 00.2 from hash search
+- Tweak README again
+- Fix redumper EDC detection output
+- Fix XGD4 PIC reading
+- Ensure popups are topmost
+- Try out more UI functionality
+- Skip system detection on inactive drives
+- Fix path tests
+- Clean up csproj files
+- Update redumper to build 221
+- Ensure multisession info is populated
+- Be clearer with protection outputs
+
+### 2.6.5 (2023-09-27)
+
+- Normalize Redumper CSS output
+- Update redumper to build 219
+- Add .NET 7 to build scripts
+- Disable subdump download in AppVeyor
+- Normalize publish scripts
+- Update AppVeyor to match scripts
+- Add release publish scripts
+- Handle invalid characters when changing program
+- Fix options not saving on update
+- Combine build scripts
+- Force information window to top
+- Reset debug option to false
+
+### 2.6.4 (2023-09-25)
+
+- Add CD Projekt ID field
+- Fix speed setting in Aaru
+- Add helper for changing dumping program from UI
+- Handle extension changing only
+- Swap order of operations for changing program
+- Fix dumping path in DD
+- Fix PlayStation serial code region parsing (Deterous)
+- Retrofit README
+- Migrate to Nuget package for Redump
+- Remove dd for Windows
+- Migrate to Nuget package for XMID
+- Migrate to Nuget package for cuesheets
+- Migrate to Nuget package for PIC
+- Fix timestamp (Ragowit)
+- Not building against .NET Standard
+- Move RedumpSystemComboBoxItem
+- Move Constants
+- Move WPFCustomMessageBox
+- Remove EnableProgressProcessing
+- Remove EnableLogFormatting
+- Remove App references from LogViewModel
+- Remove log formatting code
+- Move LogOutput
+- Move to csproj tag for internals
+- Move OptionsWindow
+- Begin decoupling App
+- Fix build
+- More decoupling App
+- Make Options non-cloneable
+- Set parent on MainViewModel init
+- Make logger a local reference
+- Move options into MainViewModel
+- Move MainWindow
+- Add .NET 7 as a build target (not AppVeyor)
+- Fix tests that have been broken for a while
+
+### 2.6.3 (2023-08-15)
+
+- Update redumper to build 195
+- Add known .NET 6 limitations to README
+- Remove `_drive.txt` from required UIC outputs
+- Make `use` flag required for MPF.Check
+- Add dumping date to log
+- Non-zero data start only for audio discs
+- Update SafeDisc Sanitization (TheRogueArchivist)
+
+### 2.6.2 (2023-07-25)
+
+- Ensure custom parameters properly set
+- Universal hash only for audio discs
+- Support LibCrypt data from Redumper
+- Always show extension for Redumper
+- Normalize old universal hash text
+- Skip extra tracks during checking
+- Modify the track count on checking
+- Attempt to match universal hash
+- Fix .NET Framework 4.8 build
+- Fix universal hash URL generation
+- Add Windows publish script
+- Add *nix publish script
+- Add build instructions to README
+- Clarify build instructions
+
+### 2.6.1 (2023-07-19)
+
+- Simplify Redumper error value extraction
+- Don't pull comment fields that auto-populate
+- Set best compression levels for log files
+- Be more explicit about .NET 6 limitation
+- Set extensions for Redumper in UI
+- Fix comment field pulling again
+
+### 2.6 (2023-07-14)
+
+- Update README
+- Add warning to login tab
+- Pull hardware info from redumper log (fuzz6001)
+- Increase the version of AppVeyor (fuzz6001)
+- Add Windows 7 note to README
+- Update redumper to build 113
+- Split MMI invocation in drive listing
+- Update README
+- Add Hasbro iON
+- Get the write offset from the latest redumper (fuzz6001)
+- Update redumper to build 115
+- Update to DIC 20230401
+- Add DIC `.` notice to README
+- Resync with Redump
+- Update redumper to build 118
+- Clarify non-Redump systems
+- Add UltraCade
+- Re-enable BD33 and BD66
+- Add PIC models for BD (unused)
+- Handle PIC based on disc type
+- UMDs always have "2 layers"
+- Add dumping program selection to main UI
+- Update to DIC 20230413
+- Comment out `.` handling for DIC
+- Ensure dumping program box can enable/disable
+- Disable special SmartE handling for DIC
+- Remove path from PS1/PS2 serial
+- Make TOC file optional for CD/GD
+- Add datafile models
+- Add datafile helper method
+- Start migrating to datafile serialization
+- Prepare for future DIC changes
+- Add suppl support to Xbox
+- Support single digit subs
+- Fix info tool hash finding
+- Fix missing size for ISO data
+- Attempt to more accurately parse layerbreaks
+- Fix upcoming suppl DAT parsing
+- Ensure blank lines don't interfere
+- De-indent ringcode data
+- Be more specific with runtime identifiers
+- Fix subdump output path in AV config
+- Fix subdump mkdir path in AV config
+- Single file packing for .NET 6 again
+- Add missing BD disc type identifier string
+- Truncate PIC data for PS4/PS5
+- Add internal theme support with class
+- Add PIC identifier to SubmissionInfo
+- Fix other media type method
+- Fix non-zero offset text
+- Add executable listing for XSX
+- Update redumper to build 151
+- Add more safety to DAT generation
+- Get write offset from redumper 119 (fuzz6001)
+- Update hardware information pull from redumper (fuzz6001)
+- Add MCD/SS header support for Redumper
+- Fix MCD region(s) parsing
+- Update to DIC 20230606
+- Update redumper to build 166
+- Unblock Redumper DVD support
+- Support Redumper DVD layerbreak
+- Add placeholder and TODOs for Redumper
+- Add TODO with notes to Redumper
+- Fix 2-layer DVD support in Redumper
+- Fix VSCode build
+- Fix Redumper DAT/layer parsing
+- Update Redumper PS1 output parsing
+- Fix previous commit, clean up helpers
+- Update redumper to build 173
+- Initial support for Redumper CSS outputs
+- Hook up CSS output for testing
+- Update redumper to build 174
+- Add support for redumper CD synonyms
+- Adjust CSS title key parsing
+- Fix non-reading loop
+- Normalize Redumper CSS outputs
+- Normalize multi-instance site tags
+- Add missing Aaru error log to zip
+- Check Redumper dat section for completeness
+- Update redumper to build 176
+- UMDs are Sony discs
+- Strip colons from Redumper disc key
+- Use `HashSet` for disc or book type
+- Add ordering to disc or book type
+- Update redumper to build 183
+- Parse and format Redumper CD multisession data
+- New layerbreak takes precedence
+- Reduce pulled information for Xbox and X360
+- Ensure we found the tags we're skipping
+- Omit pulling universal hash
+- Update Nuget packages to newest stable
+
+### 2.5 (2023-03-12)
+
+- Add _drive file to zip for UIC
+- Add Xbox Series X and PS5 to list, fix Acorn
+- Add Xbox Series X short name to list
+- Remove windows from test target
+- Remove .NET 6.0 from tests, add TODO
+- Add .NET 6.0 to tests, remove msbuild args
+- Add HD-DVD to speed definitions
+- Add PS3 internal serial and version parsing (tjanas)
+- Update Nuget packages to newest stable
+- Simplify path selection in UI
+- Fix broken normalization test
+- Update drive info before dumping
+- Update redumper strings
+- Add new parameter and mode validation
+- Add redumper to the UI
+- Update redumper to build 81
+- Fix incorrect naming in Options window
+- Initial attempt at parsing redumper outputs
+- Update README
+- Reenable write offset for all CDs
+- Add missing redumper output file
+- Force a filename for redumper
+- Fix incorrect SetParameters
+- Fix a couple redumper things
+- Update AppVeyor version
+- Output security sectors to info
+- Remove x86 requirement for build
+- Fix XGD media type outputs
+- Fix typo in ToInternalProgram
+- Fix redumper error count parsing
+- Update to Aaru v5.3.2 LTS
+- Update options loader with sane defaults
+- Fix AppVeyor pathing
+- Skip during detection
+- Address some UI concerns
+- Tweak AppVeyor, show Check 6.0 builds
+- More strict when custom parameters editing
+- Use msbuild for .NET Framework 4.8
+- Update nuget packages
+- ReadAllText not ReadAllLines
+- Add drive format (fs) to log
+- Go back to pre .NET 7 Aaru
+- Be smarter about old paths
+- Fix relative paths for DIC
+- Add nicer failure message
+- Update to DIC 20230201
+- Use relative path output for DIC
+- Remove usage of Aaru
+- Remove Aaru as submodule
+- Fix Aaru removal
+- Enable .NET 6 Windows builds
+- Update Redumper to build_106
+- Reformat CICM for old .NET versions
+- Attempt to handle no drives
+- Handle no drives better
+- Handle no drives betterer
+- Packaging requires `-windows` for framework
+- Fix other `-windows` places for .NET 6
+- Fix typo in DICMultiSectorReadValue
+- Semi-unify drive finding
+- Introduce cross-platform MMI
+- Remove System.Management
+- Add Redumper Universal Hash support
+- Fix Redumper write offset support
+- Add Redumper non-zero data start
+- Use media size for type detection on .NET 6
+- Trim PIC for PS3
+- Get the version of redumper (fuzz6001)
+- Update VSCode config files
+- Can't publish single file for UI
+- Handle missing extension gracefully
+- Fix incorrect option slider display
+- Handle undetected discs on refresh
+- Originally intended behaviour of the Update Label button (IcySon55)
+- Update to BurnOutSharp 2.7.0
+- Get error count from recent redumper log (fuzz6001)
+- Minor cosmetic changes
+- Set saner defaults for dumping speeds
+- Attempt to support Windows 7
+- Add `win7-x64` to identifier list
+- Remove unsupported identifiers
+- Add identifiers in more places
+- Move drive finding inside of the try/catch
+- Update to DIC 20230309
+- Fix errant forward slashes
+- Add TOC back as optional file
+- Fix Redumper path generation
+- Use and trim quotes for Redumper
+- Fix incorrect image name setting
+- Ensure Redumper parameters are set
+- Ensure min values are taken care of
+- Update parameters with `=` handling
+- Ensure drive and speed are set
+- Handle quotes embedded
+- Return list of missing files for Redumper
+- Readd accidentally deleted line
+- Detect EOF during the search for error counts (fuzz6001)
+
+### 2.4 (2022-10-26)
+
+- Update to DIC 20211001
+- Fix Redump disc title pulling
+- Add /mr default flag options
+- Make FillFromRedump private again
+- Fix DVD layer finding corner case
+- Fix failing module tests
+- Add option to limit region and language selections
+- Cap X360 directory check to 500MB
+- Assign normalized path to parameters
+- Move path normalization to better place
+- Specifically include Unsafe Nuget package
+- Update Nuget packages to newest stable
+- Add Xbox One system detection
+- Update to DIC 20220301
+- Force internal drive refresh
+- Add single drive refresh button (IcySon55)
+- Fix "missing" option in window
+- Track last used drive on refresh
+- Clean up pre-dump validation
+- Update to Aaru v5.3.1 LTS
+- Add upper case `<TAB>` processing
+- Reorder event handers
+- Handle sanitized protections edge case
+- Update Aaru Nuget package
+- Return faster on empty protection sets
+- Remove redundant check around volume label
+- Fix tabs in Games and Videos boxes
+- Make fully and partially matching IDs more apparent
+- Add write offset as read-only field
+- Explicitly clear list, just in case
+- Add both fully and partially matching to info file
+- Fix submission info clone
+- Clear out fully matched IDs from the partial list
+- Refine copy protection section showing
+- Update Nuget packages
+- Normalize newlines in comments and contents
+- Increase JSON accuracy for disc types
+- Further separate out protection scan outputs
+- Compress JSON for artifacts alone
+- Even stricter output for copy protection section
+- Report dictionary to InfoTool
+- Even even stricter copy protection output
+- Disable PVD creation for Aaru
+- Explicitly sanitize '?' from path
+- Combine cases in protection scan
+- Convert status label to TextBlock
+- Add option for copy protection file output
+- Make protection field user-editable
+- Add warning to tooltip
+- Create core UI library
+- Rename MPF.GUI to MPF.UI
+- Add multisession pseudo-tag
+- Add multisession helper method skeleton
+- Move and update options loader; clean up Check
+- Move helper methods around
+- Consolidate Redump login testing
+- Separate common arguments to new helper
+- Parse and format CD multisession data
+- Convert triple space to tab
+- Fix clone issue with copy protection
+- Be more picky about multisession
+- Sanitize whitespace around tabs
+- Convert internal libraries to .NET Standard 2.0
+- Update AppVeyor to VS2022
+- Update Nuget packages
+- Remove needless csproj constants
+- Update copyright date to 2022
+- Revert AppVeyor to VS2019 for now
+- Add size-based media type detection for non-Framework
+- Gate ManagmentObject use further
+- Use built-in NETFRAMEWORK directive
+- Update to BurnOutSharp 2.1.0
+- .NET 6.0 and Cleanup
+- Remove .NET Core 3.1 from test project for now
+- Remove .NET Core 3.1 entirely
+- Add filesystem logging for .NET 6
+- Avoid whitespace changes for PVD, Header, and Cuesheet
+- Sync to newest CICM
+- Update solution file for VS2022
+- Add Aaru as a submodule for .NET 6
+- Multisession is multi-line
+- Use Aaru for media type retrival (.NET 6)
+- Fix CD-R multisession info
+- Better get drive list (.NET 6)
+- Add optical media support method (.NET 6)
+- Simplify IsOptical (.NET 6)
+- Reorganize GetMediaType
+- Possibly fix tab regex replacement
+- Add PIC.bin to log zip
+- Organize projects in solution
+- Implement Drive.Create for safety
+- Fix incomplete system name detection
+- Add Sharp X68k detection
+- Add Bandai Playdia QIS detection
+- Framework for XBONE filenames
+- Add files for XBONE
+- Update to DIC 20220707
+- Fix .bin file paths; update internal filename generation
+- Disable nonstandard BD-ROM sizes
+- Trim leading file paths for XBONE
+- Give .NET 6 priority for web calls
+- Update to BurnOutSharp 2.3.0 (nw)
+- Add Mattel Fisher-Price iXL detection
+- Update to BurnOutSharp 2.3.1 (nw)
+- Fix serial parsing for Dreamcast
+- Fix missing parenthesis
+- Add internal name for Cleanrip outputs
+- Fix psxt001z namespace
+- Fix missing assignment
+- Update to new constructor
+- Update PSX content check
+- Update Aaru submodule to latest devel
+- Add Sony Electronic Book system
+- Verify GD-ROM outputs, finally
+- Electronic not Electric
+- Fix ringcode guide images
+- Add skeleton for Redumper
+- Download Redumper with AppVeyor
+- Add Redumper constants
+- Add Redumper parameter values
+- Add Redumper command support and reset
+- Add Redumper dumping command
+- Add Redumper command validation
+- Add Redumper command generation
+- Create Redumper extensions class
+- Minor Redumper cleanup
+- Add important Redumper note
+- Update to DIC 20220909
+- Possibly fix PIC parsing
+- Add PS3 folder/file checks for detection
+- Use default directory for folder browsing, if possible
+- Add unused command filename parser
+- Add initial framework for reporting dumping program
+- Report specific DIC version, if possible
+- Add dumping info section skeleton
+- Update Aaru submodules
+- Fix missing info reference change
+- Enable separated protection info output by default
+- Try adding MPF logs to zip
+- Create MPF log helper and filter for deletion
+- Fix missing info in Aaru
+- Add hardware info to DIC and Aaru
+- Fix hardware info
+- Add specialized CDS/SafeDisc filter
+- Add unused article formatter
+- Add language filtering to formatter
+- Add multi-language helper for filter
+- Update Nuget packages
+- Remove deprecated protection setting
+- Update BurnOutSharp to 2.3.4
+- Add compression result reason to log
+- Add System.Memory package to MPF.Library
+- Add CodePages package to MPF.Library
+- Remove extraneous packages
+- Change location of dumping info
+- Add MS ZipFile package to MPF.Library
+- Add + to positive offsets
+- Disable layerbreak generation for BD
+- Disable XGD version reporting
+- Disable XGD layerbreak reporting
+- Disable XGD1 PVD reporting
+- Put Redump limitations behind existing flag
+- Add framework for reported disc type
+- Add disc type parsing for Aaru and DIC
+- Fix multiple DiscType for DIC
+- Fix multiple DiscType* for DIC
+- Add logging to !submissionInfo writing failure
+- Add logging to !submissionInfo formatting failure
+- Update issue templates to be more accurate
+- Fix NRE with offsets
+- Fix readonly Filename info display
+- Fix layerbreak-based checks
+- Add PS4 serial finding (tjanas)
+- Add unused notification method
+- Move to unused Chime class
+- Add PS5 serial finding (tjanas)
+- Fix offset formatting (fuzz6001)
+
 ### 2.3 (2022-02-05)
+
 - Start overhauling Redump information pulling, again
 - Add internal structure for special site codes
 - Add new tabs for special site information
@@ -83,6 +976,7 @@
 - Adjust paths for DIC just before dumping
 
 ### 2.2 (2021-12-30)
+
 - Fix Saturn header finding
 - Add Pocket PC support
 - Add HD-DVD-Video support
@@ -134,6 +1028,7 @@
 - Add safety around volume labels
 
 ### 2.1 (2021-07-22)
+
 - Enum, no more
 - Sony works backward
 - Add experimental dark mode
@@ -163,6 +1058,7 @@
 - Update to BurnOutSharp 1.7.0
 
 ### 2.0 (2021-04-23)
+
 - Rename DICUI to Media Preservation Frontend (MPF)
 - Add handling for BEh drive _mainInfo.txt changes
 - Fix multiline regex fields during info pulling
@@ -217,6 +1113,7 @@
 - Update to BurnOutSharp 1.6.1
 
 ### 1.18 (2020-11-10)
+
 - Add more information extraction and generation for Aaru
 - Remove instances of CD Check from copy protection (again, sorry)
 - Fix multiline submission info outputs
@@ -241,6 +1138,7 @@
 - Added HD-DVD-Video detection
 
 ### 1.17.1 (2020-09-14)
+
 - Shuffled some shared, internal UI variables
 - Synced WPF and Avalonia UI internals
 - Made the disc information window less prone to bugs
@@ -248,6 +1146,7 @@
 - Added support for old(?) DIC flags: `/fix` and `/re`
 
 ### 1.17 (2020-09-12)
+
 - Updated to Aaru version 5.1
 - Updated to BurnOutSharp version 1.4.0
 - Updated to DIC version 20200716
@@ -407,7 +1306,7 @@
 - edccchk now run on all CD-Roms
 - Discs unsupported by Windows are now regonized
 - Extra \ when accepting default save has been removed.
- 
+
 ### 1.02b (2018-05-18)
 
 - Added missing DLL
@@ -420,4 +1319,4 @@
 
 ### 1.01d (2018-05-18)
 
--Combine IBM PC-CD options, misc fixes.
+-Combine IBM PC-CD options, misc fixes.

MPF.Check/MPF.Check.csproj

@@ -1,26 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
+    <!-- Assembly Properties -->
+    <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+    <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
     <OutputType>Exe</OutputType>
-    <Title>MPF Check</Title>
-    <AssemblyName>MPF.Check</AssemblyName>
-    <Description>Validator for various dumping programs</Description>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2021</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.3</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-  </PropertyGroup>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <VersionPrefix>3.1.6</VersionPrefix>
 
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
+    <!-- Package Properties -->
+    <Title>MPF Check</Title>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Description>Validator for various dumping programs</Description>
+    <Copyright>Copyright (c) Matt Nadareski 2019-2024</Copyright>
+    <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
   </PropertyGroup>
 
   <ItemGroup>
@@ -28,25 +28,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.8.0" GeneratePathProperty="true">
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.8" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.6" />
   </ItemGroup>
   
   <ItemGroup>
-    <Content Include="$(PkgBurnOutSharp)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\MPF.Library\MPF.Library.csproj">
-      <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
-      <Name>MPF.Library</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
+    <Content Include="$(PkgBinaryObjectScanner)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
   </ItemGroup>
 
 </Project>

MPF.Check/Program.cs

@@ -1,13 +1,11 @@
 using System;
 using System.IO;
-using System.Linq;
-using BurnOutSharp;
-using MPF.Core.Converters;
+using BinaryObjectScanner;
+using MPF.Core;
 using MPF.Core.Data;
 using MPF.Core.Utilities;
-using MPF.Library;
-using RedumpLib.Data;
-using RedumpLib.Web;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
 
 namespace MPF.Check
 {
@@ -15,147 +13,45 @@ namespace MPF.Check
     {
         public static void Main(string[] args)
         {
-            // Help options
-            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?")
+            // Try processing the standalone arguments
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
             {
-                DisplayHelp();
+                if (standaloneProcessed == null)
+                    DisplayHelp();
                 return;
             }
 
-            // List options
-            if (args[0] == "-lm" || args[0] == "--listmedia")
+            // Try processing the common arguments
+            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
+            if (!success)
             {
-                ListMediaTypes();
-                Console.ReadLine();
+                DisplayHelp(error);
                 return;
             }
-            else if (args[0] == "-lp" || args[0] == "--listprograms")
-            {
-                ListPrograms();
-                Console.ReadLine();
-                return;
-            }
-            else if (args[0] == "-ls" || args[0] == "--listsystems")
-            {
-                ListSystems();
-                Console.ReadLine();
-                return;
-            }
-
-            // Normal operation check
-            if (args.Length < 3)
-            {
-                DisplayHelp("Invalid number of arguments");
-                return;
-            }
-
-            // Check the MediaType
-            var mediaType = EnumConverter.ToMediaType(args[0].Trim('"'));
-            if (mediaType == MediaType.NONE)
-            {
-                DisplayHelp($"{args[0]} is not a recognized media type");
-                return;
-            }
-
-            // Check the RedumpSystem
-            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
-            if (knownSystem == null)
-            {
-                DisplayHelp($"{args[1]} is not a recognized system");
-                return;
-            }
-
-            // Default values
-            string username = null, password = null;
-            string internalProgram = "DiscImageCreator";
-            string path = string.Empty;
-            bool scan = false, compress = false, json = false;
 
             // Loop through and process options
-            int startIndex = 2;
-            for (; startIndex < args.Length; startIndex++)
+            (var options, var seedInfo, var path, int startIndex) = OptionsLoader.LoadFromArguments(args, startIndex: 2);
+            if (options.InternalProgram == InternalProgram.NONE)
             {
-                // Redump login
-                if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--credentials="))
-                {
-                    string[] credentials = args[startIndex].Split('=')[1].Split(';');
-                    username = credentials[0];
-                    password = credentials[1];
-                }
-                else if (args[startIndex] == "-c" || args[startIndex] == "--credentials")
-                {
-                    username = args[startIndex + 1];
-                    password = args[startIndex + 2];
-                    startIndex += 2;
-                }
-
-                // Use specific program
-                else if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
-                {
-                    internalProgram = args[startIndex].Split('=')[1];
-                }
-                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
-                {
-                    internalProgram = args[startIndex + 1];
-                    startIndex++;
-                }
-
-                // Use a device path for physical checks
-                else if (args[startIndex].StartsWith("-p=") || args[startIndex].StartsWith("--path="))
-                {
-                    path = args[startIndex].Split('=')[1];
-                }
-                else if (args[startIndex] == "-p" || args[startIndex] == "--path")
-                {
-                    path = args[startIndex + 1];
-                    startIndex++;
-                }
-
-                // Scan for protection (requires device path)
-                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
-                {
-                    scan = true;
-                }
-
-                // Output submission JSON
-                else if (args[startIndex].Equals("-j") || args[startIndex].Equals("--json"))
-                {
-                    json = true;
-                }
-
-                // Compress log and extraneous files
-                else if (args[startIndex].Equals("-z") || args[startIndex].Equals("--zip"))
-                {
-                    compress = true;
-                }
-
-                // Default, we fall out
-                else
-                {
-                    break;
-                }
+                DisplayHelp("A program name needs to be provided");
+                return;
             }
 
             // Make new Progress objects
             var resultProgress = new Progress<Result>();
-            resultProgress.ProgressChanged += ProgressUpdated;
+            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
             var protectionProgress = new Progress<ProtectionProgress>();
-            protectionProgress.ProgressChanged += ProgressUpdated;
+            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
 
-            // If credentials are invalid, alert the user
-            if (!string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(password))
-            {
-                using (RedumpWebClient wc = new RedumpWebClient())
-                {
-                    bool? loggedIn = wc.Login(username, password);
-                    if (loggedIn == true)
-                        Console.WriteLine("Redump username and password accepted!");
-                    else if (loggedIn == false)
-                        Console.WriteLine("Redump username and password denied!");
-                    else
-                        Console.WriteLine("An error occurred validating your crendentials!");
-                }
-            }
+            // Validate the supplied credentials
+#if NETFRAMEWORK
+            (bool? _, string? message) = RedumpWebClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty);
+#else
+            (bool? _, string? message) = RedumpHttpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).ConfigureAwait(false).GetAwaiter().GetResult();
+#endif
+            if (!string.IsNullOrEmpty(message))
+                Console.WriteLine(message);
 
             // Loop through all the rest of the args
             for (int i = startIndex; i < args.Length; i++)
@@ -171,27 +67,20 @@ namespace MPF.Check
                 string filepath = Path.GetFullPath(args[i].Trim('"'));
 
                 // Now populate an environment
-                var options = new Options
-                {
-                    InternalProgram = EnumConverter.ToInternalProgram(internalProgram),
-                    ScanForProtection = scan && !string.IsNullOrWhiteSpace(path),
-                    PromptForDiscInformation = false,
-                    ShowDiscEjectReminder = false,
-                    OutputSubmissionJSON = json,
-                    CompressLogFiles = compress,
+                Drive? drive = null;
+                if (!string.IsNullOrEmpty(path))
+                    drive = Drive.Create(null, path!);
 
-                    RedumpUsername = username,
-                    RedumpPassword = password,
-                };
-
-                Drive drive = null;
-                if (!string.IsNullOrWhiteSpace(path))
-                    drive = new Drive(null, new DriveInfo(path));
-
-                var env = new DumpEnvironment(options, "", filepath, drive, knownSystem, mediaType, null);
+                var env = new DumpEnvironment(options, filepath, drive, knownSystem, mediaType, internalProgram: null, parameters: null);
 
                 // Finally, attempt to do the output dance
+#if NET40
+                var resultTask = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress);
+                resultTask.Wait();
+                var result = resultTask.Result;
+#else
                 var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress).ConfigureAwait(false).GetAwaiter().GetResult();
+#endif
                 Console.WriteLine(result.Message);
             }
         }
@@ -200,7 +89,7 @@ namespace MPF.Check
         /// Display help for MPF.Check
         /// </summary>
         /// <param name="error">Error string to prefix the help text with</param>
-        private static void DisplayHelp(string error = null)
+        private static void DisplayHelp(string? error = null)
         {
             if (error != null)
                 Console.WriteLine(error);
@@ -214,77 +103,14 @@ namespace MPF.Check
             Console.WriteLine("-ls, --listsystems      List supported system types");
             Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
             Console.WriteLine();
+
             Console.WriteLine("Check Options:");
-            Console.WriteLine("-c, --credentials <user> <pw>  Redump username and password");
-            Console.WriteLine("-u, --use <program>            Dumping program output type");
-            Console.WriteLine("-p, --path <drivepath>         Physical drive path for additional checks");
-            Console.WriteLine("-s, --scan                     Enable copy protection scan (requires --path)");
-            Console.WriteLine("-j, --json                     Enable submission JSON output");
-            Console.WriteLine("-z, --zip                      Enable log file compression");
+            var supportedArguments = OptionsLoader.PrintSupportedArguments();
+            foreach (string argument in supportedArguments)
+            {
+                Console.WriteLine(argument);
+            }
             Console.WriteLine();
         }
-
-        /// <summary>
-        /// List all media types with their short usable names
-        /// </summary>
-        private static void ListMediaTypes()
-        {
-            Console.WriteLine("Supported Media Types:");
-            foreach (var val in Enum.GetValues(typeof(MediaType)))
-            {
-                if (((MediaType)val) == MediaType.NONE)
-                    continue;
-
-                Console.WriteLine($"{((MediaType?)val).ShortName()} - {((MediaType?)val).LongName()}");
-            }
-        }
-
-        /// <summary>
-        /// List all programs with their short usable names
-        /// </summary>
-        private static void ListPrograms()
-        {
-            Console.WriteLine("Supported Programs:");
-            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
-            {
-                if (((InternalProgram)val) == InternalProgram.NONE)
-                    continue;
-
-                Console.WriteLine($"{((InternalProgram?)val).LongName()}");
-            }
-        }
-
-        /// <summary>
-        /// List all systems with their short usable names
-        /// </summary>
-        private static void ListSystems()
-        {
-            Console.WriteLine("Supported Known Systems:");
-            var knownSystems = Enum.GetValues(typeof(RedumpSystem))
-                .OfType<RedumpSystem?>()
-                .Where(s => s != null && !s.IsMarker() && s.GetCategory() != SystemCategory.NONE)
-                .OrderBy(s => s.LongName() ?? string.Empty);
-
-            foreach (var val in knownSystems)
-            {
-                Console.WriteLine($"{val.ShortName()} - {val.LongName()}");
-            }
-        }
-
-        /// <summary>
-        /// Simple process counter to write to console
-        /// </summary>
-        private static void ProgressUpdated(object sender, Result value)
-        {
-            Console.WriteLine(value.Message);
-        }
-
-        /// <summary>
-        /// Simple process counter to write to console
-        /// </summary>
-        private static void ProgressUpdated(object sender, ProtectionProgress value)
-        {
-            Console.WriteLine($"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}");
-        }
     }
 }

MPF.Core/AssemblyInfo.cs

@@ -1,4 +0,0 @@
-using System.Runtime.CompilerServices;
-
-// Anything marked as internal can be used by the test methods
-[assembly: InternalsVisibleTo("MPF.Test")]

MPF.Core/ConsoleLogger.cs

@@ -0,0 +1,25 @@
+using System;
+using BinaryObjectScanner;
+using MPF.Core.Data;
+
+namespace MPF.Core
+{
+    public static class ConsoleLogger
+    {
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, Result value)
+        {
+            Console.WriteLine(value.Message);
+        }
+
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, ProtectionProgress value)
+        {
+            Console.WriteLine($"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}");
+        }
+    }
+}

MPF.Core/Converters/EnumConverter.cs

@@ -1,12 +1,13 @@
 using System;
+#if NET20 || NET35
+using System.Collections.Generic;
+#else
 using System.Collections.Concurrent;
+#endif
 using System.IO;
 using System.Reflection;
-#if NET_FRAMEWORK
-using IMAPI2;
-#endif
 using MPF.Core.Data;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Converters
 {
@@ -21,60 +22,15 @@ namespace MPF.Core.Converters
         /// <returns>InternalDriveType, if possible, null on error</returns>
         public static InternalDriveType? ToInternalDriveType(this DriveType driveType)
         {
-            switch (driveType)
+            return driveType switch
             {
-                case DriveType.CDRom:
-                    return InternalDriveType.Optical;
-                case DriveType.Fixed:
-                    return InternalDriveType.HardDisk;
-                case DriveType.Removable:
-                    return InternalDriveType.Removable;
-                default:
-                    return null;
-            }
+                DriveType.CDRom => (InternalDriveType?)InternalDriveType.Optical,
+                DriveType.Fixed => (InternalDriveType?)InternalDriveType.HardDisk,
+                DriveType.Removable => (InternalDriveType?)InternalDriveType.Removable,
+                _ => null,
+            };
         }
 
-#if NET_FRAMEWORK
-        /// <summary>
-        /// Convert IMAPI physical media type to a MediaType
-        /// </summary>
-        /// <param name="type">IMAPI_MEDIA_PHYSICAL_TYPE value to check</param>
-        /// <returns>MediaType if possible, null on error</returns>
-        public static MediaType? IMAPIToMediaType(this IMAPI_MEDIA_PHYSICAL_TYPE type)
-        {
-            switch (type)
-            {
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN:
-                    return MediaType.NONE;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW:
-                    return MediaType.CDROM;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER:
-                    return MediaType.DVD;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM:
-                    return MediaType.HDDVD;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE:
-                    return MediaType.BluRay;
-                default:
-                    return null;
-            }
-        }
-#endif
-
         #endregion
 
         #region Convert to Long Name
@@ -82,7 +38,11 @@ namespace MPF.Core.Converters
         /// <summary>
         /// Long name method cache
         /// </summary>
-        private static readonly ConcurrentDictionary<Type, MethodInfo> LongNameMethods = new ConcurrentDictionary<Type, MethodInfo>();
+#if NET20 || NET35
+        private static readonly Dictionary<Type, MethodInfo?> LongNameMethods = [];
+#else
+        private static readonly ConcurrentDictionary<Type, MethodInfo?> LongNameMethods = [];
+#endif
 
         /// <summary>
         /// Get the string representation of a generic enumerable value
@@ -93,21 +53,23 @@ namespace MPF.Core.Converters
         {
             try
             {
-                var sourceType = value?.GetType();
+                var sourceType = value.GetType();
                 sourceType = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
 
-                if (!LongNameMethods.TryGetValue(sourceType, out MethodInfo method))
+                if (!LongNameMethods.TryGetValue(sourceType, out var method))
                 {
-                    
-                    method = typeof(RedumpLib.Data.Extensions).GetMethod("LongName", new[] { typeof(Nullable<>).MakeGenericType(sourceType) });
-                    if (method == null)
-                        method = typeof(EnumConverter).GetMethod("LongName", new[] { typeof(Nullable<>).MakeGenericType(sourceType) });
+                    method = typeof(Extensions).GetMethod("LongName", [typeof(Nullable<>).MakeGenericType(sourceType)]);
+                    method ??= typeof(EnumConverter).GetMethod("LongName", [typeof(Nullable<>).MakeGenericType(sourceType)]);
 
+#if NET20 || NET35
+                    LongNameMethods[sourceType] = method;
+#else
                     LongNameMethods.TryAdd(sourceType, method);
+#endif
                 }
 
                 if (method != null)
-                    return method.Invoke(null, new[] { value }) as string;
+                    return method.Invoke(null, new[] { value }) as string ?? string.Empty;
                 else
                     return string.Empty;
             }
@@ -125,36 +87,65 @@ namespace MPF.Core.Converters
         /// <returns>String representing the value, if possible</returns>
         public static string LongName(this InternalProgram? prog)
         {
-            switch (prog)
+            return (prog) switch
             {
                 #region Dumping support
 
-                case InternalProgram.Aaru:
-                    return "Aaru";
-                case InternalProgram.DD:
-                    return "dd";
-                case InternalProgram.DiscImageCreator:
-                    return "DiscImageCreator";
+                InternalProgram.Aaru => "Aaru",
+                InternalProgram.DiscImageCreator => "DiscImageCreator",
+                InternalProgram.Redumper => "Redumper",
 
                 #endregion
 
                 #region Verification support only
 
-                case InternalProgram.CleanRip:
-                    return "CleanRip";
-
-                case InternalProgram.DCDumper:
-                    return "DCDumper";
-
-                case InternalProgram.UmdImageCreator:
-                    return "UmdImageCreator";
+                InternalProgram.CleanRip => "CleanRip",
+                InternalProgram.DCDumper => "DCDumper",
+                InternalProgram.PS3CFW => "PS3 CFW",
+                InternalProgram.UmdImageCreator => "UmdImageCreator",
 
                 #endregion
 
-                case InternalProgram.NONE:
-                default:
-                    return "Unknown";
-            }
+                InternalProgram.NONE => "Unknown",
+                _ => "Unknown",
+            };
+        }
+
+        /// <summary>
+        /// Get the string representation of the RedumperReadMethod enum values
+        /// </summary>
+        /// <param name="method">RedumperReadMethod value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperReadMethod? method)
+        {
+            return (method) switch
+            {
+                RedumperReadMethod.D8 => "D8",
+                RedumperReadMethod.BE => "BE",
+                RedumperReadMethod.BE_CDDA => "BE_CDDA",
+
+                RedumperReadMethod.NONE => "Default",
+                _ => "Unknown",
+            };
+        }
+
+        /// <summary>
+        /// Get the string representation of the RedumperSectorOrder enum values
+        /// </summary>
+        /// <param name="order">RedumperSectorOrder value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperSectorOrder? order)
+        {
+            return (order) switch
+            {
+                RedumperSectorOrder.DATA_C2_SUB => "DATA_C2_SUB",
+                RedumperSectorOrder.DATA_SUB_C2 => "DATA_SUB_C2",
+                RedumperSectorOrder.DATA_SUB => "DATA_SUB",
+                RedumperSectorOrder.DATA_C2 => "DATA_C2",
+
+                RedumperSectorOrder.NONE => "Default",
+                _ => "Unknown",
+            };
         }
 
         #endregion
@@ -166,41 +157,40 @@ namespace MPF.Core.Converters
         /// </summary>
         /// <param name="internalProgram">String value to convert</param>
         /// <returns>InternalProgram represented by the string, if possible</returns>
-        public static InternalProgram ToInternalProgram(string internalProgram)
+        public static InternalProgram ToInternalProgram(string? internalProgram)
         {
-            switch (internalProgram.ToLowerInvariant())
+            return (internalProgram?.ToLowerInvariant()) switch
             {
                 // Dumping support
-                case "aaru":
-                case "chef":
-                case "dichef":
-                case "discimagechef":
-                    return InternalProgram.Aaru;
-                case "creator":
-                case "dic":
-                case "dicreator":
-                case "discimagecreator":
-                    return InternalProgram.DiscImageCreator;
-                case "dd":
-                    return InternalProgram.DD;
+                "aaru"
+                    or "chef"
+                    or "dichef"
+                    or "discimagechef" => InternalProgram.Aaru,
+                "creator"
+                    or "dic"
+                    or "dicreator"
+                    or "discimagecreator" => InternalProgram.DiscImageCreator,
+                "rd"
+                    or "redumper" => InternalProgram.Redumper,
 
                 // Verification support only
-                case "cleanrip":
-                case "cr":
-                    return InternalProgram.CleanRip;
-                case "dc":
-                case "dcd":
-                case "dcdumper":
-                    return InternalProgram.DCDumper;
-                case "uic":
-                case "umd":
-                case "umdcreator":
-                case "umdimagecreator":
-                    return InternalProgram.UmdImageCreator;
+                "cleanrip"
+                    or "cr" => InternalProgram.CleanRip,
+                "dc"
+                    or "dcd"
+                    or "dcdumper" => InternalProgram.DCDumper,
+                "ps3cfw"
+                    or "ps3"
+                    or "getkey"
+                    or "managunz"
+                    or "multiman" => InternalProgram.PS3CFW,
+                "uic"
+                    or "umd"
+                    or "umdcreator"
+                    or "umdimagecreator" => InternalProgram.UmdImageCreator,
 
-                default:
-                    return InternalProgram.NONE;
-            }
+                _ => InternalProgram.NONE,
+            };
         }
 
         /// <summary>
@@ -210,170 +200,190 @@ namespace MPF.Core.Converters
         /// <returns>MediaType represented by the string, if possible</returns>
         public static MediaType ToMediaType(string type)
         {
-            switch (type.ToLowerInvariant())
+            return (type.ToLowerInvariant()) switch
             {
                 #region Punched Media
 
-                case "aperture":
-                case "aperturecard":
-                case "aperture card":
-                    return MediaType.ApertureCard;
-                case "jacquardloom":
-                case "jacquardloomcard":
-                case "jacquard loom card":
-                    return MediaType.JacquardLoomCard;
-                case "magneticstripe":
-                case "magneticstripecard":
-                case "magnetic stripe card":
-                    return MediaType.MagneticStripeCard;
-                case "opticalphone":
-                case "opticalphonecard":
-                case "optical phonecard":
-                    return MediaType.OpticalPhonecard;
-                case "punchcard":
-                case "punchedcard":
-                case "punched card":
-                    return MediaType.PunchedCard;
-                case "punchtape":
-                case "punchedtape":
-                case "punched tape":
-                    return MediaType.PunchedTape;
+                "aperture"
+                    or "aperturecard"
+                    or "aperture card" => MediaType.ApertureCard,
+                "jacquardloom"
+                    or "jacquardloomcard"
+                    or "jacquard loom card" => MediaType.JacquardLoomCard,
+                "magneticstripe"
+                    or "magneticstripecard"
+                    or "magnetic stripe card" => MediaType.MagneticStripeCard,
+                "opticalphone"
+                    or "opticalphonecard"
+                    or "optical phonecard" => MediaType.OpticalPhonecard,
+                "punchcard"
+                    or "punchedcard"
+                    or "punched card" => MediaType.PunchedCard,
+                "punchtape"
+                    or "punchedtape"
+                    or "punched tape" => MediaType.PunchedTape,
 
                 #endregion
 
                 #region Tape
 
-                case "openreel":
-                case "openreeltape":
-                case "open reel tape":
-                    return MediaType.OpenReel;
-                case "datacart":
-                case "datacartridge":
-                case "datatapecartridge":
-                case "data tape cartridge":
-                    return MediaType.DataCartridge;
-                case "cassette":
-                case "cassettetape":
-                case "cassette tape":
-                    return MediaType.Cassette;
+                "openreel"
+                    or "openreeltape"
+                    or "open reel tape" => MediaType.OpenReel,
+                "datacart"
+                    or "datacartridge"
+                    or "datatapecartridge"
+                    or "data tape cartridge" => MediaType.DataCartridge,
+                "cassette"
+                    or "cassettetape"
+                    or "cassette tape" => MediaType.Cassette,
 
                 #endregion
 
                 #region Disc / Disc
 
-                case "bd":
-                case "bdrom":
-                case "bd-rom":
-                case "bluray":
-                    return MediaType.BluRay;
-                case "cd":
-                case "cdrom":
-                case "cd-rom":
-                    return MediaType.CDROM;
-                case "dvd":
-                case "dvd5":
-                case "dvd-5":
-                case "dvd9":
-                case "dvd-9":
-                case "dvdrom":
-                case "dvd-rom":
-                    return MediaType.DVD;
-                case "fd":
-                case "floppy":
-                case "floppydisk":
-                case "floppy disk":
-                case "floppy diskette":
-                    return MediaType.FloppyDisk;
-                case "floptical":
-                    return MediaType.Floptical;
-                case "gd":
-                case "gdrom":
-                case "gd-rom":
-                    return MediaType.GDROM;
-                case "hddvd":
-                case "hd-dvd":
-                case "hddvdrom":
-                case "hd-dvd-rom":
-                    return MediaType.HDDVD;
-                case "hdd":
-                case "harddisk":
-                case "hard disk":
-                    return MediaType.HardDisk;
-                case "bernoullidisk":
-                case "iomegabernoullidisk":
-                case "bernoulli disk":
-                case "iomega bernoulli disk":
-                    return MediaType.IomegaBernoulliDisk;
-                case "jaz":
-                case "iomegajaz":
-                case "iomega jaz":
-                    return MediaType.IomegaJaz;
-                case "zip":
-                case "zipdisk":
-                case "iomegazip":
-                case "iomega zip":
-                    return MediaType.IomegaZip;
-                case "ldrom":
-                case "lvrom":
-                case "ld-rom":
-                case "lv-rom":
-                case "laserdisc":
-                case "laservision":
-                case "ld-rom / lv-rom":
-                    return MediaType.LaserDisc;
-                case "64dd":
-                case "n64dd":
-                case "64dddisk":
-                case "n64dddisk":
-                case "64dd disk":
-                case "n64dd disk":
-                    return MediaType.Nintendo64DD;
-                case "fds":
-                case "famicom":
-                case "nfds":
-                case "nintendofamicom":
-                case "famicomdisksystem":
-                case "famicom disk system":
-                case "famicom disk system disk":
-                    return MediaType.NintendoFamicomDiskSystem;
-                case "gc":
-                case "gamecube":
-                case "nintendogamecube":
-                case "nintendo gamecube":
-                case "gamecube disc":
-                case "gamecube game disc":
-                    return MediaType.NintendoGameCubeGameDisc;
-                case "wii":
-                case "nintendowii":
-                case "nintendo wii":
-                case "nintendo wii disc":
-                case "wii optical disc":
-                    return MediaType.NintendoWiiOpticalDisc;
-                case "wiiu":
-                case "nintendowiiu":
-                case "nintendo wiiu":
-                case "nintendo wiiu disc":
-                case "wiiu optical disc":
-                case "wii u optical disc":
-                    return MediaType.NintendoWiiUOpticalDisc;
-                case "umd":
-                    return MediaType.UMD;
+                "bd"
+                    or "bdrom"
+                    or "bd-rom"
+                    or "bluray" => MediaType.BluRay,
+                "cd"
+                    or "cdrom"
+                    or "cd-rom" => MediaType.CDROM,
+                "dvd"
+                    or "dvd5"
+                    or "dvd-5"
+                    or "dvd9"
+                    or "dvd-9"
+                    or "dvdrom"
+                    or "dvd-rom" => MediaType.DVD,
+                "fd"
+                    or "floppy"
+                    or "floppydisk"
+                    or "floppy disk"
+                    or "floppy diskette" => MediaType.FloppyDisk,
+                "floptical" => MediaType.Floptical,
+                "gd"
+                    or "gdrom"
+                    or "gd-rom" => MediaType.GDROM,
+                "hddvd"
+                    or "hd-dvd"
+                    or "hddvdrom"
+                    or "hd-dvd-rom" => MediaType.HDDVD,
+                "hdd"
+                    or "harddisk"
+                    or "hard disk" => MediaType.HardDisk,
+                "bernoullidisk"
+                    or "iomegabernoullidisk"
+                    or "bernoulli disk"
+                    or "iomega bernoulli disk" => MediaType.IomegaBernoulliDisk,
+                "jaz"
+                    or "iomegajaz"
+                    or "iomega jaz" => MediaType.IomegaJaz,
+                "zip"
+                    or "zipdisk"
+                    or "iomegazip"
+                    or "iomega zip" => MediaType.IomegaZip,
+                "ldrom"
+                    or "lvrom"
+                    or "ld-rom"
+                    or "lv-rom"
+                    or "laserdisc"
+                    or "laservision"
+                    or "ld-rom / lv-rom" => MediaType.LaserDisc,
+                "64dd"
+                    or "n64dd"
+                    or "64dddisk"
+                    or "n64dddisk"
+                    or "64dd disk"
+                    or "n64dd disk" => MediaType.Nintendo64DD,
+                "fds"
+                    or "famicom"
+                    or "nfds"
+                    or "nintendofamicom"
+                    or "famicomdisksystem"
+                    or "famicom disk system"
+                    or "famicom disk system disk" => MediaType.NintendoFamicomDiskSystem,
+                "gc"
+                    or "gamecube"
+                    or "nintendogamecube"
+                    or "nintendo gamecube"
+                    or "gamecube disc"
+                    or "gamecube game disc" => MediaType.NintendoGameCubeGameDisc,
+                "wii"
+                    or "nintendowii"
+                    or "nintendo wii"
+                    or "nintendo wii disc"
+                    or "wii optical disc" => MediaType.NintendoWiiOpticalDisc,
+                "wiiu"
+                    or "nintendowiiu"
+                    or "nintendo wiiu"
+                    or "nintendo wiiu disc"
+                    or "wiiu optical disc"
+                    or "wii u optical disc" => MediaType.NintendoWiiUOpticalDisc,
+                "umd" => MediaType.UMD,
 
                 #endregion
 
                 // Unsorted Formats
-                case "cartridge":
-                    return MediaType.Cartridge;
-                case "ced":
-                case "rcaced":
-                case "rca ced":
-                case "videodisc":
-                case "rca videodisc":
-                    return MediaType.CED;
+                "cartridge" => MediaType.Cartridge,
+                "ced"
+                    or "rcaced"
+                    or "rca ced"
+                    or "videodisc"
+                    or "rca videodisc" => MediaType.CED,
 
-                default:
-                    return MediaType.NONE;
-            }
+                _ => MediaType.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperReadMethod enum value for a given string
+        /// </summary>
+        /// <param name="method">String value to convert</param>
+        /// <returns>RedumperReadMethod represented by the string, if possible</returns>
+        public static RedumperReadMethod ToRedumperReadMethod(string? method)
+        {
+            return (method?.ToLowerInvariant()) switch
+            {
+                "d8" => RedumperReadMethod.D8,
+                "be" => RedumperReadMethod.BE,
+                "be_cdda"
+                    or "be cdda"
+                    or "be-cdda"
+                    or "becdda" => RedumperReadMethod.BE_CDDA,
+
+                _ => RedumperReadMethod.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperSectorOrder enum value for a given string
+        /// </summary>
+        /// <param name="order">String value to convert</param>
+        /// <returns>RedumperSectorOrder represented by the string, if possible</returns>
+        public static RedumperSectorOrder ToRedumperSectorOrder(string? order)
+        {
+            return (order?.ToLowerInvariant()) switch
+            {
+                "data_c2_sub"
+                    or "data c2 sub"
+                    or "data-c2-sub"
+                    or "datac2sub" => RedumperSectorOrder.DATA_C2_SUB,
+                "data_sub_c2"
+                    or "data sub c2"
+                    or "data-sub-c2"
+                    or "datasubc2" => RedumperSectorOrder.DATA_SUB_C2,
+                "data_sub"
+                    or "data sub"
+                    or "data-sub"
+                    or "datasub" => RedumperSectorOrder.DATA_SUB,
+                "data_c2"
+                    or "data c2"
+                    or "data-c2"
+                    or "datac2" => RedumperSectorOrder.DATA_C2,
+
+                _ => RedumperSectorOrder.NONE,
+            };
         }
 
         #endregion

MPF.Core/Data/Constants.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Data
 {
@@ -14,36 +14,45 @@ namespace MPF.Core.Data
         public const string StopDumping = "Stop Dumping";
 
         // Byte arrays for signatures
-        public static readonly byte[] SaturnSectorZeroStart = new byte[] { 0x53, 0x45, 0x47, 0x41, 0x20, 0x53, 0x45, 0x47, 0x41, 0x53, 0x41, 0x54, 0x55, 0x52, 0x4E, 0x20 };
+        public static readonly byte[] SaturnSectorZeroStart = [0x53, 0x45, 0x47, 0x41, 0x20, 0x53, 0x45, 0x47, 0x41, 0x53, 0x41, 0x54, 0x55, 0x52, 0x4E, 0x20];
 
-        // Private lists of known drive speed ranges
-        private static IReadOnlyList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
-        private static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
-        private static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
-        private static IReadOnlyList<int> Unknown { get; } = new List<int> { 1 };
+        // Lists of known drive speed ranges
+#if NET20 || NET35 || NET40
+        public static IList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
+        public static IList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IList<int> HDDVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
+        public static IList<int> Unknown { get; } = new List<int> { 1 };
+#else
+        public static IReadOnlyList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
+        public static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IReadOnlyList<int> HDDVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
+        public static IReadOnlyList<int> Unknown { get; } = new List<int> { 1 };
+#endif
 
         /// <summary>
         /// Get list of all drive speeds for a given MediaType
         /// </summary>
         /// <param name="type">MediaType? that represents the current item</param>
         /// <returns>Read-only list of drive speeds</returns>
+#if NET20 || NET35 || NET40
+        public static IList<int> GetSpeedsForMediaType(MediaType? type)
+#else
         public static IReadOnlyList<int> GetSpeedsForMediaType(MediaType? type)
+#endif
         {
-            switch (type)
+            return type switch
             {
-                case MediaType.CDROM:
-                case MediaType.GDROM:
-                    return CD;
-                case MediaType.DVD:
-                case MediaType.HDDVD:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return DVD;
-                case MediaType.BluRay:
-                    return BD;
-                default:
-                    return Unknown;
-            }
+                MediaType.CDROM
+                    or MediaType.GDROM => CD,
+                MediaType.DVD
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => DVD,
+                MediaType.HDDVD => HDDVD,
+                MediaType.BluRay => BD,
+                _ => Unknown,
+            };
         }
     }
 
@@ -52,58 +61,6 @@ namespace MPF.Core.Data
     /// </summary>
     public static class Template
     {
-        // Manual information
-
-        public const string TitleField = "Title";
-        public const string ForeignTitleField = "Foreign Title (Non-latin)";
-        public const string DiscNumberField = "Disc Number / Letter";
-        public const string DiscTitleField = "Disc Title";
-        public const string SystemField = "System";
-        public const string MediaTypeField = "Media Type";
-        public const string CategoryField = "Category";
-        public const string RegionField = "Region";
-        public const string LanguagesField = "Languages";
-        public const string PlaystationLanguageSelectionViaField = "Language Selection Via";
-        public const string DiscSerialField = "Disc Serial";
-        public const string BarcodeField = "Barcode";
-        public const string CommentsField = "Comments";
-        public const string ContentsField = "Contents";
-        public const string VersionField = "Version";
-        public const string EditionField = "Edition/Release";
-        public const string PlayStation3WiiDiscKeyField = "Disc Key";
-        public const string PlayStation3DiscIDField = "Disc ID";
-        public const string GameCubeWiiBCAField = "BCA";
-        public const string CopyProtectionField = "Copy Protection";
-        public const string MasteringRingField = "Mastering Code (laser branded/etched)";
-        public const string MasteringSIDField = "Mastering SID Code";
-        public const string MouldSIDField = "Mould SID Code";
-        public const string AdditionalMouldField = "Additional Mould";
-        public const string ToolstampField = "Toolstamp or Mastering Code (engraved/stamped)";
-
-        // Automatic Information
-
-        public const string PVDField = "Primary Volume Descriptor (PVD)";
-        public const string DATField = "DAT";
-        public const string SizeField = "Size";
-        public const string CRC32Field = "CRC32";
-        public const string MD5Field = "MD5";
-        public const string SHA1Field = "SHA1";
-        public const string MatchingIDsField = "Matching IDs";
-        public const string ErrorCountField = "Error Count";
-        public const string CuesheetField = "Cuesheet";
-        public const string SubIntentionField = "SubIntention Data (SecuROM/LibCrypt)";
-        public const string WriteOffsetField = "Write Offset";
-        public const string LayerbreakField = "Layerbreak";
-        public const string EXEDateBuildDate = "EXE/Build Date";
-        public const string HeaderField = "Header";
-        public const string PICField = "Permanent Information & Control (PIC)";
-        public const string PlayStationEDCField = "EDC";
-        public const string PlayStationAntiModchipField = "Anti-modchip";
-        public const string PlayStationLibCryptField = "LibCrypt";
-        public const string XBOXSSRanges = "Security Sector Ranges";
-
-        // Default values
-
         public const string RequiredValue = "(REQUIRED)";
         public const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
         public const string OptionalValue = "(OPTIONAL)";

MPF.Core/Data/Drive.cs

@@ -2,24 +2,25 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Management;
-using MPF.Core.Converters;
-using MPF.Core.Utilities;
-using RedumpLib.Data;
-#if NET_FRAMEWORK
-using IMAPI2;
-#else
-using Aaru.CommonTypes.Enums;
-using AaruDevices = Aaru.Devices;
+#if NET462_OR_GREATER || NETCOREAPP
+using Microsoft.Management.Infrastructure;
+using Microsoft.Management.Infrastructure.Generic;
 #endif
+using MPF.Core.Converters;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Data
 {
     /// <summary>
     /// Represents information for a single drive
     /// </summary>
+    /// <remarks>
+    /// TODO: Can the Aaru models be used instead of the ones I've created here?
+    /// </remarks>
     public class Drive
     {
+        #region Fields
+
         /// <summary>
         /// Represents drive type
         /// </summary>
@@ -28,226 +29,236 @@ namespace MPF.Core.Data
         /// <summary>
         /// Drive partition format
         /// </summary>
-        public string DriveFormat => driveInfo?.DriveFormat;
-
-        /// <summary>
-        /// Windows drive letter
-        /// </summary>
-        public char Letter => driveInfo?.Name[0] ?? '\0';
+        public string? DriveFormat { get; private set; } = null;
 
         /// <summary>
         /// Windows drive path
         /// </summary>
-        public string Name => driveInfo?.Name;
+        public string? Name { get; private set; } = null;
 
         /// <summary>
         /// Represents if Windows has marked the drive as active
         /// </summary>
-        public bool MarkedActive => driveInfo?.IsReady ?? false;
+        public bool MarkedActive { get; private set; } = false;
+
+        /// <summary>
+        /// Represents the total size of the drive
+        /// </summary>
+        public long TotalSize { get; private set; } = default;
 
         /// <summary>
         /// Media label as read by Windows
         /// </summary>
         /// <remarks>The try/catch is needed because Windows will throw an exception if the drive is not marked as active</remarks>
-        public string VolumeLabel
-        {
-            get
-            {
-                try
-                {
-                    return driveInfo?.VolumeLabel;
-                }
-                catch
-                {
-                    return null;
-                }
-            }
-        }
+        public string? VolumeLabel { get; private set; } = null;
+
+        #endregion
+
+        #region Derived Fields
 
         /// <summary>
         /// Media label as read by Windows, formatted to avoid odd outputs
+        /// If no volume label present, use PSX or PS2 serial if valid
+        /// Otherwise, use "track" as volume label
         /// </summary>
-        public string FormattedVolumeLabel
+        public string? FormattedVolumeLabel
         {
             get
             {
-                string volumeLabel = Template.DiscNotDetected;
-                if (driveInfo.IsReady)
+                string? volumeLabel = Template.DiscNotDetected;
+                if (!this.MarkedActive)
+                    return volumeLabel;
+
+                if (!string.IsNullOrEmpty(this.VolumeLabel))
                 {
-                    if (string.IsNullOrWhiteSpace(driveInfo.VolumeLabel))
-                        volumeLabel = "track";
-                    else
-                        volumeLabel = driveInfo.VolumeLabel;
+                    volumeLabel = this.VolumeLabel;
+                }
+                else
+                {
+                    // No Volume Label found, fallback to something sensible
+                    switch (this.GetRedumpSystem(null))
+                    {
+                        case RedumpSystem.SonyPlayStation:
+                        case RedumpSystem.SonyPlayStation2:
+                            InfoTool.GetPlayStationExecutableInfo(this.Name, out string? serial, out _, out _);
+                            volumeLabel = serial ?? "track";
+                            break;
+
+                        default:
+                            volumeLabel = "track";
+                            break;
+                    }
                 }
 
                 foreach (char c in Path.GetInvalidFileNameChars())
-                    volumeLabel = volumeLabel.Replace(c, '_');
+                    volumeLabel = volumeLabel?.Replace(c, '_');
 
                 return volumeLabel;
             }
         }
 
         /// <summary>
-        /// DriveInfo object representing the drive, if possible
+        /// Read-only access to the drive letter
         /// </summary>
-        private readonly DriveInfo driveInfo;
+        /// <remarks>Should only be used in UI applications</remarks>
+        public char? Letter => this.Name?[0] ?? '\0';
 
-        public Drive(InternalDriveType? driveType, DriveInfo driveInfo)
+        #endregion
+
+        /// <summary>
+        /// Protected constructor
+        /// </summary>
+        protected Drive() { }
+
+        /// <summary>
+        /// Create a new Drive object from a drive type and device path
+        /// </summary>
+        /// <param name="driveType">InternalDriveType value representing the drive type</param>
+        /// <param name="devicePath">Path to the device according to the local machine</param>
+        public static Drive? Create(InternalDriveType? driveType, string devicePath)
         {
-            this.InternalDriveType = driveType;
-            this.driveInfo = driveInfo;
+            // Create a new, empty drive object
+            var drive = new Drive()
+            {
+                InternalDriveType = driveType,
+            };
+
+            // If we have an invalid device path, return null
+            if (string.IsNullOrEmpty(devicePath))
+                return null;
+
+            // Sanitize a Windows-formatted long device path
+            if (devicePath.StartsWith("\\\\.\\"))
+                devicePath = devicePath.Substring("\\\\.\\".Length);
+
+            // Create and validate the drive info object
+            var driveInfo = new DriveInfo(devicePath);
+            if (driveInfo == null || driveInfo == default)
+                return null;
+
+            // Fill in the rest of the data
+            drive.PopulateFromDriveInfo(driveInfo);
+
+            return drive;
         }
 
+        /// <summary>
+        /// Populate all fields from a DriveInfo object
+        /// </summary>
+        /// <param name="driveInfo">DriveInfo object to populate from</param>
+        private void PopulateFromDriveInfo(DriveInfo? driveInfo)
+        {
+            // If we have an invalid DriveInfo, just return
+            if (driveInfo == null || driveInfo == default)
+                return;
+
+            // Populate the data fields
+            this.Name = driveInfo.Name;
+            this.MarkedActive = driveInfo.IsReady;
+            if (this.MarkedActive)
+            {
+                this.DriveFormat = driveInfo.DriveFormat;
+                this.TotalSize = driveInfo.TotalSize;
+                this.VolumeLabel = driveInfo.VolumeLabel;
+            }
+            else
+            {
+                this.DriveFormat = string.Empty;
+                this.TotalSize = default;
+                this.VolumeLabel = string.Empty;
+            }
+        }
+
+        #region Public Functionality
+
         /// <summary>
         /// Create a list of active drives matched to their volume labels
         /// </summary>
-        /// <param name="ignoreFixedDrives">Ture to ignore fixed drives from population, false otherwise</param>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
         /// <returns>Active drives, matched to labels, if possible</returns>
-        /// <remarks>
-        /// https://stackoverflow.com/questions/3060796/how-to-distinguish-between-usb-and-floppy-devices?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
-        /// https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx
-        /// </remarks>
         public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
         {
-            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
-            if (!ignoreFixedDrives)
-            {
-                desiredDriveTypes.Add(DriveType.Fixed);
-                desiredDriveTypes.Add(DriveType.Removable);
-            }
-
-            // Get all supported drive types
-            var drives = DriveInfo.GetDrives()
-                .Where(d => desiredDriveTypes.Contains(d.DriveType))
-                .Select(d => new Drive(EnumConverter.ToInternalDriveType(d.DriveType), d))
-                .ToList();
-
-            // TODO: Management searcher stuff is not supported on other platforms
-            // Get the floppy drives and set the flag from removable
-            try
-            {
-                ManagementObjectSearcher searcher =
-                    new ManagementObjectSearcher("root\\CIMV2",
-                    "SELECT * FROM Win32_LogicalDisk");
-
-                var collection = searcher.Get();
-                foreach (ManagementObject queryObj in collection)
-                {
-                    uint? mediaType = (uint?)queryObj["MediaType"];
-                    if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
-                    {
-                        char devId = queryObj["DeviceID"].ToString()[0];
-                        drives.ForEach(d => { if (d.Letter == devId) { d.InternalDriveType = Data.InternalDriveType.Floppy; } });
-                    }
-                }
-            }
-            catch
-            {
-                // No-op
-            }
-
-            // Order the drives by drive letter
-            drives = drives.OrderBy(i => i.Letter).ToList();
-
+            var drives = GetDriveList(ignoreFixedDrives);
+            drives = [.. drives.OrderBy(i => i == null ? "\0" : i.Name)];
             return drives;
         }
 
         /// <summary>
         /// Get the current media type from drive letter
         /// </summary>
-        /// <param name="drive"></param>
+        /// <param name="system"></param>
         /// <returns></returns>
-        /// <remarks>
-        /// This may eventually be replaced by Aaru.Devices being able to be about 10x more accurate.
-        /// This will also end up making it so that IMAPI2 is no longer necessary. Unfortunately, that
-        /// will only work for .NET Core 3.1 and beyond.
-        /// </remarks>
-        public (MediaType?, string) GetMediaType()
+        public (MediaType?, string?) GetMediaType(RedumpSystem? system)
         {
             // Take care of the non-optical stuff first
-            // TODO: See if any of these can be more granular, like Optical is
-            if (this.InternalDriveType == Data.InternalDriveType.Floppy)
-                return (MediaType.FloppyDisk, null);
-            else if (this.InternalDriveType == Data.InternalDriveType.HardDisk)
-                return (MediaType.HardDisk, null);
-            else if (this.InternalDriveType == Data.InternalDriveType.Removable)
-                return (MediaType.FlashDrive, null);
-
-#if NET_FRAMEWORK
-            // Get the current drive information
-            string deviceId = null;
-            bool loaded = false;
-            try
+            switch (this.InternalDriveType)
             {
-                // Get the device ID first
-                var searcher = new ManagementObjectSearcher(
-                    "root\\CIMV2",
-                    $"SELECT * FROM Win32_CDROMDrive WHERE Id = '{this.Letter}:\'");
-
-                foreach (ManagementObject queryObj in searcher.Get())
-                {
-                    deviceId = (string)queryObj["DeviceID"];
-                    loaded = (bool)queryObj["MediaLoaded"];
-                }
-
-                // If we got no valid device, we don't care and just return
-                if (deviceId == null)
-                    return (null, "Device could not be found");
-                else if (!loaded)
-                    return (null, "Device is not reporting media loaded");
-
-                MsftDiscMaster2 discMaster = new MsftDiscMaster2();
-                deviceId = deviceId.ToLower().Replace('\\', '#').Replace('/', '#');
-                string id = null;
-                foreach (var disc in discMaster)
-                {
-                    if (disc.ToString().Contains(deviceId))
-                        id = disc.ToString();
-                }
-
-                // If we couldn't find the drive, we don't care and return
-                if (id == null)
-                    return (null, "Device ID could not be found");
-
-                // Create the required objects for reading from the drive
-                MsftDiscRecorder2 recorder = new MsftDiscRecorder2();
-                recorder.InitializeDiscRecorder(id);
-                MsftDiscFormat2Data dataWriter = new MsftDiscFormat2Data();
-
-                // If the recorder is not supported, just return
-                if (!dataWriter.IsRecorderSupported(recorder))
-                    return (null, "IMAPI2 recorder not supported");
-
-                // Otherwise, set the recorder to get information from
-                dataWriter.Recorder = recorder;
-
-                var media = dataWriter.CurrentPhysicalMediaType;
-                return (media.IMAPIToMediaType(), null);
-            }
-            catch (Exception ex)
-            {
-                return (null, ex.Message);
-            }
-#else
-            try
-            {
-                var device = new AaruDevices.Device(this.Name);
-                if (device.Error)
-                    return (null, "Could not open device");
-                else if (device.Type != DeviceType.ATAPI && device.Type != DeviceType.SCSI)
-                    return (null, "Device does not support media type detection");
-
-                // TODO: In order to get the disc type, Aaru.Core will need to be included as a
-                // package. Unfortunately, it currently has a conflict with one of the required libraries:
-                // System.Text.Encoding.CodePages (BOS uses >= 5.0.0, DotNetZip uses >= 4.5.0 && < 5.0.0)
-            }
-            catch (Exception ex)
-            {
-                return (null, ex.Message);
+                case Data.InternalDriveType.Floppy:
+                    return (MediaType.FloppyDisk, null);
+                case Data.InternalDriveType.HardDisk:
+                    return (MediaType.HardDisk, null);
+                case Data.InternalDriveType.Removable:
+                    return (MediaType.FlashDrive, null);
             }
 
-            return (null, "Media detection only supported on .NET Framework");
-#endif
+            // Some systems should default to certain media types
+            switch (system)
+            {
+                // CD
+                case RedumpSystem.Panasonic3DOInteractiveMultiplayer:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.SegaDreamcast:
+                case RedumpSystem.SegaSaturn:
+                case RedumpSystem.SonyPlayStation:
+                case RedumpSystem.VideoCD:
+                    return (MediaType.CDROM, null);
+
+                // DVD
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.MicrosoftXbox:
+                case RedumpSystem.MicrosoftXbox360:
+                    return (MediaType.DVD, null);
+
+                // HD-DVD
+                case RedumpSystem.HDDVDVideo:
+                    return (MediaType.HDDVD, null);
+
+                // Blu-ray
+                case RedumpSystem.BDVideo:
+                case RedumpSystem.MicrosoftXboxOne:
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                case RedumpSystem.SonyPlayStation3:
+                case RedumpSystem.SonyPlayStation4:
+                case RedumpSystem.SonyPlayStation5:
+                    return (MediaType.BluRay, null);
+
+                // GameCube
+                case RedumpSystem.NintendoGameCube:
+                    return (MediaType.NintendoGameCubeGameDisc, null);
+
+                // Wii
+                case RedumpSystem.NintendoWii:
+                    return (MediaType.NintendoWiiOpticalDisc, null);
+
+                // WiiU
+                case RedumpSystem.NintendoWiiU:
+                    return (MediaType.NintendoWiiUOpticalDisc, null);
+
+                // PSP
+                case RedumpSystem.SonyPlayStationPortable:
+                    return (MediaType.UMD, null);
+            }
+
+            // Handle optical media by size and filesystem
+            if (this.TotalSize >= 0 && this.TotalSize <= 800_000_000 && (this.DriveFormat == "CDFS" || this.DriveFormat == "UDF"))
+                return (MediaType.CDROM, null);
+            else if (this.TotalSize > 800_000_000 && this.TotalSize <= 8_540_000_000 && (this.DriveFormat == "CDFS" || this.DriveFormat == "UDF"))
+                return (MediaType.DVD, null);
+            else if (this.TotalSize > 8_540_000_000)
+                return (MediaType.BluRay, null);
+
+            return (null, "Could not determine media type!");
         }
 
         /// <summary>
@@ -257,65 +268,173 @@ namespace MPF.Core.Data
         /// <returns></returns>
         public RedumpSystem? GetRedumpSystem(RedumpSystem? defaultValue)
         {
-            string drivePath = $"{this.Letter}:\\";
-
             // If we can't read the media in that drive, we can't do anything
-            if (!Directory.Exists(drivePath))
+            if (string.IsNullOrEmpty(this.Name) || !Directory.Exists(this.Name))
                 return defaultValue;
 
             // We're going to assume for floppies, HDDs, and removable drives
-            // TODO: Try to be smarter about this
             if (this.InternalDriveType != Data.InternalDriveType.Optical)
                 return RedumpSystem.IBMPCcompatible;
 
             // Check volume labels first
-            RedumpSystem? systemFromLabel = GetRedumpSystemFromVolumeLabel();
+            RedumpSystem? systemFromLabel = GetRedumpSystemFromVolumeLabel(this.VolumeLabel);
             if (systemFromLabel != null)
                 return systemFromLabel;
 
+            // Get a list of files for quicker checking
+            #region Arcade
+
+            // funworld Photo Play
+            if (File.Exists(Path.Combine(this.Name, "PP.INF"))
+                && Directory.Exists(Path.Combine(this.Name, "PPINC")))
+            {
+                return RedumpSystem.funworldPhotoPlay;
+            }
+
+            // Konami Python 2
+            if (Directory.Exists(Path.Combine(this.Name, "PY2.D")))
+            {
+                return RedumpSystem.KonamiPython2;
+            }
+
+            #endregion
+
             #region Consoles
 
+            // Bandai Playdia Quick Interactive System
+            try
+            {
+#if NET20 || NET35
+                List<string> files = [.. Directory.GetFiles(this.Name, "*", SearchOption.TopDirectoryOnly)];
+#else
+                List<string> files = Directory.EnumerateFiles(this.Name, "*", SearchOption.TopDirectoryOnly).ToList();
+#endif
+
+                if (files.Any(f => f.EndsWith(".AJS", StringComparison.OrdinalIgnoreCase))
+                    && files.Any(f => f.EndsWith(".GLB", StringComparison.OrdinalIgnoreCase)))
+                {
+                    return RedumpSystem.BandaiPlaydiaQuickInteractiveSystem;
+                }
+            }
+            catch { }
+
+            // Bandai Pippin
+            if (File.Exists(Path.Combine(this.Name, "PippinAuthenticationFile")))
+            {
+                return RedumpSystem.BandaiPippin;
+            }
+
+            // Commodore CDTV/CD32
+#if NET20 || NET35
+            if (File.Exists(Path.Combine(Path.Combine(this.Name, "S"), "STARTUP-SEQUENCE")))
+#else
+            if (File.Exists(Path.Combine(this.Name, "S", "STARTUP-SEQUENCE")))
+#endif
+            {
+                if (File.Exists(Path.Combine(this.Name, "CDTV.TM")))
+                    return RedumpSystem.CommodoreAmigaCDTV;
+                else
+                    return RedumpSystem.CommodoreAmigaCD32;
+            }
+
+            // Mattel HyperScan -- TODO: May need case-insensitivity added
+            if (File.Exists(Path.Combine(this.Name, "hyper.exe")))
+            {
+                return RedumpSystem.MattelHyperScan;
+            }
+
+            // Mattel Fisher-Price iXL
+#if NET20 || NET35
+            if (File.Exists(Path.Combine(Path.Combine(this.Name, "iXL"), "iXLUpdater.exe")))
+#else
+            if (File.Exists(Path.Combine(this.Name, "iXL", "iXLUpdater.exe")))
+#endif
+            {
+                return RedumpSystem.MattelFisherPriceiXL;
+            }
+
             // Microsoft Xbox 360
             try
             {
-                if (Directory.Exists(Path.Combine(drivePath, "$SystemUpdate"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "$SystemUpdate")).Any())
+                if (Directory.Exists(Path.Combine(this.Name, "$SystemUpdate"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "$SystemUpdate")).Any()
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "$SystemUpdate")).Any()
+#endif
+                    && this.TotalSize <= 500_000_000)
                 {
                     return RedumpSystem.MicrosoftXbox360;
                 }
             }
             catch { }
 
+            // Microsoft Xbox One and Series X
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "MSXC")))
+                {
+                    try
+                    {
+#if NET20 || NET35
+                        string catalogjs = Path.Combine(this.Name, Path.Combine("MSXC", Path.Combine("Metadata", "catalog.js")));
+#else
+                        string catalogjs = Path.Combine(this.Name, "MSXC", "Metadata", "catalog.js");
+#endif
+                        if (!File.Exists(catalogjs))
+                            return RedumpSystem.MicrosoftXboxOne;
+
+                        SabreTools.Models.Xbox.Catalog? catalog = SabreTools.Serialization.Deserializers.Catalog.DeserializeFile(catalogjs);
+                        if (catalog != null && catalog.Version != null && catalog.Packages != null)
+                        {
+                            if (!double.TryParse(catalog.Version, out double version))
+                                return RedumpSystem.MicrosoftXboxOne;
+
+                            if (version < 4)
+                                return RedumpSystem.MicrosoftXboxOne;
+
+                            foreach (var package in catalog.Packages)
+                            {
+                                if (package.Generation != "9")
+                                    return RedumpSystem.MicrosoftXboxOne;
+                            }
+
+                            return RedumpSystem.MicrosoftXboxSeriesXS;
+                        }
+                    }
+                    catch
+                    {
+                        return RedumpSystem.MicrosoftXboxOne;
+                    }
+                }
+            }
+            catch { }
+
             // Sega Dreamcast
-            if (File.Exists(Path.Combine(drivePath, "IP.BIN")))
+            if (File.Exists(Path.Combine(this.Name, "IP.BIN")))
             {
                 return RedumpSystem.SegaDreamcast;
             }
 
             // Sega Mega-CD / Sega-CD
-            if (File.Exists(Path.Combine(drivePath, "_BOOT", "IP.BIN"))
-                || File.Exists(Path.Combine(drivePath, "_BOOT", "SP.BIN"))
-                || File.Exists(Path.Combine(drivePath, "_BOOT", "SP_AS.BIN"))
-                || File.Exists(Path.Combine(drivePath, "FILESYSTEM.BIN")))
+#if NET20 || NET35
+            if (File.Exists(Path.Combine(Path.Combine(this.Name, "_BOOT"), "IP.BIN"))
+                || File.Exists(Path.Combine(Path.Combine(this.Name, "_BOOT"), "SP.BIN"))
+                || File.Exists(Path.Combine(Path.Combine(this.Name, "_BOOT"), "SP_AS.BIN"))
+                || File.Exists(Path.Combine(this.Name, "FILESYSTEM.BIN")))
+#else
+            if (File.Exists(Path.Combine(this.Name, "_BOOT", "IP.BIN"))
+                || File.Exists(Path.Combine(this.Name, "_BOOT", "SP.BIN"))
+                || File.Exists(Path.Combine(this.Name, "_BOOT", "SP_AS.BIN"))
+                || File.Exists(Path.Combine(this.Name, "FILESYSTEM.BIN")))
+#endif
             {
                 return RedumpSystem.SegaMegaCDSegaCD;
             }
 
-            // Sega Saturn
-            try
-            {
-                byte[] sector = ReadSector(0);
-                if (sector != null)
-                {
-                    if (sector.StartsWith(Interface.SaturnSectorZeroStart))
-                        return RedumpSystem.SegaSaturn;
-                }
-            }
-            catch { }
-
             // Sony PlayStation and Sony PlayStation 2
-            string psxExePath = Path.Combine(drivePath, "PSX.EXE");
-            string systemCnfPath = Path.Combine(drivePath, "SYSTEM.CNF");
+            string psxExePath = Path.Combine(this.Name, "PSX.EXE");
+            string systemCnfPath = Path.Combine(this.Name, "SYSTEM.CNF");
             if (File.Exists(systemCnfPath))
             {
                 // Check for either BOOT or BOOT2
@@ -330,18 +449,61 @@ namespace MPF.Core.Data
                 return RedumpSystem.SonyPlayStation;
             }
 
+            // Sony PlayStation 3
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "PS3_GAME"))
+                    || Directory.Exists(Path.Combine(this.Name, "PS3_UPDATE"))
+                    || File.Exists(Path.Combine(this.Name, "PS3_DISC.SFB")))
+                {
+                    return RedumpSystem.SonyPlayStation3;
+                }
+            }
+            catch { }
+
+            // Sony PlayStation 4
+            // There are more possible paths that could be checked.
+            //  There are some entries that can be found on most PS4 discs:
+            //    "/app/GAME_SERIAL/app.pkg"
+            //    "/bd/param.sfo"
+            //    "/license/rif"
+            // There are also extra files that can be found on some discs:
+            //    "/patch/GAME_SERIAL/patch.pkg" can be found in Redump entry 66816.
+            //        Originally on disc as "/patch/CUSA11302/patch.pkg".
+            //        Is used as an on-disc update for the base game app without needing to get update from the internet.
+            //    "/addcont/GAME_SERIAL/CONTENT_ID/ac.pkg" can be found in Redump entry 97619.
+            //        Originally on disc as "/addcont/CUSA00288/FFXIVEXPS400001A/ac.pkg".
+#if NET20 || NET35
+            if (File.Exists(Path.Combine(Path.Combine(Path.Combine(this.Name, "PS4"), "UPDATE"), "PS4UPDATE.PUP")))
+#else
+            if (File.Exists(Path.Combine(this.Name, "PS4", "UPDATE", "PS4UPDATE.PUP")))
+#endif
+            {
+                return RedumpSystem.SonyPlayStation4;
+            }
+
             // V.Tech V.Flash / V.Smile Pro
-            if (File.Exists(Path.Combine(drivePath, "0SYSTEM")))
+            if (File.Exists(Path.Combine(this.Name, "0SYSTEM")))
             {
                 return RedumpSystem.VTechVFlashVSmilePro;
             }
 
             #endregion
 
+            #region Computers
+
+            // Sharp X68000
+            if (File.Exists(Path.Combine(this.Name, "COMMAND.X")))
+            {
+                return RedumpSystem.SharpX68000;
+            }
+
+            #endregion
+
             #region Video Formats
 
             // BD-Video
-            if (Directory.Exists(Path.Combine(drivePath, "BDMV")))
+            if (Directory.Exists(Path.Combine(this.Name, "BDMV")))
             {
                 // Technically BD-Audio has this as well, but it's hard to split that out right now
                 return RedumpSystem.BDVideo;
@@ -350,14 +512,22 @@ namespace MPF.Core.Data
             // DVD-Audio and DVD-Video
             try
             {
-                if (Directory.Exists(Path.Combine(drivePath, "AUDIO_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "AUDIO_TS")).Any())
+                if (Directory.Exists(Path.Combine(this.Name, "AUDIO_TS"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "AUDIO_TS")).Any())
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "AUDIO_TS")).Any())
+#endif
                 {
                     return RedumpSystem.DVDAudio;
                 }
 
-                else if (Directory.Exists(Path.Combine(drivePath, "VIDEO_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VIDEO_TS")).Any())
+                else if (Directory.Exists(Path.Combine(this.Name, "VIDEO_TS"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "VIDEO_TS")).Any())
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "VIDEO_TS")).Any())
+#endif
                 {
                     return RedumpSystem.DVDVideo;
                 }
@@ -367,19 +537,42 @@ namespace MPF.Core.Data
             // HD-DVD-Video
             try
             {
-                if (Directory.Exists(Path.Combine(drivePath, "HVDVD_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "HVDVD_TS")).Any())
+                if (Directory.Exists(Path.Combine(this.Name, "HVDVD_TS"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "HVDVD_TS")).Any())
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "HVDVD_TS")).Any())
+#endif
                 {
                     return RedumpSystem.HDDVDVideo;
                 }
             }
             catch { }
 
+            // Photo CD
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "PHOTO_CD"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "PHOTO_CD")).Any())
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "PHOTO_CD")).Any())
+#endif
+                {
+                    return RedumpSystem.PhotoCD;
+                }
+            }
+            catch { }
+
             // VCD
             try
             {
-                if (Directory.Exists(Path.Combine(drivePath, "VCD"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VCD")).Any())
+                if (Directory.Exists(Path.Combine(this.Name, "VCD"))
+#if NET20 || NET35
+                    && Directory.GetFiles(Path.Combine(this.Name, "VCD")).Any())
+#else
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "VCD")).Any())
+#endif
                 {
                     return RedumpSystem.VideoCD;
                 }
@@ -396,89 +589,130 @@ namespace MPF.Core.Data
         /// Get the current system from the drive volume label
         /// </summary>
         /// <returns>The system based on volume label, null if none detected</returns>
-        public RedumpSystem? GetRedumpSystemFromVolumeLabel()
+        public static RedumpSystem? GetRedumpSystemFromVolumeLabel(string? volumeLabel)
         {
             // If the volume label is empty, we can't do anything
-            if (string.IsNullOrWhiteSpace(this.VolumeLabel))
+            if (string.IsNullOrEmpty(volumeLabel))
                 return null;
 
             // Audio CD
-            if (this.VolumeLabel.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel!.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.AudioCD;
 
             // Microsoft Xbox
-            if (this.VolumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.MicrosoftXbox;
-            else if (this.VolumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
+            else if (volumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.MicrosoftXbox;
 
             // Microsoft Xbox 360
-            if (this.VolumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.MicrosoftXbox360;
-            else if (this.VolumeLabel.Equals("XGD2DVD_NTSC", StringComparison.OrdinalIgnoreCase))
+            else if (volumeLabel.Equals("XGD2DVD_NTSC", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.MicrosoftXbox360;
 
             // Microsoft Xbox 360 - Too overly broad even if a lot of discs use this
-            //if (this.VolumeLabel.Equals("CD_ROM", StringComparison.OrdinalIgnoreCase))
+            //if (volumeLabel.Equals("CD_ROM", StringComparison.OrdinalIgnoreCase))
             //    return RedumpSystem.MicrosoftXbox360; // Also for Xbox One?
-            //if (this.VolumeLabel.Equals("DVD_ROM", StringComparison.OrdinalIgnoreCase))
+            //if (volumeLabel.Equals("DVD_ROM", StringComparison.OrdinalIgnoreCase))
             //    return RedumpSystem.MicrosoftXbox360;
 
+            // Sega Mega-CD / Sega-CD
+            if (volumeLabel.Equals("Sega_CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SegaMegaCDSegaCD;
+
             // Sony PlayStation 3
-            if (this.VolumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.SonyPlayStation3;
 
             // Sony PlayStation 4
-            if (this.VolumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.SonyPlayStation4;
 
             // Sony PlayStation 5
-            if (this.VolumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.SonyPlayStation5;
 
             return null;
         }
 
         /// <summary>
-        /// Read a sector with a specified size from the drive
+        /// Refresh the current drive information based on path
         /// </summary>
-        /// <param name="num">Sector number, non-negative</param>
-        /// <param name="size">Size of a sector in bytes</param>
-        /// <returns>Byte array representing the sector, null on error</returns>
-        public byte[] ReadSector(long num, int size = 2048)
+        public void RefreshDrive()
         {
-            // Missing drive leter is not supported
-            if (string.IsNullOrEmpty(this.driveInfo?.Name))
-                return null;
+            var driveInfo = DriveInfo.GetDrives().FirstOrDefault(d => d?.Name == this.Name);
+            this.PopulateFromDriveInfo(driveInfo);
+        }
 
-            // We don't support negative sectors
-            if (num < 0)
-                return null;
+        #endregion
 
-            // Wrap the following in case of device access errors
-            Stream fs = null;
+        #region Helpers
+
+        /// <summary>
+        /// Get all current attached Drives
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>List of drives, null on error</returns>
+        /// <remarks>
+        /// https://stackoverflow.com/questions/3060796/how-to-distinguish-between-usb-and-floppy-devices?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
+        /// https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx
+        /// </remarks>
+        private static List<Drive> GetDriveList(bool ignoreFixedDrives)
+        {
+            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
+            if (!ignoreFixedDrives)
+            {
+                desiredDriveTypes.Add(DriveType.Fixed);
+                desiredDriveTypes.Add(DriveType.Removable);
+            }
+
+            // TODO: Reduce reliance on `DriveInfo`
+            // https://github.com/aaru-dps/Aaru/blob/5164a154e2145941472f2ee0aeb2eff3338ecbb3/Aaru.Devices/Windows/ListDevices.cs#L66
+
+            // Create an output drive list
+            var drives = new List<Drive>();
+
+            // Get all standard supported drive types
             try
             {
-                // Open the drive as a device
-                fs = File.OpenRead($"\\\\?\\{this.Letter}:");
-
-                // Seek to the start of the sector, if possible
-                long start = num * size;
-                fs.Seek(start, SeekOrigin.Begin);
-
-                // Read and return the sector
-                byte[] buffer = new byte[size];
-                fs.Read(buffer, 0, size);
-                return buffer;
+                drives = DriveInfo.GetDrives()
+                    .Where(d => desiredDriveTypes.Contains(d.DriveType))
+                    .Select(d => Create(EnumConverter.ToInternalDriveType(d.DriveType), d.Name) ?? new Drive())
+                    .ToList();
             }
             catch
             {
-                return null;
+                return drives;
             }
-            finally
+
+            // Find and update all floppy drives
+#if NET462_OR_GREATER || NETCOREAPP
+            try
             {
-                fs?.Dispose();
+                CimSession session = CimSession.Create(null);
+                var collection = session.QueryInstances("root\\CIMV2", "WQL", "SELECT * FROM Win32_LogicalDisk");
+
+                foreach (CimInstance instance in collection)
+                {
+                    CimKeyedCollection<CimProperty> properties = instance.CimInstanceProperties;
+                    uint? mediaType = properties["MediaType"]?.Value as uint?;
+                    if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
+                    {
+                        char devId = (properties["Caption"].Value as string ?? string.Empty)[0];
+                        drives.ForEach(d => { if (d?.Name != null && d.Name[0] == devId) { d.InternalDriveType = Data.InternalDriveType.Floppy; } });
+                    }
+                }
             }
+            catch
+            {
+                // No-op
+            }
+#endif
+
+            return drives;
         }
+
+        #endregion
     }
 }

MPF.Core/Data/Enumerations.cs

@@ -1,5 +1,25 @@
 namespace MPF.Core.Data
 {
+    /// <summary>
+    /// Available hashing types
+    /// </summary>
+    public enum Hash
+    {
+        CRC32,
+#if NET6_0_OR_GREATER
+        CRC64,
+#endif
+        MD5,
+        SHA1,
+        SHA256,
+        SHA384,
+        SHA512,
+#if NET6_0_OR_GREATER
+        XxHash32,
+        XxHash64,
+#endif
+    }
+
     /// <summary>
     /// Drive type for dumping
     /// </summary>
@@ -20,12 +40,49 @@
 
         // Dumping support
         Aaru,
-        DD,
         DiscImageCreator,
+        Redumper,
 
         // Verification support only
         CleanRip,
         DCDumper,
+        PS3CFW,
         UmdImageCreator,
     }
+
+    /// <summary>
+    /// Drive read method option
+    /// </summary>
+    public enum RedumperReadMethod
+    {
+        NONE = 0,
+
+        BE,
+        D8,
+        BE_CDDA,
+    }
+
+    /// <summary>
+    /// Drive sector order option
+    /// </summary>
+    public enum RedumperSectorOrder
+    {
+        NONE = 0,
+
+        DATA_C2_SUB,
+        DATA_SUB_C2,
+        DATA_SUB,
+        DATA_C2,
+    }
+
+    /// <summary>
+    /// Log level for output
+    /// </summary>
+    public enum LogLevel
+    {
+        USER,
+        VERBOSE,
+        ERROR,
+        SECRET,
+    }
 }

MPF.Core/Data/IniFile.cs

@@ -8,25 +8,23 @@ namespace MPF.Core.Data
 {
     public class IniFile : IDictionary<string, string>
     {
-        private Dictionary<string, string> _keyValuePairs = new Dictionary<string, string>();
+        private Dictionary<string, string> _keyValuePairs = [];
 
         public string this[string key]
         {
             get
             {
-                if (_keyValuePairs == null)
-                    _keyValuePairs = new Dictionary<string, string>();
+                _keyValuePairs ??= [];
 
                 key = key.ToLowerInvariant();
-                if (_keyValuePairs.ContainsKey(key))
-                    return _keyValuePairs[key];
+                if (_keyValuePairs.TryGetValue(key, out string? val))
+                    return val;
 
-                return null;
+                return string.Empty;
             }
             set
             {
-                if (_keyValuePairs == null)
-                    _keyValuePairs = new Dictionary<string, string>();
+                _keyValuePairs ??= [];
 
                 key = key.ToLowerInvariant();
                 _keyValuePairs[key] = value;
@@ -81,10 +79,8 @@ namespace MPF.Core.Data
             if (!File.Exists(path))
                 return false;
 
-            using (var fileStream = File.OpenRead(path))
-            {
-                return Parse(fileStream);
-            }
+            using var fileStream = File.OpenRead(path);
+            return Parse(fileStream);
         }
 
         /// <summary>
@@ -99,45 +95,49 @@ namespace MPF.Core.Data
             // Keys are case-insensitive by default
             try
             {
-                using (StreamReader sr = new StreamReader(stream))
+                using var sr = new StreamReader(stream);
+                string section = string.Empty;
+                while (!sr.EndOfStream)
                 {
-                    string section = string.Empty;
-                    while (!sr.EndOfStream)
+                    var line = sr.ReadLine()?.Trim();
+
+                    // Empty lines are skipped
+                    if (string.IsNullOrEmpty(line))
                     {
-                        string line = sr.ReadLine().Trim();
-
-                        // Comments start with ';'
-                        if (line.StartsWith(";"))
-                        {
-                            // No-op, we don't process comments
-                        }
-
-                        // Section titles are surrounded by square brackets
-                        else if (line.StartsWith("["))
-                        {
-                            section = line.TrimStart('[').TrimEnd(']');
-                        }
-
-                        // Valid INI lines are in the format key=value
-                        else if (line.Contains("="))
-                        {
-                            // Split the line by '=' for key-value pairs
-                            string[] data = line.Split('=');
-
-                            // If the value field contains an '=', we need to put them back in
-                            string key = data[0].Trim();
-                            string value = string.Join("=", data.Skip(1)).Trim();
-
-                            // Section names are prepended to the key with a '.' separating
-                            if (!string.IsNullOrEmpty(section))
-                                key = $"{section}.{key}";
-
-                            // Set or overwrite keys in the returned dictionary
-                            _keyValuePairs[key.ToLowerInvariant()] = value;
-                        }
-
-                        // All other lines are ignored
+                        // No-op, we don't process empty lines
                     }
+
+                    // Comments start with ';'
+                    else if (line!.StartsWith(";"))
+                    {
+                        // No-op, we don't process comments
+                    }
+
+                    // Section titles are surrounded by square brackets
+                    else if (line.StartsWith("["))
+                    {
+                        section = line.TrimStart('[').TrimEnd(']');
+                    }
+
+                    // Valid INI lines are in the format key=value
+                    else if (line.Contains('='))
+                    {
+                        // Split the line by '=' for key-value pairs
+                        string[] data = line.Split('=');
+
+                        // If the value field contains an '=', we need to put them back in
+                        string key = data[0].Trim();
+                        string value = string.Join("=", data.Skip(1).ToArray()).Trim();
+
+                        // Section names are prepended to the key with a '.' separating
+                        if (!string.IsNullOrEmpty(section))
+                            key = $"{section}.{key}";
+
+                        // Set or overwrite keys in the returned dictionary
+                        _keyValuePairs[key.ToLowerInvariant()] = value;
+                    }
+
+                    // All other lines are ignored
                 }
             }
             catch
@@ -158,10 +158,8 @@ namespace MPF.Core.Data
             if (_keyValuePairs == null || _keyValuePairs.Count == 0)
                 return false;
 
-            using (var fileStream = File.OpenWrite(path))
-            {
-                return Write(fileStream);
-            }
+            using var fileStream = File.OpenWrite(path);
+            return Write(fileStream);
         }
 
         /// <summary>
@@ -179,39 +177,37 @@ namespace MPF.Core.Data
 
             try
             {
-                using (StreamWriter sw = new StreamWriter(stream))
+                // Order the dictionary by keys to link sections together
+                using var sw = new StreamWriter(stream);
+                var orderedKeyValuePairs = _keyValuePairs.OrderBy(kvp => kvp.Key);
+
+                string section = string.Empty;
+                foreach (var keyValuePair in orderedKeyValuePairs)
                 {
-                    // Order the dictionary by keys to link sections together
-                    var orderedKeyValuePairs = _keyValuePairs.OrderBy(kvp => kvp.Key);
+                    // Extract the key and value
+                    string key = keyValuePair.Key;
+                    string value = keyValuePair.Value;
 
-                    string section = string.Empty;
-                    foreach (var keyValuePair in orderedKeyValuePairs)
+                    // We assume '.' is a section name separator
+                    if (key.Contains('.'))
                     {
-                        // Extract the key and value
-                        string key = keyValuePair.Key;
-                        string value = keyValuePair.Value;
+                        // Split the key by '.'
+                        string[] data = keyValuePair.Key.Split('.');
 
-                        // We assume '.' is a section name separator
-                        if (key.Contains('.'))
+                        // If the key contains an '.', we need to put them back in
+                        string newSection = data[0].Trim();
+                        key = string.Join(".", data.Skip(1).ToArray()).Trim();
+
+                        // If we have a new section, write it out
+                        if (!string.Equals(newSection, section, StringComparison.OrdinalIgnoreCase))
                         {
-                            // Split the key by '.'
-                            string[] data = keyValuePair.Key.Split('.');
-
-                            // If the key contains an '.', we need to put them back in
-                            string newSection = data[0].Trim();
-                            key = string.Join(".", data.Skip(1)).Trim();
-
-                            // If we have a new section, write it out
-                            if (!string.Equals(newSection, section, StringComparison.OrdinalIgnoreCase))
-                            {
-                                sw.WriteLine($"[{newSection}]");
-                                section = newSection;
-                            }
+                            sw.WriteLine($"[{newSection}]");
+                            section = newSection;
                         }
-
-                        // Now write out the key and value in a standardized way
-                        sw.WriteLine($"{key}={value}");
                     }
+
+                    // Now write out the key and value in a standardized way
+                    sw.WriteLine($"{key}={value}");
                 }
             }
             catch
@@ -245,7 +241,9 @@ namespace MPF.Core.Data
 
         public bool TryGetValue(string key, out string value)
         {
-            return ((IDictionary<string, string>)_keyValuePairs).TryGetValue(key.ToLowerInvariant(), out value);
+            bool result = ((IDictionary<string, string>)_keyValuePairs).TryGetValue(key.ToLowerInvariant(), out var temp);
+            value = temp ?? string.Empty;
+            return result;
         }
 
         public void Add(KeyValuePair<string, string> item)

MPF.Core/Data/Options.cs

@@ -1,42 +1,52 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using MPF.Core.Converters;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Data
 {
-    public class Options : IDictionary<string, string>, ICloneable
+    public class Options
     {
-        private readonly Dictionary<string, string> _settings;
+        /// <summary>
+        /// All settings in the form of a dictionary
+        /// </summary>
+        public Dictionary<string, string?> Settings { get; private set; }
+
+        /// <summary>
+        /// Indicate if the program is being run with a clean configuration
+        /// </summary>
+        public bool FirstRun
+        {
+            get { return GetBooleanSetting(Settings, "FirstRun", true); }
+            set { Settings["FirstRun"] = value.ToString(); }
+        }
 
         #region Internal Program
 
         /// <summary>
         /// Path to Aaru
         /// </summary>
-        public string AaruPath
+        public string? AaruPath
         {
-            get { return GetStringSetting(_settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
-            set { _settings["AaruPath"] = value; }
+            get { return GetStringSetting(Settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            set { Settings["AaruPath"] = value; }
         }
 
         /// <summary>
         /// Path to DiscImageCreator
         /// </summary>
-        public string DiscImageCreatorPath
+        public string? DiscImageCreatorPath
         {
-            get { return GetStringSetting(_settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
-            set { _settings["DiscImageCreatorPath"] = value; }
+            get { return GetStringSetting(Settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            set { Settings["DiscImageCreatorPath"] = value; }
         }
 
         /// <summary>
-        /// Path to dd for Windows
+        /// Path to Redumper
         /// </summary>
-        public string DDPath
+        public string? RedumperPath
         {
-            get { return GetStringSetting(_settings, "DDPath", "Programs\\DD\\dd.exe"); }
-            set { _settings["DDPath"] = value; }
+            get { return GetStringSetting(Settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
+            set { Settings["RedumperPath"] = value; }
         }
 
         /// <summary>
@@ -46,13 +56,13 @@ namespace MPF.Core.Data
         {
             get
             {
-                string valueString = GetStringSetting(_settings, "InternalProgram", InternalProgram.DiscImageCreator.ToString());
+                var valueString = GetStringSetting(Settings, "InternalProgram", InternalProgram.Redumper.ToString());
                 var valueEnum = EnumConverter.ToInternalProgram(valueString);
-                return valueEnum == InternalProgram.NONE ? InternalProgram.DiscImageCreator : valueEnum;
+                return valueEnum == InternalProgram.NONE ? InternalProgram.Redumper : valueEnum;
             }
             set
             {
-                _settings["InternalProgram"] = value.ToString();
+                Settings["InternalProgram"] = value.ToString();
             }
         }
 
@@ -65,8 +75,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool EnableDarkMode
         {
-            get { return GetBooleanSetting(_settings, "EnableDarkMode", false); }
-            set { _settings["EnableDarkMode"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "EnableDarkMode", false); }
+            set { Settings["EnableDarkMode"] = value.ToString(); }
         }
 
         /// <summary>
@@ -74,17 +84,26 @@ namespace MPF.Core.Data
         /// </summary>
         public bool CheckForUpdatesOnStartup
         {
-            get { return GetBooleanSetting(_settings, "CheckForUpdatesOnStartup", true); }
-            set { _settings["CheckForUpdatesOnStartup"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "CheckForUpdatesOnStartup", true); }
+            set { Settings["CheckForUpdatesOnStartup"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Fast update label - Skips disc checks and updates path only
+        /// </summary>
+        public bool FastUpdateLabel
+        {
+            get { return GetBooleanSetting(Settings, "FastUpdateLabel", false); }
+            set { Settings["FastUpdateLabel"] = value.ToString(); }
         }
 
         /// <summary>
         /// Default output path for dumps
         /// </summary>
-        public string DefaultOutputPath
+        public string? DefaultOutputPath
         {
-            get { return GetStringSetting(_settings, "DefaultOutputPath", "ISO"); }
-            set { _settings["DefaultOutputPath"] = value; }
+            get { return GetStringSetting(Settings, "DefaultOutputPath", "ISO"); }
+            set { Settings["DefaultOutputPath"] = value; }
         }
 
         /// <summary>
@@ -94,13 +113,13 @@ namespace MPF.Core.Data
         {
             get
             {
-                string valueString = GetStringSetting(_settings, "DefaultSystem", null);
-                var valueEnum = Extensions.ToRedumpSystem(valueString);
+                var valueString = GetStringSetting(Settings, "DefaultSystem", null);
+                var valueEnum = Extensions.ToRedumpSystem(valueString ?? string.Empty);
                 return valueEnum;
             }
             set
             {
-                _settings["DefaultSystem"] = value.LongName();
+                Settings["DefaultSystem"] = value.LongName();
             }
         }
 
@@ -110,8 +129,8 @@ namespace MPF.Core.Data
         /// <remarks>This is a hidden setting</remarks>
         public bool ShowDebugViewMenuItem
         {
-            get { return GetBooleanSetting(_settings, "ShowDebugViewMenuItem", false); }
-            set { _settings["ShowDebugViewMenuItem"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ShowDebugViewMenuItem", false); }
+            set { Settings["ShowDebugViewMenuItem"] = value.ToString(); }
         }
 
         #endregion
@@ -123,8 +142,8 @@ namespace MPF.Core.Data
         /// </summary>
         public int PreferredDumpSpeedCD
         {
-            get { return GetInt32Setting(_settings, "PreferredDumpSpeedCD", 72); }
-            set { _settings["PreferredDumpSpeedCD"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedCD", 24); }
+            set { Settings["PreferredDumpSpeedCD"] = value.ToString(); }
         }
 
         /// <summary>
@@ -132,8 +151,17 @@ namespace MPF.Core.Data
         /// </summary>
         public int PreferredDumpSpeedDVD
         {
-            get { return GetInt32Setting(_settings, "PreferredDumpSpeedDVD", 24); }
-            set { _settings["PreferredDumpSpeedDVD"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedDVD", 16); }
+            set { Settings["PreferredDumpSpeedDVD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default HD-DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedHDDVD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedHDDVD", 8); }
+            set { Settings["PreferredDumpSpeedHDDVD"] = value.ToString(); }
         }
 
         /// <summary>
@@ -141,8 +169,8 @@ namespace MPF.Core.Data
         /// </summary>
         public int PreferredDumpSpeedBD
         {
-            get { return GetInt32Setting(_settings, "PreferredDumpSpeedBD", 16); }
-            set { _settings["PreferredDumpSpeedBD"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedBD", 8); }
+            set { Settings["PreferredDumpSpeedBD"] = value.ToString(); }
         }
 
         #endregion
@@ -154,8 +182,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool AaruEnableDebug
         {
-            get { return GetBooleanSetting(_settings, "AaruEnableDebug", false); }
-            set { _settings["AaruEnableDebug"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "AaruEnableDebug", false); }
+            set { Settings["AaruEnableDebug"] = value.ToString(); }
         }
 
         /// <summary>
@@ -163,8 +191,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool AaruEnableVerbose
         {
-            get { return GetBooleanSetting(_settings, "AaruEnableVerbose", false); }
-            set { _settings["AaruEnableVerbose"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "AaruEnableVerbose", false); }
+            set { Settings["AaruEnableVerbose"] = value.ToString(); }
         }
 
         /// <summary>
@@ -172,8 +200,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool AaruForceDumping
         {
-            get { return GetBooleanSetting(_settings, "AaruForceDumping", true); }
-            set { _settings["AaruForceDumping"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "AaruForceDumping", true); }
+            set { Settings["AaruForceDumping"] = value.ToString(); }
         }
 
         /// <summary>
@@ -181,8 +209,8 @@ namespace MPF.Core.Data
         /// </summary>
         public int AaruRereadCount
         {
-            get { return GetInt32Setting(_settings, "AaruRereadCount", 5); }
-            set { _settings["AaruRereadCount"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "AaruRereadCount", 5); }
+            set { Settings["AaruRereadCount"] = value.ToString(); }
         }
 
         /// <summary>
@@ -190,14 +218,32 @@ namespace MPF.Core.Data
         /// </summary>
         public bool AaruStripPersonalData
         {
-            get { return GetBooleanSetting(_settings, "AaruStripPersonalData", false); }
-            set { _settings["AaruStripPersonalData"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "AaruStripPersonalData", false); }
+            set { Settings["AaruStripPersonalData"] = value.ToString(); }
         }
 
         #endregion
 
         #region DiscImageCreator
 
+        /// <summary>
+        /// Enable multi-sector read flag by default
+        /// </summary>
+        public bool DICMultiSectorRead
+        {
+            get { return GetBooleanSetting(Settings, "DICMultiSectorRead", false); }
+            set { Settings["DICMultiSectorRead"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include a default multi-sector read value
+        /// </summary>
+        public int DICMultiSectorReadValue
+        {
+            get { return GetInt32Setting(Settings, "DICMultiSectorReadValue", 0); }
+            set { Settings["DICMultiSectorReadValue"] = value.ToString(); }
+        }
+
         /// <summary>
         /// Enable overly-secure dumping flags by default
         /// </summary>
@@ -208,8 +254,8 @@ namespace MPF.Core.Data
         /// </remarks>
         public bool DICParanoidMode
         {
-            get { return GetBooleanSetting(_settings, "DICParanoidMode", false); }
-            set { _settings["DICParanoidMode"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "DICParanoidMode", false); }
+            set { Settings["DICParanoidMode"] = value.ToString(); }
         }
 
         /// <summary>
@@ -217,8 +263,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool DICQuietMode
         {
-            get { return GetBooleanSetting(_settings, "DICQuietMode", false); }
-            set { _settings["DICQuietMode"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "DICQuietMode", false); }
+            set { Settings["DICQuietMode"] = value.ToString(); }
         }
 
         /// <summary>
@@ -226,8 +272,17 @@ namespace MPF.Core.Data
         /// </summary>
         public int DICRereadCount
         {
-            get { return GetInt32Setting(_settings, "DICRereadCount", 20); }
-            set { _settings["DICRereadCount"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "DICRereadCount", 20); }
+            set { Settings["DICRereadCount"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of DVD/HD-DVD/BD rereads
+        /// </summary>
+        public int DICDVDRereadCount
+        {
+            get { return GetInt32Setting(Settings, "DICDVDRereadCount", 10); }
+            set { Settings["DICDVDRereadCount"] = value.ToString(); }
         }
 
         /// <summary>
@@ -235,8 +290,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool DICResetDriveAfterDump
         {
-            get { return GetBooleanSetting(_settings, "DICResetDriveAfterDump", false); }
-            set { _settings["DICResetDriveAfterDump"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "DICResetDriveAfterDump", false); }
+            set { Settings["DICResetDriveAfterDump"] = value.ToString(); }
         }
 
         /// <summary>
@@ -244,8 +299,89 @@ namespace MPF.Core.Data
         /// </summary>
         public bool DICUseCMIFlag
         {
-            get { return GetBooleanSetting(_settings, "DICUseCMIFlag", false); }
-            set { _settings["DICUseCMIFlag"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "DICUseCMIFlag", false); }
+            set { Settings["DICUseCMIFlag"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redumper
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool RedumperEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, "RedumperEnableDebug", false); }
+            set { Settings["RedumperEnableDebug"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool RedumperEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, "RedumperEnableVerbose", true); }
+            set { Settings["RedumperEnableVerbose"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable options incompatible with redump submissions
+        /// </summary>
+        public bool RedumperNonRedumpMode
+        {
+            get { return GetBooleanSetting(Settings, "RedumperNonRedumpMode", false); }
+            set { Settings["RedumperNonRedumpMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable generic drive type by default with Redumper
+        /// </summary>
+        public bool RedumperUseGenericDriveType
+        {
+            get { return GetBooleanSetting(Settings, "RedumperUseGenericDriveType", false); }
+            set { Settings["RedumperUseGenericDriveType"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper read method
+        /// </summary>
+        public RedumperReadMethod RedumperReadMethod
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "RedumperReadMethod", RedumperReadMethod.NONE.ToString());
+                return EnumConverter.ToRedumperReadMethod(valueString);
+            }
+            set
+            {
+                Settings["RedumperReadMethod"] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper sector order
+        /// </summary>
+        public RedumperSectorOrder RedumperSectorOrder
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "RedumperSectorOrder", RedumperSectorOrder.NONE.ToString());
+                return EnumConverter.ToRedumperSectorOrder(valueString);
+            }
+            set
+            {
+                Settings["RedumperSectorOrder"] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Default number of rereads
+        /// </summary>
+        public int RedumperRereadCount
+        {
+            get { return GetInt32Setting(Settings, "RedumperRereadCount", 20); }
+            set { Settings["RedumperRereadCount"] = value.ToString(); }
         }
 
         #endregion
@@ -257,8 +393,17 @@ namespace MPF.Core.Data
         /// </summary>
         public bool ScanForProtection
         {
-            get { return GetBooleanSetting(_settings, "ScanForProtection", true); }
-            set { _settings["ScanForProtection"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ScanForProtection", true); }
+            set { Settings["ScanForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Output all found protections to a separate file in the directory
+        /// </summary>
+        public bool OutputSeparateProtectionFile
+        {
+            get { return GetBooleanSetting(Settings, "OutputSeparateProtectionFile", true); }
+            set { Settings["OutputSeparateProtectionFile"] = value.ToString(); }
         }
 
         /// <summary>
@@ -266,8 +411,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool AddPlaceholders
         {
-            get { return GetBooleanSetting(_settings, "AddPlaceholders", true); }
-            set { _settings["AddPlaceholders"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "AddPlaceholders", true); }
+            set { Settings["AddPlaceholders"] = value.ToString(); }
         }
 
         /// <summary>
@@ -275,8 +420,17 @@ namespace MPF.Core.Data
         /// </summary>
         public bool PromptForDiscInformation
         {
-            get { return GetBooleanSetting(_settings, "PromptForDiscInformation", true); }
-            set { _settings["PromptForDiscInformation"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "PromptForDiscInformation", true); }
+            set { Settings["PromptForDiscInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Pull all information from Redump if signed in
+        /// </summary>
+        public bool PullAllInformation
+        {
+            get { return GetBooleanSetting(Settings, "PullAllInformation", false); }
+            set { Settings["PullAllInformation"] = value.ToString(); }
         }
 
         /// <summary>
@@ -284,8 +438,17 @@ namespace MPF.Core.Data
         /// </summary>
         public bool EnableTabsInInputFields
         {
-            get { return GetBooleanSetting(_settings, "EnableTabsInInputFields", false); }
-            set { _settings["EnableTabsInInputFields"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "EnableTabsInInputFields", false); }
+            set { Settings["EnableTabsInInputFields"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Limit outputs to Redump-supported values only
+        /// </summary>
+        public bool EnableRedumpCompatibility
+        {
+            get { return GetBooleanSetting(Settings, "EnableRedumpCompatibility", true); }
+            set { Settings["EnableRedumpCompatibility"] = value.ToString(); }
         }
 
         /// <summary>
@@ -293,8 +456,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool ShowDiscEjectReminder
         {
-            get { return GetBooleanSetting(_settings, "ShowDiscEjectReminder", true); }
-            set { _settings["ShowDiscEjectReminder"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ShowDiscEjectReminder", true); }
+            set { Settings["ShowDiscEjectReminder"] = value.ToString(); }
         }
 
         /// <summary>
@@ -302,8 +465,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool EjectAfterDump
         {
-            get { return GetBooleanSetting(_settings, "EjectAfterDump", false); }
-            set { _settings["EjectAfterDump"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "EjectAfterDump", false); }
+            set { Settings["EjectAfterDump"] = value.ToString(); }
         }
 
         /// <summary>
@@ -311,8 +474,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool IgnoreFixedDrives
         {
-            get { return GetBooleanSetting(_settings, "IgnoreFixedDrives", true); }
-            set { _settings["IgnoreFixedDrives"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "IgnoreFixedDrives", true); }
+            set { Settings["IgnoreFixedDrives"] = value.ToString(); }
         }
 
         /// <summary>
@@ -320,8 +483,17 @@ namespace MPF.Core.Data
         /// </summary>
         public bool ToolsInSeparateWindow
         {
-            get { return GetBooleanSetting(_settings, "ToolsInSeparateWindow", true); }
-            set { _settings["ToolsInSeparateWindow"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ToolsInSeparateWindow", true); }
+            set { Settings["ToolsInSeparateWindow"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add the dump filename as a suffix to the auto-generated files
+        /// </summary>
+        public bool AddFilenameSuffix
+        {
+            get { return GetBooleanSetting(Settings, "AddFilenameSuffix", false); }
+            set { Settings["AddFilenameSuffix"] = value.ToString(); }
         }
 
         /// <summary>
@@ -329,8 +501,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool OutputSubmissionJSON
         {
-            get { return GetBooleanSetting(_settings, "OutputSubmissionJSON", false); }
-            set { _settings["OutputSubmissionJSON"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "OutputSubmissionJSON", false); }
+            set { Settings["OutputSubmissionJSON"] = value.ToString(); }
         }
 
         /// <summary>
@@ -338,8 +510,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool IncludeArtifacts
         {
-            get { return GetBooleanSetting(_settings, "IncludeArtifacts", false); }
-            set { _settings["IncludeArtifacts"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "IncludeArtifacts", false); }
+            set { Settings["IncludeArtifacts"] = value.ToString(); }
         }
 
         /// <summary>
@@ -347,8 +519,26 @@ namespace MPF.Core.Data
         /// </summary>
         public bool CompressLogFiles
         {
-            get { return GetBooleanSetting(_settings, "CompressLogFiles", true); }
-            set { _settings["CompressLogFiles"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "CompressLogFiles", true); }
+            set { Settings["CompressLogFiles"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Delete unnecessary files to reduce space
+        /// </summary>
+        public bool DeleteUnnecessaryFiles
+        {
+            get { return GetBooleanSetting(Settings, "DeleteUnnecessaryFiles", false); }
+            set { Settings["DeleteUnnecessaryFiles"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Create a PS3 IRD file after dumping PS3 BD-ROM discs
+        /// </summary>
+        public bool CreateIRDAfterDumping
+        {
+            get { return GetBooleanSetting(Settings, "CreateIRDAfterDumping", false); }
+            set { Settings["CreateIRDAfterDumping"] = value.ToString(); }
         }
 
         #endregion
@@ -360,8 +550,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool SkipMediaTypeDetection
         {
-            get { return GetBooleanSetting(_settings, "SkipMediaTypeDetection", false); }
-            set { _settings["SkipMediaTypeDetection"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "SkipMediaTypeDetection", false); }
+            set { Settings["SkipMediaTypeDetection"] = value.ToString(); }
         }
 
         /// <summary>
@@ -369,8 +559,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool SkipSystemDetection
         {
-            get { return GetBooleanSetting(_settings, "SkipSystemDetection", false); }
-            set { _settings["SkipSystemDetection"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "SkipSystemDetection", false); }
+            set { Settings["SkipSystemDetection"] = value.ToString(); }
         }
 
         #endregion
@@ -382,8 +572,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool ScanArchivesForProtection
         {
-            get { return GetBooleanSetting(_settings, "ScanArchivesForProtection", true); }
-            set { _settings["ScanArchivesForProtection"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ScanArchivesForProtection", true); }
+            set { Settings["ScanArchivesForProtection"] = value.ToString(); }
         }
 
         /// <summary>
@@ -391,17 +581,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool ScanPackersForProtection
         {
-            get { return GetBooleanSetting(_settings, "ScanPackersForProtection", false); }
-            set { _settings["ScanPackersForProtection"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Force scanning all files for protection
-        /// </summary>
-        public bool ForceScanningForProtection
-        {
-            get { return GetBooleanSetting(_settings, "ForceScanningForProtection", false); }
-            set { _settings["ForceScanningForProtection"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "ScanPackersForProtection", false); }
+            set { Settings["ScanPackersForProtection"] = value.ToString(); }
         }
 
         /// <summary>
@@ -409,8 +590,17 @@ namespace MPF.Core.Data
         /// </summary>
         public bool IncludeDebugProtectionInformation
         {
-            get { return GetBooleanSetting(_settings, "IncludeDebugProtectionInformation", false); }
-            set { _settings["IncludeDebugProtectionInformation"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "IncludeDebugProtectionInformation", false); }
+            set { Settings["IncludeDebugProtectionInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Remove drive letters from protection scan output
+        /// </summary>
+        public bool HideDriveLetters
+        {
+            get { return GetBooleanSetting(Settings, "HideDriveLetters", false); }
+            set { Settings["HideDriveLetters"] = value.ToString(); }
         }
 
         #endregion
@@ -422,8 +612,8 @@ namespace MPF.Core.Data
         /// </summary>
         public bool VerboseLogging
         {
-            get { return GetBooleanSetting(_settings, "VerboseLogging", true); }
-            set { _settings["VerboseLogging"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "VerboseLogging", true); }
+            set { Settings["VerboseLogging"] = value.ToString(); }
         }
 
         /// <summary>
@@ -431,55 +621,34 @@ namespace MPF.Core.Data
         /// </summary>
         public bool OpenLogWindowAtStartup
         {
-            get { return GetBooleanSetting(_settings, "OpenLogWindowAtStartup", true); }
-            set { _settings["OpenLogWindowAtStartup"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable fancy formatting of log statements
-        /// Disables EnableProgressProcessing if disabled
-        /// </summary>
-        /// <remarks>
-        /// This is mainly for outputting redirected console outputs. Not many
-        /// other bits of the logs include any specially handled outputs.
-        /// </remarks>
-        public bool EnableLogFormatting
-        {
-            get { return GetBooleanSetting(_settings, "EnableLogFormatting", false); }
-            set { _settings["EnableLogFormatting"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable progress bar updating based on log text
-        /// Disabled if EnableLogFormatting is disabled
-        /// </summary>
-        public bool EnableProgressProcessing
-        {
-            get { return GetBooleanSetting(_settings, "EnableProgressProcessing", false); }
-            set { _settings["EnableProgressProcessing"] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, "OpenLogWindowAtStartup", true); }
+            set { Settings["OpenLogWindowAtStartup"] = value.ToString(); }
         }
 
         #endregion
 
         #region Redump Login Information
 
-        public string RedumpUsername
+        public string? RedumpUsername
         {
-            get { return GetStringSetting(_settings, "RedumpUsername", ""); }
-            set { _settings["RedumpUsername"] = value; }
+            get { return GetStringSetting(Settings, "RedumpUsername", ""); }
+            set { Settings["RedumpUsername"] = value; }
         }
 
         // TODO: Figure out a way to keep this encrypted in some way, BASE64 to start?
-        public string RedumpPassword
+        public string? RedumpPassword
         {
-            get { return GetStringSetting(_settings, "RedumpPassword", ""); }
-            set { _settings["RedumpPassword"] = value; }
+            get
+            {
+                return GetStringSetting(Settings, "RedumpPassword", "");
+            }
+            set { Settings["RedumpPassword"] = value; }
         }
 
         /// <summary>
         /// Determine if a complete set of Redump credentials might exist
         /// </summary>
-        public bool HasRedumpLogin { get => !string.IsNullOrWhiteSpace(RedumpUsername) && !string.IsNullOrWhiteSpace(RedumpPassword); }
+        public bool HasRedumpLogin { get => !string.IsNullOrEmpty(RedumpUsername) && !string.IsNullOrEmpty(RedumpPassword); }
 
         #endregion
 
@@ -487,17 +656,27 @@ namespace MPF.Core.Data
         /// Constructor taking a dictionary for settings
         /// </summary>
         /// <param name="settings"></param>
-        public Options(Dictionary<string, string> settings = null)
+        public Options(Dictionary<string, string?>? settings = null)
         {
-            this._settings = settings ?? new Dictionary<string, string>();
+            this.Settings = settings ?? [];
         }
 
         /// <summary>
-        /// Create a clone of the object
+        /// Constructor taking an existing Options object
         /// </summary>
-        public object Clone()
+        /// <param name="source"></param>
+        public Options(Options? source)
         {
-            return new Options(new Dictionary<string, string>(_settings));
+            Settings = new Dictionary<string, string?>(source?.Settings ?? []);
+        }
+
+        /// <summary>
+        /// Accessor for the internal dictionary
+        /// </summary>
+        public string? this[string key]
+        {
+            get => this.Settings[key];
+            set => this.Settings[key] = value;
         }
 
         #region Helpers
@@ -509,11 +688,11 @@ namespace MPF.Core.Data
         /// <param name="key">Setting key to get a value for</param>
         /// <param name="defaultValue">Default value to return if no value is found</param>
         /// <returns>Setting value if possible, default value otherwise</returns>
-        private bool GetBooleanSetting(Dictionary<string, string> settings, string key, bool defaultValue)
+        private static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
         {
             if (settings.ContainsKey(key))
             {
-                if (Boolean.TryParse(settings[key], out bool value))
+                if (bool.TryParse(settings[key], out bool value))
                     return value;
                 else
                     return defaultValue;
@@ -531,11 +710,11 @@ namespace MPF.Core.Data
         /// <param name="key">Setting key to get a value for</param>
         /// <param name="defaultValue">Default value to return if no value is found</param>
         /// <returns>Setting value if possible, default value otherwise</returns>
-        private int GetInt32Setting(Dictionary<string, string> settings, string key, int defaultValue)
+        private static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
         {
             if (settings.ContainsKey(key))
             {
-                if (Int32.TryParse(settings[key], out int value))
+                if (int.TryParse(settings[key], out int value))
                     return value;
                 else
                     return defaultValue;
@@ -553,7 +732,7 @@ namespace MPF.Core.Data
         /// <param name="key">Setting key to get a value for</param>
         /// <param name="defaultValue">Default value to return if no value is found</param>
         /// <returns>Setting value if possible, default value otherwise</returns>
-        private string GetStringSetting(Dictionary<string, string> settings, string key, string defaultValue)
+        private static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
         {
             if (settings.ContainsKey(key))
                 return settings[key];
@@ -562,45 +741,5 @@ namespace MPF.Core.Data
         }
 
         #endregion
-
-        #region IDictionary implementations
-
-        public ICollection<string> Keys => _settings.Keys;
-
-        public ICollection<string> Values => _settings.Values;
-
-        public int Count => _settings.Count;
-
-        public bool IsReadOnly => ((IDictionary<string, string>)_settings).IsReadOnly;
-
-        public string this[string key]
-        {
-            get { return (_settings.ContainsKey(key) ? _settings[key] : null); }
-            set { _settings[key] = value; }
-        }
-
-        public bool ContainsKey(string key) => _settings.ContainsKey(key);
-
-        public void Add(string key, string value) => _settings.Add(key, value);
-
-        public bool Remove(string key) => _settings.Remove(key);
-
-        public bool TryGetValue(string key, out string value) => _settings.TryGetValue(key, out value);
-
-        public void Add(KeyValuePair<string, string> item) => _settings.Add(item.Key, item.Value);
-
-        public void Clear() => _settings.Clear();
-
-        public bool Contains(KeyValuePair<string, string> item) => ((IDictionary<string, string>)_settings).Contains(item);
-
-        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex) => ((IDictionary<string, string>)_settings).CopyTo(array, arrayIndex);
-
-        public bool Remove(KeyValuePair<string, string> item) => ((IDictionary<string, string>)_settings).Remove(item);
-
-        public IEnumerator<KeyValuePair<string, string>> GetEnumerator() => _settings.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() => _settings.GetEnumerator();
-
-        #endregion
     }
 }

MPF.Core/Data/ProcessingQueue.cs

@@ -1,16 +1,24 @@
 using System;
+#if NET20 || NET35
+using System.Collections.Generic;
+#else
 using System.Collections.Concurrent;
+#endif
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace MPF.Core.Data
 {
-    public class ProcessingQueue<T> : IDisposable
+    public sealed class ProcessingQueue<T> : IDisposable
     {
         /// <summary>
         /// Internal queue to hold data to process
         /// </summary>
+#if NET20 || NET35
+        private readonly Queue<T> InternalQueue;
+#else
         private readonly ConcurrentQueue<T> InternalQueue;
+#endif
 
         /// <summary>
         /// Custom processing step for dequeued data
@@ -24,10 +32,20 @@ namespace MPF.Core.Data
 
         public ProcessingQueue(Action<T> customProcessing)
         {
+#if NET20 || NET35
+            this.InternalQueue = new Queue<T>();
+#else
             this.InternalQueue = new ConcurrentQueue<T>();
+#endif
             this.CustomProcessing = customProcessing;
             this.TokenSource = new CancellationTokenSource();
+#if NET20 || NET35
+            Task.Run(() => ProcessQueue());
+#elif NET40
+            Task.Factory.StartNew(() => ProcessQueue());
+#else
             Task.Run(() => ProcessQueue(), this.TokenSource.Token);
+#endif
         }
 
         /// <summary>
@@ -39,10 +57,10 @@ namespace MPF.Core.Data
         /// Enqueue a new item for processing
         /// </summary>
         /// <param name="item"></param>
-        public void Enqueue(T item)
+        public void Enqueue(T? item)
         {
             // Only accept new data when not cancelled
-            if (!this.TokenSource.IsCancellationRequested)
+            if (item != null && !this.TokenSource.IsCancellationRequested)
                 this.InternalQueue.Enqueue(item);
         }
 
@@ -54,7 +72,11 @@ namespace MPF.Core.Data
             while (true)
             {
                 // Nothing in the queue means we get to idle
-                if (this.InternalQueue.Count == 0)
+#if NET20 || NET35
+                if (InternalQueue.Count == 0)
+#else
+                if (InternalQueue.IsEmpty)
+#endif
                 {
                     if (this.TokenSource.IsCancellationRequested)
                         break;
@@ -63,12 +85,17 @@ namespace MPF.Core.Data
                     continue;
                 }
 
+#if NET20 || NET35
+                // Get the next item from the queue and invoke the lambda, if possible
+                this.CustomProcessing?.Invoke(this.InternalQueue.Dequeue());
+#else
                 // Get the next item from the queue
-                if (!this.InternalQueue.TryDequeue(out T nextItem))
+                if (!this.InternalQueue.TryDequeue(out var nextItem))
                     continue;
 
                 // Invoke the lambda, if possible
                 this.CustomProcessing?.Invoke(nextItem);
+#endif
             }
         }
     }

MPF.Core/Data/Result.cs

@@ -1,9 +1,11 @@
-namespace MPF.Core.Data
+using System;
+
+namespace MPF.Core.Data
 {
     /// <summary>
     /// Generic success/failure result object, with optional message
     /// </summary>
-    public class Result
+    public class Result : System.EventArgs
     {
         /// <summary>
         /// Internal representation of success
@@ -24,25 +26,30 @@
         /// <summary>
         /// Create a default success result with no message
         /// </summary>
-        public static Result Success() => new Result(true, "");
+        public static Result Success() => new(true, "");
 
         /// <summary>
         /// Create a success result with a custom message
         /// </summary>
         /// <param name="message">String to add as a message</param>
-        public static Result Success(string message) => new Result(true, message);
+        public static Result Success(string? message) => new(true, message ?? string.Empty);
 
         /// <summary>
         /// Create a default failure result with no message
         /// </summary>
         /// <returns></returns>
-        public static Result Failure() => new Result(false, "");
+        public static Result Failure() => new(false, "");
 
         /// <summary>
         /// Create a failure result with a custom message
         /// </summary>
         /// <param name="message">String to add as a message</param>
-        public static Result Failure(string message) => new Result(false, message);
+        public static Result Failure(string? message) => new(false, message ?? string.Empty);
+
+        internal static Result Success(object value)
+        {
+            throw new NotImplementedException();
+        }
 
         /// <summary>
         /// Results can be compared to boolean values based on the success value

MPF.Core/Data/XgdInfo.cs

@@ -1,423 +0,0 @@
-using RedumpLib.Data;
-
-namespace MPF.Core.Data
-{
-    /// <summary>
-    /// Contains information specific to an XGD disc
-    /// </summary>
-    /// <remarks>
-    /// XGD1 XMID Format Information:
-    ///
-    /// AABBBCCD
-    /// - AA        => The two-ASCII-character publisher identifier (see GetPublisher for details)
-    /// - BBB       => Game ID
-    /// - CC        => Version number
-    /// - D         => Region identifier (see GetRegion for details)
-    ///
-    /// XGD2/3 XeMID Format Information:
-    ///
-    /// AABCCCDDEFFGHH(IIIIIIII)
-    /// - AA        => The two-ASCII-character publisher identifier (see GetPublisher for details)
-    /// - B         => Platform identifier; 2 indicates Xbox 360.
-    /// - CCC       => Game ID
-    /// - DD        => SKU number (unique per SKU of a title)
-    /// - E         => Region identifier (see GetRegion for details)
-    /// - FF        => Base version; usually starts at 01 (can be 1 or 2 characters)
-    /// - G         => Media type identifier (see GetMediaSubtype for details)
-    /// - HH        => Disc number stored in [disc number][total discs] format
-    /// - IIIIIIII  => 8-hex-digit certification submission identifier; usually on test discs only
-    /// </remarks>
-    public class XgdInfo
-    {
-        #region Fields
-
-        /// <summary>
-        /// Indicates whether the information in this object is fully instantiated or not
-        /// </summary>
-        public bool Initialized { get; private set; }
-
-        /// <summary>
-        /// Raw XMID/XeMID string that all other information is derived from
-        /// </summary>
-        public string XMID { get; private set; }
-
-        /// <summary>
-        /// 2-character publisher identifier
-        /// </summary>
-        public string PublisherIdentifier { get; private set; }
-
-        /// <summary>
-        /// Platform disc is made for, 2 indicates Xbox 360
-        /// </summary>
-        public char? PlatformIdentifier { get; private set; }
-
-        /// <summary>
-        /// Game ID
-        /// </summary>
-        public string GameID { get; private set; }
-
-        /// <summary>
-        /// For XGD1:   Internal version number
-        /// For XGD2/3: Title-specific SKU
-        /// </summary>
-        public string SKU { get; private set; }
-
-        /// <summary>
-        /// Region identifier character
-        /// </summary>
-        public char RegionIdentifier { get; private set; }
-
-        /// <summary>
-        /// Base version of executables, usually starts at 01
-        /// </summary>
-        /// <remarks>
-        /// TODO: Check if this is always 2 characters for XGD2/3
-        /// </remarks>
-        public string BaseVersion { get; private set; }
-
-        /// <summary>
-        /// Media subtype identifier
-        /// </summary>
-        public char MediaSubtypeIdentifier { get; private set; }
-
-        /// <summary>
-        /// Disc number stored in [disc number][total discs] format
-        /// </summary>
-        public string DiscNumberIdentifier { get; private set; }
-
-        /// <summary>
-        /// 8-hex-digit certification submission identifier; usually on test discs only
-        /// </summary>
-        public string CertificationSubmissionIdentifier { get; private set; }
-
-        #endregion
-
-        #region Auto-Generated Information
-
-        /// <summary>
-        /// Human-readable name derived from the publisher identifier
-        /// </summary>
-        public string PublisherName => GetPublisher(this.PublisherIdentifier);
-
-        /// <summary>
-        /// Internally represented region
-        /// </summary>
-        public Region? InternalRegion => GetRegion(this.RegionIdentifier);
-
-        /// <summary>
-        /// Human-readable subtype derived from the media identifier
-        /// </summary>
-        public string MediaSubtype => GetMediaSubtype(this.MediaSubtypeIdentifier);
-
-        #endregion
-
-        /// <summary>
-        /// Populate a set of XGD information from a Master ID (XMID/XeMID) string
-        /// </summary>
-        /// <param name="xmid">XMID/XeMID string representing the DMI information</param>
-        /// <param name="validate">True if value validation should be performed, false otherwise</param>
-        public XgdInfo(string xmid, bool validate = false)
-        {
-            this.Initialized = false;
-            if (string.IsNullOrWhiteSpace(xmid))
-                return;
-
-            this.XMID = xmid.TrimEnd('\0');
-            if (string.IsNullOrWhiteSpace(this.XMID))
-                return;
-
-            // XGD1 information is 8 characters
-            if (this.XMID.Length == 8)
-                this.Initialized = ParseXGD1XMID(this.XMID, validate);
-
-            // XGD2/3 information is semi-variable length
-            else if (this.XMID.Length == 13 || this.XMID.Length == 14 || this.XMID.Length == 21 || this.XMID.Length == 22)
-                this.Initialized = ParseXGD23XeMID(this.XMID, validate);
-        }
-
-        /// <summary>
-        /// Get the human-readable serial string
-        /// </summary>
-        /// <returns>Formatted serial string, null on error</returns>
-        public string GetSerial()
-        {
-            if (!this.Initialized)
-                return null;
-
-            try
-            {
-                // XGD1 doesn't use PlatformIdentifier
-                if (this.PlatformIdentifier == null)
-                    return $"{this.PublisherIdentifier}-{this.GameID}";
-
-                // XGD2/3 uses a specific identifier
-                else if (this.PlatformIdentifier == '2')
-                    return $"{this.PublisherIdentifier}-{this.PlatformIdentifier}{this.GameID}";
-
-                return null;
-            }
-            catch
-            {
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the human-readable version string
-        /// </summary>
-        /// <returns>Formatted version string, null on error</returns>
-        /// <remarks>This may differ for XGD2/3 in the future</remarks>
-        public string GetVersion()
-        {
-            if (!this.Initialized)
-                return null;
-
-            try
-            {
-                // XGD1 doesn't use PlatformIdentifier
-                if (this.PlatformIdentifier == null)
-                    return $"1.{this.SKU}";
-
-                // XGD2/3 uses a specific identifier
-                else if (this.PlatformIdentifier == '2')
-                    return $"1.{this.SKU}";
-
-                return null;
-            }
-            catch
-            {
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Parse an XGD1 XMID string
-        /// </summary>
-        /// <param name="xmid">XMID string to attempt to parse</param>
-        /// <param name="validate">True if value validation should be performed, false otherwise</param>
-        /// <returns>True if the XMID could be parsed, false otherwise</returns>
-        private bool ParseXGD1XMID(string xmid, bool validate)
-        {
-            if (xmid == null || xmid.Length != 8)
-                return false;
-
-            this.PublisherIdentifier = xmid.Substring(0, 2);
-            if (validate && string.IsNullOrEmpty(this.PublisherName))
-                return false;
-
-            this.GameID = xmid.Substring(2, 3);
-            this.SKU = xmid.Substring(5, 2);
-            this.RegionIdentifier = xmid[7];
-            if (validate && this.InternalRegion == null)
-                return false;
-
-            return true;
-        }
-
-        /// <summary>
-        /// Parse an XGD2/3 XeMID string
-        /// </summary>
-        /// <param name="xemid">XeMID string to attempt to parse</param>
-        /// <param name="validate">True if value validation should be performed, false otherwise</param>
-        /// <returns>True if the XeMID could be parsed, false otherwise</returns>
-        private bool ParseXGD23XeMID(string xemid, bool validate)
-        {
-            if (xemid == null
-                || (xemid.Length != 13 && xemid.Length != 14
-                    && xemid.Length != 21 && xemid.Length != 22))
-                return false;
-
-            this.PublisherIdentifier = xemid.Substring(0, 2);
-            if (validate && string.IsNullOrEmpty(this.PublisherName))
-                return false;
-
-            this.PlatformIdentifier = xemid[2];
-            if (validate && this.PlatformIdentifier != '2')
-                return false;
-
-            this.GameID = xemid.Substring(3, 3);
-            this.SKU = xemid.Substring(6, 2);
-            this.RegionIdentifier = xemid[8];
-            if (validate && this.InternalRegion == null)
-                return false;
-
-            if (xemid.Length == 13 || xemid.Length == 21)
-            {
-                this.BaseVersion = xemid.Substring(9, 1);
-                this.MediaSubtypeIdentifier = xemid[10];
-                if (validate && string.IsNullOrEmpty(this.MediaSubtype))
-                    return false;
-
-                this.DiscNumberIdentifier = xemid.Substring(11, 2);
-            }
-            else if (xemid.Length == 14 || xemid.Length == 22)
-            {
-                this.BaseVersion = xemid.Substring(9, 2);
-                this.MediaSubtypeIdentifier = xemid[11];
-                if (validate && string.IsNullOrEmpty(this.MediaSubtype))
-                    return false;
-
-                this.DiscNumberIdentifier = xemid.Substring(12, 2);
-            }
-
-            if (xemid.Length == 21)
-                this.CertificationSubmissionIdentifier = xemid.Substring(13);
-            else if (xemid.Length == 22)
-                this.CertificationSubmissionIdentifier = xemid.Substring(14);
-
-            return true;
-        }
-
-        #region Helpers
-
-        /// <summary>
-        /// Determine the XGD type based on the XGD2/3 media type identifier character
-        /// </summary>
-        /// <param name="mediaTypeIdentifier">Character denoting the media type</param>
-        /// <returns>Media subtype as a string, if possible</returns>
-        private static string GetMediaSubtype(char mediaTypeIdentifier)
-        {
-            switch (mediaTypeIdentifier)
-            {
-                case 'F': return "XGD3";
-                case 'X': return "XGD2";
-                case 'Z': return "Games on Demand / Marketplace Demo";
-                default: return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the full name of the publisher from the 2-character identifier
-        /// </summary>
-        /// <param name="publisherIdentifier">Case-sensitive 2-character identifier</param>
-        /// <returns>Publisher name, if possible</returns>
-        /// <see cref="https://xboxdevwiki.net/Xbe#Title_ID"/>
-        private static string GetPublisher(string publisherIdentifier)
-        {
-            switch (publisherIdentifier)
-            {
-                case "AC": return "Acclaim Entertainment";
-                case "AH": return "ARUSH Entertainment";
-                case "AQ": return "Aqua System";
-                case "AS": return "ASK";
-                case "AT": return "Atlus";
-                case "AV": return "Activision";
-                case "AY": return "Aspyr Media";
-                case "BA": return "Bandai";
-                case "BL": return "Black Box";
-                case "BM": return "BAM! Entertainment";
-                case "BR": return "Broccoli Co.";
-                case "BS": return "Bethesda Softworks";
-                case "BU": return "Bunkasha Co.";
-                case "BV": return "Buena Vista Games";
-                case "BW": return "BBC Multimedia";
-                case "BZ": return "Blizzard";
-                case "CC": return "Capcom";
-                case "CK": return "Kemco Corporation"; // TODO: Confirm
-                case "CM": return "Codemasters";
-                case "CV": return "Crave Entertainment";
-                case "DC": return "DreamCatcher Interactive";
-                case "DX": return "Davilex";
-                case "EA": return "Electronic Arts (EA)";
-                case "EC": return "Encore inc";
-                case "EL": return "Enlight Software";
-                case "EM": return "Empire Interactive";
-                case "ES": return "Eidos Interactive";
-                case "FI": return "Fox Interactive";
-                case "FS": return "From Software";
-                case "GE": return "Genki Co.";
-                case "GV": return "Groove Games";
-                case "HE": return "Tru Blu (Entertainment division of Home Entertainment Suppliers)";
-                case "HP": return "Hip games";
-                case "HU": return "Hudson Soft";
-                case "HW": return "Highwaystar";
-                case "IA": return "Mad Catz Interactive";
-                case "IF": return "Idea Factory";
-                case "IG": return "Infogrames";
-                case "IL": return "Interlex Corporation";
-                case "IM": return "Imagine Media";
-                case "IO": return "Ignition Entertainment";
-                case "IP": return "Interplay Entertainment";
-                case "IX": return "InXile Entertainment"; // TODO: Confirm
-                case "JA": return "Jaleco";
-                case "JW": return "JoWooD";
-                case "KB": return "Kemco"; // TODO: Confirm
-                case "KI": return "Kids Station Inc."; // TODO: Confirm
-                case "KN": return "Konami";
-                case "KO": return "KOEI";
-                case "KU": return "Kobi and / or GAE (formerly Global A Entertainment)"; // TODO: Confirm
-                case "LA": return "LucasArts";
-                case "LS": return "Black Bean Games (publishing arm of Leader S.p.A.)";
-                case "MD": return "Metro3D";
-                case "ME": return "Medix";
-                case "MI": return "Microïds";
-                case "MJ": return "Majesco Entertainment";
-                case "MM": return "Myelin Media";
-                case "MP": return "MediaQuest"; // TODO: Confirm
-                case "MS": return "Microsoft Game Studios";
-                case "MW": return "Midway Games";
-                case "MX": return "Empire Interactive"; // TODO: Confirm
-                case "NK": return "NewKidCo";
-                case "NL": return "NovaLogic";
-                case "NM": return "Namco";
-                case "OX": return "Oxygen Interactive";
-                case "PC": return "Playlogic Entertainment";
-                case "PL": return "Phantagram Co., Ltd.";
-                case "RA": return "Rage";
-                case "SA": return "Sammy";
-                case "SC": return "SCi Games";
-                case "SE": return "SEGA";
-                case "SN": return "SNK";
-                case "SS": return "Simon & Schuster";
-                case "SU": return "Success Corporation";
-                case "SW": return "Swing! Deutschland";
-                case "TA": return "Takara";
-                case "TC": return "Tecmo";
-                case "TD": return "The 3DO Company (or just 3DO)";
-                case "TK": return "Takuyo";
-                case "TM": return "TDK Mediactive";
-                case "TQ": return "THQ";
-                case "TS": return "Titus Interactive";
-                case "TT": return "Take-Two Interactive Software";
-                case "US": return "Ubisoft";
-                case "VC": return "Victor Interactive Software";
-                case "VN": return "Vivendi Universal (just took Interplays publishing rights)"; // TODO: Confirm
-                case "VU": return "Vivendi Universal Games";
-                case "VV": return "Vivendi Universal Games"; // TODO: Confirm
-                case "WE": return "Wanadoo Edition";
-                case "WR": return "Warner Bros. Interactive Entertainment"; // TODO: Confirm
-                case "XI": return "XPEC Entertainment and Idea Factory";
-                case "XK": return "Xbox kiosk disk?"; // TODO: Confirm
-                case "XL": return "Xbox special bundled or live demo disk?"; // TODO: Confirm
-                case "XM": return "Evolved Games"; // TODO: Confirm
-                case "XP": return "XPEC Entertainment";
-                case "XR": return "Panorama";
-                case "YB": return "YBM Sisa (South-Korea)";
-                case "ZD": return "Zushi Games (formerly Zoo Digital Publishing)";
-                default: return null;
-            }
-        }
-
-        /// <summary>
-        /// Determine the region based on the XGD serial character
-        /// </summary>
-        /// <param name="region">Character denoting the region</param>
-        /// <returns>Region, if possible</returns>
-        private static Region? GetRegion(char region)
-        {
-            switch (region)
-            {
-                case 'W': return Region.World;
-                case 'A': return Region.UnitedStatesOfAmerica;
-                case 'J': return Region.JapanAsia;
-                case 'E': return Region.Europe;
-                case 'K': return Region.USAJapan;
-                case 'L': return Region.USAEurope;
-                case 'H': return Region.JapanEurope;
-                default: return null;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Core/DumpEnvironment.cs

@@ -2,14 +2,15 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
-using BurnOutSharp;
 using MPF.Core.Data;
+using MPF.Core.Modules;
 using MPF.Core.Utilities;
-using MPF.Modules;
-using RedumpLib.Data;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF.Library
+namespace MPF.Core
 {
     /// <summary>
     /// Represents the state of all settings to be used during dumping
@@ -19,14 +20,9 @@ namespace MPF.Library
         #region Output paths
 
         /// <summary>
-        /// Base output directory to write files to
+        /// Base output file path to write files to
         /// </summary>
-        public string OutputDirectory { get; private set; }
-
-        /// <summary>
-        /// Base output filename for output
-        /// </summary>
-        public string OutputFilename { get; private set; }
+        public string OutputPath { get; private set; }
 
         #endregion
 
@@ -35,7 +31,7 @@ namespace MPF.Library
         /// <summary>
         /// Drive object representing the current drive
         /// </summary>
-        public Drive Drive { get; private set; }
+        public Drive? Drive { get; private set; }
 
         /// <summary>
         /// Currently selected system
@@ -47,39 +43,56 @@ namespace MPF.Library
         /// </summary>
         public MediaType? Type { get; private set; }
 
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram InternalProgram { get; private set; }
+
         /// <summary>
         /// Options object representing user-defined options
         /// </summary>
-        public Options Options { get; private set; }
+        public Data.Options Options { get; private set; }
 
         /// <summary>
         /// Parameters object representing what to send to the internal program
         /// </summary>
-        public BaseParameters Parameters { get; private set; }
+        public BaseParameters? Parameters { get; private set; }
 
         #endregion
-        
+
         #region Event Handlers
 
         /// <summary>
         /// Generic way of reporting a message
         /// </summary>
-        public EventHandler<string> ReportStatus;
+#if NET20 || NET35 || NET40
+        public EventHandler<BaseParameters.StringEventArgs>? ReportStatus;
+#else
+        public EventHandler<string>? ReportStatus;
+#endif
 
         /// <summary>
         /// Queue of items that need to be logged
         /// </summary>
-        private ProcessingQueue<string> outputQueue;
+        private ProcessingQueue<string>? outputQueue;
 
         /// <summary>
         /// Event handler for data returned from a process
         /// </summary>
-        private void OutputToLog(object proc, string args) => outputQueue.Enqueue(args);
+#if NET20 || NET35 || NET40
+        private void OutputToLog(object? proc, BaseParameters.StringEventArgs args) => outputQueue?.Enqueue(args.Value);
+#else
+        private void OutputToLog(object? proc, string args) => outputQueue?.Enqueue(args);
+#endif
 
         /// <summary>
         /// Process the outputs in the queue
         /// </summary>
-        private void ProcessOutputs(string nextOutput) => ReportStatus.Invoke(this, nextOutput);
+#if NET20 || NET35 || NET40
+        private void ProcessOutputs(string nextOutput) => ReportStatus?.Invoke(this, new BaseParameters.StringEventArgs { Value = nextOutput });
+#else
+        private void ProcessOutputs(string nextOutput) => ReportStatus?.Invoke(this, nextOutput);
+#endif
 
         #endregion
 
@@ -87,102 +100,70 @@ namespace MPF.Library
         /// Constructor for a full DumpEnvironment object from user information
         /// </summary>
         /// <param name="options"></param>
-        /// <param name="outputDirectory"></param>
-        /// <param name="outputFilename"></param>
+        /// <param name="outputPath"></param>
         /// <param name="drive"></param>
         /// <param name="system"></param>
         /// <param name="type"></param>
+        /// <param name="internalProgram"></param>
         /// <param name="parameters"></param>
-        public DumpEnvironment(Options options,
-            string outputDirectory,
-            string outputFilename,
-            Drive drive,
+        public DumpEnvironment(Data.Options options,
+            string outputPath,
+            Drive? drive,
             RedumpSystem? system,
             MediaType? type,
-            string parameters)
+            InternalProgram? internalProgram,
+            string? parameters)
         {
             // Set options object
-            this.Options = options;
+            Options = options;
 
             // Output paths
-            (this.OutputDirectory, this.OutputFilename) = InfoTool.NormalizeOutputPaths(outputDirectory, outputFilename);
+            OutputPath = InfoTool.NormalizeOutputPaths(outputPath, false);
 
             // UI information
-            this.Drive = drive;
-            this.System = system ?? options.DefaultSystem;
-            this.Type = type ?? MediaType.NONE;
-            
+            Drive = drive;
+            System = system ?? options.DefaultSystem;
+            Type = type ?? MediaType.NONE;
+            InternalProgram = internalProgram ?? options.InternalProgram;
+
             // Dumping program
             SetParameters(parameters);
         }
 
         #region Public Functionality
 
-        /// <summary>
-        /// Adjust output paths if we're using DiscImageCreator
-        /// </summary>
-        public void AdjustPathsForDiscImageCreator()
-        {
-            // Only DiscImageCreator has issues with paths
-            if (this.Parameters.InternalProgram != InternalProgram.DiscImageCreator)
-                return;
-
-            // Replace all instances in the output directory
-            this.OutputDirectory = this.OutputDirectory.Replace('.', '_');
-
-            // Currently, only periods in directories matter
-            // Leave the following code commented in case filename handling breaks again
-
-            // Replace all instances in the output filename, except the extension
-            //string tempFilename = Path.GetFileNameWithoutExtension(this.OutputFilename)
-            //    .Replace('.', '_');
-            //string tempExtension = Path.GetExtension(this.OutputFilename)?.TrimStart('.');
-            //this.OutputFilename = $"{tempFilename}.{tempExtension}";
-        }
-
         /// <summary>
         /// Set the parameters object based on the internal program and parameters string
         /// </summary>
         /// <param name="parameters">String representation of the parameters</param>
-        public void SetParameters(string parameters)
+        public void SetParameters(string? parameters)
         {
-            switch (Options.InternalProgram)
+            Parameters = InternalProgram switch
             {
                 // Dumping support
-                case InternalProgram.Aaru:
-                    this.Parameters = new Modules.Aaru.Parameters(parameters) { ExecutablePath = Options.AaruPath };
-                    break;
-
-                case InternalProgram.DD:
-                    this.Parameters = new Modules.DD.Parameters(parameters) { ExecutablePath = Options.DDPath };
-                    break;
-
-                case InternalProgram.DiscImageCreator:
-                    this.Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
-                    break;
+                InternalProgram.Aaru => new Modules.Aaru.Parameters(parameters) { ExecutablePath = Options.AaruPath },
+                InternalProgram.DiscImageCreator => new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath },
+                InternalProgram.Redumper => new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath },
 
                 // Verification support only
-                case InternalProgram.CleanRip:
-                    this.Parameters = new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null };
-                    break;
+                InternalProgram.CleanRip => new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null },
+                InternalProgram.DCDumper => null, // TODO: Create correct parameter type when supported
+                InternalProgram.PS3CFW => new Modules.PS3CFW.Parameters(parameters) { ExecutablePath = null },
+                InternalProgram.UmdImageCreator => new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null },
 
-                case InternalProgram.DCDumper:
-                    this.Parameters = null; // TODO: Create correct parameter type when supported
-                    break;
-
-                case InternalProgram.UmdImageCreator:
-                    this.Parameters = new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null };
-                    break;
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
 
                 // This should never happen, but it needs a fallback
-                default:
-                    this.Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
-                    break;
-            }
+                _ => new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath },
+            };
 
             // Set system and type
-            this.Parameters.System = this.System;
-            this.Parameters.Type = this.Type;
+            if (Parameters != null)
+            {
+                Parameters.System = System;
+                Parameters.Type = Type;
+            }
         }
 
         /// <summary>
@@ -190,7 +171,7 @@ namespace MPF.Library
         /// </summary>
         /// <param name="driveSpeed">Nullable int representing the drive speed</param>
         /// <returns>String representing the params, null on error</returns>
-        public string GetFullParameters(int? driveSpeed)
+        public string? GetFullParameters(int? driveSpeed)
         {
             // Populate with the correct params for inputs (if we're not on the default option)
             if (System != null && Type != MediaType.NONE)
@@ -200,29 +181,21 @@ namespace MPF.Library
                     return null;
 
                 // Set the proper parameters
-                string filename = OutputDirectory + Path.DirectorySeparatorChar + OutputFilename;
-                switch (Options.InternalProgram)
+                Parameters = InternalProgram switch
                 {
-                    case InternalProgram.Aaru:
-                        Parameters = new Modules.Aaru.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
-                        break;
+                    InternalProgram.Aaru => new Modules.Aaru.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                    InternalProgram.DiscImageCreator => new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                    InternalProgram.Redumper => new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
 
-                    case InternalProgram.DD:
-                        Parameters = new Modules.DD.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
-                        break;
-
-                    case InternalProgram.DiscImageCreator:
-                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
-                        break;
+                    // If no dumping program found, set to null
+                    InternalProgram.NONE => null,
 
                     // This should never happen, but it needs a fallback
-                    default:
-                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
-                        break;
-                }
+                    _ => new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                };
 
                 // Generate and return the param string
-                return Parameters.GenerateParameters();
+                return Parameters?.GenerateParameters();
             }
 
             return null;
@@ -235,26 +208,34 @@ namespace MPF.Library
         /// <summary>
         /// Cancel an in-progress dumping process
         /// </summary>
-        public void CancelDumping() => Parameters.KillInternalProgram();
+        public void CancelDumping() => Parameters?.KillInternalProgram();
 
         /// <summary>
         /// Eject the disc using DiscImageCreator
         /// </summary>
-        public async Task<string> EjectDisc() =>
+        public async Task<string?> EjectDisc() =>
             await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Eject);
 
         /// <summary>
         /// Reset the current drive using DiscImageCreator
         /// </summary>
-        public async Task<string> ResetDrive() =>
+        public async Task<string?> ResetDrive() =>
             await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Reset);
 
         /// <summary>
         /// Execute the initial invocation of the dumping programs
         /// </summary>
         /// <param name="progress">Optional result progress callback</param>
-        public async Task<Result> Run(IProgress<Result> progress = null)
+#if NET40
+        public Result Run(IProgress<Result>? progress = null)
+#else
+        public async Task<Result> Run(IProgress<Result>? progress = null)
+#endif
         {
+            // If we don't have parameters
+            if (Parameters == null)
+                return Result.Failure("Error! Current configuration is not supported!");
+
             // Check that we have the basics for dumping
             Result result = IsValidForDump();
             if (!result)
@@ -264,24 +245,29 @@ namespace MPF.Library
             if (!Options.ToolsInSeparateWindow)
             {
                 outputQueue = new ProcessingQueue<string>(ProcessOutputs);
-                Parameters.ReportStatus += OutputToLog;
+                if (Parameters.ReportStatus != null)
+                    Parameters.ReportStatus += OutputToLog;
             }
 
             // Execute internal tool
-            progress?.Report(Result.Success($"Executing {Options.InternalProgram}... {(Options.ToolsInSeparateWindow ? "please wait!" : "see log for output!")}"));
-            Directory.CreateDirectory(OutputDirectory);
-            await Task.Run(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
-            progress?.Report(Result.Success($"{Options.InternalProgram} has finished!"));
+            progress?.Report(Result.Success($"Executing {InternalProgram}... {(Options.ToolsInSeparateWindow ? "please wait!" : "see log for output!")}"));
 
-            // Execute additional tools
-            progress?.Report(Result.Success("Running any additional tools... see log for output!"));
-            result = await Task.Run(() => ExecuteAdditionalTools());
-            progress?.Report(result);
+            var directoryName = Path.GetDirectoryName(OutputPath);
+            if (!string.IsNullOrEmpty(directoryName))
+                Directory.CreateDirectory(directoryName);
+
+#if NET40
+            var executeTask = Task.Factory.StartNew(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
+            executeTask.Wait();
+#else
+            await Task.Run(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
+#endif
+            progress?.Report(Result.Success($"{InternalProgram} has finished!"));
 
             // Remove event handler if needed
             if (!Options.ToolsInSeparateWindow)
             {
-                outputQueue.Dispose();
+                outputQueue?.Dispose();
                 Parameters.ReportStatus -= OutputToLog;
             }
 
@@ -294,47 +280,63 @@ namespace MPF.Library
         /// <param name="resultProgress">Optional result progress callback</param>
         /// <param name="protectionProgress">Optional protection progress callback</param>
         /// <param name="processUserInfo">Optional user prompt to deal with submission information</param>
+        /// <param name="seedInfo">A seed SubmissionInfo object that contains user data</param>
         /// <returns>Result instance with the outcome</returns>
         public async Task<Result> VerifyAndSaveDumpOutput(
-            IProgress<Result> resultProgress = null,
-            IProgress<ProtectionProgress> protectionProgress = null,
-            Func<SubmissionInfo, (bool?, SubmissionInfo)> processUserInfo = null)
+            IProgress<Result>? resultProgress = null,
+            IProgress<BinaryObjectScanner.ProtectionProgress>? protectionProgress = null,
+            Func<SubmissionInfo?, (bool?, SubmissionInfo?)>? processUserInfo = null,
+            SubmissionInfo? seedInfo = null)
         {
+            if (Parameters == null)
+                return Result.Failure("Error! Current configuration is not supported!");
+
             resultProgress?.Report(Result.Success("Gathering submission information... please wait!"));
 
+            // Get the output directory and filename separately
+            var outputDirectory = Path.GetDirectoryName(OutputPath);
+            var outputFilename = Path.GetFileName(OutputPath);
+
             // Check to make sure that the output had all the correct files
-            (bool foundFiles, List<string> missingFiles) = InfoTool.FoundAllFiles(this.OutputDirectory, this.OutputFilename, this.Parameters, false);
+            (bool foundFiles, List<string> missingFiles) = Parameters.FoundAllFiles(outputDirectory, outputFilename, false);
             if (!foundFiles)
             {
-                resultProgress?.Report(Result.Failure($"There were files missing from the output:\n{string.Join("\n", missingFiles)}"));
+                resultProgress?.Report(Result.Failure($"There were files missing from the output:\n{string.Join("\n", [.. missingFiles])}"));
                 return Result.Failure("Error! Please check output directory as dump may be incomplete!");
             }
 
             // Extract the information from the output files
             resultProgress?.Report(Result.Success("Extracting output information from output files..."));
-            SubmissionInfo submissionInfo = await InfoTool.ExtractOutputInformation(
-                this.OutputDirectory,
-                this.OutputFilename,
-                this.Drive,
-                this.System,
-                this.Type,
-                this.Options,
-                this.Parameters,
+            var submissionInfo = await SubmissionInfoTool.ExtractOutputInformation(
+                OutputPath,
+                Drive,
+                System,
+                Type,
+                Options,
+                Parameters,
                 resultProgress,
                 protectionProgress);
             resultProgress?.Report(Result.Success("Extracting information complete!"));
 
+            // Inject seed submission info data, if necessary
+            if (seedInfo != null)
+            {
+                resultProgress?.Report(Result.Success("Injecting user-supplied information..."));
+                Builder.InjectSubmissionInformation(submissionInfo, seedInfo);
+                resultProgress?.Report(Result.Success("Information injection complete!"));
+            }
+
             // Eject the disc automatically if configured to
             if (Options.EjectAfterDump == true)
             {
-                resultProgress?.Report(Result.Success($"Ejecting disc in drive {Drive.Letter}"));
+                resultProgress?.Report(Result.Success($"Ejecting disc in drive {Drive?.Name}"));
                 await EjectDisc();
             }
 
             // Reset the drive automatically if configured to
-            if (Options.InternalProgram == InternalProgram.DiscImageCreator && Options.DICResetDriveAfterDump)
+            if (InternalProgram == InternalProgram.DiscImageCreator && Options.DICResetDriveAfterDump)
             {
-                resultProgress?.Report(Result.Success($"Resetting drive {Drive.Letter}"));
+                resultProgress?.Report(Result.Success($"Resetting drive {Drive?.Name}"));
                 await ResetDrive();
             }
 
@@ -354,42 +356,84 @@ namespace MPF.Library
 
             // Process special fields for site codes
             resultProgress?.Report(Result.Success("Processing site codes..."));
-            InfoTool.ProcessSpecialFields(submissionInfo);
+            Formatter.ProcessSpecialFields(submissionInfo);
             resultProgress?.Report(Result.Success("Processing complete!"));
 
             // Format the information for the text output
             resultProgress?.Report(Result.Success("Formatting information..."));
-            List<string> formattedValues = InfoTool.FormatOutputData(submissionInfo);
-            resultProgress?.Report(Result.Success("Formatting complete!"));
+            (var formattedValues, var formatResult) = Formatter.FormatOutputData(submissionInfo, Options.EnableRedumpCompatibility);
+            if (formattedValues == null)
+                resultProgress?.Report(Result.Failure(formatResult));
+            else
+                resultProgress?.Report(Result.Success(formatResult));
+
+            // Get the filename suffix for auto-generated files
+            var filenameSuffix = Options.AddFilenameSuffix ? Path.GetFileNameWithoutExtension(outputFilename) : null;
 
             // Write the text output
             resultProgress?.Report(Result.Success("Writing information to !submissionInfo.txt..."));
-            bool success = InfoTool.WriteOutputData(this.OutputDirectory, formattedValues);
-            if (success)
-                resultProgress?.Report(Result.Success("Writing complete!"));
+            (bool txtSuccess, string txtResult) = InfoTool.WriteOutputData(outputDirectory, filenameSuffix, formattedValues);
+            if (txtSuccess)
+                resultProgress?.Report(Result.Success(txtResult));
             else
-                resultProgress?.Report(Result.Failure("Writing could not complete!"));
+                resultProgress?.Report(Result.Failure(txtResult));
+
+            // Write the copy protection output
+            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Any())
+            {
+                if (Options.ScanForProtection && Options.OutputSeparateProtectionFile)
+                {
+                    resultProgress?.Report(Result.Success("Writing protection to !protectionInfo.txt..."));
+                    bool scanSuccess = InfoTool.WriteProtectionData(outputDirectory, filenameSuffix, submissionInfo, Options.HideDriveLetters);
+                    if (scanSuccess)
+                        resultProgress?.Report(Result.Success("Writing complete!"));
+                    else
+                        resultProgress?.Report(Result.Failure("Writing could not complete!"));
+                }
+            }
 
             // Write the JSON output, if required
             if (Options.OutputSubmissionJSON)
             {
-                resultProgress?.Report(Result.Success("Writing information to !submissionInfo.json.gz..."));
-                success = InfoTool.WriteOutputData(this.OutputDirectory, submissionInfo);
-                if (success)
+                resultProgress?.Report(Result.Success($"Writing information to !submissionInfo.json{(Options.IncludeArtifacts ? ".gz" : string.Empty)}..."));
+                bool jsonSuccess = InfoTool.WriteOutputData(outputDirectory, filenameSuffix, submissionInfo, Options.IncludeArtifacts);
+                if (jsonSuccess)
                     resultProgress?.Report(Result.Success("Writing complete!"));
                 else
                     resultProgress?.Report(Result.Failure("Writing could not complete!"));
             }
 
-            // Conpress the logs, if required
+            // Compress the logs, if required
             if (Options.CompressLogFiles)
             {
                 resultProgress?.Report(Result.Success("Compressing log files..."));
-                success = InfoTool.CompressLogFiles(this.OutputDirectory, this.OutputFilename, this.Parameters);
-                if (success)
-                    resultProgress?.Report(Result.Success("Compression complete!"));
+                (bool compressSuccess, string compressResult) = InfoTool.CompressLogFiles(outputDirectory, filenameSuffix, outputFilename, Parameters);
+                if (compressSuccess)
+                    resultProgress?.Report(Result.Success(compressResult));
                 else
-                    resultProgress?.Report(Result.Failure("Compression could not complete!"));
+                    resultProgress?.Report(Result.Failure(compressResult));
+            }
+
+            // Delete unnecessary files, if required
+            if (Options.DeleteUnnecessaryFiles)
+            {
+                resultProgress?.Report(Result.Success("Deleting unnecessary files..."));
+                (bool deleteSuccess, string deleteResult) = InfoTool.DeleteUnnecessaryFiles(outputDirectory, outputFilename, Parameters);
+                if (deleteSuccess)
+                    resultProgress?.Report(Result.Success(deleteResult));
+                else
+                    resultProgress?.Report(Result.Failure(deleteResult));
+            }
+
+            // Create PS3 IRD, if required
+            if (Options.CreateIRDAfterDumping && System == RedumpSystem.SonyPlayStation3 && Type == MediaType.BluRay)
+            {
+                resultProgress?.Report(Result.Success("Creating IRD... please wait!"));
+                (bool deleteSuccess, string deleteResult) = await InfoTool.WriteIRD(OutputPath, submissionInfo?.Extras?.DiscKey, submissionInfo?.Extras?.DiscID, submissionInfo?.Extras?.PIC, submissionInfo?.SizeAndChecksums?.Layerbreak, submissionInfo?.SizeAndChecksums?.CRC32);
+                if (deleteSuccess)
+                    resultProgress?.Report(Result.Success(deleteResult));
+                else
+                    resultProgress?.Report(Result.Failure(deleteResult));
             }
 
             resultProgress?.Report(Result.Success("Submission information process complete!"));
@@ -402,7 +446,11 @@ namespace MPF.Library
         /// <returns>True if the configuration is valid, false otherwise</returns>
         internal bool ParametersValid()
         {
-            bool parametersValid = Parameters.IsValid();
+            // Missing drive means it can never be valid
+            if (Drive == null)
+                return false;
+
+            bool parametersValid = Parameters?.IsValid() ?? false;
             bool floppyValid = !(Drive.InternalDriveType == InternalDriveType.Floppy ^ Type == MediaType.FloppyDisk);
 
             // TODO: HardDisk being in the Removable category is a hack, fix this later
@@ -412,28 +460,26 @@ namespace MPF.Library
             return parametersValid && floppyValid && removableDiskValid;
         }
 
-        /// <summary>
-        /// Run any additional tools given a DumpEnvironment
-        /// </summary>
-        /// <returns>Result instance with the outcome</returns>
-        private Result ExecuteAdditionalTools() => Result.Success("No external tools needed!");
-
         /// <summary>
         /// Run internal program async with an input set of parameters
         /// </summary>
         /// <param name="parameters"></param>
         /// <returns>Standard output from commandline window</returns>
-        private async Task<string> ExecuteInternalProgram(BaseParameters parameters)
+        private static async Task<string> ExecuteInternalProgram(BaseParameters parameters)
         {
             Process childProcess;
+#if NET40
+            string output = await Task.Factory.StartNew(() =>
+#else
             string output = await Task.Run(() =>
+#endif
             {
                 childProcess = new Process()
                 {
                     StartInfo = new ProcessStartInfo()
                     {
-                        FileName = parameters.ExecutablePath,
-                        Arguments = parameters.GenerateParameters(),
+                        FileName = parameters.ExecutablePath!,
+                        Arguments = parameters.GenerateParameters()!,
                         CreateNoWindow = true,
                         UseShellExecute = false,
                         RedirectStandardInput = true,
@@ -462,25 +508,24 @@ namespace MPF.Library
         private Result IsValidForDump()
         {
             // Validate that everything is good
-            if (!ParametersValid())
+            if (Parameters == null || !ParametersValid())
                 return Result.Failure("Error! Current configuration is not supported!");
 
             // Fix the output paths, just in case
-            (OutputDirectory, OutputFilename) = InfoTool.NormalizeOutputPaths(OutputDirectory, OutputFilename);
+            OutputPath = InfoTool.NormalizeOutputPaths(OutputPath, false);
 
             // Validate that the output path isn't on the dumping drive
-            string fullOutputPath = Path.GetFullPath(Path.Combine(OutputDirectory, OutputFilename));
-            if (fullOutputPath[0] == Drive.Letter)
-                return Result.Failure($"Error! Cannot output to same drive that is being dumped!");
+            if (Drive?.Name != null && OutputPath.StartsWith(Drive.Name))
+                return Result.Failure("Error! Cannot output to same drive that is being dumped!");
 
             // Validate that the required program exists
             if (!File.Exists(Parameters.ExecutablePath))
                 return Result.Failure($"Error! {Parameters.ExecutablePath} does not exist!");
 
             // Validate that the dumping drive doesn't contain the executable
-            string fullExecutablePath = Path.GetFullPath(Parameters.ExecutablePath);
-            if (fullExecutablePath[0] == Drive.Letter)
-                return Result.Failure("$Error! Cannot dump same drive that executable resides on!");
+            string fullExecutablePath = Path.GetFullPath(Parameters.ExecutablePath!);
+            if (Drive?.Name != null && fullExecutablePath.StartsWith(Drive.Name))
+                return Result.Failure("Error! Cannot dump same drive that executable resides on!");
 
             // Validate that the current configuration is supported
             return Tools.GetSupportStatus(System, Type);
@@ -493,7 +538,7 @@ namespace MPF.Library
         private bool RequiredProgramsExist()
         {
             // Validate that the path is configured
-            if (string.IsNullOrWhiteSpace(Options.DiscImageCreatorPath))
+            if (string.IsNullOrEmpty(Options.DiscImageCreatorPath))
                 return false;
 
             // Validate that the required program exists
@@ -508,14 +553,14 @@ namespace MPF.Library
         /// </summary>
         /// <param name="command">Command string to run</param>
         /// <returns>The output of the command on success, null on error</returns>
-        private async Task<string> RunStandaloneDiscImageCreatorCommand(string command)
+        private async Task<string?> RunStandaloneDiscImageCreatorCommand(string command)
         {
             // Validate that DiscImageCreator is all set
             if (!RequiredProgramsExist())
                 return null;
 
             // Validate we're not trying to eject a non-optical
-            if (Drive.InternalDriveType != InternalDriveType.Optical)
+            if (Drive == null || Drive.InternalDriveType != InternalDriveType.Optical)
                 return null;
 
             CancelDumping();
@@ -523,7 +568,7 @@ namespace MPF.Library
             var parameters = new Modules.DiscImageCreator.Parameters(string.Empty)
             {
                 BaseCommand = command,
-                DriveLetter = Drive.Letter.ToString(),
+                DrivePath = Drive.Name,
                 ExecutablePath = Options.DiscImageCreatorPath,
             };
 

MPF.Core/Hashing/Hasher.cs

@@ -1,176 +0,0 @@
-using System;
-using System.Linq;
-using System.Security.Cryptography;
-
-namespace MPF.Core.Hashing
-{
-    /// <summary>
-    /// Available hashing types
-    /// </summary>
-    [Flags]
-    public enum Hash
-    {
-        CRC = 1 << 0,
-        MD5 = 1 << 1,
-        SHA1 = 1 << 2,
-        SHA256 = 1 << 3,
-        SHA384 = 1 << 4,
-        SHA512 = 1 << 5,
-
-        // Special combinations
-        Standard = CRC | MD5 | SHA1,
-        All = CRC | MD5 | SHA1 | SHA256 | SHA384 | SHA512,
-    }
-
-    /// <summary>
-    /// Async hashing class wraper
-    /// </summary>
-    public class Hasher
-    {
-        public Hash HashType { get; private set; }
-        private IDisposable _hasher; 
-
-        public Hasher(Hash hashType)
-        {
-            this.HashType = hashType;
-            GetHasher();
-        }
-
-        /// <summary>
-        /// Generate the correct hashing class based on the hash type
-        /// </summary>
-        private void GetHasher()
-        {
-            switch (HashType)
-            {
-                case Hash.CRC:
-                    _hasher = new OptimizedCRC();
-                    break;
-
-                case Hash.MD5:
-                    _hasher = MD5.Create();
-                    break;
-
-                case Hash.SHA1:
-                    _hasher = SHA1.Create();
-                    break;
-
-                case Hash.SHA256:
-                    _hasher = SHA256.Create();
-                    break;
-
-                case Hash.SHA384:
-                    _hasher = SHA384.Create();
-                    break;
-
-                case Hash.SHA512:
-                    _hasher = SHA512.Create();
-                    break;
-            }
-        }
-
-        public void Dispose()
-        {
-            _hasher.Dispose();
-        }
-
-        /// <summary>
-        /// Process a buffer of some length with the internal hash algorithm
-        /// </summary>
-        public void Process(byte[] buffer, int size)
-        {
-            switch (HashType)
-            {
-                case Hash.CRC:
-                    (_hasher as OptimizedCRC).Update(buffer, 0, size);
-                    break;
-
-                case Hash.MD5:
-                case Hash.SHA1:
-                case Hash.SHA256:
-                case Hash.SHA384:
-                case Hash.SHA512:
-                    (_hasher as HashAlgorithm).TransformBlock(buffer, 0, size, null, 0);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Finalize the internal hash algorigthm
-        /// </summary>
-        public void Terminate()
-        {
-            byte[] emptyBuffer = new byte[0];
-            switch (HashType)
-            {
-                case Hash.CRC:
-                    (_hasher as OptimizedCRC).Update(emptyBuffer, 0, 0);
-                    break;
-
-                case Hash.MD5:
-                case Hash.SHA1:
-                case Hash.SHA256:
-                case Hash.SHA384:
-                case Hash.SHA512:
-                    (_hasher as HashAlgorithm).TransformFinalBlock(emptyBuffer, 0, 0);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Get internal hash as a byte array
-        /// </summary>
-        public byte[] GetHash()
-        {
-            switch (HashType)
-            {
-                case Hash.CRC:
-                    return BitConverter.GetBytes((_hasher as OptimizedCRC).Value).Reverse().ToArray();
-
-                case Hash.MD5:
-                case Hash.SHA1:
-                case Hash.SHA256:
-                case Hash.SHA384:
-                case Hash.SHA512:
-                    return (_hasher as HashAlgorithm).Hash;
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Get internal hash as a string
-        /// </summary>
-        public string GetHashString()
-        {
-            byte[] hash = GetHash();
-            if (hash == null)
-                return null;
-            
-            return ByteArrayToString(hash);
-        }
-
-        /// <summary>
-        /// Convert a byte array to a hex string
-        /// </summary>
-        /// <param name="bytes">Byte array to convert</param>
-        /// <returns>Hex string representing the byte array</returns>
-        /// <link>http://stackoverflow.com/questions/311165/how-do-you-convert-byte-array-to-hexadecimal-string-and-vice-versa</link>
-        private static string ByteArrayToString(byte[] bytes)
-        {
-            // If we get null in, we send null out
-            if (bytes == null)
-                return null;
-
-            try
-            {
-                string hex = BitConverter.ToString(bytes);
-                return hex.Replace("-", string.Empty).ToLowerInvariant();
-            }
-            catch
-            {
-                return null;
-            }
-        }
-    }
-}

MPF.Core/Hashing/OptimizedCRC.cs

@@ -1,154 +0,0 @@
-/*
- 
- Copyright (c) 2012-2015 Eugene Larchenko (spct@mail.ru)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- 
-*/
-
-using System;
-
-//namespace OptimizedCRC
-namespace MPF.Core.Hashing
-{
-    internal class OptimizedCRC : IDisposable
-    {
-        private const uint kCrcPoly = 0xEDB88320;
-        private const uint kInitial = 0xFFFFFFFF;
-        private const int CRC_NUM_TABLES = 8;
-        private static readonly uint[] Table;
-
-        static OptimizedCRC()
-        {
-            unchecked
-            {
-                Table = new uint[256 * CRC_NUM_TABLES];
-                int i;
-                for (i = 0; i < 256; i++)
-                {
-                    uint r = (uint)i;
-                    for (int j = 0; j < 8; j++)
-                    {
-                        r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
-                    }
-                    Table[i] = r;
-                }
-                for (; i < 256 * CRC_NUM_TABLES; i++)
-                {
-                    uint r = Table[i - 256];
-                    Table[i] = Table[r & 0xFF] ^ (r >> 8);
-                }
-            }
-        }
-
-        public uint UnsignedValue;
-
-        public OptimizedCRC()
-        {
-            Init();
-        }
-
-        /// <summary>
-        /// Reset CRC
-        /// </summary>
-        public void Init()
-        {
-            UnsignedValue = kInitial;
-        }
-
-        public int Value
-        {
-            get { return (int)~UnsignedValue; }
-        }
-
-        public void Update(byte[] data, int offset, int count)
-        {
-            new ArraySegment<byte>(data, offset, count);     // check arguments
-            if (count == 0)
-            {
-                return;
-            }
-
-            var table = OptimizedCRC.Table;
-
-            uint crc = UnsignedValue;
-
-            for (; (offset & 7) != 0 && count != 0; count--)
-            {
-                crc = (crc >> 8) ^ table[(byte)crc ^ data[offset++]];
-            }
-
-            if (count >= 8)
-            {
-                /*
-                 * Idea from 7-zip project sources (http://7-zip.org/sdk.html)
-                 */
-
-                int end = (count - 8) & ~7;
-                count -= end;
-                end += offset;
-
-                while (offset != end)
-                {
-                    crc ^= (uint)(data[offset] + (data[offset + 1] << 8) + (data[offset + 2] << 16) + (data[offset + 3] << 24));
-                    uint high = (uint)(data[offset + 4] + (data[offset + 5] << 8) + (data[offset + 6] << 16) + (data[offset + 7] << 24));
-                    offset += 8;
-
-                    crc = table[(byte)crc + 0x700]
-                        ^ table[(byte)(crc >>= 8) + 0x600]
-                        ^ table[(byte)(crc >>= 8) + 0x500]
-                        ^ table[/*(byte)*/(crc >> 8) + 0x400]
-                        ^ table[(byte)(high) + 0x300]
-                        ^ table[(byte)(high >>= 8) + 0x200]
-                        ^ table[(byte)(high >>= 8) + 0x100]
-                        ^ table[/*(byte)*/(high >> 8) + 0x000];
-                }
-            }
-
-            while (count-- != 0)
-            {
-                crc = (crc >> 8) ^ table[(byte)crc ^ data[offset++]];
-            }
-
-            UnsignedValue = crc;
-        }
-
-        static public int Compute(byte[] data, int offset, int count)
-        {
-            var crc = new OptimizedCRC();
-            crc.Update(data, offset, count);
-            return crc.Value;
-        }
-
-        static public int Compute(byte[] data)
-        {
-            return Compute(data, 0, data.Length);
-        }
-
-        static public int Compute(ArraySegment<byte> block)
-        {
-            return Compute(block.Array, block.Offset, block.Count);
-        }
-
-        public void Dispose()
-        {
-            UnsignedValue = 0;
-        }
-    }
-}

MPF.Core/Hashing/ThreadLoadBuffer.cs

@@ -1,80 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-
-//namespace Compress.ThreadReaders
-namespace MPF.Core.Hashing
-{
-    public class ThreadLoadBuffer : IDisposable
-    {
-        private readonly AutoResetEvent _waitEvent;
-        private readonly AutoResetEvent _outEvent;
-        private readonly Thread _tWorker;
-
-        private byte[] _buffer;
-        private int _size;
-        private readonly Stream _ds;
-        private bool _finished;
-        public bool errorState;
-
-        public int SizeRead;
-
-        public ThreadLoadBuffer(Stream ds)
-        {
-            _waitEvent = new AutoResetEvent(false);
-            _outEvent = new AutoResetEvent(false);
-            _finished = false;
-            _ds = ds;
-            errorState = false;
-
-            _tWorker = new Thread(MainLoop);
-            _tWorker.Start();
-        }
-
-        public void Dispose()
-        {
-            _waitEvent.Close();
-            _outEvent.Close();
-        }
-
-        private void MainLoop()
-        {
-            while (true)
-            {
-                _waitEvent.WaitOne();
-                if (_finished)
-                {
-                    break;
-                }
-                try
-                {
-                    SizeRead = _ds.Read(_buffer, 0, _size);
-                }
-                catch (Exception)
-                {
-                    errorState = true;
-                }
-                _outEvent.Set();
-            }
-        }
-
-        public void Trigger(byte[] buffer, int size)
-        {
-            _buffer = buffer;
-            _size = size;
-            _waitEvent.Set();
-        }
-
-        public void Wait()
-        {
-            _outEvent.WaitOne();
-        }
-
-        public void Finish()
-        {
-            _finished = true;
-            _waitEvent.Set();
-            _tWorker.Join();
-        }
-    }
-}

MPF.Core/MPF.Core.csproj

@@ -1,65 +1,63 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
+    <!-- Assembly Properties -->
+    <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+    <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <VersionPrefix>3.1.6</VersionPrefix>
+
+    <!-- Package Properties -->
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2021</Copyright>
+    <Description>Common code for all MPF implementations</Description>
+    <Copyright>Copyright (c) Matt Nadareski 2019-2024</Copyright>
+    <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.3</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <RepositoryType>git</RepositoryType>
   </PropertyGroup>
 
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
-  </PropertyGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="MPF.Test" />
+  </ItemGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
-    <DefineConstants>NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
-    <COMReference Include="IMAPI2">
-      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="IMAPI2FS">
-      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
+  <!-- Support for old .NET versions -->
+  <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
+    <PackageReference Include="MinAsyncBridge" Version="0.12.4" />
+    <PackageReference Include="MinTasksExtensionsBridge" Version="0.3.4" />
+    <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
+  </ItemGroup>
+  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`))">
+    <PackageReference Include="System.IO.Compression" Version="4.3.0" />
+  </ItemGroup>
+  <ItemGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
+    <PackageReference Include="IndexRange" Version="1.0.3" />
+  </ItemGroup>
+  <ItemGroup Condition="$(TargetFramework.StartsWith(`net452`))">
+    <PackageReference Include="Microsoft.Net.Http" Version="2.2.29" />
+  </ItemGroup>
+  <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
+    <PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
+    <PackageReference Include="System.IO.Compression.ZipFile" Version="4.3.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="System.Management" Version="6.0.0-rc.1.21451.13" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'!='net48'">
-    <PackageReference Include="Aaru.Devices" Version="5.3.0-rc2" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="System.Management" />
+    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.8" GeneratePathProperty="true">
+      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="LibIRD" Version="0.9.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="psxt001z.Library" Version="0.21.0-rc1" />
+    <PackageReference Include="SabreTools.Hashing" Version="1.2.0" />
+    <PackageReference Include="SabreTools.Models" Version="1.4.5" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.6" />
+    <PackageReference Include="SabreTools.Serialization" Version="1.6.0" />
   </ItemGroup>
 
 </Project>

MPF.Core/Modules/Aaru/Constants.cs

@@ -1,4 +1,4 @@
-namespace MPF.Modules.Aaru
+namespace MPF.Core.Modules.Aaru
 {
     /// <summary>
     /// Top-level commands for Aaru

MPF.Core/Modules/Aaru/Converters.cs

@@ -1,6 +1,6 @@
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF.Modules.Aaru
+namespace MPF.Core.Modules.Aaru
 {
     public static class Converters
     {

MPF.Core/Modules/CleanRip/Parameters.cs

@@ -0,0 +1,408 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using SabreTools.Hashing;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.CleanRip
+{
+    /// <summary>
+    /// Represents a generic set of CleanRip parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.CleanRip;
+
+        #endregion
+
+        /// <inheritdoc/>
+        public Parameters(string? parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            var missingFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (!File.Exists($"{basePath}_logs.zip") || !preCheck)
+                    {
+                        if (!File.Exists($"{basePath}-dumpinfo.txt"))
+                            missingFiles.Add($"{basePath}-dumpinfo.txt");
+                        if (!File.Exists($"{basePath}.bca"))
+                            missingFiles.Add($"{basePath}.bca");
+                    }
+
+                    break;
+
+                default:
+                    missingFiles.Add("Media and system combination not supported for CleanRip");
+                    break;
+            }
+
+            return (!missingFiles.Any(), missingFiles);
+        }
+
+        /// <inheritdoc/>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
+        {
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+
+            // TODO: Determine if there's a CleanRip version anywhere
+            info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(basePath + "-dumpinfo.txt")?.ToString("yyyy-MM-dd HH:mm:ss");
+
+            // Get the Datafile information
+            var datafile = GenerateCleanripDatafile(basePath + ".iso", basePath + "-dumpinfo.txt");
+
+            // ClrMameProData format is only for CDs
+            if (this.Type == MediaType.CDROM)
+                info.TracksAndWriteOffsets!.ClrMameProData = InfoTool.GenerateDatfile(datafile);
+
+            // Get the individual hash data, as per internal
+            if (InfoTool.GetISOHashValues(datafile, out long size, out var crc32, out var md5, out var sha1))
+            {
+                info.SizeAndChecksums!.Size = size;
+                info.SizeAndChecksums.CRC32 = crc32;
+                info.SizeAndChecksums.MD5 = md5;
+                info.SizeAndChecksums.SHA1 = sha1;
+
+                // Dual-layer discs have the same size and layerbreak
+                if (size == 8511160320)
+                    info.SizeAndChecksums.Layerbreak = 2084960;
+            }
+
+            // Extract info based generically on MediaType
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (File.Exists(basePath + ".bca"))
+                        info.Extras!.BCA = GetBCA(basePath + ".bca");
+
+                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out Region? gcRegion, out var gcVersion, out var gcName, out var gcSerial))
+                    {
+                        info.CommonDiscInfo!.Region = gcRegion ?? info.CommonDiscInfo.Region;
+                        info.VersionAndEditions!.Version = gcVersion ?? info.VersionAndEditions.Version;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalName] = gcName ?? string.Empty;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = gcSerial ?? string.Empty;
+                    }
+
+                    break;
+            }
+
+            // Fill in any artifacts that exist, Base64-encoded, if we need to
+            if (includeArtifacts)
+            {
+                info.Artifacts ??= [];
+
+                if (File.Exists(basePath + ".bca"))
+                    info.Artifacts["bca"] = GetBase64(GetFullFile(basePath + ".bca", binary: true)) ?? string.Empty;
+                if (File.Exists(basePath + "-dumpinfo.txt"))
+                    info.Artifacts["dumpinfo"] = GetBase64(GetFullFile(basePath + "-dumpinfo.txt")) ?? string.Empty;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetLogFilePaths(string basePath)
+        {
+            var logFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (File.Exists($"{basePath}-dumpinfo.txt"))
+                        logFiles.Add($"{basePath}-dumpinfo.txt");
+                    if (File.Exists($"{basePath}.bca"))
+                        logFiles.Add($"{basePath}.bca");
+
+                    break;
+            }
+
+            return logFiles;
+        }
+
+        #endregion
+
+        #region Information Extraction Methods
+
+        /// <summary>
+        /// Get a formatted datfile from the cleanrip output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <returns></returns>
+        private static Datafile? GenerateCleanripDatafile(string iso, string dumpinfo)
+        {
+            // If the files don't exist, we can't get info from it
+            if (!File.Exists(iso) || !File.Exists(dumpinfo))
+                return null;
+
+            long size = new FileInfo(iso).Length;
+            string crc = string.Empty;
+            string md5 = string.Empty;
+            string sha1 = string.Empty;
+
+            try
+            {
+                // Make sure this file is a dumpinfo
+                using var sr = File.OpenText(dumpinfo);
+                if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                    return null;
+
+                // Read all lines and gather dat information
+                while (!sr.EndOfStream)
+                {
+                    var line = sr.ReadLine()?.Trim();
+                    if (string.IsNullOrEmpty(line))
+                        continue;
+                    else if (line!.StartsWith("CRC32"))
+                        crc = line.Substring(7).ToLowerInvariant();
+                    else if (line.StartsWith("MD5"))
+                        md5 = line.Substring(5);
+                    else if (line.StartsWith("SHA-1"))
+                        sha1 = line.Substring(7);
+                }
+
+                // Ensure all checksums were found in log
+                if (crc == string.Empty || md5 == string.Empty || sha1 == string.Empty)
+                {
+                    if (HashTool.GetStandardHashes(iso, out long isoSize, out string? isoCRC, out string? isoMD5, out string? isoSHA1))
+                    {
+                        crc = isoCRC ?? crc;
+                        md5 = isoMD5 ?? md5;
+                        sha1 = isoSHA1 ?? sha1;
+                    }
+                }
+
+                return new Datafile
+                {
+                    Games =
+                    [
+                        new()
+                        {
+                            Roms =
+                            [
+                                new Rom { Name = Path.GetFileName(iso), Size = size.ToString(), Crc = crc, Md5 = md5, Sha1 = sha1 },
+                            ]
+                        }
+                    ]
+                };
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the hex contents of the BCA file
+        /// </summary>
+        /// <param name="bcaPath">Path to the BCA file associated with the dump</param>
+        /// <returns>BCA data as a hex string if possible, null on error</returns>
+        /// <remarks>https://stackoverflow.com/questions/9932096/add-separator-to-string-at-every-n-characters</remarks>
+        private static string? GetBCA(string bcaPath)
+        {
+            // If the file doesn't exist, we can't get the info
+            if (!File.Exists(bcaPath))
+                return null;
+
+            try
+            {
+                var hex = GetFullFile(bcaPath, true);
+                if (hex == null)
+                    return null;
+
+                return Regex.Replace(hex, ".{32}", "$0\n");
+            }
+            catch
+            {
+                // We don't care what the error was right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get a formatted datfile from the cleanrip output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <returns></returns>
+        private static string? GetCleanripDatfile(string iso, string dumpinfo)
+        {
+            // If the files don't exist, we can't get info from it
+            if (!File.Exists(iso) || !File.Exists(dumpinfo))
+                return null;
+
+            long size = new FileInfo(iso).Length;
+            string crc = string.Empty;
+            string md5 = string.Empty;
+            string sha1 = string.Empty;
+
+            try
+            {
+                // Make sure this file is a dumpinfo
+                using var sr = File.OpenText(dumpinfo);
+                if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                    return null;
+
+                // Read all lines and gather dat information
+                while (!sr.EndOfStream)
+                {
+                    var line = sr.ReadLine()?.Trim();
+                    if (string.IsNullOrEmpty(line))
+                        continue;
+                    else if (line!.StartsWith("CRC32"))
+                        crc = line.Substring(7).ToLowerInvariant();
+                    else if (line.StartsWith("MD5"))
+                        md5 = line.Substring(5);
+                    else if (line.StartsWith("SHA-1"))
+                        sha1 = line.Substring(7);
+                }
+
+                return $"<rom name=\"{Path.GetFileName(iso)}\" size=\"{size}\" crc=\"{crc}\" md5=\"{md5}\" sha1=\"{sha1}\" />";
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the extracted GC and Wii version
+        /// </summary>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <param name="region">Output region, if possible</param>
+        /// <param name="version">Output internal version of the game</param>
+        /// <param name="name">Output internal name of the game</param>
+        /// <param name="serial">Output internal serial of the game</param>
+        /// <returns></returns>
+        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string? version, out string? name, out string? serial)
+        {
+            region = null; version = null; name = null; serial = null;
+
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return false;
+
+            try
+            {
+                // Make sure this file is a dumpinfo
+                using var sr = File.OpenText(dumpinfo);
+                if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                    return false;
+
+                // Read all lines and gather dat information
+                while (!sr.EndOfStream)
+                {
+                    var line = sr.ReadLine()?.Trim();
+                    if (string.IsNullOrEmpty(line))
+                    {
+                        continue;
+                    }
+                    else if (line!.StartsWith("Version"))
+                    {
+                        version = line.Substring("Version: ".Length);
+                    }
+                    else if (line.StartsWith("Internal Name"))
+                    {
+                        name = line.Substring("Internal Name: ".Length);
+                    }
+                    else if (line.StartsWith("Filename"))
+                    {
+                        serial = line.Substring("Filename: ".Length);
+                        if (serial.EndsWith("-disc2"))
+                            serial = serial.Replace("-disc2", string.Empty);
+
+                        // char gameType = serial[0];
+                        // string gameid = serial[1] + serial[2];
+                        // string version = serial[4] + serial[5]
+
+                        switch (serial[3])
+                        {
+                            case 'A':
+                                region = Region.World;
+                                break;
+                            case 'D':
+                                region = Region.Germany;
+                                break;
+                            case 'E':
+                                region = Region.UnitedStatesOfAmerica;
+                                break;
+                            case 'F':
+                                region = Region.France;
+                                break;
+                            case 'I':
+                                region = Region.Italy;
+                                break;
+                            case 'J':
+                                region = Region.Japan;
+                                break;
+                            case 'K':
+                                region = Region.SouthKorea;
+                                break;
+                            case 'L':
+                                region = Region.Europe; // Japanese import to Europe
+                                break;
+                            case 'M':
+                                region = Region.Europe; // American import to Europe
+                                break;
+                            case 'N':
+                                region = Region.UnitedStatesOfAmerica; // Japanese import to USA
+                                break;
+                            case 'P':
+                                region = Region.Europe;
+                                break;
+                            case 'R':
+                                region = Region.RussianFederation;
+                                break;
+                            case 'S':
+                                region = Region.Spain;
+                                break;
+                            case 'Q':
+                                region = Region.SouthKorea; // Korea with Japanese language
+                                break;
+                            case 'T':
+                                region = Region.SouthKorea; // Korea with English language
+                                break;
+                            case 'X':
+                                region = null; // Not a real region code
+                                break;
+                        }
+                    }
+                }
+
+                return true;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Modules/Datafile.cs

@@ -0,0 +1,73 @@
+using System.Xml.Serialization;
+
+namespace MPF.Core.Modules
+{
+    [XmlRoot("datafile")]
+    public class Datafile
+    {
+        [XmlElement("header")]
+        public Header? Header;
+
+        [XmlElement("game")]
+        public Game[]? Games;
+    }
+
+    public class Header
+    {
+        [XmlElement("name")]
+        public string? Name;
+
+        [XmlElement("description")]
+        public string? Description;
+
+        [XmlElement("version")]
+        public string? Version;
+
+        [XmlElement("date")]
+        public string? Date;
+
+        [XmlElement("author")]
+        public string? Author;
+
+        [XmlElement("homepage")]
+        public string? Homepage;
+
+        [XmlElement("url")]
+        public string? Url;
+    }
+
+    public class Game
+    {
+        [XmlAttribute("name")]
+        public string? Name;
+
+        [XmlElement("category")]
+        public string? Category;
+
+        [XmlElement("description")]
+        public string? Description;
+
+        [XmlElement("rom")]
+        public Rom[]? Roms;
+    }
+
+    public class Rom
+    {
+        [XmlAttribute("name")]
+        public string? Name;
+
+        [XmlAttribute("size")]
+        public string? Size;
+
+        [XmlAttribute("crc")]
+        public string? Crc;
+
+        [XmlAttribute("md5")]
+        public string? Md5;
+
+        [XmlAttribute("sha1")]
+        public string? Sha1;
+
+        // TODO: Add extended hashes here
+    }
+}

MPF.Core/Modules/DiscImageCreator/Constants.cs

@@ -1,4 +1,4 @@
-namespace MPF.Modules.DiscImageCreator
+namespace MPF.Core.Modules.DiscImageCreator
 {
     /// <summary>
     /// Top-level commands for DiscImageCreator
@@ -26,6 +26,7 @@ namespace MPF.Modules.DiscImageCreator
         public const string Sub = "sub";
         public const string Swap = "swap";
         public const string Tape = "tape";
+        public const string Version = "/v";
         public const string XBOX = "xbox";
         public const string XBOXSwap = "xboxswap";
         public const string XGD2Swap = "xgd2swap";
@@ -44,12 +45,13 @@ namespace MPF.Modules.DiscImageCreator
         public const string C2Opcode = "/c2";
         public const string CopyrightManagementInformation = "/c";
         public const string D8Opcode = "/d8";
+        public const string DatExpand = "/d";
         public const string DisableBeep = "/q";
+        public const string DVDReread = "/rr";
         public const string ExtractMicroSoftCabFile = "/mscf";
         public const string Fix = "/fix";
         public const string ForceUnitAccess = "/f";
         public const string MultiSectorRead = "/mr";
-        public const string MultiSession = "/ms";
         public const string NoFixSubP = "/np";
         public const string NoFixSubQ = "/nq";
         public const string NoFixSubQLibCrypt = "/nl";
@@ -57,6 +59,7 @@ namespace MPF.Modules.DiscImageCreator
         public const string NoFixSubQSecuROM = "/ns";
         public const string NoSkipSS = "/nss";
         public const string PadSector = "/ps";
+        public const string Range = "/ra";
         public const string Raw = "/raw";
         public const string Resume = "/re";
         public const string Reverse = "/r";

MPF.Core/Modules/DiscImageCreator/Converters.cs

@@ -0,0 +1,100 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.DiscImageCreator
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the most common known system for a given MediaType
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>RedumpSystem if possible, null on error</returns>
+        public static RedumpSystem? ToRedumpSystem(string baseCommand)
+        {
+            return baseCommand switch
+            {
+                CommandStrings.Audio => (RedumpSystem?)RedumpSystem.AudioCD,
+                CommandStrings.CompactDisc
+                    or CommandStrings.Data
+                    or CommandStrings.DigitalVideoDisc
+                    or CommandStrings.Disk
+                    or CommandStrings.Floppy
+                    or CommandStrings.Tape => (RedumpSystem?)RedumpSystem.IBMPCcompatible,
+                CommandStrings.GDROM
+                    or CommandStrings.Swap => (RedumpSystem?)RedumpSystem.SegaDreamcast,
+                CommandStrings.BluRay => (RedumpSystem?)RedumpSystem.SonyPlayStation3,
+                CommandStrings.SACD => (RedumpSystem?)RedumpSystem.SuperAudioCD,
+                CommandStrings.XBOX
+                    or CommandStrings.XBOXSwap => (RedumpSystem?)RedumpSystem.MicrosoftXbox,
+                CommandStrings.XGD2Swap
+                    or CommandStrings.XGD3Swap => (RedumpSystem?)RedumpSystem.MicrosoftXbox360,
+                _ => null,
+            };
+        }
+
+        /// <summary>
+        /// Get the MediaType associated with a given base command
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>MediaType if possible, null on error</returns>
+        /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
+        public static MediaType? ToMediaType(string? baseCommand)
+        {
+            return baseCommand switch
+            {
+                CommandStrings.Audio
+                    or CommandStrings.CompactDisc
+                    or CommandStrings.Data
+                    or CommandStrings.SACD => (MediaType?)MediaType.CDROM,
+                CommandStrings.GDROM
+                    or CommandStrings.Swap => (MediaType?)MediaType.GDROM,
+                CommandStrings.DigitalVideoDisc
+                    or CommandStrings.XBOX
+                    or CommandStrings.XBOXSwap
+                    or CommandStrings.XGD2Swap
+                    or CommandStrings.XGD3Swap => (MediaType?)MediaType.DVD,
+                CommandStrings.BluRay => (MediaType?)MediaType.BluRay,
+
+                // Non-optical
+                CommandStrings.Floppy => (MediaType?)MediaType.FloppyDisk,
+                CommandStrings.Disk => (MediaType?)MediaType.HardDisk,
+                CommandStrings.Tape => (MediaType?)MediaType.DataCartridge,
+                _ => null,
+            };
+        }
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string? Extension(MediaType? type)
+        {
+            return type switch
+            {
+                MediaType.CDROM
+                    or MediaType.GDROM
+                    or MediaType.Cartridge
+                    or MediaType.HardDisk
+                    or MediaType.CompactFlash
+                    or MediaType.MMC
+                    or MediaType.SDCard
+                    or MediaType.FlashDrive => ".bin",
+                MediaType.DVD
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoWiiOpticalDisc => ".iso",
+                MediaType.LaserDisc
+                    or MediaType.NintendoGameCubeGameDisc => ".raw",
+                MediaType.NintendoWiiUOpticalDisc => ".wud",
+                MediaType.FloppyDisk => ".img",
+                MediaType.Cassette => ".wav",
+                _ => null,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.Core/Modules/PS3CFW/Parameters.cs

@@ -0,0 +1,293 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using SabreTools.Hashing;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.PS3CFW
+{
+    /// <summary>
+    /// Represents a generic set of PlayStation 3 Custom Firmware parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.PS3CFW;
+
+        #endregion
+
+        /// <inheritdoc/>
+        public Parameters(string? parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            var missingFiles = new List<string>();
+            
+            if (this.Type != MediaType.BluRay || this.System != RedumpSystem.SonyPlayStation3)
+            {
+                missingFiles.Add("Media and system combination not supported for PS3 CFW");
+            }
+            else
+            {
+                string? getKeyBasePath = GetCFWBasePath(basePath);
+                if (!File.Exists($"{getKeyBasePath}.getkey.log"))
+                    missingFiles.Add($"{getKeyBasePath}.getkey.log");
+                if (!File.Exists($"{getKeyBasePath}.disc.pic"))
+                    missingFiles.Add($"{getKeyBasePath}.disc.pic");
+            }
+
+            return (missingFiles.Count == 0, missingFiles);
+        }
+
+        /// <inheritdoc/>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
+        {
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+
+            info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+
+            // Get the Datafile information
+            Datafile? datafile = GeneratePS3CFWDatafile(basePath + ".iso");
+
+            // Fill in the hash data
+            info.TracksAndWriteOffsets!.ClrMameProData = InfoTool.GenerateDatfile(datafile);
+
+            // Get the individual hash data, as per internal
+            if (InfoTool.GetISOHashValues(datafile, out long size, out var crc32, out var md5, out var sha1))
+            {
+                info.SizeAndChecksums!.Size = size;
+                info.SizeAndChecksums.CRC32 = crc32;
+                info.SizeAndChecksums.MD5 = md5;
+                info.SizeAndChecksums.SHA1 = sha1;
+            }
+
+            // Get the PVD from the ISO
+            if (GetPVD(basePath + ".iso", out string? pvd))
+                info.Extras!.PVD = pvd;
+
+            // Try get the serial, version, and firmware version if a drive is provided
+            if (drive != null)
+            {
+                info.VersionAndEditions!.Version = InfoTool.GetPlayStation3Version(drive?.Name) ?? string.Empty;
+                info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation3Serial(drive?.Name) ?? string.Empty;
+                string? firmwareVersion = InfoTool.GetPlayStation3FirmwareVersion(drive?.Name);
+                if (firmwareVersion != null)
+                    info.CommonDiscInfo!.ContentsSpecialFields![SiteCode.Patches] = $"PS3 Firmware {firmwareVersion}";
+            }
+
+            // Try to determine the name of the GetKey file(s)
+            string? getKeyBasePath = GetCFWBasePath(basePath);
+
+            // If GenerateSubmissionInfo is run, .getkey.log existence should already be checked
+            if (!File.Exists(getKeyBasePath + ".getkey.log"))
+                return;
+
+            // Get dumping date from GetKey log date
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(getKeyBasePath + ".getkey.log")?.ToString("yyyy-MM-dd HH:mm:ss");
+
+            // TODO: Put info about abnormal PIC info beyond 132 bytes in comments?
+            if (File.Exists(getKeyBasePath + ".disc.pic"))
+                info.Extras!.PIC = GetPIC(getKeyBasePath + ".disc.pic", 264);
+
+            // Parse Disc Key, Disc ID, and PIC from the .getkey.log file
+            if (Utilities.Tools.ParseGetKeyLog(getKeyBasePath + ".getkey.log", out string? key, out string? id, out string? pic))
+            {
+                if (key != null)
+                    info.Extras!.DiscKey = key.ToUpperInvariant();
+                if (id != null)
+                    info.Extras!.DiscID = id.ToUpperInvariant().Substring(0, 24) + "XXXXXXXX";
+                if (string.IsNullOrEmpty(info.Extras!.PIC) && !string.IsNullOrEmpty(pic))
+                {
+                    pic = Regex.Replace(pic, ".{32}", "$0\n");
+                    info.Extras.PIC = pic;
+                }
+            }
+
+            // Fill in any artifacts that exist, Base64-encoded, if we need to
+            if (includeArtifacts)
+            {
+                info.Artifacts ??= [];
+
+                if (File.Exists(getKeyBasePath + ".disc.pic"))
+                    info.Artifacts["discpic"] = GetBase64(GetFullFile(getKeyBasePath + ".disc.pic", binary: true)) ?? string.Empty;
+                if (File.Exists(getKeyBasePath + ".getkey.log"))
+                    info.Artifacts["getkeylog"] = GetBase64(GetFullFile(getKeyBasePath + ".getkey.log")) ?? string.Empty;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetLogFilePaths(string basePath)
+        {
+            var logFiles = new List<string>();
+            string? getKeyBasePath = GetCFWBasePath(basePath);
+
+            if (this.System != RedumpSystem.SonyPlayStation3)
+                return logFiles;
+
+            switch (this.Type)
+            {
+                case MediaType.BluRay:
+                    if (File.Exists($"{getKeyBasePath}.getkey.log"))
+                        logFiles.Add($"{getKeyBasePath}.getkey.log");
+                    if (File.Exists($"{getKeyBasePath}.disc.pic"))
+                        logFiles.Add($"{getKeyBasePath}.disc.pic");
+
+                    break;
+            }
+
+            return logFiles;
+        }
+
+        #endregion
+
+        #region Information Extraction Methods
+
+        /// <summary>
+        /// Get a formatted datfile from the PS3 CFW output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <returns></returns>
+        private static Datafile? GeneratePS3CFWDatafile(string iso)
+        {
+            // If the ISO file doesn't exist, we can't get info from it
+            if (!File.Exists(iso))
+                return null;
+
+            try
+            {
+                if (HashTool.GetStandardHashes(iso, out long size, out string? crc, out string? md5, out string? sha1))
+                {
+                    return new Datafile
+                    {
+                        Games = [new Game { Roms = [new Rom { Name = Path.GetFileName(iso), Size = size.ToString(), Crc = crc, Md5 = md5, Sha1 = sha1, }] }]
+                    };
+                }
+                return null;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        // TODO: Don't hardcode 0x8320 and move this function to BaseParameters
+        /// <summary>
+        /// Get a isobuster-formatted PVD from a PS3 ISO, if possible
+        /// </summary>
+        /// <param name="isoPath">Path to ISO file</param>
+        /// <param name="pvd">Formatted PVD string, otherwise null</param>
+        /// <returns>True if PVD was successfully parsed, otherwise false</returns>
+        private static bool GetPVD(string isoPath, out string? pvd)
+        {
+            pvd = null;
+            try
+            {
+                // Get PVD bytes from ISO file
+                var buf = new byte[96];
+                using (FileStream iso = File.OpenRead(isoPath))
+                {
+                    iso.Seek(0x8320, SeekOrigin.Begin);
+
+                    int offset = 0;
+                    while (offset < 96)
+                    {
+                        int read = iso.Read(buf, offset, buf.Length - offset);
+                        if (read == 0)
+                            throw new EndOfStreamException();
+                        offset += read;
+                    }
+                }
+
+                // Format PVD to isobuster standard
+                char[] pvdCharArray = new char[96];
+                for (int i = 0; i < 96; i++)
+                {
+                    if (buf[i] >= 0x20 && buf[i] <= 0x7E)
+                        pvdCharArray[i] = (char)buf[i];
+                    else
+                        pvdCharArray[i] = '.';
+                }
+                string pvdASCII = new string(pvdCharArray, 0, 96);
+                pvd = string.Empty;
+                for (int i = 0; i < 96; i += 16)
+                {
+                    pvd += $"{(0x0320+i):X4} : {buf[i]:X2} {buf[i+1]:X2} {buf[i+2]:X2} {buf[i+3]:X2} {buf[i+4]:X2} {buf[i+5]:X2} {buf[i+6]:X2} {buf[i+7]:X2}  " +
+                        $"{buf[i+8]:X2} {buf[i+9]:X2} {buf[i+10]:X2} {buf[i+11]:X2} {buf[i+12]:X2} {buf[i+13]:X2} {buf[i+14]:X2} {buf[i+15]:X2}   {pvdASCII.Substring(i, 16)}\n";
+                }
+
+                return true;
+            }
+            catch
+            {
+                // We don't care what the error is
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get a formatted datfile from the PS3 CFW output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <returns>Formatted datfile, null if not valid</returns>
+        private static string? GetPS3CFWDatfile(string iso)
+        {
+            // If the files don't exist, we can't get info from it
+            if (!File.Exists(iso))
+                return null;
+
+            try
+            {
+                if (HashTool.GetStandardHashes(iso, out long size, out string? crc, out string? md5, out string? sha1))
+                    return $"<rom name=\"{Path.GetFileName(iso)}\" size=\"{size}\" crc=\"{crc}\" md5=\"{md5}\" sha1=\"{sha1}\" />";
+                return null;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        #endregion
+
+        #region Helper Functions
+
+        /// <summary>
+        /// Estimate the base filename of the .getkey.log file associated with the dump
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <returns>Base filename, null if not found</returns>
+        private string? GetCFWBasePath(string iso)
+        {
+            string? dir = Path.GetDirectoryName(iso);
+            dir ??= ".";
+
+            string[] files = Directory.GetFiles(dir, "*.getkey.log");
+
+            if (files.Length != 1)
+                return null;
+
+            return files[0].Substring(0, files[0].Length - 11);
+        }
+
+        #endregion
+    }
+}

MPF.Core/Modules/Redumper/Constants.cs

@@ -0,0 +1,83 @@
+namespace MPF.Core.Modules.Redumper
+{
+    /// <summary>
+    /// Top-level commands for Redumper
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+        public const string CD = "cd";
+        public const string DVD = "dvd"; // Synonym for CD
+        public const string BluRay = "bd"; // Synonym for CD
+        public const string SACD = "sacd"; // Synonym for CD
+        public const string Rings = "rings";
+        public const string Dump = "dump";
+        public const string DumpNew = "dumpnew"; // Temporary command, to be removed later
+        public const string Refine = "refine";
+        public const string RefineNew = "refinenew"; // Temporary command, to be removed later
+        public const string Verify = "verify";
+        public const string DVDKey = "dvdkey";
+        public const string DVDIsoKey = "dvdisokey";
+        public const string Protection = "protection";
+        public const string Split = "split";
+        public const string Hash = "hash";
+        public const string Info = "info";
+        public const string Skeleton = "skeleton";
+    }
+
+    /// <summary>
+    /// Dumping flags for Redumper
+    /// </summary>
+    public static class FlagStrings
+    {
+        // General
+        public const string HelpLong = "--help";
+        public const string HelpShort = "-h";
+        public const string Version = "--version";
+        public const string Verbose = "--verbose";
+        public const string Debug = "--debug";
+        public const string Drive = "--drive";
+        public const string Speed = "--speed";
+        public const string Retries = "--retries";
+        public const string ImagePath = "--image-path";
+        public const string ImageName = "--image-name";
+        public const string Overwrite = "--overwrite";
+
+        // Drive Configuration
+        public const string DriveType = "--drive-type";
+        public const string DriveReadOffset = "--drive-read-offset";
+        public const string DriveC2Shift = "--drive-c2-shift";
+        public const string DrivePregapStart = "--drive-pregap-start";
+        public const string DriveReadMethod = "--drive-read-method";
+        public const string DriveSectorOrder = "--drive-sector-order";
+
+        // Drive Specific
+        public const string PlextorSkipLeadin = "--plextor-skip-leadin";
+        public const string PlextorLeadinRetries = "--plextor-leadin-retries";
+        public const string AsusSkipLeadout = "--asus-skip-leadout";
+
+        // Offset
+        public const string ForceOffset = "--force-offset";
+        public const string AudioSilenceThreshold = "--audio-silence-threshold";
+        public const string CorrectOffsetShift = "--correct-offset-shift";
+        public const string OffsetShiftRelocate = "--offset-shift-relocate";
+
+        // Split
+        public const string ForceSplit = "--force-split";
+        public const string LeaveUnchanged = "--leave-unchanged";
+        public const string ForceQTOC = "--force-qtoc";
+        public const string SkipFill = "--skip-fill";
+        public const string ISO9660Trim = "--iso9660-trim";
+
+        // Miscellaneous
+        public const string LBAStart = "--lba-start";
+        public const string LBAEnd = "--lba-end";
+        public const string RefineSubchannel = "--refine-subchannel";
+        public const string Skip = "--skip";
+        public const string DumpWriteOffset = "--dump-write-offset";
+        public const string DumpReadSize = "--dump-read-size";
+        public const string OverreadLeadout = "--overread-leadout";
+        public const string LegacySubs = "--legacy-subs";
+        public const string DisableCDText = "--disable-cdtext";
+    }
+}

MPF.Core/Modules/Redumper/Converters.cs

@@ -1,6 +1,6 @@
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF.Modules.DD
+namespace MPF.Core.Modules.Redumper
 {
     public static class Converters
     {
@@ -11,10 +11,16 @@ namespace MPF.Modules.DD
         /// </summary>
         /// <param name="type">MediaType value to check</param>
         /// <returns>Valid extension (with leading '.'), null on error</returns>
-        public static string Extension(MediaType? type)
+        public static string? Extension(MediaType? type)
         {
-            // DD has a single, unified output format by default
-            return ".bin";
+            return type switch
+            {
+                MediaType.CDROM => ".bin",
+                MediaType.DVD
+                    or MediaType.HDDVD
+                    or MediaType.BluRay => ".iso",
+                _ => null,
+            };
         }
 
         #endregion

MPF.Core/Modules/UmdImageCreator/Parameters.cs

@@ -2,10 +2,13 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using MPF.Core.Converters;
 using MPF.Core.Data;
-using RedumpLib.Data;
+using SabreTools.Hashing;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF.Modules.UmdImageCreator
+namespace MPF.Core.Modules.UmdImageCreator
 {
     /// <summary>
     /// Represents a generic set of UmdImageCreator parameters
@@ -20,11 +23,11 @@ namespace MPF.Modules.UmdImageCreator
         #endregion
 
         /// <inheritdoc/>
-        public Parameters(string parameters) : base(parameters) { }
+        public Parameters(string? parameters) : base(parameters) { }
 
         /// <inheritdoc/>
-        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
-            : base(system, type, driveLetter, filename, driveSpeed, options)
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
         {
         }
 
@@ -33,7 +36,7 @@ namespace MPF.Modules.UmdImageCreator
         /// <inheritdoc/>
         public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
         {
-            List<string> missingFiles = new List<string>();
+            var missingFiles = new List<string>();
             switch (this.Type)
             {
                 case MediaType.UMD:
@@ -60,30 +63,46 @@ namespace MPF.Modules.UmdImageCreator
         }
 
         /// <inheritdoc/>
-        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, Drive drive, bool includeArtifacts)
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
         {
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+
+            // TODO: Determine if there's a UMDImageCreator version anywhere
+            info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(basePath + "_disc.txt")?.ToString("yyyy-MM-dd HH:mm:ss");
+
             // Extract info based generically on MediaType
             switch (this.Type)
             {
                 case MediaType.UMD:
-                    info.Extras.PVD = GetPVD(basePath + "_mainInfo.txt") ?? "";
+                    info.Extras!.PVD = GetPVD(basePath + "_mainInfo.txt") ?? string.Empty;
 
-                    if (GetFileHashes(basePath + ".iso", out long filesize, out string crc32, out string md5, out string sha1))
+                    if (HashTool.GetStandardHashes(basePath + ".iso", out long filesize, out var crc32, out var md5, out var sha1))
                     {
-                        info.SizeAndChecksums.Size = filesize;
+                        // Get the Datafile information
+                        var datafile = new Datafile
+                        {
+                            Games = [new Game { Roms = [new Rom { Name = string.Empty, Size = filesize.ToString(), Crc = crc32, Md5 = md5, Sha1 = sha1, }] }]
+                        };
+
+                        // Fill in the hash data
+                        info.TracksAndWriteOffsets!.ClrMameProData = InfoTool.GenerateDatfile(datafile);
+
+                        info.SizeAndChecksums!.Size = filesize;
                         info.SizeAndChecksums.CRC32 = crc32;
                         info.SizeAndChecksums.MD5 = md5;
                         info.SizeAndChecksums.SHA1 = sha1;
                     }
 
-                    if (GetUMDAuxInfo(basePath + "_disc.txt", out string title, out DiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize))
+                    if (GetUMDAuxInfo(basePath + "_disc.txt", out var title, out DiscCategory? umdcat, out var umdversion, out var umdlayer, out long umdsize))
                     {
-                        info.CommonDiscInfo.Title = title ?? "";
+                        info.CommonDiscInfo!.Title = title ?? string.Empty;
                         info.CommonDiscInfo.Category = umdcat ?? DiscCategory.Games;
-                        info.VersionAndEditions.Version = umdversion ?? "";
-                        info.SizeAndChecksums.Size = umdsize;
+                        info.VersionAndEditions!.Version = umdversion ?? string.Empty;
+                        info.SizeAndChecksums!.Size = umdsize;
 
-                        if (!string.IsNullOrWhiteSpace(umdlayer))
+                        if (!string.IsNullOrEmpty(umdlayer))
                             info.SizeAndChecksums.Layerbreak = Int64.Parse(umdlayer ?? "-1");
                     }
 
@@ -93,26 +112,32 @@ namespace MPF.Modules.UmdImageCreator
             // Fill in any artifacts that exist, Base64-encoded, if we need to
             if (includeArtifacts)
             {
+                info.Artifacts ??= [];
+
                 if (File.Exists(basePath + "_disc.txt"))
-                    info.Artifacts["disc"] = GetBase64(GetFullFile(basePath + "_disc.txt"));
+                    info.Artifacts["disc"] = GetBase64(GetFullFile(basePath + "_disc.txt")) ?? string.Empty;
+                if (File.Exists(basePath + "_drive.txt"))
+                    info.Artifacts["drive"] = GetBase64(GetFullFile(basePath + "_drive.txt")) ?? string.Empty;
                 if (File.Exists(basePath + "_mainError.txt"))
-                    info.Artifacts["mainError"] = GetBase64(GetFullFile(basePath + "_mainError.txt"));
+                    info.Artifacts["mainError"] = GetBase64(GetFullFile(basePath + "_mainError.txt")) ?? string.Empty;
                 if (File.Exists(basePath + "_mainInfo.txt"))
-                    info.Artifacts["mainInfo"] = GetBase64(GetFullFile(basePath + "_mainInfo.txt"));
+                    info.Artifacts["mainInfo"] = GetBase64(GetFullFile(basePath + "_mainInfo.txt")) ?? string.Empty;
                 if (File.Exists(basePath + "_volDesc.txt"))
-                    info.Artifacts["volDesc"] = GetBase64(GetFullFile(basePath + "_volDesc.txt"));
+                    info.Artifacts["volDesc"] = GetBase64(GetFullFile(basePath + "_volDesc.txt")) ?? string.Empty;
             }
         }
 
         /// <inheritdoc/>
         public override List<string> GetLogFilePaths(string basePath)
         {
-            List<string> logFiles = new List<string>();
+            var logFiles = new List<string>();
             switch (this.Type)
             {
                 case MediaType.UMD:
                     if (File.Exists($"{basePath}_disc.txt"))
                         logFiles.Add($"{basePath}_disc.txt");
+                    if (File.Exists($"{basePath}_drive.txt"))
+                        logFiles.Add($"{basePath}_drive.txt");
                     if (File.Exists($"{basePath}_mainError.txt"))
                         logFiles.Add($"{basePath}_mainError.txt");
                     if (File.Exists($"{basePath}_mainInfo.txt"))
@@ -135,34 +160,32 @@ namespace MPF.Modules.UmdImageCreator
         /// </summary>
         /// <param name="mainInfo">_mainInfo.txt file location</param>
         /// <returns>Newline-deliminated PVD if possible, null on error</returns>
-        private static string GetPVD(string mainInfo)
+        private static string? GetPVD(string mainInfo)
         {
             // If the file doesn't exist, we can't get info from it
             if (!File.Exists(mainInfo))
                 return null;
 
-            using (StreamReader sr = File.OpenText(mainInfo))
+            try
             {
-                try
-                {
-                    // Make sure we're in the right sector
-                    while (!sr.ReadLine().StartsWith("========== LBA[000016, 0x0000010]: Main Channel ==========")) ;
+                // Make sure we're in the right sector
+                using var sr = File.OpenText(mainInfo);
+                while (sr.ReadLine()?.StartsWith("========== LBA[000016, 0x0000010]: Main Channel ==========") == false) ;
 
-                    // Fast forward to the PVD
-                    while (!sr.ReadLine().StartsWith("0310")) ;
+                // Fast forward to the PVD
+                while (sr.ReadLine()?.StartsWith("0310") == false) ;
 
-                    // Now that we're at the PVD, read each line in and concatenate
-                    string pvd = "";
-                    for (int i = 0; i < 6; i++)
-                        pvd += sr.ReadLine() + "\n"; // 320-370
+                // Now that we're at the PVD, read each line in and concatenate
+                string pvd = "";
+                for (int i = 0; i < 6; i++)
+                    pvd += sr.ReadLine() + "\n"; // 320-370
 
-                    return pvd;
-                }
-                catch
-                {
-                    // We don't care what the exception is right now
-                    return null;
-                }
+                return pvd;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
             }
         }
 
@@ -171,7 +194,7 @@ namespace MPF.Modules.UmdImageCreator
         /// </summary>
         /// <param name="disc">_disc.txt file location</param>
         /// <returns>True on successful extraction of info, false otherwise</returns>
-        private static bool GetUMDAuxInfo(string disc, out string title, out DiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize)
+        private static bool GetUMDAuxInfo(string disc, out string? title, out DiscCategory? umdcat, out string? umdversion, out string? umdlayer, out long umdsize)
         {
             title = null; umdcat = null; umdversion = null; umdlayer = null; umdsize = -1;
 
@@ -179,39 +202,38 @@ namespace MPF.Modules.UmdImageCreator
             if (!File.Exists(disc))
                 return false;
 
-            using (StreamReader sr = File.OpenText(disc))
+            try
             {
-                try
+                // Loop through everything to get the first instance of each required field
+                using var sr = File.OpenText(disc);
+                while (!sr.EndOfStream)
                 {
-                    // Loop through everything to get the first instance of each required field
-                    string line = string.Empty;
-                    while (!sr.EndOfStream)
-                    {
-                        line = sr.ReadLine().Trim();
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line == null)
+                        break;
 
-                        if (line.StartsWith("TITLE") && title == null)
-                            title = line.Substring("TITLE: ".Length);
-                        else if (line.StartsWith("DISC_VERSION") && umdversion == null)
-                            umdversion = line.Split(' ')[1];
-                        else if (line.StartsWith("pspUmdTypes"))
-                            umdcat = GetUMDCategory(line.Split(' ')[1]);
-                        else if (line.StartsWith("L0 length"))
-                            umdlayer = line.Split(' ')[2];
-                        else if (line.StartsWith("FileSize:"))
-                            umdsize = Int64.Parse(line.Split(' ')[1]);
-                    }
-
-                    // If the L0 length is the size of the full disc, there's no layerbreak
-                    if (Int64.Parse(umdlayer) * 2048 == umdsize)
-                        umdlayer = null;
-
-                    return true;
-                }
-                catch
-                {
-                    // We don't care what the exception is right now
-                    return false;
+                    if (line.StartsWith("TITLE") && title == null)
+                        title = line.Substring("TITLE: ".Length);
+                    else if (line.StartsWith("DISC_VERSION") && umdversion == null)
+                        umdversion = line.Split(' ')[1];
+                    else if (line.StartsWith("pspUmdTypes"))
+                        umdcat = InfoTool.GetUMDCategory(line.Split(' ')[1]);
+                    else if (line.StartsWith("L0 length"))
+                        umdlayer = line.Split(' ')[2];
+                    else if (line.StartsWith("FileSize:"))
+                        umdsize = Int64.Parse(line.Split(' ')[1]);
                 }
+
+                // If the L0 length is the size of the full disc, there's no layerbreak
+                if (Int64.TryParse(umdlayer, out long umdlayerValue) && umdlayerValue * 2048 == umdsize)
+                    umdlayer = null;
+
+                return true;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
             }
         }
 

MPF.Core/Protection.cs

@@ -4,77 +4,132 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
-using BurnOutSharp;
-using BurnOutSharp.External.psxt001z;
-using BurnOutSharp.ProtectionType;
-using MPF.Core.Data;
+using psxt001z;
 
-namespace MPF.Library
+#pragma warning disable SYSLIB1045 // Convert to 'GeneratedRegexAttribute'.
+
+namespace MPF.Core
 {
     public static class Protection
     {
         /// <summary>
-        /// Run protection scan on a given dump environment
+        /// Run protection scan on a given path
         /// </summary>
         /// <param name="path">Path to scan for protection</param>
         /// <param name="options">Options object that determines what to scan</param>
         /// <param name="progress">Optional progress callback</param>
-        /// <returns>TCopy protection detected in the envirionment, if any</returns>
-        public static async Task<(bool, string)> RunProtectionScanOnPath(string path, Options options, IProgress<ProtectionProgress> progress = null)
+        /// <returns>Set of all detected copy protections with an optional error string</returns>
+        public static async Task<(Dictionary<string, List<string>>?, string?)> RunProtectionScanOnPath(string path, Data.Options options, IProgress<BinaryObjectScanner.ProtectionProgress>? progress = null)
         {
             try
             {
-                var found = await Task.Run(() =>
+#if NET40
+                var found = await Task.Factory.StartNew(() =>
                 {
-                    var scanner = new Scanner(progress)
-                    {
-                        IncludeDebug = options.IncludeDebugProtectionInformation,
-                        ScanAllFiles = options.ForceScanningForProtection,
-                        ScanArchives = options.ScanArchivesForProtection,
-                        ScanPackers = options.ScanPackersForProtection,
-                    };
+                    var scanner = new BinaryObjectScanner.Scanner(
+                        options.ScanArchivesForProtection,
+                        scanContents: true, // Hardcoded value to avoid issues
+                        scanGameEngines: false, // Hardcoded value to avoid issues
+                        options.ScanPackersForProtection,
+                        scanPaths: true, // Hardcoded value to avoid issues
+                        options.IncludeDebugProtectionInformation,
+                        progress);
+
                     return scanner.GetProtections(path);
                 });
+#else
+                var found = await Task.Run(() =>
+                {
+                    var scanner = new BinaryObjectScanner.Scanner(
+                        options.ScanArchivesForProtection,
+                        scanContents: true, // Hardcoded value to avoid issues
+                        scanGameEngines: false, // Hardcoded value to avoid issues
+                        options.ScanPackersForProtection,
+                        scanPaths: true, // Hardcoded value to avoid issues
+                        options.IncludeDebugProtectionInformation,
+                        progress);
 
-                if (found == null || found.Count() == 0)
-                    return (true, "None found");
+                    return scanner.GetProtections(path);
+                });
+#endif
 
-                // Get an ordered list of distinct found protections
-                var orderedDistinctProtections = found
-                    .Where(kvp => kvp.Value != null && kvp.Value.Any())
-                    .SelectMany(kvp => kvp.Value)
-                    .Distinct()
-                    .OrderBy(p => p);
+                // If nothing was returned, return
+#if NET20 || NET35
+                if (found == null || found.Count == 0)
+#else
+                if (found == null || found.IsEmpty)
+#endif
+                    return (null, null);
 
-                // Sanitize and join protections for writing
-                string protections = SanitizeFoundProtections(orderedDistinctProtections);
-                return (true, protections);
+                // Filter out any empty protections
+                var filteredProtections = found
+#if NET20 || NET35
+                    .Where(kvp => kvp.Value != null && kvp.Value.Count > 0)
+#else
+                    .Where(kvp => kvp.Value != null && !kvp.Value.IsEmpty)
+#endif
+                    .ToDictionary(
+                        kvp => kvp.Key,
+                        kvp => kvp.Value.OrderBy(s => s).ToList());
+
+                // Return the filtered set of protections
+                return (filteredProtections, null);
             }
             catch (Exception ex)
             {
-                return (false, ex.ToString());
+                return (null, ex.ToString());
             }
         }
 
+        /// <summary>
+        /// Format found protections to a deduplicated, ordered string
+        /// </summary>
+        /// <param name="protections">Dictionary of file to list of protection mappings</param>
+        /// <returns>Detected protections, if any</returns>
+        public static string? FormatProtections(Dictionary<string, List<string>>? protections)
+        {
+            // If the filtered list is empty in some way, return
+            if (protections == null || !protections.Any())
+                return "None found [OMIT FROM SUBMISSION]";
+
+            // Get an ordered list of distinct found protections
+            var orderedDistinctProtections = protections
+                .SelectMany(kvp => kvp.Value)
+                .Distinct()
+                .OrderBy(p => p);
+
+            // Sanitize and join protections for writing
+            string protectionString = SanitizeFoundProtections(orderedDistinctProtections);
+            if (string.IsNullOrEmpty(protectionString))
+                return "None found [OMIT FROM SUBMISSION]";
+
+            return protectionString;
+        }
+
         /// <summary>
         /// Get the existence of an anti-modchip string from a PlayStation disc, if possible
         /// </summary>
         /// <param name="path">Path to scan for anti-modchip strings</param>
         /// <returns>Anti-modchip existence if possible, false on error</returns>
-        public static async Task<bool> GetPlayStationAntiModchipDetected(string path)
+        public static async Task<bool> GetPlayStationAntiModchipDetected(string? path)
         {
-            return await Task.Run(() =>
+            // If there is no valid path
+            if (string.IsNullOrEmpty(path))
+                return false;
+
+#if NET40
+            return await Task.Factory.StartNew(() =>
             {
                 try
                 {
-                    var antiModchip = new PSXAntiModchip();
+                    var antiModchip = new BinaryObjectScanner.Protection.PSXAntiModchip();
                     foreach (string file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories))
                     {
                         try
                         {
                             byte[] fileContent = File.ReadAllBytes(file);
-                            string protection = antiModchip.CheckContents(file, fileContent, false, null, null);
-                            if (!string.IsNullOrWhiteSpace(protection))
+                            var protection = antiModchip.CheckContents(file, fileContent, false);
+                            if (!string.IsNullOrEmpty(protection))
                                 return true;
                         }
                         catch { }
@@ -84,6 +139,33 @@ namespace MPF.Library
 
                 return false;
             });
+#else
+            return await Task.Run(() =>
+            {
+                try
+                {
+                    var antiModchip = new BinaryObjectScanner.Protection.PSXAntiModchip();
+#if NET20 || NET35
+                    foreach (string file in Directory.GetFiles(path, "*", SearchOption.AllDirectories))
+#else
+                    foreach (string file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories))
+#endif
+                    {
+                        try
+                        {
+                            byte[] fileContent = File.ReadAllBytes(file);
+                            var protection = antiModchip.CheckContents(file, fileContent, false);
+                            if (!string.IsNullOrEmpty(protection))
+                                return true;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+
+                return false;
+            });
+#endif
         }
 
         /// <summary>
@@ -97,7 +179,7 @@ namespace MPF.Library
             if (!File.Exists(sub))
                 return null;
 
-            return LibCrypt.CheckSubfile(sub);
+            return LibCrypt.DetectLibCrypt([sub]);
         }
 
         /// <summary>
@@ -106,12 +188,27 @@ namespace MPF.Library
         /// <param name="foundProtections">Enumerable of found protections</param>
         public static string SanitizeFoundProtections(IEnumerable<string> foundProtections)
         {
+            // EXCEPTIONS
+            if (foundProtections.Any(p => p.StartsWith("[Exception opening file")))
+            {
+                foundProtections = foundProtections.Where(p => !p.StartsWith("[Exception opening file"));
+#if NET20 || NET35 || NET40 || NET452 || NET462
+                var tempList = new List<string> { "Exception occurred while scanning [RESCAN NEEDED]" };
+                tempList.AddRange(foundProtections);
+                foundProtections = tempList.OrderBy(p => p);
+#else
+                foundProtections = foundProtections
+                    .Prepend("Exception occurred while scanning [RESCAN NEEDED]")
+                    .OrderBy(p => p);
+#endif
+            }
+
             // ActiveMARK
             if (foundProtections.Any(p => p == "ActiveMARK 5") && foundProtections.Any(p => p == "ActiveMARK"))
                 foundProtections = foundProtections.Where(p => p != "ActiveMARK");
 
             // Cactus Data Shield
-            if (foundProtections.Any(p => Regex.IsMatch(p, @"Cactus Data Shield [0-9]{3} .+")) && foundProtections.Any(p => p == "Cactus Data Shield 200"))
+            if (foundProtections.Any(p => Regex.IsMatch(p, @"Cactus Data Shield [0-9]{3} .+", RegexOptions.Compiled)) && foundProtections.Any(p => p == "Cactus Data Shield 200"))
                 foundProtections = foundProtections.Where(p => p != "Cactus Data Shield 200");
 
             // CD-Check
@@ -141,7 +238,7 @@ namespace MPF.Library
             // JoWood X-Prot
             if (foundProtections.Any(p => p.StartsWith("JoWood X-Prot")))
             {
-                if (foundProtections.Any(p => Regex.IsMatch(p, @"JoWood X-Prot [0-9]\.[0-9]\.[0-9]\.[0-9]{2}")))
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"JoWood X-Prot [0-9]\.[0-9]\.[0-9]\.[0-9]{2}", RegexOptions.Compiled)))
                 {
                     foundProtections = foundProtections.Where(p => p != "JoWood X-Prot")
                         .Where(p => p != "JoWood X-Prot v1.0-v1.3")
@@ -177,80 +274,77 @@ namespace MPF.Library
             // SafeCast
             // TODO: Figure this one out
 
+            // Cactus Data Shield / SafeDisc
+            if (foundProtections.Any(p => p == "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)"))
+            {
+                foundProtections = foundProtections
+                    .Where(p => p != "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)");
+
+                if (foundProtections.Any(p => !p.StartsWith("SafeDisc")))
+                {
+#if NET20 || NET35 || NET40 || NET452 || NET462
+                    var tempList = new List<string>();
+                    tempList.AddRange(foundProtections);
+                    tempList.Add("Cactus Data Shield 300");
+                    foundProtections = tempList;
+#else
+                    foundProtections = foundProtections.Append("Cactus Data Shield 300");
+#endif
+                }
+            }
+
             // SafeDisc
             if (foundProtections.Any(p => p.StartsWith("SafeDisc")))
             {
-                if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}")))
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
                         .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc 2")
-                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
-                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
-                        .Where(p => !p.StartsWith("SafeDisc (drvmgt.dll)"))
-                        .Where(p => !p.StartsWith("SafeDisc (secdrv.sys)"))
-                        .Where(p => p != "SafeDisc Lite");
+                        .Where(p => p != "SafeDisc 2+");
                 }
-                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (drvmgt.dll)")))
+                else if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
                         .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc 2")
-                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
-                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
-                        .Where(p => !p.StartsWith("SafeDisc (secdrv.sys)"))
-                        .Where(p => p != "SafeDisc Lite");
+                        .Where(p => p != "SafeDisc 2+");
                 }
-                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (secdrv.sys)")))
+                else if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
                         .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc 2")
-                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
-                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
-                        .Where(p => p != "SafeDisc Lite");
+                        .Where(p => p != "SafeDisc 2+");
                 }
-                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (dplayerx.dll)")))
+                else if (foundProtections.Any(p => p.StartsWith("Macrovision Security Driver")))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => p != "SafeDisc")
                         .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc 2")
-                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
-                        .Where(p => p != "SafeDisc Lite");
+                        .Where(p => p != "SafeDisc 2+");
                 }
-                else if (foundProtections.Any(p => p == "SafeDisc 3.20-4.xx (version removed)"))
+                else if (foundProtections.Any(p => p == "SafeDisc 2+"))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
-                        .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc 2")
-                        .Where(p => p != "SafeDisc Lite");
-                }
-                else if (foundProtections.Any(p => p == "SafeDisc 2"))
-                {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
-                        .Where(p => p != "SafeDisc 1/Lite")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc Lite");
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => p != "SafeDisc");
                 }
                 else if (foundProtections.Any(p => p == "SafeDisc 1/Lite"))
                 {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
-                        .Where(p => p != "SafeDisc 1-3")
-                        .Where(p => p != "SafeDisc Lite");
-                }
-                else if (foundProtections.Any(p => p == "SafeDisc Lite"))
-                {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
-                        .Where(p => p != "SafeDisc 1-3");
-                }
-                else if (foundProtections.Any(p => p == "SafeDisc 1-3"))
-                {
-                    foundProtections = foundProtections.Where(p => p != "SafeDisc");
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => p != "SafeDisc");
                 }
             }
 
@@ -263,7 +357,7 @@ namespace MPF.Library
             // StarForce
             if (foundProtections.Any(p => p.StartsWith("StarForce")))
             {
-                if (foundProtections.Any(p => Regex.IsMatch(p, @"StarForce [0-9]+\..+")))
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"StarForce [0-9]+\..+", RegexOptions.Compiled)))
                 {
                     foundProtections = foundProtections.Where(p => p != "StarForce")
                         .Where(p => p != "StarForce 3-5")
@@ -298,7 +392,7 @@ namespace MPF.Library
             if (foundProtections.Any(p => p == "XCP") && foundProtections.Any(p => p.StartsWith("XCP") && p.Length > "XCP".Length))
                 foundProtections = foundProtections.Where(p => p != "XCP");
 
-            return string.Join(", ", foundProtections);
+            return string.Join(", ", foundProtections.ToArray());
         }
     }
 }

MPF.Core/SubmissionInfoTool.cs

@@ -0,0 +1,760 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using MPF.Core.Data;
+using MPF.Core.Modules;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Core
+{
+    /// <summary>
+    /// Class to hold all SubmissionInfo-related methods
+    /// </summary>
+    internal static class SubmissionInfoTool
+    {
+        #region Extraction and Filling
+
+        /// <summary>
+        /// Extract all of the possible information from a given input combination
+        /// </summary>
+        /// <param name="outputPath">Output path to write to</param>
+        /// <param name="drive">Drive object representing the current drive</param>
+        /// <param name="system">Currently selected system</param>
+        /// <param name="mediaType">Currently selected media type</param>
+        /// <param name="options">Options object representing user-defined options</param>
+        /// <param name="parameters">Parameters object representing what to send to the internal program</param>
+        /// <param name="resultProgress">Optional result progress callback</param>
+        /// <param name="protectionProgress">Optional protection progress callback</param>
+        /// <returns>SubmissionInfo populated based on outputs, null on error</returns>
+        public static async Task<SubmissionInfo?> ExtractOutputInformation(
+            string outputPath,
+            Drive? drive,
+            RedumpSystem? system,
+            MediaType? mediaType,
+            Options options,
+            BaseParameters? parameters,
+            IProgress<Result>? resultProgress = null,
+            IProgress<BinaryObjectScanner.ProtectionProgress>? protectionProgress = null)
+        {
+            // Ensure the current disc combination should exist
+            if (!system.MediaTypes().Contains(mediaType))
+                return null;
+
+            // Split the output path for easier use
+            var outputDirectory = Path.GetDirectoryName(outputPath);
+            string outputFilename = Path.GetFileName(outputPath);
+
+            // Check that all of the relevant files are there
+            (bool foundFiles, List<string> missingFiles) = parameters.FoundAllFiles(outputDirectory, outputFilename, false);
+            if (!foundFiles)
+            {
+                resultProgress?.Report(Result.Failure($"There were files missing from the output:\n{string.Join("\n", [.. missingFiles])}"));
+                resultProgress?.Report(Result.Failure($"This may indicate an issue with the hardware or media, including unsupported devices.\nPlease see dumping program documentation for more details."));
+                return null;
+            }
+
+            // Sanitize the output filename to strip off any potential extension
+            outputFilename = Path.GetFileNameWithoutExtension(outputFilename);
+
+            // Create the SubmissionInfo object with all user-inputted values by default
+            string combinedBase;
+            if (string.IsNullOrEmpty(outputDirectory))
+                combinedBase = outputFilename;
+            else
+                combinedBase = Path.Combine(outputDirectory, outputFilename);
+
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    System = system,
+                    Media = mediaType.ToDiscType(),
+                    Title = options.AddPlaceholders ? Template.RequiredValue : string.Empty,
+                    ForeignTitleNonLatin = options.AddPlaceholders ? Template.OptionalValue : string.Empty,
+                    DiscNumberLetter = options.AddPlaceholders ? Template.OptionalValue : string.Empty,
+                    DiscTitle = options.AddPlaceholders ? Template.OptionalValue : string.Empty,
+                    Category = null,
+                    Region = null,
+                    Languages = null,
+                    Serial = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty,
+                    Barcode = options.AddPlaceholders ? Template.OptionalValue : string.Empty,
+                    Contents = string.Empty,
+                },
+                VersionAndEditions = new VersionAndEditionsSection()
+                {
+                    Version = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty,
+                    OtherEditions = options.AddPlaceholders ? "(VERIFY THIS) Original" : string.Empty,
+                },
+                DumpingInfo = new DumpingInfoSection()
+                {
+                    FrontendVersion = Utilities.Tools.GetCurrentVersion(),
+                },
+            };
+
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+
+            // Get specific tool output handling
+            parameters?.GenerateSubmissionInfo(info, options, combinedBase, drive, options.IncludeArtifacts);
+
+            // Get a list of matching IDs for each line in the DAT
+            if (!string.IsNullOrEmpty(info.TracksAndWriteOffsets!.ClrMameProData) && options.HasRedumpLogin)
+#if NET40
+                _ = FillFromRedump(options, info, resultProgress);
+#else
+                _ = await FillFromRedump(options, info, resultProgress);
+#endif
+
+            // If we have both ClrMamePro and Size and Checksums data, remove the ClrMamePro
+            if (!string.IsNullOrEmpty(info.SizeAndChecksums?.CRC32))
+                info.TracksAndWriteOffsets.ClrMameProData = null;
+
+            // Add the volume label to comments, if possible or necessary
+            string? volLabels = FormatVolumeLabels(drive?.VolumeLabel, parameters?.VolumeLabels);
+            if (volLabels != null)
+                info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.VolumeLabel] = volLabels;
+
+            // Extract info based generically on MediaType
+            switch (mediaType)
+            {
+                case MediaType.CDROM:
+                case MediaType.GDROM:
+                    info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    break;
+
+                case MediaType.DVD:
+                case MediaType.HDDVD:
+                case MediaType.BluRay:
+
+                    // If we have a single-layer disc
+                    if (info.SizeAndChecksums!.Layerbreak == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a dual-layer disc
+                    else if (info.SizeAndChecksums!.Layerbreak2 == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a triple-layer disc
+                    else if (info.SizeAndChecksums!.Layerbreak3 == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer2MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a quad-layer disc
+                    else
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer2MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer3MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer3MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer3ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+
+                    break;
+
+                case MediaType.NintendoGameCubeGameDisc:
+                    info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.Extras!.BCA ??= (options.AddPlaceholders ? Template.RequiredValue : string.Empty);
+                    break;
+
+                case MediaType.NintendoWiiOpticalDisc:
+
+                    // If we have a single-layer disc
+                    if (info.SizeAndChecksums!.Layerbreak == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a dual-layer disc
+                    else
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    }
+
+                    info.Extras!.DiscKey = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.Extras.BCA = info.Extras.BCA ?? (options.AddPlaceholders ? Template.RequiredValue : string.Empty);
+
+                    break;
+
+                case MediaType.UMD:
+                    // Both single- and dual-layer discs have two "layers" for the ring
+                    info.CommonDiscInfo!.Layer0MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                    info.CommonDiscInfo.Layer1MasteringRing = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MasteringSID = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1ToolstampMasteringCode = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+
+                    info.SizeAndChecksums!.CRC32 ??= (options.AddPlaceholders ? Template.RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.SizeAndChecksums.MD5 ??= (options.AddPlaceholders ? Template.RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.SizeAndChecksums.SHA1 ??= (options.AddPlaceholders ? Template.RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.TracksAndWriteOffsets.ClrMameProData = null;
+                    break;
+            }
+
+            // Extract info based specifically on RedumpSystem
+            switch (system)
+            {
+                case RedumpSystem.AcornArchimedes:
+                    info.CommonDiscInfo!.Region ??= Region.UnitedKingdom;
+                    break;
+
+                case RedumpSystem.AppleMacintosh:
+                case RedumpSystem.EnhancedCD:
+                case RedumpSystem.IBMPCcompatible:
+                case RedumpSystem.PalmOS:
+                case RedumpSystem.PocketPC:
+                case RedumpSystem.RainbowDisc:
+                case RedumpSystem.SonyElectronicBook:
+                    resultProgress?.Report(Result.Success("Running copy protection scan... this might take a while!"));
+                    var (protectionString, fullProtections) = await InfoTool.GetCopyProtection(drive, options, protectionProgress);
+
+                    info.CopyProtection!.Protection += protectionString;
+                    info.CopyProtection.FullProtections = fullProtections as Dictionary<string, List<string>?> ?? [];
+                    resultProgress?.Report(Result.Success("Copy protection scan complete!"));
+
+                    if (system == RedumpSystem.EnhancedCD)
+                        info.CommonDiscInfo!.Category ??= DiscCategory.Audio;
+
+                    if (system == RedumpSystem.SonyElectronicBook)
+                        info.CommonDiscInfo!.Category ??= DiscCategory.Multimedia;
+
+                    break;
+
+                case RedumpSystem.AudioCD:
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.SuperAudioCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Audio;
+                    break;
+
+                case RedumpSystem.BandaiPlaydiaQuickInteractiveSystem:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= info.CommonDiscInfo.Region ?? Region.Japan;
+                    break;
+
+                case RedumpSystem.BDVideo:
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.HDDVDVideo:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    info.CopyProtection!.Protection ??= options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCD:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCD32:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Europe;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCDTV:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Europe;
+                    break;
+
+                case RedumpSystem.FujitsuFMTownsseries:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.FujitsuFMTownsMarty:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.HasbroVideoNow:
+                case RedumpSystem.HasbroVideoNowColor:
+                case RedumpSystem.HasbroVideoNowJr:
+                case RedumpSystem.VideoCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    break;
+
+                case RedumpSystem.HasbroVideoNowXP:
+                case RedumpSystem.PhotoCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Multimedia;
+                    break;
+
+                case RedumpSystem.IncredibleTechnologiesEagle:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamieAmusement:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiFireBeat:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiSystemGV:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiSystem573:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiTwinkle:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.MattelHyperScan:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.MicrosoftXboxOne:
+                    if (drive?.Name != null)
+                    {
+                        string xboxOneMsxcPath = Path.Combine(drive.Name, "MSXC");
+                        if (drive != null && Directory.Exists(xboxOneMsxcPath))
+                        {
+                            info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.Filename] ??= string.Join("\n",
+                                Directory.GetFiles(xboxOneMsxcPath, "*", SearchOption.TopDirectoryOnly).Select(Path.GetFileName).ToArray());
+                        }
+                    }
+
+                    break;
+
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                    if (drive?.Name != null)
+                    {
+                        string xboxSeriesXMsxcPath = Path.Combine(drive.Name, "MSXC");
+                        if (drive != null && Directory.Exists(xboxSeriesXMsxcPath))
+                        {
+                            info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.Filename] ??= string.Join("\n",
+                                Directory.GetFiles(xboxSeriesXMsxcPath, "*", SearchOption.TopDirectoryOnly).Select(Path.GetFileName).ToArray());
+                        }
+                    }
+
+                    break;
+
+                case RedumpSystem.NamcoSegaNintendoTriforce:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.NavisoftNaviken21:
+                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPC88series:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPC98series:
+                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPCFXPCFXGA:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.SegaChihiro:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaDreamcast:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaNaomi:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaNaomi2:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaTitanVideo:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SharpX68000:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.SNKNeoGeoCD:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SonyPlayStation:
+                    // Only check the disc if the dumping program couldn't detect
+                    if (drive != null && info.CopyProtection!.AntiModchip == YesNo.NULL)
+                    {
+                        resultProgress?.Report(Result.Success("Checking for anti-modchip strings... this might take a while!"));
+                        info.CopyProtection.AntiModchip = await InfoTool.GetAntiModchipDetected(drive) ? YesNo.Yes : YesNo.No;
+                        resultProgress?.Report(Result.Success("Anti-modchip string scan complete!"));
+                    }
+
+                    // Special case for DIC only
+                    if (parameters?.InternalProgram == InternalProgram.DiscImageCreator)
+                    {
+                        resultProgress?.Report(Result.Success("Checking for LibCrypt status... this might take a while!"));
+                        InfoTool.GetLibCryptDetected(info, combinedBase);
+                        resultProgress?.Report(Result.Success("LibCrypt status checking complete!"));
+                    }
+
+                    break;
+
+                case RedumpSystem.SonyPlayStation2:
+                    info.CommonDiscInfo!.LanguageSelection ??= [];
+                    break;
+
+                case RedumpSystem.SonyPlayStation3:
+                    info.Extras!.DiscKey ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.Extras.DiscID ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.TomyKissSite:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.ZAPiTGamesGameWaveFamilyEntertainmentSystem:
+                    info.CopyProtection!.Protection ??= options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    break;
+            }
+
+            // Set the category if it's not overriden
+            info.CommonDiscInfo!.Category ??= DiscCategory.Games;
+
+            // Comments and contents have odd handling
+            if (string.IsNullOrEmpty(info.CommonDiscInfo.Comments))
+                info.CommonDiscInfo.Comments = options.AddPlaceholders ? Template.OptionalValue : string.Empty;
+            if (string.IsNullOrEmpty(info.CommonDiscInfo.Contents))
+                info.CommonDiscInfo.Contents = options.AddPlaceholders ? Template.OptionalValue : string.Empty;
+
+            // Normalize the disc type with all current information
+            Validator.NormalizeDiscType(info);
+
+            return info;
+        }
+
+        /// <summary>
+        /// Fill in a SubmissionInfo object from Redump, if possible
+        /// </summary>
+        /// <param name="options">Options object representing user-defined options</param>
+        /// <param name="info">Existing SubmissionInfo object to fill</param>
+        /// <param name="resultProgress">Optional result progress callback</param>
+#if NET40
+        public static bool FillFromRedump(Options options, SubmissionInfo info, IProgress<Result>? resultProgress = null)
+#else
+        public async static Task<bool> FillFromRedump(Options options, SubmissionInfo info, IProgress<Result>? resultProgress = null)
+#endif
+        {
+            // If no username is provided
+            if (string.IsNullOrEmpty(options.RedumpUsername) || string.IsNullOrEmpty(options.RedumpPassword))
+                return false;
+
+            // Set the current dumper based on username
+            info.DumpersAndStatus ??= new DumpersAndStatusSection();
+            info.DumpersAndStatus.Dumpers = [options.RedumpUsername!];
+            info.PartiallyMatchedIDs = [];
+
+            // Login to Redump
+#if NETFRAMEWORK
+            using var wc = new RedumpWebClient();
+            bool? loggedIn = wc.Login(options.RedumpUsername!, options.RedumpPassword!);
+#else
+            using var wc = new RedumpHttpClient();
+            bool? loggedIn = await wc.Login(options.RedumpUsername, options.RedumpPassword);
+#endif
+            if (loggedIn == null)
+            {
+                resultProgress?.Report(Result.Failure("There was an unknown error connecting to Redump"));
+                return false;
+            }
+            else if (loggedIn == false)
+            {
+                // Don't log the as a failure or error
+                return false;
+            }
+
+            // Setup the full-track checks
+            bool allFound = true;
+            List<int>? fullyMatchedIDs = null;
+
+            // Loop through all of the hashdata to find matching IDs
+            resultProgress?.Report(Result.Success("Finding disc matches on Redump..."));
+            var splitData = info.TracksAndWriteOffsets?.ClrMameProData?.TrimEnd('\n')?.Split('\n');
+            int trackCount = splitData?.Length ?? 0;
+            foreach (string hashData in splitData ?? [])
+            {
+                // Catch any errant blank lines
+                if (string.IsNullOrEmpty(hashData))
+                {
+                    trackCount--;
+                    resultProgress?.Report(Result.Success("Blank line found, skipping!"));
+                    continue;
+                }
+
+                // If the line ends in a known extra track names, skip them for checking
+                if (hashData.Contains("(Track 0).bin")
+                    || hashData.Contains("(Track 0.2).bin")
+                    || hashData.Contains("(Track 00).bin")
+                    || hashData.Contains("(Track 00.2).bin")
+                    || hashData.Contains("(Track A).bin")
+                    || hashData.Contains("(Track A.2).bin")
+                    || hashData.Contains("(Track AA).bin")
+                    || hashData.Contains("(Track AA.2).bin"))
+                {
+                    trackCount--;
+                    resultProgress?.Report(Result.Success("Extra track found, skipping!"));
+                    continue;
+                }
+
+                // Get the SHA-1 hash
+                if (!InfoTool.GetISOHashValues(hashData, out _, out _, out _, out string? sha1))
+                {
+                    resultProgress?.Report(Result.Failure($"Line could not be parsed: {hashData}"));
+                    continue;
+                }
+
+#if NET40
+                var validateTask = Validator.ValidateSingleTrack(wc, info, sha1);
+                validateTask.Wait();
+                (bool singleFound, var foundIds, string? result) = validateTask.Result;
+#else
+                (bool singleFound, var foundIds, string? result) = await Validator.ValidateSingleTrack(wc, info, sha1);
+#endif
+                if (singleFound)
+                    resultProgress?.Report(Result.Success(result));
+                else
+                    resultProgress?.Report(Result.Failure(result));
+
+                // Ensure that all tracks are found
+                allFound &= singleFound;
+
+                // If we found a track, only keep track of distinct found tracks
+                if (singleFound && foundIds != null)
+                {
+                    if (fullyMatchedIDs == null)
+                        fullyMatchedIDs = foundIds;
+                    else
+                        fullyMatchedIDs = fullyMatchedIDs.Intersect(foundIds).ToList();
+                }
+                // If no tracks were found, remove all fully matched IDs found so far
+                else
+                {
+                    fullyMatchedIDs = [];
+                }
+            }
+
+            // If we don't have any matches but we have a universal hash
+            if (!info.PartiallyMatchedIDs.Any() && info.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.UniversalHash) == true)
+            {
+#if NET40
+                var validateTask = Validator.ValidateUniversalHash(wc, info);
+                validateTask.Wait();
+                (bool singleFound, var foundIds, string? result) = validateTask.Result;
+#else
+                (bool singleFound, var foundIds, string? result) = await Validator.ValidateUniversalHash(wc, info);
+#endif
+                if (singleFound)
+                    resultProgress?.Report(Result.Success(result));
+                else
+                    resultProgress?.Report(Result.Failure(result));
+
+                // Ensure that the hash is found
+                allFound = singleFound;
+
+                // If we found a track, only keep track of distinct found tracks
+                if (singleFound && foundIds != null)
+                {
+                    fullyMatchedIDs = foundIds;
+                }
+                // If no tracks were found, remove all fully matched IDs found so far
+                else
+                {
+                    fullyMatchedIDs = [];
+                }
+            }
+
+            // Make sure we only have unique IDs
+            info.PartiallyMatchedIDs = [.. info.PartiallyMatchedIDs.Distinct().OrderBy(id => id)];
+
+            resultProgress?.Report(Result.Success("Match finding complete! " + (fullyMatchedIDs != null && fullyMatchedIDs.Count > 0
+                ? "Fully Matched IDs: " + string.Join(",", fullyMatchedIDs.Select(i => i.ToString()).ToArray())
+                : "No matches found")));
+
+            // Exit early if one failed or there are no matched IDs
+            if (!allFound || fullyMatchedIDs == null || fullyMatchedIDs.Count == 0)
+                return false;
+
+            // Find the first matched ID where the track count matches, we can grab a bunch of info from it
+            int totalMatchedIDsCount = fullyMatchedIDs.Count;
+            for (int i = 0; i < totalMatchedIDsCount; i++)
+            {
+                // Skip if the track count doesn't match
+#if NET40
+                var validateTask = Validator.ValidateTrackCount(wc, fullyMatchedIDs[i], trackCount);
+                validateTask.Wait();
+                if (!validateTask.Result)
+#else
+                if (!await Validator.ValidateTrackCount(wc, fullyMatchedIDs[i], trackCount))
+#endif
+                    continue;
+
+                // Fill in the fields from the existing ID
+                resultProgress?.Report(Result.Success($"Filling fields from existing ID {fullyMatchedIDs[i]}..."));
+#if NET40
+                var fillTask = Task.Factory.StartNew(() => Builder.FillFromId(wc, info, fullyMatchedIDs[i], options.PullAllInformation));
+                fillTask.Wait();
+                _ = fillTask.Result;
+#else
+                _ = await Builder.FillFromId(wc, info, fullyMatchedIDs[i], options.PullAllInformation);
+#endif
+                resultProgress?.Report(Result.Success("Information filling complete!"));
+
+                // Set the fully matched ID to the current
+                info.FullyMatchedID = fullyMatchedIDs[i];
+                break;
+            }
+
+            // Clear out fully matched IDs from the partial list
+            if (info.FullyMatchedID.HasValue)
+            {
+                if (info.PartiallyMatchedIDs.Count == 1)
+                    info.PartiallyMatchedIDs = null;
+                else
+                    info.PartiallyMatchedIDs.Remove(info.FullyMatchedID.Value);
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        #region Helper Functions
+
+        /// <summary>
+        /// Formats a list of volume labels and their corresponding filesystems
+        /// </summary>
+        /// <param name="labels">Dictionary of volume labels and their filesystems</param>
+        /// <returns>Formatted string of volume labels and their filesystems</returns>
+        private static string? FormatVolumeLabels(string? driveLabel, Dictionary<string, List<string>>? labels)
+        {
+            // Must have at least one label to format
+            if (driveLabel == null && (labels == null || labels.Count == 0))
+                return null;
+
+            // If no labels given, use drive label
+            if (labels == null || labels.Count == 0)
+            {
+                // Ignore common volume labels
+                if (Drive.GetRedumpSystemFromVolumeLabel(driveLabel) != null)
+                    return null;
+
+                return driveLabel;
+            }
+
+            // If only one label, don't mention fs
+            string firstLabel = labels.First().Key;
+            if (labels.Count == 1 && (firstLabel == driveLabel || driveLabel == null))
+            {
+                // Ignore common volume labels
+                if (Drive.GetRedumpSystemFromVolumeLabel(firstLabel) != null)
+                    return null;
+
+                return firstLabel;
+            }
+
+            // Otherwise, state filesystem for each label
+            List<string> volLabels = [];
+            
+            // Begin formatted output with the label from Windows, if it is unique and not a common volume label
+            if (driveLabel != null && !labels.TryGetValue(driveLabel, out List<string>? value) && Drive.GetRedumpSystemFromVolumeLabel(driveLabel) == null)
+                volLabels.Add(driveLabel);
+
+            // Add remaining labels with their corresponding filesystems
+            foreach (KeyValuePair<string, List<string>> label in labels)
+            {
+                // Ignore common volume labels
+                if (Drive.GetRedumpSystemFromVolumeLabel(label.Key) == null)
+                    volLabels.Add($"{label.Key} ({string.Join(", ", [.. label.Value])})");
+            }
+
+            // Ensure that no labels are empty
+            volLabels = volLabels.Where(l => !string.IsNullOrEmpty(l?.Trim())).ToList();
+
+            // Print each label separated by a comma and a space
+            if (volLabels.Count == 0)
+                return null;
+
+            return string.Join(", ", [.. volLabels]);
+        }
+
+        #endregion
+    }
+}

MPF.Core/UI/ComboBoxItems/Element.cs

@@ -3,13 +3,13 @@ using System.Collections.Generic;
 using System.Linq;
 using MPF.Core.Converters;
 
-namespace MPF
+namespace MPF.Core.UI.ComboBoxItems
 {
     /// <summary>
     /// A generic combo box element
     /// </summary>
     /// <typeparam name="T">Enum type representing the possible values</typeparam>
-    public class Element<T> : IElement where T : struct, Enum
+    public class Element<T> : IEquatable<Element<T>>, IElement where T : struct, Enum
     {
         private readonly T Data;
 
@@ -47,5 +47,23 @@ namespace MPF
                 .OfType<T>()
                 .Select(e => new Element<T>(e));
         }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj)
+        {
+            return Equals(obj as Element<T>);
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(Element<T>? other)
+        {
+            if (other == null)
+                return false;
+
+            return Name == other.Name;
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode() => base.GetHashCode();
     }
 }

MPF.Core/UI/ComboBoxItems/IElement.cs

@@ -1,4 +1,4 @@
-namespace MPF
+namespace MPF.Core.UI.ComboBoxItems
 {
     public interface IElement
     {

MPF.Core/UI/ComboBoxItems/RedumpSystemComboBoxItem.cs

@@ -1,18 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Core.Converters;
-using MPF.Core.Utilities;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF
+namespace MPF.Core.UI.ComboBoxItems
 {
     /// <summary>
     /// Represents a single item in the System combo box
     /// </summary>
-    public class RedumpSystemComboBoxItem : IElement
+    public class RedumpSystemComboBoxItem : IEquatable<RedumpSystemComboBoxItem>, IElement
     {
-        private readonly object Data;
+        private readonly object? Data;
 
         public RedumpSystemComboBoxItem(RedumpSystem? system) => Data = system;
         public RedumpSystemComboBoxItem(SystemCategory? category) => Data = category;
@@ -81,5 +79,23 @@ namespace MPF
 
             return systemsValues;
         }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj)
+        {
+            return Equals(obj as RedumpSystemComboBoxItem);
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(RedumpSystemComboBoxItem? other)
+        {
+            if (other == null)
+                return false;
+
+            return Value == other.Value;
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode() => base.GetHashCode();
     }
 }

MPF.Core/UI/ViewModels/CheckDumpViewModel.cs

@@ -0,0 +1,484 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.UI.ViewModels
+{
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public class CheckDumpViewModel : INotifyPropertyChanged
+    {
+        #region Fields
+
+        /// <summary>
+        /// Access to the current options
+        /// </summary>
+        public Data.Options Options
+        {
+            get => _options;
+        }
+        private readonly Data.Options _options;
+
+        /// <summary>
+        /// Indicates if SelectionChanged events can be executed
+        /// </summary>
+        public bool CanExecuteSelectionChanged { get; private set; } = false;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Currently selected system value
+        /// </summary>
+        public RedumpSystem? CurrentSystem
+        {
+            get => _currentSystem;
+            set
+            {
+                _currentSystem = value;
+                TriggerPropertyChanged(nameof(CurrentSystem));
+            }
+        }
+        private RedumpSystem? _currentSystem;
+
+        /// <summary>
+        /// Indicates the status of the system type combo box
+        /// </summary>
+        public bool SystemTypeComboBoxEnabled
+        {
+            get => _systemTypeComboBoxEnabled;
+            set
+            {
+                _systemTypeComboBoxEnabled = value;
+                TriggerPropertyChanged(nameof(SystemTypeComboBoxEnabled));
+            }
+        }
+        private bool _systemTypeComboBoxEnabled;
+
+        /// <summary>
+        /// Currently selected media type value
+        /// </summary>
+        public MediaType? CurrentMediaType
+        {
+            get => _currentMediaType;
+            set
+            {
+                _currentMediaType = value;
+                TriggerPropertyChanged(nameof(CurrentMediaType));
+            }
+        }
+        private MediaType? _currentMediaType;
+
+        /// <summary>
+        /// Indicates the status of the media type combo box
+        /// </summary>
+        public bool MediaTypeComboBoxEnabled
+        {
+            get => _mediaTypeComboBoxEnabled;
+            set
+            {
+                _mediaTypeComboBoxEnabled = value;
+                TriggerPropertyChanged(nameof(MediaTypeComboBoxEnabled));
+            }
+        }
+        private bool _mediaTypeComboBoxEnabled;
+
+        /// <summary>
+        /// Currently provided input path
+        /// </summary>
+        public string? InputPath
+        {
+            get => _inputPath;
+            set
+            {
+                _inputPath = value;
+                TriggerPropertyChanged(nameof(InputPath));
+            }
+        }
+        private string? _inputPath;
+
+        /// <summary>
+        /// Indicates the status of the input path text box
+        /// </summary>
+        public bool InputPathTextBoxEnabled
+        {
+            get => _inputPathTextBoxEnabled;
+            set
+            {
+                _inputPathTextBoxEnabled = value;
+                TriggerPropertyChanged(nameof(InputPathTextBoxEnabled));
+            }
+        }
+        private bool _inputPathTextBoxEnabled;
+
+        /// <summary>
+        /// Indicates the status of the input path browse button
+        /// </summary>
+        public bool InputPathBrowseButtonEnabled
+        {
+            get => _inputPathBrowseButtonEnabled;
+            set
+            {
+                _inputPathBrowseButtonEnabled = value;
+                TriggerPropertyChanged(nameof(InputPathBrowseButtonEnabled));
+            }
+        }
+        private bool _inputPathBrowseButtonEnabled;
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram CurrentProgram
+        {
+            get => _currentProgram;
+            set
+            {
+                _currentProgram = value;
+                TriggerPropertyChanged(nameof(CurrentProgram));
+            }
+        }
+        private InternalProgram _currentProgram;
+
+        /// <summary>
+        /// Indicates the status of the dumping program combo box
+        /// </summary>
+        public bool DumpingProgramComboBoxEnabled
+        {
+            get => _dumpingProgramComboBoxEnabled;
+            set
+            {
+                _dumpingProgramComboBoxEnabled = value;
+                TriggerPropertyChanged(nameof(DumpingProgramComboBoxEnabled));
+            }
+        }
+        private bool _dumpingProgramComboBoxEnabled;
+
+        /// <summary>
+        /// Indicates the status of the check dump button
+        /// </summary>
+        public bool CheckDumpButtonEnabled
+        {
+            get => _checkDumpButtonEnabled;
+            set
+            {
+                _checkDumpButtonEnabled = value;
+                TriggerPropertyChanged(nameof(CheckDumpButtonEnabled));
+            }
+        }
+        private bool _checkDumpButtonEnabled;
+
+        /// <summary>
+        /// Indicates the status of the cancel button
+        /// </summary>
+        public bool CancelButtonEnabled
+        {
+            get => _cancelButtonEnabled;
+            set
+            {
+                _cancelButtonEnabled = value;
+                TriggerPropertyChanged(nameof(CancelButtonEnabled));
+            }
+        }
+        private bool _cancelButtonEnabled;
+
+        #endregion
+
+        #region List Properties
+
+        /// <summary>
+        /// Current list of supported media types
+        /// </summary>
+        public List<Element<MediaType>>? MediaTypes
+        {
+            get => _mediaTypes;
+            set
+            {
+                _mediaTypes = value;
+                TriggerPropertyChanged(nameof(MediaTypes));
+            }
+        }
+        private List<Element<MediaType>>? _mediaTypes;
+
+        /// <summary>
+        /// Current list of supported system profiles
+        /// </summary>
+        public List<RedumpSystemComboBoxItem> Systems
+        {
+            get => _systems;
+            set
+            {
+                _systems = value;
+                TriggerPropertyChanged(nameof(Systems));
+            }
+        }
+        private List<RedumpSystemComboBoxItem> _systems;
+
+        /// <summary>
+        /// List of available internal programs
+        /// </summary>
+        public List<Element<InternalProgram>> InternalPrograms
+        {
+            get => _internalPrograms;
+            set
+            {
+                _internalPrograms = value;
+                TriggerPropertyChanged(nameof(InternalPrograms));
+            }
+        }
+        private List<Element<InternalProgram>> _internalPrograms;
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for pure view model
+        /// </summary>
+        public CheckDumpViewModel()
+        {
+            _options = OptionsLoader.LoadFromConfig();
+            _internalPrograms = [];
+            _inputPath = string.Empty;
+            _systems = [];
+
+            SystemTypeComboBoxEnabled = true;
+            InputPathTextBoxEnabled = true;
+            InputPathBrowseButtonEnabled = true;
+            MediaTypeComboBoxEnabled = true;
+            DumpingProgramComboBoxEnabled = true;
+            CheckDumpButtonEnabled = false;
+            CancelButtonEnabled = true;
+
+            MediaTypes = [];
+            Systems = RedumpSystemComboBoxItem.GenerateElements().ToList();
+            InternalPrograms = [];
+
+            PopulateMediaType();
+            PopulateInternalPrograms();
+            EnableEventHandlers();
+        }
+
+        #region Property Updates
+
+        /// <summary>
+        /// Trigger a property changed event
+        /// </summary>
+        private void TriggerPropertyChanged(string propertyName)
+        {
+            // Disable event handlers temporarily
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // If the property change event is initialized
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+
+            // Reenable event handlers, if necessary
+            if (cachedCanExecuteSelectionChanged) EnableEventHandlers();
+        }
+
+        #endregion
+
+        #region UI Commands
+
+        /// <summary>
+        /// Change the currently selected system
+        /// </summary>
+        public void ChangeSystem()
+        {
+            PopulateMediaType();
+            this.CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        /// <summary>
+        /// Change the currently selected media type
+        /// </summary>
+        public void ChangeMediaType()
+        {
+            this.CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        /// <summary>
+        /// Change the currently selected dumping program
+        /// </summary>
+        public void ChangeDumpingProgram()
+        {
+            this.CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        /// <summary>
+        /// Change the currently selected input path
+        /// </summary>
+        public void ChangeInputPath()
+        {
+            this.CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        #endregion
+
+        #region UI Control
+
+        /// <summary>
+        /// Enables all UI elements that should be enabled
+        /// </summary>
+        private void EnableUIElements()
+        {
+            SystemTypeComboBoxEnabled = true;
+            InputPathTextBoxEnabled = true;
+            InputPathBrowseButtonEnabled = true;
+            DumpingProgramComboBoxEnabled = true;
+            PopulateMediaType();
+            CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+            CancelButtonEnabled = true;
+        }
+
+        /// <summary>
+        /// Disables all UI elements
+        /// </summary>
+        private void DisableUIElements()
+        {
+            SystemTypeComboBoxEnabled = false;
+            InputPathTextBoxEnabled = false;
+            InputPathBrowseButtonEnabled = false;
+            MediaTypeComboBoxEnabled = false;
+            DumpingProgramComboBoxEnabled = false;
+            CheckDumpButtonEnabled = false;
+            CancelButtonEnabled = false;
+        }
+
+        #endregion
+
+        #region Population
+
+        /// <summary>
+        /// Populate media type according to system type
+        /// </summary>
+        private void PopulateMediaType()
+        {
+            // Disable other UI updates
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            if (this.CurrentSystem != null)
+            {
+                var mediaTypeValues = this.CurrentSystem.MediaTypes();
+                int index = mediaTypeValues.FindIndex(m => m == this.CurrentMediaType);
+
+                MediaTypes = mediaTypeValues.Select(m => new Element<MediaType>(m ?? MediaType.NONE)).ToList();
+                this.MediaTypeComboBoxEnabled = MediaTypes.Count > 1;
+                this.CurrentMediaType = (index > -1 ? MediaTypes[index] : MediaTypes[0]);
+            }
+            else
+            {
+                this.MediaTypeComboBoxEnabled = false;
+                this.MediaTypes = null;
+                this.CurrentMediaType = null;
+            }
+
+            // Reenable event handlers, if necessary
+            if (cachedCanExecuteSelectionChanged) EnableEventHandlers();
+        }
+
+        /// <summary>
+        /// Populate media type according to system type
+        /// </summary>
+        private void PopulateInternalPrograms()
+        {
+            // Disable other UI updates
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // Get the current internal program
+            InternalProgram internalProgram = this.Options.InternalProgram;
+
+            // Create a static list of supported Check programs, not everything
+            var internalPrograms = new List<InternalProgram> { InternalProgram.Redumper, InternalProgram.Aaru, InternalProgram.DiscImageCreator, InternalProgram.CleanRip, InternalProgram.PS3CFW, InternalProgram.UmdImageCreator };
+            InternalPrograms = internalPrograms.Select(ip => new Element<InternalProgram>(ip)).ToList();
+
+            // Select the current default dumping program
+            int currentIndex = InternalPrograms.FindIndex(m => m == internalProgram);
+            this.CurrentProgram = (currentIndex > -1 ? InternalPrograms[currentIndex].Value : InternalPrograms[0].Value);
+
+            // Reenable event handlers, if necessary
+            if (cachedCanExecuteSelectionChanged) EnableEventHandlers();
+        }
+
+        #endregion
+
+        #region UI Functionality
+
+        private bool ShouldEnableCheckDumpButton()
+        {
+            return this.CurrentSystem != null && this.CurrentMediaType != null && !string.IsNullOrEmpty(this.InputPath);
+        }
+
+        /// <summary>
+        /// Enable all textbox and combobox event handlers
+        /// </summary>
+        private void EnableEventHandlers()
+        {
+            CanExecuteSelectionChanged = true;
+        }
+
+        /// <summary>
+        /// Disable all textbox and combobox event handlers
+        /// </summary>
+        private void DisableEventHandlers()
+        {
+            CanExecuteSelectionChanged = false;
+        }
+
+        #endregion
+
+        #region MPF.Check
+
+        /// <summary>
+        /// Performs MPF.Check functionality
+        /// </summary>
+        /// <returns>An error message if failed, otherwise string.Empty/null</returns>
+        public async Task<string?> CheckDump(Func<SubmissionInfo?, (bool?, SubmissionInfo?)> processUserInfo)
+        {
+            if (string.IsNullOrEmpty(InputPath))
+                return "Invalid Input path";
+
+            if (!File.Exists(this.InputPath!.Trim('"')))
+                return "Input Path is not a valid file";
+
+            // Disable UI while Check is running
+            DisableUIElements();
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // Populate an environment
+            var env = new DumpEnvironment(Options, Path.GetFullPath(this.InputPath.Trim('"')), null, this.CurrentSystem, this.CurrentMediaType, this.CurrentProgram, parameters: null);
+
+            // Make new Progress objects
+            var resultProgress = new Progress<Result>();
+            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+            var protectionProgress = new Progress<ProtectionProgress>();
+            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+
+            // Finally, attempt to do the output dance
+            var result = await env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress, processUserInfo);
+
+            // Reenable UI and event handlers, if necessary
+            EnableUIElements();
+            if (cachedCanExecuteSelectionChanged)
+                EnableEventHandlers();
+
+            return result.Message;
+        }
+
+        #endregion
+    }
+}

MPF.Core/UI/ViewModels/DiscInformationViewModel.cs

@@ -0,0 +1,247 @@
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.UI.ViewModels
+{
+    public class DiscInformationViewModel
+    {
+        #region Fields
+
+        /// <summary>
+        /// Application-level Options object
+        /// </summary>
+        public Options Options { get; private set; }
+
+        /// <summary>
+        /// SubmissionInfo object to fill and save
+        /// </summary>
+        public SubmissionInfo SubmissionInfo { get; private set; }
+
+        #endregion
+
+        #region Lists
+
+        /// <summary>
+        /// List of available disc categories
+        /// </summary>
+        public List<Element<DiscCategory>> Categories { get; private set; } = Element<DiscCategory>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of available regions
+        /// </summary>
+        public List<Element<Region>> Regions { get; private set; } = Element<Region>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of Redump-supported Regions
+        /// </summary>
+        private static readonly List<Region> RedumpRegions = new()
+        {
+            Region.Argentina,
+            Region.Asia,
+            Region.AsiaEurope,
+            Region.AsiaUSA,
+            Region.Australia,
+            Region.AustraliaGermany,
+            Region.AustraliaNewZealand,
+            Region.Austria,
+            Region.AustriaSwitzerland,
+            Region.Belarus,
+            Region.Belgium,
+            Region.BelgiumNetherlands,
+            Region.Brazil,
+            Region.Bulgaria,
+            Region.Canada,
+            Region.China,
+            Region.Croatia,
+            Region.Czechia,
+            Region.Denmark,
+            Region.Estonia,
+            Region.Europe,
+            Region.EuropeAsia,
+            Region.EuropeAustralia,
+            Region.EuropeCanada,
+            Region.EuropeGermany,
+            Region.Export,
+            Region.Finland,
+            Region.France,
+            Region.FranceSpain,
+            Region.Germany,
+            Region.GreaterChina,
+            Region.Greece,
+            Region.Hungary,
+            Region.Iceland,
+            Region.India,
+            Region.Ireland,
+            Region.Israel,
+            Region.Italy,
+            Region.Japan,
+            Region.JapanAsia,
+            Region.JapanEurope,
+            Region.JapanKorea,
+            Region.JapanUSA,
+            Region.SouthKorea,
+            Region.LatinAmerica,
+            Region.Lithuania,
+            Region.Netherlands,
+            Region.NewZealand,
+            Region.Norway,
+            Region.Poland,
+            Region.Portugal,
+            Region.Romania,
+            Region.RussianFederation,
+            Region.Scandinavia,
+            Region.Serbia,
+            Region.Singapore,
+            Region.Slovakia,
+            Region.SouthAfrica,
+            Region.Spain,
+            Region.SpainPortugal,
+            Region.Sweden,
+            Region.Switzerland,
+            Region.Taiwan,
+            Region.Thailand,
+            Region.Turkey,
+            Region.UnitedArabEmirates,
+            Region.UnitedKingdom,
+            Region.UKAustralia,
+            Region.Ukraine,
+            Region.UnitedStatesOfAmerica,
+            Region.USAAsia,
+            Region.USAAustralia,
+            Region.USABrazil,
+            Region.USACanada,
+            Region.USAEurope,
+            Region.USAGermany,
+            Region.USAJapan,
+            Region.USAKorea,
+            Region.World,
+        };
+
+        /// <summary>
+        /// List of available languages
+        /// </summary>
+        public List<Element<Language>> Languages { get; private set; } = Element<Language>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of Redump-supported Languages
+        /// </summary>
+        private static readonly List<Language> RedumpLanguages = new()
+        {
+            Language.Afrikaans,
+            Language.Albanian,
+            Language.Arabic,
+            Language.Armenian,
+            Language.Basque,
+            Language.Belarusian,
+            Language.Bulgarian,
+            Language.Catalan,
+            Language.Chinese,
+            Language.Croatian,
+            Language.Czech,
+            Language.Danish,
+            Language.Dutch,
+            Language.English,
+            Language.Estonian,
+            Language.Finnish,
+            Language.French,
+            Language.Gaelic,
+            Language.German,
+            Language.Greek,
+            Language.Hebrew,
+            Language.Hindi,
+            Language.Hungarian,
+            Language.Icelandic,
+            Language.Indonesian,
+            Language.Italian,
+            Language.Japanese,
+            Language.Korean,
+            Language.Latin,
+            Language.Latvian,
+            Language.Lithuanian,
+            Language.Macedonian,
+            Language.Norwegian,
+            Language.Polish,
+            Language.Portuguese,
+            Language.Panjabi,
+            Language.Romanian,
+            Language.Russian,
+            Language.Serbian,
+            Language.Slovak,
+            Language.Slovenian,
+            Language.Spanish,
+            Language.Swedish,
+            Language.Tamil,
+            Language.Thai,
+            Language.Turkish,
+            Language.Ukrainian,
+            Language.Vietnamese,
+        };
+
+        /// <summary>
+        /// List of available languages
+        /// </summary>
+        public List<Element<LanguageSelection>> LanguageSelections { get; private set; } = Element<LanguageSelection>.GenerateElements().ToList();
+
+        #endregion
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public DiscInformationViewModel(Options options, SubmissionInfo? submissionInfo)
+        {
+            Options = options;
+            SubmissionInfo = submissionInfo?.Clone() as SubmissionInfo ?? new SubmissionInfo();
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Load the current contents of the base SubmissionInfo to the UI
+        /// </summary>
+        /// TODO: Convert selected list item to binding
+        public void Load()
+        {
+            if (SubmissionInfo.CommonDiscInfo?.Languages != null)
+                Languages.ForEach(l => l.IsChecked = SubmissionInfo.CommonDiscInfo.Languages.Contains(l));
+            if (SubmissionInfo.CommonDiscInfo?.LanguageSelection != null)
+                LanguageSelections.ForEach(ls => ls.IsChecked = SubmissionInfo.CommonDiscInfo.LanguageSelection.Contains(ls));
+        }
+
+        /// <summary>
+        /// Save the current contents of the UI to the base SubmissionInfo
+        /// </summary>
+        /// TODO: Convert selected list item to binding
+        public void Save()
+        {
+            if (SubmissionInfo.CommonDiscInfo == null)
+                SubmissionInfo.CommonDiscInfo = new CommonDiscInfoSection();
+            SubmissionInfo.CommonDiscInfo.Languages = Languages.Where(l => l.IsChecked).Select(l => l?.Value).ToArray();
+            if (!SubmissionInfo.CommonDiscInfo.Languages.Any())
+                SubmissionInfo.CommonDiscInfo.Languages = [null];
+            SubmissionInfo.CommonDiscInfo.LanguageSelection = LanguageSelections.Where(ls => ls.IsChecked).Select(ls => ls?.Value).ToArray();
+            SubmissionInfo.CommonDiscInfo.Title = InfoTool.NormalizeDiscTitle(SubmissionInfo.CommonDiscInfo.Title, SubmissionInfo.CommonDiscInfo.Languages);
+        }
+
+        /// <summary>
+        /// Repopulate the list of Languages based on Redump support
+        /// </summary>
+        public void SetRedumpLanguages()
+        {
+            this.Languages = RedumpLanguages.Select(l => new Element<Language>(l)).ToList();
+        }
+
+        /// <summary>
+        /// Repopulate the list of Regions based on Redump support
+        /// </summary>
+        public void SetRedumpRegions()
+        {
+            this.Regions = RedumpRegions.Select(r => new Element<Region>(r)).ToList();
+        }
+
+        #endregion
+    }
+}

MPF.Core/UI/ViewModels/OptionsViewModel.cs

@@ -0,0 +1,164 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading.Tasks;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Core.UI.ViewModels
+{
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public class OptionsViewModel : INotifyPropertyChanged
+    {
+        #region Fields
+
+        /// <summary>
+        /// Title for the window
+        /// </summary>
+        public string? Title
+        {
+            get => _title;
+            set
+            {
+                _title = value;
+                TriggerPropertyChanged(nameof(Title));
+            }
+        }
+        private string? _title;
+
+        /// <summary>
+        /// Current set of options
+        /// </summary>
+        public Options Options { get; }
+
+        /// <summary>
+        /// Flag for if settings were saved or not
+        /// </summary>
+        public bool SavedSettings { get; set; }
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        #endregion
+
+        #region Lists
+
+        /// <summary>
+        /// List of available internal programs
+        /// </summary>
+        public static List<Element<InternalProgram>> InternalPrograms => PopulateInternalPrograms();
+
+        /// <summary>
+        /// Current list of supported Redumper read methods
+        /// </summary>
+        public static List<Element<RedumperReadMethod>> RedumperReadMethods => PopulateRedumperReadMethods();
+
+        /// <summary>
+        /// Current list of supported Redumper sector orders
+        /// </summary>
+        public static List<Element<RedumperSectorOrder>> RedumperSectorOrders => PopulateRedumperSectorOrders();
+
+        /// <summary>
+        /// Current list of supported system profiles
+        /// </summary>
+        public static List<RedumpSystemComboBoxItem> Systems => RedumpSystemComboBoxItem.GenerateElements().ToList();
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for pure view model
+        /// </summary>
+        public OptionsViewModel()
+        {
+            Options = new Options();
+        }
+
+        /// <summary>
+        /// Constructor for in-code
+        /// </summary>
+        public OptionsViewModel(Options baseOptions)
+        {
+            Options = new Options(baseOptions);
+        }
+
+        #region Population
+
+        /// <summary>
+        /// Get a complete list of supported internal programs
+        /// </summary>
+        private static List<Element<InternalProgram>> PopulateInternalPrograms()
+        {
+            var internalPrograms = new List<InternalProgram> { InternalProgram.Redumper, InternalProgram.DiscImageCreator, InternalProgram.Aaru };
+            return internalPrograms.Select(ip => new Element<InternalProgram>(ip)).ToList();
+        }
+
+        /// <summary>
+        /// Get a complete list of supported redumper drive read methods
+        /// </summary>
+        private static List<Element<RedumperReadMethod>> PopulateRedumperReadMethods()
+        {
+            var readMethods = new List<RedumperReadMethod> { RedumperReadMethod.NONE, RedumperReadMethod.D8, RedumperReadMethod.BE, RedumperReadMethod.BE_CDDA };
+            return readMethods.Select(rm => new Element<RedumperReadMethod>(rm)).ToList();
+        }
+
+        /// <summary>
+        /// Get a complete list of supported redumper drive sector orders
+        /// </summary>
+        private static List<Element<RedumperSectorOrder>> PopulateRedumperSectorOrders()
+        {
+            var sectorOrders = new List<RedumperSectorOrder> { RedumperSectorOrder.NONE, RedumperSectorOrder.DATA_C2_SUB, RedumperSectorOrder.DATA_SUB_C2, RedumperSectorOrder.DATA_SUB, RedumperSectorOrder.DATA_C2 };
+            return sectorOrders.Select(so => new Element<RedumperSectorOrder>(so)).ToList();
+        }
+
+        #endregion
+
+        #region UI Commands
+
+        /// <summary>
+        /// Test Redump login credentials
+        /// </summary>
+#if NET40
+        public static Task<(bool?, string?)> TestRedumpLogin(string username, string password)
+#else
+        public static async Task<(bool?, string?)> TestRedumpLogin(string username, string password)
+#endif
+        {
+#if NET40
+            return Task.Factory.StartNew(() => RedumpWebClient.ValidateCredentials(username, password));
+#elif NETFRAMEWORK
+            return await Task.Run(() => RedumpWebClient.ValidateCredentials(username, password));
+#else
+            return await RedumpHttpClient.ValidateCredentials(username, password);
+#endif
+        }
+
+        /// <summary>
+        /// Reset Redumper non-redump options (Read Method, Sector Order, Drive Type)
+        /// </summary>
+        public void NonRedumpModeUnChecked()
+        {
+            Options.RedumperReadMethod = RedumperReadMethod.NONE;
+            Options.RedumperSectorOrder = RedumperSectorOrder.NONE;
+            Options.RedumperUseGenericDriveType = false;
+            TriggerPropertyChanged(nameof(Options));
+        }
+
+        #endregion
+
+        #region Property Updates
+
+        /// <summary>
+        /// Trigger a property changed event
+        /// </summary>
+        private void TriggerPropertyChanged(string propertyName)
+        {
+            // If the property change event is initialized
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        #endregion
+    }
+}

MPF.Core/Utilities/Chime.cs

@@ -0,0 +1,400 @@
+#if FALSE
+
+using System;
+
+namespace MPF.Core.Utilities
+{
+    /// <summary>
+    /// Methods to deal with outputting tones to the PC speaker
+    /// </summary>
+    public class Chime
+    {
+        /// <summary>
+        /// Standard duration to play a single tone
+        /// </summary>
+        private const int standardDurationMs = 200;
+
+        #region Octave 0
+
+        /// <summary>
+        /// Frequency representing C(0)
+        /// </summary>
+        private const int noteC0 = 16; // 16.35
+
+        /// <summary>
+        /// Frequency representing D(0)
+        /// </summary>
+        private const int noteD0 = 18; // 18.35
+
+        /// <summary>
+        /// Frequency representing E(0)
+        /// </summary>
+        private const int noteE0 = 21; // 20.60
+
+        /// <summary>
+        /// Frequency representing F(0)
+        /// </summary>
+        private const int noteF0 = 22; // 21.83
+
+        /// <summary>
+        /// Frequency representing G(0)
+        /// </summary>
+        private const int noteG0 = 25; // 24.50
+
+        /// <summary>
+        /// Frequency representing A(0)
+        /// </summary>
+        private const int noteA0 = 28; // 27.50
+
+        /// <summary>
+        /// Frequency representing B(0)
+        /// </summary>
+        private const int noteB0 = 31; // 30.87
+
+        #endregion
+
+        #region Octave 1
+
+        /// <summary>
+        /// Frequency representing C(1)
+        /// </summary>
+        private const int noteC1 = 33; // 32.70
+
+        /// <summary>
+        /// Frequency representing D(1)
+        /// </summary>
+        private const int noteD1 = 37; // 36.71
+
+        /// <summary>
+        /// Frequency representing E(1)
+        /// </summary>
+        private const int noteE1 = 41; // 41.20
+
+        /// <summary>
+        /// Frequency representing F(1)
+        /// </summary>
+        private const int noteF1 = 44; // 43.65
+
+        /// <summary>
+        /// Frequency representing G(1)
+        /// </summary>
+        private const int noteG1 = 49; // 49.00
+
+        /// <summary>
+        /// Frequency representing A(1)
+        /// </summary>
+        private const int noteA1 = 55; // 55.00
+
+        /// <summary>
+        /// Frequency representing B(1)
+        /// </summary>
+        private const int noteB1 = 62; // 61.74
+
+        #endregion
+
+        #region Octave 2
+
+        /// <summary>
+        /// Frequency representing C(2)
+        /// </summary>
+        private const int noteC2 = 65; // 65.41
+
+        /// <summary>
+        /// Frequency representing D(2)
+        /// </summary>
+        private const int noteD2 = 73; // 73.42
+
+        /// <summary>
+        /// Frequency representing E(2)
+        /// </summary>
+        private const int noteE2 = 82; // 82.41
+
+        /// <summary>
+        /// Frequency representing F(2)
+        /// </summary>
+        private const int noteF2 = 87; // 87.31
+
+        /// <summary>
+        /// Frequency representing G(2)
+        /// </summary>
+        private const int noteG2 = 98; // 98.00
+
+        /// <summary>
+        /// Frequency representing A(2)
+        /// </summary>
+        private const int noteA2 = 110; // 110.00
+
+        /// <summary>
+        /// Frequency representing B(2)
+        /// </summary>
+        private const int noteB2 = 123; // 123.47
+
+        #endregion
+
+        #region Octave 3
+
+        /// <summary>
+        /// Frequency representing C(3)
+        /// </summary>
+        private const int noteC3 = 131; // 130.81
+
+        /// <summary>
+        /// Frequency representing D(3)
+        /// </summary>
+        private const int noteD3 = 147; // 146.83
+
+        /// <summary>
+        /// Frequency representing E(3)
+        /// </summary>
+        private const int noteE3 = 165; // 164.81
+
+        /// <summary>
+        /// Frequency representing F(3)
+        /// </summary>
+        private const int noteF3 = 175; // 174.61
+
+        /// <summary>
+        /// Frequency representing G(3)
+        /// </summary>
+        private const int noteG3 = 196; // 196.00
+
+        /// <summary>
+        /// Frequency representing A(3)
+        /// </summary>
+        private const int noteA3 = 220; // 220.00
+
+        /// <summary>
+        /// Frequency representing B(3)
+        /// </summary>
+        private const int noteB3 = 247; // 246.94
+
+        #endregion
+
+        #region Octave 4
+
+        /// <summary>
+        /// Frequency representing C(4)
+        /// </summary>
+        private const int noteC4 = 262; // 261.63
+
+        /// <summary>
+        /// Frequency representing D(4)
+        /// </summary>
+        private const int noteD4 = 294; // 293.66
+
+        /// <summary>
+        /// Frequency representing E(4)
+        /// </summary>
+        private const int noteE4 = 330; // 329.63
+
+        /// <summary>
+        /// Frequency representing F(4)
+        /// </summary>
+        private const int noteF4 = 349; // 349.23
+
+        /// <summary>
+        /// Frequency representing G(4)
+        /// </summary>
+        private const int noteG4 = 392; // 392.00
+
+        /// <summary>
+        /// Frequency representing A(4)
+        /// </summary>
+        private const int noteA4 = 440; // 440.00
+
+        /// <summary>
+        /// Frequency representing B(4)
+        /// </summary>
+        private const int noteB4 = 494; // 493.88
+
+        #endregion
+
+        #region Octave 5
+
+        /// <summary>
+        /// Frequency representing C(5)
+        /// </summary>
+        private const int noteC5 = 523; // 523.25
+
+        /// <summary>
+        /// Frequency representing D(5)
+        /// </summary>
+        private const int noteD5 = 587; // 587.33
+
+        /// <summary>
+        /// Frequency representing E(5)
+        /// </summary>
+        private const int noteE5 = 659; // 659.25
+
+        /// <summary>
+        /// Frequency representing F(5)
+        /// </summary>
+        private const int noteF5 = 698; // 698.46
+
+        /// <summary>
+        /// Frequency representing G(5)
+        /// </summary>
+        private const int noteG5 = 783; // 783.99
+
+        /// <summary>
+        /// Frequency representing A(5)
+        /// </summary>
+        private const int noteA5 = 880; // 880.00
+
+        /// <summary>
+        /// Frequency representing B(5)
+        /// </summary>
+        private const int noteB5 = 988; // 987.77
+
+        #endregion
+
+        #region Octave 6
+
+        /// <summary>
+        /// Frequency representing C(6)
+        /// </summary>
+        private const int noteC6 = 1047; // 1046.50
+
+        /// <summary>
+        /// Frequency representing D(6)
+        /// </summary>
+        private const int noteD6 = 1175; // 1174.66
+
+        /// <summary>
+        /// Frequency representing E(6)
+        /// </summary>
+        private const int noteE6 = 1319; // 1318.51
+
+        /// <summary>
+        /// Frequency representing F(6)
+        /// </summary>
+        private const int noteF6 = 1397; // 1396.91
+
+        /// <summary>
+        /// Frequency representing G(6)
+        /// </summary>
+        private const int noteG6 = 1568; // 1567.98
+
+        /// <summary>
+        /// Frequency representing A(6)
+        /// </summary>
+        private const int noteA6 = 1760; // 1760.00
+
+        /// <summary>
+        /// Frequency representing B(6)
+        /// </summary>
+        private const int noteB6 = 1976; // 1975.53
+
+        #endregion
+
+        #region Octave 7
+
+        /// <summary>
+        /// Frequency representing C(7)
+        /// </summary>
+        private const int noteC7 = 2093; // 2093.00
+
+        /// <summary>
+        /// Frequency representing D(7)
+        /// </summary>
+        private const int noteD7 = 2349; // 2349.32
+
+        /// <summary>
+        /// Frequency representing E(7)
+        /// </summary>
+        private const int noteE7 = 2637; // 2637.02
+
+        /// <summary>
+        /// Frequency representing F(7)
+        /// </summary>
+        private const int noteF7 = 2794; // 2793.83
+
+        /// <summary>
+        /// Frequency representing G(7)
+        /// </summary>
+        private const int noteG7 = 3136; // 3135.96
+
+        /// <summary>
+        /// Frequency representing A(7)
+        /// </summary>
+        private const int noteA7 = 3520; // 3520.00
+
+        /// <summary>
+        /// Frequency representing B(7)
+        /// </summary>
+        private const int noteB7 = 3951; // 3951.07
+
+        #endregion
+
+        #region Octave 8
+
+        /// <summary>
+        /// Frequency representing C(8)
+        /// </summary>
+        private const int noteC8 = 4186; // 4186.01
+
+        /// <summary>
+        /// Frequency representing D(8)
+        /// </summary>
+        private const int noteD8 = 4699; // 4698.63
+
+        /// <summary>
+        /// Frequency representing E(8)
+        /// </summary>
+        private const int noteE8 = 5274; // 5274.04
+
+        /// <summary>
+        /// Frequency representing F(8)
+        /// </summary>
+        private const int noteF8 = 5588; // 5587.65
+
+        /// <summary>
+        /// Frequency representing G(8)
+        /// </summary>
+        private const int noteG8 = 6272; // 6271.93
+
+        /// <summary>
+        /// Frequency representing A(8)
+        /// </summary>
+        private const int noteA8 = 7040; // 7040.00
+
+        /// <summary>
+        /// Frequency representing B(8)
+        /// </summary>
+        private const int noteB8 = 7902; // 7902.13
+
+        #endregion
+
+        /// <summary>
+        /// Output a series of beeps for completion, similar to DiscImageCreator
+        /// </summary>
+        /// <param name="success">True if the upward series should play, false otherwise</param>
+        public static void StandardCompletion(bool success)
+        {
+            if (success)
+            {
+                Console.Beep(noteC4, standardDurationMs);
+                Console.Beep(noteD4, standardDurationMs);
+                Console.Beep(noteE4, standardDurationMs);
+                Console.Beep(noteF4, standardDurationMs);
+                Console.Beep(noteG4, standardDurationMs);
+                Console.Beep(noteA4, standardDurationMs);
+                Console.Beep(noteB4, standardDurationMs);
+                Console.Beep(noteC5, standardDurationMs);
+            }
+            else
+            {
+                Console.Beep(noteC5, standardDurationMs);
+                Console.Beep(noteB4, standardDurationMs);
+                Console.Beep(noteA4, standardDurationMs);
+                Console.Beep(noteG4, standardDurationMs);
+                Console.Beep(noteF4, standardDurationMs);
+                Console.Beep(noteE4, standardDurationMs);
+                Console.Beep(noteD4, standardDurationMs);
+                Console.Beep(noteC4, standardDurationMs);
+            }
+        }
+    }
+}
+
+#endif

MPF.Core/Utilities/EnumExtensions.cs

@@ -1,38 +1,13 @@
-using RedumpLib.Data;
+using System;
+using System.Collections.Generic;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Utilities
 {
     public static class EnumExtensions
     {
-        /// <summary>
-        /// Determine if a system is okay if it's not detected by Windows
-        /// </summary>
-        /// <param name="system">RedumpSystem value to check</param>
-        /// <returns>True if Windows show see a disc when dumping, false otherwise</returns>
-        public static bool DetectedByWindows(this RedumpSystem? system)
-        {
-            switch (system)
-            {
-                case RedumpSystem.AmericanLaserGames3DO:
-                case RedumpSystem.AppleMacintosh:
-                case RedumpSystem.Atari3DO:
-                case RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem:
-                case RedumpSystem.NewJatreCDi:
-                case RedumpSystem.NintendoGameCube:
-                case RedumpSystem.NintendoWii:
-                case RedumpSystem.NintendoWiiU:
-                case RedumpSystem.PhilipsCDi:
-                case RedumpSystem.PhilipsCDiDigitalVideo:
-                case RedumpSystem.Panasonic3DOInteractiveMultiplayer:
-                case RedumpSystem.PanasonicM2:
-                case RedumpSystem.PioneerLaserActive:
-                case RedumpSystem.SuperAudioCD:
-                    return false;
-                default:
-                    return true;
-            }
-        }
-
         /// <summary>
         /// Determine if the media supports drive speeds
         /// </summary>
@@ -40,105 +15,35 @@ namespace MPF.Core.Utilities
         /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
         public static bool DoesSupportDriveSpeed(this MediaType? type)
         {
-            switch (type)
+            return type switch
             {
-                case MediaType.CDROM:
-                case MediaType.DVD:
-                case MediaType.GDROM:
-                case MediaType.HDDVD:
-                case MediaType.BluRay:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return true;
-                default:
-                    return false;
-            }
+                MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.GDROM
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => true,
+                _ => false,
+            };
         }
 
         /// <summary>
-        /// Determine if a system has reversed ringcodes
+        /// List all programs with their short usable names
         /// </summary>
-        /// <param name="system">RedumpSystem value to check</param>
-        /// <returns>True if the system has reversed ringcodes, false otherwise</returns>
-        public static bool HasReversedRingcodes(this RedumpSystem? system)
+        public static List<string> ListPrograms()
         {
-            switch (system)
-            {
-                case RedumpSystem.SonyPlayStation2:
-                case RedumpSystem.SonyPlayStation3:
-                case RedumpSystem.SonyPlayStation4:
-                //case RedumpSystem.SonyPlayStation5:
-                    return true;
-                default:
-                    return false;
-            }
-        }
+            var programs = new List<string>();
 
-        /// <summary>
-        /// Determine if a system is considered audio-only
-        /// </summary>
-        /// <param name="system">RedumpSystem value to check</param>
-        /// <returns>True if the system is audio-only, false otherwise</returns>
-        /// <remarks>
-        /// Philips CD-i should NOT be in this list. It's being included until there's a
-        /// reasonable distinction between CD-i and CD-i ready on the database side.
-        /// </remarks>
-        public static bool IsAudio(this RedumpSystem? system)
-        {
-            switch (system)
+            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
             {
-                case RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem:
-                case RedumpSystem.AudioCD:
-                case RedumpSystem.DVDAudio:
-                case RedumpSystem.HasbroVideoNow:
-                case RedumpSystem.HasbroVideoNowColor:
-                case RedumpSystem.HasbroVideoNowJr:
-                case RedumpSystem.HasbroVideoNowXP:
-                case RedumpSystem.PhilipsCDi:
-                case RedumpSystem.SuperAudioCD:
-                    return true;
-                default:
-                    return false;
-            }
-        }
+                if (((InternalProgram)val!) == InternalProgram.NONE)
+                    continue;
 
-        /// <summary>
-        /// Determine if a system is a marker value
-        /// </summary>
-        /// <param name="system">RedumpSystem value to check</param>
-        /// <returns>True if the system is a marker value, false otherwise</returns>
-        public static bool IsMarker(this RedumpSystem? system)
-        {
-            switch (system)
-            {
-                case RedumpSystem.MarkerArcadeEnd:
-                case RedumpSystem.MarkerComputerEnd:
-                case RedumpSystem.MarkerDiscBasedConsoleEnd:
-                // case RedumpSystem.MarkerOtherConsoleEnd:
-                case RedumpSystem.MarkerOtherEnd:
-                    return true;
-                default:
-                    return false;
+                programs.Add($"{((InternalProgram?)val).LongName()}");
             }
-        }
 
-        /// <summary>
-        /// Determine if a system is considered XGD
-        /// </summary>
-        /// <param name="system">RedumpSystem value to check</param>
-        /// <returns>True if the system is XGD, false otherwise</returns>
-        public static bool IsXGD(this RedumpSystem? system)
-        {
-            switch (system)
-            {
-                case RedumpSystem.MicrosoftXbox:
-                case RedumpSystem.MicrosoftXbox360:
-                case RedumpSystem.MicrosoftXboxOne:
-                case RedumpSystem.MicrosoftXboxSeriesXS:
-                    return true;
-                default:
-                    return false;
-            }
+            return programs;
         }
     }
 }

MPF.Core/Utilities/Logging.cs

@@ -14,7 +14,13 @@ namespace MPF.Core.Utilities
         /// <param name="reader">TextReader representing the input</param>
         /// <param name="baseClass">Invoking class, passed on to the event handler</param>
         /// <param name="handler">Event handler to be invoked to write to log</param>
-        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<string> handler)
+#if NET20 || NET35
+        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<Modules.BaseParameters.StringEventArgs>? handler)
+#elif NET40
+        public static void OutputToLog(TextReader reader, object baseClass, EventHandler<Modules.BaseParameters.StringEventArgs>? handler)
+#else
+        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<string>? handler)
+#endif
         {
             // Initialize the required variables
             char[] buffer = new char[256];
@@ -26,7 +32,15 @@ namespace MPF.Core.Utilities
                 while (true)
                 {
                     // Try to read the next chunk of characters
+#if NET20 || NET35
+                    read = await Task.Run(() => reader.Read(buffer, 0, buffer.Length));
+#elif NET40
+                    var readTask = Task.Factory.StartNew(() => reader.Read(buffer, 0, buffer.Length));
+                    readTask.Wait();
+                    read = readTask.Result;
+#else
                     read = await reader.ReadAsync(buffer, 0, buffer.Length);
+#endif
                     if (read == 0)
                     {
                         Thread.Sleep(10);
@@ -34,25 +48,41 @@ namespace MPF.Core.Utilities
                     }
 
                     // Convert the characters into a string
-                    string line = new string(buffer, 0, read);
+                    string line = new(buffer, 0, read);
 
                     // If we have no newline characters, store in the string builder
+#if NETFRAMEWORK
                     if (!line.Contains("\r") && !line.Contains("\n"))
+#else
+                    if (!line.Contains('\r') && !line.Contains('\n'))
+#endif
                         sb.Append(line);
 
                     // If we have a newline, append and log
+#if NETFRAMEWORK
                     else if (line.Contains("\n") || line.Contains("\r\n"))
+#else
+                    else if (line.Contains('\n') || line.Contains("\r\n"))
+#endif
                         ProcessNewLines(sb, line, baseClass, handler);
 
                     // If we have a carriage return only, append and log first and last instances
+#if NETFRAMEWORK
                     else if (line.Contains("\r"))
+#else
+                    else if (line.Contains('\r'))
+#endif
                         ProcessCarriageReturns(sb, line, baseClass, handler);
                 }
             }
             catch { }
             finally
             {
+#if NET20 || NET35 || NET40
+                handler?.Invoke(baseClass, new Modules.BaseParameters.StringEventArgs { Value = sb.ToString() });
+#else
                 handler?.Invoke(baseClass, sb.ToString());
+#endif
             }
         }
 
@@ -63,14 +93,22 @@ namespace MPF.Core.Utilities
         /// <param name="line">Current line to process</param>
         /// <param name="baseClass">Invoking class, passed on to the event handler</param>
         /// <param name="handler">Event handler to be invoked to write to log</param>
-        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+#if NET20 || NET35 || NET40
+        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<Modules.BaseParameters.StringEventArgs>? handler)
+#else
+        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<string>? handler)
+#endif
         {
             line = line.Replace("\r\n", "\n");
             var split = line.Split('\n');
             for (int i = 0; i < split.Length; i++)
             {
                 // If the chunk contains a carriage return, handle it like a separate line
+#if NETFRAMEWORK
                 if (split[i].Contains("\r"))
+#else
+                if (split[i].Contains('\r'))
+#endif
                 {
                     ProcessCarriageReturns(sb, split[i], baseClass, handler);
                     continue;
@@ -80,8 +118,13 @@ namespace MPF.Core.Utilities
                 if (i == 0)
                 {
                     sb.Append(split[i]);
+#if NET20 || NET35 || NET40
+                    handler?.Invoke(baseClass, new Modules.BaseParameters.StringEventArgs { Value = sb.ToString() });
+                    sb = new();
+#else
                     handler?.Invoke(baseClass, sb.ToString());
                     sb.Clear();
+#endif
                 }
 
                 // For the last item, just append so it's dealt with the next time
@@ -93,7 +136,11 @@ namespace MPF.Core.Utilities
                 // For everything else, directly write out
                 else
                 {
+#if NET20 || NET35 || NET40
+                    handler?.Invoke(baseClass, new Modules.BaseParameters.StringEventArgs { Value = split[i] });
+#else
                     handler?.Invoke(baseClass, split[i]);
+#endif
                 }
             }
         }
@@ -105,16 +152,25 @@ namespace MPF.Core.Utilities
         /// <param name="line">Current line to process</param>
         /// <param name="baseClass">Invoking class, passed on to the event handler</param>
         /// <param name="handler">Event handler to be invoked to write to log</param>
-        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+#if NET20 || NET35 || NET40
+        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<Modules.BaseParameters.StringEventArgs>? handler)
+#else
+        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<string>? handler)
+#endif
         {
             var split = line.Split('\r');
 
             // Append and log the first
             sb.Append(split[0]);
+#if NET20 || NET35 || NET40
+            handler?.Invoke(baseClass, new Modules.BaseParameters.StringEventArgs { Value = sb.ToString() });
+            sb = new();
+#else
             handler?.Invoke(baseClass, sb.ToString());
+            sb.Clear();
+#endif
 
             // Append the last
-            sb.Clear();
             sb.Append($"\r{split[split.Length - 1]}");
         }
     }

MPF.Core/Utilities/OptionsLoader.cs

@@ -0,0 +1,294 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Utilities
+{
+    public static class OptionsLoader
+    {
+        private const string ConfigurationPath = "config.json";
+
+        #region Arguments
+
+        /// <summary>
+        /// Process any standalone arguments for the program
+        /// </summary>
+        /// <returns>True if one of the arguments was processed, false otherwise</returns>
+        public static bool? ProcessStandaloneArguments(string[] args)
+        {
+            // Help options
+            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?")
+                return false;
+
+            // List options
+            if (args[0] == "-lm" || args[0] == "--listmedia")
+            {
+                Console.WriteLine("Supported Media Types:");
+                foreach (string mediaType in Extensions.ListMediaTypes())
+                {
+                    Console.WriteLine(mediaType);
+                }
+                Console.ReadLine();
+                return true;
+            }
+            else if (args[0] == "-lp" || args[0] == "--listprograms")
+            {
+                Console.WriteLine("Supported Programs:");
+                foreach (string program in EnumExtensions.ListPrograms())
+                {
+                    Console.WriteLine(program);
+                }
+                Console.ReadLine();
+                return true;
+            }
+            else if (args[0] == "-ls" || args[0] == "--listsystems")
+            {
+                Console.WriteLine("Supported Systems:");
+                foreach (string system in Extensions.ListSystems())
+                {
+                    Console.WriteLine(system);
+                }
+                Console.ReadLine();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Process common arguments for all functionality
+        /// </summary>
+        /// <returns>True if all arguments pass, false otherwise</returns>
+        public static (bool, MediaType, RedumpSystem?, string?) ProcessCommonArguments(string[] args)
+        {
+            // All other use requires at least 3 arguments
+            if (args.Length < 3)
+                return (false, MediaType.NONE, null, "Invalid number of arguments");
+
+            // Check the MediaType
+            var mediaType = EnumConverter.ToMediaType(args[0].Trim('"'));
+            if (mediaType == MediaType.NONE)
+                return (false, MediaType.NONE, null, $"{args[0]} is not a recognized media type");
+
+            // Check the RedumpSystem
+            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
+            if (knownSystem == null)
+                return (false, MediaType.NONE, null, $"{args[1]} is not a recognized system");
+
+            return (true, mediaType, knownSystem, null);
+        }
+
+        /// <summary>
+        /// Load the current set of options from application arguments
+        /// </summary>
+        public static (Options, SubmissionInfo?, string?, int) LoadFromArguments(string[] args, int startIndex = 0)
+        {
+            // Create the output values with defaults
+            var options = new Options()
+            {
+                RedumpUsername = null,
+                RedumpPassword = null,
+                InternalProgram = InternalProgram.NONE,
+                AddFilenameSuffix = false,
+                OutputSubmissionJSON = false,
+                CompressLogFiles = false,
+                DeleteUnnecessaryFiles = false,
+            };
+
+            // Create the submission info to return, if necessary
+            SubmissionInfo? info = null;
+            string? parsedPath = null;
+
+            // These values require multiple parts to be active
+            bool scan = false, protectFile = false, hideDriveLetters = false;
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+                return (options, null, null, 0);
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return (options, null, null, startIndex);
+
+            // Loop through the arguments and parse out values
+            for (; startIndex < args.Length; startIndex++)
+            {
+                // Use specific program
+                if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    string internalProgram = args[startIndex].Split('=')[1];
+                    options.InternalProgram = EnumConverter.ToInternalProgram(internalProgram);
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = EnumConverter.ToInternalProgram(internalProgram);
+                    startIndex++;
+                }
+
+                // Redump login
+                else if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--credentials="))
+                {
+                    string[] credentials = args[startIndex].Split('=')[1].Split(';');
+                    options.RedumpUsername = credentials[0];
+                    options.RedumpPassword = credentials[1];
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--credentials")
+                {
+                    options.RedumpUsername = args[startIndex + 1];
+                    options.RedumpPassword = args[startIndex + 2];
+                    startIndex += 2;
+                }
+
+                // Pull all information (requires Redump login)
+                else if (args[startIndex].Equals("-a") || args[startIndex].Equals("--pull-all"))
+                {
+                    options.PullAllInformation = true;
+                }
+
+                // Use a device path for physical checks
+                else if (args[startIndex].StartsWith("-p=") || args[startIndex].StartsWith("--path="))
+                {
+                    parsedPath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-p" || args[startIndex] == "--path")
+                {
+                    parsedPath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Scan for protection (requires device path)
+                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
+                {
+                    scan = true;
+                }
+
+                // Output protection to separate file (requires scan for protection)
+                else if (args[startIndex].Equals("-f") || args[startIndex].Equals("--protect-file"))
+                {
+                    protectFile = true;
+                }
+
+                // Hide drive letters from scan output (requires --protect-file)
+                else if (args[startIndex].Equals("-g") || args[startIndex].Equals("--hide-drive-letters"))
+                {
+                    hideDriveLetters = true;
+                }
+
+                // Include seed info file
+                else if (args[startIndex].StartsWith("-l=") || args[startIndex].StartsWith("--load-seed="))
+                {
+                    string seedInfo = args[startIndex].Split('=')[1];
+                    info = Builder.CreateFromFile(seedInfo);
+                }
+                else if (args[startIndex] == "-l" || args[startIndex] == "--load-seed")
+                {
+                    string seedInfo = args[startIndex + 1];
+                    info = Builder.CreateFromFile(seedInfo);
+                    startIndex++;
+                }
+
+                // Add filename suffix
+                else if (args[startIndex].Equals("-x") || args[startIndex].Equals("--suffix"))
+                {
+                    options.AddFilenameSuffix = true;
+                }
+
+                // Output submission JSON
+                else if (args[startIndex].Equals("-j") || args[startIndex].Equals("--json"))
+                {
+                    options.OutputSubmissionJSON = true;
+                }
+
+                // Compress log and extraneous files
+                else if (args[startIndex].Equals("-z") || args[startIndex].Equals("--zip"))
+                {
+                    options.CompressLogFiles = true;
+                }
+
+                // Delete unnecessary files files
+                else if (args[startIndex].Equals("-d") || args[startIndex].Equals("--delete"))
+                {
+                    options.DeleteUnnecessaryFiles = true;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            // Now deal with the complex options
+            options.ScanForProtection = scan && !string.IsNullOrEmpty(parsedPath);
+            options.OutputSeparateProtectionFile = scan && protectFile && !string.IsNullOrEmpty(parsedPath);
+            options.HideDriveLetters = hideDriveLetters && scan && protectFile && !string.IsNullOrEmpty(parsedPath);
+
+            return (options, info, parsedPath, startIndex);
+        }
+
+        /// <summary>
+        /// Return a list of supported arguments and descriptions
+        /// </summary>
+        public static List<string> PrintSupportedArguments()
+        {
+            var supportedArguments = new List<string>
+            {
+                "-u, --use <program>            Dumping program output type [REQUIRED]",
+                "-c, --credentials <user> <pw>  Redump username and password",
+                "-a, --pull-all                 Pull all information from Redump (requires --credentials)",
+                "-p, --path <drivepath>         Physical drive path for additional checks",
+                "-s, --scan                     Enable copy protection scan (requires --path)",
+                "-f, --protect-file             Output protection to separate file (requires --scan)",
+                "-g, --hide-drive-letters       Hide drive letters from scan output (requires --protect-file)",
+                "-l, --load-seed <path>         Load a seed submission JSON for user information",
+                "-x, --suffix                   Enable adding filename suffix",
+                "-j, --json                     Enable submission JSON output",
+                "-z, --zip                      Enable log file compression",
+                "-d, --delete                   Enable unnecessary file deletion",
+            };
+
+            return supportedArguments;
+        }
+
+        #endregion
+
+        #region Configuration
+
+        /// <summary>
+        /// Load the current set of options from the application configuration
+        /// </summary>
+        public static Options LoadFromConfig()
+        {
+            if (!File.Exists(ConfigurationPath))
+            {
+                _ = File.Create(ConfigurationPath);
+                return new Options();
+            }
+
+            var serializer = JsonSerializer.Create();
+            var stream = File.Open(ConfigurationPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var reader = new StreamReader(stream);
+            var settings = serializer.Deserialize(reader, typeof(Dictionary<string, string?>)) as Dictionary<string, string?>;
+            return new Options(settings);
+        }
+
+        /// <summary>
+        /// Save the current set of options to the application configuration
+        /// </summary>
+        public static void SaveToConfig(Options options)
+        {
+            var serializer = JsonSerializer.Create();
+            var sw = new StreamWriter(ConfigurationPath) { AutoFlush = true };
+            var writer = new JsonTextWriter(sw) { Formatting = Formatting.Indented };
+            serializer.Serialize(writer, options.Settings, typeof(Dictionary<string, string>));
+        }
+
+        #endregion
+    }
+}

MPF.Core/Utilities/Tools.cs

@@ -1,9 +1,10 @@
 using System;
+using System.IO;
 using System.Net;
 using System.Reflection;
 using MPF.Core.Data;
 using Newtonsoft.Json.Linq;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Utilities
 {
@@ -71,6 +72,36 @@ namespace MPF.Core.Utilities
             return true;
         }
 
+        /// <summary>
+        /// Converts a hex string into a byte array
+        /// </summary>
+        /// <param name="hex">Hex string</param>
+        /// <returns>Converted byte array, or null if invalid hex string</returns>
+        public static byte[]? HexStringToByteArray(string? hexString)
+        {
+            // Valid hex string must be an even number of characters
+            if (string.IsNullOrEmpty(hexString) || hexString!.Length % 2 == 1)
+                return null;
+
+            // Convert ASCII to byte via lookup table
+            int[] hexLookup = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F];
+            byte[] byteArray = new byte[hexString.Length / 2];
+            for (int i = 0; i < hexString.Length; i += 2)
+            {
+                // Convert next two chars to ASCII value relative to '0'
+                int a = Char.ToUpper(hexString[i]) - '0';
+                int b = Char.ToUpper(hexString[i + 1]) - '0';
+
+                // Ensure hex string only has '0' through '9' and 'A' through 'F' (case insensitive)
+                if ((a < 0 || b < 0 || a > 22 || b > 22) || (a > 10 && a < 17) || (b > 10 && b < 17))
+                    return null;
+                byteArray[i / 2] = (byte)(hexLookup[a] << 4 | hexLookup[b]);
+            }
+
+            return byteArray;
+        }
+
         #endregion
 
         #region Support
@@ -85,38 +116,84 @@ namespace MPF.Core.Utilities
                 return Result.Failure("Please select a valid system");
 
             // If we're on an unsupported type, update the status accordingly
-            switch (type)
+            return type switch
             {
                 // Fully supported types
-                case MediaType.BluRay:
-                case MediaType.CDROM:
-                case MediaType.DVD:
-                case MediaType.FloppyDisk:
-                case MediaType.HardDisk:
-                case MediaType.CompactFlash:
-                case MediaType.SDCard:
-                case MediaType.FlashDrive:
-                case MediaType.HDDVD:
-                    return Result.Success($"{type.LongName()} ready to dump");
+                MediaType.BluRay
+                    or MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.FloppyDisk
+                    or MediaType.HardDisk
+                    or MediaType.CompactFlash
+                    or MediaType.SDCard
+                    or MediaType.FlashDrive
+                    or MediaType.HDDVD => Result.Success($"{type.LongName()} ready to dump"),
 
                 // Partially supported types
-                case MediaType.GDROM:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return Result.Success($"{type.LongName()} partially supported for dumping");
+                MediaType.GDROM
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => Result.Success($"{type.LongName()} partially supported for dumping"),
 
                 // Special case for other supported tools
-                case MediaType.UMD:
-                    return Result.Failure($"{type.LongName()} supported for submission info parsing");
+                MediaType.UMD => Result.Failure($"{type.LongName()} supported for submission info parsing"),
 
                 // Specifically unknown type
-                case MediaType.NONE:
-                    return Result.Failure($"Please select a valid media type");
+                MediaType.NONE => Result.Failure($"Please select a valid media type"),
 
                 // Undumpable but recognized types
-                default:
-                    return Result.Failure($"{type.LongName()} media are not supported for dumping");
-            }
+                _ => Result.Failure($"{type.LongName()} media are not supported for dumping"),
+            };
+        }
+
+        /// <summary>
+        /// Returns false if a given InternalProgram does not support a given MediaType
+        /// </summary>
+        public static bool ProgramSupportsMedia(InternalProgram program, MediaType? type)
+        {
+            // If the media type is not set, return false
+            if (type == null || type == MediaType.NONE)
+                return false;
+
+            return (program) switch
+            {
+                // Aaru
+                InternalProgram.Aaru when type == MediaType.BluRay => true,
+                InternalProgram.Aaru when type == MediaType.CDROM => true,
+                InternalProgram.Aaru when type == MediaType.CompactFlash => true,
+                InternalProgram.Aaru when type == MediaType.DVD => true,
+                InternalProgram.Aaru when type == MediaType.GDROM => true,
+                InternalProgram.Aaru when type == MediaType.FlashDrive => true,
+                InternalProgram.Aaru when type == MediaType.FloppyDisk => true,
+                InternalProgram.Aaru when type == MediaType.HardDisk => true,
+                InternalProgram.Aaru when type == MediaType.HDDVD => true,
+                InternalProgram.Aaru when type == MediaType.NintendoGameCubeGameDisc => true,
+                InternalProgram.Aaru when type == MediaType.NintendoWiiOpticalDisc => true,
+                InternalProgram.Aaru when type == MediaType.SDCard => true,
+
+                // DiscImageCreator
+                InternalProgram.DiscImageCreator when type == MediaType.BluRay => true,
+                InternalProgram.DiscImageCreator when type == MediaType.CDROM => true,
+                InternalProgram.DiscImageCreator when type == MediaType.CompactFlash => true,
+                InternalProgram.DiscImageCreator when type == MediaType.DVD => true,
+                InternalProgram.DiscImageCreator when type == MediaType.GDROM => true,
+                InternalProgram.DiscImageCreator when type == MediaType.FlashDrive => true,
+                InternalProgram.DiscImageCreator when type == MediaType.FloppyDisk => true,
+                InternalProgram.DiscImageCreator when type == MediaType.HardDisk => true,
+                InternalProgram.DiscImageCreator when type == MediaType.HDDVD => true,
+                InternalProgram.DiscImageCreator when type == MediaType.NintendoGameCubeGameDisc => true,
+                InternalProgram.DiscImageCreator when type == MediaType.NintendoWiiOpticalDisc => true,
+                InternalProgram.DiscImageCreator when type == MediaType.SDCard => true,
+
+                // Redumper
+                InternalProgram.Redumper when type == MediaType.BluRay => true,
+                InternalProgram.Redumper when type == MediaType.CDROM => true,
+                InternalProgram.Redumper when type == MediaType.DVD => true,
+                InternalProgram.Redumper when type == MediaType.GDROM => true,
+                InternalProgram.Redumper when type == MediaType.HDDVD => true,
+
+                // Default
+                _ => false,
+            };
         }
 
         #endregion
@@ -131,17 +208,20 @@ namespace MPF.Core.Utilities
         /// String representing the message to display the the user.
         /// String representing the new release URL.
         /// </returns>
-        public static (bool different, string message, string url) CheckForNewVersion()
+        public static (bool different, string message, string? url) CheckForNewVersion()
         {
             try
             {
                 // Get current assembly version
-                var assemblyVersion = Assembly.GetEntryAssembly().GetName().Version;
-                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}" + (assemblyVersion.Build != 0 ? $".{assemblyVersion.Build}" : string.Empty);
+                var assemblyVersion = Assembly.GetEntryAssembly()?.GetName()?.Version;
+                if (assemblyVersion == null)
+                    return (false, "Assembly version could not be determined", null);
+
+                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}";
 
                 // Get the latest tag from GitHub
-                (string tag, string url) = GetRemoteVersionAndUrl();
-                bool different = version != tag;
+                var (tag, url) = GetRemoteVersionAndUrl();
+                bool different = version != tag && tag != null;
 
                 string message = $"Local version: {version}"
                     + $"{Environment.NewLine}Remote version: {tag}"
@@ -160,30 +240,405 @@ namespace MPF.Core.Utilities
         /// <summary>
         /// Get the current informational version formatted as a string
         /// </summary>
-        public static string GetCurrentVersion()
+        public static string? GetCurrentVersion()
         {
-            var assemblyVersion = Attribute.GetCustomAttribute(Assembly.GetEntryAssembly(), typeof(AssemblyInformationalVersionAttribute)) as AssemblyInformationalVersionAttribute;
-            return assemblyVersion.InformationalVersion;
+            try
+            {
+                var assembly = Assembly.GetEntryAssembly();
+                if (assembly == null)
+                    return null;
+
+                var assemblyVersion = Attribute.GetCustomAttribute(assembly, typeof(AssemblyInformationalVersionAttribute)) as AssemblyInformationalVersionAttribute;
+                return assemblyVersion?.InformationalVersion;
+            }
+            catch (Exception ex)
+            {
+                return ex.ToString();
+            }
         }
 
         /// <summary>
         /// Get the latest version of MPF from GitHub and the release URL
         /// </summary>
-        private static (string tag, string url) GetRemoteVersionAndUrl()
+        private static (string? tag, string? url) GetRemoteVersionAndUrl()
         {
-            using (WebClient wc = new WebClient())
+#if NET20 || NET35 || NET40
+            // Not supported in .NET Frameworks 2.0, 3.5, or 4.0
+            return (null, null);
+#else
+            using var hc = new System.Net.Http.HttpClient();
+#if NET452
+            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
+#endif
+
+            // TODO: Figure out a better way than having this hardcoded...
+            string url = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
+            var message = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, url);
+            message.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0");
+            var latestReleaseJsonString = hc.SendAsync(message)?.ConfigureAwait(false).GetAwaiter().GetResult()
+                .Content?.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            if (latestReleaseJsonString == null)
+                return (null, null);
+
+            var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
+            if (latestReleaseJson == null)
+                return (null, null);
+
+            var latestTag = latestReleaseJson["tag_name"]?.ToString();
+            var releaseUrl = latestReleaseJson["html_url"]?.ToString();
+
+            return (latestTag, releaseUrl);
+#endif
+        }
+
+        #endregion
+
+        #region PlayStation 3 specific tools
+
+        /// <summary>
+        /// Validates a getkey log to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="logPath">Path to getkey log file</param>
+        /// <param name="key">Output key string, null if not valid</param>
+        /// <param name="id">Output disc ID string, null if not valid</param>
+        /// <param name="pic">Output PIC string, null if not valid</param>
+        /// <returns>True if path to log file contains valid key, false otherwise</returns>
+        public static bool ParseGetKeyLog(string? logPath, out string? key, out string? id, out string? pic)
+        {
+            key = id = pic = null;
+
+            if (string.IsNullOrEmpty(logPath))
+                return false;
+
+            try
             {
-                wc.Headers["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0";
+                if (!File.Exists(logPath))
+                    return false;
 
-                // TODO: Figure out a better way than having this hardcoded...
-                string url = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
-                string latestReleaseJsonString = wc.DownloadString(url);
-                var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
-                string latestTag = latestReleaseJson["tag_name"].ToString();
-                string releaseUrl = latestReleaseJson["html_url"].ToString();
+                // Protect from attempting to read from really long files
+                FileInfo logFile = new(logPath);
+                if (logFile.Length > 65536)
+                    return false;
 
-                return (latestTag, releaseUrl);
+                // Read from .getkey.log file
+                using StreamReader sr = File.OpenText(logPath);
+
+                // Determine whether GetKey was successful
+                string? line;
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("get_dec_key succeeded!") == false) ;
+                if (line == null)
+                    return false;
+
+                // Look for Disc Key in log
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_key = ") == false) ;
+
+                // If end of file reached, no key found
+                if (line == null)
+                    return false;
+
+                // Get Disc Key from log
+                string discKeyStr = line.Substring("disc_key = ".Length);
+
+                // Validate Disc Key from log
+                if (discKeyStr.Length != 32)
+                    return false;
+
+                // Convert Disc Key to byte array
+                key = discKeyStr;
+                if (key == null)
+                    return false;
+
+                // Read Disc ID
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_id = ") == false) ;
+
+                // If end of file reached, no ID found
+                if (line == null)
+                    return false;
+
+                // Get Disc ID from log
+                string discIDStr = line.Substring("disc_id = ".Length);
+
+                // Validate Disc ID from log
+                if (discIDStr.Length != 32)
+                    return false;
+
+                // Replace X's in Disc ID with 00000001
+                discIDStr = discIDStr.Substring(0, 24) + "00000001";
+
+                // Convert Disc ID to byte array
+                id = discIDStr;
+                if (id == null)
+                    return false;
+
+                // Look for PIC in log
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("PIC:") == false) ;
+
+                // If end of file reached, no PIC found
+                if (line == null)
+                    return false;
+
+                // Get PIC from log
+                string discPICStr = "";
+                for (int i = 0; i < 9; i++)
+                    discPICStr += sr.ReadLine();
+                if (discPICStr == null)
+                    return false;
+
+                // Validate PIC from log
+                if (discPICStr.Length != 264)
+                    return false;
+
+                // Convert PIC to byte array
+                pic = discPICStr;
+                if (pic == null)
+                    return false;
+
+                // Double check for warnings in .getkey.log
+                while ((line = sr.ReadLine()) != null)
+                {
+                    string t = line.Trim();
+                    if (t.StartsWith("WARNING"))
+                        return false;
+                    else if (t.StartsWith("SUCCESS"))
+                        return true;
+                }
             }
+            catch
+            {
+                // We are not concerned with the error
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Validates a getkey log to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="logPath">Path to getkey log file</param>
+        /// <param name="key">Output 16 byte disc key, null if not valid</param>
+        /// <param name="id">Output 16 byte disc ID, null if not valid</param>
+        /// <param name="pic">Output 230 byte PIC, null if not valid</param>
+        /// <returns>True if path to log file contains valid key, false otherwise</returns>
+        public static bool ParseGetKeyLog(string? logPath, out byte[]? key, out byte[]? id, out byte[]? pic)
+        {
+            key = id = pic = null;
+            if (ParseGetKeyLog(logPath, out string? keyString, out string? idString, out string? picString))
+            {
+                if (string.IsNullOrEmpty(keyString) || string.IsNullOrEmpty(idString) || string.IsNullOrEmpty(picString) || picString!.Length < 230)
+                    return false;
+
+                key = Tools.HexStringToByteArray(keyString);
+                id = Tools.HexStringToByteArray(idString);
+                pic = Tools.HexStringToByteArray(picString.Substring(0, 230));
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Validates a hexadecimal disc ID
+        /// </summary>
+        /// <param name="discID">String representing hexadecimal disc ID</param>
+        /// <returns>True if string is a valid disc ID, false otherwise</returns>
+        public static byte[]? ParseDiscID(string? discID)
+        {
+            if (string.IsNullOrEmpty(discID))
+                return null;
+
+            string cleandiscID = discID!.Trim().Replace("\n", string.Empty);
+
+            if (discID!.Length != 32)
+                return null;
+
+            // Censor last 4 bytes by replacing with 0x00000001
+            cleandiscID = cleandiscID.Substring(0, 24) + "00000001";
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? id = Tools.HexStringToByteArray(cleandiscID);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Validates a key file to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="keyPath">Path to key file</param>
+        /// <returns>Output 16 byte key, null if not valid</returns>
+        public static byte[]? ParseKeyFile(string? keyPath)
+        {
+            if (string.IsNullOrEmpty(keyPath))
+                return null;
+
+            // Try read from key file
+            try
+            {
+                if (!File.Exists(keyPath))
+                    return null;
+
+                // Key file must be exactly 16 bytes long
+                FileInfo keyFile = new(keyPath);
+                if (keyFile.Length != 16)
+                    return null;
+                byte[] key = new byte[16];
+
+                // Read 16 bytes from Key file
+                using FileStream fs = new(keyPath, FileMode.Open, FileAccess.Read);
+                using BinaryReader reader = new(fs);
+                int numBytes = reader.Read(key, 0, 16);
+                if (numBytes != 16)
+                    return null;
+
+                return key;
+            }
+            catch
+            {
+                // Not concerned with error
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Validates a hexadecimal key
+        /// </summary>
+        /// <param name="hexKey">String representing hexadecimal key</param>
+        /// <returns>Output 16 byte key, null if not valid</returns>
+        public static byte[]? ParseHexKey(string? hexKey)
+        {
+            if (string.IsNullOrEmpty(hexKey))
+                return null;
+
+            string cleanHexKey = hexKey!.Trim().Replace("\n", string.Empty);
+
+            if (cleanHexKey.Length != 32)
+                return null;
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? key = Tools.HexStringToByteArray(cleanHexKey);
+
+            return key;
+        }
+
+        /// <summary>
+        /// Validates a PIC file path
+        /// </summary>
+        /// <param name="picPath">Path to PIC file</param>
+        /// <returns>Output PIC byte array, null if not valid</returns>
+        public static byte[]? ParsePICFile(string? picPath)
+        {
+            if (string.IsNullOrEmpty(picPath))
+                return null;
+
+            // Try read from PIC file
+            try
+            {
+                if (!File.Exists(picPath))
+                    return null;
+
+                // PIC file must be at least 115 bytes long
+                FileInfo picFile = new(picPath);
+                if (picFile.Length < 115)
+                    return null;
+                byte[] pic = new byte[115];
+
+                // Read 115 bytes from PIC file
+                using FileStream fs = new(picPath, FileMode.Open, FileAccess.Read);
+                using BinaryReader reader = new(fs);
+                int numBytes = reader.Read(pic, 0, 115);
+                if (numBytes != 115)
+                    return null;
+
+                // Validate that a PIC was read by checking first 6 bytes
+                if (pic[0] != 0x10 ||
+                    pic[1] != 0x02 ||
+                    pic[2] != 0x00 ||
+                    pic[3] != 0x00 ||
+                    pic[4] != 0x44 ||
+                    pic[5] != 0x49)
+                    return null;
+
+                return pic;
+            }
+            catch
+            {
+                // Not concerned with error
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Validates a PIC
+        /// </summary>
+        /// <param name="inputPIC">String representing PIC</param>
+        /// <returns>Output PIC byte array, null if not valid</returns>
+        public static byte[]? ParsePIC(string? inputPIC)
+        {
+            if (string.IsNullOrEmpty(inputPIC))
+                return null;
+
+            string cleanPIC = inputPIC!.Trim().Replace("\n", string.Empty);
+
+            if (cleanPIC.Length < 230)
+                return null;
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? pic = Tools.HexStringToByteArray(cleanPIC.Substring(0, 230));
+
+            return pic;
+        }
+
+        /// <summary>
+        /// Validates a string representing a layerbreak value (in sectors)
+        /// </summary>
+        /// <param name="inputLayerbreak">String representing layerbreak value</param>
+        /// <param name="layerbreak">Output layerbreak value, null if not valid</param>
+        /// <returns>True if layerbreak is valid, false otherwise</returns>
+        public static long? ParseLayerbreak(string? inputLayerbreak)
+        {
+            if (string.IsNullOrEmpty(inputLayerbreak))
+                return null;
+
+            if (!long.TryParse(inputLayerbreak, out long layerbreak))
+                return null;
+
+            return ParseLayerbreak(layerbreak);
+        }
+
+        /// <summary>
+        /// Validates a layerbreak value (in sectors)
+        /// </summary>
+        /// <param name="inputLayerbreak">Number representing layerbreak value</param>
+        /// <param name="layerbreak">Output layerbreak value, null if not valid</param>
+        /// <returns>True if layerbreak is valid, false otherwise</returns>
+        public static long? ParseLayerbreak(long? layerbreak)
+        {
+            // Check that layerbreak is positive number and smaller than largest disc size (in sectors)
+            if (layerbreak <= 0 || layerbreak > 24438784)
+                return null;
+
+            return layerbreak;
+        }
+
+        /// <summary>
+        /// Converts a CRC32 hash hex string into uint32 representation
+        /// </summary>
+        /// <param name="inputLayerbreak">Hex string representing CRC32 hash</param>
+        /// <param name="layerbreak">Output CRC32 value, null if not valid</param>
+        /// <returns>True if CRC32 hash string is valid, false otherwise</returns>
+        public static uint? ParseCRC32(string? inputCRC32)
+        {
+            if (string.IsNullOrEmpty(inputCRC32))
+                return null;
+
+            byte[]? crc32 = Tools.HexStringToByteArray(inputCRC32);
+
+            if (crc32 == null || crc32.Length != 4)
+                return null;
+
+            return (uint)(0x01000000 * crc32[0] + 0x00010000 * crc32[1] + 0x00000100 * crc32[2] + 0x00000001 * crc32[3]);
         }
 
         #endregion

MPF.CueSheets/CueFile.cs

@@ -1,238 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// The audio or data file’s filetype
-    /// </summary>
-    public enum CueFileType
-    {
-        /// <summary>
-        /// Intel binary file (least significant byte first). Use for data files.
-        /// </summary>
-        BINARY,
-
-        /// <summary>
-        /// Motorola binary file (most significant byte first). Use for data files.
-        /// </summary>
-        MOTOROLA,
-
-        /// <summary>
-        /// Audio AIFF file (44.1KHz 16-bit stereo)
-        /// </summary>
-        AIFF,
-
-        /// <summary>
-        /// Audio WAVE file (44.1KHz 16-bit stereo)
-        /// </summary>
-        WAVE,
-
-        /// <summary>
-        /// Audio MP3 file (44.1KHz 16-bit stereo)
-        /// </summary>
-        MP3,
-    }
-
-    /// <summary>
-    /// Represents a single FILE in a cuesheet
-    /// </summary>
-    public class CueFile
-    {
-        /// <summary>
-        /// filename
-        /// </summary>
-        public string FileName { get; set; }
-
-        /// <summary>
-        /// filetype
-        /// </summary>
-        public CueFileType FileType { get; set; }
-
-        /// <summary>
-        /// List of TRACK in FILE
-        /// </summary>
-        public List<CueTrack> Tracks { get; set; }
-
-        /// <summary>
-        /// Create an empty FILE
-        /// </summary>
-        public CueFile()
-        {
-        }
-
-        /// <summary>
-        /// Fill a FILE from an array of lines
-        /// </summary>
-        /// <param name="fileName">File name to set</param>
-        /// <param name="fileType">File type to set</param>
-        /// <param name="cueLines">Lines array to pull from</param>
-        /// <param name="i">Reference to index in array</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public CueFile(string fileName, string fileType, string[] cueLines, ref int i, bool throwOnError = false)
-        {
-            if (cueLines == null)
-            {
-                if (throwOnError)
-                    throw new ArgumentNullException(nameof(cueLines));
-
-                return;
-            }
-            else if (i < 0 || i > cueLines.Length)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException();
-
-                return;
-            }
-
-            // Set the current fields
-            this.FileName = fileName.Trim('"');
-            this.FileType = GetFileType(fileType);
-
-            // Increment to start
-            i++;
-
-            for (; i < cueLines.Length; i++)
-            {
-                string line = cueLines[i].Trim();
-                string[] splitLine = line.Split(' ');
-
-                // If we have an empty line, we skip
-                if (string.IsNullOrWhiteSpace(line))
-                    continue;
-
-                switch (splitLine[0])
-                {
-                    // Read comments
-                    case "REM":
-                        // We ignore all comments for now
-                        break;
-
-                    // Read track information
-                    case "TRACK":
-                        if (splitLine.Length < 3)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"TRACK line malformed: {line}");
-
-                            continue;
-                        }
-
-                        if (this.Tracks == null)
-                            this.Tracks = new List<CueTrack>();
-
-                        var track = new CueTrack(splitLine[1], splitLine[2], cueLines, ref i);
-                        if (track == default)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"TRACK line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Tracks.Add(track);
-                        break;
-
-                    // Default means return
-                    default:
-                        i--;
-                        return;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Write the FILE out to a stream
-        /// </summary>
-        /// <param name="sw">StreamWriter to write to</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public void Write(StreamWriter sw, bool throwOnError = false)
-        {
-            // If we don't have any tracks, it's invalid
-            if (this.Tracks == null)
-            {
-                if (throwOnError)
-                    throw new ArgumentNullException(nameof(this.Tracks));
-
-                return;
-            }
-            else if (this.Tracks.Count == 0)
-            {
-                if (throwOnError)
-                    throw new ArgumentException("No tracks provided to write");
-
-                return;
-            }
-
-            sw.WriteLine($"FILE \"{this.FileName}\" {FromFileType(this.FileType)}");
-
-            foreach (var track in Tracks)
-            {
-                track.Write(sw);
-            }
-        }
-
-        /// <summary>
-        /// Get the file type from a given string
-        /// </summary>
-        /// <param name="fileType">String to get value from</param>
-        /// <returns>CueFileType, if possible</returns>
-        private CueFileType GetFileType(string fileType)
-        {
-            switch (fileType.ToLowerInvariant())
-            {
-                case "binary":
-                    return CueFileType.BINARY;
-
-                case "motorola":
-                    return CueFileType.MOTOROLA;
-
-                case "aiff":
-                    return CueFileType.AIFF;
-
-                case "wave":
-                    return CueFileType.WAVE;
-
-                case "mp3":
-                    return CueFileType.MP3;
-
-                default:
-                    return CueFileType.BINARY;
-            }
-        }
-
-        /// <summary>
-        /// Get the string from a given file type
-        /// </summary>
-        /// <param name="fileType">CueFileType to get value from</param>
-        /// <returns>String, if possible (default BINARY)</returns>
-        private string FromFileType(CueFileType fileType)
-        {
-            switch (fileType)
-            {
-                case CueFileType.BINARY:
-                    return "BINARY";
-
-                case CueFileType.MOTOROLA:
-                    return "MOTOROLA";
-
-                case CueFileType.AIFF:
-                    return "AIFF";
-
-                case CueFileType.WAVE:
-                    return "WAVE";
-
-                case CueFileType.MP3:
-                    return "MP3";
-
-                default:
-                    return string.Empty;
-            }
-        }
-    }
-}

MPF.CueSheets/CueIndex.cs

@@ -1,163 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// Represents a single INDEX in a TRACK
-    /// </summary>
-    public class CueIndex
-    {
-        /// <summary>
-        /// INDEX number, between 0 and 99
-        /// </summary>
-        public int Index { get; set; }
-
-        /// <summary>
-        /// Starting time of INDEX in minutes
-        /// </summary>
-        public int Minutes { get; set; }
-
-        /// <summary>
-        /// Starting time of INDEX in seconds
-        /// </summary>
-        /// <remarks>There are 60 seconds in a minute</remarks>
-        public int Seconds { get; set; }
-
-        /// <summary>
-        /// Starting time of INDEX in frames.
-        /// </summary>
-        /// <remarks>There are 75 frames per second</remarks>
-        public int Frames { get; set; }
-
-        /// <summary>
-        /// Create an empty INDEX
-        /// </summary>
-        public CueIndex()
-        {
-        }
-
-        /// <summary>
-        /// Fill a INDEX from an array of lines
-        /// </summary>
-        /// <param name="index">Index to set</param>
-        /// <param name="startTime">Start time to set</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public CueIndex(string index, string startTime, bool throwOnError = false)
-        {
-            // Set the current fields
-            if (!int.TryParse(index, out int parsedIndex))
-            {
-                if (throwOnError)
-                    throw new ArgumentException($"Index was not a number: {index}");
-
-                return;
-            }
-            else if (parsedIndex < 0 || parsedIndex > 99)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Index must be between 0 and 99: {parsedIndex}");
-
-                return;
-            }
-
-            // Ignore empty lines
-            if (string.IsNullOrWhiteSpace(startTime))
-            {
-                if (throwOnError)
-                    throw new ArgumentException("Start time was null or whitespace");
-
-                return;
-            }
-
-            // Ignore lines that don't contain the correct information
-            if (startTime.Length != 8 || startTime.Count(c => c == ':') != 2)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Start time was not in a recognized format: {startTime}");
-
-                return;
-            }
-
-            // Split the line
-            string[] splitTime = startTime.Split(':');
-            if (splitTime.Length != 3)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Start time was not in a recognized format: {startTime}");
-
-                return;
-            }
-
-            // Parse the lengths
-            int[] lengthSegments = new int[3];
-
-            // Minutes
-            if (!int.TryParse(splitTime[0], out lengthSegments[0]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Minutes segment was not a number: {splitTime[0]}");
-
-                return;
-            }
-            else if (lengthSegments[0] < 0)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
-
-                return;
-            }
-
-            // Seconds
-            if (!int.TryParse(splitTime[1], out lengthSegments[1]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Seconds segment was not a number: {splitTime[1]}");
-
-                return;
-            }
-            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
-
-                return;
-            }
-
-            // Frames
-            if (!int.TryParse(splitTime[2], out lengthSegments[2]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Frames segment was not a number: {splitTime[2]}");
-
-                return;
-            }
-            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
-
-                return;
-            }
-
-            // Set the values
-            this.Index = parsedIndex;
-            this.Minutes = lengthSegments[0];
-            this.Seconds = lengthSegments[1];
-            this.Frames = lengthSegments[2];
-        }
-
-        /// <summary>
-        /// Write the INDEX out to a stream
-        /// </summary>
-        /// <param name="sw">StreamWriter to write to</param>
-        public void Write(StreamWriter sw)
-        {
-            sw.WriteLine($"    INDEX {this.Index:D2} {this.Minutes:D2}:{this.Seconds:D2}:{this.Frames:D2}");
-        }
-    }
-}

MPF.CueSheets/CueSheet.cs

@@ -1,250 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// Represents a single cuesheet
-    /// </summary>
-    public class CueSheet
-    {
-        /// <summary>
-        /// CATALOG
-        /// </summary>
-        public string Catalog { get; set; }
-
-        /// <summary>
-        /// CDTEXTFILE
-        /// </summary>
-        public string CdTextFile { get; set; }
-
-        /// <summary>
-        /// PERFORMER
-        /// </summary>
-        public string Performer { get; set; }
-
-        /// <summary>
-        /// SONGWRITER
-        /// </summary>
-        public string Songwriter { get; set; }
-
-        /// <summary>
-        /// TITLE
-        /// </summary>
-        public string Title { get; set; }
-
-        /// <summary>
-        /// List of FILE in cuesheet
-        /// </summary>
-        public List<CueFile> Files { get; set; }
-
-        /// <summary>
-        /// Create an empty cuesheet
-        /// </summary>
-        public CueSheet()
-        {
-        }
-
-        /// <summary>
-        /// Create a cuesheet from a file, if possible
-        /// </summary>
-        /// <param name="filename"></param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public CueSheet(string filename, bool throwOnError = false)
-        {
-            // Check that the file exists
-            if (!File.Exists(filename))
-                return;
-
-            // Check the extension
-            string ext = Path.GetExtension(filename).TrimStart('.');
-            if (!string.Equals(ext, "cue", StringComparison.OrdinalIgnoreCase)
-                && !string.Equals(ext, "txt", StringComparison.OrdinalIgnoreCase))
-            {
-                return;
-            }
-
-            // Open the file and begin reading
-            string[] cueLines = File.ReadAllLines(filename);
-            for (int i = 0; i < cueLines.Length; i++)
-            {
-                string line = cueLines[i].Trim();
-
-                // http://stackoverflow.com/questions/554013/regular-expression-to-split-on-spaces-unless-in-quotes
-                string[] splitLine = Regex
-                    .Matches(line, @"[^\s""]+|""[^""]*""")
-                    .Cast<Match>()
-                    .Select(m => m.Groups[0].Value)
-                    .ToArray();
-
-                // If we have an empty line, we skip
-                if (string.IsNullOrWhiteSpace(line))
-                    continue;
-
-                switch (splitLine[0])
-                {
-                    // Read comments
-                    case "REM":
-                        // We ignore all comments for now
-                        break;
-
-                    // Read MCN
-                    case "CATALOG":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"CATALOG line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Catalog = splitLine[1];
-                        break;
-
-                    // Read external CD-Text file path
-                    case "CDTEXTFILE":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"CDTEXTFILE line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.CdTextFile = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced performer
-                    case "PERFORMER":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"PERFORMER line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Performer = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced songwriter
-                    case "SONGWRITER":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"SONGWRITER line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Songwriter = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced title
-                    case "TITLE":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"TITLE line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Title = splitLine[1];
-                        break;
-
-                    // Read file information
-                    case "FILE":
-                        if (splitLine.Length < 3)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"FILE line malformed: {line}");
-
-                            continue;
-                        }
-
-                        if (this.Files == null)
-                            this.Files = new List<CueFile>();
-
-                        var file = new CueFile(splitLine[1], splitLine[2], cueLines, ref i);
-                        if (file == default)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"FILE line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Files.Add(file);
-                        break;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Write the cuesheet out to a file
-        /// </summary>
-        /// <param name="filename">File path to write to</param>
-        public void Write(string filename)
-        {
-            using (var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
-            {
-                Write(fs);
-            }
-        }
-
-        /// <summary>
-        /// Write the cuesheet out to a stream
-        /// </summary>
-        /// <param name="stream">Stream to write to</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public void Write(Stream stream, bool throwOnError = false)
-        {
-            // If we don't have any files, it's invalid
-            if (this.Files == null)
-            {
-                if (throwOnError)
-                    throw new ArgumentNullException(nameof(this.Files));
-
-                return;
-            }
-            else if (this.Files.Count == 0)
-            {
-                if (throwOnError)
-                    throw new ArgumentException("No files provided to write");
-
-                return;
-            }
-
-            using (var sw = new StreamWriter(stream, Encoding.ASCII, 1024, true))
-            {
-                if (!string.IsNullOrEmpty(this.Catalog))
-                    sw.WriteLine($"CATALOG {this.Catalog}");
-
-                if (!string.IsNullOrEmpty(this.CdTextFile))
-                    sw.WriteLine($"CDTEXTFILE {this.CdTextFile}");
-
-                if (!string.IsNullOrEmpty(this.Performer))
-                    sw.WriteLine($"PERFORMER {this.Performer}");
-
-                if (!string.IsNullOrEmpty(this.Songwriter))
-                    sw.WriteLine($"SONGWRITER {this.Songwriter}");
-
-                if (!string.IsNullOrEmpty(this.Title))
-                    sw.WriteLine($"TITLE {this.Title}");
-
-                foreach (var file in Files)
-                {
-                    file.Write(sw);
-                }
-            }
-        }
-    }
-}

MPF.CueSheets/CueTrack.cs

@@ -1,554 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// Track datatype
-    /// </summary>
-    public enum CueTrackDataType
-    {
-        /// <summary>
-        /// AUDIO, Audio/Music (2352)
-        /// </summary>
-        AUDIO,
-
-        /// <summary>
-        /// CDG, Karaoke CD+G (2448)
-        /// </summary>
-        CDG,
-
-        /// <summary>
-        /// MODE1/2048, CD-ROM Mode1 Data (cooked)
-        /// </summary>
-        MODE1_2048,
-
-        /// <summary>
-        /// MODE1/2352 CD-ROM Mode1 Data (raw)
-        /// </summary>
-        MODE1_2352,
-
-        /// <summary>
-        /// MODE2/2336, CD-ROM XA Mode2 Data
-        /// </summary>
-        MODE2_2336,
-
-        /// <summary>
-        /// MODE2/2352, CD-ROM XA Mode2 Data
-        /// </summary>
-        MODE2_2352,
-
-        /// <summary>
-        /// CDI/2336, CD-I Mode2 Data
-        /// </summary>
-        CDI_2336,
-
-        /// <summary>
-        /// CDI/2352, CD-I Mode2 Data
-        /// </summary>
-        CDI_2352,
-    }
-
-    /// <summary>
-    /// Special subcode flags within a track
-    /// </summary>
-    [Flags]
-    public enum CueTrackFlag
-    {
-        /// <summary>
-        /// DCP, Digital copy permitted
-        /// </summary>
-        DCP = 1 << 0,
-
-        /// <summary>
-        /// 4CH, Four channel audio
-        /// </summary>
-        FourCH = 1 << 1,
-
-        /// <summary>
-        /// PRE, Pre-emphasis enabled (audio tracks only)
-        /// </summary>
-        PRE = 1 << 2,
-
-        /// <summary>
-        /// SCMS, Serial Copy Management System (not supported by all recorders)
-        /// </summary>
-        SCMS = 1 << 3,
-
-        /// <summary>
-        /// DATA, set for data files. This flag is set automatically based on the track’s filetype
-        /// </summary>
-        DATA = 1 << 4,
-    }
-
-    /// <summary>
-    /// Represents a single TRACK in a FILE
-    /// </summary>
-    public class CueTrack
-    {
-        /// <summary>
-        /// Track number. The range is 1 to 99.
-        /// </summary>
-        public int Number { get; set; }
-
-        /// <summary>
-        /// Track datatype
-        /// </summary>
-        public CueTrackDataType DataType { get; set; }
-
-        /// <summary>
-        /// FLAGS
-        /// </summary>
-        public CueTrackFlag Flags { get; set; }
-
-        /// <summary>
-        /// ISRC
-        /// </summary>
-        /// <remarks>12 characters in length</remarks>
-        public string ISRC { get; set; }
-
-        /// <summary>
-        /// PERFORMER
-        /// </summary>
-        public string Performer { get; set; }
-
-        /// <summary>
-        /// SONGWRITER
-        /// </summary>
-        public string Songwriter { get; set; }
-
-        /// <summary>
-        /// TITLE
-        /// </summary>
-        public string Title { get; set; }
-
-        /// <summary>
-        /// PREGAP
-        /// </summary>
-        public PreGap PreGap { get; set; }
-
-        /// <summary>
-        /// List of INDEX in TRACK
-        /// </summary>
-        /// <remarks>Must start with 0 or 1 and then sequential</remarks>
-        public List<CueIndex> Indices { get; set; }
-
-        /// <summary>
-        /// POSTGAP
-        /// </summary>
-        public PostGap PostGap { get; set; }
-
-        /// <summary>
-        /// Create an empty TRACK
-        /// </summary>
-        public CueTrack()
-        {
-        }
-
-        /// <summary>
-        /// Fill a TRACK from an array of lines
-        /// </summary>
-        /// <param name="number">Number to set</param>
-        /// <param name="dataType">Data type to set</param>
-        /// <param name="cueLines">Lines array to pull from</param>
-        /// <param name="i">Reference to index in array</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public CueTrack(string number, string dataType, string[] cueLines, ref int i, bool throwOnError = false)
-        {
-            if (cueLines == null)
-            {
-                if (throwOnError)
-                    throw new ArgumentNullException(nameof(cueLines));
-
-                return;
-            }
-            else if (i < 0 || i > cueLines.Length)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException();
-
-                return;
-            }
-
-            // Set the current fields
-            if (!int.TryParse(number, out int parsedNumber))
-            {
-                if (throwOnError)
-                    throw new ArgumentException($"Number was not a number: {number}");
-
-                return;
-            }
-            else if (parsedNumber < 1 || parsedNumber > 99)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Index must be between 1 and 99: {parsedNumber}");
-
-                return;
-            }
-
-            this.Number = parsedNumber;
-            this.DataType = GetDataType(dataType);
-
-            // Increment to start
-            i++;
-
-            for (; i < cueLines.Length; i++)
-            {
-                string line = cueLines[i].Trim();
-                string[] splitLine = line.Split(' ');
-
-                // If we have an empty line, we skip
-                if (string.IsNullOrWhiteSpace(line))
-                    continue;
-
-                switch (splitLine[0])
-                {
-                    // Read comments
-                    case "REM":
-                        // We ignore all comments for now
-                        break;
-
-                    // Read flag information
-                    case "FLAGS":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"FLAGS line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Flags = GetFlags(splitLine);
-                        break;
-
-                    // Read International Standard Recording Code
-                    case "ISRC":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"ISRC line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.ISRC = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced performer
-                    case "PERFORMER":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"PERFORMER line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Performer = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced songwriter
-                    case "SONGWRITER":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"SONGWRITER line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Songwriter = splitLine[1];
-                        break;
-
-                    // Read CD-Text enhanced title
-                    case "TITLE":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"TITLE line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Title = splitLine[1];
-                        break;
-
-                    // Read pregap information
-                    case "PREGAP":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"PREGAP line malformed: {line}");
-
-                            continue;
-                        }
-
-                        var pregap = new PreGap(splitLine[1]);
-                        if (pregap == default)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"PREGAP line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.PreGap = pregap;
-                        break;
-
-                    // Read index information
-                    case "INDEX":
-                        if (splitLine.Length < 3)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"INDEX line malformed: {line}");
-
-                            continue;
-                        }
-
-                        if (this.Indices == null)
-                            this.Indices = new List<CueIndex>();
-
-                        var index = new CueIndex(splitLine[1], splitLine[2]);
-                        if (index == default)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"INDEX line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.Indices.Add(index);
-                        break;
-
-                    // Read postgap information
-                    case "POSTGAP":
-                        if (splitLine.Length < 2)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"POSTGAP line malformed: {line}");
-
-                            continue;
-                        }
-
-                        var postgap = new PostGap(splitLine[1]);
-                        if (postgap == default)
-                        {
-                            if (throwOnError)
-                                throw new FormatException($"POSTGAP line malformed: {line}");
-
-                            continue;
-                        }
-
-                        this.PostGap = postgap;
-                        break;
-
-                    // Default means return
-                    default:
-                        i--;
-                        return;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Write the TRACK out to a stream
-        /// </summary>
-        /// <param name="sw">StreamWriter to write to</param
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public void Write(StreamWriter sw, bool throwOnError = false)
-        {
-            // If we don't have any indices, it's invalid
-            if (this.Indices == null)
-            {
-                if (throwOnError)
-                    throw new ArgumentNullException(nameof(this.Indices));
-
-                return;
-            }
-            else if (this.Indices.Count == 0)
-            {
-                if (throwOnError)
-                    throw new ArgumentException("No indices provided to write");
-
-                return;
-            }
-
-            sw.WriteLine($"  TRACK {this.Number:D2} {FromDataType(this.DataType)}");
-
-            if (this.Flags != 0)
-                sw.WriteLine($"    FLAGS {FromFlags(this.Flags)}");
-
-            if (!string.IsNullOrEmpty(this.ISRC))
-                sw.WriteLine($"ISRC {this.ISRC}");
-
-            if (!string.IsNullOrEmpty(this.Performer))
-                sw.WriteLine($"PERFORMER {this.Performer}");
-
-            if (!string.IsNullOrEmpty(this.Songwriter))
-                sw.WriteLine($"SONGWRITER {this.Songwriter}");
-
-            if (!string.IsNullOrEmpty(this.Title))
-                sw.WriteLine($"TITLE {this.Title}");
-
-            if (this.PreGap != null)
-                this.PreGap.Write(sw);
-
-            foreach (var index in Indices)
-            {
-                index.Write(sw);
-            }
-
-            if (this.PostGap != null)
-                this.PostGap.Write(sw);
-        }
-
-        /// <summary>
-        /// Get the data type from a given string
-        /// </summary>
-        /// <param name="dataType">String to get value from</param>
-        /// <returns>CueTrackDataType, if possible (default AUDIO)</returns>
-        private CueTrackDataType GetDataType(string dataType)
-        {
-            switch (dataType.ToLowerInvariant())
-            {
-                case "audio":
-                    return CueTrackDataType.AUDIO;
-
-                case "cdg":
-                    return CueTrackDataType.CDG;
-
-                case "mode1/2048":
-                    return CueTrackDataType.MODE1_2048;
-
-                case "mode1/2352":
-                    return CueTrackDataType.MODE1_2352;
-
-                case "mode2/2336":
-                    return CueTrackDataType.MODE2_2336;
-
-                case "mode2/2352":
-                    return CueTrackDataType.MODE2_2352;
-
-                case "cdi/2336":
-                    return CueTrackDataType.CDI_2336;
-
-                case "cdi/2352":
-                    return CueTrackDataType.CDI_2352;
-
-                default:
-                    return CueTrackDataType.AUDIO;
-            }
-        }
-
-        /// <summary>
-        /// Get the string from a given data type
-        /// </summary>
-        /// <param name="dataType">CueTrackDataType to get value from</param>
-        /// <returns>string, if possible</returns>
-        private string FromDataType(CueTrackDataType dataType)
-        {
-            switch (dataType)
-            {
-                case CueTrackDataType.AUDIO:
-                    return "AUDIO";
-
-                case CueTrackDataType.CDG:
-                    return "CDG";
-
-                case CueTrackDataType.MODE1_2048:
-                    return "MODE1/2048";
-
-                case CueTrackDataType.MODE1_2352:
-                    return "MODE1/2352";
-
-                case CueTrackDataType.MODE2_2336:
-                    return "MODE2/2336";
-
-                case CueTrackDataType.MODE2_2352:
-                    return "MODE2/2352";
-
-                case CueTrackDataType.CDI_2336:
-                    return "CDI/2336";
-
-                case CueTrackDataType.CDI_2352:
-                    return "CDI/2352";
-
-                default:
-                    return string.Empty;
-            }
-        }
-
-        /// <summary>
-        /// Get the flag value for an array of strings
-        /// </summary>
-        /// <param name="flagStrings">Possible flags as strings</param>
-        /// <returns>CueTrackFlag value representing the strings, if possible</returns>
-        private CueTrackFlag GetFlags(string[] flagStrings)
-        {
-            CueTrackFlag flag = 0;
-
-            foreach (string flagString in flagStrings)
-            {
-                switch (flagString.ToLowerInvariant())
-                {
-                    case "flags":
-                        // No-op since this is the start of the line
-                        break;
-
-                    case "dcp":
-                        flag |= CueTrackFlag.DCP;
-                        break;
-
-                    case "4ch":
-                        flag |= CueTrackFlag.FourCH;
-                        break;
-
-                    case "pre":
-                        flag |= CueTrackFlag.PRE;
-                        break;
-
-                    case "scms":
-                        flag |= CueTrackFlag.SCMS;
-                        break;
-
-                    case "data":
-                        flag |= CueTrackFlag.DATA;
-                        break;
-                }
-            }
-
-            return flag;
-        }
-
-        /// <summary>
-        /// Get the string value for a set of track flags
-        /// </summary>
-        /// <param name="flags">CueTrackFlag to get value from</param>
-        /// <returns>String value representing the CueTrackFlag, if possible</returns>
-        private string FromFlags(CueTrackFlag flags)
-        {
-            string outputFlagString = string.Empty;
-
-            if (flags.HasFlag(CueTrackFlag.DCP))
-                outputFlagString += "DCP ";
-
-            if (flags.HasFlag(CueTrackFlag.FourCH))
-                outputFlagString += "4CH ";
-
-            if (flags.HasFlag(CueTrackFlag.PRE))
-                outputFlagString += "PRE ";
-
-            if (flags.HasFlag(CueTrackFlag.SCMS))
-                outputFlagString += "SCMS ";
-
-            if (flags.HasFlag(CueTrackFlag.DATA))
-                outputFlagString += "DATA ";
-
-            return outputFlagString.Trim();
-        }
-    }
-}

MPF.CueSheets/MPF.CueSheets.csproj

@@ -1,30 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2021</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.3</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-</Project>

MPF.CueSheets/PostGap.cs

@@ -1,139 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// Represents POSTGAP information of a track
-    /// </summary>
-    public class PostGap
-    {
-        /// <summary>
-        /// Length of POSTGAP in minutes
-        /// </summary>
-        public int Minutes { get; set; }
-
-        /// <summary>
-        /// Length of POSTGAP in seconds
-        /// </summary>
-        /// <remarks>There are 60 seconds in a minute</remarks>
-        public int Seconds { get; set; }
-
-        /// <summary>
-        /// Length of POSTGAP in frames.
-        /// </summary>
-        /// <remarks>There are 75 frames per second</remarks>
-        public int Frames { get; set; }
-
-        /// Create an empty POSTGAP
-        /// </summary>
-        public PostGap()
-        {
-        }
-
-        /// <summary>
-        /// Create a POSTGAP from a mm:ss:ff length
-        /// </summary>
-        /// <param name="length">String to get length information from</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public PostGap(string length, bool throwOnError = false)
-        {
-            // Ignore empty lines
-            if (string.IsNullOrWhiteSpace(length))
-            {
-                if (throwOnError)
-                    throw new ArgumentException("Length was null or whitespace");
-
-                return;
-            }
-
-            // Ignore lines that don't contain the correct information
-            if (length.Length != 8 || length.Count(c => c == ':') != 2)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Length was not in a recognized format: {length}");
-
-                return;
-            }
-
-            // Split the line
-            string[] splitLength = length.Split(':');
-            if (splitLength.Length != 3)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Length was not in a recognized format: {length}");
-
-                return;
-            }
-
-            // Parse the lengths
-            int[] lengthSegments = new int[3];
-
-            // Minutes
-            if (!int.TryParse(splitLength[0], out lengthSegments[0]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Minutes segment was not a number: {splitLength[0]}");
-
-                return;
-            }
-            else if (lengthSegments[0] < 0)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
-
-                return;
-            }
-
-            // Seconds
-            if (!int.TryParse(splitLength[1], out lengthSegments[1]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Seconds segment was not a number: {splitLength[1]}");
-
-                return;
-            }
-            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
-
-                return;
-            }
-
-            // Frames
-            if (!int.TryParse(splitLength[2], out lengthSegments[2]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Frames segment was not a number: {splitLength[2]}");
-
-                return;
-            }
-            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
-
-                return;
-            }
-
-            // Set the values
-            this.Minutes = lengthSegments[0];
-            this.Seconds = lengthSegments[1];
-            this.Frames = lengthSegments[2];
-        }
-
-        /// <summary>
-        /// Write the POSTGAP out to a stream
-        /// </summary>
-        /// <param name="sw">StreamWriter to write to</param>
-        public void Write(StreamWriter sw)
-        {
-            sw.WriteLine($"    POSTGAP {this.Minutes:D2}:{this.Seconds:D2}:{this.Frames:D2}");
-        }
-    }
-}

MPF.CueSheets/PreGap.cs

@@ -1,140 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-
-/// <remarks>
-/// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
-/// </remarks>
-namespace MPF.CueSheets
-{
-    /// <summary>
-    /// Represents PREGAP information of a track
-    /// </summary>
-    public class PreGap
-    {
-        /// <summary>
-        /// Length of PREGAP in minutes
-        /// </summary>
-        public int Minutes { get; set; }
-
-        /// <summary>
-        /// Length of PREGAP in seconds
-        /// </summary>
-        /// <remarks>There are 60 seconds in a minute</remarks>
-        public int Seconds { get; set; }
-
-        /// <summary>
-        /// Length of PREGAP in frames.
-        /// </summary>
-        /// <remarks>There are 75 frames per second</remarks>
-        public int Frames { get; set; }
-
-        /// <summary>
-        /// Create an empty PREGAP
-        /// </summary>
-        public PreGap()
-        {
-        }
-
-        /// <summary>
-        /// Create a PREGAP from a mm:ss:ff length
-        /// </summary>
-        /// <param name="length">String to get length information from</param>
-        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
-        public PreGap(string length, bool throwOnError = false)
-        {
-            // Ignore empty lines
-            if (string.IsNullOrWhiteSpace(length))
-            {
-                if (throwOnError)
-                    throw new ArgumentException("Length was null or whitespace");
-
-                return;
-            }
-
-            // Ignore lines that don't contain the correct information
-            if (length.Length != 8 || length.Count(c => c == ':') != 2)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Length was not in a recognized format: {length}");
-
-                return;
-            }
-
-            // Split the line
-            string[] splitLength = length.Split(':');
-            if (splitLength.Length != 3)
-            {
-                if (throwOnError)
-                    throw new FormatException($"Length was not in a recognized format: {length}");
-
-                return;
-            }
-
-            // Parse the lengths
-            int[] lengthSegments = new int[3];
-
-            // Minutes
-            if (!int.TryParse(splitLength[0], out lengthSegments[0]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Minutes segment was not a number: {splitLength[0]}");
-
-                return;
-            }
-            else if (lengthSegments[0] < 0)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
-
-                return;
-            }
-
-            // Seconds
-            if (!int.TryParse(splitLength[1], out lengthSegments[1]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Seconds segment was not a number: {splitLength[1]}");
-
-                return;
-            }
-            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
-
-                return;
-            }
-
-            // Frames
-            if (!int.TryParse(splitLength[2], out lengthSegments[2]))
-            {
-                if (throwOnError)
-                    throw new FormatException($"Frames segment was not a number: {splitLength[2]}");
-
-                return;
-            }
-            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-            {
-                if (throwOnError)
-                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
-
-                return;
-            }
-
-            // Set the values
-            this.Minutes = lengthSegments[0];
-            this.Seconds = lengthSegments[1];
-            this.Frames = lengthSegments[2];
-        }
-
-        /// <summary>
-        /// Write the PREGAP out to a stream
-        /// </summary>
-        /// <param name="sw">StreamWriter to write to</param>
-        public void Write(StreamWriter sw)
-        {
-            sw.WriteLine($"    PREGAP {this.Minutes:D2}:{this.Seconds:D2}:{this.Frames:D2}");
-        }
-    }
-}

MPF.Library/AssemblyInfo.cs

@@ -1,4 +0,0 @@
-using System.Runtime.CompilerServices;
-
-// Anything marked as internal can be used by the test methods
-[assembly: InternalsVisibleTo("MPF.Test")]

MPF.Library/MPF.Library.csproj

@@ -1,50 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
-    <AssemblyName>MPF.Library</AssemblyName>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2021</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.3</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
-    <DefineConstants>NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
-    <ProjectReference Include="..\MPF.Modules\MPF.Modules.csproj" />
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.8.0" GeneratePathProperty="true">
-      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="System.IO.Compression" Version="4.3.0" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-  
-  <ItemGroup>
-    <Content Include="$(PkgBurnOutSharp)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
-  </ItemGroup>
-
-</Project>

MPF.Modules/AssemblyInfo.cs

@@ -1,4 +0,0 @@
-using System.Runtime.CompilerServices;
-
-// Anything marked as internal can be used by the test methods
-[assembly: InternalsVisibleTo("MPF.Test")]

MPF.Modules/CleanRIp/Parameters.cs

@@ -1,306 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using MPF.Core.Data;
-using RedumpLib.Data;
-
-namespace MPF.Modules.CleanRip
-{
-    /// <summary>
-    /// Represents a generic set of CleanRip parameters
-    /// </summary>
-    public class Parameters : BaseParameters
-    {
-        #region Metadata
-
-        /// <inheritdoc/>
-        public override InternalProgram InternalProgram => InternalProgram.CleanRip;
-
-        #endregion
-
-        /// <inheritdoc/>
-        public Parameters(string parameters) : base(parameters) { }
-
-        /// <inheritdoc/>
-        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
-            : base(system, type, driveLetter, filename, driveSpeed, options)
-        {
-        }
-
-        #region BaseParameters Implementations
-
-        /// <inheritdoc/>
-        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
-        {
-            List<string> missingFiles = new List<string>();
-            switch (this.Type)
-            {
-                case MediaType.DVD: // Only added here to help users; not strictly correct
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    if (!File.Exists($"{basePath}_logs.zip") || !preCheck)
-                    {
-                        if (!File.Exists($"{basePath}-dumpinfo.txt"))
-                            missingFiles.Add($"{basePath}-dumpinfo.txt");
-                        if (!File.Exists($"{basePath}.bca"))
-                            missingFiles.Add($"{basePath}.bca");
-                    }
-
-                    break;
-
-                default:
-                    missingFiles.Add("Media and system combination not supported for CleanRip");
-                    break;
-            }
-
-            return (!missingFiles.Any(), missingFiles);
-        }
-
-        /// <inheritdoc/>
-        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, Drive drive, bool includeArtifacts)
-        {
-            info.TracksAndWriteOffsets.ClrMameProData = GetCleanripDatfile(basePath + ".iso", basePath + "-dumpinfo.txt");
-            
-            // Get the individual hash data, as per internal
-            if (GetISOHashValues(info.TracksAndWriteOffsets.ClrMameProData, out long size, out string crc32, out string md5, out string sha1))
-            {
-                info.SizeAndChecksums.Size = size;
-                info.SizeAndChecksums.CRC32 = crc32;
-                info.SizeAndChecksums.MD5 = md5;
-                info.SizeAndChecksums.SHA1 = sha1;
-
-                // Dual-layer discs have the same size and layerbreak
-                if (size == 8511160320)
-                    info.SizeAndChecksums.Layerbreak = 2084960;
-            }            
-
-            // Extract info based generically on MediaType
-            switch (this.Type)
-            {
-                case MediaType.DVD: // Only added here to help users; not strictly correct
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    if (File.Exists(basePath + ".bca"))
-                        info.Extras.BCA = GetBCA(basePath + ".bca");
-
-                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out Region? gcRegion, out string gcVersion))
-                    {
-                        info.CommonDiscInfo.Region = gcRegion ?? info.CommonDiscInfo.Region;
-                        info.VersionAndEditions.Version = gcVersion ?? info.VersionAndEditions.Version;
-                    }
-
-                    break;
-            }
-
-            // Fill in any artifacts that exist, Base64-encoded, if we need to
-            if (includeArtifacts)
-            {
-                if (File.Exists(basePath + ".bca"))
-                    info.Artifacts["bca"] = GetBase64(GetFullFile(basePath + ".bca", binary: true));
-                if (File.Exists(basePath + "-dumpinfo.txt"))
-                    info.Artifacts["dumpinfo"] = GetBase64(GetFullFile(basePath + "-dumpinfo.txt"));
-            }
-        }
-
-        /// <inheritdoc/>
-        public override List<string> GetLogFilePaths(string basePath)
-        {
-            List<string> logFiles = new List<string>();
-            switch (this.Type)
-            {
-                case MediaType.DVD: // Only added here to help users; not strictly correct
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    if (File.Exists($"{basePath}-dumpinfo.txt"))
-                        logFiles.Add($"{basePath}-dumpinfo.txt");
-                    if (File.Exists($"{basePath}.bca"))
-                        logFiles.Add($"{basePath}.bca");
-
-                    break;
-            }
-
-            return logFiles;
-        }
-
-        #endregion
-
-        #region Information Extraction Methods
-
-        /// <summary>
-        /// Get the hex contents of the BCA file
-        /// </summary>
-        /// <param name="bcaPath">Path to the BCA file associated with the dump</param>
-        /// <returns>BCA data as a hex string if possible, null on error</returns>
-        /// <remarks>https://stackoverflow.com/questions/9932096/add-separator-to-string-at-every-n-characters</remarks>
-        private static string GetBCA(string bcaPath)
-        {
-            // If the file doesn't exist, we can't get the info
-            if (!File.Exists(bcaPath))
-                return null;
-
-            try
-            {
-                string hex = GetFullFile(bcaPath, true);
-                return Regex.Replace(hex, ".{32}", "$0\n");
-            }
-            catch
-            {
-                // We don't care what the error was right now
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Get a formatted datfile from the cleanrip output, if possible
-        /// </summary>
-        /// <param name="iso">Path to ISO file</param>
-        /// <param name="dumpinfo">Path to discinfo file</param>
-        /// <returns></returns>
-        private static string GetCleanripDatfile(string iso, string dumpinfo)
-        {
-            // If the file doesn't exist, we can't get info from it
-            if (!File.Exists(dumpinfo))
-                return null;
-
-            using (StreamReader sr = File.OpenText(dumpinfo))
-            {
-                long size = new FileInfo(iso).Length;
-                string crc = string.Empty;
-                string md5 = string.Empty;
-                string sha1 = string.Empty;
-
-                try
-                {
-                    // Make sure this file is a dumpinfo
-                    if (!sr.ReadLine().Contains("--File Generated by CleanRip"))
-                        return null;
-
-                    // Read all lines and gather dat information
-                    while (!sr.EndOfStream)
-                    {
-                        string line = sr.ReadLine().Trim();
-                        if (line.StartsWith("CRC32"))
-                            crc = line.Substring(7).ToLowerInvariant();
-                        else if (line.StartsWith("MD5"))
-                            md5 = line.Substring(5);
-                        else if (line.StartsWith("SHA-1"))
-                            sha1 = line.Substring(7);
-                    }
-
-                    return $"<rom name=\"{Path.GetFileName(iso)}\" size=\"{size}\" crc=\"{crc}\" md5=\"{md5}\" sha1=\"{sha1}\" />";
-                }
-                catch
-                {
-                    // We don't care what the exception is right now
-                    return null;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Get the extracted GC and Wii version
-        /// </summary>
-        /// <param name="dumpinfo">Path to discinfo file</param>
-        /// <param name="region">Output region, if possible</param>
-        /// <param name="version">Output internal version of the game</param>
-        /// <returns></returns>
-        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string version)
-        {
-            region = null; version = null;
-
-            // If the file doesn't exist, we can't get info from it
-            if (!File.Exists(dumpinfo))
-                return false;
-
-            using (StreamReader sr = File.OpenText(dumpinfo))
-            {
-                try
-                {
-                    // Make sure this file is a dumpinfo
-                    if (!sr.ReadLine().Contains("--File Generated by CleanRip"))
-                        return false;
-
-                    // Read all lines and gather dat information
-                    while (!sr.EndOfStream)
-                    {
-                        string line = sr.ReadLine().Trim();
-                        if (line.StartsWith("Version"))
-                        {
-                            version = line.Substring(9);
-                        }
-                        else if (line.StartsWith("Filename"))
-                        {
-                            string serial = line.Substring(10);
-
-                            // char gameType = serial[0];
-                            // string gameid = serial[1] + serial[2];
-                            // string version = serial[4] + serial[5]
-
-                            switch (serial[3])
-                            {
-                                case 'A':
-                                    region = Region.World;
-                                    break;
-                                case 'D':
-                                    region = Region.Germany;
-                                    break;
-                                case 'E':
-                                    region = Region.UnitedStatesOfAmerica;
-                                    break;
-                                case 'F':
-                                    region = Region.France;
-                                    break;
-                                case 'I':
-                                    region = Region.Italy;
-                                    break;
-                                case 'J':
-                                    region = Region.Japan;
-                                    break;
-                                case 'K':
-                                    region = Region.SouthKorea;
-                                    break;
-                                case 'L':
-                                    region = Region.Europe; // Japanese import to Europe
-                                    break;
-                                case 'M':
-                                    region = Region.Europe; // American import to Europe
-                                    break;
-                                case 'N':
-                                    region = Region.UnitedStatesOfAmerica; // Japanese import to USA
-                                    break;
-                                case 'P':
-                                    region = Region.Europe;
-                                    break;
-                                case 'R':
-                                    region = Region.RussianFederation;
-                                    break;
-                                case 'S':
-                                    region = Region.Spain;
-                                    break;
-                                case 'Q':
-                                    region = Region.SouthKorea; // Korea with Japanese language
-                                    break;
-                                case 'T':
-                                    region = Region.SouthKorea; // Korea with English language
-                                    break;
-                                case 'X':
-                                    region = null; // Not a real region code
-                                    break;
-                            }
-                        }
-                    }
-
-                    return true;
-                }
-                catch
-                {
-                    // We don't care what the exception is right now
-                    return false;
-                }
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Modules/DD/Constants.cs

@@ -1,32 +0,0 @@
-namespace MPF.Modules.DD
-{
-    /// <summary>
-    /// Top-level commands for DD
-    /// </summary>
-    public static class CommandStrings
-    {
-        public const string NONE = "";
-        public const string List = "--list";
-    }
-
-    /// <summary>
-    /// Dumping flags for DD
-    /// </summary>
-    public static class FlagStrings
-    {
-        // Boolean flags
-        public const string Progress = "--progress";
-        public const string Size = "--size";
-
-        // Int64 flags
-        public const string BlockSize = "bs";
-        public const string Count = "count";
-        public const string Seek = "seek";
-        public const string Skip = "skip";
-
-        // String flags
-        public const string Filter = "--filter";
-        public const string InputFile = "if";
-        public const string OutputFile = "of";
-    }
-}

MPF.Modules/DD/Parameters.cs

@@ -1,404 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using MPF.Core.Data;
-using RedumpLib.Data;
-
-namespace MPF.Modules.DD
-{
-    /// <summary>
-    /// Represents a generic set of DD parameters
-    /// </summary>
-    public class Parameters : BaseParameters
-    {
-        #region Generic Dumping Information
-
-        /// <inheritdoc/>
-        public override string InputPath => InputFileValue?.TrimStart('\\', '?');
-
-        /// <inheritdoc/>
-        public override string OutputPath => OutputFileValue;
-
-        /// <inheritdoc/>
-        /// <inheritdoc/>
-        public override int? Speed
-        {
-            get { return 1; }
-            set { }
-        }
-
-        #endregion
-
-        #region Metadata
-
-        /// <inheritdoc/>
-        public override InternalProgram InternalProgram => InternalProgram.DD;
-
-        #endregion
-
-        #region Flag Values
-
-        public long? BlockSizeValue { get; set; }
-
-        public long? CountValue { get; set; }
-
-        // fixed, removable, disk, partition
-        public string FilterValue { get; set; }
-
-        public string InputFileValue { get; set; }
-
-        public string OutputFileValue { get; set; }
-
-        public long? SeekValue { get; set; }
-
-        public long? SkipValue { get; set; }
-
-        #endregion
-
-        /// <inheritdoc/>
-        public Parameters(string parameters) : base(parameters) { }
-
-        /// <inheritdoc/>
-        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
-            : base(system, type, driveLetter, filename, driveSpeed, options)
-        {
-        }
-
-        #region BaseParameters Implementations
-
-        /// <inheritdoc/>
-        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
-        {
-            // TODO: Figure out what sort of output files are expected... just `.bin`?
-            return (true, new List<string>());
-        }
-
-        /// <inheritdoc/>
-        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, Drive drive, bool includeArtifacts)
-        {
-            // TODO: Fill in submission info specifics for DD
-            string outputDirectory = Path.GetDirectoryName(basePath);
-
-            switch (this.Type)
-            {
-                // Determine type-specific differences
-            }
-
-            switch (this.System)
-            {
-                case RedumpSystem.KonamiPython2:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string pythonTwoSerial, out Region? pythonTwoRegion, out string pythonTwoDate))
-                    {
-                        // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = pythonTwoSerial ?? string.Empty;
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? pythonTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = pythonTwoDate;
-                    }
-
-                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
-                    break;
-
-                case RedumpSystem.SonyPlayStation:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationSerial, out Region? playstationRegion, out string playstationDate))
-                    {
-                        // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = playstationSerial ?? string.Empty;
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = playstationDate;
-                    }
-
-                    break;
-
-                case RedumpSystem.SonyPlayStation2:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationTwoSerial, out Region? playstationTwoRegion, out string playstationTwoDate))
-                    {
-                        // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = playstationTwoSerial ?? string.Empty;
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = playstationTwoDate;
-                    }
-
-                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
-                    break;
-
-                case RedumpSystem.SonyPlayStation4:
-                    info.VersionAndEditions.Version = GetPlayStation4Version(drive?.Letter) ?? "";
-                    break;
-
-                case RedumpSystem.SonyPlayStation5:
-                    info.VersionAndEditions.Version = GetPlayStation5Version(drive?.Letter) ?? "";
-                    break;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override string GenerateParameters()
-        {
-            List<string> parameters = new List<string>();
-
-            if (BaseCommand == null)
-                BaseCommand = CommandStrings.NONE;
-
-            if (!string.IsNullOrEmpty(BaseCommand))
-                parameters.Add(BaseCommand);
-
-            #region Boolean flags
-
-            // Progress
-            if (IsFlagSupported(FlagStrings.Progress))
-            {
-                if (this[FlagStrings.Progress] == true)
-                    parameters.Add($"{FlagStrings.Progress}");
-            }
-
-            // Size
-            if (IsFlagSupported(FlagStrings.Size))
-            {
-                if (this[FlagStrings.Size] == true)
-                    parameters.Add($"{FlagStrings.Size}");
-            }
-
-            #endregion
-
-            #region Int64 flags
-
-            // Block Size
-            if (IsFlagSupported(FlagStrings.BlockSize))
-            {
-                if (this[FlagStrings.BlockSize] == true && BlockSizeValue != null)
-                    parameters.Add($"{FlagStrings.BlockSize}={BlockSizeValue}");
-            }
-
-            // Count
-            if (IsFlagSupported(FlagStrings.Count))
-            {
-                if (this[FlagStrings.Count] == true && CountValue != null)
-                    parameters.Add($"{FlagStrings.Count}={CountValue}");
-            }
-
-            // Seek
-            if (IsFlagSupported(FlagStrings.Seek))
-            {
-                if (this[FlagStrings.Seek] == true && SeekValue != null)
-                    parameters.Add($"{FlagStrings.Seek}={SeekValue}");
-            }
-
-            // Skip
-            if (IsFlagSupported(FlagStrings.Skip))
-            {
-                if (this[FlagStrings.Skip] == true && SkipValue != null)
-                    parameters.Add($"{FlagStrings.Skip}={SkipValue}");
-            }
-
-            #endregion
-
-            #region String flags
-
-            // Filter
-            if (IsFlagSupported(FlagStrings.Filter))
-            {
-                if (this[FlagStrings.Filter] == true && FilterValue != null)
-                    parameters.Add($"{FlagStrings.Filter}={FilterValue}");
-            }
-
-            // Input File
-            if (IsFlagSupported(FlagStrings.InputFile))
-            {
-                if (this[FlagStrings.InputFile] == true && InputFileValue != null)
-                    parameters.Add($"{FlagStrings.InputFile}=\"{InputFileValue}\"");
-                else
-                    return null;
-            }
-
-            // Output File
-            if (IsFlagSupported(FlagStrings.OutputFile))
-            {
-                if (this[FlagStrings.OutputFile] == true && OutputFileValue != null)
-                    parameters.Add($"{FlagStrings.OutputFile}=\"{OutputFileValue}\"");
-                else
-                    return null;
-            }
-
-            #endregion
-
-            return string.Join(" ", parameters);
-        }
-
-        /// <inheritdoc/>
-        public override Dictionary<string, List<string>> GetCommandSupport()
-        {
-            return new Dictionary<string, List<string>>()
-            {
-                [CommandStrings.NONE] = new List<string>()
-                {
-                    FlagStrings.BlockSize,
-                    FlagStrings.Count,
-                    FlagStrings.Filter,
-                    FlagStrings.InputFile,
-                    FlagStrings.OutputFile,
-                    FlagStrings.Progress,
-                    FlagStrings.Seek,
-                    FlagStrings.Size,
-                    FlagStrings.Skip,
-                },
-
-                [CommandStrings.List] = new List<string>()
-                {
-                },
-            };
-        }
-
-        /// <inheritdoc/>
-        public override string GetDefaultExtension(MediaType? mediaType) => Converters.Extension(mediaType);
-
-        /// <inheritdoc/>
-        public override bool IsDumpingCommand()
-        {
-            switch (this.BaseCommand)
-            {
-                case CommandStrings.List:
-                    return false;
-                default:
-                    return true;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ResetValues()
-        {
-            BaseCommand = CommandStrings.NONE;
-
-            flags = new Dictionary<string, bool?>();
-
-            BlockSizeValue = null;
-            CountValue = null;
-            InputFileValue = null;
-            OutputFileValue = null;
-            SeekValue = null;
-            SkipValue = null;
-        }
-
-        /// <inheritdoc/>
-        protected override void SetDefaultParameters(char driveLetter, string filename, int? driveSpeed, Options options)
-        {
-            BaseCommand = CommandStrings.NONE;
-
-            this[FlagStrings.InputFile] = true;
-            InputFileValue = $"\\\\?\\{driveLetter}:";
-
-            this[FlagStrings.OutputFile] = true;
-            OutputFileValue = filename;
-
-            // TODO: Add more common block sizes
-            this[FlagStrings.BlockSize] = true;
-            switch (this.Type)
-            {
-                case MediaType.FloppyDisk:
-                    BlockSizeValue = 1440 * 1024;
-                    break;
-
-                default:
-                    BlockSizeValue = 1024 * 1024 * 1024;
-                    break;
-            }
-
-            this[FlagStrings.Progress] = true;
-            this[FlagStrings.Size] = true;
-        }
-
-        /// <inheritdoc/>
-        protected override bool ValidateAndSetParameters(string parameters)
-        {
-            BaseCommand = CommandStrings.NONE;
-
-            // The string has to be valid by itself first
-            if (string.IsNullOrWhiteSpace(parameters))
-                return false;
-
-            // Now split the string into parts for easier validation
-            // https://stackoverflow.com/questions/14655023/split-a-string-that-has-white-spaces-unless-they-are-enclosed-within-quotes
-            parameters = parameters.Trim();
-            List<string> parts = Regex.Matches(parameters, @"[\""].+?[\""]|[^ ]+")
-                .Cast<Match>()
-                .Select(m => m.Value)
-                .ToList();
-
-            // Determine what the commandline should look like given the first item
-            int start = 0;
-            if (parts[0] == CommandStrings.List)
-            {
-                BaseCommand = parts[0];
-                start = 1;
-            }
-
-            // Loop through all auxilary flags, if necessary
-            for (int i = start; i < parts.Count; i++)
-            {
-                // Flag read-out values
-                long? longValue = null;
-                string stringValue = null;
-
-                // Keep a count of keys to determine if we should break out to filename handling or not
-                int keyCount = Keys.Count();
-
-                #region Boolean flags
-
-                // Progress
-                ProcessFlagParameter(parts, FlagStrings.Progress, ref i);
-
-                // Size
-                ProcessFlagParameter(parts, FlagStrings.Size, ref i);
-
-                #endregion
-
-                #region Int64 flags
-
-                // Block Size
-                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, ref i);
-                if (longValue != null)
-                    BlockSizeValue = longValue;
-
-                // Count
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, ref i);
-                if (longValue != null)
-                    CountValue = longValue;
-
-                // Seek
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, ref i);
-                if (longValue != null)
-                    SeekValue = longValue;
-
-                // Skip
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, ref i);
-                if (longValue != null)
-                    SkipValue = longValue;
-
-                #endregion
-
-                #region String flags
-
-                // Filter (fixed, removable, disk, partition)
-                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, ref i);
-                if (!string.IsNullOrEmpty(stringValue))
-                    FilterValue = stringValue;
-
-                // Input File
-                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, ref i);
-                if (!string.IsNullOrEmpty(stringValue))
-                    InputFileValue = stringValue;
-
-                // Output File
-                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, ref i);
-                if (!string.IsNullOrEmpty(stringValue))
-                    OutputFileValue = stringValue;
-
-                #endregion
-            }
-
-            return true;
-        }
-
-        #endregion
-    }
-}

MPF.Modules/DiscImageCreator/Converters.cs

@@ -1,124 +0,0 @@
-using RedumpLib.Data;
-
-namespace MPF.Modules.DiscImageCreator
-{
-    public static class Converters
-    {
-        #region Cross-enumeration conversions
-
-        /// <summary>
-        /// Get the most common known system for a given MediaType
-        /// </summary>
-        /// <param name="baseCommand">Command value to check</param>
-        /// <returns>RedumpSystem if possible, null on error</returns>
-        public static RedumpSystem? ToRedumpSystem(string baseCommand)
-        {
-            switch (baseCommand)
-            {
-                case CommandStrings.Audio:
-                    return RedumpSystem.AudioCD;
-                case CommandStrings.CompactDisc:
-                case CommandStrings.Data:
-                case CommandStrings.DigitalVideoDisc:
-                case CommandStrings.Disk:
-                case CommandStrings.Floppy:
-                case CommandStrings.Tape:
-                    return RedumpSystem.IBMPCcompatible;
-                case CommandStrings.GDROM:
-                case CommandStrings.Swap:
-                    return RedumpSystem.SegaDreamcast;
-                case CommandStrings.BluRay:
-                    return RedumpSystem.SonyPlayStation3;
-                case CommandStrings.SACD:
-                    return RedumpSystem.SuperAudioCD;
-                case CommandStrings.XBOX:
-                case CommandStrings.XBOXSwap:
-                    return RedumpSystem.MicrosoftXbox;
-                case CommandStrings.XGD2Swap:
-                case CommandStrings.XGD3Swap:
-                    return RedumpSystem.MicrosoftXbox360;
-                default:
-                    return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the MediaType associated with a given base command
-        /// </summary>
-        /// <param name="baseCommand">Command value to check</param>
-        /// <returns>MediaType if possible, null on error</returns>
-        /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
-        public static MediaType? ToMediaType(string baseCommand)
-        {
-            switch (baseCommand)
-            {
-                case CommandStrings.Audio:
-                case CommandStrings.CompactDisc:
-                case CommandStrings.Data:
-                case CommandStrings.SACD:
-                    return MediaType.CDROM;
-                case CommandStrings.GDROM:
-                case CommandStrings.Swap:
-                    return MediaType.GDROM;
-                case CommandStrings.DigitalVideoDisc:
-                case CommandStrings.XBOX:
-                case CommandStrings.XBOXSwap:
-                case CommandStrings.XGD2Swap:
-                case CommandStrings.XGD3Swap:
-                    return MediaType.DVD;
-                case CommandStrings.BluRay:
-                    return MediaType.BluRay;
-
-                // Non-optical
-                case CommandStrings.Floppy:
-                    return MediaType.FloppyDisk;
-                case CommandStrings.Disk:
-                    return MediaType.HardDisk;
-                case CommandStrings.Tape:
-                    return MediaType.DataCartridge;
-                default:
-                    return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the default extension for a given disc type
-        /// </summary>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>Valid extension (with leading '.'), null on error</returns>
-        public static string Extension(MediaType? type)
-        {
-            switch (type)
-            {
-                case MediaType.CDROM:
-                case MediaType.GDROM:
-                case MediaType.Cartridge:
-                case MediaType.HardDisk:
-                case MediaType.CompactFlash:
-                case MediaType.MMC:
-                case MediaType.SDCard:
-                case MediaType.FlashDrive:
-                    return ".bin";
-                case MediaType.DVD:
-                case MediaType.HDDVD:
-                case MediaType.BluRay:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return ".iso";
-                case MediaType.LaserDisc:
-                case MediaType.NintendoGameCubeGameDisc:
-                    return ".raw";
-                case MediaType.NintendoWiiUOpticalDisc:
-                    return ".wud";
-                case MediaType.FloppyDisk:
-                    return ".img";
-                case MediaType.Cassette:
-                    return ".wav";
-                case MediaType.NONE:
-                default:
-                    return null;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Modules/MPF.Modules.csproj

@@ -1,46 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2021</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.3</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
-    <DefineConstants>NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
-    <ProjectReference Include="..\MPF.CueSheets\MPF.CueSheets.csproj" />
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
-    <ProjectReference Include="..\CICMMetadata\CICMMetadataEditor\CICMMetadataEditor\CICMMetadataEditor.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="System.Memory" Version="4.5.4" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-
-</Project>

MPF.Test/Core/Converters/EnumConverterTests.cs

@@ -2,9 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-#if NET_FRAMEWORK
-using IMAPI2;
-#endif
 using MPF.Core.Converters;
 using MPF.Core.Data;
 using Xunit;
@@ -18,41 +15,12 @@ namespace MPF.Test.Core.Converters
         /// <summary>
         /// DiscType values that map to InternalDriveType
         /// </summary>
-        private static readonly DriveType[] _mappableDriveTypes = new DriveType[]
-        {
+        private static readonly DriveType[] _mappableDriveTypes =
+        [
             DriveType.CDRom,
             DriveType.Fixed,
             DriveType.Removable,
-        };
-
-#if NET_FRAMEWORK
-        /// <summary>
-        /// IMAPI_MEDIA_PHYSICAL_TYPE values that map to MediaType
-        /// </summary>
-        private static readonly IMAPI_MEDIA_PHYSICAL_TYPE[] _mappableImapiTypes = new IMAPI_MEDIA_PHYSICAL_TYPE[]
-        {
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR,
-            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE,
-        };
-#endif
+        ];
 
         /// <summary>
         /// Check that every supported DriveType maps to an InternalDriveType
@@ -71,63 +39,24 @@ namespace MPF.Test.Core.Converters
                 Assert.NotNull(actual);
         }
 
-#if NET_FRAMEWORK
-        /// <summary>
-        /// Check that every supported IMAPI_MEDIA_PHYSICAL_TYPE maps to an MediaType
-        /// </summary>
-        /// <param name="imapiType">IMAPI_MEDIA_PHYSICAL_TYPE value to check</param>
-        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
-        [Theory]
-        [MemberData(nameof(GenerateImapiTypeMappingTestData))]
-        public void IMAPIToMediaTypeTest(IMAPI_MEDIA_PHYSICAL_TYPE imapiType, bool expectNull)
-        {
-            var actual = imapiType.IMAPIToMediaType();
-
-            if (expectNull)
-                Assert.Null(actual);
-            else
-                Assert.NotNull(actual);
-        }
-#endif
-
         /// <summary>
         /// Generate a test set of DriveType values
         /// </summary>
         /// <returns>MemberData-compatible list of DriveType values</returns>
-        public static List<object[]> GenerateDriveTypeMappingTestData()
+        public static List<object?[]> GenerateDriveTypeMappingTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (DriveType driveType in Enum.GetValues(typeof(DriveType)))
             {
                 if (_mappableDriveTypes.Contains(driveType))
-                    testData.Add(new object[] { driveType, false });
+                    testData.Add([driveType, false]);
                 else
-                    testData.Add(new object[] { driveType, true });
+                    testData.Add([driveType, true]);
             }
 
             return testData;
         }
 
-#if NET_FRAMEWORK
-        /// <summary>
-        /// Generate a test set of IMAPI_MEDIA_PHYSICAL_TYPE values
-        /// </summary>
-        /// <returns>MemberData-compatible list of IMAPI_MEDIA_PHYSICAL_TYPE values</returns>
-        public static List<object[]> GenerateImapiTypeMappingTestData()
-        {
-            var testData = new List<object[]>() { new object[] { null, false } };
-            foreach (IMAPI_MEDIA_PHYSICAL_TYPE imapiType in Enum.GetValues(typeof(IMAPI_MEDIA_PHYSICAL_TYPE)))
-            {
-                if (_mappableImapiTypes.Contains(imapiType))
-                    testData.Add(new object[] { imapiType, false });
-                else
-                    testData.Add(new object[] { imapiType, true });
-            }
-
-            return testData;
-        }
-#endif
-
         #endregion
 
         #region Convert to Long Name
@@ -150,12 +79,12 @@ namespace MPF.Test.Core.Converters
         /// Generate a test set of InternalProgram values
         /// </summary>
         /// <returns>MemberData-compatible list of InternalProgram values</returns>
-        public static List<object[]> GenerateInternalProgramTestData()
+        public static List<object?[]> GenerateInternalProgramTestData()
         {
-            var testData = new List<object[]>() { new object[] { null } };
+            var testData = new List<object?[]>() { new object?[] { null } };
             foreach (InternalProgram? internalProgram in Enum.GetValues(typeof(InternalProgram)))
             {
-                testData.Add(new object[] { internalProgram });
+                testData.Add([internalProgram]);
             }
 
             return testData;

MPF.Test/Core/Data/XgdInfoTests.cs

@@ -1,115 +0,0 @@
-using MPF.Core.Data;
-using Xunit;
-
-namespace MPF.Test.Core.Data
-{
-    public class XgdInfoTests
-    {
-        [Theory]
-        [InlineData(null)]
-        [InlineData("")]
-        [InlineData("1234567")]
-        [InlineData("1234567\0")]
-        [InlineData("123456789")]
-        public void UnmatchedStringTests(string invalidString)
-        {
-            XgdInfo xgdInfo = new XgdInfo(invalidString);
-            Assert.False(xgdInfo.Initialized);
-        }
-
-        [Theory]
-        [InlineData("AV00100W", "AV", "001", "00", 'W')]
-        [InlineData("AV00100W\0", "AV", "001", "00", 'W')]
-        public void XGD1ValidTests(string validString, string publisher, string gameId, string version, char regionIdentifier)
-        {
-            XgdInfo xgdInfo = new XgdInfo(validString, validate: true);
-
-            Assert.True(xgdInfo.Initialized);
-            Assert.Equal(publisher, xgdInfo.PublisherIdentifier);
-            Assert.Equal(gameId, xgdInfo.GameID);
-            Assert.Equal(version, xgdInfo.SKU);
-            Assert.Equal(regionIdentifier, xgdInfo.RegionIdentifier);
-        }
-
-        [Theory]
-        // Invalid publisher identifier
-        [InlineData("ZZ000000")]
-        [InlineData("ZZ000000\0")]
-        // Invalid region identifier
-        [InlineData("AV00000Z")]
-        [InlineData("AV00000Z\0")]
-        public void XGD1InvalidTests(string invalidString)
-        {
-            XgdInfo xgdInfo = new XgdInfo(invalidString, validate: true);
-            Assert.False(xgdInfo.Initialized);
-        }
-
-        [Theory]
-        [InlineData("AV200100W0F11", "AV", "001", "00", 'W', "0", 'F', "11", null)]
-        [InlineData("AV200100W0F11\0", "AV", "001", "00", 'W', "0", 'F', "11", null)]
-        [InlineData("AV200100W01F11", "AV", "001", "00", 'W', "01", 'F', "11", null)]
-        [InlineData("AV200100W01F11\0", "AV", "001", "00", 'W', "01", 'F', "11", null)]
-        [InlineData("AV200100W0F11DEADBEEF", "AV", "001", "00", 'W', "0", 'F', "11", "DEADBEEF")]
-        [InlineData("AV200100W0F11DEADBEEF\0", "AV", "001", "00", 'W', "0", 'F', "11", "DEADBEEF")]
-        [InlineData("AV200100W01F11DEADBEEF", "AV", "001", "00", 'W', "01", 'F', "11", "DEADBEEF")]
-        [InlineData("AV200100W01F11DEADBEEF\0", "AV", "001", "00", 'W', "01", 'F', "11", "DEADBEEF")]
-        public void XGD23ValidTests(string validString, string publisher, string gameId, string sku, char regionIdentifier, string baseVersion, char mediaSubtype, string discNumber, string cert)
-        {
-            XgdInfo xgdInfo = new XgdInfo(validString, validate: true);
-
-            Assert.True(xgdInfo.Initialized);
-            Assert.Equal(publisher, xgdInfo.PublisherIdentifier);
-            Assert.Equal('2', xgdInfo.PlatformIdentifier);
-            Assert.Equal(gameId, xgdInfo.GameID);
-            Assert.Equal(sku, xgdInfo.SKU);
-            Assert.Equal(regionIdentifier, xgdInfo.RegionIdentifier);
-            Assert.Equal(baseVersion, xgdInfo.BaseVersion);
-            Assert.Equal(mediaSubtype, xgdInfo.MediaSubtypeIdentifier);
-            Assert.Equal(discNumber, xgdInfo.DiscNumberIdentifier);
-            Assert.Equal(cert, xgdInfo.CertificationSubmissionIdentifier);
-        }
-
-        [Theory]
-        // Invalid publisher identifier
-        [InlineData("ZZ00000000000")]
-        [InlineData("ZZ00000000000\0")]
-        [InlineData("ZZ000000000000")]
-        [InlineData("ZZ000000000000\0")]
-        [InlineData("ZZ0000000000000000000")]
-        [InlineData("ZZ0000000000000000000\0")]
-        [InlineData("ZZ00000000000000000000")]
-        [InlineData("ZZ00000000000000000000\0")]
-        // Invalid platform identifier
-        [InlineData("AV90000000000")]
-        [InlineData("AV90000000000\0")]
-        [InlineData("AV900000000000")]
-        [InlineData("AV900000000000\0")]
-        [InlineData("AV9000000000000000000")]
-        [InlineData("AV9000000000000000000\0")]
-        [InlineData("AV90000000000000000000")]
-        [InlineData("AV90000000000000000000\0")]
-        // Invalid region identifier
-        [InlineData("AV200000Z0000")]
-        [InlineData("AV200000Z0000\0")]
-        [InlineData("AV200000Z00000")]
-        [InlineData("AV200000Z00000\0")]
-        [InlineData("AV200000Z000000000000")]
-        [InlineData("AV200000Z000000000000\0")]
-        [InlineData("AV200000Z0000000000000")]
-        [InlineData("AV200000Z0000000000000\0")]
-        // Invalid media subtype identifier
-        [InlineData("AV200000W0A00")]
-        [InlineData("AV200000W0A00\0")]
-        [InlineData("AV200000W00A00")]
-        [InlineData("AV200000W00A00\0")]
-        [InlineData("AV200000W00A000000000")]
-        [InlineData("AV200000W00A000000000\0")]
-        [InlineData("AV200000W00A0000000000")]
-        [InlineData("AV200000W00A0000000000\0")]
-        public void XGD23InvalidTests(string invalidString)
-        {
-            XgdInfo xgdInfo = new XgdInfo(invalidString, validate: true);
-            Assert.False(xgdInfo.Initialized);
-        }
-    }
-}

MPF.Test/Core/Utilities/EnumExtensionsTests.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using MPF.Core.Utilities;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Core.Utilities
@@ -12,8 +12,8 @@ namespace MPF.Test.Core.Utilities
         /// <summary>
         /// MediaType values that support drive speeds
         /// </summary>
-        private static readonly MediaType?[] _supportDriveSpeeds = new MediaType?[]
-        {
+        private static readonly MediaType?[] _supportDriveSpeeds =
+        [
             MediaType.CDROM,
             MediaType.DVD,
             MediaType.GDROM,
@@ -21,55 +21,59 @@ namespace MPF.Test.Core.Utilities
             MediaType.BluRay,
             MediaType.NintendoGameCubeGameDisc,
             MediaType.NintendoWiiOpticalDisc,
-        };
+        ];
 
         /// <summary>
         /// RedumpSystem values that are considered Audio
         /// </summary>
-        private static readonly RedumpSystem?[] _audioSystems = new RedumpSystem?[]
-        {
+        private static readonly RedumpSystem?[] _audioSystems =
+        [
             RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem,
             RedumpSystem.AudioCD,
             RedumpSystem.DVDAudio,
+            RedumpSystem.HasbroiONEducationalGamingSystem,
             RedumpSystem.HasbroVideoNow,
             RedumpSystem.HasbroVideoNowColor,
             RedumpSystem.HasbroVideoNowJr,
             RedumpSystem.HasbroVideoNowXP,
+            RedumpSystem.PlayStationGameSharkUpdates,
             RedumpSystem.PhilipsCDi,
             RedumpSystem.SuperAudioCD,
-        };
+        ];
 
         /// <summary>
         /// RedumpSystem values that are considered markers
         /// </summary>
-        private static readonly RedumpSystem?[] _markerSystems = new RedumpSystem?[]
-        {
+        private static readonly RedumpSystem?[] _markerSystems =
+        [
             RedumpSystem.MarkerArcadeEnd,
             RedumpSystem.MarkerComputerEnd,
             RedumpSystem.MarkerDiscBasedConsoleEnd,
             RedumpSystem.MarkerOtherEnd,
-        };
+        ];
 
         /// <summary>
         /// RedumpSystem values that are have reversed ringcodes
         /// </summary>
-        private static readonly RedumpSystem?[] _reverseRingcodeSystems = new RedumpSystem?[]
-        {
+        private static readonly RedumpSystem?[] _reverseRingcodeSystems =
+        [
             RedumpSystem.SonyPlayStation2,
             RedumpSystem.SonyPlayStation3,
             RedumpSystem.SonyPlayStation4,
-        };
+            RedumpSystem.SonyPlayStation5,
+            RedumpSystem.SonyPlayStationPortable,
+        ];
 
         /// <summary>
         /// RedumpSystem values that are considered XGD
         /// </summary>
-        private static readonly RedumpSystem?[] _xgdSystems = new RedumpSystem?[]
-        {
+        private static readonly RedumpSystem?[] _xgdSystems =
+        [
             RedumpSystem.MicrosoftXbox,
             RedumpSystem.MicrosoftXbox360,
             RedumpSystem.MicrosoftXboxOne,
             RedumpSystem.MicrosoftXboxSeriesXS,
-        };
+        ];
 
         /// <summary>
         /// Check that all optical media support drive speeds
@@ -140,15 +144,15 @@ namespace MPF.Test.Core.Utilities
         /// Generate a test set of MediaType values that support drive speeds
         /// </summary>
         /// <returns>MemberData-compatible list of MediaType values</returns>
-        public static List<object[]> GenerateSupportDriveSpeedsTestData()
+        public static List<object?[]> GenerateSupportDriveSpeedsTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (MediaType mediaType in Enum.GetValues(typeof(MediaType)))
             {
                 if (_supportDriveSpeeds.Contains(mediaType))
-                    testData.Add(new object[] { mediaType, true });
+                    testData.Add([mediaType, true]);
                 else
-                    testData.Add(new object[] { mediaType, false });
+                    testData.Add([mediaType, false]);
             }
 
             return testData;
@@ -158,15 +162,15 @@ namespace MPF.Test.Core.Utilities
         /// Generate a test set of RedumpSystem values that are considered Audio
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateAudioSystemsTestData()
+        public static List<object?[]> GenerateAudioSystemsTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
                 if (_audioSystems.Contains(redumpSystem))
-                    testData.Add(new object[] { redumpSystem, true });
+                    testData.Add([redumpSystem, true]);
                 else
-                    testData.Add(new object[] { redumpSystem, false });
+                    testData.Add([redumpSystem, false]);
             }
 
             return testData;
@@ -176,15 +180,15 @@ namespace MPF.Test.Core.Utilities
         /// Generate a test set of RedumpSystem values that are considered markers
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateMarkerSystemsTestData()
+        public static List<object?[]> GenerateMarkerSystemsTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
                 if (_markerSystems.Contains(redumpSystem))
-                    testData.Add(new object[] { redumpSystem, true });
+                    testData.Add([redumpSystem, true]);
                 else
-                    testData.Add(new object[] { redumpSystem, false });
+                    testData.Add([redumpSystem, false]);
             }
 
             return testData;
@@ -194,15 +198,15 @@ namespace MPF.Test.Core.Utilities
         /// Generate a test set of RedumpSystem values that are considered markers
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateReversedRingcodeSystemsTestData()
+        public static List<object?[]> GenerateReversedRingcodeSystemsTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
                 if (_reverseRingcodeSystems.Contains(redumpSystem))
-                    testData.Add(new object[] { redumpSystem, true });
+                    testData.Add([redumpSystem, true]);
                 else
-                    testData.Add(new object[] { redumpSystem, false });
+                    testData.Add([redumpSystem, false]);
             }
 
             return testData;
@@ -212,15 +216,15 @@ namespace MPF.Test.Core.Utilities
         /// Generate a test set of RedumpSystem values that are considered XGD
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateXGDSystemsTestData()
+        public static List<object?[]> GenerateXGDSystemsTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
                 if (_xgdSystems.Contains(redumpSystem))
-                    testData.Add(new object[] { redumpSystem, true });
+                    testData.Add([redumpSystem, true]);
                 else
-                    testData.Add(new object[] { redumpSystem, false });
+                    testData.Add([redumpSystem, false]);
             }
 
             return testData;

MPF.Test/Library/DumpEnvironmentTests.cs

@@ -1,7 +1,6 @@
-using System.IO;
+using MPF.Core;
 using MPF.Core.Data;
-using MPF.Library;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Library
@@ -15,14 +14,16 @@ namespace MPF.Test.Library
         [InlineData("fd A test.img", 'A', true, MediaType.FloppyDisk, true)]
         [InlineData("dvd X test.iso 8 /raw", 'X', false, MediaType.FloppyDisk, false)]
         [InlineData("stop D", 'D', false, MediaType.DVD, true)]
-        public void ParametersValidTest(string parameters, char letter, bool isFloppy, MediaType? mediaType, bool expected)
+        public void ParametersValidTest(string? parameters, char letter, bool isFloppy, MediaType? mediaType, bool expected)
         {
             var options = new Options() { InternalProgram = InternalProgram.DiscImageCreator };
-            var drive = isFloppy
-                ? new Drive(InternalDriveType.Floppy, new DriveInfo(letter.ToString()))
-                : new Drive(InternalDriveType.Optical, new DriveInfo(letter.ToString()));
 
-            var env = new DumpEnvironment(options, string.Empty, string.Empty, drive, RedumpSystem.IBMPCcompatible, mediaType, parameters);
+            // TODO: This relies on creating real objects for the drive. Can we mock this out instead?
+            var drive = isFloppy
+                ? Drive.Create(InternalDriveType.Floppy, letter.ToString())
+                : Drive.Create(InternalDriveType.Optical, letter.ToString());
+
+            var env = new DumpEnvironment(options, string.Empty, drive, RedumpSystem.IBMPCcompatible, mediaType, null, parameters);
 
             bool actual = env.ParametersValid();
             Assert.Equal(expected, actual);

MPF.Test/Library/InfoToolTests.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
-using MPF.Library;
-using RedumpLib.Data;
+using System.IO;
+using MPF.Core;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Library
@@ -8,77 +10,39 @@ namespace MPF.Test.Library
     public class InfoToolTests
     {
         [Theory]
-        [InlineData(null, 0, 0, 0, 0, null)]
-        [InlineData(null, 12345, 0, 0, 0, null)]
-        [InlineData(null, 12345, 1, 0, 0, null)]
-        [InlineData(null, 12345, 1, 2, 0, null)]
-        [InlineData(null, 12345, 1, 2, 3, null)]
-        [InlineData(MediaType.CDROM, 0, 0, 0, 0, "CD-ROM")]
-        [InlineData(MediaType.CDROM, 12345, 0, 0, 0, "CD-ROM")]
-        [InlineData(MediaType.CDROM, 12345, 1, 0, 0, "CD-ROM")]
-        [InlineData(MediaType.CDROM, 12345, 1, 2, 0, "CD-ROM")]
-        [InlineData(MediaType.CDROM, 12345, 1, 2, 3, "CD-ROM")]
-        [InlineData(MediaType.DVD, 0, 0, 0, 0, "DVD-ROM-5")]
-        [InlineData(MediaType.DVD, 12345, 0, 0, 0, "DVD-ROM-5")]
-        [InlineData(MediaType.DVD, 12345, 1, 0, 0, "DVD-ROM-9")]
-        [InlineData(MediaType.DVD, 12345, 1, 2, 0, "DVD-ROM-9")]
-        [InlineData(MediaType.DVD, 12345, 1, 2, 3, "DVD-ROM-9")]
-        [InlineData(MediaType.BluRay, 0, 0, 0, 0, "BD-ROM-25")]
-        [InlineData(MediaType.BluRay, 12345, 0, 0, 0, "BD-ROM-25")]
-        [InlineData(MediaType.BluRay, 26_843_531_857, 0, 0, 0, "BD-ROM-33")]
-        [InlineData(MediaType.BluRay, 12345, 1, 0, 0, "BD-ROM-50")]
-        [InlineData(MediaType.BluRay, 53_687_063_713, 1, 0, 0, "BD-ROM-66")]
-        [InlineData(MediaType.BluRay, 12345, 1, 2, 0, "BD-ROM-100")]
-        [InlineData(MediaType.BluRay, 12345, 1, 2, 3, "BD-ROM-128")]
-        [InlineData(MediaType.UMD, 0, 0, 0, 0, "UMD-SL")]
-        [InlineData(MediaType.UMD, 12345, 0, 0, 0, "UMD-SL")]
-        [InlineData(MediaType.UMD, 12345, 1, 0, 0, "UMD-DL")]
-        [InlineData(MediaType.UMD, 12345, 1, 2, 0, "UMD-DL")]
-        [InlineData(MediaType.UMD, 12345, 1, 2, 3, "UMD-DL")]
-        public void GetFixedMediaTypeTest(
-            MediaType? mediaType,
-            long size,
-            long layerbreak,
-            long layerbreak2,
-            long layerbreak3,
-            string expected)
+        [InlineData(null, "")]
+        [InlineData(" ", " ")]
+        [InlineData("super\\blah.bin", "super\\blah.bin")]
+        [InlineData("super\\hero\\blah.bin", "super\\hero\\blah.bin")]
+        [InlineData("super.hero\\blah.bin", "super.hero\\blah.bin")]
+        [InlineData("superhero\\blah.rev.bin", "superhero\\blah.rev.bin")]
+        [InlineData("super&hero\\blah.bin", "super&hero\\blah.bin")]
+        [InlineData("superhero\\blah&foo.bin", "superhero\\blah&foo.bin")]
+        public void NormalizeOutputPathsTest(string? outputPath, string? expectedPath)
         {
-            string actual = InfoTool.GetFixedMediaType(mediaType, size, layerbreak, layerbreak2, layerbreak3);
-            Assert.Equal(expected, actual);
-        }
+            if (!string.IsNullOrEmpty(expectedPath))
+                expectedPath = Path.GetFullPath(expectedPath);
 
-        [Theory]
-        [InlineData(null, null, null, null)]
-        [InlineData(" ", "", " ", "")]
-        [InlineData("super", "blah.bin", "super", "blah.bin")]
-        [InlineData("super\\hero", "blah.bin", "super\\hero", "blah.bin")]
-        [InlineData("super.hero", "blah.bin", "super.hero", "blah.bin")]
-        [InlineData("superhero", "blah.rev.bin", "superhero", "blah.rev.bin")]
-        [InlineData("super&hero", "blah.bin", "super&hero", "blah.bin")]
-        [InlineData("superhero", "blah&foo.bin", "superhero", "blah&foo.bin")]
-        public void NormalizeOutputPathsTest(string outputDirectory, string outputFilename, string expectedOutputDirectory, string expectedOutputFilename)
-        {
-            (string actualOutputDirectory, string actualOutputFilename) = InfoTool.NormalizeOutputPaths(outputDirectory, outputFilename);
-            Assert.Equal(expectedOutputDirectory, actualOutputDirectory);
-            Assert.Equal(expectedOutputFilename, actualOutputFilename);
+            string actualPath = InfoTool.NormalizeOutputPaths(outputPath, true);
+            Assert.Equal(expectedPath, actualPath);
         }
 
         [Fact]
         public void ProcessSpecialFieldsCompleteTest()
         {
             // Create a new SubmissionInfo object
-            SubmissionInfo info = new SubmissionInfo()
+            var info = new SubmissionInfo()
             {
                 CommonDiscInfo = new CommonDiscInfoSection()
                 {
                     Comments = "This is a comments line\n[T:ISBN] ISBN Value",
-                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.VolumeLabel] = "VOLUME_LABEL",
                     },
 
                     Contents = "This is a contents line\n[T:GF] Game Footage",
-                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.Patches] = "1.04 patch",
                     },
@@ -86,7 +50,7 @@ namespace MPF.Test.Library
             };
 
             // Process the special fields
-            InfoTool.ProcessSpecialFields(info);
+            Formatter.ProcessSpecialFields(info);
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);
@@ -107,13 +71,13 @@ namespace MPF.Test.Library
         public void ProcessSpecialFieldsNullObjectTest()
         {
             // Create a new SubmissionInfo object
-            SubmissionInfo info = new SubmissionInfo()
+            var info = new SubmissionInfo()
             {
                 CommonDiscInfo = null,
             };
 
             // Process the special fields
-            InfoTool.ProcessSpecialFields(info);
+            Formatter.ProcessSpecialFields(info);
 
             // Validate
             Assert.Null(info.CommonDiscInfo);
@@ -123,18 +87,18 @@ namespace MPF.Test.Library
         public void ProcessSpecialFieldsNullCommentsContentsTest()
         {
             // Create a new SubmissionInfo object
-            SubmissionInfo info = new SubmissionInfo()
+            var info = new SubmissionInfo()
             {
                 CommonDiscInfo = new CommonDiscInfoSection()
                 {
                     Comments = null,
-                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.VolumeLabel] = "VOLUME_LABEL",
                     },
 
                     Contents = null,
-                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.Patches] = "1.04 patch",
                     },
@@ -142,7 +106,7 @@ namespace MPF.Test.Library
             };
 
             // Process the special fields
-            InfoTool.ProcessSpecialFields(info);
+            Formatter.ProcessSpecialFields(info);
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);
@@ -163,7 +127,7 @@ namespace MPF.Test.Library
         public void ProcessSpecialFieldsNullDictionariesTest()
         {
             // Create a new SubmissionInfo object
-            SubmissionInfo info = new SubmissionInfo()
+            var info = new SubmissionInfo()
             {
                 CommonDiscInfo = new CommonDiscInfoSection()
                 {
@@ -176,7 +140,7 @@ namespace MPF.Test.Library
             };
 
             // Process the special fields
-            InfoTool.ProcessSpecialFields(info);
+            Formatter.ProcessSpecialFields(info);
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);

MPF.Test/Library/ProtectionTests.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Library;
+using MPF.Core;
 using Xunit;
 
 namespace MPF.Test.Library
@@ -11,11 +11,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsActiveMARKTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "ActiveMARK",
                 "ActiveMARK 5",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("ActiveMARK 5", sanitized);
@@ -24,11 +24,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsCactusDataShieldTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Cactus Data Shield 200",
                 "Cactus Data Shield 200 (Build 3.0.100a)",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Cactus Data Shield 200 (Build 3.0.100a)", sanitized);
@@ -37,11 +37,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsCDCheckTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Anything Else Protection",
                 "Executable-Based CD Check",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Anything Else Protection", sanitized);
@@ -50,11 +50,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsCDCopsTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "CD-Cops",
                 "CD-Cops v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("CD-Cops v1.2.0", sanitized);
@@ -63,11 +63,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsCDKeyTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Anything Else Protection",
                 "CD-Key / Serial",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Anything Else Protection", sanitized);
@@ -76,11 +76,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsEACdKeyTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "EA CdKey Registration Module",
                 "EA CdKey Registration Module v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("EA CdKey Registration Module v1.2.0", sanitized);
@@ -89,11 +89,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsEADRMTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "EA DRM Protection",
                 "EA DRM Protection v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("EA DRM Protection v1.2.0", sanitized);
@@ -102,11 +102,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsGFWLTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Games for Windows LIVE",
                 "Games for Windows LIVE v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Games for Windows LIVE v1.2.0", sanitized);
@@ -115,11 +115,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsGFWLZDPPTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Games for Windows LIVE",
                 "Games for Windows LIVE Zero Day Piracy Protection",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Games for Windows LIVE, Games for Windows LIVE Zero Day Piracy Protection", sanitized);
@@ -128,11 +128,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsImpulseReactorTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Impulse Reactor",
                 "Impulse Reactor Core Module v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Impulse Reactor Core Module v1.2.0", sanitized);
@@ -145,14 +145,14 @@ namespace MPF.Test.Library
         [InlineData(3)]
         public void SanitizeFoundProtectionsJoWoodXProtTest(int skip)
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "JoWood X-Prot 1.2.0.00",
                 "JoWood X-Prot v2",
                 "JoWood X-Prot v1.4+",
                 "JoWood X-Prot v1.0-v1.3",
                 "JoWood X-Prot",
-            };
+            ];
 
             // Safeguard for the future
             if (skip >= protections.Count)
@@ -168,53 +168,16 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsOnlineRegistrationTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Anything Else Protection",
                 "Executable-Based Online Registration",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Anything Else Protection", sanitized);
         }
 
-        [Theory]
-        [InlineData(0)]
-        [InlineData(1)]
-        [InlineData(2)]
-        [InlineData(3)]
-        [InlineData(4)]
-        [InlineData(5)]
-        [InlineData(6)]
-        [InlineData(7)]
-        [InlineData(8)]
-        public void SanitizeFoundProtectionsSafeDiscTest(int skip)
-        {
-            List<string> protections = new List<string>()
-            {
-                "SafeDisc 1.20.000",
-                "SafeDisc (drvmgt.dll) 1.2.0",
-                "SafeDisc (secdrv.sys) 1.2.0",
-                "SafeDisc (dplayerx.dll) 1.2.0",
-                "SafeDisc 3.20-4.xx (version removed)",
-                "SafeDisc 2",
-                "SafeDisc 1/Lite",
-                "SafeDisc Lite",
-                "SafeDisc 1-3",
-                "SafeDisc",
-            };
-
-            // Safeguard for the future
-            if (skip >= protections.Count)
-                throw new ArgumentException("Invalid skip value", nameof(skip));
-
-            // The list is in order of preference
-            protections = protections.Skip(skip).ToList();
-
-            string sanitized = Protection.SanitizeFoundProtections(protections);
-            Assert.Equal(protections[0], sanitized);
-        }
-
         [Theory]
         [InlineData(0)]
         [InlineData(1)]
@@ -222,14 +185,14 @@ namespace MPF.Test.Library
         [InlineData(3)]
         public void SanitizeFoundProtectionStarForceTest(int skip)
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "StarForce 1.20.000.000",
                 "StarForce 5 [Protected Module]",
                 "StarForce 5",
                 "StarForce 3-5",
                 "StarForce",
-            };
+            ];
 
             // Safeguard for the future
             if (skip >= protections.Count)
@@ -245,11 +208,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsSysiphusTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "Sysiphus",
                 "Sysiphus v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("Sysiphus v1.2.0", sanitized);
@@ -258,11 +221,11 @@ namespace MPF.Test.Library
         [Fact]
         public void SanitizeFoundProtectionsXCPTest()
         {
-            List<string> protections = new List<string>()
-            {
+            List<string> protections =
+            [
                 "XCP",
                 "XCP v1.2.0",
-            };
+            ];
 
             string sanitized = Protection.SanitizeFoundProtections(protections);
             Assert.Equal("XCP v1.2.0", sanitized);

MPF.Test/MPF.Test.csproj

@@ -1,56 +1,35 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1;net5.0-windows</TargetFrameworks>
-    <PlatformTarget>x86</PlatformTarget>
-    <IsPackable>false</IsPackable>
+    <TargetFrameworks>net8.0</TargetFrameworks>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
-    <DefineConstants>NET_FRAMEWORK</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
-    <COMReference Include="IMAPI2">
-      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="IMAPI2FS">
-      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\MPF\MPF.csproj" />
-    <ProjectReference Include="..\MPF.Library\MPF.Library.csproj" />
-    <ProjectReference Include="..\MPF.Modules\MPF.Modules.csproj" />
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeCoverage" Version="16.11.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="Microsoft.CodeCoverage" Version="17.10.0-release-24177-07" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0-release-24177-07" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.6" />
+    <PackageReference Include="xunit" Version="2.7.1" />
     <PackageReference Include="xunit.abstractions" Version="2.0.3" />
-    <PackageReference Include="xunit.analyzers" Version="0.10.0" />
-    <PackageReference Include="xunit.assert" Version="2.4.1" />
-    <PackageReference Include="xunit.core" Version="2.4.1" />
-    <PackageReference Include="xunit.extensibility.core" Version="2.4.1" />
-    <PackageReference Include="xunit.extensibility.execution" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.console" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+    <PackageReference Include="xunit.analyzers" Version="1.12.0" />
+    <PackageReference Include="xunit.assert" Version="2.7.1" />
+    <PackageReference Include="xunit.core" Version="2.7.1" />
+    <PackageReference Include="xunit.extensibility.core" Version="2.7.1" />
+    <PackageReference Include="xunit.extensibility.execution" Version="2.7.1" />
+    <PackageReference Include="xunit.runner.console" Version="2.7.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

MPF.Test/Modules/DiscImageCreatorTests.cs

@@ -1,7 +1,8 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using MPF.Core.Data;
-using MPF.Modules.DiscImageCreator;
-using RedumpLib.Data;
+using MPF.Core.Modules.DiscImageCreator;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Modules
@@ -17,40 +18,124 @@ namespace MPF.Test.Modules
         [InlineData(RedumpSystem.SonyPlayStation3, MediaType.BluRay, CommandStrings.BluRay)]
         [InlineData(RedumpSystem.AppleMacintosh, MediaType.FloppyDisk, CommandStrings.Floppy)]
         [InlineData(RedumpSystem.RawThrillsVarious, MediaType.GDROM, null)]
-        public void ParametersFromSystemAndTypeTest(RedumpSystem? knownSystem, MediaType? mediaType, string expected)
+        public void ParametersFromSystemAndTypeTest(RedumpSystem? knownSystem, MediaType? mediaType, string? expected)
         {
-            var options = new Options { };
-            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
+            var options = new Options();
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
             Assert.Equal(expected, actual.BaseCommand);
         }
 
         [Theory]
-        [InlineData(RedumpSystem.AppleMacintosh, MediaType.LaserDisc, true, 20, null, null)]
-        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, false, 20, null, new string[] { FlagStrings.Raw })]
-        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, 20, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
-        /* paranoid mode tests */
-        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, 1000, 2, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
-        [InlineData(RedumpSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
-        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
-        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
-        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
-        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
-        /* reread c2 */
-        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, false, 1000, null, new string[] { FlagStrings.C2Opcode })]
-        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new string[] { FlagStrings.C2Opcode })]
-        public void ParametersFromOptionsTest(RedumpSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, string[] expected)
+        [InlineData(RedumpSystem.AppleMacintosh, MediaType.LaserDisc, null)] // Deliberately unsupported
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, new string[] { FlagStrings.Raw })]
+        public void ParametersFromOptionsSpecialDefaultTest(RedumpSystem? knownSystem, MediaType? mediaType, string[]? expected)
         {
-            var options = new Options { DICParanoidMode = paranoid, DICRereadCount = rereadC2 };
-            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
+            var options = new Options();
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, 1000, new string[] { FlagStrings.C2Opcode })]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, -1, new string[] { FlagStrings.C2Opcode })]
+        public void ParametersFromOptionsC2RereadTest(RedumpSystem? knownSystem, MediaType? mediaType, int rereadC2, string[] expected)
+        {
+            var options = new Options { DICRereadCount = rereadC2 };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
 
-            HashSet<string> expectedSet = new HashSet<string>(expected ?? new string[0]);
-            HashSet<string> actualSet = new HashSet<string>(actual.Keys ?? new string[0]);
             Assert.Equal(expectedSet, actualSet);
             if (rereadC2 == -1 || !knownSystem.MediaTypes().Contains(mediaType))
                 Assert.Null(actual.C2OpcodeValue[0]);
             else
                 Assert.Equal(rereadC2, actual.C2OpcodeValue[0]);
-            Assert.Equal(subchannelLevel, actual.SubchannelReadLevelValue);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, 1000, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, -1, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.BluRay, 1000, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.BluRay, -1, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsDVDRereadTest(RedumpSystem? knownSystem, MediaType? mediaType, int rereadDVDBD, string[] expected)
+        {
+            var options = new Options { DICDVDRereadCount = rereadDVDBD };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+
+            Assert.Equal(expectedSet, actualSet);
+            if (rereadDVDBD == -1 || !knownSystem.MediaTypes().Contains(mediaType))
+                Assert.Null(actual.DVDRereadValue);
+            else
+                Assert.Equal(rereadDVDBD, actual.DVDRereadValue);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.MultiSectorRead, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, false, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsMultiSectorReadTest(RedumpSystem? knownSystem, MediaType? mediaType, bool multiSectorRead, string[] expected)
+        {
+            var options = new Options { DICMultiSectorRead = multiSectorRead };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+            if (expectedSet.Count != 1 && multiSectorRead)
+                Assert.Equal(0, actual.MultiSectorReadValue);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, false, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, new string[] { FlagStrings.DVDReread, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsParanoidModeTest(RedumpSystem? knownSystem, MediaType? mediaType, bool paranoidMode, string[] expected)
+        {
+            var options = new Options { DICParanoidMode = paranoidMode };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+            if (paranoidMode)
+            {
+                if (actualSet.Contains(FlagStrings.ScanSectorProtect))
+                    Assert.True(actual[FlagStrings.ScanSectorProtect]);
+
+                if (actualSet.Contains(FlagStrings.SubchannelReadLevel))
+                {
+                    Assert.True(actual[FlagStrings.SubchannelReadLevel]);
+                    Assert.Equal(2, actual.SubchannelReadLevelValue);
+                }
+            }
+            else
+            {
+                if (actualSet.Contains(FlagStrings.ScanSectorProtect))
+                    Assert.False(actual[FlagStrings.ScanSectorProtect]);
+
+                if (actualSet.Contains(FlagStrings.SubchannelReadLevel))
+                    Assert.False(actual[FlagStrings.SubchannelReadLevel]);
+
+                Assert.Null(actual.SubchannelReadLevelValue);
+            }
         }
 
         [Theory]
@@ -62,7 +147,7 @@ namespace MPF.Test.Modules
         [InlineData("bd D longer\\path_test.iso 16", true)]
         [InlineData("stop D", true)]
         [InlineData("ls", false)]
-        public void ValidateParametersTest(string parameters, bool expected)
+        public void ValidateParametersTest(string? parameters, bool expected)
         {
             var actual = new Parameters(parameters);
             Assert.Equal(expected, actual.IsValid());
@@ -76,9 +161,9 @@ namespace MPF.Test.Modules
         [InlineData(MediaType.FloppyDisk, ".img")]
         [InlineData(MediaType.Cassette, ".wav")]
         [InlineData(MediaType.NONE, null)]
-        public void MediaTypeToExtensionTest(MediaType? mediaType, string expected)
+        public void MediaTypeToExtensionTest(MediaType? mediaType, string? expected)
         {
-            string actual = MPF.Modules.DiscImageCreator.Converters.Extension(mediaType);
+            var actual = Converters.Extension(mediaType);
             Assert.Equal(expected, actual);
         }
 
@@ -102,7 +187,7 @@ namespace MPF.Test.Modules
         [InlineData(CommandStrings.XBOX, MediaType.DVD)]
         public void BaseCommandToMediaTypeTest(string command, MediaType? expected)
         {
-            MediaType? actual = MPF.Modules.DiscImageCreator.Converters.ToMediaType(command);
+            MediaType? actual = Converters.ToMediaType(command);
             Assert.Equal(expected, actual);
         }
 
@@ -126,7 +211,7 @@ namespace MPF.Test.Modules
         [InlineData(CommandStrings.XBOX, RedumpSystem.MicrosoftXbox)]
         public void BaseCommandToRedumpSystemTest(string command, RedumpSystem? expected)
         {
-            RedumpSystem? actual = MPF.Modules.DiscImageCreator.Converters.ToRedumpSystem(command);
+            RedumpSystem? actual = Converters.ToRedumpSystem(command);
             Assert.Equal(expected, actual);
         }
 
@@ -142,7 +227,7 @@ namespace MPF.Test.Modules
             Assert.NotNull(parametersObject);
 
             // Validate that the same set of parameters are generated on the output
-            string newParameters = parametersObject.GenerateParameters();
+            var newParameters = parametersObject.GenerateParameters();
             Assert.NotNull(newParameters);
             Assert.Equal(originalParameters, newParameters);
         }
@@ -157,9 +242,29 @@ namespace MPF.Test.Modules
             Assert.NotNull(parametersObject);
 
             // Validate that the same set of parameters are generated on the output
-            string newParameters = parametersObject.GenerateParameters();
+            var newParameters = parametersObject.GenerateParameters();
             Assert.NotNull(newParameters);
             Assert.Equal(originalParameters, newParameters);
         }
+
+        /// <summary>
+        /// Generate a HashSet of keys that are considered to be set
+        /// </summary>
+        /// <param name="parameters">Parameters object to get keys from</param>
+        /// <returns>HashSet representing the strings</returns>
+        private static HashSet<string> GenerateUsedKeys(Parameters parameters)
+        {
+            var usedKeys = new HashSet<string>();
+            if (parameters?.Keys == null)
+                return usedKeys;
+
+            foreach (string key in parameters.Keys)
+            {
+                if (parameters[key] == true)
+                    usedKeys.Add(key);
+            }
+
+            return usedKeys;
+        }
     }
 }

MPF.Test/RedumpLib/ExtensionsTests.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Linq;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.RedumpLib
@@ -18,12 +18,17 @@ namespace MPF.Test.RedumpLib
         private static readonly DiscType?[] _mappableDiscTypes = new DiscType?[]
         {
             DiscType.BD25,
+            DiscType.BD33,
             DiscType.BD50,
+            DiscType.BD66,
+            DiscType.BD100,
+            DiscType.BD128,
             DiscType.CD,
             DiscType.DVD5,
             DiscType.DVD9,
             DiscType.GDROM,
             DiscType.HDDVDSL,
+            DiscType.HDDVDDL,
             DiscType.NintendoGameCubeGameDisc,
             DiscType.NintendoWiiOpticalDiscSL,
             DiscType.NintendoWiiOpticalDiscDL,
@@ -90,15 +95,15 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of DiscType values
         /// </summary>
         /// <returns>MemberData-compatible list of DiscType values</returns>
-        public static List<object[]> GenerateDiscTypeMappingTestData()
+        public static List<object?[]> GenerateDiscTypeMappingTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
             {
                 if (_mappableDiscTypes.Contains(discType))
-                    testData.Add(new object[] { discType, false });
+                    testData.Add(new object?[] { discType, false });
                 else
-                    testData.Add(new object[] { discType, true });
+                    testData.Add(new object?[] { discType, true });
             }
 
             return testData;
@@ -108,12 +113,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of RedumpSystem values
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateRedumpSystemMappingTestData()
+        public static List<object?[]> GenerateRedumpSystemMappingTestData()
         {
-            var testData = new List<object[]>() { new object[] { null } };
+            var testData = new List<object?[]>() { new object?[] { null } };
             foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
-                testData.Add(new object[] { redumpSystem });
+                testData.Add(new object?[] { redumpSystem });
             }
 
             return testData;
@@ -123,16 +128,16 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of mappable media types
         /// </summary>
         /// <returns>MemberData-compatible list of MediaTypes</returns>
-        public static List<object[]> GenerateMediaTypeMappingTestData()
+        public static List<object?[]> GenerateMediaTypeMappingTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
 
             foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
             {
                 if (_mappableMediaTypes.Contains(mediaType))
-                    testData.Add(new object[] { mediaType, false });
+                    testData.Add(new object?[] { mediaType, false });
                 else
-                    testData.Add(new object[] { mediaType, true });
+                    testData.Add(new object?[] { mediaType, true });
             }
 
             return testData;
@@ -151,7 +156,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateDiscCategoryTestData))]
         public void DiscCategoryLongNameTest(DiscCategory? discCategory, bool expectNull)
         {
-            string actual = discCategory.LongName();
+            var actual = discCategory.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -163,12 +168,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of DiscCategory values
         /// </summary>
         /// <returns>MemberData-compatible list of DiscCategory values</returns>
-        public static List<object[]> GenerateDiscCategoryTestData()
+        public static List<object?[]> GenerateDiscCategoryTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (DiscCategory? discCategory in Enum.GetValues(typeof(DiscCategory)))
             {
-                testData.Add(new object[] { discCategory, false });
+                testData.Add(new object?[] { discCategory, false });
             }
 
             return testData;
@@ -187,7 +192,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateDiscTypeTestData))]
         public void DiscTypeLongNameTest(DiscType? discType, bool expectNull)
         {
-            string actual = discType.LongName();
+            var actual = discType.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -199,15 +204,15 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of DiscType values
         /// </summary>
         /// <returns>MemberData-compatible list of DiscType values</returns>
-        public static List<object[]> GenerateDiscTypeTestData()
+        public static List<object?[]> GenerateDiscTypeTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
             {
                 if (discType == DiscType.NONE)
-                    testData.Add(new object[] { discType, true });
+                    testData.Add(new object?[] { discType, true });
                 else
-                    testData.Add(new object[] { discType, false });
+                    testData.Add(new object?[] { discType, false });
             }
 
             return testData;
@@ -226,7 +231,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateLanguageTestData))]
         public void LanguageLongNameTest(Language? language, bool expectNull)
         {
-            string actual = language.LongName();
+            var actual = language.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -243,7 +248,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateLanguageTestData))]
         public void LanguageShortNameTest(Language? language, bool expectNull)
         {
-            string actual = language.ShortName();
+            var actual = language.ShortName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -263,8 +268,8 @@ namespace MPF.Test.RedumpLib
             int totalCount = 0;
             foreach (Language? language in fullLanguages)
             {
-                string code = language.TwoLetterCode();
-                if (string.IsNullOrWhiteSpace(code))
+                var code = language.TwoLetterCode();
+                if (string.IsNullOrEmpty(code))
                     continue;
 
                 // Throw if the code already exists
@@ -290,8 +295,8 @@ namespace MPF.Test.RedumpLib
             int totalCount = 0;
             foreach (Language? language in fullLanguages)
             {
-                string code = language.ThreeLetterCode();
-                if (string.IsNullOrWhiteSpace(code))
+                var code = language.ThreeLetterCode();
+                if (string.IsNullOrEmpty(code))
                     continue;
 
                 // Throw if the code already exists
@@ -317,8 +322,8 @@ namespace MPF.Test.RedumpLib
             int totalCount = 0;
             foreach (Language? language in fullLanguages)
             {
-                string code = language.ThreeLetterCodeAlt();
-                if (string.IsNullOrWhiteSpace(code))
+                var code = language.ThreeLetterCodeAlt();
+                if (string.IsNullOrEmpty(code))
                     continue;
 
                 // Throw if the code already exists
@@ -336,12 +341,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of Language values
         /// </summary>
         /// <returns>MemberData-compatible list of Language values</returns>
-        public static List<object[]> GenerateLanguageTestData()
+        public static List<object?[]> GenerateLanguageTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (Language? language in Enum.GetValues(typeof(Language)))
             {
-                testData.Add(new object[] { language, false });
+                testData.Add(new object?[] { language, false });
             }
 
             return testData;
@@ -360,7 +365,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateLanguageSelectionTestData))]
         public void LanguageSelectionLongNameTest(LanguageSelection? languageSelection, bool expectNull)
         {
-            string actual = languageSelection.LongName();
+            var actual = languageSelection.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -372,12 +377,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of LanguageSelection values
         /// </summary>
         /// <returns>MemberData-compatible list of LanguageSelection values</returns>
-        public static List<object[]> GenerateLanguageSelectionTestData()
+        public static List<object?[]> GenerateLanguageSelectionTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (LanguageSelection? languageSelection in Enum.GetValues(typeof(LanguageSelection)))
             {
-                testData.Add(new object[] { languageSelection, false });
+                testData.Add(new object?[] { languageSelection, false });
             }
 
             return testData;
@@ -396,7 +401,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateMediaTypeTestData))]
         public void MediaTypeLongNameTest(MediaType? mediaType, bool expectNull)
         {
-            string actual = mediaType.LongName();
+            var actual = mediaType.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -413,7 +418,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateMediaTypeTestData))]
         public void MediaTypeShortNameTest(MediaType? mediaType, bool expectNull)
         {
-            string actual = mediaType.ShortName();
+            var actual = mediaType.ShortName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -425,12 +430,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of MediaType values
         /// </summary>
         /// <returns>MemberData-compatible list of MediaType values</returns>
-        public static List<object[]> GenerateMediaTypeTestData()
+        public static List<object?[]> GenerateMediaTypeTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
             {
-                testData.Add(new object[] { mediaType, false });
+                testData.Add(new object?[] { mediaType, false });
             }
 
             return testData;
@@ -449,7 +454,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateRegionTestData))]
         public void RegionLongNameTest(Region? region, bool expectNull)
         {
-            string actual = region.LongName();
+            var actual = region.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -466,7 +471,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateRegionTestData))]
         public void RegionShortNameTest(Region? region, bool expectNull)
         {
-            string actual = region.ShortName();
+            var actual = region.ShortName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -486,8 +491,8 @@ namespace MPF.Test.RedumpLib
             int totalCount = 0;
             foreach (Region? region in fullRegions)
             {
-                string code = region.ShortName();
-                if (string.IsNullOrWhiteSpace(code))
+                var code = region.ShortName();
+                if (string.IsNullOrEmpty(code))
                     continue;
 
                 // Throw if the code already exists
@@ -505,12 +510,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of Region values
         /// </summary>
         /// <returns>MemberData-compatible list of Region values</returns>
-        public static List<object[]> GenerateRegionTestData()
+        public static List<object?[]> GenerateRegionTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (Region? region in Enum.GetValues(typeof(Region)))
             {
-                testData.Add(new object[] { region, false });
+                testData.Add(new object?[] { region, false });
             }
 
             return testData;
@@ -529,7 +534,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateSiteCodeTestData))]
         public void SiteCodeLongNameTest(SiteCode? siteCode, bool expectNull)
         {
-            string actual = siteCode.LongName();
+            var actual = siteCode.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -546,7 +551,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateSiteCodeTestData))]
         public void SiteCodeShortNameTest(SiteCode? siteCode, bool expectNull)
         {
-            string actual = siteCode.ShortName();
+            var actual = siteCode.ShortName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -558,12 +563,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of SiteCode values
         /// </summary>
         /// <returns>MemberData-compatible list of SiteCode values</returns>
-        public static List<object[]> GenerateSiteCodeTestData()
+        public static List<object?[]> GenerateSiteCodeTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (SiteCode? siteCode in Enum.GetValues(typeof(SiteCode)))
             {
-                testData.Add(new object[] { siteCode, false });
+                testData.Add(new object?[] { siteCode, false });
             }
 
             return testData;
@@ -573,17 +578,6 @@ namespace MPF.Test.RedumpLib
 
         #region System
 
-        /// <summary>
-        /// RedumpSystem values that are considered markers and not real systems
-        /// </summary>
-        private static readonly RedumpSystem?[] _markerSystemTypes = new RedumpSystem?[]
-        {
-            RedumpSystem.MarkerArcadeEnd,
-            RedumpSystem.MarkerComputerEnd,
-            RedumpSystem.MarkerDiscBasedConsoleEnd,
-            RedumpSystem.MarkerOtherEnd,
-        };
-
         /// <summary>
         /// Check that every RedumpSystem has a long name provided
         /// </summary>
@@ -593,7 +587,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateRedumpSystemTestData))]
         public void RedumpSystemLongNameTest(RedumpSystem? redumpSystem, bool expectNull)
         {
-            string actual = redumpSystem.LongName();
+            var actual = redumpSystem.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -628,16 +622,16 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of RedumpSystem values
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateRedumpSystemTestData()
+        public static List<object?[]> GenerateRedumpSystemTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
             {
                 // We want to skip all markers for this
-                if (_markerSystemTypes.Contains(redumpSystem))
+                if (redumpSystem.IsMarker())
                     continue;
 
-                testData.Add(new object[] { redumpSystem, false });
+                testData.Add(new object?[] { redumpSystem, false });
             }
 
             return testData;
@@ -656,7 +650,7 @@ namespace MPF.Test.RedumpLib
         [MemberData(nameof(GenerateSystemCategoryTestData))]
         public void SystemCategoryLongNameTest(SystemCategory? systemCategory, bool expectNull)
         {
-            string actual = systemCategory.LongName();
+            var actual = systemCategory.LongName();
 
             if (expectNull)
                 Assert.Null(actual);
@@ -668,15 +662,15 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of SystemCategory values
         /// </summary>
         /// <returns>MemberData-compatible list of SystemCategory values</returns>
-        public static List<object[]> GenerateSystemCategoryTestData()
+        public static List<object?[]> GenerateSystemCategoryTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, true } };
+            var testData = new List<object?[]>() { new object?[] { null, true } };
             foreach (SystemCategory? systemCategory in Enum.GetValues(typeof(SystemCategory)))
             {
                 if (systemCategory == SystemCategory.NONE)
-                    testData.Add(new object[] { systemCategory, true });
+                    testData.Add(new object?[] { systemCategory, true });
                 else
-                    testData.Add(new object[] { systemCategory, false });
+                    testData.Add(new object?[] { systemCategory, false });
             }
 
             return testData;
@@ -707,12 +701,12 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of YesNo values
         /// </summary>
         /// <returns>MemberData-compatible list of YesNo values</returns>
-        public static List<object[]> GenerateYesNoTestData()
+        public static List<object?[]> GenerateYesNoTestData()
         {
-            var testData = new List<object[]>() { new object[] { null, false } };
+            var testData = new List<object?[]>() { new object?[] { null, false } };
             foreach (YesNo? yesNo in Enum.GetValues(typeof(YesNo)))
             {
-                testData.Add(new object[] { yesNo, false });
+                testData.Add(new object?[] { yesNo, false });
             }
 
             return testData;

MPF.Test/RedumpLib/SubmissionInfoTests.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Newtonsoft.Json;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.RedumpLib
@@ -42,7 +42,8 @@ namespace MPF.Test.RedumpLib
             var submissionInfo = new SubmissionInfo()
             {
                 SchemaVersion = 1,
-                MatchedIDs = new List<int> { 0, 1, 2, 3 },
+                FullyMatchedID = 3,
+                PartiallyMatchedIDs = new List<int> { 0, 1, 2, 3 },
                 Added = DateTime.UtcNow,
                 LastModified = DateTime.UtcNow,
 
@@ -80,12 +81,12 @@ namespace MPF.Test.RedumpLib
                     EXEDateBuildDate = "19xx-xx-xx",
                     ErrorsCount = "0",
                     Comments = "Comment data line 1\r\nComment data line 2",
-                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.ISBN] = "ISBN",
                     },
                     Contents = "Special contents 1\r\nSpecial contents 2",
-                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
                     {
                         [SiteCode.PlayableDemos] = "Game Demo 1",
                     },
@@ -132,7 +133,7 @@ namespace MPF.Test.RedumpLib
 
                 DumpersAndStatus = new DumpersAndStatusSection()
                 {
-                    Status = DumpStatus.TwoOrMoHumanReadablesGreen,
+                    Status = DumpStatus.TwoOrMoreGreen,
                     Dumpers = new string[] { "Dumper1", "Dumper2" },
                     OtherDumpers = "Dumper3",
                 },
@@ -156,6 +157,16 @@ namespace MPF.Test.RedumpLib
                     SHA1 = "SHA1",
                 },
 
+                DumpingInfo = new DumpingInfoSection()
+                {
+                    DumpingProgram = "DiscImageCreator 20500101",
+                    DumpingDate = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"),
+                    Manufacturer = "ATAPI",
+                    Model = "Optical Drive",
+                    Firmware = "1.23",
+                    ReportedDiscType = "CD-R",
+                },
+
                 Artifacts = new Dictionary<string, string>()
                 {
                     ["Sample Artifact"] = "Sample Data",

MPF.Test/UI/AllowedSpeedsTest.cs

@@ -1,6 +1,5 @@
-using System.Linq;
-using MPF.Core.Data;
-using RedumpLib.Data;
+using MPF.Core.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Data
@@ -16,7 +15,7 @@ namespace MPF.Test.Data
         public void GetAllowedDriveSpeedForMediaTypeTest(MediaType? mediaType, int maxExpected)
         {
             var actual = Interface.GetSpeedsForMediaType(mediaType);
-            Assert.Equal(maxExpected, actual.Last());
+            Assert.Equal(maxExpected, actual[actual.Count - 1]);
         }
     }
 }

MPF.UI.Core/Constants.cs

@@ -2,24 +2,26 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Media;
+using static MPF.Core.Data.Interface;
 
-namespace MPF
+namespace MPF.UI.Core
 {
     /// <summary>
     /// Variables for UI elements
     /// </summary>
     public static class Constants
     {
-        // Private lists of known drive speed ranges
-        private static IReadOnlyList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
-        private static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
-        private static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
-
         // Create collections for UI based on known drive speeds
         public static DoubleCollection SpeedsForCDAsCollection { get; } = GetDoubleCollectionFromIntList(CD);
         public static DoubleCollection SpeedsForDVDAsCollection { get; } = GetDoubleCollectionFromIntList(DVD);
+        public static DoubleCollection SpeedsForHDDVDAsCollection { get; } = GetDoubleCollectionFromIntList(HDDVD);
         public static DoubleCollection SpeedsForBDAsCollection { get; } = GetDoubleCollectionFromIntList(BD);
+
+#if NET20 || NET35 || NET40
+        private static DoubleCollection GetDoubleCollectionFromIntList(IList<int> list)
+#else
         private static DoubleCollection GetDoubleCollectionFromIntList(IReadOnlyList<int> list)
-            => new DoubleCollection(list.Select(i => Convert.ToDouble(i)).ToList());
+#endif
+            => new(list.Select(i => Convert.ToDouble(i)).ToList());
     }
 }

MPF.UI.Core/ElementConverter.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.UI.Core
+{
+    internal class ElementConverter: IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return value switch
+            {
+                DiscCategory discCategory => new Element<DiscCategory>(discCategory),
+                InternalProgram internalProgram => new Element<InternalProgram>(internalProgram),
+                MediaType mediaType => new Element<MediaType>(mediaType),
+                RedumperReadMethod readMethod => new Element<RedumperReadMethod>(readMethod),
+                RedumperSectorOrder sectorOrder => new Element<RedumperSectorOrder>(sectorOrder),
+                RedumpSystem redumpSystem => new RedumpSystemComboBoxItem(redumpSystem),
+                Region region => new Element<Region>(region),
+
+                // Null values are treated as a system value
+                _ => new RedumpSystemComboBoxItem((RedumpSystem?)null),
+            };
+        }
+
+        public object? ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            // If it's an IElement but ends up null
+            if (value is not IElement element)
+                return null;
+
+            return element switch
+            {
+                Element<DiscCategory> dcElement => dcElement.Value,
+                Element<InternalProgram> ipElement => ipElement.Value,
+                Element<MediaType> mtElement => mtElement.Value,
+                Element<RedumperReadMethod> rmElement => rmElement.Value,
+                Element<RedumperSectorOrder> soElement => soElement.Value,
+                RedumpSystemComboBoxItem rsElement => rsElement.Value,
+                Element<Region> reValue => reValue.Value,
+                _ => null,
+            };
+        }
+    }
+}

MPF.UI.Core/External/WPFCustomMessageBox/CustomMessageBox.cs

@@ -18,7 +18,7 @@ namespace WPFCustomMessageBox
         /// Global parameter to enable (true) or disable (false) the removal of the title bar icon.
         /// If you are using a custom window style, the icon removal may cause issues like displaying two title bar (the default windows one and the custom one). 
         /// </summary>
-        public static bool RemoveTitleBarIcon = true;
+        private static readonly bool RemoveTitleBarIcon = true;
 
         /// <summary>
         /// Displays a message box that has a message and returns a result.
@@ -173,7 +173,7 @@ namespace WPFCustomMessageBox
         /// </param>
         /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
         /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
-        public static MessageBoxResult Show(Window owner, string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        public static MessageBoxResult Show(Window owner, string? messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
         {
             switch (button)
             {
@@ -515,11 +515,11 @@ namespace WPFCustomMessageBox
         /// <param name="timeout">The message box will close automatically after given milliseconds</param>
         /// <param name="timeoutResult">If the message box closes automatically due to <paramref name="timeout"/> being exceeded, this result is returned.</param>
         /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
-        private static MessageBoxResult ShowOKMessage(Window owner, string messageBoxText, string caption, string okButtonText, string cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        private static MessageBoxResult ShowOKMessage(Window? owner, string? messageBoxText, string caption, string? okButtonText, string? cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
         {
             MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.OK : MessageBoxButton.OKCancel;
 
-            CustomMessageBoxWindow msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
+            var msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
             if (!string.IsNullOrEmpty(okButtonText))
                 msg.OkButtonText = okButtonText;
             if (!string.IsNullOrEmpty(cancelButtonText))
@@ -545,11 +545,11 @@ namespace WPFCustomMessageBox
         /// <param name="timeout">The message box will close automatically after given milliseconds</param>
         /// <param name="timeoutResult">If the message box closes automatically due to <paramref name="timeout"/> being exceeded, this result is returned.</param>
         /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
-        private static MessageBoxResult ShowYesNoMessage(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        private static MessageBoxResult ShowYesNoMessage(Window? owner, string? messageBoxText, string caption, string? yesButtonText, string? noButtonText, string? cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
         {
             MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.YesNo : MessageBoxButton.YesNoCancel;
 
-            CustomMessageBoxWindow msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
+            var msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
             if (!string.IsNullOrEmpty(yesButtonText))
                 msg.YesButtonText = yesButtonText;
             if (!string.IsNullOrEmpty(noButtonText))
@@ -566,14 +566,14 @@ namespace WPFCustomMessageBox
         {
             if (timeout.HasValue && timeout.Value <= 0)
             {
-                throw new ArgumentOutOfRangeException("timeout", string.Format("Timeout must be greater than 0."));
+                throw new ArgumentOutOfRangeException(nameof(timeout), string.Format("Timeout must be greater than 0."));
             }
 
             if (timeout.HasValue)
             {
                 //System.Threading.Timer timer = null;
                 //timer = new System.Threading.Timer(s => { msg.Close(); timer.Dispose(); }, null, timeout.Value, System.Threading.Timeout.Infinite);
-                System.Timers.Timer timer = new System.Timers.Timer(timeout.Value) { AutoReset = false };
+                var timer = new System.Timers.Timer(timeout.Value) { AutoReset = false };
                 timer.Elapsed += delegate {
                     Application.Current.Dispatcher.Invoke(new Action(() =>
                     {

MPF.UI.Core/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml

@@ -4,16 +4,10 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         WindowStartupLocation="CenterScreen"
         WindowStyle="None"
-        ShowInTaskbar="False"
         ResizeMode="NoResize" SizeToContent="WidthAndHeight"
-        TextOptions.TextFormattingMode="Display" TextOptions.TextRenderingMode="ClearType" UseLayoutRounding="True"
         Title="" MinHeight="155" MaxWidth="470" MinWidth="154"
         BorderBrush="DarkGray" BorderThickness="2">
 
-    <WindowChrome.WindowChrome>
-        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
-    </WindowChrome.WindowChrome>
-
     <Grid>
         <Grid.RowDefinitions>
             <RowDefinition Height="*" />

MPF.UI.Core/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml.cs

@@ -0,0 +1,347 @@
+using System;
+using System.Drawing;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using MPF.UI.Core;
+
+#pragma warning disable IDE1006 // Naming Styles
+
+namespace WPFCustomMessageBox
+{
+    /// <summary>
+    /// Interaction logic for ModalDialog.xaml
+    /// </summary>
+    internal partial class CustomMessageBoxWindow : Window
+    {
+        private readonly bool _removeTitleBarIcon = true;
+
+        public string? Caption
+        {
+            get
+            {
+                return Title;
+            }
+            set
+            {
+                Title = value;
+            }
+        }
+
+        public string? Message
+        {
+            get
+            {
+#if NET35
+                return _TextBlock_Message!.Text;
+#else
+                return TextBlock_Message.Text;
+#endif
+            }
+            set
+            {
+#if NET35
+                _TextBlock_Message!.Text = value;
+#else
+                TextBlock_Message.Text = value;
+#endif
+            }
+        }
+
+        public string? OkButtonText
+        {
+            get
+            {
+#if NET35
+                return _Label_Ok!.Content.ToString();
+#else
+                return Label_Ok.Content.ToString();
+#endif
+            }
+            set
+            {
+#if NET35
+                _Label_Ok!.Content = value.TryAddKeyboardAccellerator();
+#else
+                Label_Ok.Content = value.TryAddKeyboardAccellerator();
+#endif
+            }
+        }
+
+        public string? CancelButtonText
+        {
+            get
+            {
+#if NET35
+                return _Label_Cancel!.Content.ToString();
+#else
+                return Label_Cancel.Content.ToString();
+#endif
+            }
+            set
+            {
+#if NET35
+                _Label_Cancel!.Content = value.TryAddKeyboardAccellerator();
+#else
+                Label_Cancel.Content = value.TryAddKeyboardAccellerator();
+#endif
+            }
+        }
+
+        public string? YesButtonText
+        {
+            get
+            {
+#if NET35
+                return _Label_Yes!.Content.ToString();
+#else
+                return Label_Yes.Content.ToString();
+#endif
+            }
+            set
+            {
+#if NET35
+                _Label_Yes!.Content = value.TryAddKeyboardAccellerator();
+#else
+                Label_Yes.Content = value.TryAddKeyboardAccellerator();
+#endif
+            }
+        }
+
+        public string? NoButtonText
+        {
+            get
+            {
+#if NET35
+                return _Label_No!.Content.ToString();
+#else
+                return Label_No.Content.ToString();
+#endif
+            }
+            set
+            {
+#if NET35
+                _Label_No!.Content = value.TryAddKeyboardAccellerator();
+#else
+                Label_No.Content = value.TryAddKeyboardAccellerator();
+#endif
+            }
+        }
+
+        public MessageBoxResult Result { get; set; }
+
+#if NET35
+
+        private Button? _Button_Cancel => ItemHelper.FindChild<Button>(this, "Button_Cancel");
+        private Button? _Button_No => ItemHelper.FindChild<Button>(this, "Button_No");
+        private Button? _Button_OK => ItemHelper.FindChild<Button>(this, "Button_OK");
+        private Button? _Button_Yes => ItemHelper.FindChild<Button>(this, "Button_Yes");
+        private System.Windows.Controls.Image? _Image_MessageBox => ItemHelper.FindChild<System.Windows.Controls.Image>(this, "Image_MessageBox");
+        private Label? _Label_Cancel => ItemHelper.FindChild<Label>(this, "Label_Cancel");
+        private Label? _Label_No => ItemHelper.FindChild<Label>(this, "Label_No");
+        private Label? _Label_Ok => ItemHelper.FindChild<Label>(this, "Label_Ok");
+        private Label? _Label_Yes => ItemHelper.FindChild<Label>(this, "Label_Yes");
+        private TextBlock? _TextBlock_Message => ItemHelper.FindChild<TextBlock>(this, "TextBlock_Message");
+
+#endif
+
+        internal CustomMessageBoxWindow(Window? owner, string? message, string? caption = null, MessageBoxButton? button = null, MessageBoxImage? image = null, bool removeTitleBarIcon = true)
+        {
+#if NET40_OR_GREATER || NETCOREAPP
+            System.Windows.Media.TextOptions.SetTextFormattingMode(this, System.Windows.Media.TextFormattingMode.Display);
+            System.Windows.Media.TextOptions.SetTextRenderingMode(this, System.Windows.Media.TextRenderingMode.ClearType);
+            UseLayoutRounding = true;
+#endif
+
+#if NET452_OR_GREATER || NETCOREAPP
+            var chrome = new System.Windows.Shell.WindowChrome
+            {
+                CaptionHeight = 0,
+                ResizeBorderThickness = new Thickness(0),
+            };
+            System.Windows.Shell.WindowChrome.SetWindowChrome(this, chrome);
+#endif
+
+#if NET40_OR_GREATER || NETCOREAPP
+            InitializeComponent();
+#endif
+
+            _removeTitleBarIcon = removeTitleBarIcon;
+            Focusable = true;
+            ShowActivated = true;
+            ShowInTaskbar = true;
+
+            if (owner != null && owner.IsLoaded)
+            {
+                Owner = owner;
+                WindowStartupLocation = WindowStartupLocation.CenterOwner;
+            }
+
+            Message = message;
+            Caption = caption;
+
+            DisplayButtons(button ?? MessageBoxButton.OK);
+
+            if (image.HasValue)
+                DisplayImage(image.Value);
+            else
+#if NET35
+                _Image_MessageBox!.Visibility = Visibility.Collapsed;
+#else
+                Image_MessageBox.Visibility = Visibility.Collapsed;
+#endif
+        }
+
+        protected override void OnSourceInitialized(EventArgs e)
+        {
+            if (_removeTitleBarIcon)
+                Util.RemoveIcon(this);
+
+            base.OnSourceInitialized(e);
+        }
+
+        private void DisplayButtons(MessageBoxButton button)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.OKCancel:
+                    // Hide all but OK, Cancel
+#if NET35
+                    _Button_OK!.Visibility = Visibility.Visible;
+                    _Button_OK.Focus();
+                    _Button_Cancel!.Visibility = Visibility.Visible;
+
+                    _Button_Yes!.Visibility = Visibility.Collapsed;
+                    _Button_No!.Visibility = Visibility.Collapsed;
+#else
+                    Button_OK.Visibility = Visibility.Visible;
+                    Button_OK.Focus();
+                    Button_Cancel.Visibility = Visibility.Visible;
+
+                    Button_Yes.Visibility = Visibility.Collapsed;
+                    Button_No.Visibility = Visibility.Collapsed;
+#endif
+                    break;
+                case MessageBoxButton.YesNo:
+                    // Hide all but Yes, No
+#if NET35
+                    _Button_Yes!.Visibility = Visibility.Visible;
+                    _Button_Yes.Focus();
+                    _Button_No!.Visibility = Visibility.Visible;
+
+                    _Button_OK!.Visibility = Visibility.Collapsed;
+                    _Button_Cancel!.Visibility = Visibility.Collapsed;
+#else
+                    Button_Yes.Visibility = Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = Visibility.Visible;
+
+                    Button_OK.Visibility = Visibility.Collapsed;
+                    Button_Cancel.Visibility = Visibility.Collapsed;
+#endif
+                    break;
+                case MessageBoxButton.YesNoCancel:
+                    // Hide only OK
+#if NET35
+                    _Button_Yes!.Visibility = Visibility.Visible;
+                    _Button_Yes.Focus();
+                    _Button_No!.Visibility = Visibility.Visible;
+                    _Button_Cancel!.Visibility = Visibility.Visible;
+
+                    _Button_OK!.Visibility = Visibility.Collapsed;
+#else
+                    Button_Yes.Visibility = Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = Visibility.Visible;
+                    Button_Cancel.Visibility = Visibility.Visible;
+
+                    Button_OK.Visibility = Visibility.Collapsed;
+#endif
+                    break;
+                default:
+                    // Hide all but OK
+#if NET35
+                    _Button_OK!.Visibility = Visibility.Visible;
+                    _Button_OK.Focus();
+
+                    _Button_Yes!.Visibility = Visibility.Collapsed;
+                    _Button_No!.Visibility = Visibility.Collapsed;
+                    _Button_Cancel!.Visibility = Visibility.Collapsed;
+#else
+                    Button_OK.Visibility = Visibility.Visible;
+                    Button_OK.Focus();
+
+                    Button_Yes.Visibility = Visibility.Collapsed;
+                    Button_No.Visibility = Visibility.Collapsed;
+                    Button_Cancel.Visibility = Visibility.Collapsed;
+#endif
+                    break;
+            }
+        }
+
+        private void DisplayImage(MessageBoxImage image)
+        {
+            Icon icon;
+
+            switch (image)
+            {
+                case MessageBoxImage.Exclamation:       // Enumeration value 48 - also covers "Warning"
+                    icon = SystemIcons.Exclamation;
+                    break;
+                case MessageBoxImage.Error:             // Enumeration value 16, also covers "Hand" and "Stop"
+                    icon = SystemIcons.Hand;
+                    break;
+                case MessageBoxImage.Information:       // Enumeration value 64 - also covers "Asterisk"
+                    icon = SystemIcons.Information;
+                    break;
+                case MessageBoxImage.Question:
+                    icon = SystemIcons.Question;
+                    break;
+                default:
+                    icon = SystemIcons.Information;
+                    break;
+            }
+
+#if NET35
+            _Image_MessageBox!.Source = icon.ToImageSource();
+            _Image_MessageBox.Visibility = Visibility.Visible;
+#else
+            Image_MessageBox.Source = icon.ToImageSource();
+            Image_MessageBox.Visibility = Visibility.Visible;
+#endif
+        }
+
+        private void Button_OK_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.OK;
+            Close();
+        }
+
+        private void Button_Cancel_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.Cancel;
+            Close();
+        }
+
+        private void Button_Yes_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.Yes;
+            Close();
+        }
+
+        private void Button_No_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.No;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for Title MouseDown event
+        /// </summary>
+        private void TitleMouseDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+                this.DragMove();
+        }
+    }
+}

MPF.UI.Core/External/WPFCustomMessageBox/Util.cs

@@ -37,7 +37,7 @@ namespace WPFCustomMessageBox
         const int SWP_NOMOVE = 0x0002;
         const int SWP_NOZORDER = 0x0004;
         const int SWP_FRAMECHANGED = 0x0020;
-        const uint WM_SETICON = 0x0080;
+        //const uint WM_SETICON = 0x0080;
 
 
         internal static ImageSource ToImageSource(this Icon icon)
@@ -60,7 +60,7 @@ namespace WPFCustomMessageBox
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
-        internal static string TryAddKeyboardAccellerator(this string input)
+        internal static string? TryAddKeyboardAccellerator(this string? input)
         {
             if (input == null)
                 return input;
@@ -84,7 +84,7 @@ namespace WPFCustomMessageBox
             IntPtr hwnd = new WindowInteropHelper(window).Handle;
             // Change the extended window style to not show a window icon
             int extendedStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
-            SetWindowLong(hwnd, GWL_EXSTYLE, extendedStyle | WS_EX_DLGMODALFRAME);
+            _ = SetWindowLong(hwnd, GWL_EXSTYLE, extendedStyle | WS_EX_DLGMODALFRAME);
             // Update the window's non-client area to reflect the changes
             SetWindowPos(hwnd, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
         }

MPF.UI.Core/ItemHelper.cs

@@ -0,0 +1,124 @@
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows;
+
+namespace MPF.UI.Core
+{
+    internal static class ItemHelper
+    {
+        /// <summary>
+        /// Finds a Child of a given item in the visual tree. 
+        /// </summary>
+        /// <param name="parent">A direct parent of the queried item.</param>
+        /// <typeparam name="T">The type of the queried item.</typeparam>
+        /// <param name="childName">x:Name or Name of child. </param>
+        /// <returns>The first parent item that matches the submitted type parameter. 
+        /// If not matching item can be found, 
+        /// a null parent is being returned.</returns>
+        public static T? FindChild<T>(DependencyObject? parent, string childName) where T : DependencyObject
+        {
+            // Confirm parent and childName are valid. 
+            if (parent == null) return null;
+
+            T? foundChild = null;
+
+            if (parent is ItemsControl itemsControl && itemsControl.Items != null)
+            {
+                int childrenCount = itemsControl.Items.Count;
+                for (int i = 0; i < childrenCount; i++)
+                {
+                    var child = itemsControl.Items[i] as DependencyObject;
+
+                    // If the child is not of the request child type child
+                    if (child is not T)
+                    {
+                        // recursively drill down the tree
+                        foundChild = FindChild<T>(child, childName);
+
+                        // If the child is found, break so we do not overwrite the found child. 
+                        if (foundChild != null)
+                            break;
+                    }
+                    else if (!string.IsNullOrEmpty(childName))
+                    {
+                        // If the child's name is set for search
+                        if (child is FrameworkElement frameworkElement && frameworkElement.Name == childName)
+                        {
+                            // if the child's name is of the request name
+                            foundChild = (T)child;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        // child element found.
+                        foundChild = (T)child;
+                        break;
+                    }
+                }
+            }
+            else if (parent is ContentControl contentControl && contentControl.Content != null)
+            {
+                var child = contentControl.Content as DependencyObject;
+
+                // If the child is not of the request child type child
+                if (child is not T)
+                {
+                    // recursively drill down the tree
+                    foundChild = FindChild<T>(child, childName);
+                }
+                else if (!string.IsNullOrEmpty(childName))
+                {
+                    // If the child's name is set for search
+                    if (child is FrameworkElement frameworkElement && frameworkElement.Name == childName)
+                    {
+                        // if the child's name is of the request name
+                        foundChild = (T)child;
+                    }
+                }
+                else
+                {
+                    // child element found.
+                    foundChild = (T)child;
+                }
+            }
+            else if (parent is Visual)
+            {
+                int childrenCount = VisualTreeHelper.GetChildrenCount(parent);
+                for (int i = 0; i < childrenCount; i++)
+                {
+                    var child = VisualTreeHelper.GetChild(parent, i);
+
+                    // If the child is not of the request child type child
+                    if (child is not T)
+                    {
+                        // recursively drill down the tree
+                        foundChild = FindChild<T>(child, childName);
+
+                        // If the child is found, break so we do not overwrite the found child. 
+                        if (foundChild != null)
+                            break;
+                    }
+                    else if (!string.IsNullOrEmpty(childName))
+                    {
+                        // If the child's name is set for search
+                        if (child is FrameworkElement frameworkElement && frameworkElement.Name == childName)
+                        {
+                            // if the child's name is of the request name
+                            foundChild = (T)child;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        // child element found.
+                        foundChild = (T)child;
+                        break;
+                    }
+                }
+            }
+
+            return foundChild;
+        }
+    }
+}

MPF.UI.Core/MPF.UI.Core.csproj

@@ -0,0 +1,60 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
+  <PropertyGroup>
+    <!-- Assembly Properties -->
+    <TargetFrameworks>net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0-windows;net6.0-windows;net7.0-windows;net8.0-windows</TargetFrameworks>
+    <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <ImportFrameworkWinFXTargets Condition="$(TargetFramework.StartsWith(`net3`))">true</ImportFrameworkWinFXTargets>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <UseWindowsForms>true</UseWindowsForms>
+    <UseWPF>true</UseWPF>
+    <VersionPrefix>3.1.6</VersionPrefix>
+
+    <!-- Package Properties -->
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Description>Common code for all MPF UI implementations</Description>
+    <Copyright>Copyright (c) Matt Nadareski 2019-2024</Copyright>
+    <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Resource Include="Images\ring-code-guide-1-layer.png" />
+    <Resource Include="Images\ring-code-guide-2-layer.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+  </ItemGroup>
+
+  <!-- Support for old .NET versions -->
+  <ItemGroup Condition="$(TargetFramework.StartsWith(`net3`))">
+    <Reference Include="PresentationBuildTasks" HintPath="$(ProgramFiles)\Reference Assemblies\Microsoft\Framework\v3.0\PresentationBuildTasks.dll" />
+    <Reference Include="PresentationCore" HintPath="$(ProgramFiles)\Reference Assemblies\Microsoft\Framework\v3.0\PresentationCore.dll" />
+    <Reference Include="PresentationFramework" HintPath="$(ProgramFiles)\Reference Assemblies\Microsoft\Framework\v3.0\PresentationFramework.dll" />
+    <Reference Include="WindowsBase" HintPath="$(ProgramFiles)\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.6" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Page Update="UserControls\UserInput.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+    <Page Update="Windows\DiscInformationWindow.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+    <Page Update="Windows\RingCodeGuideWindow.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+  </ItemGroup>
+</Project>