Bump version

* add _drive.txt file to GetOutputFiles for UmdImageCreator

* remove required from _drive

* disc -> drive

.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 6.0 has 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](https://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 6.0 has 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](https://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 6.0 has known issues, please try using another build to reproduce the error
+- Is it copy protection related? If so, report the issue [here](https://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,14 +25,15 @@ What version are you using?
 **Build**
 What runtime version are you using?
 
-- [ ] .NET Framework 4.8 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, win-arm64, linux-x64, linux-arm64, osx-x64, osx-arm64]
+        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_cli.yml

@@ -0,0 +1,50 @@
+name: MPF CLI
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        project: [MPF.CLI]
+        runtime: [win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64, osx-arm64]
+        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_nupkg.yml

@@ -0,0 +1,61 @@
+name: Nuget Pack
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+        
+    - name: Restore dependencies
+      run: dotnet restore
+      
+    - name: Pack
+      run: dotnet pack
+
+    - name: Upload Execution Contexts package
+      uses: actions/upload-artifact@v4
+      with:
+        name: 'Execution Contexts Package'
+        path: 'MPF.ExecutionContexts/bin/Release/*.nupkg'
+
+    - name: Upload Execution Contexts to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: 'MPF.ExecutionContexts/bin/Release/*.nupkg'
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True
+
+    - name: Upload Processors package
+      uses: actions/upload-artifact@v4
+      with:
+        name: 'Processors Package'
+        path: 'MPF.Processors/bin/Release/*.nupkg'
+
+    - name: Upload Execution Contexts to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: 'MPF.Processors/bin/Release/*.nupkg'
+        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,64 @@
+name: MPF UI
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        project: [MPF.UI]
+        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 DiscImageCreator
+      run: |
+        wget https://github.com/user-attachments/files/15521936/DiscImageCreator_20240601.zip
+        unzip -u DiscImageCreator_20240601.zip
+        mkdir -p MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Creator
+        mv Release_ANSI/* MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Creator/
+
+    - name: Bundle Redumper
+      run: |
+        wget https://github.com/superg/redumper/releases/download/build_371/redumper-2024.05.27_build371-win64.zip
+        unzip redumper-2024.05.27_build371-win64.zip
+        mkdir -p MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Redumper
+        mv redumper-2024.05.27_build371-win64/bin/redumper.exe MPF.UI/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

.vscode/launch.json

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

.vscode/tasks.json

@@ -3,22 +3,11 @@
     "tasks": [
         {
             "label": "build",
-            "command": "msbuild",
+            "command": "dotnet",
             "type": "process",
             "args": [
+                "build",
                 "${workspaceFolder}/MPF.sln",
-                "-property:RuntimeIdentifiers=win7-x64"
-            ],
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "publish",
-            "command": "msbuild",
-            "type": "process",
-            "args": [
-                "${workspaceFolder}/MPF/MPF.csproj",
-                "-target:Publish",
-                "-property:RuntimeIdentifiers=win7-x64"
             ],
             "problemMatcher": "$msCompile"
         },

CHANGELIST.md

@@ -1,3 +1,829 @@
+### 3.2.2 (2024-09-xx)
+
+- Clean up some Check options, add IRD option
+- Add Check flags for protection scan extras
+- Add comments around default options object
+- Fix usings ordering in ItemHelper
+- Add physical drive extensions to new tool
+- Fix build for older .NET
+- Move two extensions to a better location
+- Fix XGD3 SS ranges
+- Fix config location in OptionsLoader
+- Fix some CLI issues
+- Add more verbose requirement to CLI help
+- Quote input paths if needed
+- Allow separate mounted path for Linux
+- Fix cleaning XGD3 SS
+- Prepare Redumper for XGD support
+- Hash DMI and PFI files for XGD in Redumper
+- Support GD-ROM info for Redumper
+- Futureproof GD-ROM LD in Redumper
+- Make GD-ROM LD code nicer to read
+- Rename 2 XGD helper methods
+- Add bus encryption enabled method
+- Move BEE method to better location
+- Use new BEE method in code
+- Include serial for UMD
+- Remove GD-ROM version fallback method
+- Preemptively update Redumper Saturn support
+- Move MSXC parsing to PhysicalTool
+- Fix minor inconsistencies
+- Create some PlayStation helper methods
+- Remove redundant drive calls
+- Start preparing for better output file checks
+- Create currently-unused helper class
+- Make helper class more robust
+- Add unused GetOutputFiles method
+- Hook up GetOutputFiles in debug way
+- Replace GetLogFilePaths with common code
+- Move GetLogFilePaths to better location
+- Replace GenerateArtifacts with common code
+- Define new ArtifactKey field
+- Add artifact keys for all relevant files
+- Make GenerateArtifacts return a dictionary
+- Split new output file methods
+- Fix up some file path methods
+- Fix broken build
+- Rearrange some BaseProcessor methods
+- Fix new AddToArchive methods
+- Fix recursive issue in AddToArchive
+- Add unused passable func to OutputFile
+- Pass in new func for OutputFile
+- Use new func in Redumper
+- Add runtime error for improperly created artifacts
+- Minor tweaks to existing code
+- Add new, unused CheckAllOutputFilesExist variant
+- Rename new method to CheckRequiredFiles
+- Use simplified CheckAllOutputFilesExist
+- Create and use RegexOutputFile
+- Add archive override for RegexOutputFile
+- Less confusing implmentation of DatfileExists
+- Forgot the other locations
+- Add future XGD output files
+- Add and use CustomOutputFile
+- Fix access permissions of output file classes
+- Handle XGD required files
+- Forgot to assume directories don't exist
+- Fix typo in publisher identifiers
+- Ensure manufacturer files starting from 0 are zipped in redumper DVD (TurnedToast)
+- Add _drive.txt file to GetOutputFiles for UmdImageCreator (TurnedToast)
+
+### 3.2.1 (2024-08-05)
+
+- Add nuget packing for processors and contexts
+- Address build warnings for packages
+- Add Linux ARM64 as target by default
+- Fix nuget package naming
+- Forgot to upload packages to release
+- Add `osx-arm64` to libraries
+- Better support build matricies
+- Show script settings
+- Add flag values to script settings
+- Enable last runtime by default
+- Update README with new build matricies
+- Remove empty gitmodules
+- Purple
+- Separate themes into own namespace and files
+- Seal all theme classes
+- Add preliminary MPF.CLI
+- Add CLI build status to README
+- Add CLI information to README
+- Save default config values for CLI
+- Allow custom parameters for CLI
+- Load options before anything else
+- Dispose of stream when creating config
+- Try to make config safer for CLI
+- Blindly assume the path exists
+- Add CLI status output on runtime
+- Ensure tracks are assigned in Aaru
+- Custom theme colors
+- Use speed for CLI from configuration
+- Fix minimum number of args checks
+- Move GetDefaultSpeedForMediaType to common location
+- Move some Check-specific methods
+- Add some custom CLI parameters
+- Try out custom options classes
+- Simplify custom parameters warning
+- Fix CLI help text alignment
+- Bring Check and CLI in parity with param processing
+- Remove now-unncessary names
+- Don't set MediaType if parameters ambiguous
+- Fix parameters after extension change
+- Fix logic for deducing region from PlayStation ISN (JohnVeness)
+- Fix broken test logic
+- Remove RedumpLib tests
+- Change to generic wording in report (JohnVeness)
+- Add include artifacts flag for check, sanitize options
+- Remove old --protect-file mentions (JohnVeness)
+- Update RedumpLib to 1.4.1
+- Enable loading seed JSON (Deterous)
+
+### 3.2.0 (2024-06-20)
+
+- Create currently-unused processors
+- Move DataFile to Core.Data
+- Seal XBC processor
+- Migrate processor functionality
+- Remove now-unneeded parameters classes
+- Simplify access within processors
+- Rename Parameters to ExecutionContext
+- Ensure check-only implementations still work
+- Update to DIC 20240401
+- Update Redumper to build 329
+- Simplify mv command in build config
+- Fix subfolder issue from previous
+- Remove redundant BinaryReaderExtensions class
+- Use Logiqx model instead of internal one
+- Split some processing code
+- Remove unnecessary field in execution contexts
+- Slight tweak to deal with net20
+- Make some methods required for override
+- Remove dcdumper until further notice
+- Invert using statement in dump environment
+- Make options internal to dump environment
+- Split constants files into component parts
+- Remove odd code from Result class
+- Slight tweak to Result class variables
+- Move constants into related classes
+- Separate out artifact generation
+- Reduce surface area of generation method
+- Make GetLogFilePaths required
+- Handle version like category
+- Move PlayStation drive use mostly to helper
+- Separate out copy protection run
+- Remove duplicate GetFullFile method
+- Move GetBase64 to InfoTool
+- Remove another redundant GetFullFile
+- Clean up usings after moving methods
+- Remove Chime
+- Move string contents for UI to view model
+- Remove unused byte array constant
+- Fix net20, net35, and net40
+- Reduce processing queue sleep time
+- Move EnumConverter to Core.Data
+- Clean up usings
+- Separate out StringEventArgs
+- Use StringEventArgs more broadly
+- Make StringEventArgs more complete
+- Make implicit StringEventArgs bidirectional
+- Make implicit Result bidirectional
+- Rename Result to ResultEventArgs for consistency
+- Reduce accessors for DumpEnvironment
+- Better handle interface constants
+- Make StringEventArgs internally consistent
+- Remove use of "this" in ProcessingQueue
+- Use proper private variable naming in ProcessingQueue
+- Seal all execution contexts
+- Remove use of "this" in Drive
+- Move GetRedumpSystemFromVolumeLabel to InfoTool
+- Execution context is not needed to extract info
+- Remove other reference to execution context
+- Make processor private to DumpEnvironment
+- Make context private to DumpEnvironment
+- Make media type private to DumpEnvironment
+- Make system private to DumpEnvironment
+- Make drive private to DumpEnvironment
+- Simplify RequiredProgramsExist logic
+- Reduce complexity of ProcessSystem method
+- Remove unnecessary GetAntiModchipDetected method
+- Make GetCopyProtection signature easier to read
+- Move GetLibCryptDetected back to DIC processor
+- Make RunProtectionScanOnPath signature easier to read
+- Clean up usings
+- Remove automatic eject and reset options
+- Remove options from UI
+- Remove firmware output for Redumper (Deterous)
+- Merge EnumConverter and EnumExtensions
+- Move event args to root of Core
+- Move processing queue to root of Core
+- Move InfoTool to Core.Utilities
+- Move SubmissionInfoTool to Core.Utilities
+- Fix build
+- Rename Protection to ProtectionTool
+- Move ProtectionTool to Core.Utilities
+- Move Drive to root of Core
+- Move Options to root of Core
+- Move Enumerations to root of Core
+- Move ToInternalDriveType to Drive
+- Clean up EnumExtensions
+- Make FormattedVolumeLabel a method
+- Move GetRedumpSystem to MainViewModel
+- Rename Core.UI namespace to Core.Frontend
+- Move DumpEnvironment to Core.Frontend
+- Move Options to Core.Frontend
+- Remove useless using statement
+- Move OptionsLoader to Core.Frontend
+- Move Logging to Core.Frontend
+- Decouple InfoTool from processors
+- Rename SubmissionInfoTool to SubmissionGenerator
+- Move SubmissionGenerator to Core.Frontend
+- Move EnumExtensions to root of core
+- Move Options to root of Core
+- Decouple Frontend from execution contexts
+- Split Core.Frontend into separate library
+- Split Core.Processors into separate library
+- Split Core.ExecutionContexts into separate library
+- Rename Core.* libraries
+- Fix up visual solution
+- Move Aaru CICM code to Core
+- Clean up Core dependencies
+- Move Aaru CICM code to Processors
+- Merge UI.Core into main application
+- Rename main application to MPF.UI
+- Fix build scripts
+- Make protection file output required
+- Standardize PS1-5 outputs and parsing (Deterous)
+- Update Redumper to build 371
+- Tools always run in separate window
+- Move ConsoleLogger to Check CLI
+- Move ProcessingQueue to Frontend
+- Move LogLevel enum to Frontend
+- Create ProcessingTool and move some methods
+- Remove unused byte array helper methods
+- Move GetSupportStatus to DumpEnvironment
+- Call psxt001z direct from DIC processor
+- Move GetCopyProtection to ProtectionTool
+- Slight cleanup of InfoTool
+- Move ProtectionTool to Frontend
+- Move ToRedumper* methods to Options
+- Move ToMediaType to OptionsLoader
+- Move ListPrograms to OptionsLoader
+- Move DoesSupportDriveSpeed to DumpEnvironment
+- Move ToInternalProgram to Options
+- Centralize dumping program information gathering
+- Move drive-reading methods to Drive
+- Move output writing to DumpEnvironment
+- Move Xbox/X360 helpers to ProcessingTool
+- Move PS3 helpers to ProcessingTool
+- Clean up usings
+- Centralize PS1/2 region detection
+- Move ProgramSupportsMedia to MainViewModel
+- Rename Tools to VersionTool
+- Move VersionTool to root of Core
+- Move InfoTool to root of Core
+- Create FrontendTool and move some methods to it
+- Clear out InfoTool and remove
+- Merge VersionTool into FrontendTool
+- Move EnumExtensions to Frontend
+- Treat KP2 like PS2 in DIC
+- Slight readability cleanup in DIC
+- Hacky move of DIC-specific code
+- Remove Drive dependency from GenerateSubmissionInfo
+- Move Drive to Frontend
+- Move ResultEventArgs to Frontend
+- Remove unused reporter delegate
+- Move StringEventArgs to Frontend
+- Decouple execution contexts from Options class
+- Combine remaining Core into Frontend
+- Remove Core library, fix build
+- Create Frontend.Tools namespace
+- Remove magic strings from settings reading
+- Move Redumper enums to a better place
+- Fix one DIC parameter test
+- Ensure setting defaults are consistent
+- Move ToRedumper* back to EnumExtensions
+- Rearrange test classes to match new format
+- Fix logic for PS1-5 system information
+- Fix setting PS1-5 version on invalid
+- Fix setting Python 2 version on invalid
+- Clean up some ProcessSystem cases
+- Add PS3 info extraction for DIC
+- Update to DIC 20240601
+- Fix UI build workflow
+- Add update parameter to unzip
+- Handle Redumper .asus files
+- Handle Redumper .atip and .pma files
+- Simplify DIC DMI location finding
+- Move track full matching to separate loop
+- Fix... something with Linux publish script
+- Make match sets immutable
+- Update BinaryObjectScanner to 3.1.12
+- Fix excluding programs in nix script
+
+### 3.1.9a (2024-05-21)
+
+- Fix dictionary error in Redumper parsing
+- Fix overwriting placeholders in Redumper
+
+### 3.1.9 (2024-05-19)
+
+- Update Redumper to build 325
+- Fix CleanRip not pulling info (Deterous)
+- Fix XboxOne/XboxSX Filename bug (Deterous)
+- Trim PIC for XboxOne/XboxSX (Deterous)
+- Get volume label from UIC outputs
+- Add site code listing to Check
+- Update RedumpLib and related
+- Update BinaryObjectScanner to 3.1.11
+- Remove now-unused Hash enum
+- Use IO implementation of IniFile
+- Add Xbox Backup Creator support to MPF.Check (Deterous)
+- Update BinaryObjectScanner to 3.1.12
+- Prefer PlayStation info from Redumper logs (Deterous)
+
+### 3.1.8 (2024-05-09)
+
+- Option for default Redumper leadin retries (Deterous)
+- Omit false positives on formatting protections
+- Critical update to BinaryObjectScanner 3.1.10
+- Add _PFI.bin support for UIC
+
+### 3.1.7 (2024-04-28)
+
+- Critical update to BinaryObjectScanner 3.1.9
+
+### 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
@@ -814,7 +1640,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
@@ -827,4 +1653,4 @@
 
 ### 1.01d (2018-05-18)
 
--Combine IBM PC-CD options, misc fixes.
+-Combine IBM PC-CD options, misc fixes.

MPF.CLI/ConsoleLogger.cs

@@ -0,0 +1,25 @@
+using System;
+using BinaryObjectScanner;
+using MPF.Frontend;
+
+namespace MPF.CLI
+{
+    public static class ConsoleLogger
+    {
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, ResultEventArgs 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.CLI/MPF.CLI.csproj

@@ -0,0 +1,61 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.2.2</VersionPrefix>
+
+        <!-- Package Properties -->
+        <Title>MPF CLI</Title>
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>CLI frontend 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>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <!-- 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>
+        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" GeneratePathProperty="true">
+            <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <Content Include="$(PkgBinaryObjectScanner)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
+    </ItemGroup>
+
+</Project>

MPF.CLI/Program.cs

@@ -0,0 +1,339 @@
+using System;
+using System.IO;
+#if NET40
+using System.Threading.Tasks;
+#endif
+using BinaryObjectScanner;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.CLI
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Load options from the config file
+            var options = OptionsLoader.LoadFromConfig();
+            if (options.FirstRun)
+            {
+                // Application paths
+                options.AaruPath = "FILL ME IN";
+                options.DiscImageCreatorPath = "FILL ME IN";
+                options.RedumperPath = "FILL ME IN";
+                options.InternalProgram = InternalProgram.NONE;
+
+                // Reset first run
+                options.FirstRun = false;
+                OptionsLoader.SaveToConfig(options, saveDefault: true);
+            }
+
+            // Try processing the standalone arguments
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
+            {
+                if (standaloneProcessed == null)
+                    DisplayHelp();
+                return;
+            }
+
+            // Try processing the common arguments
+            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
+            if (!success)
+            {
+                DisplayHelp(error);
+                return;
+            }
+
+            // Validate the supplied credentials
+            (bool? _, string? message) = RedumpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).GetAwaiter().GetResult();
+            if (!string.IsNullOrEmpty(message))
+                Console.WriteLine(message);
+
+            // Process any custom parameters
+            (CommandOptions opts, int startIndex) = LoadFromArguments(args, options, startIndex: 2);
+            
+            // Validate the internal program
+            switch (options.InternalProgram)
+            {
+                case InternalProgram.Aaru:
+                    if (!File.Exists(options.AaruPath))
+                    {
+                        DisplayHelp("A path needs to be supplied for Aaru, exiting...");
+                        return;
+                    }
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    if (!File.Exists(options.DiscImageCreatorPath))
+                    {
+                        DisplayHelp("A path needs to be supplied for DIC, exiting...");
+                        return;
+                    }
+                    break;
+
+                case InternalProgram.Redumper:
+                    if (!File.Exists(options.RedumperPath))
+                    {
+                        DisplayHelp("A path needs to be supplied for Redumper, exiting...");
+                        return;
+                    }
+                    break;
+
+                default:
+                    DisplayHelp($"{options.InternalProgram} is not a supported dumping program, exiting...");
+                    break;
+            }
+
+            // Ensure we have the values we need
+            if (opts.CustomParams == null && (opts.DevicePath == null || opts.FilePath == null))
+            {
+                DisplayHelp("Both a device path and file path need to be supplied, exiting...");
+                return;
+            }
+
+            // Get the speed from the options
+            int speed = opts.DriveSpeed ?? FrontendTool.GetDefaultSpeedForMediaType(mediaType, options);
+
+            // Populate an environment
+            var drive = Drive.Create(null, opts.DevicePath ?? string.Empty);
+            var env = new DumpEnvironment(options,
+                opts.FilePath,
+                drive,
+                knownSystem,
+                mediaType,
+                options.InternalProgram,
+                parameters: null);
+
+            // Process the parameters
+            string? paramStr = opts.CustomParams ?? env.GetFullParameters(speed);
+            if (string.IsNullOrEmpty(paramStr))
+            {
+                DisplayHelp("No valid environment could be created, exiting...");
+                return;
+            }
+            env.SetExecutionContext(paramStr);
+
+            // Make new Progress objects
+            var resultProgress = new Progress<ResultEventArgs>();
+            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+            var protectionProgress = new Progress<ProtectionProgress>();
+            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+
+            // Invoke the dumping program
+            Console.WriteLine($"Invoking {options.InternalProgram} using '{paramStr}'");
+            var dumpResult = env.Run(resultProgress).GetAwaiter().GetResult();
+            Console.WriteLine(dumpResult.Message);
+            if (!dumpResult)
+                return;
+
+            // If it was not a dumping command
+            if (!env.IsDumpingCommand())
+            {
+                Console.WriteLine("Execution not recognized as dumping command, skipping processing...");
+                return;
+            }
+
+            // If we have a mounted path, replace the environment
+            if (opts.MountedPath != null && Directory.Exists(opts.MountedPath))
+            {
+                drive = Drive.Create(null, opts.MountedPath);
+                env = new DumpEnvironment(options,
+                    opts.FilePath,
+                    drive,
+                    knownSystem,
+                    mediaType,
+                    internalProgram: null,
+                    parameters: null);
+            }
+
+            // Finally, attempt to do the output dance
+#if NET40
+            var verifyTask = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress);
+            verifyTask.Wait();
+            var verifyResult = verifyTask.Result;
+#else
+            var verifyResult = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress).ConfigureAwait(false).GetAwaiter().GetResult();
+#endif
+            Console.WriteLine(verifyResult.Message);
+        }
+
+        /// <summary>
+        /// Display help for MPF.CLI
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        private static void DisplayHelp(string? error = null)
+        {
+            if (error != null)
+                Console.WriteLine(error);
+
+            Console.WriteLine("Usage:");
+            Console.WriteLine("MPF.CLI <mediatype> <system> [options]");
+            Console.WriteLine();
+            Console.WriteLine("Standalone Options:");
+            Console.WriteLine("-h, -?                  Show this help text");
+            Console.WriteLine("-lc, --listcodes        List supported comment/content site codes");
+            Console.WriteLine("-lm, --listmedia        List supported media types");
+            Console.WriteLine("-ls, --listsystems      List supported system types");
+            Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
+            Console.WriteLine();
+
+            Console.WriteLine("CLI Options:");
+            Console.WriteLine("-u, --use <program>            Override default dumping program");
+            Console.WriteLine("-d, --device <devicepath>      Physical drive path (Required if no custom parameters set)");
+            Console.WriteLine("-m, --mounted <dirpath>        Mounted filesystem path for additional checks");
+            Console.WriteLine("-f, --file \"<filepath>\"        Output file path (Required if no custom parameters set)");
+            Console.WriteLine("-s, --speed <speed>            Override default dumping speed");
+            Console.WriteLine("-c, --custom \"<params>\"        Custom parameters to use");
+            Console.WriteLine();
+
+            Console.WriteLine("Custom dumping parameters, if used, will fully replace the default parameters.");
+            Console.WriteLine("All dumping parameters need to be supplied if doing this.");
+            Console.WriteLine("Otherwise, both a drive path and output file path are required.");
+            Console.WriteLine();
+
+            Console.WriteLine("Mounted filesystem path is only recommended on OSes that require block");
+            Console.WriteLine("device dumping, usually Linux and macOS.");
+            Console.WriteLine();
+        }
+
+        /// <summary>
+        /// Load the current set of options from application arguments
+        /// </summary>
+        private static (CommandOptions, int) LoadFromArguments(string[] args, Frontend.Options options, int startIndex = 0)
+        {
+            // Create return values
+            var opts = new CommandOptions();
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+                return (opts, 0);
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return (opts, 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 = Frontend.Options.ToInternalProgram(internalProgram);
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = Frontend.Options.ToInternalProgram(internalProgram);
+                    startIndex++;
+                }
+
+                // Use a device path
+                else if (args[startIndex].StartsWith("-d=") || args[startIndex].StartsWith("--device="))
+                {
+                    opts.DevicePath = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-d" || args[startIndex] == "--device")
+                {
+                    opts.DevicePath = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Use a mounted path for physical checks
+                else if (args[startIndex].StartsWith("-m=") || args[startIndex].StartsWith("--mounted="))
+                {
+                    opts.MountedPath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-m" || args[startIndex] == "--mounted")
+                {
+                    opts.MountedPath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Use a file path
+                else if (args[startIndex].StartsWith("-f=") || args[startIndex].StartsWith("--file="))
+                {
+                    opts.FilePath = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-f" || args[startIndex] == "--file")
+                {
+                    opts.FilePath = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Set an override speed
+                else if (args[startIndex].StartsWith("-s=") || args[startIndex].StartsWith("--speed="))
+                {
+                    if (!int.TryParse(args[startIndex].Split('=')[1].Trim('"'), out int speed))
+                        speed = -1;
+
+                    opts.DriveSpeed = speed;
+                }
+                else if (args[startIndex] == "-s" || args[startIndex] == "--speed")
+                {
+                    if (!int.TryParse(args[startIndex + 1].Trim('"'), out int speed))
+                        speed = -1;
+
+                    opts.DriveSpeed = speed;
+                    startIndex++;
+                }
+
+                // Use a custom parameters
+                else if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--custom="))
+                {
+                    opts.CustomParams = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--custom")
+                {
+                    opts.CustomParams = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            return (opts, startIndex);
+        }
+
+        /// <summary>
+        /// Represents commandline options
+        /// </summary>
+        private class CommandOptions
+        {
+            /// <summary>
+            /// Path to the device to dump
+            /// </summary>
+            /// <remarks>Required if custom parameters are not set</remarks>
+            public string? DevicePath { get; set; } = null;
+
+            /// <summary>
+            /// Path to the mounted filesystem to check
+            /// </summary>
+            /// <remarks>Should only be used when the device path is not readable</remarks>
+            public string? MountedPath { get; set; } = null;
+
+            /// <summary>
+            /// Path to the output file
+            /// </summary>
+            /// <remarks>Required if custom parameters are not set</remarks>
+            public string? FilePath { get; set; } = null;
+
+            /// <summary>
+            /// Override drive speed
+            /// </summary>
+            public int? DriveSpeed { get; set; } = null;
+
+            /// <summary>
+            /// Custom parameters for dumping
+            /// </summary>
+            public string? CustomParams { get; set; } = null;
+        }
+    }
+}

MPF.Check/ConsoleLogger.cs

@@ -0,0 +1,25 @@
+using System;
+using BinaryObjectScanner;
+using MPF.Frontend;
+
+namespace MPF.Check
+{
+    public static class ConsoleLogger
+    {
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, ResultEventArgs 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.Check/MPF.Check.csproj

@@ -1,50 +1,65 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFrameworks>net48;net6.0</TargetFrameworks>
-    <RuntimeIdentifiers>win7-x64;win8-x64;win81-x64;win10-x64;linux-x64;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-2023</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.6.2</Version>
-    <AssemblyVersion>$(Version)</AssemblyVersion>
-    <FileVersion>$(Version)</FileVersion>
-    <IncludeSource>true</IncludeSource>
-    <IncludeSymbols>true</IncludeSymbols>
-  </PropertyGroup>
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.2.2</VersionPrefix>
 
-  <PropertyGroup>
-    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
-    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
-    <NrtShowRevision>false</NrtShowRevision>
-  </PropertyGroup>
+        <!-- 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>
-    <None Include="App.config" />
-  </ItemGroup>
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="2.8.0" GeneratePathProperty="true">
-      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.3">
-      <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>
+    <ItemGroup>
+        <None Include="App.config" />
+    </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
-    <ProjectReference Include="..\MPF.Library\MPF.Library.csproj" />
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
+    <!-- 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>
+        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" GeneratePathProperty="true">
+            <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <Content Include="$(PkgBinaryObjectScanner)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
+    </ItemGroup>
 
 </Project>

MPF.Check/Program.cs

@@ -1,12 +1,15 @@
 using System;
 using System.IO;
-using BurnOutSharp;
-using MPF.Core.Converters;
-using MPF.Core.Data;
-using MPF.Core.Utilities;
-using MPF.Library;
-using RedumpLib.Data;
-using RedumpLib.Web;
+#if NET40
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+using BinaryObjectScanner;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
 
 namespace MPF.Check
 {
@@ -14,31 +17,68 @@ namespace MPF.Check
     {
         public static void Main(string[] args)
         {
+            // Create a default options object
+            var options = new Frontend.Options()
+            {
+                // Internal Program
+                InternalProgram = InternalProgram.NONE,
+
+                // Extra Dumping Options
+                ScanForProtection = false,
+                AddPlaceholders = true,
+                PullAllInformation = false,
+                AddFilenameSuffix = false,
+                OutputSubmissionJSON = false,
+                IncludeArtifacts = false,
+                CompressLogFiles = false,
+                DeleteUnnecessaryFiles = false,
+                CreateIRDAfterDumping = false,
+
+                // Protection Scanning Options
+                ScanArchivesForProtection = true,
+                ScanPackersForProtection = false,
+                IncludeDebugProtectionInformation = false,
+                HideDriveLetters = false,
+
+                // Redump Login Information
+                RedumpUsername = null,
+                RedumpPassword = null,
+            };
+
             // Try processing the standalone arguments
-            if (ProcessStandaloneArguments(args))
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
+            {
+                if (standaloneProcessed == null)
+                    DisplayHelp();
                 return;
+            }
 
             // Try processing the common arguments
-            (bool success, MediaType mediaType, RedumpSystem? knownSystem) = ProcessCommonArguments(args);
+            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
             if (!success)
+            {
+                DisplayHelp(error);
                 return;
+            }
 
             // Loop through and process options
-            (Core.Data.Options options, string path, int startIndex) = OptionsLoader.LoadFromArguments(args, startIndex: 2);
+            (CommandOptions opts, int startIndex) = LoadFromArguments(args, options, startIndex: 2);
+            if (options.InternalProgram == InternalProgram.NONE)
+            {
+                DisplayHelp("A program name needs to be provided");
+                return;
+            }
 
             // Make new Progress objects
-            var resultProgress = new Progress<Result>();
-            resultProgress.ProgressChanged += ProgressUpdated;
+            var resultProgress = new Progress<ResultEventArgs>();
+            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
             var protectionProgress = new Progress<ProtectionProgress>();
-            protectionProgress.ProgressChanged += ProgressUpdated;
+            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
 
             // Validate the supplied credentials
-#if NET48 || NETSTANDARD2_1
-            (bool? _, string message) = RedumpWebClient.ValidateCredentials(options?.RedumpUsername, options?.RedumpPassword);
-#else
-            (bool? _, string message) = RedumpHttpClient.ValidateCredentials(options?.RedumpUsername, options?.RedumpPassword).ConfigureAwait(false).GetAwaiter().GetResult();
-#endif
-            if (!string.IsNullOrWhiteSpace(message))
+            (bool? _, string? message) = RedumpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).GetAwaiter().GetResult();
+            if (!string.IsNullOrEmpty(message))
                 Console.WriteLine(message);
 
             // Loop through all the rest of the args
@@ -55,14 +95,14 @@ namespace MPF.Check
                 string filepath = Path.GetFullPath(args[i].Trim('"'));
 
                 // Now populate an environment
-                Drive drive = null;
-                if (!string.IsNullOrWhiteSpace(path))
-                    drive = Drive.Create(null, path);
+                Drive? drive = null;
+                if (!string.IsNullOrEmpty(opts.DevicePath))
+                    drive = Drive.Create(null, opts.DevicePath!);
 
                 var env = new DumpEnvironment(options, filepath, drive, knownSystem, mediaType, internalProgram: null, parameters: null);
 
                 // Finally, attempt to do the output dance
-                var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress).ConfigureAwait(false).GetAwaiter().GetResult();
+                var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress, seedInfo: opts.Seed).GetAwaiter().GetResult();
                 Console.WriteLine(result.Message);
             }
         }
@@ -71,124 +111,229 @@ 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);
 
             Console.WriteLine("Usage:");
-            Console.WriteLine("MPF.Check.exe <mediatype> <system> [options] </path/to/output.cue/iso> ...");
+            Console.WriteLine("MPF.Check <mediatype> <system> [options] </path/to/output.cue/iso> ...");
             Console.WriteLine();
             Console.WriteLine("Standalone Options:");
             Console.WriteLine("-h, -?                  Show this help text");
+            Console.WriteLine("-lc, --listcodes        List supported comment/content site codes");
             Console.WriteLine("-lm, --listmedia        List supported media types");
             Console.WriteLine("-ls, --listsystems      List supported system types");
             Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
             Console.WriteLine();
 
             Console.WriteLine("Check Options:");
-            var supportedArguments = OptionsLoader.PrintSupportedArguments();
-            foreach (string argument in supportedArguments)
-            {
-                Console.WriteLine(argument);
-            }
+            Console.WriteLine("-u, --use <program>            Dumping program output type [REQUIRED]");
+            Console.WriteLine("    --load-seed <path>         Load a seed submission JSON for user information");
+            Console.WriteLine("    --no-placeholders          Disable placeholder values in submission info");
+            Console.WriteLine("    --create-ird               Create IRD from output files (PS3 only)");
+            Console.WriteLine("-c, --credentials <user> <pw>  Redump username and password");
+            Console.WriteLine("    --pull-all                 Pull all information from Redump (requires --credentials)");
+            Console.WriteLine("-p, --path <drivepath>         Physical drive path for additional checks");
+            Console.WriteLine("-s, --scan                     Enable copy protection scan (requires --path)");
+            Console.WriteLine("    --disable-archives         Disable scanning archives (requires --scan)");
+            Console.WriteLine("    --enable-packers           Enable scanning for packers (requires --scan)");
+            Console.WriteLine("    --enable-debug             Enable debug protection information (requires --scan)");
+            Console.WriteLine("    --hide-drive-letters       Hide drive letters from scan output (requires --scan)");
+            Console.WriteLine("-x, --suffix                   Enable adding filename suffix");
+            Console.WriteLine("-j, --json                     Enable submission JSON output");
+            Console.WriteLine("    --include-artifacts        Include artifacts in JSON (requires --json)");
+            Console.WriteLine("-z, --zip                      Enable log file compression");
+            Console.WriteLine("-d, --delete                   Enable unnecessary file deletion");
             Console.WriteLine();
         }
 
         /// <summary>
-        /// Process common arguments for all functionality
+        /// Load the current set of options from application arguments
         /// </summary>
-        /// <returns>True if all arguments pass, false otherwise</returns>
-        private static (bool, MediaType, RedumpSystem?) ProcessCommonArguments(string[] args)
+        private static (CommandOptions, int) LoadFromArguments(string[] args, Frontend.Options options, int startIndex = 0)
         {
-            // All other use requires at least 3 arguments
-            if (args.Length < 3)
+            // Create return values
+            var opts = new CommandOptions();
+
+            // These values require multiple parts to be active
+            bool scan = false,
+                enableArchives = true,
+                enablePackers = false,
+                enableDebug = false,
+                hideDriveLetters = false;
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+                return (opts, 0);
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return (opts, startIndex);
+
+            // Loop through the arguments and parse out values
+            for (; startIndex < args.Length; startIndex++)
             {
-                DisplayHelp("Invalid number of arguments");
-                return (false, MediaType.NONE, null);
+                // Use specific program
+                if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    string internalProgram = args[startIndex].Split('=')[1];
+                    options.InternalProgram = Frontend.Options.ToInternalProgram(internalProgram);
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = Frontend.Options.ToInternalProgram(internalProgram);
+                    startIndex++;
+                }
+
+                // Include seed info file
+                else if (args[startIndex].StartsWith("--load-seed="))
+                {
+                    string seedInfo = args[startIndex].Split('=')[1];
+                    opts.Seed = Builder.CreateFromFile(seedInfo);
+                }
+                else if (args[startIndex] == "--load-seed")
+                {
+                    string seedInfo = args[startIndex + 1];
+                    opts.Seed = Builder.CreateFromFile(seedInfo);
+                    startIndex++;
+                }
+
+                // Disable placeholder values in submission info
+                else if (args[startIndex].Equals("--no-placeholders"))
+                {
+                    options.AddPlaceholders = false;
+                }
+
+                // Create IRD from output files (PS3 only)
+                else if (args[startIndex].Equals("--create-ird"))
+                {
+                    options.CreateIRDAfterDumping = true;
+                }
+
+                // 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("--pull-all"))
+                {
+                    options.PullAllInformation = true;
+                }
+
+                // Use a device path for physical checks
+                else if (args[startIndex].StartsWith("-p=") || args[startIndex].StartsWith("--path="))
+                {
+                    opts.DevicePath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-p" || args[startIndex] == "--path")
+                {
+                    opts.DevicePath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Scan for protection (requires device path)
+                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
+                {
+                    scan = true;
+                }
+
+                // Disable scanning archives (requires --scan)
+                else if (args[startIndex].Equals("--disable-archives"))
+                {
+                    enableArchives = false;
+                }
+
+                // Enable scanning for packers (requires --scan)
+                else if (args[startIndex].Equals("--enable-packers"))
+                {
+                    enablePackers = true;
+                }
+
+                // Enable debug protection information (requires --scan)
+                else if (args[startIndex].Equals("--enable-debug"))
+                {
+                    enableDebug = true;
+                }
+
+                // Hide drive letters from scan output (requires --scan)
+                else if (args[startIndex].Equals("--hide-drive-letters"))
+                {
+                    hideDriveLetters = true;
+                }
+
+                // 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;
+                }
+
+                // Output submission JSON
+                else if (args[startIndex].Equals("--include-artifacts"))
+                {
+                    options.IncludeArtifacts = 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;
+                }
             }
 
-            // Check the MediaType
-            var mediaType = EnumConverter.ToMediaType(args[0].Trim('"'));
-            if (mediaType == MediaType.NONE)
-            {
-                DisplayHelp($"{args[0]} is not a recognized media type");
-                return (false, MediaType.NONE, null);
-            }
+            // Now deal with the complex options
+            options.ScanForProtection = scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.ScanArchivesForProtection = enableArchives && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.ScanPackersForProtection = enablePackers && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(opts.DevicePath);
 
-            // Check the RedumpSystem
-            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
-            if (knownSystem == null)
-            {
-                DisplayHelp($"{args[1]} is not a recognized system");
-                return (false, MediaType.NONE, null);
-            }
-
-            return (true, mediaType, knownSystem);
+            return (opts, startIndex);
         }
 
         /// <summary>
-        /// Process any standalone arguments for the program
+        /// Represents commandline options
         /// </summary>
-        /// <returns>True if one of the arguments was processed, false otherwise</returns>
-        private static bool ProcessStandaloneArguments(string[] args)
+        private class CommandOptions
         {
-            // Help options
-            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?")
-            {
-                DisplayHelp();
-                return true;
-            }
+            /// <summary>
+            /// Seed submission info from an input file
+            /// </summary>
+            public SubmissionInfo? Seed { get; set; } = null;
 
-            // 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>
-        /// 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}");
+            /// <summary>
+            /// Path to the device to scan
+            /// </summary>
+            public string? DevicePath { get; set; } = null;
         }
     }
 }

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/Converters/EnumConverter.cs

@@ -1,385 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.IO;
-using System.Reflection;
-#if NETFRAMEWORK
-using IMAPI2;
-#endif
-using MPF.Core.Data;
-using RedumpLib.Data;
-
-namespace MPF.Core.Converters
-{
-    public static class EnumConverter
-    {
-        #region Cross-enumeration conversions
-
-        /// <summary>
-        /// Convert drive type to internal version, if possible
-        /// </summary>
-        /// <param name="driveType">DriveType value to check</param>
-        /// <returns>InternalDriveType, if possible, null on error</returns>
-        public static InternalDriveType? ToInternalDriveType(this DriveType driveType)
-        {
-            switch (driveType)
-            {
-                case DriveType.CDRom:
-                    return InternalDriveType.Optical;
-                case DriveType.Fixed:
-                    return InternalDriveType.HardDisk;
-                case DriveType.Removable:
-                    return InternalDriveType.Removable;
-                default:
-                    return null;
-            }
-        }
-
-#if NETFRAMEWORK
-        /// <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
-
-        /// <summary>
-        /// Long name method cache
-        /// </summary>
-        private static readonly ConcurrentDictionary<Type, MethodInfo> LongNameMethods = new ConcurrentDictionary<Type, MethodInfo>();
-
-        /// <summary>
-        /// Get the string representation of a generic enumerable value
-        /// </summary>
-        /// <param name="value">Enum value to convert</param>
-        /// <returns>String representation of that value if possible, empty string on error</returns>
-        public static string GetLongName(Enum value)
-        {
-            try
-            {
-                var sourceType = value?.GetType();
-                sourceType = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
-
-                if (!LongNameMethods.TryGetValue(sourceType, out MethodInfo 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) });
-
-                    LongNameMethods.TryAdd(sourceType, method);
-                }
-
-                if (method != null)
-                    return method.Invoke(null, new[] { value }) as string;
-                else
-                    return string.Empty;
-            }
-            catch
-            {
-                // Converter is not implemented for the given type
-                return string.Empty;
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the InternalProgram enum values
-        /// </summary>
-        /// <param name="prog">InternalProgram value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(this InternalProgram? prog)
-        {
-            switch (prog)
-            {
-                #region Dumping support
-
-                case InternalProgram.Aaru:
-                    return "Aaru";
-                case InternalProgram.DD:
-                    return "dd";
-                case InternalProgram.DiscImageCreator:
-                    return "DiscImageCreator";
-                case InternalProgram.Redumper:
-                    return "redumper";
-
-                #endregion
-
-                #region Verification support only
-
-                case InternalProgram.CleanRip:
-                    return "CleanRip";
-
-                case InternalProgram.DCDumper:
-                    return "DCDumper";
-
-                case InternalProgram.UmdImageCreator:
-                    return "UmdImageCreator";
-
-                #endregion
-
-                case InternalProgram.NONE:
-                default:
-                    return "Unknown";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the InternalProgram enum value for a given string
-        /// </summary>
-        /// <param name="internalProgram">String value to convert</param>
-        /// <returns>InternalProgram represented by the string, if possible</returns>
-        public static InternalProgram ToInternalProgram(string internalProgram)
-        {
-            switch (internalProgram.ToLowerInvariant())
-            {
-                // 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;
-                case "rd":
-                case "redumper":
-                    return 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;
-
-                default:
-                    return InternalProgram.NONE;
-            }
-        }
-
-        /// <summary>
-        /// Get the MediaType enum value for a given string
-        /// </summary>
-        /// <param name="type">String value to convert</param>
-        /// <returns>MediaType represented by the string, if possible</returns>
-        public static MediaType ToMediaType(string type)
-        {
-            switch (type.ToLowerInvariant())
-            {
-                #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;
-
-                #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;
-
-                #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;
-
-                #endregion
-
-                // Unsorted Formats
-                case "cartridge":
-                    return MediaType.Cartridge;
-                case "ced":
-                case "rcaced":
-                case "rca ced":
-                case "videodisc":
-                case "rca videodisc":
-                    return MediaType.CED;
-
-                default:
-                    return MediaType.NONE;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Core/Data/Constants.cs

@@ -1,120 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using RedumpLib.Data;
-
-namespace MPF.Core.Data
-{
-    /// <summary>
-    /// Constant values for UI
-    /// </summary>
-    public static class Interface
-    {
-        // Button values
-        public const string StartDumping = "Start Dumping";
-        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 };
-
-        // 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> HDDVD { 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 };
-
-        /// <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>
-        public static IReadOnlyList<int> GetSpeedsForMediaType(MediaType? type)
-        {
-            switch (type)
-            {
-                case MediaType.CDROM:
-                case MediaType.GDROM:
-                    return CD;
-                case MediaType.DVD:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return DVD;
-                case MediaType.HDDVD:
-                    return HDDVD;
-                case MediaType.BluRay:
-                    return BD;
-                default:
-                    return Unknown;
-            }
-        }
-    }
-
-    /// <summary>
-    /// Template field values for submission info
-    /// </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 DumpingProgramField = "Dumping Program";
-        public const string DumpingDriveManufacturer = "Manufacturer";
-        public const string DumpingDriveModel = "Model";
-        public const string DumpingDriveFirmware = "Firmware";
-        public const string ReportedDiscType = "Reported Disc Type";
-        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 FullyMatchingIDField = "Fully Matching ID";
-        public const string PartiallyMatchingIDsField = "Partially 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)";
-        public const string DiscNotDetected = "Disc Not Detected";
-    }
-}

MPF.Core/Data/Drive.cs

@@ -1,650 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Microsoft.Management.Infrastructure;
-using Microsoft.Management.Infrastructure.Generic;
-using MPF.Core.Converters;
-using MPF.Core.Utilities;
-using RedumpLib.Data;
-#if NETFRAMEWORK
-using IMAPI2;
-#endif
-
-namespace MPF.Core.Data
-{
-    /// <summary>
-    /// Represents information for a single drive
-    /// </summary>
-    /// <remarks>
-    /// TODO: This needs to be less Windows-centric. Devices do not always have a single letter that can be used.
-    /// 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>
-        public InternalDriveType? InternalDriveType { get; set; }
-
-        /// <summary>
-        /// Drive partition format
-        /// </summary>
-        public string DriveFormat { get; private set; } = null;
-
-        /// <summary>
-        /// Windows drive path
-        /// </summary>
-        public string Name { get; private set; } = null;
-
-        /// <summary>
-        /// Represents if Windows has marked the drive as active
-        /// </summary>
-        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; private set; } = null;
-
-        #endregion
-
-        #region Derived Fields
-
-        /// <summary>
-        /// Media label as read by Windows, formatted to avoid odd outputs
-        /// </summary>
-        public string FormattedVolumeLabel
-        {
-            get
-            {
-                string volumeLabel = Template.DiscNotDetected;
-                if (this.MarkedActive)
-                {
-                    if (string.IsNullOrWhiteSpace(this.VolumeLabel))
-                        volumeLabel = "track";
-                    else
-                        volumeLabel = this.VolumeLabel;
-                }
-
-                foreach (char c in Path.GetInvalidFileNameChars())
-                    volumeLabel = volumeLabel.Replace(c, '_');
-
-                return volumeLabel;
-            }
-        }
-
-        /// <summary>
-        /// Windows drive letter
-        /// </summary>
-        public char Letter => this.Name == null || this.Name.Length == 0 ? '\0' : this.Name[0];
-
-        #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)
-        {
-            // Create a new, empty drive object
-            var drive = new Drive()
-            {
-                InternalDriveType = driveType,
-            };
-
-            // If we have an invalid device path, return null
-            if (string.IsNullOrWhiteSpace(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">True to ignore fixed drives from population, false otherwise</param>
-        /// <returns>Active drives, matched to labels, if possible</returns>
-        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
-        {
-            var drives = GetDriveList(ignoreFixedDrives);
-            drives = drives?.OrderBy(i => i.Letter)?.ToList();
-            return drives;
-        }
-
-        /// <summary>
-        /// Get the current media type from drive letter
-        /// </summary>
-        /// <returns></returns>
-        public (MediaType?, string) GetMediaType()
-        {
-            // 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 NET6_0_OR_GREATER
-            else
-                return GetMediaTypeFromSize();
-#endif
-
-            // Get the current drive information
-            string deviceId = null;
-            bool loaded = false;
-            try
-            {
-                // Get the device ID first
-                CimSession session = CimSession.Create(null);
-                var collection = session.QueryInstances("root\\CIMV2", "WQL", $"SELECT * FROM Win32_CDROMDrive WHERE Id = '{this.Letter}:\'");
-
-                foreach (CimInstance instance in collection)
-                {
-                    CimKeyedCollection<CimProperty> properties = instance.CimInstanceProperties;
-                    deviceId = (string)properties["DeviceID"]?.Value;
-                    loaded = (bool)properties["MediaLoaded"]?.Value;
-                }
-
-                // 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");
-
-#if NETFRAMEWORK
-
-                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);
-
-#else
-
-                return (null, "IMAPI2 recorder not supported");
-
-#endif
-            }
-            catch (Exception ex)
-            {
-                return (null, ex.Message);
-            }
-        }
-
-        /// <summary>
-        /// Get the current system from drive
-        /// </summary>
-        /// <param name="defaultValue"></param>
-        /// <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))
-                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();
-            if (systemFromLabel != null)
-                return systemFromLabel;
-
-            // Get a list of files for quicker checking
-            #region Consoles
-
-            // Bandai Playdia Quick Interactive System
-            try
-            {
-                List<string> files = Directory.EnumerateFiles(drivePath, "*", SearchOption.TopDirectoryOnly).ToList();
-
-                if (files.Any(f => f.EndsWith(".AJS", StringComparison.OrdinalIgnoreCase))
-                    && files.Any(f => f.EndsWith(".GLB", StringComparison.OrdinalIgnoreCase)))
-                {
-                    return RedumpSystem.BandaiPlaydiaQuickInteractiveSystem;
-                }
-            }
-            catch { }
-
-            // Mattel Fisher-Price iXL
-            if (File.Exists(Path.Combine(drivePath, "iXL", "iXLUpdater.exe")))
-            {
-                return RedumpSystem.MattelFisherPriceiXL;
-            }
-
-            // Microsoft Xbox 360
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "$SystemUpdate"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "$SystemUpdate")).Any()
-                    && this.TotalSize <= 500_000_000)
-                {
-                    return RedumpSystem.MicrosoftXbox360;
-                }
-            }
-            catch { }
-
-            // Microsoft Xbox One
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "MSXC"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "MSXC")).Any())
-                {
-                    return RedumpSystem.MicrosoftXboxOne;
-                }
-            }
-            catch { }
-
-            // Sega Dreamcast
-            if (File.Exists(Path.Combine(drivePath, "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")))
-            {
-                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");
-            if (File.Exists(systemCnfPath))
-            {
-                // Check for either BOOT or BOOT2
-                var systemCnf = new IniFile(systemCnfPath);
-                if (systemCnf.ContainsKey("BOOT"))
-                    return RedumpSystem.SonyPlayStation;
-                else if (systemCnf.ContainsKey("BOOT2"))
-                    return RedumpSystem.SonyPlayStation2;
-            }
-            else if (File.Exists(psxExePath))
-            {
-                return RedumpSystem.SonyPlayStation;
-            }
-
-            // Sony PlayStation 3
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "PS3_GAME"))
-                    || Directory.Exists(Path.Combine(drivePath, "PS3_UPDATE"))
-                    || File.Exists(Path.Combine(drivePath, "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 (File.Exists(Path.Combine(drivePath, "PS4", "UPDATE", "PS4UPDATE.PUP")))
-            {
-                return RedumpSystem.SonyPlayStation4;
-            }
-
-            // V.Tech V.Flash / V.Smile Pro
-            if (File.Exists(Path.Combine(drivePath, "0SYSTEM")))
-            {
-                return RedumpSystem.VTechVFlashVSmilePro;
-            }
-
-            #endregion
-
-            #region Computers
-
-            // Sharp X68000
-            if (File.Exists(Path.Combine(drivePath, "COMMAND.X")))
-            {
-                return RedumpSystem.SharpX68000;
-            }
-
-            #endregion
-
-            #region Video Formats
-
-            // BD-Video
-            if (Directory.Exists(Path.Combine(drivePath, "BDMV")))
-            {
-                // Technically BD-Audio has this as well, but it's hard to split that out right now
-                return RedumpSystem.BDVideo;
-            }
-
-            // DVD-Audio and DVD-Video
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "AUDIO_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "AUDIO_TS")).Any())
-                {
-                    return RedumpSystem.DVDAudio;
-                }
-
-                else if (Directory.Exists(Path.Combine(drivePath, "VIDEO_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VIDEO_TS")).Any())
-                {
-                    return RedumpSystem.DVDVideo;
-                }
-            }
-            catch { }
-
-            // HD-DVD-Video
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "HVDVD_TS"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "HVDVD_TS")).Any())
-                {
-                    return RedumpSystem.HDDVDVideo;
-                }
-            }
-            catch { }
-
-            // VCD
-            try
-            {
-                if (Directory.Exists(Path.Combine(drivePath, "VCD"))
-                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VCD")).Any())
-                {
-                    return RedumpSystem.VideoCD;
-                }
-            }
-            catch { }
-
-            #endregion
-
-            // Default return
-            return defaultValue;
-        }
-
-        /// <summary>
-        /// 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()
-        {
-            // If the volume label is empty, we can't do anything
-            if (string.IsNullOrWhiteSpace(this.VolumeLabel))
-                return null;
-
-            // Audio CD
-            if (this.VolumeLabel.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.AudioCD;
-
-            // Microsoft Xbox
-            if (this.VolumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.MicrosoftXbox;
-            else if (this.VolumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.MicrosoftXbox;
-
-            // Microsoft Xbox 360
-            if (this.VolumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.MicrosoftXbox360;
-            else if (this.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))
-            //    return RedumpSystem.MicrosoftXbox360; // Also for Xbox One?
-            //if (this.VolumeLabel.Equals("DVD_ROM", StringComparison.OrdinalIgnoreCase))
-            //    return RedumpSystem.MicrosoftXbox360;
-
-            // Sega Mega-CD / Sega-CD
-            if (this.VolumeLabel.Equals("Sega_CD", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.SegaMegaCDSegaCD;
-
-            // Sony PlayStation 3
-            if (this.VolumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.SonyPlayStation3;
-
-            // Sony PlayStation 4
-            if (this.VolumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.SonyPlayStation4;
-
-            // Sony PlayStation 5
-            if (this.VolumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
-                return RedumpSystem.SonyPlayStation5;
-
-            return null;
-        }
-
-        /// <summary>
-        /// Read a sector with a specified size from the drive
-        /// </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)
-        {
-            // Missing drive leter is not supported
-            if (string.IsNullOrEmpty(this.Name))
-                return null;
-
-            // We don't support negative sectors
-            if (num < 0)
-                return null;
-
-            // Wrap the following in case of device access errors
-            Stream fs = null;
-            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;
-            }
-            catch
-            {
-                return null;
-            }
-            finally
-            {
-                fs?.Dispose();
-            }
-        }
-
-        /// <summary>
-        /// Refresh the current drive information based on path
-        /// </summary>
-        public void RefreshDrive()
-        {
-            var driveInfo = DriveInfo.GetDrives().FirstOrDefault(d => d?.Name == this.Name);
-            this.PopulateFromDriveInfo(driveInfo);
-        }
-
-        #endregion
-
-        #region Helpers
-
-        /// <summary>
-        /// Get the media type for a device path based on size
-        /// </summary>
-        /// <returns>MediaType, null on error</returns>
-        private (MediaType?, string) GetMediaTypeFromSize()
-        {
-            if (this.TotalSize >= 0 && this.TotalSize < 800_000_000 && this.DriveFormat == "CDFS")
-                return (MediaType.CDROM, null);
-            else if (this.TotalSize >= 400_000_000 && this.TotalSize <= 8_540_000_000 && this.DriveFormat == "UDF")
-                return (MediaType.DVD, null);
-            else
-                return (MediaType.BluRay, null);
-        }
-
-        /// <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
-            List<Drive> drives = new List<Drive>();
-
-            // Get all standard supported drive types
-            try
-            {
-                drives = DriveInfo.GetDrives()
-                    .Where(d => desiredDriveTypes.Contains(d.DriveType))
-                    .Select(d => Create(EnumConverter.ToInternalDriveType(d.DriveType), d.Name))
-                    .ToList();
-            }
-            catch
-            {
-                return drives;
-            }
-
-            // Find and update all floppy drives
-            try
-            {
-                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)[0];
-                        drives.ForEach(d => { if (d.Letter == devId) { d.InternalDriveType = Data.InternalDriveType.Floppy; } });
-                    }
-                }
-            }
-            catch
-            {
-                // No-op
-            }
-
-            return drives;
-        }
-
-        #endregion
-    }
-}

MPF.Core/Data/IniFile.cs

@@ -1,296 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-
-namespace MPF.Core.Data
-{
-    public class IniFile : IDictionary<string, string>
-    {
-        private Dictionary<string, string> _keyValuePairs = new Dictionary<string, string>();
-
-        public string this[string key]
-        {
-            get
-            {
-                if (_keyValuePairs == null)
-                    _keyValuePairs = new Dictionary<string, string>();
-
-                key = key.ToLowerInvariant();
-                if (_keyValuePairs.ContainsKey(key))
-                    return _keyValuePairs[key];
-
-                return null;
-            }
-            set
-            {
-                if (_keyValuePairs == null)
-                    _keyValuePairs = new Dictionary<string, string>();
-
-                key = key.ToLowerInvariant();
-                _keyValuePairs[key] = value;
-            }
-        }
-
-        /// <summary>
-        /// Create an empty INI file
-        /// </summary>
-        public IniFile()
-        {
-        }
-
-        /// <summary>
-        /// Populate an INI file from path
-        /// </summary>
-        public IniFile(string path)
-        {
-            this.Parse(path);
-        }
-
-        /// <summary>
-        /// Populate an INI file from stream
-        /// </summary>
-        public IniFile(Stream stream)
-        {
-            this.Parse(stream);
-        }
-
-        /// <summary>
-        /// Add or update a key and value to the INI file
-        /// </summary>
-        public void AddOrUpdate(string key, string value)
-        {
-            _keyValuePairs[key.ToLowerInvariant()] = value;
-        }
-
-        /// <summary>
-        /// Remove a key from the INI file
-        /// </summary>
-        public void Remove(string key)
-        {
-            _keyValuePairs.Remove(key.ToLowerInvariant());
-        }
-
-        /// <summary>
-        /// Read an INI file based on the path
-        /// </summary>
-        public bool Parse(string path)
-        {
-            // If we don't have a file, we can't read it
-            if (!File.Exists(path))
-                return false;
-
-            using (var fileStream = File.OpenRead(path))
-            {
-                return Parse(fileStream);
-            }
-        }
-
-        /// <summary>
-        /// Read an INI file from a stream
-        /// </summary>
-        public bool Parse(Stream stream)
-        {
-            // If the stream is invalid or unreadable, we can't process it
-            if (stream == null || !stream.CanRead || stream.Position >= stream.Length - 1)
-                return false;
-
-            // Keys are case-insensitive by default
-            try
-            {
-                using (StreamReader sr = new StreamReader(stream))
-                {
-                    string section = string.Empty;
-                    while (!sr.EndOfStream)
-                    {
-                        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
-                    }
-                }
-            }
-            catch
-            {
-                // We don't care what the error was, just catch and return
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Write an INI file to a path
-        /// </summary>
-        public bool Write(string path)
-        {
-            // If we don't have a valid dictionary with values, we can't write out
-            if (_keyValuePairs == null || _keyValuePairs.Count == 0)
-                return false;
-
-            using (var fileStream = File.OpenWrite(path))
-            {
-                return Write(fileStream);
-            }
-        }
-
-        /// <summary>
-        /// Write an INI file to a stream
-        /// </summary>
-        public bool Write(Stream stream)
-        {
-            // If we don't have a valid dictionary with values, we can't write out
-            if (_keyValuePairs == null || _keyValuePairs.Count == 0)
-                return false;
-
-            // If the stream is invalid or unwritable, we can't output to it
-            if (stream == null || !stream.CanWrite || stream.Position >= stream.Length - 1)
-                return false;
-
-            try
-            {
-                using (StreamWriter sw = new StreamWriter(stream))
-                {
-                    // Order the dictionary by keys to link sections together
-                    var orderedKeyValuePairs = _keyValuePairs.OrderBy(kvp => kvp.Key);
-
-                    string section = string.Empty;
-                    foreach (var keyValuePair in orderedKeyValuePairs)
-                    {
-                        // Extract the key and value
-                        string key = keyValuePair.Key;
-                        string value = keyValuePair.Value;
-
-                        // We assume '.' is a section name separator
-                        if (key.Contains('.'))
-                        {
-                            // 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;
-                            }
-                        }
-
-                        // Now write out the key and value in a standardized way
-                        sw.WriteLine($"{key}={value}");
-                    }
-                }
-            }
-            catch
-            {
-                // We don't care what the error was, just catch and return
-                return false;
-            }
-
-            return true;
-        }
-
-        #region IDictionary Impelementations
-
-        public ICollection<string> Keys => ((IDictionary<string, string>)_keyValuePairs).Keys;
-
-        public ICollection<string> Values => ((IDictionary<string, string>)_keyValuePairs).Values;
-
-        public int Count => ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Count;
-
-        public bool IsReadOnly => ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).IsReadOnly;
-
-        public void Add(string key, string value)
-        {
-            ((IDictionary<string, string>)_keyValuePairs).Add(key.ToLowerInvariant(), value);
-        }
-
-        bool IDictionary<string, string>.Remove(string key)
-        {
-            return ((IDictionary<string, string>)_keyValuePairs).Remove(key.ToLowerInvariant());
-        }
-
-        public bool TryGetValue(string key, out string value)
-        {
-            return ((IDictionary<string, string>)_keyValuePairs).TryGetValue(key.ToLowerInvariant(), out value);
-        }
-
-        public void Add(KeyValuePair<string, string> item)
-        {
-            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
-            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Add(newItem);
-        }
-
-        public void Clear()
-        {
-            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Clear();
-        }
-
-        public bool Contains(KeyValuePair<string, string> item)
-        {
-            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
-            return ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Contains(newItem);
-        }
-
-        public bool ContainsKey(string key)
-        {
-            return _keyValuePairs.ContainsKey(key.ToLowerInvariant());
-        }
-
-        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
-        {
-            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).CopyTo(array, arrayIndex);
-        }
-
-        public bool Remove(KeyValuePair<string, string> item)
-        {
-            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
-            return ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Remove(newItem);
-        }
-
-        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
-        {
-            return ((IEnumerable<KeyValuePair<string, string>>)_keyValuePairs).GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return ((IEnumerable)_keyValuePairs).GetEnumerator();
-        }
-
-        #endregion
-    }
-}

MPF.Core/Data/Options.cs

@@ -1,700 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using MPF.Core.Converters;
-using RedumpLib.Data;
-
-namespace MPF.Core.Data
-{
-    public class Options : IDictionary<string, string>, ICloneable
-    {
-        private readonly Dictionary<string, string> _settings;
-
-        #region Internal Program
-
-        /// <summary>
-        /// Path to Aaru
-        /// </summary>
-        public string AaruPath
-        {
-            get { return GetStringSetting(_settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
-            set { _settings["AaruPath"] = value; }
-        }
-
-        /// <summary>
-        /// Path to DiscImageCreator
-        /// </summary>
-        public string DiscImageCreatorPath
-        {
-            get { return GetStringSetting(_settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
-            set { _settings["DiscImageCreatorPath"] = value; }
-        }
-
-        /// <summary>
-        /// Path to dd for Windows
-        /// </summary>
-        public string DDPath
-        {
-            get { return GetStringSetting(_settings, "DDPath", "Programs\\DD\\dd.exe"); }
-            set { _settings["DDPath"] = value; }
-        }
-
-        /// <summary>
-        /// Path to Redumper
-        /// </summary>
-        public string RedumperPath
-        {
-            get { return GetStringSetting(_settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
-            set { _settings["RedumperPath"] = value; }
-        }
-
-        /// <summary>
-        /// Currently selected dumping program
-        /// </summary>
-        public InternalProgram InternalProgram
-        {
-            get
-            {
-                string valueString = GetStringSetting(_settings, "InternalProgram", InternalProgram.DiscImageCreator.ToString());
-                var valueEnum = EnumConverter.ToInternalProgram(valueString);
-                return valueEnum == InternalProgram.NONE ? InternalProgram.DiscImageCreator : valueEnum;
-            }
-            set
-            {
-                _settings["InternalProgram"] = value.ToString();
-            }
-        }
-
-        #endregion
-
-        #region UI Defaults
-
-        /// <summary>
-        /// Enable dark mode for UI elements
-        /// </summary>
-        public bool EnableDarkMode
-        {
-            get { return GetBooleanSetting(_settings, "EnableDarkMode", false); }
-            set { _settings["EnableDarkMode"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Check for updates on startup
-        /// </summary>
-        public bool CheckForUpdatesOnStartup
-        {
-            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
-        {
-            get { return GetStringSetting(_settings, "DefaultOutputPath", "ISO"); }
-            set { _settings["DefaultOutputPath"] = value; }
-        }
-
-        /// <summary>
-        /// Default system if none can be detected
-        /// </summary>
-        public RedumpSystem? DefaultSystem
-        {
-            get
-            {
-                string valueString = GetStringSetting(_settings, "DefaultSystem", null);
-                var valueEnum = Extensions.ToRedumpSystem(valueString);
-                return valueEnum;
-            }
-            set
-            {
-                _settings["DefaultSystem"] = value.LongName();
-            }
-        }
-
-        /// <summary>
-        /// Default output path for dumps
-        /// </summary>
-        /// <remarks>This is a hidden setting</remarks>
-        public bool ShowDebugViewMenuItem
-        {
-            get { return GetBooleanSetting(_settings, "ShowDebugViewMenuItem", false); }
-            set { _settings["ShowDebugViewMenuItem"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Dumping Speeds
-
-        /// <summary>
-        /// Default CD dumping speed
-        /// </summary>
-        public int PreferredDumpSpeedCD
-        {
-            get { return GetInt32Setting(_settings, "PreferredDumpSpeedCD", 24); }
-            set { _settings["PreferredDumpSpeedCD"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Default DVD dumping speed
-        /// </summary>
-        public int PreferredDumpSpeedDVD
-        {
-            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>
-        /// Default BD dumping speed
-        /// </summary>
-        public int PreferredDumpSpeedBD
-        {
-            get { return GetInt32Setting(_settings, "PreferredDumpSpeedBD", 8); }
-            set { _settings["PreferredDumpSpeedBD"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Aaru
-
-        /// <summary>
-        /// Enable debug output while dumping by default
-        /// </summary>
-        public bool AaruEnableDebug
-        {
-            get { return GetBooleanSetting(_settings, "AaruEnableDebug", false); }
-            set { _settings["AaruEnableDebug"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable verbose output while dumping by default
-        /// </summary>
-        public bool AaruEnableVerbose
-        {
-            get { return GetBooleanSetting(_settings, "AaruEnableVerbose", false); }
-            set { _settings["AaruEnableVerbose"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable force dumping of media by default
-        /// </summary>
-        public bool AaruForceDumping
-        {
-            get { return GetBooleanSetting(_settings, "AaruForceDumping", true); }
-            set { _settings["AaruForceDumping"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Default number of sector/subchannel rereads
-        /// </summary>
-        public int AaruRereadCount
-        {
-            get { return GetInt32Setting(_settings, "AaruRereadCount", 5); }
-            set { _settings["AaruRereadCount"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Strip personal data information from Aaru metadata by default
-        /// </summary>
-        public bool AaruStripPersonalData
-        {
-            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>
-        /// <remarks>
-        /// Split this into component parts later. Currently does:
-        /// - Scan sector protection and set subchannel read level to 2 for CD
-        /// - Set scan file protect flag for DVD
-        /// </remarks>
-        public bool DICParanoidMode
-        {
-            get { return GetBooleanSetting(_settings, "DICParanoidMode", false); }
-            set { _settings["DICParanoidMode"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable the Quiet flag by default
-        /// </summary>
-        public bool DICQuietMode
-        {
-            get { return GetBooleanSetting(_settings, "DICQuietMode", false); }
-            set { _settings["DICQuietMode"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Default number of C2 rereads
-        /// </summary>
-        public int DICRereadCount
-        {
-            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>
-        /// Reset drive after dumping (useful for older drives)
-        /// </summary>
-        public bool DICResetDriveAfterDump
-        {
-            get { return GetBooleanSetting(_settings, "DICResetDriveAfterDump", false); }
-            set { _settings["DICResetDriveAfterDump"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Use the CMI flag for supported disc types
-        /// </summary>
-        public bool DICUseCMIFlag
-        {
-            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", false); }
-            set { _settings["RedumperEnableVerbose"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Default number of rereads
-        /// </summary>
-        public int RedumperRereadCount
-        {
-            get { return GetInt32Setting(_settings, "RedumperRereadCount", 20); }
-            set { _settings["RedumperRereadCount"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Extra Dumping Options
-
-        /// <summary>
-        /// Scan the disc for protection after dumping
-        /// </summary>
-        public bool ScanForProtection
-        {
-            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>
-        /// Add placeholder values in the submission info
-        /// </summary>
-        public bool AddPlaceholders
-        {
-            get { return GetBooleanSetting(_settings, "AddPlaceholders", true); }
-            set { _settings["AddPlaceholders"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Show the disc information window after dumping
-        /// </summary>
-        public bool PromptForDiscInformation
-        {
-            get { return GetBooleanSetting(_settings, "PromptForDiscInformation", true); }
-            set { _settings["PromptForDiscInformation"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable tabs in all input fields
-        /// </summary>
-        public bool EnableTabsInInputFields
-        {
-            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>
-        /// Show disc eject reminder before the disc information window is shown
-        /// </summary>
-        public bool ShowDiscEjectReminder
-        {
-            get { return GetBooleanSetting(_settings, "ShowDiscEjectReminder", true); }
-            set { _settings["ShowDiscEjectReminder"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Eject the disc after dumping
-        /// </summary>
-        public bool EjectAfterDump
-        {
-            get { return GetBooleanSetting(_settings, "EjectAfterDump", false); }
-            set { _settings["EjectAfterDump"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Ignore fixed drives when populating the list
-        /// </summary>
-        public bool IgnoreFixedDrives
-        {
-            get { return GetBooleanSetting(_settings, "IgnoreFixedDrives", true); }
-            set { _settings["IgnoreFixedDrives"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Show dumping tools in their own window instead of in the log
-        /// </summary>
-        public bool ToolsInSeparateWindow
-        {
-            get { return GetBooleanSetting(_settings, "ToolsInSeparateWindow", true); }
-            set { _settings["ToolsInSeparateWindow"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Output the compressed JSON version of the submission info
-        /// </summary>
-        public bool OutputSubmissionJSON
-        {
-            get { return GetBooleanSetting(_settings, "OutputSubmissionJSON", false); }
-            set { _settings["OutputSubmissionJSON"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Include log files in serialized JSON data
-        /// </summary>
-        public bool IncludeArtifacts
-        {
-            get { return GetBooleanSetting(_settings, "IncludeArtifacts", false); }
-            set { _settings["IncludeArtifacts"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Compress output log files to reduce space
-        /// </summary>
-        public bool CompressLogFiles
-        {
-            get { return GetBooleanSetting(_settings, "CompressLogFiles", true); }
-            set { _settings["CompressLogFiles"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Skip Options
-
-        /// <summary>
-        /// Skip detecting media type on disc scan
-        /// </summary>
-        public bool SkipMediaTypeDetection
-        {
-            get { return GetBooleanSetting(_settings, "SkipMediaTypeDetection", false); }
-            set { _settings["SkipMediaTypeDetection"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Skip detecting known system on disc scan
-        /// </summary>
-        public bool SkipSystemDetection
-        {
-            get { return GetBooleanSetting(_settings, "SkipSystemDetection", false); }
-            set { _settings["SkipSystemDetection"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Protection Scanning Options
-
-        /// <summary>
-        /// Scan archive contents during protection scanning
-        /// </summary>
-        public bool ScanArchivesForProtection
-        {
-            get { return GetBooleanSetting(_settings, "ScanArchivesForProtection", true); }
-            set { _settings["ScanArchivesForProtection"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Scan for executable packers during protection scanning
-        /// </summary>
-        public bool ScanPackersForProtection
-        {
-            get { return GetBooleanSetting(_settings, "ScanPackersForProtection", false); }
-            set { _settings["ScanPackersForProtection"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Include debug information with scan results
-        /// </summary>
-        public bool IncludeDebugProtectionInformation
-        {
-            get { return GetBooleanSetting(_settings, "IncludeDebugProtectionInformation", false); }
-            set { _settings["IncludeDebugProtectionInformation"] = value.ToString(); }
-        }
-
-        #endregion
-
-        #region Logging Options
-
-        /// <summary>
-        /// Enable verbose and debug logs to be written
-        /// </summary>
-        public bool VerboseLogging
-        {
-            get { return GetBooleanSetting(_settings, "VerboseLogging", true); }
-            set { _settings["VerboseLogging"] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Have the log panel expanded by default on startup
-        /// </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(); }
-        }
-
-        #endregion
-
-        #region Redump Login Information
-
-        public string RedumpUsername
-        {
-            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
-        {
-            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); }
-
-        #endregion
-
-        /// <summary>
-        /// Constructor taking a dictionary for settings
-        /// </summary>
-        /// <param name="settings"></param>
-        public Options(Dictionary<string, string> settings = null)
-        {
-            this._settings = settings ?? new Dictionary<string, string>();
-        }
-
-        /// <summary>
-        /// Create a clone of the object
-        /// </summary>
-        public object Clone()
-        {
-            return new Options(new Dictionary<string, string>(_settings));
-        }
-
-        #region Helpers
-
-        /// <summary>
-        /// Get a Boolean setting from a settings, dictionary
-        /// </summary>
-        /// <param name="settings">Dictionary representing the settings</param>
-        /// <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)
-        {
-            if (settings.ContainsKey(key))
-            {
-                if (Boolean.TryParse(settings[key], out bool value))
-                    return value;
-                else
-                    return defaultValue;
-            }
-            else
-            {
-                return defaultValue;
-            }
-        }
-
-        /// <summary>
-        /// Get an Int32 setting from a settings, dictionary
-        /// </summary>
-        /// <param name="settings">Dictionary representing the settings</param>
-        /// <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)
-        {
-            if (settings.ContainsKey(key))
-            {
-                if (Int32.TryParse(settings[key], out int value))
-                    return value;
-                else
-                    return defaultValue;
-            }
-            else
-            {
-                return defaultValue;
-            }
-        }
-
-        /// <summary>
-        /// Get a String setting from a settings, dictionary
-        /// </summary>
-        /// <param name="settings">Dictionary representing the settings</param>
-        /// <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)
-        {
-            if (settings.ContainsKey(key))
-                return settings[key];
-            else
-                return defaultValue;
-        }
-
-        #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/PICDiscInformation.cs

@@ -1,38 +0,0 @@
-namespace MPF.Core.Data
-{
-    /// <summary>
-    /// Disc Information and Emergency Brake data shall be read from the PIC zone. DI units that
-    /// contain physical information shall be returned.Emergency Brake data shall be returned.The
-    /// information shall be collected from the layer specified in the Layer field of the CDB. If any data
-    /// can be returned, 4 100 bytes shall be returned.
-    /// </summary>
-    /// <see href="https://www.t10.org/ftp/t10/document.05/05-206r0.pdf"/>
-    /// <see href="https://github.com/aaru-dps/Aaru.Decoders/blob/devel/Bluray/DI.cs"/>
-    public class PICDiscInformation
-    {
-        #region Fields
-
-        /// <summary>
-        /// 2048 bytes for BD-ROM, 3584 bytes for BD-R/RE
-        /// </summary>
-        /// <remarks>Big-endian format</remarks>
-        public ushort DataStructureLength { get; set; }
-
-        /// <summary>
-        /// Should be 0x00
-        /// </summary>
-        public byte Reserved0 { get; set; }
-
-        /// <summary>
-        /// Should be 0x00
-        /// </summary>
-        public byte Reserved1 { get; set; }
-
-        /// <summary>
-        /// Disc information and emergency brake units
-        /// </summary>
-        public PICDiscInformationUnit[] Units { get; set; }
-
-        #endregion
-    }
-}

MPF.Core/Data/PICDiscInformationUnit.cs

@@ -1,114 +0,0 @@
-namespace MPF.Core.Data
-{
-    /// <see href="https://www.t10.org/ftp/t10/document.05/05-206r0.pdf"/>
-    /// <see href="https://github.com/aaru-dps/Aaru.Decoders/blob/devel/Bluray/DI.cs"/>
-    public class PICDiscInformationUnit
-    {
-        #region Fields
-
-        #region Header
-
-        /// <summary>
-        /// Disc Information Identifier "DI"
-        /// Emergency Brake Identifier "EB"
-        /// </summary>
-        public string DiscInformationIdentifier { get; set; }
-
-        /// <summary>
-        /// Disc Information Format
-        /// </summary>
-        public byte DiscInformationFormat { get; set; }
-
-        /// <summary>
-        /// Number of DI units in each DI block
-        /// </summary>
-        public byte NumberOfUnitsInBlock { get; set; }
-
-        /// <summary>
-        /// Should be 0x00
-        /// </summary>
-        public byte Reserved0 { get; set; }
-
-        /// <summary>
-        /// DI unit Sequence Number
-        /// </summary>
-        public byte SequenceNumber { get; set; }
-
-        /// <summary>
-        /// Number of bytes in use in this DI unit
-        /// </summary>
-        public byte BytesInUse { get; set; }
-
-        /// <summary>
-        /// Should be 0x00
-        /// </summary>
-        public byte Reserved1 { get; set; }
-
-        #endregion
-
-        // TODO: Write models for the dependent contents, if possible
-        #region Body
-
-        /// <summary>
-        /// Disc Type Identifier
-        /// = "BDO" for BD-ROM
-        /// = "BDU" for BD-ROM Ultra
-        /// = "BDW" for BD-RE
-        /// = "BDR" for BD-R
-        /// </summary>
-        public string DiscTypeIdentifier { get; set; }
-
-        /// <summary>
-        /// Disc Size/Class/Version
-        /// </summary>
-        public byte DiscSizeClassVersion { get; set; }
-
-        /// <summary>
-        /// DI Unit Format dependent contents
-        /// </summary>
-        /// <remarks>52 bytes for BD-ROM, 100 bytes for BD-R/RE</remarks>
-        public byte[] FormatDependentContents { get; set; }
-
-        #endregion
-
-        #region Trailer (BD-R/RE only)
-
-        /// <summary>
-        /// Disc Manufacturer ID
-        /// </summary>
-        /// <remarks>6 bytes</remarks>
-        public byte[] DiscManufacturerID { get; set; }
-
-        /// <summary>
-        /// Media Type ID
-        /// </summary>
-        /// <remarks>3 bytes</remarks>
-        public byte[] MediaTypeID { get; set; }
-
-        /// <summary>
-        /// Time Stamp
-        /// </summary>
-        public ushort TimeStamp { get; set; }
-
-        /// <summary>
-        /// Product Revision Number
-        /// </summary>
-        public byte ProductRevisionNumber { get; set; }
-
-        #endregion
-
-        #endregion
-
-        #region Constants
-
-        public const string DiscTypeIdentifierROM = "BDO";
-
-        public const string DiscTypeIdentifierROMUltra = "BDU";
-
-        public const string DiscTypeIdentifierReWritable = "BDW";
-
-        public const string DiscTypeIdentifierRecordable = "BDR";
-
-        #endregion
-    }
-}

MPF.Core/Data/ProcessingQueue.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MPF.Core.Data
-{
-    public class ProcessingQueue<T> : IDisposable
-    {
-        /// <summary>
-        /// Internal queue to hold data to process
-        /// </summary>
-        private readonly ConcurrentQueue<T> InternalQueue;
-
-        /// <summary>
-        /// Custom processing step for dequeued data
-        /// </summary>
-        private readonly Action<T> CustomProcessing;
-
-        /// <summary>
-        /// Cancellation method for the processing task
-        /// </summary>
-        private readonly CancellationTokenSource TokenSource;
-
-        public ProcessingQueue(Action<T> customProcessing)
-        {
-            this.InternalQueue = new ConcurrentQueue<T>();
-            this.CustomProcessing = customProcessing;
-            this.TokenSource = new CancellationTokenSource();
-            Task.Run(() => ProcessQueue(), this.TokenSource.Token);
-        }
-
-        /// <summary>
-        /// Dispose the current instance
-        /// </summary>
-        public void Dispose() => this.TokenSource.Cancel();
-
-        /// <summary>
-        /// Enqueue a new item for processing
-        /// </summary>
-        /// <param name="item"></param>
-        public void Enqueue(T item)
-        {
-            // Only accept new data when not cancelled
-            if (!this.TokenSource.IsCancellationRequested)
-                this.InternalQueue.Enqueue(item);
-        }
-
-        /// <summary>
-        /// Process
-        /// </summary>
-        private void ProcessQueue()
-        {
-            while (true)
-            {
-                // Nothing in the queue means we get to idle
-                if (this.InternalQueue.Count == 0)
-                {
-                    if (this.TokenSource.IsCancellationRequested)
-                        break;
-
-                    Thread.Sleep(10);
-                    continue;
-                }
-
-                // Get the next item from the queue
-                if (!this.InternalQueue.TryDequeue(out T nextItem))
-                    continue;
-
-                // Invoke the lambda, if possible
-                this.CustomProcessing?.Invoke(nextItem);
-            }
-        }
-    }
-}

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/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,55 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;net6.0</TargetFrameworks>
-    <RuntimeIdentifiers>win7-x64;win8-x64;win81-x64;win10-x64;linux-x64;osx-x64</RuntimeIdentifiers>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2023</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.6.2</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 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>
-
-  <ItemGroup>
-    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Management.Infrastructure" Version="2.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="System.Configuration.ConfigurationManager" Version="7.0.0" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
-  </ItemGroup>
-
-</Project>

MPF.Core/Utilities/BinaryReaderExtensions.cs

@@ -1,174 +0,0 @@
-using System;
-using System.IO;
-
-namespace MPF.Core.Utilities
-{
-    /// <summary>
-    /// Big endian reading overloads for BinaryReader
-    /// </summary>
-    public static class BinaryReaderExtensions
-    {
-        /// <summary>
-        /// Reads the specified number of bytes from the stream, starting from a specified point in the byte array.
-        /// </summary>
-        /// <param name="buffer">The buffer to read data into.</param>
-        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
-        /// <param name="count">The number of bytes to read.</param>
-        /// <returns>The number of bytes read into buffer. This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached.</returns>
-        public static int ReadBigEndian(this BinaryReader reader, byte[] buffer, int index, int count)
-        {
-            int retval = reader.Read(buffer, index, count);
-            Array.Reverse(buffer);
-            return retval;
-        }
-
-        /// <summary>
-        /// Reads the specified number of characters from the stream, starting from a specified point in the character array.
-        /// </summary>
-        /// <param name="buffer">The buffer to read data into.</param>
-        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
-        /// <param name="count">The number of characters to read.</param>
-        /// <returns>The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached.</returns>
-        public static int ReadBigEndian(this BinaryReader reader, char[] buffer, int index, int count)
-        {
-            int retval = reader.Read(buffer, index, count);
-            Array.Reverse(buffer);
-            return retval;
-        }
-
-        /// <summary>
-        /// Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes.
-        /// </summary>
-        /// <param name="count">The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur.</param>
-        /// <returns>A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
-        public static byte[] ReadBytesBigEndian(this BinaryReader reader, int count)
-        {
-            byte[] retval = reader.ReadBytes(count);
-            Array.Reverse(retval);
-            return retval;
-        }
-
-        /// <summary>
-        /// Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream.
-        /// </summary>
-        /// <param name="count">The number of characters to read. This value must be 0 or a non-negative number or an exception will occur.</param>
-        /// <returns>A character array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
-        public static char[] ReadCharsBigEndian(this BinaryReader reader, int count)
-        {
-            char[] retval = reader.ReadChars(count);
-            Array.Reverse(retval);
-            return retval;
-        }
-
-        /// <summary>
-        /// Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes.
-        /// </summary>
-        /// <returns>A decimal value read from the current stream.</returns>
-        public static decimal ReadDecimalBigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(16);
-            Array.Reverse(retval);
-
-            int i1 = BitConverter.ToInt32(retval, 0);
-            int i2 = BitConverter.ToInt32(retval, 4);
-            int i3 = BitConverter.ToInt32(retval, 8);
-            int i4 = BitConverter.ToInt32(retval, 12);
-
-            return new decimal(new int[] { i1, i2, i3, i4 });
-        }
-
-        /// <summary>
-        /// eads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes.
-        /// </summary>
-        /// <returns>An 8-byte floating point value read from the current stream.</returns>
-        public static double ReadDoubleBigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(8);
-            Array.Reverse(retval);
-            return BitConverter.ToDouble(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes.
-        /// </summary>
-        /// <returns>A 2-byte signed integer read from the current stream.</returns>
-        public static short ReadInt16BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(2);
-            Array.Reverse(retval);
-            return BitConverter.ToInt16(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes.
-        /// </summary>
-        /// <returns>A 4-byte signed integer read from the current stream.</returns>
-        public static int ReadInt32BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(4);
-            Array.Reverse(retval);
-            return BitConverter.ToInt32(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes.
-        /// </summary>
-        /// <returns>An 8-byte signed integer read from the current stream.</returns>
-        public static long ReadInt64BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(8);
-            Array.Reverse(retval);
-            return BitConverter.ToInt64(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes.
-        /// </summary>
-        /// <returns>A 4-byte floating point value read from the current stream.</returns>
-        public static float ReadSingleBigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(4);
-            Array.Reverse(retval);
-            return BitConverter.ToSingle(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>A 2-byte unsigned integer read from this stream.</returns>
-        public static ushort ReadUInt16BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(2);
-            Array.Reverse(retval);
-            return BitConverter.ToUInt16(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>A 4-byte unsigned integer read from this stream.</returns>
-        public static uint ReadUInt32BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(4);
-            Array.Reverse(retval);
-            return BitConverter.ToUInt32(retval, 0);
-        }
-
-        /// <summary>
-        /// Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>An 8-byte unsigned integer read from this stream.</returns>
-        public static ulong ReadUInt64BigEndian(this BinaryReader reader)
-        {
-            byte[] retval = reader.ReadBytes(8);
-            Array.Reverse(retval);
-            return BitConverter.ToUInt64(retval, 0);
-        }
-    }
-}

MPF.Core/Utilities/Chime.cs

@@ -1,396 +0,0 @@
-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);
-            }
-        }
-    }
-}

MPF.Core/Utilities/EnumExtensions.cs

@@ -1,149 +0,0 @@
-using System;
-using System.Collections.Generic;
-using MPF.Core.Converters;
-using MPF.Core.Data;
-using 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>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
-        public static bool DoesSupportDriveSpeed(this MediaType? type)
-        {
-            switch (type)
-            {
-                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;
-            }
-        }
-
-        /// <summary>
-        /// Determine if a system has reversed ringcodes
-        /// </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)
-        {
-            switch (system)
-            {
-                case RedumpSystem.SonyPlayStation2:
-                case RedumpSystem.SonyPlayStation3:
-                case RedumpSystem.SonyPlayStation4:
-                //case RedumpSystem.SonyPlayStation5:
-                case RedumpSystem.SonyPlayStationPortable:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-        /// <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)
-            {
-                case RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem:
-                case RedumpSystem.AudioCD:
-                case RedumpSystem.DVDAudio:
-                case RedumpSystem.HasbroiONEducationalGamingSystem:
-                case RedumpSystem.HasbroVideoNow:
-                case RedumpSystem.HasbroVideoNowColor:
-                case RedumpSystem.HasbroVideoNowJr:
-                case RedumpSystem.HasbroVideoNowXP:
-                case RedumpSystem.PhilipsCDi:
-                case RedumpSystem.PlayStationGameSharkUpdates:
-                case RedumpSystem.SuperAudioCD:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-        /// <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;
-            }
-        }
-
-        /// <summary>
-        /// List all programs with their short usable names
-        /// </summary>
-        public static List<string> ListPrograms()
-        {
-            var programs = new List<string>();
-
-            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
-            {
-                if (((InternalProgram)val) == InternalProgram.NONE)
-                    continue;
-
-                programs.Add($"{((InternalProgram?)val).LongName()}");
-            }
-
-            return programs;
-        }
-    }
-}

MPF.Core/Utilities/Logging.cs

@@ -1,121 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MPF.Core.Utilities
-{
-    public static class Logging
-    {
-        /// <summary>
-        /// Process a chunk of text and send it to a handler
-        /// </summary>
-        /// <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)
-        {
-            // Initialize the required variables
-            char[] buffer = new char[256];
-            int read = 0;
-            var sb = new StringBuilder();
-
-            try
-            {
-                while (true)
-                {
-                    // Try to read the next chunk of characters
-                    read = await reader.ReadAsync(buffer, 0, buffer.Length);
-                    if (read == 0)
-                    {
-                        Thread.Sleep(10);
-                        continue;
-                    }
-
-                    // Convert the characters into a string
-                    string line = new string(buffer, 0, read);
-
-                    // If we have no newline characters, store in the string builder
-                    if (!line.Contains("\r") && !line.Contains("\n"))
-                        sb.Append(line);
-
-                    // If we have a newline, append and log
-                    else if (line.Contains("\n") || line.Contains("\r\n"))
-                        ProcessNewLines(sb, line, baseClass, handler);
-
-                    // If we have a carriage return only, append and log first and last instances
-                    else if (line.Contains("\r"))
-                        ProcessCarriageReturns(sb, line, baseClass, handler);
-                }
-            }
-            catch { }
-            finally
-            {
-                handler?.Invoke(baseClass, sb.ToString());
-            }
-        }
-
-        /// <summary>
-        /// Process a chunk that contains newlines
-        /// </summary>
-        /// <param name="sb">StringBuilder to write from and append to</param>
-        /// <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)
-        {
-            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 (split[i].Contains("\r"))
-                {
-                    ProcessCarriageReturns(sb, split[i], baseClass, handler);
-                    continue;
-                }
-
-                // For the first item, append to anything existing and then write out
-                if (i == 0)
-                {
-                    sb.Append(split[i]);
-                    handler?.Invoke(baseClass, sb.ToString());
-                    sb.Clear();
-                }
-
-                // For the last item, just append so it's dealt with the next time
-                else if (i == split.Length - 1)
-                {
-                    sb.Append(split[i]);
-                }
-
-                // For everything else, directly write out
-                else
-                {
-                    handler?.Invoke(baseClass, split[i]);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Process a chunk that contains carriage returns
-        /// </summary>
-        /// <param name="sb">StringBuilder to write from and append to</param>
-        /// <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)
-        {
-            var split = line.Split('\r');
-
-            // Append and log the first
-            sb.Append(split[0]);
-            handler?.Invoke(baseClass, sb.ToString());
-
-            // Append the last
-            sb.Clear();
-            sb.Append($"\r{split[split.Length - 1]}");
-        }
-    }
-}

MPF.Core/Utilities/OptionsLoader.cs

@@ -1,182 +0,0 @@
-using System.Collections.Generic;
-using System.Configuration;
-using MPF.Core.Converters;
-using MPF.Core.Data;
-
-namespace MPF.Core.Utilities
-{
-    public static class OptionsLoader
-    {
-        #region Arguments
-
-        /// <summary>
-        /// Load the current set of options from application arguments
-        /// </summary>
-        public static (Options, 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,
-                OutputSubmissionJSON = false,
-                CompressLogFiles = false,
-            };
-
-            string parsedPath = null;
-
-            // These values require multiple parts to be active
-            bool scan = false, protectFile = false;
-
-            // If we have no arguments, just return
-            if (args == null || args.Length == 0)
-                return (options, null, 0);
-
-            // If we have an invalid start index, just return
-            if (startIndex < 0 || startIndex >= args.Length)
-                return (options, null, startIndex);
-
-            // Loop through the arguments and parse out values
-            for (; startIndex < args.Length; startIndex++)
-            {
-                // Redump login
-                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;
-                }
-
-                // Use specific program
-                else 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++;
-                }
-
-                // 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;
-                }
-
-                // 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;
-                }
-
-                // Default, we fall out
-                else
-                {
-                    break;
-                }
-            }
-
-            // We default to DiscImageCreator currently
-            if (options.InternalProgram == InternalProgram.NONE)
-                options.InternalProgram = InternalProgram.DiscImageCreator;
-
-            // Now deal with the complex options
-            options.ScanForProtection = scan && !string.IsNullOrWhiteSpace(parsedPath);
-            options.OutputSeparateProtectionFile = scan && protectFile && !string.IsNullOrWhiteSpace(parsedPath);
-
-            return (options, parsedPath, startIndex);
-        }
-
-        /// <summary>
-        /// Return a list of supported arguments and descriptions
-        /// </summary>
-        public static List<string> PrintSupportedArguments()
-        {
-            var supportedArguments = new List<string>();
-
-            supportedArguments.Add("-c, --credentials <user> <pw>  Redump username and password");
-            supportedArguments.Add("-u, --use <program>            Dumping program output type");
-            supportedArguments.Add("-p, --path <drivepath>         Physical drive path for additional checks");
-            supportedArguments.Add("-s, --scan                     Enable copy protection scan (requires --path)");
-            supportedArguments.Add("-f, --protect-file             Output protection to separate file (requires --scan)");
-            supportedArguments.Add("-j, --json                     Enable submission JSON output");
-            supportedArguments.Add("-z, --zip                      Enable log file compression");
-
-            return supportedArguments;
-        }
-
-        #endregion
-
-        #region Configuration
-
-        /// <summary>
-        /// Load the current set of options from the application configuration
-        /// </summary>
-        public static Options LoadFromConfig()
-        {
-            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
-
-            var settings = configFile.AppSettings.Settings;
-            var dict = new Dictionary<string, string>();
-
-            foreach (string key in settings.AllKeys)
-            {
-                dict[key] = settings[key]?.Value ?? string.Empty;
-            }
-
-            return new Options(dict);
-        }
-
-        /// <summary>
-        /// Save the current set of options to the application configuration
-        /// </summary>
-        public static void SaveToConfig(Options options)
-        {
-            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
-
-            // Loop through all settings in Options and save them, overwriting existing settings
-            foreach (var kvp in options)
-            {
-                configFile.AppSettings.Settings.Remove(kvp.Key);
-                configFile.AppSettings.Settings.Add(kvp.Key, kvp.Value);
-            }
-
-            configFile.Save(ConfigurationSaveMode.Modified);
-        }
-
-        #endregion
-    }
-}

MPF.Core/Utilities/Tools.cs

@@ -1,213 +0,0 @@
-using System;
-using System.Reflection;
-using MPF.Core.Data;
-using Newtonsoft.Json.Linq;
-using RedumpLib.Data;
-
-namespace MPF.Core.Utilities
-{
-    public static class Tools
-    {
-        #region Byte Arrays
-
-        /// <summary>
-        /// Search for a byte array in another array
-        /// </summary>
-        public static bool Contains(this byte[] stack, byte[] needle, out int position, int start = 0, int end = -1)
-        {
-            // Initialize the found position to -1
-            position = -1;
-
-            // If either array is null or empty, we can't do anything
-            if (stack == null || stack.Length == 0 || needle == null || needle.Length == 0)
-                return false;
-
-            // If the needle array is larger than the stack array, it can't be contained within
-            if (needle.Length > stack.Length)
-                return false;
-
-            // If start or end are not set properly, set them to defaults
-            if (start < 0)
-                start = 0;
-            if (end < 0)
-                end = stack.Length - needle.Length;
-
-            for (int i = start; i < end; i++)
-            {
-                if (stack.EqualAt(needle, i))
-                {
-                    position = i;
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// See if a byte array starts with another
-        /// </summary>
-        public static bool StartsWith(this byte[] stack, byte[] needle)
-        {
-            return stack.Contains(needle, out int _, start: 0, end: 1);
-        }
-
-        /// <summary>
-        /// Get if a stack at a certain index is equal to a needle
-        /// </summary>
-        private static bool EqualAt(this byte[] stack, byte[] needle, int index)
-        {
-            // If we're too close to the end of the stack, return false
-            if (needle.Length >= stack.Length - index)
-                return false;
-
-            for (int i = 0; i < needle.Length; i++)
-            {
-                if (stack[i + index] != needle[i])
-                    return false;
-            }
-
-            return true;
-        }
-
-        #endregion
-
-        #region Support
-
-        /// <summary>
-        /// Verify that, given a system and a media type, they are correct
-        /// </summary>
-        public static Result GetSupportStatus(RedumpSystem? system, MediaType? type)
-        {
-            // No system chosen, update status
-            if (system == null)
-                return Result.Failure("Please select a valid system");
-
-            // If we're on an unsupported type, update the status accordingly
-            switch (type)
-            {
-                // 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");
-
-                // Partially supported types
-                case MediaType.GDROM:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return 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");
-
-                // Specifically unknown type
-                case MediaType.NONE:
-                    return Result.Failure($"Please select a valid media type");
-
-                // Undumpable but recognized types
-                default:
-                    return Result.Failure($"{type.LongName()} media are not supported for dumping");
-            }
-        }
-
-        #endregion
-
-        #region Versioning
-
-        /// <summary>
-        /// Check for a new MPF version
-        /// </summary>
-        /// <returns>
-        /// Bool representing if the values are different.
-        /// 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()
-        {
-            try
-            {
-                // Get current assembly version
-                var assemblyVersion = Assembly.GetEntryAssembly().GetName().Version;
-                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}" + (assemblyVersion.Build != 0 ? $".{assemblyVersion.Build}" : string.Empty);
-
-                // Get the latest tag from GitHub
-                (string tag, string url) = GetRemoteVersionAndUrl();
-                bool different = version != tag;
-
-                string message = $"Local version: {version}"
-                    + $"{Environment.NewLine}Remote version: {tag}"
-                    + (different
-                        ? $"{Environment.NewLine}The update URL has been added copied to your clipboard"
-                        : $"{Environment.NewLine}You have the newest version!");
-
-                return (different, message, url);
-            }
-            catch (Exception ex)
-            {
-                return (false, ex.ToString(), null);
-            }
-        }
-
-        /// <summary>
-        /// Get the current informational version formatted as a string
-        /// </summary>
-        public static string GetCurrentVersion()
-        {
-            try
-            {
-                var assemblyVersion = Attribute.GetCustomAttribute(Assembly.GetEntryAssembly(), 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()
-        {
-#if NETFRAMEWORK
-            using (System.Net.WebClient wc = new System.Net.WebClient())
-            {
-                wc.Headers["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0";
-
-                // 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();
-
-                return (latestTag, releaseUrl);
-            }
-#else
-            using (System.Net.Http.HttpClient hc = new System.Net.Http.HttpClient())
-            {
-                // 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");
-                string latestReleaseJsonString = hc.Send(message)?.Content?.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
-                var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
-                string latestTag = latestReleaseJson["tag_name"].ToString();
-                string releaseUrl = latestReleaseJson["html_url"].ToString();
-
-                return (latestTag, releaseUrl);
-            }
-#endif
-        }
-
-        #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,31 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;net6.0</TargetFrameworks>
-    <RuntimeIdentifiers>win7-x64;win8-x64;win81-x64;win10-x64;linux-x64;osx-x64</RuntimeIdentifiers>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2023</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.6.2</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="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.3">
-      <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.ExecutionContexts/Aaru/CommandStrings.cs

@@ -0,0 +1,68 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Top-level commands for Aaru
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+
+        // Archive Family
+        public const string ArchivePrefixShort = "arc";
+        public const string ArchivePrefixLong = "archive";
+        public const string ArchiveInfo = "info";
+
+        // Database Family
+        public const string DatabasePrefixShort = "db";
+        public const string DatabasePrefixLong = "database";
+        public const string DatabaseStats = "stats";
+        public const string DatabaseUpdate = "update";
+
+        // Device Family
+        public const string DevicePrefixShort = "dev";
+        public const string DevicePrefixLong = "device";
+        public const string DeviceInfo = "info";
+        public const string DeviceList = "list";
+        public const string DeviceReport = "report";
+
+        // Filesystem Family
+        public const string FilesystemPrefixShort = "fi";
+        public const string FilesystemPrefixShortAlt = "fs";
+        public const string FilesystemPrefixLong = "filesystem";
+        public const string FilesystemExtract = "extract";
+        public const string FilesystemInfo = "info";
+        public const string FilesystemListShort = "ls";
+        public const string FilesystemListLong = "list";
+        public const string FilesystemOptions = "options";
+
+        // Image Family
+        public const string ImagePrefixShort = "i";
+        public const string ImagePrefixLong = "image";
+        public const string ImageChecksumShort = "chk";
+        public const string ImageChecksumLong = "checksum";
+        public const string ImageCompareShort = "cmp";
+        public const string ImageCompareLong = "compare";
+        public const string ImageConvert = "convert";
+        public const string ImageCreateSidecar = "create-sidecar";
+        public const string ImageDecode = "decode";
+        public const string ImageEntropy = "entropy";
+        public const string ImageInfo = "info";
+        public const string ImageOptions = "options";
+        public const string ImagePrint = "print";
+        public const string ImageVerify = "verify";
+
+        // Media Family
+        public const string MediaPrefixShort = "m";
+        public const string MediaPrefixLong = "media";
+        public const string MediaDump = "dump";
+        public const string MediaInfo = "info";
+        public const string MediaScan = "scan";
+
+        // Standalone Commands
+        public const string Configure = "configure";
+        public const string Formats = "formats";
+        public const string ListEncodings = "list-encodings";
+        public const string ListNamespaces = "list-namespaces";
+        public const string Remote = "remote";
+    }
+}

MPF.ExecutionContexts/Aaru/Converters.cs

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

MPF.ExecutionContexts/Aaru/EncodingStrings.cs

@@ -0,0 +1,43 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported encodings for Aaru
+    /// </summary>
+    /// TODO: Use to verify encoding settings
+    public static class EncodingStrings
+    {
+        public const string ArabicMac = "x-mac-arabic";
+        public const string AtariASCII = "atascii";
+        public const string CentralEuropeanMac = "x-mac-ce";
+        public const string CommodorePETSCII = "petscii";
+        public const string CroatianMac = "x-mac-croatian";
+        public const string CyrillicMac = "x-mac-cryillic";
+        public const string FarsiMac = "x-mac-farsi";
+        public const string GreekMac = "x-mac-greek";
+        public const string HebrewMac = "x-mac-hebrew";
+        public const string RomanianMac = "x-mac-romanian";
+        public const string SinclairZXSpectrum = "spectrum";
+        public const string SinclairZX80 = "zx80";
+        public const string SinclairZX81 = "zx81";
+        public const string TurkishMac = "x-mac-turkish";
+        public const string UkrainianMac = "x-mac-ukrainian";
+        public const string Unicode = "utf-16";
+        public const string UnicodeBigEndian = "utf-16BE";
+        public const string UnicodeUTF32BigEndian = "utf-32BE";
+        public const string UnicodeUTF32 = "utf-32";
+        public const string UnicodeUTF7 = "utf-7";
+        public const string UnicodeUTF8 = "utf-8";
+        public const string USASCII = "us-ascii";
+        public const string WesternEuropeanAppleII = "apple2";
+        public const string WesternEuropeanAppleIIc = "apple2c";
+        public const string WesternEuropeanAppleIIe = "apple2e";
+        public const string WesternEuropeanAppleIIgs = "apple2gs";
+        public const string WesternEuropeanAppleLisa = "lisa";
+        public const string WesternEuropeanAtariST = "atarist";
+        public const string WesternEuropeanGEM = "gem";
+        public const string WesternEuropeanGEOS = "geos";
+        public const string WesternEuropeanISO = "iso-8859-1";
+        public const string WesternEuropeanMac = "macintosh";
+        public const string WesternEuropeanRadix50 = "radix50";
+    }
+}

MPF.ExecutionContexts/Aaru/FlagStrings.cs

@@ -0,0 +1,151 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Dumping flags for Aaru
+    /// </summary>
+    public static class FlagStrings
+    {
+        // Boolean flags
+        public const string Adler32Short = "-a";
+        public const string Adler32Long = "--adler32";
+        public const string ClearLong = "--clear";
+        public const string ClearAllLong = "--clear-all";
+        public const string CRC16Long = "--crc16";
+        public const string CRC32Short = "-c";
+        public const string CRC32Long = "--crc32";
+        public const string CRC64Long = "--crc64";
+        public const string DebugShort = "-d";
+        public const string DebugLong = "--debug";
+        public const string DiskTagsShort = "-f";
+        public const string DiskTagsLong = "--disk-tags";
+        public const string DuplicatedSectorsShort = "-p";
+        public const string DuplicatedSectorsLong = "--duplicated-sectors";
+        public const string EjectLong = "--eject";
+        public const string ExtendedAttributesShort = "-x";
+        public const string ExtendedAttributesLong = "--xattrs";
+        public const string FilesystemsShort = "-f";
+        public const string FilesystemsLong = "--filesystems";
+        public const string FirstPregapLong = "--first-pregap";
+        public const string FixOffsetLong = "--fix-offset";
+        public const string FixSubchannelLong = "--fix-subchannel";
+        public const string FixSubchannelCrcLong = "--fix-subchannel-crc";
+        public const string FixSubchannelPositionLong = "--fix-subchannel-position";
+        public const string Fletcher16Long = "--fletcher16";
+        public const string Fletcher32Long = "--fletcher32";
+        public const string ForceShort = "-f";
+        public const string ForceLong = "--force";
+        public const string GenerateSubchannelsLong = "--generate-subchannels";
+        public const string HelpShort = "-h";
+        public const string HelpShortAlt = "-?";
+        public const string HelpLong = "--help";
+        public const string LongFormatShort = "-l";
+        public const string LongFormatLong = "--long-format";
+        public const string LongSectorsShort = "-r";
+        public const string LongSectorsLong = "--long-sectors";
+        public const string MD5Short = "-m";
+        public const string MD5Long = "--md5";
+        public const string MetadataLong = "--metadata";
+        public const string PartitionsShort = "-p";
+        public const string PartitionsLong = "--partitions";
+        public const string PauseLong = "--pause";
+        public const string PersistentLong = "--persistent";
+        public const string PrivateLong = "--private";
+        public const string ResumeShort = "-r";
+        public const string ResumeLong = "--resume";
+        public const string RetrySubchannelLong = "--retry-subchannel";
+        public const string SectorTagsShort = "-p";
+        public const string SectorTagsLong = "--sector-tags";
+        public const string SeparatedTracksShort = "-t";
+        public const string SeparatedTracksLong = "--separated-tracks";
+        public const string SHA1Short = "-s";
+        public const string SHA1Long = "--sha1";
+        public const string SHA256Long = "--sha256";
+        public const string SHA384Long = "--sha384";
+        public const string SHA512Long = "--sha512";
+        public const string SkipCdiReadyHoleLong = "--skip-cdiready-hole";
+        public const string SpamSumShort = "-f";
+        public const string SpamSumLong = "--spamsum";
+        public const string StopOnErrorShort = "-s";
+        public const string StopOnErrorLong = "--stop-on-error";
+        public const string StoreEncryptedLong = "--store-encrypted";
+        public const string TapeShort = "-t";
+        public const string TapeLong = "--tape";
+        public const string TitleKeysLong = "--title-keys";
+        public const string TrapDiscShort = "-t";
+        public const string TrapDiscLong = "--trap-disc";
+        public const string TrimLong = "--trim";
+        public const string UseBufferedReadsLong = "--use-buffered-reads";
+        public const string VerboseShort = "-v";
+        public const string VerboseLong = "--verbose";
+        public const string VerifyDiscShort = "-w";
+        public const string VerifyDiscLong = "--verify-disc";
+        public const string VerifySectorsShort = "-s";
+        public const string VerifySectorsLong = "--verify-sectors";
+        public const string VersionLong = "--version";
+        public const string WholeDiscShort = "-w";
+        public const string WholeDiscLong = "--whole-disc";
+
+        // Int8 flags
+        public const string SpeedLong = "--speed";
+
+        // Int16 flags
+        public const string RetryPassesShort = "-p";
+        public const string RetryPassesLong = "--retry-passes";
+        public const string WidthShort = "-w";
+        public const string WidthLong = "--width";
+
+        // Int32 flags
+        public const string BlockSizeShort = "-b";
+        public const string BlockSizeLong = "--block-size";
+        public const string CountShort = "-c";
+        public const string CountLong = "--count";
+        public const string MaxBlocksLong = "--max-blocks";
+        public const string MediaLastSequenceLong = "--media-lastsequence";
+        public const string MediaSequenceLong = "--media-sequence";
+        public const string SkipShort = "-k";
+        public const string SkipLong = "--skip";
+
+        // Int64 flags
+        public const string LengthShort = "-l"; // or "all"
+        public const string LengthLong = "--length"; // or "all"
+        public const string StartShort = "-s";
+        public const string StartLong = "--start";
+
+        // String flags
+        public const string CommentsLong = "--comments";
+        public const string CreatorLong = "--creator";
+        public const string DriveManufacturerLong = "--drive-manufacturer";
+        public const string DriveModelLong = "--drive-model";
+        public const string DriveRevisionLong = "--drive-revision";
+        public const string DriveSerialLong = "--drive-serial";
+        public const string EncodingShort = "-e";
+        public const string EncodingLong = "--encoding";
+        public const string FormatConvertShort = "-p";
+        public const string FormatConvertLong = "--format";
+        public const string FormatDumpShort = "-t";
+        public const string FormatDumpLong = "--format";
+        public const string GeometryShort = "-g";
+        public const string GeometryLong = "--geometry";
+        public const string ImgBurnLogShort = "-b";
+        public const string ImgBurnLogLong = "--ibg-log";
+        public const string MediaBarcodeLong = "--media-barcode";
+        public const string MediaManufacturerLong = "--media-manufacturer";
+        public const string MediaModelLong = "--media-model";
+        public const string MediaPartNumberLong = "--media-partnumber";
+        public const string MediaSerialLong = "--media-serial";
+        public const string MediaTitleLong = "--media-title";
+        public const string MHDDLogShort = "-m";
+        public const string MHDDLogLong = "--mhdd-log";
+        public const string NamespaceShort = "-n";
+        public const string NamespaceLong = "--namespace";
+        public const string OptionsShort = "-O";
+        public const string OptionsLong = "--options";
+        public const string OutputPrefixShort = "-w";
+        public const string OutputPrefixLong = "--output-prefix";
+        public const string ResumeFileShort = "-r";
+        public const string ResumeFileLong = "--resume-file";
+        public const string SubchannelLong = "--subchannel";
+        public const string XMLSidecarShort = "-x";
+        public const string XMLSidecarLong = "--cicm-xml";
+    }
+}

MPF.ExecutionContexts/Aaru/FormatStrings.cs

@@ -0,0 +1,169 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported formats for Aaru
+    /// </summary>
+    /// TODO: Use to verify format settings
+    public static class FormatStrings
+    {
+        // Supported filters
+        public const string AppleDouble = "AppleDouble";
+        public const string AppleSingle = "AppleSingle";
+        public const string BZip2 = "BZip2";
+        public const string GZip = "GZip";
+        public const string LZip = "LZip";
+        public const string MacBinary = "MacBinary";
+        public const string NoFilter = "No filter";
+        public const string PCExchange = "PCExchange";
+        public const string XZ = "XZ";
+
+        // Read-only media image formats
+        public const string AppleDiskArchivalRetrievalTool = "Apple Disk Archival/Retrieval Tool";
+        public const string AppleNewDiskImageFormat = "Apple New Disk Image Format";
+        public const string AppleNIB = "Apple NIB";
+        public const string BlindWrite4 = "BlindWrite 4";
+        public const string BlindWrite5 = "BlindWrite 5";
+        public const string CPCEMUDiskFileAndExtendedCPCDiskFile = "CPCEMU Disk-File and Extended CPC Disk-File";
+        public const string D2FDiskImage = "d2f disk image";
+        public const string D88DiskImage = "D88 Disk Image";
+        public const string DIMDiskImage = "DIM Disk Image";
+        public const string DiscFerret = "DiscFerret";
+        public const string DiscJuggler = "DiscJuggler";
+        public const string DreamcastGDIImage = "Dreamcast GDI image";
+        public const string DunfieldsIMD = "Dunfield's IMD";
+        public const string HDCopyDiskImage = "HD-Copy disk image";
+        public const string KryoFluxSTREAM = "KryoFlux STREAM";
+        public const string MAMECompressedHunksOfData = "MAME Compressed Hunks of Data";
+        public const string MicrosoftVHDX = "Microsoft VHDX";
+        public const string NeroBurningROMImage = "Nero Burning ROM image";
+        public const string PartCloneDiskImage = "PartClone disk image";
+        public const string PartimageDiskImage = "Partimage disk image";
+        public const string SpectrumFloppyDiskImage = "Spectrum Floppy Disk Image";
+        public const string SuperCardPro = "SuperCardPro";
+        public const string SydexCopyQM = "Sydex CopyQM";
+        public const string SydexTeleDisk = "Sydex TeleDisk";
+
+        // Read/write media image formats
+        public const string AaruFormat = "Aaru Format";
+        public const string ACTApricotDiskImage = "ACT Apricot Disk Image";
+        public const string Alcohol120MediaDescriptorStructure = "Alcohol 120% Media Descriptor Structure";
+        public const string Anex86DiskImage = "Anex86 Disk Image";
+        public const string Apple2InterleavedDiskImage = "Apple ][Interleaved Disk Image";
+        public const string Apple2IMG = "Apple 2IMG";
+        public const string AppleDiskCopy42 = "Apple DiskCopy 4.2";
+        public const string AppleUniversalDiskImageFormat = "Apple Universal Disk Image Format";
+        public const string BasicLisaUtility = "Basic Lisa Utility";
+        public const string CDRDAOTocfile = "CDRDAO tocfile";
+        public const string CDRWinCuesheet = "CDRWin cuesheet";
+        public const string CisCopyDiskImageDCFile = "CisCopy Disk Image(DC-File)";
+        public const string CloneCD = "CloneCD";
+        public const string CopyTape = "CopyTape";
+        public const string DigitalResearchDiskCopy = "Digital Research DiskCopy";
+        public const string IBMSaveDskF = "IBM SaveDskF";
+        public const string MAXIDiskImage = "MAXI Disk image";
+        public const string ParallelsDiskImage = "Parallels disk image";
+        public const string QEMUCopyOnWriteDiskImage = "QEMU Copy-On-Write disk image";
+        public const string QEMUCopyOnWriteDiskImageV2 = "QEMU Copy-On-Write disk image v2";
+        public const string QEMUEnhancedDiskImage = "QEMU Enhanced Disk image";
+        public const string RawDiskImage = "Raw Disk Image";
+        public const string RayAracheliansDiskIMage = "Ray Arachelian's Disk IMage";
+        public const string RSIDEHardDiskImage = "RS-IDE Hard Disk Image";
+        public const string T98HardDiskImage = "T98 Hard Disk Image";
+        public const string T98NextNHDr0DiskImage = "T98-Next NHD r0 Disk Image";
+        public const string Virtual98DiskImage = "Virtual98 Disk Image";
+        public const string VirtualBoxDiskImage = "VirtualBox Disk Image";
+        public const string VirtualPC = "VirtualPC";
+        public const string VMwareDiskImage = "VMware disk image";
+
+        // Supported filesystems for identification and information only
+        public const string AcornAdvancedDiscFilingSystem = "Acorn Advanced Disc Filing System";
+        public const string AlexanderOsipovDOSFileSystem = "Alexander Osipov DOS file system";
+        public const string AmigaDOSFilesystem = "Amiga DOS filesystem";
+        public const string AppleFileSystem = "Apple File System";
+        public const string AppleHFSPlusFilesystem = "Apple HFS+ filesystem";
+        public const string AppleHierarchicalFileSystem = "Apple Hierarchical File System";
+        public const string AppleProDOSFilesystem = "Apple ProDOS filesystem";
+        public const string AtheOSFilesystem = "AtheOS Filesystem";
+        public const string BeFilesystem = "Be Filesystem";
+        public const string BSDFastFileSystem = "BSD Fast File System(aka UNIX File System, UFS)";
+        public const string BTreeFileSystem = "B-tree file system";
+        public const string CommodoreFileSystem = "Commodore file system";
+        public const string CramFilesystem = "Cram filesystem";
+        public const string DumpEightPlugin = "dump(8) Plugin";
+        public const string ECMA67 = "ECMA-67";
+        public const string ExtentFileSystemPlugin = "Extent File System Plugin";
+        public const string F2FSPlugin = "F2FS Plugin";
+        public const string Files11OnDiskStructure = "Files-11 On-Disk Structure";
+        public const string FossilFilesystemPlugin = "Fossil Filesystem Plugin";
+        public const string HAMMERFilesystem = "HAMMER Filesystem";
+        public const string HighPerformanceOpticalFileSystem = "High Performance Optical File System";
+        public const string HPLogicalInterchangeFormatPlugin = "HP Logical Interchange Format Plugin";
+        public const string JFSPlugin = "JFS Plugin";
+        public const string LinuxExtendedFilesystem = "Linux extended Filesystem";
+        public const string LinuxExtendedFilesystem234 = "Linux extended Filesystem 2, 3 and 4";
+        public const string LocusFilesystemPlugin = "Locus Filesystem Plugin";
+        public const string MicroDOSFileSystem = "MicroDOS file system";
+        public const string MicrosoftExtendedFileAllocationTable = "Microsoft Extended File Allocation Table";
+        public const string MinixFilesystem = "Minix Filesystem";
+        public const string NewTechnologyFileSystem = "New Technology File System(NTFS)";
+        public const string NILFS2Plugin = "NILFS2 Plugin";
+        public const string NintendoOpticalFilesystems = "Nintendo optical filesystems";
+        public const string OS2HighPerformanceFileSystem = "OS/2 High Performance File System";
+        public const string OS9RandomBlockFilePlugin = "OS-9 Random Block File Plugin";
+        public const string PCEngineCDPlugin = "PC Engine CD Plugin";
+        public const string PCFXPlugin = "PC-FX Plugin";
+        public const string ProfessionalFileSystem = "Professional File System";
+        public const string QNX4Plugin = "QNX4 Plugin";
+        public const string QNX6Plugin = "QNX6 Plugin";
+        public const string ReiserFilesystemPlugin = "Reiser Filesystem Plugin";
+        public const string Reiser4FilesystemPlugin = "Reiser4 Filesystem Plugin";
+        public const string ResilientFileSystemPlugin = "Resilient File System plugin";
+        public const string RT11FileSystem = "RT-11 file system";
+        public const string SmartFileSystem = "SmartFileSystem";
+        public const string SolarOSFilesystem = "Solar_OS filesystem";
+        public const string SquashFilesystem = "Squash filesystem";
+        public const string UNICOSFilesystemPlugin = "UNICOS Filesystem Plugin";
+        public const string UniversalDiskFormat = "Universal Disk Format";
+        public const string UNIXBootFilesystem = "UNIX Boot filesystem";
+        public const string UNIXSystemVFilesystem = "UNIX System V filesystem";
+        public const string VeritasFilesystem = "Veritas filesystem";
+        public const string VMwareFilesystem = "VMware filesystem";
+        public const string XFSFilesystemPlugin = "XFS Filesystem Plugin";
+        public const string XiaFilesystem = "Xia filesystem";
+        public const string ZFSFilesystemPlugin = "ZFS Filesystem Plugin";
+
+        // Supported filesystems that can read their contents
+        public const string AppleDOSFileSystem = "Apple DOS File System";
+        public const string AppleLisaFileSystem = "Apple Lisa File System";
+        public const string AppleMacintoshFileSystem = "Apple Macintosh File System";
+        public const string CPMFileSystem = "CP/M File System";
+        public const string FATXFilesystemPlugin = "FATX Filesystem Plugin";
+        public const string ISO9660Filesystem = "ISO9660 Filesystem";
+        public const string MicrosoftFileAllocationTable = "Microsoft File Allocation Table";
+        public const string OperaFilesystemPlugin = "Opera Filesystem Plugin";
+        public const string UCSDPascalFilesystem = "U.C.S.D.Pascal filesystem";
+
+        // Supported partitioning schemes
+        public const string AcornFileCorePartitions = "Acorn FileCore partitions";
+        public const string ACTApricotPartitions = "ACT Apricot partitions";
+        public const string AmigaRigidDiskBlock = "Amiga Rigid Disk Block";
+        public const string ApplePartitionMap = "Apple Partition Map";
+        public const string AtariPartitions = "Atari partitions";
+        public const string BSDDisklabel = "BSD disklabel";
+        public const string DECDisklabel = "DEC disklabel";
+        public const string DragonFlyBSD64bitDisklabel = "DragonFly BSD 64-bit disklabel";
+        public const string GUIDPartitionTable = "GUID Partition Table";
+        public const string Human68kPartitions = "Human 68k partitions";
+        public const string MasterBootRecord = "Master Boot Record";
+        public const string NECPC9800PartitionTable = "NEC PC-9800 partition table";
+        public const string NeXTDisklabel = "NeXT Disklabel";
+        public const string Plan9PartitionTable = "Plan9 partition table";
+        public const string RioKarmaPartitioning = "Rio Karma partitioning";
+        public const string SGIDiskVolumeHeader = "SGI Disk Volume Header";
+        public const string SunDisklabel = "Sun Disklabel";
+        public const string UNIXHardwired = "UNIX hardwired";
+        public const string UNIXVTOC = "UNIX VTOC";
+        public const string XboxPartitioning = "Xbox partitioning";
+        public const string XENIX = "XENIX";
+    }
+}

MPF.ExecutionContexts/Aaru/NamespaceStrings.cs

@@ -0,0 +1,27 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported namespaces for Aaru
+    /// </summary>
+    /// TODO: Use to verify namespace settings
+    public static class NamespaceStrings
+    {
+        // Namespaces for Apple Lisa File System
+        public const string LisaOfficeSystem = "office";
+        public const string LisaPascalWorkshop = "workshop"; // Default
+
+        // Namespaces for ISO9660 Filesystem
+        public const string JolietVolumeDescriptor = "joliet"; // Default
+        public const string PrimaryVolumeDescriptor = "normal";
+        public const string PrimaryVolumeDescriptorwithEncoding = "romeo";
+        public const string RockRidge = "rrip";
+        public const string PrimaryVolumeDescriptorVersionSuffix = "vms";
+
+        // Namespaces for Microsoft File Allocation Table
+        public const string DOS83UpperCase = "dos";
+        public const string LFNWhenAvailableWithFallback = "ecs"; // Default
+        public const string LongFileNames = "lfn";
+        public const string WindowsNT83MixedCase = "nt";
+        public const string OS2Extended = "os2";
+    }
+}

MPF.ExecutionContexts/Aaru/OptionStrings.cs

@@ -0,0 +1,43 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported options for Aaru
+    /// </summary>
+    /// TODO: Use to verify option settings
+    public static class OptionStrings
+    {
+        // Aaru format
+        public const string AaruCompress = "compress"; // boolean, default true;
+        public const string AaruDeduplicate = "deduplicate"; // boolean, default true
+        public const string AaruDictionary = "dictionary"; // number, default 33554432
+        public const string AaruMaxDDTSize = "max_ddt_size"; // number, default 256
+        public const string AaruMD5 = "md5"; // boolean, default false
+        public const string AaruSectorsPerBlock = "sectors_per_block"; // number, default 4096 [power of 2]
+        public const string AaruSHA1 = "sha1"; // boolean, default false
+        public const string AaruSHA256 = "sha256"; // boolean, default false
+        public const string AaruSpamSum = "spamsum"; // boolean, default false
+
+        // ACT Apricot Disk Image
+        public const string ACTApricotDiskImageCompress = "compress"; // boolean, default false
+
+        // Apple DiskCopy 4.2
+        public const string AppleDiskCopyMacOSX = "macosx"; // boolean, default false
+
+        // CDRDAO tocfile
+        public const string CDRDAOTocfileSeparate = "separate"; // boolean, default false
+
+        // CDRWin cuesheet
+        public const string CDRWinCuesheetSeparate = "separate"; // boolean, default false
+
+        // ISO9660 Filesystem
+        public const string ISO9660FSUseEvd = "use_evd"; // boolean, default false
+        public const string ISO9660FSUsePathTable = "use_path_table"; // boolean, default false
+        public const string ISO9660FSUseTransTbl = "use_trans_tbl"; // boolean, default false
+
+        // VMware disk image
+        public const string VMwareDiskImageAdapterType = "adapter_type"; // string, default ide [ide, lsilogic, buslogic, legacyESX]
+        public const string VMwareDiskImageHWVersion = "hwversion"; // number, default 4
+        public const string VMwareDiskImageSparse = "sparse"; // boolean, default false
+        public const string VMwareDiskImageSplit = "split"; // boolean, default false
+    }
+}

MPF.ExecutionContexts/Aaru/SettingConstants.cs

@@ -0,0 +1,20 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    public static class SettingConstants
+    {
+        public const string EnableDebug = "AaruEnableDebug";
+        public const bool EnableDebugDefault = false;
+
+        public const string EnableVerbose = "AaruEnableVerbose";
+        public const bool EnableVerboseDefault = true;
+
+        public const string ForceDumping = "AaruForceDumping";
+        public const bool ForceDumpingDefault = true;
+
+        public const string RereadCount = "AaruRereadCount";
+        public const int RereadCountDefault = 5;
+
+        public const string StripPersonalData = "AaruStripPersonalData";
+        public const bool StripPersonalDataDefault = false;
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/CommandStrings.cs

@@ -0,0 +1,35 @@
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    /// <summary>
+    /// Top-level commands for DiscImageCreator
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+        public const string Audio = "audio";
+        public const string BluRay = "bd";
+        public const string Close = "close";
+        public const string CompactDisc = "cd";
+        public const string Data = "data";
+        public const string DigitalVideoDisc = "dvd";
+        public const string Disk = "disk";
+        public const string DriveSpeed = "ls";
+        public const string Eject = "eject";
+        public const string Floppy = "fd";
+        public const string GDROM = "gd";
+        public const string MDS = "mds";
+        public const string Merge = "merge";
+        public const string Reset = "reset";
+        public const string SACD = "sacd";
+        public const string Start = "start";
+        public const string Stop = "stop";
+        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";
+        public const string XGD3Swap = "xgd3swap";
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/Converters.cs

@@ -0,0 +1,100 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.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.ExecutionContexts/DiscImageCreator/FlagStrings.cs

@@ -1,38 +1,5 @@
-namespace MPF.Modules.DiscImageCreator
+namespace MPF.ExecutionContexts.DiscImageCreator
 {
-    /// <summary>
-    /// Top-level commands for DiscImageCreator
-    /// </summary>
-    public static class CommandStrings
-    {
-        public const string NONE = "";
-        public const string Audio = "audio";
-        public const string BluRay = "bd";
-        public const string Close = "close";
-        public const string CompactDisc = "cd";
-        public const string Data = "data";
-        public const string DigitalVideoDisc = "dvd";
-        public const string Disk = "disk";
-        public const string DriveSpeed = "ls";
-        public const string Eject = "eject";
-        public const string Floppy = "fd";
-        public const string GDROM = "gd";
-        public const string MDS = "mds";
-        public const string Merge = "merge";
-        public const string Reset = "reset";
-        public const string SACD = "sacd";
-        public const string Start = "start";
-        public const string Stop = "stop";
-        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";
-        public const string XGD3Swap = "xgd3swap";
-    }
-
     /// <summary>
     /// Dumping flags for DiscImageCreator
     /// </summary>
@@ -69,6 +36,7 @@ namespace MPF.Modules.DiscImageCreator
         public const string SeventyFour = "/74";
         public const string SkipSector = "/sk";
         public const string SubchannelReadLevel = "/s";
+        public const string Tages = "/t";
         public const string UseAnchorVolumeDescriptorPointer = "/avdp";
         public const string VideoNow = "/vn";
         public const string VideoNowColor = "/vnc";

MPF.ExecutionContexts/DiscImageCreator/SettingConstants.cs

@@ -0,0 +1,26 @@
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    public static class SettingConstants
+    {
+        public const string DVDRereadCount = "DICDVDRereadCount";
+        public const int DVDRereadCountDefault = 10;
+
+        public const string MultiSectorRead = "DICMultiSectorRead";
+        public const bool MultiSectorReadDefault = false;
+
+        public const string MultiSectorReadValue = "DICMultiSectorReadValue";
+        public const int MultiSectorReadValueDefault = 0;
+
+        public const string ParanoidMode = "DICParanoidMode";
+        public const bool ParanoidModeDefault = false;
+
+        public const string QuietMode = "DICQuietMode";
+        public const bool QuietModeDefault = false;
+
+        public const string RereadCount = "DICRereadCount";
+        public const int RereadCountDefault = 20;
+
+        public const string UseCMIFlag = "DICUseCMIFlag";
+        public const bool UseCMIFlagDefault = false;
+    }
+}

MPF.ExecutionContexts/MPF.ExecutionContexts.csproj

@@ -0,0 +1,59 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.2.2</VersionPrefix>
+        <WarningsNotAsErrors>NU5104</WarningsNotAsErrors>
+
+        <!-- Package Properties -->
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>Common code for all MPF execution contexts</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>
+        <InternalsVisibleTo Include="MPF.Test" />
+    </ItemGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <!-- 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(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
+        <PackageReference Include="IndexRange" Version="1.0.3" />
+    </ItemGroup>
+    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
+        <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
+    </ItemGroup>
+
+</Project>

MPF.ExecutionContexts/Redumper/CommandStrings.cs

@@ -0,0 +1,28 @@
+namespace MPF.ExecutionContexts.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 New = "new"; // Synonym for CD; Temporary command, to be removed later
+        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";
+    }
+}

MPF.ExecutionContexts/Redumper/Converters.cs

@@ -1,6 +1,6 @@
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF.Modules.DD
+namespace MPF.ExecutionContexts.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.ExecutionContexts/Redumper/Enumerations.cs

@@ -0,0 +1,27 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Drive read method option
+    /// </summary>
+    public enum ReadMethod
+    {
+        NONE = 0,
+
+        BE,
+        D8,
+        BE_CDDA,
+    }
+
+    /// <summary>
+    /// Drive sector order option
+    /// </summary>
+    public enum SectorOrder
+    {
+        NONE = 0,
+
+        DATA_C2_SUB,
+        DATA_SUB_C2,
+        DATA_SUB,
+        DATA_C2,
+    }
+}

MPF.ExecutionContexts/Redumper/ExecutionContext.cs

@@ -0,0 +1,909 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Represents a generic set of Redumper parameters
+    /// </summary>
+    public sealed class ExecutionContext : BaseExecutionContext
+    {
+        #region Generic Dumping Information
+
+        /// <inheritdoc/>
+        public override string? InputPath => DriveValue?.Trim('"');
+
+        /// <inheritdoc/>
+        public override string? OutputPath => Path.Combine(
+                ImagePathValue?.Trim('"') ?? string.Empty,
+                ImageNameValue?.Trim('"') ?? string.Empty)
+            + GetDefaultExtension(this.Type);
+
+        /// <inheritdoc/>
+        public override int? Speed => SpeedValue;
+
+        #endregion
+
+        #region Flag Values
+
+        /// <summary>
+        /// List of all modes being run
+        /// </summary>
+        public List<string>? ModeValues { get; set; }
+
+        #region General
+
+        /// <summary>
+        /// Drive to use, first available drive with disc, if not provided
+        /// </summary>
+        public string? DriveValue { get; set; }
+
+        /// <summary>
+        /// Drive read speed, optimal drive speed will be used if not provided
+        /// </summary>
+        public int? SpeedValue { get; set; }
+
+        /// <summary>
+        /// Number of sector retries in case of SCSI/C2 error (default: 0)
+        /// </summary>
+        public int? RetriesValue { get; set; }
+
+        /// <summary>
+        /// Dump files base directory
+        /// </summary>
+        public string? ImagePathValue { get; set; }
+
+        /// <summary>
+        /// Dump files prefix, autogenerated in dump mode, if not provided
+        /// </summary>
+        public string? ImageNameValue { get; set; }
+
+        #endregion
+
+        #region Drive Configuration
+
+        /// <summary>
+        /// Override drive type, possible values: GENERIC, PLEXTOR, LG_ASUS
+        /// </summary>
+        public string? DriveTypeValue { get; set; }
+
+        /// <summary>
+        /// Override drive read offset
+        /// </summary>
+        public int? DriveReadOffsetValue { get; set; }
+
+        /// <summary>
+        /// Override drive C2 shift
+        /// </summary>
+        public int? DriveC2ShiftValue { get; set; }
+
+        /// <summary>
+        /// Override drive pre-gap start LBA
+        /// </summary>
+        public int? DrivePregapStartValue { get; set; }
+
+        /// <summary>
+        /// Override drive read method, possible values: BE, D8, BE_CDDA
+        /// </summary>
+        public string? DriveReadMethodValue { get; set; }
+
+        /// <summary>
+        /// Override drive sector order, possible values: DATA_C2_SUB, DATA_SUB_C2
+        /// </summary>
+        public string? DriveSectorOrderValue { get; set; }
+
+        #endregion
+
+        #region Offset
+
+        /// <summary>
+        /// Override offset autodetection and use supplied value
+        /// </summary>
+        public int? ForceOffsetValue { get; set; }
+
+        /// <summary>
+        /// Maximum absolute sample value to treat it as silence (default: 32)
+        /// </summary>
+        public int? AudioSilenceThresholdValue { get; set; }
+
+        #endregion
+
+        #region Split
+
+        /// <summary>
+        /// Fill byte value for skipped sectors (default: 0x55)
+        /// </summary>
+        public byte? SkipFillValue { get; set; }
+
+        #endregion
+
+        #region Miscellaneous
+
+        /// <summary>
+        /// LBA to start dumping from
+        /// </summary>
+        public int? LBAStartValue { get; set; }
+
+        /// <summary>
+        /// LBA to stop dumping at (everything before the value), useful for discs with fake TOC
+        /// </summary>
+        public int? LBAEndValue { get; set; }
+
+        /// <summary>
+        /// LBA ranges of sectors to skip
+        /// </summary>
+        public string? SkipValue { get; set; }
+
+        /// <summary>
+        /// Write offset for dumps when reading as data
+        /// </summary>
+        public int? DumpWriteOffsetValue { get; set; }
+
+        /// <summary>
+        /// Number of sectors to read at once on initial dump, DVD only (Default 32)
+        /// </summary>
+        public int? DumpReadSizeValue { get; set; }
+
+        /// <summary>
+        /// Maximum number of lead-in retries per session (Default 4)
+        /// </summary>
+        public int? PlextorLeadinRetriesValue { get; set; }
+
+        #endregion
+
+        #endregion
+
+        /// <inheritdoc/>
+        public ExecutionContext(string? parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public ExecutionContext(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Dictionary<string, string?> options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseExecutionContext Implementations
+
+        /// <inheritdoc/>
+        /// <remarks>Command support is irrelevant for redumper</remarks>
+        public override Dictionary<string, List<string>> GetCommandSupport()
+        {
+            return new Dictionary<string, List<string>>()
+            {
+                [CommandStrings.NONE] =
+                [
+                    // General
+                    FlagStrings.HelpLong,
+                    FlagStrings.HelpShort,
+                    FlagStrings.Version,
+                    FlagStrings.Verbose,
+                    FlagStrings.Debug,
+                    FlagStrings.Drive,
+                    FlagStrings.Speed,
+                    FlagStrings.Retries,
+                    FlagStrings.ImagePath,
+                    FlagStrings.ImageName,
+                    FlagStrings.Overwrite,
+
+                    // Drive Configuration
+                    FlagStrings.DriveType,
+                    FlagStrings.DriveReadOffset,
+                    FlagStrings.DriveC2Shift,
+                    FlagStrings.DrivePregapStart,
+                    FlagStrings.DriveReadMethod,
+                    FlagStrings.DriveSectorOrder,
+
+                    // Drive Specific
+                    FlagStrings.PlextorSkipLeadin,
+                    FlagStrings.PlextorLeadinRetries,
+                    FlagStrings.AsusSkipLeadout,
+
+                    // Offset
+                    FlagStrings.ForceOffset,
+                    FlagStrings.AudioSilenceThreshold,
+                    FlagStrings.CorrectOffsetShift,
+                    FlagStrings.OffsetShiftRelocate,
+
+                    // Split
+                    FlagStrings.ForceSplit,
+                    FlagStrings.LeaveUnchanged,
+                    FlagStrings.ForceQTOC,
+                    FlagStrings.SkipFill,
+                    FlagStrings.ISO9660Trim,
+
+                    // Miscellaneous
+                    FlagStrings.LBAStart,
+                    FlagStrings.LBAEnd,
+                    FlagStrings.RefineSubchannel,
+                    FlagStrings.Skip,
+                    FlagStrings.DumpWriteOffset,
+                    FlagStrings.DumpReadSize,
+                    FlagStrings.OverreadLeadout,
+                    FlagStrings.ForceUnscrambled,
+                    FlagStrings.LegacySubs,
+                    FlagStrings.DisableCDText,
+                ],
+            };
+        }
+
+        /// <inheritdoc/>
+        /// <remarks>
+        /// Redumper is unique in that the base command can be multiple
+        /// modes all listed together. It is also unique in that "all
+        /// flags are supported for everything" and it filters out internally
+        /// </remarks>
+        public override string GenerateParameters()
+        {
+            var parameters = new List<string>();
+
+            ModeValues ??= [CommandStrings.NONE];
+
+            // Modes
+            parameters.AddRange(ModeValues);
+
+            #region General
+
+            // Help
+            if (this[FlagStrings.HelpLong] == true)
+                parameters.Add(FlagStrings.HelpLong);
+
+            // Version
+            if (this[FlagStrings.Version] == true)
+                parameters.Add(FlagStrings.Version);
+
+            // Verbose
+            if (this[FlagStrings.Verbose] == true)
+                parameters.Add(FlagStrings.Verbose);
+
+            // Debug
+            if (this[FlagStrings.Debug] == true)
+                parameters.Add(FlagStrings.Debug);
+
+            // Drive
+            if (this[FlagStrings.Drive] == true)
+            {
+                if (DriveValue != null)
+                {
+                    if (DriveValue.Contains(' '))
+                        parameters.Add($"{FlagStrings.Drive}=\"{DriveValue}\"");
+                    else
+                        parameters.Add($"{FlagStrings.Drive}={DriveValue}");
+                }
+            }
+
+            // Speed
+            if (this[FlagStrings.Speed] == true)
+            {
+                if (SpeedValue != null)
+                    parameters.Add($"{FlagStrings.Speed}={SpeedValue}");
+            }
+
+            // Retries
+            if (this[FlagStrings.Retries] == true)
+            {
+                if (RetriesValue != null)
+                    parameters.Add($"{FlagStrings.Retries}={RetriesValue}");
+            }
+
+            // Image Path
+            if (this[FlagStrings.ImagePath] == true)
+            {
+                if (ImagePathValue != null)
+                    parameters.Add($"{FlagStrings.ImagePath}={ImagePathValue}");
+            }
+
+            // Image Name
+            if (this[FlagStrings.ImageName] == true)
+            {
+                if (ImageNameValue != null)
+                    parameters.Add($"{FlagStrings.ImageName}={ImageNameValue}");
+            }
+
+            // Overwrite
+            if (this[FlagStrings.Overwrite] == true)
+                parameters.Add(FlagStrings.Overwrite);
+
+            #endregion
+
+            #region Drive Configuration
+
+            // Drive Type
+            if (this[FlagStrings.DriveType] == true)
+            {
+                if (DriveTypeValue != null)
+                    parameters.Add($"{FlagStrings.DriveType}={DriveTypeValue}");
+            }
+
+            // Drive Read Offset
+            if (this[FlagStrings.DriveReadOffset] == true)
+            {
+                if (DriveReadOffsetValue != null)
+                    parameters.Add($"{FlagStrings.DriveReadOffset}={DriveReadOffsetValue}");
+            }
+
+            // Drive C2 Shift
+            if (this[FlagStrings.DriveC2Shift] == true)
+            {
+                if (DriveC2ShiftValue != null)
+                    parameters.Add($"{FlagStrings.DriveC2Shift}={DriveC2ShiftValue}");
+            }
+
+            // Drive Pregap Start
+            if (this[FlagStrings.DrivePregapStart] == true)
+            {
+                if (DrivePregapStartValue != null)
+                    parameters.Add($"{FlagStrings.DrivePregapStart}={DrivePregapStartValue}");
+            }
+
+            // Drive Read Method
+            if (this[FlagStrings.DriveReadMethod] == true)
+            {
+                if (DriveReadMethodValue != null)
+                    parameters.Add($"{FlagStrings.DriveReadMethod}={DriveReadMethodValue}");
+            }
+
+            // Drive Sector Order
+            if (this[FlagStrings.DriveSectorOrder] == true)
+            {
+                if (DriveSectorOrderValue != null)
+                    parameters.Add($"{FlagStrings.DriveSectorOrder}={DriveSectorOrderValue}");
+            }
+
+            #endregion
+
+            #region Drive Specific
+
+            // Plextor Leadin Skip
+            if (this[FlagStrings.PlextorSkipLeadin] == true)
+                parameters.Add(FlagStrings.PlextorSkipLeadin);
+
+            // Plextor Leadin Retries
+            if (this[FlagStrings.PlextorLeadinRetries] == true)
+            {
+                if (PlextorLeadinRetriesValue != null)
+                    parameters.Add($"{FlagStrings.PlextorLeadinRetries}={PlextorLeadinRetriesValue}");
+            }
+
+            // Asus Skip Leadout
+            if (this[FlagStrings.AsusSkipLeadout] == true)
+                parameters.Add(FlagStrings.AsusSkipLeadout);
+
+            #endregion
+
+            #region Offset
+
+            // Force Offset
+            if (this[FlagStrings.ForceOffset] == true)
+            {
+                if (ForceOffsetValue != null)
+                    parameters.Add($"{FlagStrings.ForceOffset}={ForceOffsetValue}");
+            }
+
+            // Audio Silence Threshold
+            if (this[FlagStrings.AudioSilenceThreshold] == true)
+            {
+                if (AudioSilenceThresholdValue != null)
+                    parameters.Add($"{FlagStrings.AudioSilenceThreshold}={AudioSilenceThresholdValue}");
+            }
+
+            // Correct Offset Shift
+            if (this[FlagStrings.CorrectOffsetShift] == true)
+                parameters.Add(FlagStrings.CorrectOffsetShift);
+
+            // Offset Shift Relocate
+            if (this[FlagStrings.OffsetShiftRelocate] == true)
+                parameters.Add(FlagStrings.OffsetShiftRelocate);
+
+            #endregion
+
+            #region Split
+
+            // Force Split
+            if (this[FlagStrings.ForceSplit] == true)
+                parameters.Add(FlagStrings.ForceSplit);
+
+            // Leave Unchanged
+            if (this[FlagStrings.LeaveUnchanged] == true)
+                parameters.Add(FlagStrings.LeaveUnchanged);
+
+            // Force QTOC
+            if (this[FlagStrings.ForceQTOC] == true)
+                parameters.Add(FlagStrings.ForceQTOC);
+
+            // Skip Fill
+            if (this[FlagStrings.SkipFill] == true)
+            {
+                if (SkipFillValue != null)
+                    parameters.Add($"{FlagStrings.SkipFill}={SkipFillValue:x}");
+            }
+
+            // ISO9660 Trim
+            if (this[FlagStrings.ISO9660Trim] == true)
+                parameters.Add(FlagStrings.ISO9660Trim);
+
+            #endregion
+
+            #region Miscellaneous
+
+            // LBA Start
+            if (this[FlagStrings.LBAStart] == true)
+            {
+                if (LBAStartValue != null)
+                    parameters.Add($"{FlagStrings.LBAStart}={LBAStartValue}");
+            }
+
+            // LBA End
+            if (this[FlagStrings.LBAEnd] == true)
+            {
+                if (LBAEndValue != null)
+                    parameters.Add($"{FlagStrings.LBAEnd}={LBAEndValue}");
+            }
+
+            // Refine Subchannel
+            if (this[FlagStrings.RefineSubchannel] == true)
+                parameters.Add(FlagStrings.RefineSubchannel);
+
+            // Skip
+            if (this[FlagStrings.Skip] == true)
+            {
+                if (!string.IsNullOrEmpty(SkipValue))
+                    parameters.Add($"{FlagStrings.Skip}={SkipValue}");
+            }
+
+            // Dump Write Offset
+            if (this[FlagStrings.DumpWriteOffset] == true)
+            {
+                if (DumpWriteOffsetValue != null)
+                    parameters.Add($"{FlagStrings.DumpWriteOffset}={DumpWriteOffsetValue}");
+            }
+
+            // Dump Read Size
+            if (this[FlagStrings.DumpReadSize] == true)
+            {
+                if (DumpReadSizeValue != null && DumpReadSizeValue > 0)
+                    parameters.Add($"{FlagStrings.DumpReadSize}={DumpReadSizeValue}");
+            }
+
+            // Overread Leadout
+            if (this[FlagStrings.OverreadLeadout] == true)
+                parameters.Add(FlagStrings.OverreadLeadout);
+
+            // Force Unscrambled
+            if (this[FlagStrings.ForceUnscrambled] == true)
+                parameters.Add(FlagStrings.ForceUnscrambled);
+
+            // Legacy Subs
+            if (this[FlagStrings.LegacySubs] == true)
+                parameters.Add(FlagStrings.LegacySubs);
+
+            // Disable CD Text
+            if (this[FlagStrings.DisableCDText] == true)
+                parameters.Add(FlagStrings.DisableCDText);
+
+            #endregion
+
+            return string.Join(" ", [.. parameters]);
+        }
+
+        /// <inheritdoc/>
+        public override string? GetDefaultExtension(MediaType? mediaType) => Converters.Extension(mediaType);
+
+        /// <inheritdoc/>
+        public override MediaType? GetMediaType() => null;
+
+        /// <inheritdoc/>
+        public override bool IsDumpingCommand()
+        {
+            return this.BaseCommand == CommandStrings.NONE
+                || this.BaseCommand?.Contains(CommandStrings.CD) == true
+                || this.BaseCommand?.Contains(CommandStrings.DVD) == true
+                || this.BaseCommand?.Contains(CommandStrings.BluRay) == true
+                || this.BaseCommand?.Contains(CommandStrings.SACD) == true
+                || this.BaseCommand?.Contains(CommandStrings.New) == true
+                || this.BaseCommand?.Contains(CommandStrings.Dump) == true
+                || this.BaseCommand?.Contains(CommandStrings.DumpNew) == true;
+        }
+
+        /// <inheritdoc/>
+        protected override void ResetValues()
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            flags = [];
+
+            // General
+            DriveValue = null;
+            SpeedValue = null;
+            RetriesValue = null;
+            ImagePathValue = null;
+            ImageNameValue = null;
+
+            // Drive Configuration
+            DriveTypeValue = null;
+            DriveReadOffsetValue = null;
+            DriveC2ShiftValue = null;
+            DrivePregapStartValue = null;
+            DriveReadMethodValue = null;
+            DriveSectorOrderValue = null;
+
+            // Offset
+            ForceOffsetValue = null;
+            AudioSilenceThresholdValue = null;
+
+            // Split
+            SkipFillValue = null;
+
+            // Miscellaneous
+            LBAStartValue = null;
+            LBAEndValue = null;
+            SkipValue = null;
+            DumpReadSizeValue = null;
+        }
+
+        /// <inheritdoc/>
+        protected override void SetDefaultParameters(string? drivePath, string filename, int? driveSpeed, Dictionary<string, string?> options)
+        {
+            // If we don't have a CD, DVD, HD-DVD, or BD, we can't dump using redumper
+            if (this.Type != MediaType.CDROM
+                && this.Type != MediaType.DVD
+                && this.Type != MediaType.HDDVD
+                && this.Type != MediaType.BluRay)
+            {
+                return;
+            }
+
+            BaseCommand = CommandStrings.NONE;
+            switch (this.Type)
+            {
+                case MediaType.CDROM:
+                    ModeValues = this.System switch
+                    {
+                        RedumpSystem.SuperAudioCD => [CommandStrings.SACD],
+                        _ => [CommandStrings.CD],
+                    };
+                    break;
+                case MediaType.DVD:
+                    ModeValues = [CommandStrings.DVD];
+                    break;
+                case MediaType.HDDVD: // TODO: Keep in sync if another command string shows up
+                    ModeValues = [CommandStrings.DVD];
+                    break;
+                case MediaType.BluRay:
+                    ModeValues = [CommandStrings.BluRay];
+                    break;
+                default:
+                    BaseCommand = null;
+                    return;
+            }
+
+            this[FlagStrings.Drive] = true;
+            DriveValue = drivePath;
+
+            this[FlagStrings.Speed] = true;
+            SpeedValue = driveSpeed;
+
+            // Set user-defined options
+            if (GetBooleanSetting(options, SettingConstants.EnableVerbose, SettingConstants.EnableVerboseDefault))
+                this[FlagStrings.Verbose] = true;
+            if (GetBooleanSetting(options, SettingConstants.EnableDebug, SettingConstants.EnableDebugDefault))
+                this[FlagStrings.Debug] = true;
+
+            string? readMethod = GetStringSetting(options, SettingConstants.ReadMethod, SettingConstants.ReadMethodDefault);
+            
+            if (!string.IsNullOrEmpty(readMethod) && readMethod != ReadMethod.NONE.ToString())
+            {
+                this[FlagStrings.DriveReadMethod] = true;
+                DriveReadMethodValue = readMethod;
+            }
+
+            string? sectorOrder = GetStringSetting(options, SettingConstants.SectorOrder, SettingConstants.SectorOrderDefault);
+            if (!string.IsNullOrEmpty(sectorOrder) && sectorOrder != SectorOrder.NONE.ToString())
+            {
+                this[FlagStrings.DriveSectorOrder] = true;
+                DriveSectorOrderValue = sectorOrder;
+            }
+
+            if (GetBooleanSetting(options, SettingConstants.UseGenericDriveType, SettingConstants.UseGenericDriveTypeDefault))
+            {
+                this[FlagStrings.DriveType] = true;
+                DriveTypeValue = "GENERIC";
+            }
+
+            // Set the output paths
+            if (!string.IsNullOrEmpty(filename))
+            {
+                var imagePath = Path.GetDirectoryName(filename);
+                if (!string.IsNullOrEmpty(imagePath))
+                {
+                    this[FlagStrings.ImagePath] = true;
+                    ImagePathValue = $"\"{imagePath}\"";
+                }
+
+                string imageName = Path.GetFileNameWithoutExtension(filename);
+                if (!string.IsNullOrEmpty(imageName))
+                {
+                    this[FlagStrings.ImageName] = true;
+                    ImageNameValue = $"\"{imageName}\"";
+                }
+            }
+
+            this[FlagStrings.Retries] = true;
+            RetriesValue = GetInt32Setting(options, SettingConstants.RereadCount, SettingConstants.RereadCountDefault);
+
+            if (GetBooleanSetting(options, SettingConstants.EnableLeadinRetry, SettingConstants.EnableLeadinRetryDefault))
+            {
+                this[FlagStrings.PlextorLeadinRetries] = true;
+                PlextorLeadinRetriesValue = GetInt32Setting(options, SettingConstants.LeadinRetryCount, SettingConstants.LeadinRetryCountDefault);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override bool ValidateAndSetParameters(string? parameters)
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            // The string has to be valid by itself first
+            if (string.IsNullOrEmpty(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, @"([a-zA-Z\-]*=)?[\""].+?[\""]|[^ ]+", RegexOptions.Compiled)
+                .Cast<Match>()
+                .Select(m => m.Value)
+                .ToList();
+
+            // Setup the modes
+            ModeValues = [];
+
+            // All modes should be cached separately
+            int index = 0;
+            for (; index < parts.Count; index++)
+            {
+                // Flag to see if we have a flag
+                bool isFlag = false;
+
+                string part = parts[index];
+                switch (part)
+                {
+                    case CommandStrings.CD:
+                    case CommandStrings.DVD:
+                    case CommandStrings.BluRay:
+                    case CommandStrings.SACD:
+                    case CommandStrings.New: // Temporary command, to be removed later
+                    case CommandStrings.Rings:
+                    case CommandStrings.Dump:
+                    case CommandStrings.DumpNew: // Temporary command, to be removed later
+                    case CommandStrings.Refine:
+                    case CommandStrings.RefineNew: // Temporary command, to be removed later
+                    case CommandStrings.Verify:
+                    case CommandStrings.DVDKey:
+                    case CommandStrings.DVDIsoKey:
+                    case CommandStrings.Protection:
+                    case CommandStrings.Split:
+                    case CommandStrings.Hash:
+                    case CommandStrings.Info:
+                    case CommandStrings.Skeleton:
+                        ModeValues.Add(part);
+                        break;
+
+                    // Default is either a flag or an invalid mode
+                    default:
+                        if (part.StartsWith("-"))
+                        {
+                            isFlag = true;
+                            break;
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                }
+
+                // If we had a flag, break out
+                if (isFlag)
+                    break;
+            }
+
+            // Loop through all auxiliary flags, if necessary
+            for (int i = index; i < parts.Count; i++)
+            {
+                // Flag read-out values
+                byte? byteValue = null;
+                int? intValue = null;
+                string? stringValue = null;
+
+                #region General
+
+                // Help
+                ProcessFlagParameter(parts, FlagStrings.HelpShort, FlagStrings.HelpLong, ref i);
+
+                // Version
+                ProcessFlagParameter(parts, FlagStrings.Version, ref i);
+
+                // Verbose
+                ProcessFlagParameter(parts, FlagStrings.Verbose, ref i);
+
+                // Debug
+                ProcessFlagParameter(parts, FlagStrings.Debug, ref i);
+
+                // Drive
+                stringValue = ProcessStringParameter(parts, FlagStrings.Drive, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    DriveValue = stringValue;
+
+                // Speed
+                intValue = ProcessInt32Parameter(parts, FlagStrings.Speed, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    SpeedValue = intValue;
+
+                // Retries
+                intValue = ProcessInt32Parameter(parts, FlagStrings.Retries, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    RetriesValue = intValue;
+
+                // Image Path
+                stringValue = ProcessStringParameter(parts, FlagStrings.ImagePath, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    ImagePathValue = $"\"{stringValue!.Trim('"')}\"";
+
+                // Image Name
+                stringValue = ProcessStringParameter(parts, FlagStrings.ImageName, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    ImageNameValue = $"\"{stringValue!.Trim('"')}\"";
+
+                // Overwrite
+                ProcessFlagParameter(parts, FlagStrings.Overwrite, ref i);
+
+                #endregion
+
+                #region Drive Configuration
+
+                // Drive Type
+                stringValue = ProcessStringParameter(parts, FlagStrings.DriveType, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    DriveTypeValue = stringValue;
+
+                // Drive Read Offset
+                intValue = ProcessInt32Parameter(parts, FlagStrings.DriveReadOffset, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    DriveReadOffsetValue = intValue;
+
+                // Drive C2 Shift
+                intValue = ProcessInt32Parameter(parts, FlagStrings.DriveC2Shift, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    DriveC2ShiftValue = intValue;
+
+                // Drive Pregap Start
+                intValue = ProcessInt32Parameter(parts, FlagStrings.DrivePregapStart, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    DrivePregapStartValue = intValue;
+
+                // Drive Read Method
+                stringValue = ProcessStringParameter(parts, FlagStrings.DriveReadMethod, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    DriveReadMethodValue = stringValue;
+
+                // Drive Sector Order
+                stringValue = ProcessStringParameter(parts, FlagStrings.DriveSectorOrder, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    DriveSectorOrderValue = stringValue;
+
+                #endregion
+
+                #region Drive Specific
+
+                // Plextor Skip Leadin
+                ProcessFlagParameter(parts, FlagStrings.PlextorSkipLeadin, ref i);
+
+                // Plextor Leadin Retries
+                intValue = ProcessInt32Parameter(parts, FlagStrings.PlextorLeadinRetries, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    PlextorLeadinRetriesValue = intValue;
+
+                // Asus Skip Leadout
+                ProcessFlagParameter(parts, FlagStrings.AsusSkipLeadout, ref i);
+
+                #endregion
+
+                #region Offset
+
+                // Force Offset
+                intValue = ProcessInt32Parameter(parts, FlagStrings.ForceOffset, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    ForceOffsetValue = intValue;
+
+                // Audio Silence Threshold
+                intValue = ProcessInt32Parameter(parts, FlagStrings.AudioSilenceThreshold, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    AudioSilenceThresholdValue = intValue;
+
+                // Correct Offset Shift
+                ProcessFlagParameter(parts, FlagStrings.CorrectOffsetShift, ref i);
+
+                // Correct Shift Relocate
+                ProcessFlagParameter(parts, FlagStrings.OffsetShiftRelocate, ref i);
+
+                #endregion
+
+                #region Split
+
+                // Force Split
+                ProcessFlagParameter(parts, FlagStrings.ForceSplit, ref i);
+
+                // Leave Unchanged
+                ProcessFlagParameter(parts, FlagStrings.LeaveUnchanged, ref i);
+
+                // Force QTOC
+                ProcessFlagParameter(parts, FlagStrings.ForceQTOC, ref i);
+
+                // Skip Fill
+                byteValue = ProcessUInt8Parameter(parts, FlagStrings.SkipFill, ref i);
+                if (byteValue != null && byteValue != Byte.MinValue)
+                    SkipFillValue = byteValue;
+
+                // ISO9660 Trim
+                ProcessFlagParameter(parts, FlagStrings.ISO9660Trim, ref i);
+
+                #endregion
+
+                #region Miscellaneous
+
+                // LBA Start
+                intValue = ProcessInt32Parameter(parts, FlagStrings.LBAStart, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    LBAStartValue = intValue;
+
+                // LBA End
+                intValue = ProcessInt32Parameter(parts, FlagStrings.LBAEnd, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    LBAEndValue = intValue;
+
+                // Refine Subchannel
+                ProcessFlagParameter(parts, FlagStrings.RefineSubchannel, ref i);
+
+                // Skip
+                stringValue = ProcessStringParameter(parts, FlagStrings.Skip, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    SkipValue = stringValue;
+
+                // Dump Write Offset
+                intValue = ProcessInt32Parameter(parts, FlagStrings.DumpWriteOffset, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    DumpWriteOffsetValue = intValue;
+
+                // Dump Read Size
+                intValue = ProcessInt32Parameter(parts, FlagStrings.DumpReadSize, ref i);
+                if (intValue != null && intValue != Int32.MinValue)
+                    DumpReadSizeValue = intValue;
+
+                // Overread Leadout
+                ProcessFlagParameter(parts, FlagStrings.OverreadLeadout, ref i);
+
+                // Force Unscrambled
+                ProcessFlagParameter(parts, FlagStrings.ForceUnscrambled, ref i);
+
+                // Legacy Subs
+                ProcessFlagParameter(parts, FlagStrings.LegacySubs, ref i);
+
+                // Disable CD Text
+                ProcessFlagParameter(parts, FlagStrings.DisableCDText, ref i);
+
+                #endregion
+            }
+
+            // If the image name was not set, set it with a default value
+            if (string.IsNullOrEmpty(this.ImageNameValue))
+                this.ImageNameValue = "track";
+
+            return true;
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Redumper/FlagStrings.cs

@@ -1,24 +1,5 @@
-namespace MPF.Modules.Redumper
+namespace MPF.ExecutionContexts.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 Dump = "dump";
-        public const string Info = "info";
-        public const string Protection = "protection";
-        public const string Refine = "refine";
-        public const string Split = "split";
-        public const string Verify = "verify";
-        public const string DVDKey = "dvdkey";
-    }
-
     /// <summary>
     /// Dumping flags for Redumper
     /// </summary>
@@ -27,6 +8,7 @@ namespace MPF.Modules.Redumper
         // 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";
@@ -45,7 +27,7 @@ namespace MPF.Modules.Redumper
         public const string DriveSectorOrder = "--drive-sector-order";
 
         // Drive Specific
-        public const string PlextorLeadinSkip = "--plextor-leadin-skip";
+        public const string PlextorSkipLeadin = "--plextor-skip-leadin";
         public const string PlextorLeadinRetries = "--plextor-leadin-retries";
         public const string AsusSkipLeadout = "--asus-skip-leadout";
 
@@ -67,6 +49,11 @@ namespace MPF.Modules.Redumper
         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 ForceUnscrambled = "--force-unscrambled";
+        public const string LegacySubs = "--legacy-subs";
+        public const string DisableCDText = "--disable-cdtext";
     }
 }

MPF.ExecutionContexts/Redumper/SettingConstants.cs

@@ -0,0 +1,29 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    public static class SettingConstants
+    {
+        public const string EnableDebug = "RedumperEnableDebug";
+        public const bool EnableDebugDefault = false;
+
+        public const string EnableLeadinRetry = "RedumperEnableLeadinRetry";
+        public const bool EnableLeadinRetryDefault = false;
+
+        public const string EnableVerbose = "RedumperEnableVerbose";
+        public const bool EnableVerboseDefault = true;
+
+        public const string LeadinRetryCount = "RedumperLeadinRetryCount";
+        public const int LeadinRetryCountDefault = 4;
+
+        public const string ReadMethod = "RedumperReadMethod";
+        public static readonly string ReadMethodDefault = Redumper.ReadMethod.NONE.ToString();
+
+        public const string RereadCount = "RedumperRereadCount";
+        public const int RereadCountDefault = 20;
+
+        public const string SectorOrder = "RedumperSectorOrder";
+        public static readonly string SectorOrderDefault = Redumper.SectorOrder.NONE.ToString();
+
+        public const string UseGenericDriveType = "RedumperUseGenericDriveType";
+        public const bool UseGenericDriveTypeDefault = false;
+    }
+}

MPF.Frontend/ComboBoxItems/Element.cs

@@ -1,15 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Core.Converters;
 
-namespace MPF.UI.Core.ComboBoxItems
+namespace MPF.Frontend.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;
 
@@ -22,7 +21,7 @@ namespace MPF.UI.Core.ComboBoxItems
         public static implicit operator T? (Element<T> item) => item?.Data;
 
         /// <inheritdoc/>
-        public string Name => EnumConverter.GetLongName(Data);
+        public string Name => EnumExtensions.GetLongName(Data);
 
         public override string ToString() => Name;
 
@@ -47,5 +46,23 @@ namespace MPF.UI.Core.ComboBoxItems
                 .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.Frontend/ComboBoxItems/IElement.cs

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

MPF.Frontend/ComboBoxItems/RedumpSystemComboBoxItem.cs

@@ -1,18 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Core.Utilities;
-using MPF.UI.Core.ComboBoxItems;
-using RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 
-namespace MPF
+namespace MPF.Frontend.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.Frontend/Drive.cs

@@ -0,0 +1,316 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+#if NET462_OR_GREATER || NETCOREAPP
+using Microsoft.Management.Infrastructure;
+using Microsoft.Management.Infrastructure.Generic;
+#endif
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend
+{
+    /// <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>
+        public InternalDriveType? InternalDriveType { get; set; }
+
+        /// <summary>
+        /// Drive partition format
+        /// </summary>
+        public string? DriveFormat { get; private set; } = null;
+
+        /// <summary>
+        /// Windows drive path
+        /// </summary>
+        public string? Name { get; private set; } = null;
+
+        /// <summary>
+        /// Represents if Windows has marked the drive as active
+        /// </summary>
+        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; private set; } = null;
+
+        #endregion
+
+        #region Derived Fields
+
+        /// <summary>
+        /// Read-only access to the drive letter
+        /// </summary>
+        /// <remarks>Should only be used in UI applications</remarks>
+        public char? Letter => Name?[0] ?? '\0';
+
+        #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)
+        {
+            // 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
+            Name = driveInfo.Name;
+            MarkedActive = driveInfo.IsReady;
+            if (MarkedActive)
+            {
+                DriveFormat = driveInfo.DriveFormat;
+                TotalSize = driveInfo.TotalSize;
+                VolumeLabel = driveInfo.VolumeLabel;
+            }
+            else
+            {
+                DriveFormat = string.Empty;
+                TotalSize = default;
+                VolumeLabel = string.Empty;
+            }
+        }
+
+        #region Public Functionality
+
+        /// <summary>
+        /// Create a list of active drives matched to their volume labels
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>Active drives, matched to labels, if possible</returns>
+        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
+        {
+            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="system"></param>
+        /// <returns></returns>
+        public (MediaType?, string?) GetMediaType(RedumpSystem? system)
+        {
+            // Take care of the non-optical stuff first
+            switch (InternalDriveType)
+            {
+                case Frontend.InternalDriveType.Floppy:
+                    return (MediaType.FloppyDisk, null);
+                case Frontend.InternalDriveType.HardDisk:
+                    return (MediaType.HardDisk, null);
+                case Frontend.InternalDriveType.Removable:
+                    return (MediaType.FlashDrive, null);
+            }
+
+            // 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 (TotalSize >= 0 && TotalSize <= 800_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
+                return (MediaType.CDROM, null);
+            else if (TotalSize > 800_000_000 && TotalSize <= 8_540_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
+                return (MediaType.DVD, null);
+            else if (TotalSize > 8_540_000_000)
+                return (MediaType.BluRay, null);
+
+            return (null, "Could not determine media type!");
+        }
+
+        /// <summary>
+        /// Refresh the current drive information based on path
+        /// </summary>
+        public void RefreshDrive()
+        {
+            var driveInfo = DriveInfo.GetDrives().FirstOrDefault(d => d?.Name == Name);
+            PopulateFromDriveInfo(driveInfo);
+        }
+
+        #endregion
+
+        #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
+            {
+                drives = DriveInfo.GetDrives()
+                    .Where(d => desiredDriveTypes.Contains(d.DriveType))
+                    .Select(d => Create(ToInternalDriveType(d.DriveType), d.Name) ?? new Drive())
+                    .ToList();
+            }
+            catch
+            {
+                return drives;
+            }
+
+            // Find and update all floppy drives
+#if NET462_OR_GREATER || NETCOREAPP
+            try
+            {
+                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 = Frontend.InternalDriveType.Floppy; } });
+                    }
+                }
+            }
+            catch
+            {
+                // No-op
+            }
+#endif
+
+            return drives;
+        }
+
+        /// <summary>
+        /// Convert drive type to internal version, if possible
+        /// </summary>
+        /// <param name="driveType">DriveType value to check</param>
+        /// <returns>InternalDriveType, if possible, null on error</returns>
+        internal static InternalDriveType? ToInternalDriveType(DriveType driveType)
+        {
+            return driveType switch
+            {
+                DriveType.CDRom => (InternalDriveType?)Frontend.InternalDriveType.Optical,
+                DriveType.Fixed => (InternalDriveType?)Frontend.InternalDriveType.HardDisk,
+                DriveType.Removable => (InternalDriveType?)Frontend.InternalDriveType.Removable,
+                _ => null,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/DumpEnvironment.cs

@@ -0,0 +1,839 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text;
+#if NET40
+using System.Threading;
+#endif
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.ExecutionContexts;
+using MPF.Frontend.Tools;
+using MPF.Processors;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using Formatting = Newtonsoft.Json.Formatting;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Represents the state of all settings to be used during dumping
+    /// </summary>
+    public class DumpEnvironment
+    {
+        #region Output paths
+
+        /// <summary>
+        /// Base output file path to write files to
+        /// </summary>
+        public string OutputPath { get; private set; }
+
+        #endregion
+
+        #region UI information
+
+        /// <summary>
+        /// Drive object representing the current drive
+        /// </summary>
+        private Drive? _drive;
+
+        /// <summary>
+        /// ExecutionContext object representing how to invoke the internal program
+        /// </summary>
+        private BaseExecutionContext? _executionContext;
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        private readonly InternalProgram _internalProgram;
+
+        /// <summary>
+        /// Options object representing user-defined options
+        /// </summary>
+        private readonly Frontend.Options _options;
+
+        /// <summary>
+        /// Processor object representing how to process the outputs
+        /// </summary>
+        private BaseProcessor? _processor;
+
+        /// <summary>
+        /// Currently selected system
+        /// </summary>
+        private readonly RedumpSystem? _system;
+
+        /// <summary>
+        /// Currently selected media type
+        /// </summary>
+        private readonly MediaType? _type;
+
+        #endregion
+
+        #region Passthrough Fields
+
+        /// <inheritdoc cref="BaseExecutionContext.InputPath"/>
+        public string? ContextInputPath => _executionContext?.InputPath;
+
+        /// <inheritdoc cref="BaseExecutionContext.OutputPath"/>
+        public string? ContextOutputPath => _executionContext?.OutputPath;
+
+        /// <inheritdoc cref="Drive.MarkedActive/>
+        public bool DriveMarkedActive => _drive?.MarkedActive ?? false;
+
+        /// <inheritdoc cref="Drive.Name/>
+        public string? DriveName => _drive?.Name;
+
+        /// <inheritdoc cref="BaseExecutionContext.Speed"/>
+        public int? Speed
+        {
+            get => _executionContext?.Speed;
+            set
+            {
+                if (_executionContext != null)
+                    _executionContext.Speed = value;
+            }
+        }
+
+        /// <inheritdoc cref="Extensions.LongName(RedumpSystem?)/>
+        public string? SystemName => _system.LongName();
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Generic way of reporting a message
+        /// </summary>
+        public EventHandler<StringEventArgs>? ReportStatus;
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for a full DumpEnvironment object from user information
+        /// </summary>
+        /// <param name="options"></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(Frontend.Options options,
+            string? outputPath,
+            Drive? drive,
+            RedumpSystem? system,
+            MediaType? type,
+            InternalProgram? internalProgram,
+            string? parameters)
+        {
+            // Set options object
+            _options = options;
+
+            // Output paths
+            OutputPath = FrontendTool.NormalizeOutputPaths(outputPath, false);
+
+            // UI information
+            _drive = drive;
+            _system = system ?? options.DefaultSystem;
+            _type = type ?? MediaType.NONE;
+            _internalProgram = internalProgram ?? options.InternalProgram;
+
+            // Dumping program
+            SetExecutionContext(parameters);
+            SetProcessor();
+        }
+
+        #region Internal Program Management
+
+        /// <summary>
+        /// Check output path for matching logs from all dumping programs
+        /// </summary>
+        public InternalProgram? CheckForMatchingProgram(string? outputDirectory, string outputFilename)
+        {
+            // If a complete dump exists from a different program
+            InternalProgram? programFound = null;
+            if (programFound == null && _internalProgram != InternalProgram.Aaru)
+            {
+                var processor = new Processors.Aaru(_system, _type);
+                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
+                if (foundOtherFiles)
+                    programFound = InternalProgram.Aaru;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.DiscImageCreator)
+            {
+                var processor = new Processors.DiscImageCreator(_system, _type);
+                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
+                if (foundOtherFiles)
+                    programFound = InternalProgram.DiscImageCreator;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.Redumper)
+            {
+                var processor = new Processors.Redumper(_system, _type);
+                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
+                if (foundOtherFiles)
+                    programFound = InternalProgram.Redumper;
+            }
+
+            return programFound;
+        }
+
+        /// <summary>
+        /// Set the parameters object based on the internal program and parameters string
+        /// </summary>
+        /// <param name="parameters">String representation of the parameters</param>
+        public bool SetExecutionContext(string? parameters)
+        {
+            _executionContext = _internalProgram switch
+            {
+                InternalProgram.Aaru => new ExecutionContexts.Aaru.ExecutionContext(parameters) { ExecutablePath = _options.AaruPath },
+                InternalProgram.DiscImageCreator => new ExecutionContexts.DiscImageCreator.ExecutionContext(parameters) { ExecutablePath = _options.DiscImageCreatorPath },
+                InternalProgram.Redumper => new ExecutionContexts.Redumper.ExecutionContext(parameters) { ExecutablePath = _options.RedumperPath },
+
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
+                _ => null,
+            };
+
+            // Set system, type, and drive
+            if (_executionContext != null)
+            {
+                _executionContext.System = _system;
+                _executionContext.Type = _type;
+
+                // Set some parameters, if not already set
+                OutputPath ??= _executionContext.OutputPath!;
+                _drive ??= Drive.Create(InternalDriveType.Optical, _executionContext.InputPath!);
+            }
+
+            return _executionContext != null;
+        }
+
+        /// <summary>
+        /// Set the processor object based on the internal program
+        /// </summary>
+        public bool SetProcessor()
+        {
+            _processor = _internalProgram switch
+            {
+                InternalProgram.Aaru => new Processors.Aaru(_system, _type),
+                InternalProgram.CleanRip => new CleanRip(_system, _type),
+                InternalProgram.DiscImageCreator => new DiscImageCreator(_system, _type),
+                InternalProgram.PS3CFW => new PS3CFW(_system, _type),
+                InternalProgram.Redumper => new Redumper(_system, _type),
+                InternalProgram.UmdImageCreator => new UmdImageCreator(_system, _type),
+                InternalProgram.XboxBackupCreator => new XboxBackupCreator(_system, _type),
+
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
+                _ => null,
+            };
+
+            return _processor != null;
+        }
+
+        /// <summary>
+        /// Get the full parameter string for either DiscImageCreator or Aaru
+        /// </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)
+        {
+            // Populate with the correct params for inputs (if we're not on the default option)
+            if (_system != null && _type != MediaType.NONE)
+            {
+                // If drive letter is invalid, skip this
+                if (_drive == null)
+                    return null;
+
+                // Set the proper parameters
+                _executionContext = _internalProgram switch
+                {
+                    InternalProgram.Aaru => new ExecutionContexts.Aaru.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+                    InternalProgram.DiscImageCreator => new ExecutionContexts.DiscImageCreator.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+                    InternalProgram.Redumper => new ExecutionContexts.Redumper.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+
+                    // If no dumping program found, set to null
+                    InternalProgram.NONE => null,
+                    _ => null,
+                };
+
+                // Generate and return the param string
+                return _executionContext?.GenerateParameters();
+            }
+
+            return null;
+        }
+
+        #endregion
+
+        #region Passthrough Functionality
+
+        /// <inheritdoc cref="Extensions.DetectedByWindows(RedumpSystem?)"/>
+        public bool DetectedByWindows() => _system.DetectedByWindows();
+
+        /// <summary>
+        /// Determine if the media supports drive speeds
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
+        public bool DoesSupportDriveSpeed()
+        {
+            return _type switch
+            {
+                MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.GDROM
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => true,
+                _ => false,
+            };
+        }
+
+        /// <inheritdoc cref="BaseProcessor.FoundAllFiles(string?, string)"/>
+        public bool FoundAllFiles(string? outputDirectory, string outputFilename)
+        {
+            if (_processor == null)
+                return false;
+
+            return _processor.FoundAllFiles(outputDirectory, outputFilename).Item1;
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.GetDefaultExtension(MediaType?)"/>
+        public string? GetDefaultExtension(MediaType? mediaType)
+        {
+            if (_executionContext == null)
+                return null;
+
+            return _executionContext.GetDefaultExtension(mediaType);
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.GetMediaType()"/>
+        public MediaType? GetMediaType()
+        {
+            if (_executionContext == null)
+                return null;
+
+            return _executionContext.GetMediaType();
+        }
+
+        /// <summary>
+        /// Verify that, given a system and a media type, they are correct
+        /// </summary>
+        public ResultEventArgs GetSupportStatus()
+        {
+            // No system chosen, update status
+            if (_system == null)
+                return ResultEventArgs.Failure("Please select a valid system");
+
+            // If we're on an unsupported type, update the status accordingly
+            return _type switch
+            {
+                // Fully supported types
+                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 => ResultEventArgs.Success($"{_type.LongName()} ready to dump"),
+
+                // Partially supported types
+                MediaType.GDROM
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => ResultEventArgs.Success($"{_type.LongName()} partially supported for dumping"),
+
+                // Special case for other supported tools
+                MediaType.UMD => ResultEventArgs.Failure($"{_type.LongName()} supported for submission info parsing"),
+
+                // Specifically unknown type
+                MediaType.NONE => ResultEventArgs.Failure($"Please select a valid media type"),
+
+                // Undumpable but recognized types
+                _ => ResultEventArgs.Failure($"{_type.LongName()} media are not supported for dumping"),
+            };
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.IsDumpingCommand()"/>
+        public bool IsDumpingCommand()
+        {
+            if (_executionContext == null)
+                return false;
+
+            return _executionContext.IsDumpingCommand();
+        }
+
+        /// <inheritdoc cref="Drive.RefreshDrive"/>
+        public void RefreshDrive() => _drive?.RefreshDrive();
+
+        #endregion
+
+        #region Dumping
+
+        /// <summary>
+        /// Cancel an in-progress dumping process
+        /// </summary>
+        public void CancelDumping() => _executionContext?.KillInternalProgram();
+
+        /// <summary>
+        /// Execute the initial invocation of the dumping programs
+        /// </summary>
+        /// <param name="progress">Optional result progress callback</param>
+        public async Task<ResultEventArgs> Run(IProgress<ResultEventArgs>? progress = null)
+        {
+            // If we don't have parameters
+            if (_executionContext == null)
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            // Check that we have the basics for dumping
+            ResultEventArgs result = IsValidForDump();
+            if (!result)
+                return result;
+
+            // Execute internal tool
+            progress?.Report(ResultEventArgs.Success($"Executing {_internalProgram}... please wait!"));
+
+            var directoryName = Path.GetDirectoryName(OutputPath);
+            if (!string.IsNullOrEmpty(directoryName))
+                Directory.CreateDirectory(directoryName);
+
+#if NET40
+            await Task.Factory.StartNew(() => { _executionContext.ExecuteInternalProgram(); return true; });
+#else
+            await Task.Run(_executionContext.ExecuteInternalProgram);
+#endif
+            progress?.Report(ResultEventArgs.Success($"{_internalProgram} has finished!"));
+
+            return result;
+        }
+
+        /// <summary>
+        /// Verify that the current environment has a complete dump and create submission info is possible
+        /// </summary>
+        /// <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<ResultEventArgs> VerifyAndSaveDumpOutput(
+            IProgress<ResultEventArgs>? resultProgress = null,
+            IProgress<ProtectionProgress>? protectionProgress = null,
+            Func<SubmissionInfo?, (bool?, SubmissionInfo?)>? processUserInfo = null,
+            SubmissionInfo? seedInfo = null)
+        {
+            if (_processor == null)
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            resultProgress?.Report(ResultEventArgs.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) = _processor.FoundAllFiles(outputDirectory, outputFilename);
+            if (!foundFiles)
+            {
+                resultProgress?.Report(ResultEventArgs.Failure($"There were files missing from the output:\n{string.Join("\n", [.. missingFiles])}"));
+                return ResultEventArgs.Failure("Error! Please check output directory as dump may be incomplete!");
+            }
+
+            // Extract the information from the output files
+            resultProgress?.Report(ResultEventArgs.Success("Extracting output information from output files..."));
+            var submissionInfo = await SubmissionGenerator.ExtractOutputInformation(
+                OutputPath,
+                _drive,
+                _system,
+                _type,
+                _options,
+                _processor,
+                resultProgress,
+                protectionProgress);
+            resultProgress?.Report(ResultEventArgs.Success("Extracting information complete!"));
+
+            // Inject seed submission info data, if necessary
+            if (seedInfo != null)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Injecting user-supplied information..."));
+                Builder.InjectSubmissionInformation(submissionInfo, seedInfo);
+                resultProgress?.Report(ResultEventArgs.Success("Information injection complete!"));
+            }
+
+            // Get user-modifiable information if confugured to
+            if (_options.PromptForDiscInformation && processUserInfo != null)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Waiting for additional disc information..."));
+
+                bool? filledInfo;
+                (filledInfo, submissionInfo) = processUserInfo(submissionInfo);
+
+                if (filledInfo == true)
+                    resultProgress?.Report(ResultEventArgs.Success("Additional disc information added!"));
+                else
+                    resultProgress?.Report(ResultEventArgs.Success("Disc information skipped!"));
+            }
+
+            // Process special fields for site codes
+            resultProgress?.Report(ResultEventArgs.Success("Processing site codes..."));
+            Formatter.ProcessSpecialFields(submissionInfo);
+            resultProgress?.Report(ResultEventArgs.Success("Processing complete!"));
+
+            // Format the information for the text output
+            resultProgress?.Report(ResultEventArgs.Success("Formatting information..."));
+            (var formattedValues, var formatResult) = Formatter.FormatOutputData(submissionInfo, _options.EnableRedumpCompatibility);
+            if (formattedValues == null)
+                resultProgress?.Report(ResultEventArgs.Failure(formatResult));
+            else
+                resultProgress?.Report(ResultEventArgs.Success(formatResult));
+
+            // Get the filename suffix for auto-generated files
+            var filenameSuffix = _options.AddFilenameSuffix ? Path.GetFileNameWithoutExtension(outputFilename) : null;
+
+            // Write the text output
+            resultProgress?.Report(ResultEventArgs.Success("Writing submission information file..."));
+            (bool txtSuccess, string txtResult) = WriteOutputData(outputDirectory, filenameSuffix, formattedValues);
+            if (txtSuccess)
+                resultProgress?.Report(ResultEventArgs.Success(txtResult));
+            else
+                resultProgress?.Report(ResultEventArgs.Failure(txtResult));
+
+            // Write the copy protection output
+            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Any())
+            {
+                if (_options.ScanForProtection)
+                {
+                    resultProgress?.Report(ResultEventArgs.Success("Writing protection information file..."));
+                    bool scanSuccess = WriteProtectionData(outputDirectory, filenameSuffix, submissionInfo, _options.HideDriveLetters);
+                    if (scanSuccess)
+                        resultProgress?.Report(ResultEventArgs.Success("Writing complete!"));
+                    else
+                        resultProgress?.Report(ResultEventArgs.Failure("Writing could not complete!"));
+                }
+            }
+
+            // Write the JSON output, if required
+            if (_options.OutputSubmissionJSON)
+            {
+                resultProgress?.Report(ResultEventArgs.Success($"Writing submission information JSON file{(_options.IncludeArtifacts ? " with artifacts" : string.Empty)}..."));
+                bool jsonSuccess = WriteOutputData(outputDirectory, filenameSuffix, submissionInfo, _options.IncludeArtifacts);
+                if (jsonSuccess)
+                    resultProgress?.Report(ResultEventArgs.Success("Writing complete!"));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure("Writing could not complete!"));
+            }
+
+            // Compress the logs, if required
+            if (_options.CompressLogFiles)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Compressing log files..."));
+                (bool compressSuccess, string compressResult) = _processor?.CompressLogFiles(outputDirectory, filenameSuffix, outputFilename) ?? (false, "No processor provided!");
+                if (compressSuccess)
+                    resultProgress?.Report(ResultEventArgs.Success(compressResult));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure(compressResult));
+            }
+
+            // Delete unnecessary files, if required
+            if (_options.DeleteUnnecessaryFiles)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Deleting unnecessary files..."));
+                (bool deleteSuccess, string deleteResult) = _processor?.DeleteUnnecessaryFiles(outputDirectory, outputFilename) ?? (false, "No processor provided!");
+                if (deleteSuccess)
+                    resultProgress?.Report(ResultEventArgs.Success(deleteResult));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure(deleteResult));
+            }
+
+            // Create PS3 IRD, if required
+            if (_options.CreateIRDAfterDumping && _system == RedumpSystem.SonyPlayStation3 && _type == MediaType.BluRay)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Creating IRD... please wait!"));
+                (bool deleteSuccess, string deleteResult) = await WriteIRD(OutputPath, submissionInfo?.Extras?.DiscKey, submissionInfo?.Extras?.DiscID, submissionInfo?.Extras?.PIC, submissionInfo?.SizeAndChecksums?.Layerbreak, submissionInfo?.SizeAndChecksums?.CRC32);
+                if (deleteSuccess)
+                    resultProgress?.Report(ResultEventArgs.Success(deleteResult));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure(deleteResult));
+            }
+
+            resultProgress?.Report(ResultEventArgs.Success("Submission information process complete!"));
+            return ResultEventArgs.Success();
+        }
+
+        /// <summary>
+        /// Checks if the parameters are valid
+        /// </summary>
+        /// <returns>True if the configuration is valid, false otherwise</returns>
+        internal bool ParametersValid()
+        {
+            // Missing drive means it can never be valid
+            if (_drive == null)
+                return false;
+
+            bool parametersValid = _executionContext?.IsValid() ?? false;
+            bool floppyValid = !(_drive.InternalDriveType == InternalDriveType.Floppy ^ _type == MediaType.FloppyDisk);
+
+            // TODO: HardDisk being in the Removable category is a hack, fix this later
+            bool removableDiskValid = !((_drive.InternalDriveType == InternalDriveType.Removable || _drive.InternalDriveType == InternalDriveType.HardDisk)
+                ^ (_type == MediaType.CompactFlash || _type == MediaType.SDCard || _type == MediaType.FlashDrive || _type == MediaType.HardDisk));
+
+            return parametersValid && floppyValid && removableDiskValid;
+        }
+
+        /// <summary>
+        /// Validate the current environment is ready for a dump
+        /// </summary>
+        /// <returns>Result instance with the outcome</returns>
+        private ResultEventArgs IsValidForDump()
+        {
+            // Validate that everything is good
+            if (_executionContext == null || !ParametersValid())
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            // Fix the output paths, just in case
+            OutputPath = FrontendTool.NormalizeOutputPaths(OutputPath, false);
+
+            // Validate that the output path isn't on the dumping drive
+            if (_drive?.Name != null && OutputPath.StartsWith(_drive.Name))
+                return ResultEventArgs.Failure("Error! Cannot output to same drive that is being dumped!");
+
+            // Validate that the required program exists
+            if (!File.Exists(_executionContext.ExecutablePath))
+                return ResultEventArgs.Failure($"Error! {_executionContext.ExecutablePath} does not exist!");
+
+            // Validate that the dumping drive doesn't contain the executable
+            string fullExecutablePath = Path.GetFullPath(_executionContext.ExecutablePath!);
+            if (_drive?.Name != null && fullExecutablePath.StartsWith(_drive.Name))
+                return ResultEventArgs.Failure("Error! Cannot dump same drive that executable resides on!");
+
+            // Validate that the current configuration is supported
+            return GetSupportStatus();
+        }
+
+        #endregion
+
+        #region Information Output
+
+        /// <summary>
+        /// Write the data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="lines">Preformatted list of lines to write out to the file</param>
+        /// <returns>True on success, false on error</returns>
+        private static (bool, string) WriteOutputData(string? outputDirectory, string? filenameSuffix, List<string>? lines)
+        {
+            // Check to see if the inputs are valid
+            if (lines == null)
+                return (false, "No formatted data found to write!");
+
+            // Now write out to a generic file
+            try
+            {
+                // Get the file path
+                var path = string.Empty;
+                if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = "!submissionInfo.txt";
+                else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = $"!submissionInfo_{filenameSuffix}.txt";
+                else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, "!submissionInfo.txt");
+                else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.txt");
+
+                using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
+                foreach (string line in lines)
+                {
+                    sw.WriteLine(line);
+                }
+            }
+            catch (Exception ex)
+            {
+                return (false, $"Writing could not complete: {ex}");
+            }
+
+            return (true, "Writing complete!");
+        }
+
+        // MOVE TO REDUMPLIB
+        /// <summary>
+        /// Write the data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="info">SubmissionInfo object representing the JSON to write out to the file</param>
+        /// <param name="includedArtifacts">True if artifacts were included, false otherwise</param>
+        /// <returns>True on success, false on error</returns>
+        private static bool WriteOutputData(string? outputDirectory, string? filenameSuffix, SubmissionInfo? info, bool includedArtifacts)
+        {
+            // Check to see if the input is valid
+            if (info == null)
+                return false;
+
+            try
+            {
+                // Serialize the JSON and get it writable
+                string json = JsonConvert.SerializeObject(info, Formatting.Indented);
+                byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
+
+                // If we included artifacts, write to a GZip-compressed file
+                if (includedArtifacts)
+                {
+                    var path = string.Empty;
+                    if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                        path = "!submissionInfo.json.gz";
+                    else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                        path = $"!submissionInfo_{filenameSuffix}.json.gz";
+                    else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                        path = Path.Combine(outputDirectory, "!submissionInfo.json.gz");
+                    else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                        path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.json.gz");
+
+                    using var fs = File.Create(path);
+                    using var gs = new GZipStream(fs, CompressionMode.Compress);
+                    gs.Write(jsonBytes, 0, jsonBytes.Length);
+                }
+
+                // Otherwise, write out to a normal JSON
+                else
+                {
+                    var path = string.Empty;
+                    if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                        path = "!submissionInfo.json";
+                    else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                        path = $"!submissionInfo_{filenameSuffix}.json";
+                    else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                        path = Path.Combine(outputDirectory, "!submissionInfo.json");
+                    else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                        path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.json");
+
+                    using var fs = File.Create(path);
+                    fs.Write(jsonBytes, 0, jsonBytes.Length);
+                }
+            }
+            catch
+            {
+                // We don't care what the error is right now
+                return false;
+            }
+
+            return true;
+        }
+
+        // MOVE TO REDUMPLIB
+        /// <summary>
+        /// Write the protection data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="info">SubmissionInfo object containing the protection information</param>
+        /// <param name="hideDriveLetters">True if drive letters are to be removed from output, false otherwise</param>
+        /// <returns>True on success, false on error</returns>
+        private static bool WriteProtectionData(string? outputDirectory, string? filenameSuffix, SubmissionInfo? info, bool hideDriveLetters)
+        {
+            // Check to see if the inputs are valid
+            if (info?.CopyProtection?.FullProtections == null || !info.CopyProtection.FullProtections.Any())
+                return true;
+
+            // Now write out to a generic file
+            try
+            {
+                var path = string.Empty;
+                if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = "!protectionInfo.txt";
+                else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = $"!protectionInfo{filenameSuffix}.txt";
+                else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, "!protectionInfo.txt");
+                else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, $"!protectionInfo{filenameSuffix}.txt");
+
+                using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
+
+                List<string> sortedKeys = [.. info.CopyProtection.FullProtections.Keys.OrderBy(k => k)];
+                foreach (string key in sortedKeys)
+                {
+                    string scanPath = key;
+                    if (hideDriveLetters)
+                        scanPath = Path.DirectorySeparatorChar + key.Substring((Path.GetPathRoot(key) ?? String.Empty).Length);
+
+                    List<string>? scanResult = info.CopyProtection.FullProtections[key];
+
+                    if (scanResult == null)
+                        sw.WriteLine($"{scanPath}: None");
+                    else
+                        sw.WriteLine($"{scanPath}: {string.Join(", ", [.. scanResult])}");
+                }
+            }
+            catch
+            {
+                // We don't care what the error is right now
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Create an IRD and write it to the specified output directory with optional filename suffix
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="outputFilename">Output filename to use as the base path</param>
+        /// <returns>True on success, false on error</returns>
+        private static async Task<(bool, string)> WriteIRD(string isoPath, string? discKeyString, string? discIDString, string? picString, long? layerbreak, string? crc32)
+        {
+            try
+            {
+                // Output IRD file path
+                string irdPath = Path.ChangeExtension(isoPath, ".ird");
+
+                // Parse disc key from submission info (Required)
+                byte[]? discKey = ProcessingTool.ParseHexKey(discKeyString);
+                if (discKey == null)
+                    return (false, "Failed to create IRD: No key provided");
+
+                // Parse Disc ID from submission info (Optional)
+                byte[]? discID = ProcessingTool.ParseDiscID(discIDString);
+
+                // Parse PIC from submission info (Optional)
+                byte[]? pic = ProcessingTool.ParsePIC(picString);
+
+                // Parse CRC32 strings into ISO hash for Unique ID field (Optional)
+                uint? uid = ProcessingTool.ParseCRC32(crc32);
+
+                // Ensure layerbreak value is valid (Optional)
+                layerbreak = ProcessingTool.ParseLayerbreak(layerbreak);
+
+                // Create Redump-style reproducible IRD
+#if NET40
+                LibIRD.ReIRD ird = await Task.Factory.StartNew(() =>
+#else
+                LibIRD.ReIRD ird = await Task.Run(() =>
+#endif
+                    new LibIRD.ReIRD(isoPath, discKey, layerbreak, uid));
+                if (pic != null)
+                    ird.PIC = pic;
+                if (discID != null && ird.DiscID[15] != 0x00)
+                    ird.DiscID = discID;
+
+                // Write IRD to file
+                ird.Write(irdPath);
+
+                return (true, "IRD created!");
+            }
+            catch (Exception)
+            {
+                // We don't care what the error is
+                return (false, "Failed to create IRD");
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/EnumExtensions.cs

@@ -0,0 +1,221 @@
+using System;
+#if NET20 || NET35
+using System.Collections.Generic;
+#else
+using System.Collections.Concurrent;
+#endif
+using System.Reflection;
+using SabreTools.RedumpLib.Data;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+
+namespace MPF.Frontend
+{
+    public static class EnumExtensions
+    {
+        #region Convert to Long Name
+
+        /// <summary>
+        /// Long name method cache
+        /// </summary>
+#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
+        /// </summary>
+        /// <param name="value">Enum value to convert</param>
+        /// <returns>String representation of that value if possible, empty string on error</returns>
+        public static string GetLongName(Enum value)
+        {
+            try
+            {
+                var sourceType = value.GetType();
+                sourceType = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
+
+                if (!LongNameMethods.TryGetValue(sourceType, out var method))
+                {
+                    method = typeof(Extensions).GetMethod("LongName", [typeof(Nullable<>).MakeGenericType(sourceType)]);
+                    method ??= typeof(EnumExtensions).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 ?? string.Empty;
+                else
+                    return string.Empty;
+            }
+            catch
+            {
+                // Converter is not implemented for the given type
+                return string.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get the string representation of the InternalProgram enum values
+        /// </summary>
+        /// <param name="prog">InternalProgram value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this InternalProgram? prog)
+        {
+            return (prog) switch
+            {
+                #region Dumping support
+
+                InternalProgram.Aaru => "Aaru",
+                InternalProgram.DiscImageCreator => "DiscImageCreator",
+                InternalProgram.Redumper => "Redumper",
+
+                #endregion
+
+                #region Verification support only
+
+                InternalProgram.CleanRip => "CleanRip",
+                InternalProgram.PS3CFW => "PS3 CFW",
+                InternalProgram.UmdImageCreator => "UmdImageCreator",
+                InternalProgram.XboxBackupCreator => "XboxBackupCreator",
+
+                #endregion
+
+                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
+
+        #region Convert from String
+
+        /// <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(this 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(this 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
+
+        #region Functionality Support
+
+        /// <summary>
+        /// Get if a system requires an anti-modchip scan
+        /// </summary>
+        public static bool SupportsAntiModchipScans(this RedumpSystem? system)
+        {
+            return system switch
+            {
+                RedumpSystem.SonyPlayStation => true,
+                _ => false,
+            };
+        }
+
+        /// <summary>
+        /// Get if a system requires a copy protection scan
+        /// </summary>
+        public static bool SupportsCopyProtectionScans(this RedumpSystem? system)
+        {
+            return system switch
+            {
+                RedumpSystem.AppleMacintosh => true,
+                RedumpSystem.EnhancedCD => true,
+                RedumpSystem.IBMPCcompatible => true,
+                RedumpSystem.PalmOS => true,
+                RedumpSystem.PocketPC => true,
+                RedumpSystem.RainbowDisc => true,
+                RedumpSystem.SonyElectronicBook => true,
+                _ => false,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/Enumerations.cs

@@ -1,4 +1,4 @@
-namespace MPF.Core.Data
+namespace MPF.Frontend
 {
     /// <summary>
     /// Drive type for dumping
@@ -20,13 +20,24 @@
 
         // Dumping support
         Aaru,
-        DD,
         DiscImageCreator,
         Redumper,
 
         // Verification support only
         CleanRip,
-        DCDumper,
+        PS3CFW,
         UmdImageCreator,
+        XboxBackupCreator,
     }
-}
+
+    /// <summary>
+    /// Log level for output
+    /// </summary>
+    public enum LogLevel
+    {
+        USER,
+        VERBOSE,
+        ERROR,
+        SECRET,
+    }
+}

MPF.Frontend/InterfaceConstants.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Constant values for UI
+    /// </summary>
+    public static class InterfaceConstants
+    {
+        /// <summary>
+        /// Set of all accepted speed values
+        /// </summary>
+        private static readonly List<int> _speedValues = [1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72];
+
+        /// <summary>
+        /// Set of accepted speeds for CD and GD media
+        /// </summary>
+        public static IList<int> CD => _speedValues.Where(s => s <= 72).ToList();
+
+        /// <summary>
+        /// Set of accepted speeds for DVD media
+        /// </summary>
+        public static IList<int> DVD => _speedValues.Where(s => s <= 24).ToList();
+
+        /// <summary>
+        /// Set of accepted speeds for HD-DVD media
+        /// </summary>
+        public static IList<int> HDDVD => _speedValues.Where(s => s <= 24).ToList();
+
+        /// <summary>
+        /// Set of accepted speeds for BD media
+        /// </summary>
+        public static IList<int> BD => _speedValues.Where(s => s <= 16).ToList();
+
+        /// <summary>
+        /// Set of accepted speeds for all other media
+        /// </summary>
+        public static IList<int> Unknown => _speedValues.Where(s => s <= 1).ToList();
+
+        /// <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>
+        public static IList<int> GetSpeedsForMediaType(MediaType? type)
+        {
+            return type switch
+            {
+                MediaType.CDROM
+                    or MediaType.GDROM => CD,
+                MediaType.DVD
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => DVD,
+                MediaType.HDDVD => HDDVD,
+                MediaType.BluRay => BD,
+                _ => Unknown,
+            };
+        }
+    }
+}

MPF.Frontend/MPF.Frontend.csproj

@@ -0,0 +1,73 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.2.2</VersionPrefix>
+
+        <!-- Package Properties -->
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>Common code for all MPF frontend 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>
+        <InternalsVisibleTo Include="MPF.Test" />
+    </ItemGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.ExecutionContexts\MPF.ExecutionContexts.csproj" />
+        <ProjectReference Include="..\MPF.Processors\MPF.Processors.csproj" />
+    </ItemGroup>
+
+    <!-- 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(`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.Net.Http" Version="4.3.4" />
+        <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" 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="SabreTools.RedumpLib" Version="1.4.1" />
+    </ItemGroup>
+
+</Project>

MPF.Frontend/Options.cs

@@ -0,0 +1,801 @@
+using System.Collections.Generic;
+using SabreTools.RedumpLib.Data;
+using AaruSettings = MPF.ExecutionContexts.Aaru.SettingConstants;
+using DICSettings = MPF.ExecutionContexts.DiscImageCreator.SettingConstants;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+using RedumperSettings = MPF.ExecutionContexts.Redumper.SettingConstants;
+
+namespace MPF.Frontend
+{
+    public class Options
+    {
+        /// <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
+        {
+            get { return GetStringSetting(Settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            set { Settings["AaruPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to DiscImageCreator
+        /// </summary>
+        public string? DiscImageCreatorPath
+        {
+            get { return GetStringSetting(Settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            set { Settings["DiscImageCreatorPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to Redumper
+        /// </summary>
+        public string? RedumperPath
+        {
+            get { return GetStringSetting(Settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
+            set { Settings["RedumperPath"] = value; }
+        }
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram InternalProgram
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "InternalProgram", InternalProgram.Redumper.ToString());
+                var valueEnum = ToInternalProgram(valueString);
+                return valueEnum == InternalProgram.NONE ? InternalProgram.Redumper : valueEnum;
+            }
+            set
+            {
+                Settings["InternalProgram"] = value.ToString();
+            }
+        }
+
+        #endregion
+
+        #region UI Defaults
+
+        /// <summary>
+        /// Enable dark mode for UI elements
+        /// </summary>
+        public bool EnableDarkMode
+        {
+            get { return GetBooleanSetting(Settings, "EnableDarkMode", false); }
+            set { Settings["EnableDarkMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable purple mode for UI elements
+        /// </summary>
+        public bool EnablePurpMode
+        {
+            get { return GetBooleanSetting(Settings, "EnablePurpMode", false); }
+            set { Settings["EnablePurpMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Custom color setting
+        /// </summary>
+        public string? CustomBackgroundColor
+        {
+            get { return GetStringSetting(Settings, "CustomBackgroundColor", null); }
+            set { Settings["CustomBackgroundColor"] = value; }
+        }
+
+        /// <summary>
+        /// Custom color setting
+        /// </summary>
+        public string? CustomTextColor
+        {
+            get { return GetStringSetting(Settings, "CustomTextColor", null); }
+            set { Settings["CustomTextColor"] = value; }
+        }
+
+        /// <summary>
+        /// Check for updates on startup
+        /// </summary>
+        public bool CheckForUpdatesOnStartup
+        {
+            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
+        {
+            get { return GetStringSetting(Settings, "DefaultOutputPath", "ISO"); }
+            set { Settings["DefaultOutputPath"] = value; }
+        }
+
+        /// <summary>
+        /// Default system if none can be detected
+        /// </summary>
+        public RedumpSystem? DefaultSystem
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "DefaultSystem", null);
+                var valueEnum = Extensions.ToRedumpSystem(valueString ?? string.Empty);
+                return valueEnum;
+            }
+            set
+            {
+                Settings["DefaultSystem"] = value.LongName();
+            }
+        }
+
+        /// <summary>
+        /// Default output path for dumps
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public bool ShowDebugViewMenuItem
+        {
+            get { return GetBooleanSetting(Settings, "ShowDebugViewMenuItem", false); }
+            set { Settings["ShowDebugViewMenuItem"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Dumping Speeds
+
+        /// <summary>
+        /// Default CD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedCD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedCD", 24); }
+            set { Settings["PreferredDumpSpeedCD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedDVD
+        {
+            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>
+        /// Default BD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedBD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedBD", 8); }
+            set { Settings["PreferredDumpSpeedBD"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Aaru
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool AaruEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.EnableDebug, AaruSettings.EnableDebugDefault); }
+            set { Settings[AaruSettings.EnableDebug] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool AaruEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.EnableVerbose, AaruSettings.EnableVerboseDefault); }
+            set { Settings[AaruSettings.EnableVerbose] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable force dumping of media by default
+        /// </summary>
+        public bool AaruForceDumping
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.ForceDumping, AaruSettings.ForceDumpingDefault); }
+            set { Settings[AaruSettings.ForceDumping] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of sector/subchannel rereads
+        /// </summary>
+        public int AaruRereadCount
+        {
+            get { return GetInt32Setting(Settings, AaruSettings.RereadCount, AaruSettings.RereadCountDefault); }
+            set { Settings[AaruSettings.RereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Strip personal data information from Aaru metadata by default
+        /// </summary>
+        public bool AaruStripPersonalData
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.StripPersonalData, AaruSettings.StripPersonalDataDefault); }
+            set { Settings[AaruSettings.StripPersonalData] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region DiscImageCreator
+
+        /// <summary>
+        /// Enable multi-sector read flag by default
+        /// </summary>
+        public bool DICMultiSectorRead
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.MultiSectorRead, DICSettings.MultiSectorReadDefault); }
+            set { Settings[DICSettings.MultiSectorRead] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include a default multi-sector read value
+        /// </summary>
+        public int DICMultiSectorReadValue
+        {
+            get { return GetInt32Setting(Settings, DICSettings.MultiSectorReadValue, DICSettings.MultiSectorReadValueDefault); }
+            set { Settings[DICSettings.MultiSectorReadValue] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable overly-secure dumping flags by default
+        /// </summary>
+        /// <remarks>
+        /// Split this into component parts later. Currently does:
+        /// - Scan sector protection and set subchannel read level to 2 for CD
+        /// - Set scan file protect flag for DVD
+        /// </remarks>
+        public bool DICParanoidMode
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.ParanoidMode, DICSettings.ParanoidModeDefault); }
+            set { Settings[DICSettings.ParanoidMode] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable the Quiet flag by default
+        /// </summary>
+        public bool DICQuietMode
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.QuietMode, DICSettings.QuietModeDefault); }
+            set { Settings[DICSettings.QuietMode] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of C2 rereads
+        /// </summary>
+        public int DICRereadCount
+        {
+            get { return GetInt32Setting(Settings, DICSettings.RereadCount, DICSettings.RereadCountDefault); }
+            set { Settings[DICSettings.RereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of DVD/HD-DVD/BD rereads
+        /// </summary>
+        public int DICDVDRereadCount
+        {
+            get { return GetInt32Setting(Settings, DICSettings.DVDRereadCount, DICSettings.DVDRereadCountDefault); }
+            set { Settings[DICSettings.DVDRereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Use the CMI flag for supported disc types
+        /// </summary>
+        public bool DICUseCMIFlag
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.UseCMIFlag, DICSettings.UseCMIFlagDefault); }
+            set { Settings[DICSettings.UseCMIFlag] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redumper
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool RedumperEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableDebug, RedumperSettings.EnableDebugDefault); }
+            set { Settings[RedumperSettings.EnableDebug] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable Redumper custom lead-in retries for Plextor drives
+        /// </summary>
+        public bool RedumperEnableLeadinRetry
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableLeadinRetry, RedumperSettings.EnableLeadinRetryDefault); }
+            set { Settings[RedumperSettings.EnableLeadinRetry] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool RedumperEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableVerbose, RedumperSettings.EnableVerboseDefault); }
+            set { Settings[RedumperSettings.EnableVerbose] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of redumper Plextor leadin retries
+        /// </summary>
+        public int RedumperLeadinRetryCount
+        {
+            get { return GetInt32Setting(Settings, RedumperSettings.LeadinRetryCount, RedumperSettings.LeadinRetryCountDefault); }
+            set { Settings[RedumperSettings.LeadinRetryCount] = 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, RedumperSettings.UseGenericDriveType, RedumperSettings.UseGenericDriveTypeDefault); }
+            set { Settings[RedumperSettings.UseGenericDriveType] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper read method
+        /// </summary>
+        public RedumperReadMethod RedumperReadMethod
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.ReadMethod, RedumperSettings.ReadMethodDefault);
+                return valueString.ToRedumperReadMethod();
+            }
+            set
+            {
+                Settings[RedumperSettings.ReadMethod] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper sector order
+        /// </summary>
+        public RedumperSectorOrder RedumperSectorOrder
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.SectorOrder, RedumperSettings.SectorOrderDefault);
+                return valueString.ToRedumperSectorOrder();
+            }
+            set
+            {
+                Settings[RedumperSettings.SectorOrder] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Default number of rereads
+        /// </summary>
+        public int RedumperRereadCount
+        {
+            get { return GetInt32Setting(Settings, RedumperSettings.RereadCount, RedumperSettings.RereadCountDefault); }
+            set { Settings[RedumperSettings.RereadCount] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Extra Dumping Options
+
+        /// <summary>
+        /// Scan the disc for protection after dumping
+        /// </summary>
+        public bool ScanForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanForProtection", true); }
+            set { Settings["ScanForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add placeholder values in the submission info
+        /// </summary>
+        public bool AddPlaceholders
+        {
+            get { return GetBooleanSetting(Settings, "AddPlaceholders", true); }
+            set { Settings["AddPlaceholders"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show the disc information window after dumping
+        /// </summary>
+        public bool PromptForDiscInformation
+        {
+            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>
+        /// Enable tabs in all input fields
+        /// </summary>
+        public bool EnableTabsInInputFields
+        {
+            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>
+        /// Show disc eject reminder before the disc information window is shown
+        /// </summary>
+        public bool ShowDiscEjectReminder
+        {
+            get { return GetBooleanSetting(Settings, "ShowDiscEjectReminder", true); }
+            set { Settings["ShowDiscEjectReminder"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Ignore fixed drives when populating the list
+        /// </summary>
+        public bool IgnoreFixedDrives
+        {
+            get { return GetBooleanSetting(Settings, "IgnoreFixedDrives", true); }
+            set { Settings["IgnoreFixedDrives"] = 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>
+        /// Output the compressed JSON version of the submission info
+        /// </summary>
+        public bool OutputSubmissionJSON
+        {
+            get { return GetBooleanSetting(Settings, "OutputSubmissionJSON", false); }
+            set { Settings["OutputSubmissionJSON"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include log files in serialized JSON data
+        /// </summary>
+        public bool IncludeArtifacts
+        {
+            get { return GetBooleanSetting(Settings, "IncludeArtifacts", false); }
+            set { Settings["IncludeArtifacts"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Compress output log files to reduce space
+        /// </summary>
+        public bool CompressLogFiles
+        {
+            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
+
+        #region Skip Options
+
+        /// <summary>
+        /// Skip detecting media type on disc scan
+        /// </summary>
+        public bool SkipMediaTypeDetection
+        {
+            get { return GetBooleanSetting(Settings, "SkipMediaTypeDetection", false); }
+            set { Settings["SkipMediaTypeDetection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Skip detecting known system on disc scan
+        /// </summary>
+        public bool SkipSystemDetection
+        {
+            get { return GetBooleanSetting(Settings, "SkipSystemDetection", false); }
+            set { Settings["SkipSystemDetection"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Protection Scanning Options
+
+        /// <summary>
+        /// Scan archive contents during protection scanning
+        /// </summary>
+        public bool ScanArchivesForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanArchivesForProtection", true); }
+            set { Settings["ScanArchivesForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Scan for executable packers during protection scanning
+        /// </summary>
+        public bool ScanPackersForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanPackersForProtection", false); }
+            set { Settings["ScanPackersForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include debug information with scan results
+        /// </summary>
+        public bool IncludeDebugProtectionInformation
+        {
+            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
+
+        #region Logging Options
+
+        /// <summary>
+        /// Enable verbose and debug logs to be written
+        /// </summary>
+        public bool VerboseLogging
+        {
+            get { return GetBooleanSetting(Settings, "VerboseLogging", true); }
+            set { Settings["VerboseLogging"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Have the log panel expanded by default on startup
+        /// </summary>
+        public bool OpenLogWindowAtStartup
+        {
+            get { return GetBooleanSetting(Settings, "OpenLogWindowAtStartup", true); }
+            set { Settings["OpenLogWindowAtStartup"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redump Login Information
+
+        public string? RedumpUsername
+        {
+            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
+        {
+            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.IsNullOrEmpty(RedumpUsername) && !string.IsNullOrEmpty(RedumpPassword); }
+
+        #endregion
+
+        /// <summary>
+        /// Constructor taking a dictionary for settings
+        /// </summary>
+        /// <param name="settings"></param>
+        public Options(Dictionary<string, string?>? settings = null)
+        {
+            this.Settings = settings ?? [];
+        }
+
+        /// <summary>
+        /// Constructor taking an existing Options object
+        /// </summary>
+        /// <param name="source"></param>
+        public Options(Options? source)
+        {
+            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
+
+        /// <summary>
+        /// Get the InternalProgram enum value for a given string
+        /// </summary>
+        /// <param name="internalProgram">String value to convert</param>
+        /// <returns>InternalProgram represented by the string, if possible</returns>
+        public static InternalProgram ToInternalProgram(string? internalProgram)
+        {
+            return (internalProgram?.ToLowerInvariant()) switch
+            {
+                // Dumping support
+                "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
+                "cleanrip"
+                    or "cr" => InternalProgram.CleanRip,
+                "ps3cfw"
+                    or "ps3"
+                    or "getkey"
+                    or "managunz"
+                    or "multiman" => InternalProgram.PS3CFW,
+                "uic"
+                    or "umd"
+                    or "umdcreator"
+                    or "umdimagecreator" => InternalProgram.UmdImageCreator,
+                "xbc"
+                    or "xbox"
+                    or "xbox360"
+                    or "xboxcreator"
+                    or "xboxbackupcreator" => InternalProgram.XboxBackupCreator,
+
+                _ => InternalProgram.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get a Boolean setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <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 static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (bool.TryParse(settings[key], out bool value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get an Int32 setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <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 static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (int.TryParse(settings[key], out int value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get a String setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <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 static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
+        {
+            if (settings.ContainsKey(key))
+                return settings[key];
+            else
+                return defaultValue;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/ProcessingQueue.cs

@@ -0,0 +1,102 @@
+using System;
+#if NET20 || NET35
+using System.Collections.Generic;
+#else
+using System.Collections.Concurrent;
+#endif
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MPF.Frontend
+{
+    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
+        /// </summary>
+        private readonly Action<T> _customProcessing;
+
+        /// <summary>
+        /// Cancellation method for the processing task
+        /// </summary>
+        private readonly CancellationTokenSource _tokenSource;
+
+        public ProcessingQueue(Action<T> customProcessing)
+        {
+#if NET20 || NET35
+            _internalQueue = new Queue<T>();
+#else
+            _internalQueue = new ConcurrentQueue<T>();
+#endif
+            _customProcessing = customProcessing;
+            _tokenSource = new CancellationTokenSource();
+#if NET20 || NET35
+            Task.Run(() => ProcessQueue());
+#elif NET40
+            Task.Factory.StartNew(() => ProcessQueue());
+#else
+            Task.Run(() => ProcessQueue(), _tokenSource.Token);
+#endif
+        }
+
+        /// <summary>
+        /// Dispose the current instance
+        /// </summary>
+        public void Dispose() => _tokenSource.Cancel();
+
+        /// <summary>
+        /// Enqueue a new item for processing
+        /// </summary>
+        /// <param name="item"></param>
+        public void Enqueue(T? item)
+        {
+            // Only accept new data when not cancelled
+            if (item != null && !_tokenSource.IsCancellationRequested)
+                _internalQueue.Enqueue(item);
+        }
+
+        /// <summary>
+        /// Process
+        /// </summary>
+        private void ProcessQueue()
+        {
+            while (true)
+            {
+                // Nothing in the queue means we get to idle
+#if NET20 || NET35
+                if (_internalQueue.Count == 0)
+#else
+                if (_internalQueue.IsEmpty)
+#endif
+                {
+                    if (_tokenSource.IsCancellationRequested)
+                        break;
+
+                    Thread.Sleep(1);
+                    continue;
+                }
+
+#if NET20 || NET35
+                // Get the next item from the queue and invoke the lambda, if possible
+                _customProcessing?.Invoke(_internalQueue.Dequeue());
+#else
+                // Get the next item from the queue
+                if (!_internalQueue.TryDequeue(out var nextItem))
+                    continue;
+
+                // Invoke the lambda, if possible
+                _customProcessing?.Invoke(nextItem);
+#endif
+            }
+        }
+    }
+}

MPF.Frontend/ResultEventArgs.cs

@@ -1,52 +1,59 @@
-namespace MPF.Core.Data
+using System;
+
+namespace MPF.Frontend
 {
     /// <summary>
     /// Generic success/failure result object, with optional message
     /// </summary>
-    public class Result
+    public class ResultEventArgs : EventArgs
     {
         /// <summary>
         /// Internal representation of success
         /// </summary>
-        private readonly bool success;
+        private readonly bool _success;
 
         /// <summary>
         /// Optional message for the result
         /// </summary>
-        public string Message { get; private set; }
+        public string Message { get; }
 
-        private Result(bool success, string message)
+        private ResultEventArgs(bool success, string message)
         {
-            this.success = success;
-            this.Message = message;
+            _success = success;
+            Message = message;
         }
 
         /// <summary>
         /// Create a default success result with no message
         /// </summary>
-        public static Result Success() => new Result(true, "");
+        public static ResultEventArgs Success() => new(true, string.Empty);
 
         /// <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 ResultEventArgs 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 ResultEventArgs Failure() => new(false, string.Empty);
 
         /// <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 ResultEventArgs Failure(string? message) => new(false, message ?? string.Empty);
 
         /// <summary>
         /// Results can be compared to boolean values based on the success value
         /// </summary>
-        public static implicit operator bool(Result result) => result.success;
+        public static implicit operator bool(ResultEventArgs result) => result._success;
+
+        /// <summary>
+        /// Results can be compared to boolean values based on the success value
+        /// </summary>
+        public static implicit operator ResultEventArgs(bool bval) => new(bval, string.Empty);
     }
 }

MPF.Frontend/StringEventArgs.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Text;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// String wrapper for event arguments
+    /// </summary>
+    public class StringEventArgs : EventArgs
+    {
+        /// <summary>
+        /// String represented by the event arguments
+        /// </summary>
+        private readonly string _value;
+
+        /// <summary>
+        /// Constructor for string values
+        /// </summary>
+        public StringEventArgs(string? value)
+        {
+            _value = value ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Constructor for StringBuilder values
+        /// </summary>
+        public StringEventArgs(StringBuilder? value)
+        {
+            _value = value?.ToString() ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator string(StringEventArgs args) => args._value;
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringBuilder(StringEventArgs args) => new(args._value);
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringEventArgs(string? str) => new(str);
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringEventArgs(StringBuilder? sb) => new(sb);
+    }
+}

MPF.Frontend/Tools/FrontendTool.cs

@@ -0,0 +1,649 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Tools
+{
+    public static class FrontendTool
+    {
+        #region Information Extraction
+
+        /// <summary>
+        /// Get the default speed for a given media type from the supplied options
+        /// </summary>
+        public static int GetDefaultSpeedForMediaType(MediaType? mediaType, Options options)
+        {
+            return mediaType switch
+            {
+                // CD dump speed
+                MediaType.CDROM => options.PreferredDumpSpeedCD,
+                MediaType.GDROM => options.PreferredDumpSpeedCD,
+
+                // DVD dump speed
+                MediaType.DVD => options.PreferredDumpSpeedDVD,
+                MediaType.NintendoGameCubeGameDisc => options.PreferredDumpSpeedDVD,
+                MediaType.NintendoWiiOpticalDisc => options.PreferredDumpSpeedDVD,
+
+                // HD-DVD dump speed
+                MediaType.HDDVD => options.PreferredDumpSpeedHDDVD,
+
+                // BD dump speed
+                MediaType.BluRay => options.PreferredDumpSpeedBD,
+
+                // Default
+                _ => options.PreferredDumpSpeedCD,
+            };
+        }
+
+        /// <summary>
+        /// Get the current system from the drive volume label
+        /// </summary>
+        /// <returns>The system based on volume label, null if none detected</returns>
+        public static RedumpSystem? GetRedumpSystemFromVolumeLabel(string? volumeLabel)
+        {
+            // If the volume label is empty, we can't do anything
+            if (string.IsNullOrEmpty(volumeLabel))
+                return null;
+
+            // Audio CD
+            if (volumeLabel!.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.AudioCD;
+
+            // Microsoft Xbox
+            if (volumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+            else if (volumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+
+            // Microsoft Xbox 360
+            if (volumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox360;
+            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 (volumeLabel.Equals("CD_ROM", StringComparison.OrdinalIgnoreCase))
+            //    return RedumpSystem.MicrosoftXbox360; // Also for Xbox One?
+            //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 (volumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation3;
+
+            // Sony PlayStation 4
+            if (volumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation4;
+
+            // Sony PlayStation 5
+            if (volumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation5;
+
+            return null;
+        }
+
+        #endregion
+
+        #region Normalization
+
+        /// <summary>
+        /// Adjust a disc title so that it will be processed correctly by Redump
+        /// </summary>
+        /// <param name="title">Existing title to potentially reformat</param>
+        /// <param name="languages">Array of languages to use for assuming articles</param>
+        /// <returns>The reformatted title</returns>
+        public static string? NormalizeDiscTitle(string? title, Language?[]? languages)
+        {
+            // If we have no set languages, then assume English
+            if (languages == null || languages.Length == 0)
+                languages = [Language.English];
+
+            // Loop through all of the given languages
+            foreach (var language in languages)
+            {
+                // If the new title is different, assume it was normalized and return it
+                string? newTitle = NormalizeDiscTitle(title, language);
+                if (newTitle != title)
+                    return newTitle;
+            }
+
+            // If we didn't already try English, try it now
+            if (!languages.Contains(Language.English))
+                return NormalizeDiscTitle(title, Language.English);
+
+            // If all fails, then the title didn't need normalization
+            return title;
+        }
+
+        /// <summary>
+        /// Adjust a disc title so that it will be processed correctly by Redump
+        /// </summary>
+        /// <param name="title">Existing title to potentially reformat</param>
+        /// <param name="language">Language to use for assuming articles</param>
+        /// <returns>The reformatted title</returns>
+        /// <remarks>
+        /// If the language of the title is unknown or if it's multilingual,
+        /// pass in Language.English for standardized coverage.
+        /// </remarks>
+        public static string? NormalizeDiscTitle(string? title, Language? language)
+        {
+            // If we have an invalid title, just return it as-is
+            if (string.IsNullOrEmpty(title))
+                return title;
+
+            // If we have an invalid language, assume Language.English
+            if (language == null)
+                language = Language.English;
+
+            // Get the title split into parts
+            string[] splitTitle = title!.Split(' ').Where(s => !string.IsNullOrEmpty(s)).ToArray();
+
+            // If we only have one part, we can't do anything
+            if (splitTitle.Length <= 1)
+                return title;
+
+            // Determine if we have a definite or indefinite article as the first item
+            string firstItem = splitTitle[0];
+            switch (firstItem.ToLowerInvariant())
+            {
+                // Latin script articles
+                case "'n"
+                    when language is Language.Manx:
+                case "a"
+                    when language is Language.English
+                        || language is Language.Hungarian
+                        || language is Language.Portuguese
+                        || language is Language.Scots:
+                case "a'"
+                    when language is Language.English
+                        || language is Language.Hungarian
+                        || language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "al"
+                    when language is Language.Breton:
+                case "am"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "an"
+                    when language is Language.Breton
+                        || language is Language.Cornish
+                        || language is Language.English
+                        || language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "anek"
+                    when language is Language.Nepali:
+                case "ar"
+                    when language is Language.Breton:
+                case "az"
+                    when language is Language.Hungarian:
+                case "ān"
+                    when language is Language.Persian:
+                case "as"
+                    when language is Language.Portuguese:
+                case "d'"
+                    when language is Language.Luxembourgish:
+                case "das"
+                    when language is Language.German:
+                case "dat"
+                    when language is Language.Luxembourgish:
+                case "de"
+                    when language is Language.Dutch:
+                case "déi"
+                    when language is Language.Luxembourgish:
+                case "dem"
+                    when language is Language.German
+                        || language is Language.Luxembourgish:
+                case "den"
+                    when language is Language.Dutch
+                        || language is Language.German
+                        || language is Language.Luxembourgish:
+                case "der"
+                    when language is Language.Dutch
+                        || language is Language.German
+                        || language is Language.Luxembourgish:
+                case "des"
+                    when language is Language.Dutch
+                        || language is Language.French
+                        || language is Language.German:
+                case "die"
+                    when language is Language.Afrikaans
+                        || language is Language.German:
+                case "du"
+                    when language is Language.French:
+                case "e"
+                    when language is Language.Papiamento:
+                case "een"
+                    when language is Language.Dutch:
+                case "egy"
+                    when language is Language.Hungarian:
+                case "ei"
+                    when language is Language.Norwegian:
+                case "ein"
+                    when language is Language.German
+                        || language is Language.Norwegian:
+                case "eine"
+                    when language is Language.German:
+                case "einem"
+                    when language is Language.German:
+                case "einen"
+                    when language is Language.German:
+                case "einer"
+                    when language is Language.German:
+                case "eines"
+                    when language is Language.German:
+                case "eit"
+                    when language is Language.Norwegian:
+                case "ek"
+                    when language is Language.Nepali:
+                case "el"
+                    when language is Language.Arabic
+                        || language is Language.Catalan
+                        || language is Language.Spanish:
+                case "els"
+                    when language is Language.Catalan:
+                case "en"
+                    when language is Language.Danish
+                        || language is Language.Luxembourgish
+                        || language is Language.Norwegian
+                        || language is Language.Swedish:
+                case "eng"
+                    when language is Language.Luxembourgish:
+                case "engem"
+                    when language is Language.Luxembourgish:
+                case "enger"
+                    when language is Language.Luxembourgish:
+                case "es"
+                    when language is Language.Catalan:
+                case "et"
+                    when language is Language.Danish
+                        || language is Language.Norwegian:
+                case "ett"
+                    when language is Language.Swedish:
+                case "euta"
+                    when language is Language.Nepali:
+                case "euti"
+                    when language is Language.Nepali:
+                case "gli"
+                    when language is Language.Italian:
+                case "he"
+                    when language is Language.Hawaiian
+                        || language is Language.Maori:
+                case "het"
+                    when language is Language.Dutch:
+                case "i"
+                    when language is Language.Italian
+                        || language is Language.Khasi:
+                case "il"
+                    when language is Language.Italian:
+                case "in"
+                    when language is Language.Persian:
+                case "ka"
+                    when language is Language.Hawaiian
+                        || language is Language.Khasi:
+                case "ke"
+                    when language is Language.Hawaiian:
+                case "ki"
+                    when language is Language.Khasi:
+                case "kunai"
+                    when language is Language.Nepali:
+                case "l'"
+                    when language is Language.Catalan
+                        || language is Language.French
+                        || language is Language.Italian:
+                case "la"
+                    when language is Language.Catalan
+                        || language is Language.Esperanto
+                        || language is Language.French
+                        || language is Language.Italian
+                        || language is Language.Spanish:
+                case "las"
+                    when language is Language.Spanish:
+                case "le"
+                    when language is Language.French
+                        || language is Language.Interlingua
+                        || language is Language.Italian:
+                case "les"
+                    when language is Language.Catalan
+                        || language is Language.French:
+                case "lo"
+                    when language is Language.Catalan
+                        || language is Language.Italian
+                        || language is Language.Spanish:
+                case "los"
+                    when language is Language.Catalan
+                        || language is Language.Spanish:
+                case "na"
+                    when language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "nam"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "nan"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "nā"
+                    when language is Language.Hawaiian:
+                case "ngā"
+                    when language is Language.Maori:
+                case "niște"
+                    when language is Language.Romanian:
+                case "ny"
+                    when language is Language.Manx:
+                case "o"
+                    when language is Language.Portuguese
+                        || language is Language.Romanian:
+                case "os"
+                    when language is Language.Portuguese:
+                case "sa"
+                    when language is Language.Catalan:
+                case "sang"
+                    when language is Language.Malay:
+                case "se"
+                    when language is Language.Finnish:
+                case "ses"
+                    when language is Language.Catalan:
+                case "si"
+                    when language is Language.Malay:
+                case "te"
+                    when language is Language.Maori:
+                case "the"
+                    when language is Language.English
+                        || language is Language.Scots:
+                case "u"
+                    when language is Language.Khasi:
+                case "ul"
+                    when language is Language.Breton:
+                case "um"
+                    when language is Language.Portuguese:
+                case "uma"
+                    when language is Language.Portuguese:
+                case "umas"
+                    when language is Language.Portuguese:
+                case "un"
+                    when language is Language.Breton
+                        || language is Language.Catalan
+                        || language is Language.French
+                        || language is Language.Interlingua
+                        || language is Language.Italian
+                        || language is Language.Papiamento
+                        || language is Language.Romanian
+                        || language is Language.Spanish:
+                case "un'"
+                    when language is Language.Italian:
+                case "una"
+                    when language is Language.Catalan
+                        || language is Language.Italian:
+                case "unas"
+                    when language is Language.Spanish:
+                case "une"
+                    when language is Language.French:
+                case "uno"
+                    when language is Language.Italian:
+                case "unos"
+                    when language is Language.Spanish:
+                case "uns"
+                    when language is Language.Catalan
+                        || language is Language.Portuguese:
+                case "unei"
+                    when language is Language.Romanian:
+                case "unes"
+                    when language is Language.Catalan:
+                case "unor"
+                    when language is Language.Romanian:
+                case "unui"
+                    when language is Language.Romanian:
+                case "ur"
+                    when language is Language.Breton:
+                case "y"
+                    when language is Language.Manx
+                        || language is Language.Welsh:
+                case "ye"
+                    when language is Language.Persian:
+                case "yek"
+                    when language is Language.Persian:
+                case "yn"
+                    when language is Language.Manx:
+                case "yr"
+                    when language is Language.Welsh:
+
+                // Non-latin script articles
+                case "ο"
+                    when language is Language.Greek:
+                case "η"
+                    when language is Language.Greek:
+                case "το"
+                    when language is Language.Greek:
+                case "οι"
+                    when language is Language.Greek:
+                case "τα"
+                    when language is Language.Greek:
+                case "ένας"
+                    when language is Language.Greek:
+                case "μια"
+                    when language is Language.Greek:
+                case "ένα"
+                    when language is Language.Greek:
+                case "еден"
+                    when language is Language.Macedonian:
+                case "една"
+                    when language is Language.Macedonian:
+                case "едно"
+                    when language is Language.Macedonian:
+                case "едни"
+                    when language is Language.Macedonian:
+                case "एउटा"
+                    when language is Language.Nepali:
+                case "एउटी"
+                    when language is Language.Nepali:
+                case "एक"
+                    when language is Language.Nepali:
+                case "अनेक"
+                    when language is Language.Nepali:
+                case "कुनै"
+                    when language is Language.Nepali:
+                case "דער"
+                    when language is Language.Yiddish:
+                case "די"
+                    when language is Language.Yiddish:
+                case "דאָס"
+                    when language is Language.Yiddish:
+                case "דעם"
+                    when language is Language.Yiddish:
+                case "אַ"
+                    when language is Language.Yiddish:
+                case "אַן"
+                    when language is Language.Yiddish:
+
+                    break;
+
+                // Otherwise, just return it as-is
+                default:
+                    return title;
+            }
+
+            // Insert the first item if we have a `:` or `-`
+            bool itemInserted = false;
+            var newTitleBuilder = new StringBuilder();
+            for (int i = 1; i < splitTitle.Length; i++)
+            {
+                string segment = splitTitle[i];
+                if (!itemInserted && segment == ":")
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($", {firstItem} :");
+                }
+                else if (!itemInserted && segment == "-")
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($", {firstItem} -");
+                }
+                else if (!itemInserted && segment.EndsWith(":"))
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}:");
+                }
+                else if (!itemInserted && segment.EndsWith("-"))
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}-");
+                }
+                else
+                {
+                    newTitleBuilder.Append($" {segment}");
+                }
+            }
+
+            // If we didn't insert the item yet, add it to the end
+            string newTitle = newTitleBuilder.ToString().Trim();
+            if (!itemInserted)
+                newTitle = $"{newTitle}, {firstItem}";
+
+            return newTitle;
+        }
+
+        /// <summary>
+        /// Normalize a split set of paths
+        /// </summary>
+        /// <param name="path">Path value to normalize</param>
+        public static string NormalizeOutputPaths(string? path, bool getFullPath)
+        {
+            // The easy way
+            try
+            {
+                // If we have an invalid path
+                if (string.IsNullOrEmpty(path))
+                    return string.Empty;
+
+                // Remove quotes and angle brackets from path
+                path = path!.Replace("\"", string.Empty);
+                path = path!.Replace("<", string.Empty);
+                path = path!.Replace(">", string.Empty);
+
+                // Try getting the combined path and returning that directly
+                string fullPath = getFullPath ? Path.GetFullPath(path) : path;
+                var fullDirectory = Path.GetDirectoryName(fullPath);
+                string fullFile = Path.GetFileName(fullPath);
+
+                // Remove invalid path characters
+                if (fullDirectory != null)
+                {
+                    foreach (char c in Path.GetInvalidPathChars())
+                        fullDirectory = fullDirectory.Replace(c, '_');
+                }
+
+                // Remove invalid filename characters
+                foreach (char c in Path.GetInvalidFileNameChars())
+                    fullFile = fullFile.Replace(c, '_');
+
+                if (string.IsNullOrEmpty(fullDirectory))
+                    return fullFile;
+                else
+                    return Path.Combine(fullDirectory, fullFile);
+            }
+            catch { }
+
+            return path ?? string.Empty;
+        }
+
+        #endregion
+
+        #region Versioning
+
+        /// <summary>
+        /// Check for a new MPF version
+        /// </summary>
+        /// <returns>
+        /// Bool representing if the values are different.
+        /// 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()
+        {
+            try
+            {
+                // Get current assembly version
+                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
+                var (tag, url) = GetRemoteVersionAndUrl();
+                bool different = version != tag && tag != null;
+
+                string message = $"Local version: {version}"
+                    + $"{Environment.NewLine}Remote version: {tag}"
+                    + (different
+                        ? $"{Environment.NewLine}The update URL has been added copied to your clipboard"
+                        : $"{Environment.NewLine}You have the newest version!");
+
+                return (different, message, url);
+            }
+            catch (Exception ex)
+            {
+                return (false, ex.ToString(), null);
+            }
+        }
+
+        /// <summary>
+        /// Get the current informational version formatted as a string
+        /// </summary>
+        public static string? GetCurrentVersion()
+        {
+            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()
+        {
+#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
+            System.Net.ServicePointManager.SecurityProtocol = System.Net.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 = Newtonsoft.Json.Linq.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
+    }
+}

MPF.Frontend/Tools/OptionsLoader.cs

@@ -0,0 +1,321 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Tools
+{
+    public static class OptionsLoader
+    {
+        /// <summary>
+        /// Full path to the configuration file used by the program
+        /// </summary>
+#if NET20 || NET35 || NET40 || NET452
+        private static string ConfigurationPath => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config.json");
+#else
+        private static string ConfigurationPath => Path.Combine(AppContext.BaseDirectory, "config.json");
+#endif
+
+        #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] == "-lc" || args[0] == "--listcodes")
+            {
+                Console.WriteLine("Supported Site Codes:");
+                foreach (string siteCode in Extensions.ListSiteCodes())
+                {
+                    Console.WriteLine(siteCode);
+                }
+                Console.ReadLine();
+                return true;
+            }
+            else 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 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 = 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>
+        /// List all programs with their short usable names
+        /// </summary>
+        private static List<string> ListPrograms()
+        {
+            var programs = new List<string>();
+
+            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
+            {
+                if (((InternalProgram)val!) == InternalProgram.NONE)
+                    continue;
+
+                programs.Add($"{((InternalProgram?)val).LongName()}");
+            }
+
+            return programs;
+        }
+
+        /// <summary>
+        /// Get the MediaType enum value for a given string
+        /// </summary>
+        /// <param name="type">String value to convert</param>
+        /// <returns>MediaType represented by the string, if possible</returns>
+        private static MediaType ToMediaType(string type)
+        {
+            return (type.ToLowerInvariant()) switch
+            {
+                #region Punched Media
+
+                "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
+
+                "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
+
+                "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
+                "cartridge" => MediaType.Cartridge,
+                "ced"
+                    or "rcaced"
+                    or "rca ced"
+                    or "videodisc"
+                    or "rca videodisc" => MediaType.CED,
+
+                _ => MediaType.NONE,
+            };
+        }
+
+        #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).Dispose();
+                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?>;
+            reader.Dispose();
+            return new Options(settings);
+        }
+
+        /// <summary>
+        /// Save the current set of options to the application configuration
+        /// </summary>
+        public static void SaveToConfig(Options options, bool saveDefault = false)
+        {
+            // If default values should be saved as well
+            if (saveDefault)
+            {
+                PropertyInfo[] properties = typeof(Options).GetProperties();
+                foreach (var property in properties)
+                {
+                    // Skip dictionary properties
+                    if (property.Name == "Item")
+                        continue;
+
+                    // Skip non-option properties
+                    if (property.Name == "Settings" || property.Name == "HasRedumpLogin")
+                        continue;
+
+                    var val = property.GetValue(options, null);
+                    property.SetValue(options, val, null);
+                }
+            }
+
+            // Handle a very strange edge case
+            if (!File.Exists(ConfigurationPath))
+                File.Create(ConfigurationPath).Dispose();
+
+            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.Frontend/Tools/PhysicalTool.cs

@@ -0,0 +1,591 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using SabreTools.IO;
+
+namespace MPF.Frontend.Tools
+{
+    public static class PhysicalTool
+    {
+        #region Generic
+
+        /// <summary>s
+        /// Get the last modified date for a file from a physical disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <param name="filePath">Relative file path</param>
+        /// <returns>Output last modified date in "yyyy-mm-dd" format if possible, null on error</returns>
+        public static string? GetFileDate(Drive? drive, string? filePath, bool fixTwoDigitYear = false)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If the executable name is invalid, we can't do this part
+            if (string.IsNullOrEmpty(filePath))
+                return null;
+
+            // Now that we have the EXE name, try to get the fileinfo for it
+            string exePath = Path.Combine(drive.Name, filePath);
+            if (!File.Exists(exePath))
+                return null;
+
+            // Get the last modified time
+            var fi = new FileInfo(exePath);
+            var lastModified = fi.LastWriteTimeUtc;
+            int year = lastModified.Year;
+            int month = lastModified.Month;
+            int day = lastModified.Day;
+
+            // Fix the Y2K timestamp issue, if required
+            if (fixTwoDigitYear)
+                year = year >= 1900 && year < 1920 ? 2000 + year % 100 : year;
+
+            // Format and return the string
+            var dt = new DateTime(year, month, day);
+            return dt.ToString("yyyy-MM-dd");
+        }
+
+        #endregion
+
+        #region BD-Video
+
+        /// <summary>
+        /// Get if the Bus Encryption Enabled (BEE) flag is set in a path
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Bus encryption enabled status if possible, false otherwise</returns>
+        public static bool GetBusEncryptionEnabled(Drive? drive)
+        {
+            // If there's no drive path, we can't get BEE flag
+            if (string.IsNullOrEmpty(drive?.Name))
+                return false;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return false;
+
+            // Get the two possible file paths
+#if NET20 || NET35
+            string content000 = Path.Combine(Path.Combine(drive.Name, "AACS"), "Content000.cer");
+            string content001 = Path.Combine(Path.Combine(drive.Name, "AACS"), "Content001.cer");
+#else
+            string content000 = Path.Combine(drive.Name, "AACS", "Content000.cer");
+            string content001 = Path.Combine(drive.Name, "AACS", "Content001.cer");
+#endif
+
+            try
+            {
+                // Check the required files
+                if (File.Exists(content000) && new FileInfo(content000).Length > 1)
+                {
+                    using var fs = File.OpenRead(content000);
+                    _ = fs.ReadByte(); // Skip the first byte
+                    return fs.ReadByte() > 127;
+                }
+                else if (File.Exists(content001) && new FileInfo(content001).Length > 1)
+                {
+                    using var fs = File.OpenRead(content001);
+                    _ = fs.ReadByte(); // Skip the first byte
+                    return fs.ReadByte() > 127;
+                }
+
+                // False if neither file fits the criteria
+                return false;
+            }
+            catch
+            {
+                // We don't care what the error is right now
+                return false;
+            }
+        }
+
+        #endregion
+
+        #region PlayStation
+
+        /// <summary>
+        /// Get the EXE name from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Executable name on success, null otherwise</returns>
+        public static string? GetPlayStationExecutableName(Drive? drive)
+        {
+            // If there's no drive path, we can't get exe name
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the two paths that we will need to check
+            string psxExePath = Path.Combine(drive.Name, "PSX.EXE");
+            string systemCnfPath = Path.Combine(drive.Name, "SYSTEM.CNF");
+
+            // Read the CNF file as an INI file
+            var systemCnf = new IniFile(systemCnfPath);
+            string? bootValue = string.Empty;
+
+            // PlayStation uses "BOOT" as the key
+            if (systemCnf.ContainsKey("BOOT"))
+                bootValue = systemCnf["BOOT"];
+
+            // PlayStation 2 uses "BOOT2" as the key
+            if (systemCnf.ContainsKey("BOOT2"))
+                bootValue = systemCnf["BOOT2"];
+
+            // If we had any boot value, parse it and get the executable name
+            if (!string.IsNullOrEmpty(bootValue))
+            {
+                var match = Regex.Match(bootValue, @"cdrom.?:\\?(.*)", RegexOptions.Compiled);
+                if (match.Groups.Count > 1)
+                {
+                    string? serial = match.Groups[1].Value;
+
+                    // Some games may have the EXE in a subfolder
+                    serial = Path.GetFileName(serial);
+
+                    return serial;
+                }
+            }
+
+            // If the SYSTEM.CNF value can't be found, try PSX.EXE
+            if (File.Exists(psxExePath))
+                return "PSX.EXE";
+
+            // If neither can be found, we return null
+            return null;
+        }
+
+        /// <summary>
+        /// Get the serial from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Serial on success, null otherwise</returns>
+        public static string? GetPlayStationSerial(Drive? drive)
+        {
+            // Try to get the executable name
+            string? exeName = GetPlayStationExecutableName(drive);
+            if (string.IsNullOrEmpty(exeName))
+                return null;
+
+            // Handle generic PSX.EXE
+            if (exeName == "PSX.EXE")
+                return null;
+
+            // EXE name may have a trailing `;` after
+            // EXE name should always be in all caps
+            exeName = exeName!
+                .Split(';')[0]
+                .ToUpperInvariant();
+
+            // Serial is most of the EXE name normalized
+            return exeName
+                .Replace('_', '-')
+                .Replace(".", string.Empty);
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 2 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation2Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the SYSTEM.CNF path to check
+            string systemCnfPath = Path.Combine(drive.Name, "SYSTEM.CNF");
+
+            // Try to parse the SYSTEM.CNF file
+            var systemCnf = new IniFile(systemCnfPath);
+            if (systemCnf.ContainsKey("VER"))
+                return systemCnf["VER"];
+
+            // If "VER" can't be found, we can't do much
+            return null;
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation3Serial(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to use PS3_DISC.SFB
+            string sfbPath = Path.Combine(drive.Name, "PS3_DISC.SFB");
+            if (File.Exists(sfbPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfbPath));
+                    br.BaseStream.Seek(0x220, SeekOrigin.Begin);
+                    return new string(br.ReadChars(0x10)).TrimEnd('\0');
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            // Attempt to use PARAM.SFO
+#if NET20 || NET35
+            string sfoPath = Path.Combine(Path.Combine(drive.Name, "PS3_GAME"), "PARAM.SFO");
+#else
+            string sfoPath = Path.Combine(drive.Name, "PS3_GAME", "PARAM.SFO");
+#endif
+            if (File.Exists(sfoPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfoPath));
+                    br.BaseStream.Seek(-0x18, SeekOrigin.End);
+                    return new string(br.ReadChars(9)).TrimEnd('\0').Insert(4, "-");
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation3Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to use PS3_DISC.SFB
+            string sfbPath = Path.Combine(drive.Name, "PS3_DISC.SFB");
+            if (File.Exists(sfbPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfbPath));
+                    br.BaseStream.Seek(0x230, SeekOrigin.Begin);
+                    var discVersion = new string(br.ReadChars(0x10)).TrimEnd('\0');
+                    if (!string.IsNullOrEmpty(discVersion))
+                        return discVersion;
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            // Attempt to use PARAM.SFO
+#if NET20 || NET35
+            string sfoPath = Path.Combine(Path.Combine(drive.Name, "PS3_GAME"), "PARAM.SFO");
+#else
+            string sfoPath = Path.Combine(drive.Name, "PS3_GAME", "PARAM.SFO");
+#endif
+            if (File.Exists(sfoPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfoPath));
+                    br.BaseStream.Seek(-0x08, SeekOrigin.End);
+                    return new string(br.ReadChars(5)).TrimEnd('\0');
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get the firmware version from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Firmware version if possible, null on error</returns>
+        public static string? GetPlayStation3FirmwareVersion(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to read from /PS3_UPDATE/PS3UPDAT.PUP
+#if NET20 || NET35
+            string pupPath = Path.Combine(Path.Combine(drive.Name, "PS3_UPDATE"), "PS3UPDAT.PUP");
+#else
+            string pupPath = Path.Combine(drive.Name, "PS3_UPDATE", "PS3UPDAT.PUP");
+#endif
+            if (!File.Exists(pupPath))
+                return null;
+
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(pupPath));
+                br.BaseStream.Seek(0x3E, SeekOrigin.Begin);
+                byte[] buf = new byte[2];
+                br.Read(buf, 0, 2);
+                Array.Reverse(buf);
+                short location = BitConverter.ToInt16(buf, 0);
+                br.BaseStream.Seek(location, SeekOrigin.Begin);
+                return new string(br.ReadChars(4));
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 4 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation4Serial(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.sfo, we don't have a PlayStation 4 disc
+#if NET20 || NET35
+            string paramSfoPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.sfo");
+#else
+            string paramSfoPath = Path.Combine(drive.Name, "bd", "param.sfo");
+#endif
+            if (!File.Exists(paramSfoPath))
+                return null;
+
+            // Let's try reading param.sfo to find the serial at the end of the file
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(paramSfoPath));
+                br.BaseStream.Seek(-0x14, SeekOrigin.End);
+                return new string(br.ReadChars(9)).Insert(4, "-");
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 4 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation4Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.sfo, we don't have a PlayStation 4 disc
+#if NET20 || NET35
+            string paramSfoPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.sfo");
+#else
+            string paramSfoPath = Path.Combine(drive.Name, "bd", "param.sfo");
+#endif
+            if (!File.Exists(paramSfoPath))
+                return null;
+
+            // Let's try reading param.sfo to find the version at the end of the file
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(paramSfoPath));
+                br.BaseStream.Seek(-0x08, SeekOrigin.End);
+                return new string(br.ReadChars(5));
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 5 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation5Serial(Drive? drive)
+        {
+            // Attempt to get the param.json file
+            var json = GetPlayStation5ParamsJsonFromDrive(drive);
+            if (json == null)
+                return null;
+
+            try
+            {
+                return json["disc"]?[0]?["masterDataId"]?.Value<string>()?.Insert(4, "-");
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        // <summary>
+        /// Get the version from a PlayStation 5 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation5Version(Drive? drive)
+        {
+            // Attempt to get the param.json file
+            var json = GetPlayStation5ParamsJsonFromDrive(drive);
+            if (json == null)
+                return null;
+
+            try
+            {
+                return json["masterVersion"]?.Value<string>();
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the params.json file from a drive path, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>JObject representing the JSON on success, null on error</returns>
+        private static JObject? GetPlayStation5ParamsJsonFromDrive(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.json, we don't have a PlayStation 5 disc
+#if NET20 || NET35
+            string paramJsonPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.json");
+#else
+            string paramJsonPath = Path.Combine(drive.Name, "bd", "param.json");
+#endif
+            return GetPlayStation5ParamsJsonFromFile(paramJsonPath);
+        }
+
+        /// <summary>
+        /// Get the params.json file from a filename, if possible
+        /// </summary>
+        /// <param name="filename">Filename to check</param>
+        /// <returns>JObject representing the JSON on success, null on error</returns>
+        private static JObject? GetPlayStation5ParamsJsonFromFile(string? filename)
+        {
+            // If the file doesn't exist
+            if (string.IsNullOrEmpty(filename) || !File.Exists(filename))
+                return null;
+
+            // Let's try reading param.json to find the version in the unencrypted JSON
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(filename));
+                br.BaseStream.Seek(0x800, SeekOrigin.Begin);
+                byte[] jsonBytes = br.ReadBytes((int)(br.BaseStream.Length - 0x800));
+                return JsonConvert.DeserializeObject(Encoding.ASCII.GetString(jsonBytes)) as JObject;
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        #endregion
+
+        #region Xbox
+
+        /// <summary>
+        /// Get all filenames for Xbox One and Xbox Series X
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Filenames if possible, null on error</returns>
+        public static string? GetXboxFilenames(Drive? drive)
+        {
+            // If there's no drive path, we can't get BEE flag
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the MSXC directory path
+            string msxc = Path.Combine(drive.Name, "MSXC");
+            if (!Directory.Exists(msxc))
+                return null;
+
+            try
+            {
+                var files = Directory.GetFiles(msxc, "*", SearchOption.TopDirectoryOnly);
+                var filenames = files.Select(Path.GetFileName).ToArray();
+                return string.Join("\n", filenames);
+            }
+            catch
+            {
+                // We don't care what the error is right now
+                return null;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/Tools/ProtectionTool.cs

@@ -4,14 +4,34 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
-using BinaryObjectScanner.Protection;
-using BurnOutSharp;
-using psxt001z;
+using BinaryObjectScanner;
 
-namespace MPF.Library
+#pragma warning disable SYSLIB1045 // Convert to 'GeneratedRegexAttribute'.
+
+namespace MPF.Frontend.Tools
 {
-    public static class Protection
+    public static class ProtectionTool
     {
+        /// <summary>
+        /// Get the current detected copy protection(s), if possible
+        /// </summary>
+        /// <param name="drive">Drive object representing the current drive</param>
+        /// <param name="options">Options object that determines what to scan</param>
+        /// <param name="progress">Optional progress callback</param>
+        /// <returns>Detected copy protection(s) if possible, null on error</returns>
+        public static async Task<(string?, Dictionary<string, List<string>>?)> GetCopyProtection(Drive? drive,
+            Frontend.Options options,
+            IProgress<ProtectionProgress>? progress = null)
+        {
+            if (options.ScanForProtection && drive?.Name != null)
+            {
+                (var protection, _) = await RunProtectionScanOnPath(drive.Name, options, progress);
+                return (FormatProtections(protection), protection);
+            }
+
+            return ("(CHECK WITH PROTECTIONID)", null);
+        }
+
         /// <summary>
         /// Run protection scan on a given path
         /// </summary>
@@ -19,10 +39,27 @@ namespace MPF.Library
         /// <param name="options">Options object that determines what to scan</param>
         /// <param name="progress">Optional progress callback</param>
         /// <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, Core.Data.Options options, IProgress<ProtectionProgress> progress = null)
+        public static async Task<(Dictionary<string, List<string>>?, string?)> RunProtectionScanOnPath(string path,
+            Frontend.Options options,
+            IProgress<ProtectionProgress>? progress = null)
         {
             try
             {
+#if NET40
+                var found = await Task.Factory.StartNew(() =>
+                {
+                    var scanner = new 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 Scanner(
@@ -36,14 +73,23 @@ namespace MPF.Library
 
                     return scanner.GetProtections(path);
                 });
+#endif
 
                 // If nothing was returned, return
-                if (found == null || !found.Any())
+#if NET20 || NET35
+                if (found == null || found.Count == 0)
+#else
+                if (found == null || found.IsEmpty)
+#endif
                     return (null, null);
 
                 // Filter out any empty protections
                 var filteredProtections = found
-                    .Where(kvp => kvp.Value != null && kvp.Value.Any())
+#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());
@@ -62,11 +108,11 @@ namespace MPF.Library
         /// </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)
+        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";
+                return "None found [OMIT FROM SUBMISSION]";
 
             // Get an ordered list of distinct found protections
             var orderedDistinctProtections = protections
@@ -76,8 +122,8 @@ namespace MPF.Library
 
             // Sanitize and join protections for writing
             string protectionString = SanitizeFoundProtections(orderedDistinctProtections);
-            if (string.IsNullOrWhiteSpace(protectionString))
-                return "None found";
+            if (string.IsNullOrEmpty(protectionString))
+                return "None found [OMIT FROM SUBMISSION]";
 
             return protectionString;
         }
@@ -87,20 +133,25 @@ namespace MPF.Library
         /// </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);
-                            if (!string.IsNullOrWhiteSpace(protection))
+                            var protection = antiModchip.CheckContents(file, fileContent, false);
+                            if (!string.IsNullOrEmpty(protection))
                                 return true;
                         }
                         catch { }
@@ -110,20 +161,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 { }
 
-        /// <summary>
-        /// Get if LibCrypt data is detected in the subchannel file, if possible
-        /// </summary>
-        /// <param name="sub">.sub file location</param>
-        /// <returns>Status of the LibCrypt data, if possible</returns>
-        public static bool? GetLibCryptDetected(string sub)
-        {
-            // If the file doesn't exist, we can't get info from it
-            if (!File.Exists(sub))
-                return null;
-
-            return LibCrypt.CheckSubfile(sub);
+                return false;
+            });
+#endif
         }
 
         /// <summary>
@@ -132,12 +196,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
@@ -167,7 +246,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")
@@ -210,84 +289,70 @@ namespace MPF.Library
                     .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
-            // TODO: Update based on new internal naming schemes
             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) && !p.StartsWith("Macrovision Protection File")))
                 {
-                    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) && !p.StartsWith("Macrovision Protection File")))
                 {
-                    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) && !p.StartsWith("Macrovision Protection File")))
                 {
-                    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");
                 }
             }
 
@@ -300,7 +365,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")
@@ -335,7 +400,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.Frontend/Tools/SubmissionGenerator.cs

@@ -0,0 +1,905 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.Processors;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Frontend.Tools
+{
+    /// <summary>
+    /// Generator for SubmissionInfo objects
+    /// </summary>
+    internal static class SubmissionGenerator
+    {
+        #region Constants
+
+        private const string RequiredValue = "(REQUIRED)";
+        private const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
+        private const string OptionalValue = "(OPTIONAL)";
+
+        #endregion
+
+        #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="processor">Processor object representing how to process the outputs</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,
+            Frontend.Options options,
+            BaseProcessor processor,
+            IProgress<ResultEventArgs>? resultProgress = null,
+            IProgress<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) = processor.FoundAllFiles(outputDirectory, outputFilename);
+            if (!foundFiles)
+            {
+                resultProgress?.Report(ResultEventArgs.Failure($"There were files missing from the output:\n{string.Join("\n", [.. missingFiles])}"));
+                resultProgress?.Report(ResultEventArgs.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);
+
+            // Create the default submission info
+            SubmissionInfo info = CreateDefaultSubmissionInfo(processor, system, mediaType, options.AddPlaceholders);
+
+            // Get specific tool output handling
+            processor?.GenerateSubmissionInfo(info, combinedBase, options.EnableRedumpCompatibility);
+            if (options.IncludeArtifacts)
+                info.Artifacts = processor?.GenerateArtifacts(combinedBase);
+
+            // 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, processor?.VolumeLabels);
+            if (volLabels != null)
+                info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.VolumeLabel] = volLabels;
+
+            // Extract info based generically on MediaType
+            ProcessMediaType(info, mediaType, options.AddPlaceholders);
+
+            // Extract info based specifically on RedumpSystem
+            ProcessSystem(info, system, drive, options.AddPlaceholders, processor is DiscImageCreator, combinedBase);
+
+            // Run anti-modchip check, if necessary
+            if (drive != null && system.SupportsAntiModchipScans() && info.CopyProtection!.AntiModchip == YesNo.NULL)
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Checking for anti-modchip strings... this might take a while!"));
+                info.CopyProtection.AntiModchip = await ProtectionTool.GetPlayStationAntiModchipDetected(drive?.Name) ? YesNo.Yes : YesNo.No;
+                resultProgress?.Report(ResultEventArgs.Success("Anti-modchip string scan complete!"));
+            }
+
+            // Run copy protection, if possible or necessary
+            if (system.SupportsCopyProtectionScans())
+            {
+                resultProgress?.Report(ResultEventArgs.Success("Running copy protection scan... this might take a while!"));
+                var (protectionString, fullProtections) = await ProtectionTool.GetCopyProtection(drive, options, protectionProgress);
+
+                info.CopyProtection!.Protection += protectionString;
+                info.CopyProtection.FullProtections = fullProtections as Dictionary<string, List<string>?> ?? [];
+                resultProgress?.Report(ResultEventArgs.Success("Copy protection scan complete!"));
+            }
+
+            // Set fields that may have automatic filling otherwise
+            info.CommonDiscInfo!.Category ??= DiscCategory.Games;
+            info.VersionAndEditions!.Version ??= options.AddPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+            // Comments and contents have odd handling
+            if (string.IsNullOrEmpty(info.CommonDiscInfo.Comments))
+                info.CommonDiscInfo.Comments = options.AddPlaceholders ? OptionalValue : string.Empty;
+            if (string.IsNullOrEmpty(info.CommonDiscInfo.Contents))
+                info.CommonDiscInfo.Contents = options.AddPlaceholders ? 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>
+        public async static Task<bool> FillFromRedump(Frontend.Options options, SubmissionInfo info, IProgress<ResultEventArgs>? resultProgress = null)
+        {
+            // 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
+            var wc = new RedumpClient();
+            bool? loggedIn = await wc.Login(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty);
+            if (loggedIn == null)
+            {
+                resultProgress?.Report(ResultEventArgs.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 checks
+            bool allFound = true;
+            List<int[]> foundIdSets = [];
+
+            // Loop through all of the hashdata to find matching IDs
+            resultProgress?.Report(ResultEventArgs.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(ResultEventArgs.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(ResultEventArgs.Success("Extra track found, skipping!"));
+                    continue;
+                }
+
+                // Get the SHA-1 hash
+                if (!ProcessingTool.GetISOHashValues(hashData, out _, out _, out _, out string? sha1))
+                {
+                    resultProgress?.Report(ResultEventArgs.Failure($"Line could not be parsed: {hashData}"));
+                    continue;
+                }
+
+                (bool singleFound, var foundIds, string? result) = await Validator.ValidateSingleTrack(wc, info, sha1);
+                if (singleFound)
+                    resultProgress?.Report(ResultEventArgs.Success(result));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure(result));
+
+                // Add the found IDs to the map
+                foundIdSets.Add(foundIds?.ToArray() ?? []);
+
+                // Ensure that all tracks are found
+                allFound &= singleFound;
+            }
+
+            // If all tracks were found, check if there are any fully-matched IDs
+            List<int>? fullyMatchedIDs = null;
+            if (allFound)
+            {
+                fullyMatchedIDs = null;
+                foreach (var set in foundIdSets)
+                {
+                    // First track is always all IDs
+                    if (fullyMatchedIDs == null)
+                    {
+                        fullyMatchedIDs = [.. set];
+                        continue;
+                    }
+
+                    // Try to intersect with all known IDs
+                    fullyMatchedIDs = fullyMatchedIDs.Intersect(set).ToList();
+                    if (!fullyMatchedIDs.Any())
+                        break;
+                }
+            }
+
+            // 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(ResultEventArgs.Success(result));
+                else
+                    resultProgress?.Report(ResultEventArgs.Failure(result));
+
+                // Ensure that the hash is found
+                allFound = singleFound;
+
+                // If we found a match, then the disc is a match
+                if (singleFound && foundIds != null)
+                    fullyMatchedIDs = foundIds;
+                else
+                    fullyMatchedIDs = [];
+            }
+
+            // Make sure we only have unique IDs
+            info.PartiallyMatchedIDs = [.. info.PartiallyMatchedIDs.Distinct().OrderBy(id => id)];
+
+            resultProgress?.Report(ResultEventArgs.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(ResultEventArgs.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(ResultEventArgs.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>
+        /// Creates a default SubmissionInfo object based on the current system and media type
+        /// </summary>
+        private static SubmissionInfo CreateDefaultSubmissionInfo(BaseProcessor processor, RedumpSystem? system, MediaType? mediaType, bool addPlaceholders)
+        {
+            // Create the template object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    System = system,
+                    Media = mediaType.ToDiscType(),
+                    Title = addPlaceholders ? RequiredValue : string.Empty,
+                    ForeignTitleNonLatin = addPlaceholders ? OptionalValue : string.Empty,
+                    DiscNumberLetter = addPlaceholders ? OptionalValue : string.Empty,
+                    DiscTitle = addPlaceholders ? OptionalValue : string.Empty,
+                    Category = null,
+                    Region = null,
+                    Languages = null,
+                    Serial = addPlaceholders ? RequiredIfExistsValue : string.Empty,
+                    Barcode = addPlaceholders ? OptionalValue : string.Empty,
+                    Contents = string.Empty,
+                },
+                VersionAndEditions = new VersionAndEditionsSection()
+                {
+                    OtherEditions = addPlaceholders ? "(VERIFY THIS) Original" : string.Empty,
+                },
+                DumpingInfo = new DumpingInfoSection()
+                {
+                    FrontendVersion = FrontendTool.GetCurrentVersion(),
+                    DumpingProgram = GetDumpingProgramFromProcessor(processor),
+                },
+            };
+
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+            return info;
+        }
+
+        /// <summary>
+        /// Get the dumping program name from the processor
+        /// </summary>
+        /// <param name="processor"></param>
+        /// <returns></returns>
+        private static string? GetDumpingProgramFromProcessor(BaseProcessor processor)
+        {
+            // Map to the internal program
+            InternalProgram? internalProgram = processor switch
+            {
+                Processors.Aaru => InternalProgram.Aaru,
+                CleanRip => InternalProgram.CleanRip,
+                DiscImageCreator => InternalProgram.DiscImageCreator,
+                PS3CFW => InternalProgram.PS3CFW,
+                Redumper => InternalProgram.Redumper,
+                UmdImageCreator => InternalProgram.UmdImageCreator,
+                XboxBackupCreator => InternalProgram.XboxBackupCreator,
+                _ => null,
+            };
+
+            // Use the internal program to map to the name
+            return internalProgram.LongName();
+        }
+
+        /// <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 (FrontendTool.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 (FrontendTool.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) && FrontendTool.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 (FrontendTool.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]);
+        }
+
+        /// <summary>
+        /// Processes default data based on media type
+        /// </summary>
+        private static bool ProcessMediaType(SubmissionInfo info, MediaType? mediaType, bool addPlaceholders)
+        {
+            switch (mediaType)
+            {
+                case MediaType.CDROM:
+                case MediaType.GDROM:
+                    info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? 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 = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a dual-layer disc
+                    else if (info.SizeAndChecksums!.Layerbreak2 == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a triple-layer disc
+                    else if (info.SizeAndChecksums!.Layerbreak3 == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer2MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a quad-layer disc
+                    else
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer2MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer2ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer3MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer3MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer3ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+
+                    break;
+
+                case MediaType.NintendoGameCubeGameDisc:
+                    info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.Extras!.BCA ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case MediaType.NintendoWiiOpticalDisc:
+
+                    // If we have a single-layer disc
+                    if (info.SizeAndChecksums!.Layerbreak == default)
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+                    // If we have a dual-layer disc
+                    else
+                    {
+                        info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer0AdditionalMould = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                        info.CommonDiscInfo.Layer1MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                        info.CommonDiscInfo.Layer1MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    }
+
+                    info.Extras!.DiscKey = addPlaceholders ? RequiredValue : string.Empty;
+                    info.Extras.BCA ??= addPlaceholders ? RequiredValue : string.Empty;
+
+                    break;
+
+                case MediaType.UMD:
+                    // Both single- and dual-layer discs have two "layers" for the ring
+                    info.CommonDiscInfo!.Layer0MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer0MouldSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                    info.CommonDiscInfo.Layer1MasteringRing = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1MasteringSID = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    info.CommonDiscInfo.Layer1ToolstampMasteringCode = addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                    info.SizeAndChecksums!.CRC32 ??= (addPlaceholders ? RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.SizeAndChecksums.MD5 ??= (addPlaceholders ? RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.SizeAndChecksums.SHA1 ??= (addPlaceholders ? RequiredValue + " [Not automatically generated for UMD]" : string.Empty);
+                    info.TracksAndWriteOffsets!.ClrMameProData = null;
+                    break;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Processes default data based on system type
+        /// </summary>
+        private static bool ProcessSystem(SubmissionInfo info, RedumpSystem? system, Drive? drive, bool addPlaceholders, bool isDiscImageCreator, string basePath)
+        {
+            // Extract info based specifically on RedumpSystem
+            switch (system)
+            {
+                case RedumpSystem.AcornArchimedes:
+                    info.CommonDiscInfo!.Region ??= Region.UnitedKingdom;
+                    break;
+
+                case RedumpSystem.AudioCD:
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.EnhancedCD:
+                case RedumpSystem.SuperAudioCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Audio;
+                    break;
+
+                case RedumpSystem.BandaiPlaydiaQuickInteractiveSystem:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= info.CommonDiscInfo.Region ?? Region.Japan;
+                    break;
+
+                case RedumpSystem.BDVideo:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    bool bee = PhysicalTool.GetBusEncryptionEnabled(drive);
+                    if (bee && string.IsNullOrEmpty(info.CopyProtection!.Protection))
+                        info.CopyProtection.Protection = "Bus encryption enabled flag set";
+                    else if (bee)
+                        info.CopyProtection!.Protection += "\nBus encryption enabled flag set";
+                    else
+                        info.CopyProtection!.Protection ??= addPlaceholders ? RequiredIfExistsValue : string.Empty;
+
+                    break;
+
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.HDDVDVideo:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    info.CopyProtection!.Protection ??= addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCD:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCD32:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Europe;
+                    break;
+
+                case RedumpSystem.CommodoreAmigaCDTV:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Europe;
+                    break;
+
+                case RedumpSystem.FujitsuFMTownsseries:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? 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:
+                case RedumpSystem.SonyElectronicBook:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Multimedia;
+                    break;
+
+                case RedumpSystem.IncredibleTechnologiesEagle:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamieAmusement:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiFireBeat:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiPython2:
+                    string? kp2Exe = PhysicalTool.GetPlayStationExecutableName(drive);
+
+                    // TODO: Remove this hack when DIC supports build date output
+                    if (isDiscImageCreator)
+                        info.CommonDiscInfo!.EXEDateBuildDate = DiscImageCreator.GetPlayStationEXEDate($"{basePath}_volDesc.txt", kp2Exe);
+
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStationSerial);
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= PhysicalTool.GetFileDate(drive, kp2Exe, fixTwoDigitYear: true);
+
+                    if (CommentFieldExists(info, SiteCode.InternalSerialName, out kp2Exe))
+                        info.CommonDiscInfo!.Region = ProcessingTool.GetPlayStationRegion(kp2Exe);
+
+                    SetVersionIfNotExists(info, drive, PhysicalTool.GetPlayStation2Version);
+                    break;
+
+                case RedumpSystem.KonamiSystemGV:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiSystem573:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.KonamiTwinkle:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.MattelHyperScan:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.MicrosoftXboxOne:
+                    info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.Filename] = PhysicalTool.GetXboxFilenames(drive) ?? string.Empty;
+                    break;
+
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                    info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.Filename] = PhysicalTool.GetXboxFilenames(drive) ?? string.Empty;
+                    break;
+
+                case RedumpSystem.NamcoSegaNintendoTriforce:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.NavisoftNaviken21:
+                    info.CommonDiscInfo!.EXEDateBuildDate = addPlaceholders ? RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPC88series:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPC98series:
+                    info.CommonDiscInfo!.EXEDateBuildDate = addPlaceholders ? RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.NECPCFXPCFXGA:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.SegaChihiro:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaDreamcast:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaNaomi:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaNaomi2:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SegaTitanVideo:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SharpX68000:
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.SNKNeoGeoCD:
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= addPlaceholders ? RequiredValue : string.Empty;
+                    break;
+
+                case RedumpSystem.SonyPlayStation:
+                    string? ps1Exe = PhysicalTool.GetPlayStationExecutableName(drive);
+
+                    // TODO: Remove this hack when DIC supports build date output
+                    if (isDiscImageCreator)
+                        info.CommonDiscInfo!.EXEDateBuildDate = DiscImageCreator.GetPlayStationEXEDate($"{basePath}_volDesc.txt", ps1Exe, psx: true);
+
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStationSerial);
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= PhysicalTool.GetFileDate(drive, ps1Exe, fixTwoDigitYear: true);
+
+                    if (CommentFieldExists(info, SiteCode.InternalSerialName, out ps1Exe))
+                        info.CommonDiscInfo!.Region = ProcessingTool.GetPlayStationRegion(ps1Exe);
+
+                    break;
+
+                case RedumpSystem.SonyPlayStation2:
+                    info.CommonDiscInfo!.LanguageSelection ??= [];
+                    string? ps2Exe = PhysicalTool.GetPlayStationExecutableName(drive);
+
+                    // TODO: Remove this hack when DIC supports build date output
+                    if (isDiscImageCreator)
+                        info.CommonDiscInfo!.EXEDateBuildDate = DiscImageCreator.GetPlayStationEXEDate($"{basePath}_volDesc.txt", ps2Exe);
+
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStationSerial);
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= PhysicalTool.GetFileDate(drive, ps2Exe, fixTwoDigitYear: true);
+
+                    if (CommentFieldExists(info, SiteCode.InternalSerialName, out ps2Exe))
+                        info.CommonDiscInfo.Region = ProcessingTool.GetPlayStationRegion(ps2Exe);
+
+                    SetVersionIfNotExists(info, drive, PhysicalTool.GetPlayStation2Version);
+                    break;
+
+                case RedumpSystem.SonyPlayStation3:
+                    info.Extras!.DiscKey ??= addPlaceholders ? RequiredValue : string.Empty;
+                    info.Extras.DiscID ??= addPlaceholders ? RequiredValue : string.Empty;
+
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStation3Serial);
+                    SetVersionIfNotExists(info, drive, PhysicalTool.GetPlayStation3Version);
+                    SetCommentFieldIfNotExists(info, SiteCode.Patches, drive, FormatPlayStation3FirmwareVersion);
+                    break;
+
+                case RedumpSystem.SonyPlayStation4:
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStation4Serial);
+                    SetVersionIfNotExists(info, drive, PhysicalTool.GetPlayStation4Version);
+                    break;
+
+                case RedumpSystem.SonyPlayStation5:
+                    SetCommentFieldIfNotExists(info, SiteCode.InternalSerialName, drive, PhysicalTool.GetPlayStation5Serial);
+                    SetVersionIfNotExists(info, drive, PhysicalTool.GetPlayStation5Version);
+                    break;
+
+                case RedumpSystem.TomyKissSite:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    info.CommonDiscInfo!.Region ??= Region.Japan;
+                    break;
+
+                case RedumpSystem.ZAPiTGamesGameWaveFamilyEntertainmentSystem:
+                    info.CopyProtection!.Protection ??= addPlaceholders ? RequiredIfExistsValue : string.Empty;
+                    break;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Get a preformatted string for the PS3 firmware version, if possible
+        /// </summary>
+        private static string? FormatPlayStation3FirmwareVersion(Drive? drive)
+        {
+            string? firmwareVersion = PhysicalTool.GetPlayStation3FirmwareVersion(drive);
+            if (string.IsNullOrEmpty(firmwareVersion))
+                return string.Empty;
+
+            return $"PS3 Firmware {firmwareVersion}";
+        }
+
+        /// <summary>
+        /// Determine if a comment field exists based on key
+        /// </summary>
+        private static bool CommentFieldExists(SubmissionInfo info, SiteCode key, out string? value)
+        {
+            // Ensure the comments fields exist
+            if (info.CommonDiscInfo!.CommentsSpecialFields == null)
+                info.CommonDiscInfo.CommentsSpecialFields = [];
+
+            // Check if the field exists
+            if (!info.CommonDiscInfo.CommentsSpecialFields.TryGetValue(key, out value))
+                return false;
+            if (string.IsNullOrEmpty(value))
+                return false;
+
+            // The value is valid
+            return true;
+        }
+
+        /// <summary>
+        /// Set a comment field if it doesn't already have a value
+        /// </summary>
+        private static void SetCommentFieldIfNotExists(SubmissionInfo info, SiteCode key, Drive? drive, Func<Drive?, string?> valueFunc)
+        {
+            // If the field has a valid value, skip
+            if (CommentFieldExists(info, key, out _))
+                return;
+
+            // Set the value
+            info.CommonDiscInfo!.CommentsSpecialFields![key] = valueFunc(drive) ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Set the version if it doesn't already have a value
+        /// </summary>
+        private static void SetVersionIfNotExists(SubmissionInfo info, Drive? drive, Func<Drive?, string?> valueFunc)
+        {
+            // If the version already exists, skip
+            if (!string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                return;
+
+            // Set the version
+            info.VersionAndEditions.Version = valueFunc(drive) ?? string.Empty;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/ViewModels/CheckDumpViewModel.cs

@@ -0,0 +1,481 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.Frontend.ComboBoxItems;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.ViewModels
+{
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public class CheckDumpViewModel : INotifyPropertyChanged
+    {
+        #region Fields
+
+        /// <summary>
+        /// Access to the current options
+        /// </summary>
+        public Frontend.Options Options
+        {
+            get => _options;
+        }
+        private readonly Frontend.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, InternalProgram.XboxBackupCreator };
+            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<ResultEventArgs>();
+            var protectionProgress = new Progress<ProtectionProgress>();
+
+            // 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.Frontend/ViewModels/DiscInformationViewModel.cs

@@ -0,0 +1,246 @@
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Frontend.ComboBoxItems;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.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 = FrontendTool.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.Frontend/ViewModels/OptionsViewModel.cs

@@ -0,0 +1,155 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading.Tasks;
+using MPF.Frontend.ComboBoxItems;
+using SabreTools.RedumpLib.Web;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+
+namespace MPF.Frontend.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>
+        public static async Task<(bool?, string?)> TestRedumpLogin(string username, string password)
+        {
+            return await RedumpClient.ValidateCredentials(username, password);
+        }
+
+        /// <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.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/DumpEnvironment.cs

@@ -1,574 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Threading.Tasks;
-using BurnOutSharp;
-using MPF.Core.Data;
-using MPF.Core.Utilities;
-using MPF.Modules;
-using RedumpLib.Data;
-
-namespace MPF.Library
-{
-    /// <summary>
-    /// Represents the state of all settings to be used during dumping
-    /// </summary>
-    public class DumpEnvironment
-    {
-        #region Output paths
-
-        /// <summary>
-        /// Base output file path to write files to
-        /// </summary>
-        public string OutputPath { get; private set; }
-
-        #endregion
-
-        #region UI information
-
-        /// <summary>
-        /// Drive object representing the current drive
-        /// </summary>
-        public Drive Drive { get; private set; }
-
-        /// <summary>
-        /// Currently selected system
-        /// </summary>
-        public RedumpSystem? System { get; private set; }
-
-        /// <summary>
-        /// Currently selected media type
-        /// </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 Core.Data.Options Options { get; private set; }
-
-        /// <summary>
-        /// Parameters object representing what to send to the internal program
-        /// </summary>
-        public BaseParameters Parameters { get; private set; }
-
-        #endregion
-        
-        #region Event Handlers
-
-        /// <summary>
-        /// Generic way of reporting a message
-        /// </summary>
-        public EventHandler<string> ReportStatus;
-
-        /// <summary>
-        /// Queue of items that need to be logged
-        /// </summary>
-        private ProcessingQueue<string> outputQueue;
-
-        /// <summary>
-        /// Event handler for data returned from a process
-        /// </summary>
-        private void OutputToLog(object proc, string args) => outputQueue.Enqueue(args);
-
-        /// <summary>
-        /// Process the outputs in the queue
-        /// </summary>
-        private void ProcessOutputs(string nextOutput) => ReportStatus.Invoke(this, nextOutput);
-
-        #endregion
-
-        /// <summary>
-        /// Constructor for a full DumpEnvironment object from user information
-        /// </summary>
-        /// <param name="options"></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(Core.Data.Options options,
-            string outputPath,
-            Drive drive,
-            RedumpSystem? system,
-            MediaType? type,
-            InternalProgram? internalProgram,
-            string parameters)
-        {
-            // Set options object
-            this.Options = options;
-
-            // Output paths
-            this.OutputPath = InfoTool.NormalizeOutputPaths(outputPath);
-
-            // UI information
-            this.Drive = drive;
-            this.System = system ?? options.DefaultSystem;
-            this.Type = type ?? MediaType.NONE;
-            this.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;
-
-            try
-            {
-                // Normalize the output path
-                string outputPath = InfoTool.NormalizeOutputPaths(this.OutputPath);
-
-                // Replace all instances in the output directory
-                string outputDirectory = Path.GetDirectoryName(outputPath);
-                outputDirectory = outputDirectory.Replace(".", "_");
-
-                // Replace all instances in the output filename
-                string outputFilename = Path.GetFileNameWithoutExtension(outputPath);
-                outputFilename = outputFilename.Replace(".", "_");
-
-                // Get the extension for recreating the path
-                string outputExtension = Path.GetExtension(outputPath).TrimStart('.');
-
-                // Rebuild the output path
-                if (!string.IsNullOrWhiteSpace(outputExtension))
-                    this.OutputPath = Path.Combine(outputDirectory, $"{outputFilename}.{outputExtension}");
-                else
-                    this.OutputPath = Path.Combine(outputDirectory, outputFilename);
-
-                // Assign the path to the filename as well for dumping
-                ((Modules.DiscImageCreator.Parameters)this.Parameters).Filename = this.OutputPath;
-            }
-            catch { }
-        }
-
-        /// <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)
-        {
-            switch (this.InternalProgram)
-            {
-                // 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;
-
-                case InternalProgram.Redumper:
-                    this.Parameters = new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath };
-                    break;
-
-                // Verification support only
-                case InternalProgram.CleanRip:
-                    this.Parameters = new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null };
-                    break;
-
-                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;
-
-                // This should never happen, but it needs a fallback
-                default:
-                    this.Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
-                    break;
-            }
-
-            // Set system and type
-            this.Parameters.System = this.System;
-            this.Parameters.Type = this.Type;
-        }
-
-        /// <summary>
-        /// Get the full parameter string for either DiscImageCreator or Aaru
-        /// </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)
-        {
-            // Populate with the correct params for inputs (if we're not on the default option)
-            if (System != null && Type != MediaType.NONE)
-            {
-                // If drive letter is invalid, skip this
-                if (Drive == null)
-                    return null;
-
-                // Set the proper parameters
-                switch (this.InternalProgram)
-                {
-                    case InternalProgram.Aaru:
-                        Parameters = new Modules.Aaru.Parameters(System, Type, Drive.Letter, this.OutputPath, driveSpeed, Options);
-                        break;
-
-                    case InternalProgram.DD:
-                        Parameters = new Modules.DD.Parameters(System, Type, Drive.Letter, this.OutputPath, driveSpeed, Options);
-                        break;
-
-                    case InternalProgram.DiscImageCreator:
-                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, this.OutputPath, driveSpeed, Options);
-                        break;
-
-                    case InternalProgram.Redumper:
-                        Parameters = new Modules.Redumper.Parameters(System, Type, Drive.Letter, this.OutputPath, driveSpeed, Options);
-                        break;
-
-                    // This should never happen, but it needs a fallback
-                    default:
-                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, this.OutputPath, driveSpeed, Options);
-                        break;
-                }
-
-                // Generate and return the param string
-                return Parameters.GenerateParameters();
-            }
-
-            return null;
-        }
-
-        #endregion
-
-        #region Dumping
-
-        /// <summary>
-        /// Cancel an in-progress dumping process
-        /// </summary>
-        public void CancelDumping() => Parameters.KillInternalProgram();
-
-        /// <summary>
-        /// Eject the disc using DiscImageCreator
-        /// </summary>
-        public async Task<string> EjectDisc() =>
-            await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Eject);
-
-        /// <summary>
-        /// Reset the current drive using DiscImageCreator
-        /// </summary>
-        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)
-        {
-            // Check that we have the basics for dumping
-            Result result = IsValidForDump();
-            if (!result)
-                return result;
-
-            // Invoke output processing, if needed
-            if (!Options.ToolsInSeparateWindow)
-            {
-                outputQueue = new ProcessingQueue<string>(ProcessOutputs);
-                Parameters.ReportStatus += OutputToLog;
-            }
-
-            // Execute internal tool
-            progress?.Report(Result.Success($"Executing {this.InternalProgram}... {(Options.ToolsInSeparateWindow ? "please wait!" : "see log for output!")}"));
-            Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath));
-            await Task.Run(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
-            progress?.Report(Result.Success($"{this.InternalProgram} has finished!"));
-
-            // Execute additional tools
-            progress?.Report(Result.Success("Running any additional tools... see log for output!"));
-            result = await Task.Run(() => ExecuteAdditionalTools());
-            progress?.Report(result);
-
-            // Remove event handler if needed
-            if (!Options.ToolsInSeparateWindow)
-            {
-                outputQueue.Dispose();
-                Parameters.ReportStatus -= OutputToLog;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Verify that the current environment has a complete dump and create submission info is possible
-        /// </summary>
-        /// <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>
-        /// <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)
-        {
-            resultProgress?.Report(Result.Success("Gathering submission information... please wait!"));
-
-            // Get the output directory and filename separately
-            string outputDirectory = Path.GetDirectoryName(this.OutputPath);
-            string outputFilename = Path.GetFileName(this.OutputPath);
-
-            // Check to make sure that the output had all the correct files
-            (bool foundFiles, List<string> missingFiles) = InfoTool.FoundAllFiles(outputDirectory, outputFilename, this.Parameters, false);
-            if (!foundFiles)
-            {
-                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.OutputPath,
-                this.Drive,
-                this.System,
-                this.Type,
-                this.Options,
-                this.Parameters,
-                resultProgress,
-                protectionProgress);
-            resultProgress?.Report(Result.Success("Extracting information complete!"));
-
-            // Eject the disc automatically if configured to
-            if (Options.EjectAfterDump == true)
-            {
-                resultProgress?.Report(Result.Success($"Ejecting disc in drive {Drive.Letter}"));
-                await EjectDisc();
-            }
-
-            // Reset the drive automatically if configured to
-            if (this.InternalProgram == InternalProgram.DiscImageCreator && Options.DICResetDriveAfterDump)
-            {
-                resultProgress?.Report(Result.Success($"Resetting drive {Drive.Letter}"));
-                await ResetDrive();
-            }
-
-            // Get user-modifiable information if confugured to
-            if (Options.PromptForDiscInformation && processUserInfo != null)
-            {
-                resultProgress?.Report(Result.Success("Waiting for additional disc information..."));
-
-                bool? filledInfo;
-                (filledInfo, submissionInfo) = processUserInfo(submissionInfo);
-
-                if (filledInfo == true)
-                    resultProgress?.Report(Result.Success("Additional disc information added!"));
-                else
-                    resultProgress?.Report(Result.Success("Disc information skipped!"));
-            }
-
-            // Process special fields for site codes
-            resultProgress?.Report(Result.Success("Processing site codes..."));
-            InfoTool.ProcessSpecialFields(submissionInfo);
-            resultProgress?.Report(Result.Success("Processing complete!"));
-
-            // Format the information for the text output
-            resultProgress?.Report(Result.Success("Formatting information..."));
-            (List<string> formattedValues, string formatResult) = InfoTool.FormatOutputData(submissionInfo, this.Options);
-            if (formattedValues == null)
-                resultProgress?.Report(Result.Success(formatResult));
-            else
-                resultProgress?.Report(Result.Failure(formatResult));
-
-            // Write the text output
-            resultProgress?.Report(Result.Success("Writing information to !submissionInfo.txt..."));
-            (bool txtSuccess, string txtResult) = InfoTool.WriteOutputData(outputDirectory, formattedValues);
-            if (txtSuccess)
-                resultProgress?.Report(Result.Success(txtResult));
-            else
-                resultProgress?.Report(Result.Failure(txtResult));
-
-            // Write the copy protection output
-            if (Options.ScanForProtection && Options.OutputSeparateProtectionFile)
-            {
-                resultProgress?.Report(Result.Success("Writing protection to !protectionInfo.txt..."));
-                bool scanSuccess = InfoTool.WriteProtectionData(outputDirectory, submissionInfo);
-                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{(Options.IncludeArtifacts ? ".gz" : string.Empty)}..."));
-                bool jsonSuccess = InfoTool.WriteOutputData(outputDirectory, submissionInfo, Options.IncludeArtifacts);
-                if (jsonSuccess)
-                    resultProgress?.Report(Result.Success("Writing complete!"));
-                else
-                    resultProgress?.Report(Result.Failure("Writing could not complete!"));
-            }
-
-            // Compress the logs, if required
-            if (Options.CompressLogFiles)
-            {
-                resultProgress?.Report(Result.Success("Compressing log files..."));
-                (bool compressSuccess, string compressResult) = InfoTool.CompressLogFiles(outputDirectory, outputFilename, this.Parameters);
-                if (compressSuccess)
-                    resultProgress?.Report(Result.Success(compressResult));
-                else
-                    resultProgress?.Report(Result.Failure(compressResult));
-            }
-
-            resultProgress?.Report(Result.Success("Submission information process complete!"));
-            return Result.Success();
-        }
-
-        /// <summary>
-        /// Checks if the parameters are valid
-        /// </summary>
-        /// <returns>True if the configuration is valid, false otherwise</returns>
-        internal bool ParametersValid()
-        {
-            bool parametersValid = Parameters.IsValid();
-            bool floppyValid = !(Drive.InternalDriveType == InternalDriveType.Floppy ^ Type == MediaType.FloppyDisk);
-
-            // TODO: HardDisk being in the Removable category is a hack, fix this later
-            bool removableDiskValid = !((Drive.InternalDriveType == InternalDriveType.Removable || Drive.InternalDriveType == InternalDriveType.HardDisk)
-                ^ (Type == MediaType.CompactFlash || Type == MediaType.SDCard || Type == MediaType.FlashDrive || Type == MediaType.HardDisk));
-
-            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)
-        {
-            Process childProcess;
-            string output = await Task.Run(() =>
-            {
-                childProcess = new Process()
-                {
-                    StartInfo = new ProcessStartInfo()
-                    {
-                        FileName = parameters.ExecutablePath,
-                        Arguments = parameters.GenerateParameters(),
-                        CreateNoWindow = true,
-                        UseShellExecute = false,
-                        RedirectStandardInput = true,
-                        RedirectStandardOutput = true,
-                    },
-                };
-                childProcess.Start();
-                childProcess.WaitForExit(1000);
-
-                // Just in case, we want to push a button 5 times to clear any errors
-                for (int i = 0; i < 5; i++)
-                    childProcess.StandardInput.WriteLine("Y");
-
-                string stdout = childProcess.StandardOutput.ReadToEnd();
-                childProcess.Dispose();
-                return stdout;
-            });
-
-            return output;
-        }
-
-        /// <summary>
-        /// Validate the current environment is ready for a dump
-        /// </summary>
-        /// <returns>Result instance with the outcome</returns>
-        private Result IsValidForDump()
-        {
-            // Validate that everything is good
-            if (!ParametersValid())
-                return Result.Failure("Error! Current configuration is not supported!");
-
-            // Fix the output paths, just in case
-            this.OutputPath = InfoTool.NormalizeOutputPaths(this.OutputPath);
-
-            // Validate that the output path isn't on the dumping drive
-            if (this.OutputPath[0] == Drive.Letter)
-                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!");
-
-            // Validate that the current configuration is supported
-            return Tools.GetSupportStatus(System, Type);
-        }
-
-        /// <summary>
-        /// Validate that DIscImageCreator is able to be found
-        /// </summary>
-        /// <returns>True if DiscImageCreator is found properly, false otherwise</returns>
-        private bool RequiredProgramsExist()
-        {
-            // Validate that the path is configured
-            if (string.IsNullOrWhiteSpace(Options.DiscImageCreatorPath))
-                return false;
-
-            // Validate that the required program exists
-            if (!File.Exists(Options.DiscImageCreatorPath))
-                return false;
-
-            return true;
-        }
-
-        /// <summary>
-        /// Run a standalone DiscImageCreator command
-        /// </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)
-        {
-            // 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)
-                return null;
-
-            CancelDumping();
-
-            var parameters = new Modules.DiscImageCreator.Parameters(string.Empty)
-            {
-                BaseCommand = command,
-                DriveLetter = Drive.Letter.ToString(),
-                ExecutablePath = Options.DiscImageCreatorPath,
-            };
-
-            return await ExecuteInternalProgram(parameters);
-        }
-
-        #endregion
-    }
-}

MPF.Library/MPF.Library.csproj

@@ -1,48 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net48;net6.0</TargetFrameworks>
-    <RuntimeIdentifiers>win7-x64;win8-x64;win81-x64;win10-x64;linux-x64;osx-x64</RuntimeIdentifiers>
-    <AssemblyName>MPF.Library</AssemblyName>
-    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
-    <Copyright>Copyright (c)2019-2023</Copyright>
-    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.6.2</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>
-    <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="2.8.0" GeneratePathProperty="true">
-      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="System.IO.Compression" Version="4.3.0" />
-    <PackageReference Include="System.IO.Compression.ZipFile" Version="4.3.0" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.3">
-      <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/Aaru/Constants.cs

@@ -1,491 +0,0 @@
-namespace MPF.Modules.Aaru
-{
-    /// <summary>
-    /// Top-level commands for Aaru
-    /// </summary>
-    public static class CommandStrings
-    {
-        public const string NONE = "";
-
-        // Archive Family
-        public const string ArchivePrefixShort = "arc";
-        public const string ArchivePrefixLong = "archive";
-        public const string ArchiveInfo = "info";
-
-        // Database Family
-        public const string DatabasePrefixShort = "db";
-        public const string DatabasePrefixLong = "database";
-        public const string DatabaseStats = "stats";
-        public const string DatabaseUpdate = "update";
-
-        // Device Family
-        public const string DevicePrefixShort = "dev";
-        public const string DevicePrefixLong = "device";
-        public const string DeviceInfo = "info";
-        public const string DeviceList = "list";
-        public const string DeviceReport = "report";
-
-        // Filesystem Family
-        public const string FilesystemPrefixShort = "fi";
-        public const string FilesystemPrefixShortAlt = "fs";
-        public const string FilesystemPrefixLong = "filesystem";
-        public const string FilesystemExtract = "extract";
-        public const string FilesystemInfo = "info";
-        public const string FilesystemListShort = "ls";
-        public const string FilesystemListLong = "list";
-        public const string FilesystemOptions = "options";
-
-        // Image Family
-        public const string ImagePrefixShort = "i";
-        public const string ImagePrefixLong = "image";
-        public const string ImageChecksumShort = "chk";
-        public const string ImageChecksumLong = "checksum";
-        public const string ImageCompareShort = "cmp";
-        public const string ImageCompareLong = "compare";
-        public const string ImageConvert = "convert";
-        public const string ImageCreateSidecar = "create-sidecar";
-        public const string ImageDecode = "decode";
-        public const string ImageEntropy = "entropy";
-        public const string ImageInfo = "info";
-        public const string ImageOptions = "options";
-        public const string ImagePrint = "print";
-        public const string ImageVerify = "verify";
-
-        // Media Family
-        public const string MediaPrefixShort = "m";
-        public const string MediaPrefixLong = "media";
-        public const string MediaDump = "dump";
-        public const string MediaInfo = "info";
-        public const string MediaScan = "scan";
-
-        // Standalone Commands
-        public const string Configure = "configure";
-        public const string Formats = "formats";
-        public const string ListEncodings = "list-encodings";
-        public const string ListNamespaces = "list-namespaces";
-        public const string Remote = "remote";
-    }
-
-    /// <summary>
-    /// Supported encodings for Aaru
-    /// </summary>
-    /// TODO: Use to verify encoding settings
-    public static class EncodingStrings
-    {
-        public const string ArabicMac = "x-mac-arabic";
-        public const string AtariASCII = "atascii";
-        public const string CentralEuropeanMac = "x-mac-ce";
-        public const string CommodorePETSCII = "petscii";
-        public const string CroatianMac = "x-mac-croatian";
-        public const string CyrillicMac = "x-mac-cryillic";
-        public const string FarsiMac = "x-mac-farsi";
-        public const string GreekMac = "x-mac-greek";
-        public const string HebrewMac = "x-mac-hebrew";
-        public const string RomanianMac = "x-mac-romanian";
-        public const string SinclairZXSpectrum = "spectrum";
-        public const string SinclairZX80 = "zx80";
-        public const string SinclairZX81 = "zx81";
-        public const string TurkishMac = "x-mac-turkish";
-        public const string UkrainianMac = "x-mac-ukrainian";
-        public const string Unicode = "utf-16";
-        public const string UnicodeBigEndian = "utf-16BE";
-        public const string UnicodeUTF32BigEndian = "utf-32BE";
-        public const string UnicodeUTF32 = "utf-32";
-        public const string UnicodeUTF7 = "utf-7";
-        public const string UnicodeUTF8 = "utf-8";
-        public const string USASCII = "us-ascii";
-        public const string WesternEuropeanAppleII = "apple2";
-        public const string WesternEuropeanAppleIIc = "apple2c";
-        public const string WesternEuropeanAppleIIe = "apple2e";
-        public const string WesternEuropeanAppleIIgs = "apple2gs";
-        public const string WesternEuropeanAppleLisa = "lisa";
-        public const string WesternEuropeanAtariST = "atarist";
-        public const string WesternEuropeanGEM = "gem";
-        public const string WesternEuropeanGEOS = "geos";
-        public const string WesternEuropeanISO = "iso-8859-1";
-        public const string WesternEuropeanMac = "macintosh";
-        public const string WesternEuropeanRadix50 = "radix50";
-    }
-
-    /// <summary>
-    /// Dumping flags for Aaru
-    /// </summary>
-    public static class FlagStrings
-    {
-        // Boolean flags
-        public const string Adler32Short = "-a";
-        public const string Adler32Long = "--adler32";
-        public const string ClearLong = "--clear";
-        public const string ClearAllLong = "--clear-all";
-        public const string CRC16Long = "--crc16";
-        public const string CRC32Short = "-c";
-        public const string CRC32Long = "--crc32";
-        public const string CRC64Long = "--crc64";
-        public const string DebugShort = "-d";
-        public const string DebugLong = "--debug";
-        public const string DiskTagsShort = "-f";
-        public const string DiskTagsLong = "--disk-tags";
-        public const string DuplicatedSectorsShort = "-p";
-        public const string DuplicatedSectorsLong = "--duplicated-sectors";
-        public const string EjectLong = "--eject";
-        public const string ExtendedAttributesShort = "-x";
-        public const string ExtendedAttributesLong = "--xattrs";
-        public const string FilesystemsShort = "-f";
-        public const string FilesystemsLong = "--filesystems";
-        public const string FirstPregapLong = "--first-pregap";
-        public const string FixOffsetLong = "--fix-offset";
-        public const string FixSubchannelLong = "--fix-subchannel";
-        public const string FixSubchannelCrcLong = "--fix-subchannel-crc";
-        public const string FixSubchannelPositionLong = "--fix-subchannel-position";
-        public const string Fletcher16Long = "--fletcher16";
-        public const string Fletcher32Long = "--fletcher32";
-        public const string ForceShort = "-f";
-        public const string ForceLong = "--force";
-        public const string GenerateSubchannelsLong = "--generate-subchannels";
-        public const string HelpShort = "-h";
-        public const string HelpShortAlt = "-?";
-        public const string HelpLong = "--help";
-        public const string LongFormatShort = "-l";
-        public const string LongFormatLong = "--long-format";
-        public const string LongSectorsShort = "-r";
-        public const string LongSectorsLong = "--long-sectors";
-        public const string MD5Short = "-m";
-        public const string MD5Long = "--md5";
-        public const string MetadataLong = "--metadata";
-        public const string PartitionsShort = "-p";
-        public const string PartitionsLong = "--partitions";
-        public const string PauseLong = "--pause";
-        public const string PersistentLong = "--persistent";
-        public const string PrivateLong = "--private";
-        public const string ResumeShort = "-r";
-        public const string ResumeLong = "--resume";
-        public const string RetrySubchannelLong = "--retry-subchannel";
-        public const string SectorTagsShort = "-p";
-        public const string SectorTagsLong = "--sector-tags";
-        public const string SeparatedTracksShort = "-t";
-        public const string SeparatedTracksLong = "--separated-tracks";
-        public const string SHA1Short = "-s";
-        public const string SHA1Long = "--sha1";
-        public const string SHA256Long = "--sha256";
-        public const string SHA384Long = "--sha384";
-        public const string SHA512Long = "--sha512";
-        public const string SkipCdiReadyHoleLong = "--skip-cdiready-hole";
-        public const string SpamSumShort = "-f";
-        public const string SpamSumLong = "--spamsum";
-        public const string StopOnErrorShort = "-s";
-        public const string StopOnErrorLong = "--stop-on-error";
-        public const string StoreEncryptedLong = "--store-encrypted";
-        public const string TapeShort = "-t";
-        public const string TapeLong = "--tape";
-        public const string TitleKeysLong = "--title-keys";
-        public const string TrapDiscShort = "-t";
-        public const string TrapDiscLong = "--trap-disc";
-        public const string TrimLong = "--trim";
-        public const string UseBufferedReadsLong = "--use-buffered-reads";
-        public const string VerboseShort = "-v";
-        public const string VerboseLong = "--verbose";
-        public const string VerifyDiscShort = "-w";
-        public const string VerifyDiscLong = "--verify-disc";
-        public const string VerifySectorsShort = "-s";
-        public const string VerifySectorsLong = "--verify-sectors";
-        public const string VersionLong = "--version";
-        public const string WholeDiscShort = "-w";
-        public const string WholeDiscLong = "--whole-disc";
-
-        // Int8 flags
-        public const string SpeedLong = "--speed";
-
-        // Int16 flags
-        public const string RetryPassesShort = "-p";
-        public const string RetryPassesLong = "--retry-passes";
-        public const string WidthShort = "-w";
-        public const string WidthLong = "--width";
-
-        // Int32 flags
-        public const string BlockSizeShort = "-b";
-        public const string BlockSizeLong = "--block-size";
-        public const string CountShort = "-c";
-        public const string CountLong = "--count";
-        public const string MaxBlocksLong = "--max-blocks";
-        public const string MediaLastSequenceLong = "--media-lastsequence";
-        public const string MediaSequenceLong = "--media-sequence";
-        public const string SkipShort = "-k";
-        public const string SkipLong = "--skip";
-
-        // Int64 flags
-        public const string LengthShort = "-l"; // or "all"
-        public const string LengthLong = "--length"; // or "all"
-        public const string StartShort = "-s";
-        public const string StartLong = "--start";
-
-        // String flags
-        public const string CommentsLong = "--comments";
-        public const string CreatorLong = "--creator";
-        public const string DriveManufacturerLong = "--drive-manufacturer";
-        public const string DriveModelLong = "--drive-model";
-        public const string DriveRevisionLong = "--drive-revision";
-        public const string DriveSerialLong = "--drive-serial";
-        public const string EncodingShort = "-e";
-        public const string EncodingLong = "--encoding";
-        public const string FormatConvertShort = "-p";
-        public const string FormatConvertLong = "--format";
-        public const string FormatDumpShort = "-t";
-        public const string FormatDumpLong = "--format";
-        public const string GeometryShort = "-g";
-        public const string GeometryLong = "--geometry";
-        public const string ImgBurnLogShort = "-b";
-        public const string ImgBurnLogLong = "--ibg-log";
-        public const string MediaBarcodeLong = "--media-barcode";
-        public const string MediaManufacturerLong = "--media-manufacturer";
-        public const string MediaModelLong = "--media-model";
-        public const string MediaPartNumberLong = "--media-partnumber";
-        public const string MediaSerialLong = "--media-serial";
-        public const string MediaTitleLong = "--media-title";
-        public const string MHDDLogShort = "-m";
-        public const string MHDDLogLong = "--mhdd-log";
-        public const string NamespaceShort = "-n";
-        public const string NamespaceLong = "--namespace";
-        public const string OptionsShort = "-O";
-        public const string OptionsLong = "--options";
-        public const string OutputPrefixShort = "-w";
-        public const string OutputPrefixLong = "--output-prefix";
-        public const string ResumeFileShort = "-r";
-        public const string ResumeFileLong = "--resume-file";
-        public const string SubchannelLong = "--subchannel";
-        public const string XMLSidecarShort = "-x";
-        public const string XMLSidecarLong = "--cicm-xml";
-    }
-
-    /// <summary>
-    /// Supported formats for Aaru
-    /// </summary>
-    /// TODO: Use to verify format settings
-    public static class FormatStrings
-    {
-        // Supported filters
-        public const string AppleDouble = "AppleDouble";
-        public const string AppleSingle = "AppleSingle";
-        public const string BZip2 = "BZip2";
-        public const string GZip = "GZip";
-        public const string LZip = "LZip";
-        public const string MacBinary = "MacBinary";
-        public const string NoFilter = "No filter";
-        public const string PCExchange = "PCExchange";
-        public const string XZ = "XZ";
-
-        // Read-only media image formats
-        public const string AppleDiskArchivalRetrievalTool = "Apple Disk Archival/Retrieval Tool";
-        public const string AppleNewDiskImageFormat = "Apple New Disk Image Format";
-        public const string AppleNIB = "Apple NIB";
-        public const string BlindWrite4 = "BlindWrite 4";
-        public const string BlindWrite5 = "BlindWrite 5";
-        public const string CPCEMUDiskFileAndExtendedCPCDiskFile = "CPCEMU Disk-File and Extended CPC Disk-File";
-        public const string D2FDiskImage = "d2f disk image";
-        public const string D88DiskImage = "D88 Disk Image";
-        public const string DIMDiskImage = "DIM Disk Image";
-        public const string DiscFerret = "DiscFerret";
-        public const string DiscJuggler = "DiscJuggler";
-        public const string DreamcastGDIImage = "Dreamcast GDI image";
-        public const string DunfieldsIMD = "Dunfield's IMD";
-        public const string HDCopyDiskImage = "HD-Copy disk image";
-        public const string KryoFluxSTREAM = "KryoFlux STREAM";
-        public const string MAMECompressedHunksOfData = "MAME Compressed Hunks of Data";
-        public const string MicrosoftVHDX = "Microsoft VHDX";
-        public const string NeroBurningROMImage = "Nero Burning ROM image";
-        public const string PartCloneDiskImage = "PartClone disk image";
-        public const string PartimageDiskImage = "Partimage disk image";
-        public const string SpectrumFloppyDiskImage = "Spectrum Floppy Disk Image";
-        public const string SuperCardPro = "SuperCardPro";
-        public const string SydexCopyQM = "Sydex CopyQM";
-        public const string SydexTeleDisk = "Sydex TeleDisk";
-
-        // Read/write media image formats
-        public const string AaruFormat = "Aaru Format";
-        public const string ACTApricotDiskImage = "ACT Apricot Disk Image";
-        public const string Alcohol120MediaDescriptorStructure = "Alcohol 120% Media Descriptor Structure";
-        public const string Anex86DiskImage = "Anex86 Disk Image";
-        public const string Apple2InterleavedDiskImage = "Apple ][Interleaved Disk Image";
-        public const string Apple2IMG = "Apple 2IMG";
-        public const string AppleDiskCopy42 = "Apple DiskCopy 4.2";
-        public const string AppleUniversalDiskImageFormat = "Apple Universal Disk Image Format";
-        public const string BasicLisaUtility = "Basic Lisa Utility";
-        public const string CDRDAOTocfile = "CDRDAO tocfile";
-        public const string CDRWinCuesheet = "CDRWin cuesheet";
-        public const string CisCopyDiskImageDCFile = "CisCopy Disk Image(DC-File)";
-        public const string CloneCD = "CloneCD";
-        public const string CopyTape = "CopyTape";
-        public const string DigitalResearchDiskCopy = "Digital Research DiskCopy";
-        public const string IBMSaveDskF = "IBM SaveDskF";
-        public const string MAXIDiskImage = "MAXI Disk image";
-        public const string ParallelsDiskImage = "Parallels disk image";
-        public const string QEMUCopyOnWriteDiskImage = "QEMU Copy-On-Write disk image";
-        public const string QEMUCopyOnWriteDiskImageV2 = "QEMU Copy-On-Write disk image v2";
-        public const string QEMUEnhancedDiskImage = "QEMU Enhanced Disk image";
-        public const string RawDiskImage = "Raw Disk Image";
-        public const string RayAracheliansDiskIMage = "Ray Arachelian's Disk IMage";
-        public const string RSIDEHardDiskImage = "RS-IDE Hard Disk Image";
-        public const string T98HardDiskImage = "T98 Hard Disk Image";
-        public const string T98NextNHDr0DiskImage = "T98-Next NHD r0 Disk Image";
-        public const string Virtual98DiskImage = "Virtual98 Disk Image";
-        public const string VirtualBoxDiskImage = "VirtualBox Disk Image";
-        public const string VirtualPC = "VirtualPC";
-        public const string VMwareDiskImage = "VMware disk image";
-
-        // Supported filesystems for identification and information only
-        public const string AcornAdvancedDiscFilingSystem = "Acorn Advanced Disc Filing System";
-        public const string AlexanderOsipovDOSFileSystem = "Alexander Osipov DOS file system";
-        public const string AmigaDOSFilesystem = "Amiga DOS filesystem";
-        public const string AppleFileSystem = "Apple File System";
-        public const string AppleHFSPlusFilesystem = "Apple HFS+ filesystem";
-        public const string AppleHierarchicalFileSystem = "Apple Hierarchical File System";
-        public const string AppleProDOSFilesystem = "Apple ProDOS filesystem";
-        public const string AtheOSFilesystem = "AtheOS Filesystem";
-        public const string BeFilesystem = "Be Filesystem";
-        public const string BSDFastFileSystem = "BSD Fast File System(aka UNIX File System, UFS)";
-        public const string BTreeFileSystem = "B-tree file system";
-        public const string CommodoreFileSystem = "Commodore file system";
-        public const string CramFilesystem = "Cram filesystem";
-        public const string DumpEightPlugin = "dump(8) Plugin";
-        public const string ECMA67 = "ECMA-67";
-        public const string ExtentFileSystemPlugin = "Extent File System Plugin";
-        public const string F2FSPlugin = "F2FS Plugin";
-        public const string Files11OnDiskStructure = "Files-11 On-Disk Structure";
-        public const string FossilFilesystemPlugin = "Fossil Filesystem Plugin";
-        public const string HAMMERFilesystem = "HAMMER Filesystem";
-        public const string HighPerformanceOpticalFileSystem = "High Performance Optical File System";
-        public const string HPLogicalInterchangeFormatPlugin = "HP Logical Interchange Format Plugin";
-        public const string JFSPlugin = "JFS Plugin";
-        public const string LinuxExtendedFilesystem = "Linux extended Filesystem";
-        public const string LinuxExtendedFilesystem234 = "Linux extended Filesystem 2, 3 and 4";
-        public const string LocusFilesystemPlugin = "Locus Filesystem Plugin";
-        public const string MicroDOSFileSystem = "MicroDOS file system";
-        public const string MicrosoftExtendedFileAllocationTable = "Microsoft Extended File Allocation Table";
-        public const string MinixFilesystem = "Minix Filesystem";
-        public const string NewTechnologyFileSystem = "New Technology File System(NTFS)";
-        public const string NILFS2Plugin = "NILFS2 Plugin";
-        public const string NintendoOpticalFilesystems = "Nintendo optical filesystems";
-        public const string OS2HighPerformanceFileSystem = "OS/2 High Performance File System";
-        public const string OS9RandomBlockFilePlugin = "OS-9 Random Block File Plugin";
-        public const string PCEngineCDPlugin = "PC Engine CD Plugin";
-        public const string PCFXPlugin = "PC-FX Plugin";
-        public const string ProfessionalFileSystem = "Professional File System";
-        public const string QNX4Plugin = "QNX4 Plugin";
-        public const string QNX6Plugin = "QNX6 Plugin";
-        public const string ReiserFilesystemPlugin = "Reiser Filesystem Plugin";
-        public const string Reiser4FilesystemPlugin = "Reiser4 Filesystem Plugin";
-        public const string ResilientFileSystemPlugin = "Resilient File System plugin";
-        public const string RT11FileSystem = "RT-11 file system";
-        public const string SmartFileSystem = "SmartFileSystem";
-        public const string SolarOSFilesystem = "Solar_OS filesystem";
-        public const string SquashFilesystem = "Squash filesystem";
-        public const string UNICOSFilesystemPlugin = "UNICOS Filesystem Plugin";
-        public const string UniversalDiskFormat = "Universal Disk Format";
-        public const string UNIXBootFilesystem = "UNIX Boot filesystem";
-        public const string UNIXSystemVFilesystem = "UNIX System V filesystem";
-        public const string VeritasFilesystem = "Veritas filesystem";
-        public const string VMwareFilesystem = "VMware filesystem";
-        public const string XFSFilesystemPlugin = "XFS Filesystem Plugin";
-        public const string XiaFilesystem = "Xia filesystem";
-        public const string ZFSFilesystemPlugin = "ZFS Filesystem Plugin";
-
-        // Supported filesystems that can read their contents
-        public const string AppleDOSFileSystem = "Apple DOS File System";
-        public const string AppleLisaFileSystem = "Apple Lisa File System";
-        public const string AppleMacintoshFileSystem = "Apple Macintosh File System";
-        public const string CPMFileSystem = "CP/M File System";
-        public const string FATXFilesystemPlugin = "FATX Filesystem Plugin";
-        public const string ISO9660Filesystem = "ISO9660 Filesystem";
-        public const string MicrosoftFileAllocationTable = "Microsoft File Allocation Table";
-        public const string OperaFilesystemPlugin = "Opera Filesystem Plugin";
-        public const string UCSDPascalFilesystem = "U.C.S.D.Pascal filesystem";
-
-        // Supported partitioning schemes
-        public const string AcornFileCorePartitions = "Acorn FileCore partitions";
-        public const string ACTApricotPartitions = "ACT Apricot partitions";
-        public const string AmigaRigidDiskBlock = "Amiga Rigid Disk Block";
-        public const string ApplePartitionMap = "Apple Partition Map";
-        public const string AtariPartitions = "Atari partitions";
-        public const string BSDDisklabel = "BSD disklabel";
-        public const string DECDisklabel = "DEC disklabel";
-        public const string DragonFlyBSD64bitDisklabel = "DragonFly BSD 64-bit disklabel";
-        public const string GUIDPartitionTable = "GUID Partition Table";
-        public const string Human68kPartitions = "Human 68k partitions";
-        public const string MasterBootRecord = "Master Boot Record";
-        public const string NECPC9800PartitionTable = "NEC PC-9800 partition table";
-        public const string NeXTDisklabel = "NeXT Disklabel";
-        public const string Plan9PartitionTable = "Plan9 partition table";
-        public const string RioKarmaPartitioning = "Rio Karma partitioning";
-        public const string SGIDiskVolumeHeader = "SGI Disk Volume Header";
-        public const string SunDisklabel = "Sun Disklabel";
-        public const string UNIXHardwired = "UNIX hardwired";
-        public const string UNIXVTOC = "UNIX VTOC";
-        public const string XboxPartitioning = "Xbox partitioning";
-        public const string XENIX = "XENIX";
-    }
-
-    /// <summary>
-    /// Supported namespaces for Aaru
-    /// </summary>
-    /// TODO: Use to verify namespace settings
-    public static class NamespaceStrings
-    {
-        // Namespaces for Apple Lisa File System
-        public const string LisaOfficeSystem = "office";
-        public const string LisaPascalWorkshop = "workshop"; // Default
-
-        // Namespaces for ISO9660 Filesystem
-        public const string JolietVolumeDescriptor = "joliet"; // Default
-        public const string PrimaryVolumeDescriptor = "normal";
-        public const string PrimaryVolumeDescriptorwithEncoding = "romeo";
-        public const string RockRidge = "rrip";
-        public const string PrimaryVolumeDescriptorVersionSuffix = "vms";
-
-        // Namespaces for Microsoft File Allocation Table
-        public const string DOS83UpperCase = "dos";
-        public const string LFNWhenAvailableWithFallback = "ecs"; // Default
-        public const string LongFileNames = "lfn";
-        public const string WindowsNT83MixedCase = "nt";
-        public const string OS2Extended = "os2";
-    }
-
-    /// <summary>
-    /// Supported options for Aaru
-    /// </summary>
-    /// TODO: Use to verify option settings
-    public static class OptionStrings
-    {
-        // Aaru format
-        public const string AaruCompress = "compress"; // boolean, default true;
-        public const string AaruDeduplicate = "deduplicate"; // boolean, default true
-        public const string AaruDictionary = "dictionary"; // number, default 33554432
-        public const string AaruMaxDDTSize = "max_ddt_size"; // number, default 256
-        public const string AaruMD5 = "md5"; // boolean, default false
-        public const string AaruSectorsPerBlock = "sectors_per_block"; // number, default 4096 [power of 2]
-        public const string AaruSHA1 = "sha1"; // boolean, default false
-        public const string AaruSHA256 = "sha256"; // boolean, default false
-        public const string AaruSpamSum = "spamsum"; // boolean, default false
-
-        // ACT Apricot Disk Image
-        public const string ACTApricotDiskImageCompress = "compress"; // boolean, default false
-
-        // Apple DiskCopy 4.2
-        public const string AppleDiskCopyMacOSX = "macosx"; // boolean, default false
-
-        // CDRDAO tocfile
-        public const string CDRDAOTocfileSeparate = "separate"; // boolean, default false
-
-        // CDRWin cuesheet
-        public const string CDRWinCuesheetSeparate = "separate"; // boolean, default false
-
-        // ISO9660 Filesystem
-        public const string ISO9660FSUseEvd = "use_evd"; // boolean, default false
-        public const string ISO9660FSUsePathTable = "use_path_table"; // boolean, default false
-        public const string ISO9660FSUseTransTbl = "use_trans_tbl"; // boolean, default false
-
-        // VMware disk image
-        public const string VMwareDiskImageAdapterType = "adapter_type"; // string, default ide [ide, lsilogic, buslogic, legacyESX]
-        public const string VMwareDiskImageHWVersion = "hwversion"; // number, default 4
-        public const string VMwareDiskImageSparse = "sparse"; // boolean, default false
-        public const string VMwareDiskImageSplit = "split"; // boolean, default false
-    }
-}

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,374 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using MPF.Core.Converters;
-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, Options options, string basePath, Drive drive, bool includeArtifacts)
-        {
-            // TODO: Determine if there's a CleanRip version anywhere
-            info.DumpingInfo.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
-            Datafile datafile = GenerateCleanripDatafile(basePath + ".iso", basePath + "-dumpinfo.txt");
-            
-            // Get the individual hash data, as per internal
-            if (GetISOHashValues(datafile, 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, out string gcName))
-                    {
-                        info.CommonDiscInfo.Region = gcRegion ?? info.CommonDiscInfo.Region;
-                        info.VersionAndEditions.Version = gcVersion ?? info.VersionAndEditions.Version;
-                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalName] = gcName ?? string.Empty;
-                    }
-
-                    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 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 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 new Datafile
-                    {
-                        Games = new Game[]
-                        {
-                            new Game
-                            {
-                                Roms = new Rom[]
-                                {
-                                    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
-            {
-                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>
-        /// <param name="name">Output internal name of the game</param>
-        /// <returns></returns>
-        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string version, out string name)
-        {
-            region = null; version = null; name = 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("Version: ".Length);
-                        }
-                        else if (line.StartsWith("Internal Name"))
-                        {
-                            name = line.Substring("Internal Name: ".Length);
-                        }
-                        else if (line.StartsWith("Filename"))
-                        {
-                            string serial = line.Substring("Filename: ".Length);
-
-                            // 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
-    }
-}