Bump version

* Prefer PlayStation info from Redumper logs

* Restrict parsing PS data to info field

* Typo

* Readd version field

.github/workflows/build_check.yml

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

.github/workflows/build_ui.yml

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

.github/workflows/check_pr.yml

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

CHANGELIST.md

@@ -1,3 +1,134 @@
+### 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

MPF.Check/MPF.Check.csproj

@@ -6,11 +6,12 @@
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
     <OutputType>Exe</OutputType>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <VersionPrefix>3.1.1</VersionPrefix>
+    <VersionPrefix>3.1.9</VersionPrefix>
 
     <!-- Package Properties -->
     <Title>MPF Check</Title>
@@ -31,10 +32,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.0.2" GeneratePathProperty="true">
+    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.12" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.8" />
   </ItemGroup>
   
   <ItemGroup>

MPF.Check/Program.cs

@@ -99,6 +99,7 @@ namespace MPF.Check
             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");

MPF.Core/Converters/EnumConverter.cs

@@ -101,7 +101,9 @@ namespace MPF.Core.Converters
 
                 InternalProgram.CleanRip => "CleanRip",
                 InternalProgram.DCDumper => "DCDumper",
+                InternalProgram.PS3CFW => "PS3 CFW",
                 InternalProgram.UmdImageCreator => "UmdImageCreator",
+                InternalProgram.XboxBackupCreator => "XboxBackupCreator",
 
                 #endregion
 
@@ -110,7 +112,44 @@ namespace MPF.Core.Converters
             };
         }
 
-#endregion
+        /// <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
 
@@ -141,10 +180,20 @@ namespace MPF.Core.Converters
                 "dc"
                     or "dcd"
                     or "dcdumper" => InternalProgram.DCDumper,
+                "ps3cfw"
+                    or "ps3"
+                    or "getkey"
+                    or "managunz"
+                    or "multiman" => InternalProgram.PS3CFW,
                 "uic"
                     or "umd"
                     or "umdcreator"
                     or "umdimagecreator" => InternalProgram.UmdImageCreator,
+                "xbc"
+                    or "xbox"
+                    or "xbox360"
+                    or "xboxcreator"
+                    or "xboxbackupcreator" => InternalProgram.XboxBackupCreator,
 
                 _ => InternalProgram.NONE,
             };
@@ -293,6 +342,56 @@ namespace MPF.Core.Converters
             };
         }
 
+        /// <summary>
+        /// Get the RedumperReadMethod enum value for a given string
+        /// </summary>
+        /// <param name="method">String value to convert</param>
+        /// <returns>RedumperReadMethod represented by the string, if possible</returns>
+        public static RedumperReadMethod ToRedumperReadMethod(string? method)
+        {
+            return (method?.ToLowerInvariant()) switch
+            {
+                "d8" => RedumperReadMethod.D8,
+                "be" => RedumperReadMethod.BE,
+                "be_cdda"
+                    or "be cdda"
+                    or "be-cdda"
+                    or "becdda" => RedumperReadMethod.BE_CDDA,
+
+                _ => RedumperReadMethod.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperSectorOrder enum value for a given string
+        /// </summary>
+        /// <param name="order">String value to convert</param>
+        /// <returns>RedumperSectorOrder represented by the string, if possible</returns>
+        public static RedumperSectorOrder ToRedumperSectorOrder(string? order)
+        {
+            return (order?.ToLowerInvariant()) switch
+            {
+                "data_c2_sub"
+                    or "data c2 sub"
+                    or "data-c2-sub"
+                    or "datac2sub" => RedumperSectorOrder.DATA_C2_SUB,
+                "data_sub_c2"
+                    or "data sub c2"
+                    or "data-sub-c2"
+                    or "datasubc2" => RedumperSectorOrder.DATA_SUB_C2,
+                "data_sub"
+                    or "data sub"
+                    or "data-sub"
+                    or "datasub" => RedumperSectorOrder.DATA_SUB,
+                "data_c2"
+                    or "data c2"
+                    or "data-c2"
+                    or "datac2" => RedumperSectorOrder.DATA_C2,
+
+                _ => RedumperSectorOrder.NONE,
+            };
+        }
+
         #endregion
     }
 }

MPF.Core/Data/Drive.cs

@@ -7,6 +7,7 @@ using Microsoft.Management.Infrastructure;
 using Microsoft.Management.Infrastructure.Generic;
 #endif
 using MPF.Core.Converters;
+using SabreTools.IO;
 using SabreTools.RedumpLib.Data;
 
 namespace MPF.Core.Data
@@ -291,6 +292,12 @@ namespace MPF.Core.Data
                 return RedumpSystem.funworldPhotoPlay;
             }
 
+            // Konami Python 2
+            if (Directory.Exists(Path.Combine(this.Name, "PY2.D")))
+            {
+                return RedumpSystem.KonamiPython2;
+            }
+
             #endregion
 
             #region Consoles
@@ -331,6 +338,12 @@ namespace MPF.Core.Data
                     return RedumpSystem.CommodoreAmigaCD32;
             }
 
+            // Mattel HyperScan -- TODO: May need case-insensitivity added
+            if (File.Exists(Path.Combine(this.Name, "hyper.exe")))
+            {
+                return RedumpSystem.MattelHyperScan;
+            }
+
             // Mattel Fisher-Price iXL
 #if NET20 || NET35
             if (File.Exists(Path.Combine(Path.Combine(this.Name, "iXL"), "iXLUpdater.exe")))
@@ -357,17 +370,43 @@ namespace MPF.Core.Data
             }
             catch { }
 
-            // Microsoft Xbox One
+            // Microsoft Xbox One and Series X
             try
             {
-                if (Directory.Exists(Path.Combine(this.Name, "MSXC"))
-#if NET20 || NET35
-                    && Directory.GetFiles(Path.Combine(this.Name, "MSXC")).Any())
-#else
-                    && Directory.EnumerateFiles(Path.Combine(this.Name, "MSXC")).Any())
-#endif
+                if (Directory.Exists(Path.Combine(this.Name, "MSXC")))
                 {
-                    return RedumpSystem.MicrosoftXboxOne;
+                    try
+                    {
+#if NET20 || NET35
+                        string catalogjs = Path.Combine(this.Name, Path.Combine("MSXC", Path.Combine("Metadata", "catalog.js")));
+#else
+                        string catalogjs = Path.Combine(this.Name, "MSXC", "Metadata", "catalog.js");
+#endif
+                        if (!File.Exists(catalogjs))
+                            return RedumpSystem.MicrosoftXboxOne;
+
+                        SabreTools.Models.Xbox.Catalog? catalog = SabreTools.Serialization.Deserializers.Catalog.DeserializeFile(catalogjs);
+                        if (catalog != null && catalog.Version != null && catalog.Packages != null)
+                        {
+                            if (!double.TryParse(catalog.Version, out double version))
+                                return RedumpSystem.MicrosoftXboxOne;
+
+                            if (version < 4)
+                                return RedumpSystem.MicrosoftXboxOne;
+
+                            foreach (var package in catalog.Packages)
+                            {
+                                if (package.Generation != "9")
+                                    return RedumpSystem.MicrosoftXboxOne;
+                            }
+
+                            return RedumpSystem.MicrosoftXboxSeriesXS;
+                        }
+                    }
+                    catch
+                    {
+                        return RedumpSystem.MicrosoftXboxOne;
+                    }
                 }
             }
             catch { }

MPF.Core/Data/Enumerations.cs

@@ -1,25 +1,5 @@
 namespace MPF.Core.Data
 {
-    /// <summary>
-    /// Available hashing types
-    /// </summary>
-    public enum Hash
-    {
-        CRC32,
-#if NET6_0_OR_GREATER
-        CRC64,
-#endif
-        MD5,
-        SHA1,
-        SHA256,
-        SHA384,
-        SHA512,
-#if NET6_0_OR_GREATER
-        XxHash32,
-        XxHash64,
-#endif
-    }
-
     /// <summary>
     /// Drive type for dumping
     /// </summary>
@@ -46,7 +26,34 @@
         // Verification support only
         CleanRip,
         DCDumper,
+        PS3CFW,
         UmdImageCreator,
+        XboxBackupCreator,
+    }
+
+    /// <summary>
+    /// Drive read method option
+    /// </summary>
+    public enum RedumperReadMethod
+    {
+        NONE = 0,
+
+        BE,
+        D8,
+        BE_CDDA,
+    }
+
+    /// <summary>
+    /// Drive sector order option
+    /// </summary>
+    public enum RedumperSectorOrder
+    {
+        NONE = 0,
+
+        DATA_C2_SUB,
+        DATA_SUB_C2,
+        DATA_SUB,
+        DATA_C2,
     }
 
     /// <summary>

MPF.Core/Data/IniFile.cs

@@ -1,294 +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 = [];
-
-        public string this[string key]
-        {
-            get
-            {
-                _keyValuePairs ??= [];
-
-                key = key.ToLowerInvariant();
-                if (_keyValuePairs.TryGetValue(key, out string? val))
-                    return val;
-
-                return string.Empty;
-            }
-            set
-            {
-                _keyValuePairs ??= [];
-
-                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 var sr = new StreamReader(stream);
-                string section = string.Empty;
-                while (!sr.EndOfStream)
-                {
-                    var line = sr.ReadLine()?.Trim();
-
-                    // Empty lines are skipped
-                    if (string.IsNullOrEmpty(line))
-                    {
-                        // No-op, we don't process empty lines
-                    }
-
-                    // Comments start with ';'
-                    else if (line!.StartsWith(";"))
-                    {
-                        // No-op, we don't process comments
-                    }
-
-                    // Section titles are surrounded by square brackets
-                    else if (line.StartsWith("["))
-                    {
-                        section = line.TrimStart('[').TrimEnd(']');
-                    }
-
-                    // Valid INI lines are in the format key=value
-                    else if (line.Contains('='))
-                    {
-                        // Split the line by '=' for key-value pairs
-                        string[] data = line.Split('=');
-
-                        // If the value field contains an '=', we need to put them back in
-                        string key = data[0].Trim();
-                        string value = string.Join("=", data.Skip(1).ToArray()).Trim();
-
-                        // Section names are prepended to the key with a '.' separating
-                        if (!string.IsNullOrEmpty(section))
-                            key = $"{section}.{key}";
-
-                        // Set or overwrite keys in the returned dictionary
-                        _keyValuePairs[key.ToLowerInvariant()] = value;
-                    }
-
-                    // All other lines are ignored
-                }
-            }
-            catch
-            {
-                // 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
-            {
-                // Order the dictionary by keys to link sections together
-                using var sw = new StreamWriter(stream);
-                var orderedKeyValuePairs = _keyValuePairs.OrderBy(kvp => kvp.Key);
-
-                string section = string.Empty;
-                foreach (var keyValuePair in orderedKeyValuePairs)
-                {
-                    // 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).ToArray()).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)
-        {
-            bool result = ((IDictionary<string, string>)_keyValuePairs).TryGetValue(key.ToLowerInvariant(), out var temp);
-            value = temp ?? string.Empty;
-            return result;
-        }
-
-        public void Add(KeyValuePair<string, string> item)
-        {
-            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

@@ -316,6 +316,15 @@ namespace MPF.Core.Data
             set { Settings["RedumperEnableDebug"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Enable Redumper custom lead-in retries for Plextor drives
+        /// </summary>
+        public bool RedumperEnableLeadinRetry
+        {
+            get { return GetBooleanSetting(Settings, "RedumperEnableLeadinRetry", false); }
+            set { Settings["RedumperEnableLeadinRetry"] = value.ToString(); }
+        }
+
         /// <summary>
         /// Enable verbose output while dumping by default
         /// </summary>
@@ -326,12 +335,21 @@ namespace MPF.Core.Data
         }
 
         /// <summary>
-        /// Enable BE reading by default with Redumper
+        /// Default number of redumper Plextor leadin retries
         /// </summary>
-        public bool RedumperUseBEReading
+        public int RedumperLeadinRetryCount
         {
-            get { return GetBooleanSetting(Settings, "RedumperUseBEReading", false); }
-            set { Settings["RedumperUseBEReading"] = value.ToString(); }
+            get { return GetInt32Setting(Settings, "RedumperLeadinRetryCount", 4); }
+            set { Settings["RedumperLeadinRetryCount"] = 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>
@@ -343,6 +361,38 @@ namespace MPF.Core.Data
             set { Settings["RedumperUseGenericDriveType"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Currently selected default redumper read method
+        /// </summary>
+        public RedumperReadMethod RedumperReadMethod
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "RedumperReadMethod", RedumperReadMethod.NONE.ToString());
+                return EnumConverter.ToRedumperReadMethod(valueString);
+            }
+            set
+            {
+                Settings["RedumperReadMethod"] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper sector order
+        /// </summary>
+        public RedumperSectorOrder RedumperSectorOrder
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "RedumperSectorOrder", RedumperSectorOrder.NONE.ToString());
+                return EnumConverter.ToRedumperSectorOrder(valueString);
+            }
+            set
+            {
+                Settings["RedumperSectorOrder"] = value.ToString();
+            }
+        }
+
         /// <summary>
         /// Default number of rereads
         /// </summary>
@@ -500,6 +550,15 @@ namespace MPF.Core.Data
             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

MPF.Core/DumpEnvironment.cs

@@ -148,10 +148,15 @@ namespace MPF.Core
                 // Verification support only
                 InternalProgram.CleanRip => new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null },
                 InternalProgram.DCDumper => null, // TODO: Create correct parameter type when supported
+                InternalProgram.PS3CFW => new Modules.PS3CFW.Parameters(parameters) { ExecutablePath = null },
                 InternalProgram.UmdImageCreator => new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null },
+                InternalProgram.XboxBackupCreator => new Modules.XboxBackupCreator.Parameters(parameters) { ExecutablePath = null },
+
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
 
                 // This should never happen, but it needs a fallback
-                _ => new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath },
+                _ => new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath },
             };
 
             // Set system and type
@@ -183,12 +188,15 @@ namespace MPF.Core
                     InternalProgram.DiscImageCreator => new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
                     InternalProgram.Redumper => new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
 
+                    // If no dumping program found, set to null
+                    InternalProgram.NONE => null,
+
                     // This should never happen, but it needs a fallback
-                    _ => new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                    _ => new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
                 };
 
                 // Generate and return the param string
-                return Parameters.GenerateParameters();
+                return Parameters?.GenerateParameters();
             }
 
             return null;
@@ -281,6 +289,9 @@ namespace MPF.Core
             Func<SubmissionInfo?, (bool?, SubmissionInfo?)>? processUserInfo = null,
             SubmissionInfo? seedInfo = null)
         {
+            if (Parameters == null)
+                return Result.Failure("Error! Current configuration is not supported!");
+
             resultProgress?.Report(Result.Success("Gathering submission information... please wait!"));
 
             // Get the output directory and filename separately
@@ -353,9 +364,9 @@ namespace MPF.Core
             resultProgress?.Report(Result.Success("Formatting information..."));
             (var formattedValues, var formatResult) = Formatter.FormatOutputData(submissionInfo, Options.EnableRedumpCompatibility);
             if (formattedValues == null)
-                resultProgress?.Report(Result.Success(formatResult));
-            else
                 resultProgress?.Report(Result.Failure(formatResult));
+            else
+                resultProgress?.Report(Result.Success(formatResult));
 
             // Get the filename suffix for auto-generated files
             var filenameSuffix = Options.AddFilenameSuffix ? Path.GetFileNameWithoutExtension(outputFilename) : null;
@@ -415,6 +426,17 @@ namespace MPF.Core
                     resultProgress?.Report(Result.Failure(deleteResult));
             }
 
+            // Create PS3 IRD, if required
+            if (Options.CreateIRDAfterDumping && System == RedumpSystem.SonyPlayStation3 && Type == MediaType.BluRay)
+            {
+                resultProgress?.Report(Result.Success("Creating IRD... please wait!"));
+                (bool deleteSuccess, string deleteResult) = await InfoTool.WriteIRD(OutputPath, submissionInfo?.Extras?.DiscKey, submissionInfo?.Extras?.DiscID, submissionInfo?.Extras?.PIC, submissionInfo?.SizeAndChecksums?.Layerbreak, submissionInfo?.SizeAndChecksums?.CRC32);
+                if (deleteSuccess)
+                    resultProgress?.Report(Result.Success(deleteResult));
+                else
+                    resultProgress?.Report(Result.Failure(deleteResult));
+            }
+
             resultProgress?.Report(Result.Success("Submission information process complete!"));
             return Result.Success();
         }

MPF.Core/Hashing/Hasher.cs

@@ -1,350 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-#if NET6_0_OR_GREATER
-using System.IO.Hashing;
-#endif
-using System.Linq;
-using System.Security.Cryptography;
-using System.Threading.Tasks;
-using MPF.Core.Data;
-
-namespace MPF.Core.Hashing
-{
-    public sealed class Hasher : IDisposable
-    {
-        #region Properties
-
-        /// <summary>
-        /// Hash type associated with the current state
-        /// </summary>
-#if NETFRAMEWORK || NETCOREAPP3_1
-        public Hash HashType { get; private set; }
-#else
-        public Hash HashType { get; init; }
-#endif
-
-        /// <summary>
-        /// Current hash in bytes
-        /// </summary>
-        public byte[]? CurrentHashBytes
-        {
-            get
-            {
-                return (_hasher) switch
-                {
-                    HashAlgorithm ha => ha.Hash,
-                    NonCryptographicHashAlgorithm ncha => ncha.GetCurrentHash().Reverse().ToArray(),
-                    _ => null,
-                };
-            }
-        }
-
-        /// <summary>
-        /// Current hash as a string
-        /// </summary>
-        public string? CurrentHashString => ByteArrayToString(CurrentHashBytes);
-
-        #endregion
-
-        #region Private Fields
-
-        /// <summary>
-        /// Internal hasher being used for processing
-        /// </summary>
-        /// <remarks>May be either a HashAlgorithm or NonCryptographicHashAlgorithm</remarks>
-        private object? _hasher;
-
-        #endregion
-
-        #region Constructors
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="hashType">Hash type to instantiate</param>
-        public Hasher(Hash hashType)
-        {
-            this.HashType = hashType;
-            GetHasher();
-        }
-
-        /// <summary>
-        /// Generate the correct hashing class based on the hash type
-        /// </summary>
-        private void GetHasher()
-        {
-            _hasher = HashType switch
-            {
-                Hash.CRC32 => new Crc32(),
-#if NET6_0_OR_GREATER
-                Hash.CRC64 => new Crc64(),
-#endif
-                Hash.MD5 => MD5.Create(),
-                Hash.SHA1 => SHA1.Create(),
-                Hash.SHA256 => SHA256.Create(),
-                Hash.SHA384 => SHA384.Create(),
-                Hash.SHA512 => SHA512.Create(),
-#if NET6_0_OR_GREATER
-                Hash.XxHash32 => new XxHash32(),
-                Hash.XxHash64 => new XxHash64(),
-#endif
-                _ => null,
-            };
-        }
-
-        /// <inheritdoc/>
-        public void Dispose()
-        {
-            if (_hasher is IDisposable disposable)
-                disposable.Dispose();
-        }
-
-        #endregion
-
-        #region Static Hashing
-
-        /// <summary>
-        /// Get hashes from an input file path
-        /// </summary>
-        /// <param name="filename">Path to the input file</param>
-        /// <returns>True if hashing was successful, false otherwise</returns>
-        public static bool GetFileHashes(string filename, out long size, out string? crc32, out string? md5, out string? sha1)
-        {
-            // Set all initial values
-            crc32 = null; md5 = null; sha1 = null;
-
-            // Get all file hashes
-            var fileHashes = GetFileHashes(filename, out size);
-            if (fileHashes == null)
-                return false;
-
-            // Assign the file hashes and return
-            crc32 = fileHashes[Hash.CRC32];
-            md5 = fileHashes[Hash.MD5];
-            sha1 = fileHashes[Hash.SHA1];
-            return true;
-        }
-
-        /// <summary>
-        /// Get hashes from an input file path
-        /// </summary>
-        /// <param name="filename">Path to the input file</param>
-        /// <returns>Dictionary containing hashes on success, null on error</returns>
-        public static Dictionary<Hash, string?>? GetFileHashes(string filename, out long size)
-        {
-            // If the file doesn't exist, we can't do anything
-            if (!File.Exists(filename))
-            {
-                size = -1;
-                return null;
-            }
-
-            // Set the file size
-            size = new FileInfo(filename).Length;
-
-            // Open the input file
-            var input = File.OpenRead(filename);
-
-            // Return the hashes from the stream
-            return GetStreamHashes(input);
-        }
-
-        /// <summary>
-        /// Get hashes from an input Stream
-        /// </summary>
-        /// <param name="input">Stream to hash</param>
-        /// <returns>Dictionary containing hashes on success, null on error</returns>
-        public static Dictionary<Hash, string?>? GetStreamHashes(Stream input)
-        {
-            // Create the output dictionary
-            var hashDict = new Dictionary<Hash, string?>();
-
-            try
-            {
-                // Get a list of hashers to run over the buffer
-                var hashers = new Dictionary<Hash, Hasher>
-                {
-                    { Hash.CRC32, new Hasher(Hash.CRC32) },
-#if NET6_0_OR_GREATER
-                    { Hash.CRC64, new Hasher(Hash.CRC64) },
-#endif
-                    { Hash.MD5, new Hasher(Hash.MD5) },
-                    { Hash.SHA1, new Hasher(Hash.SHA1) },
-                    { Hash.SHA256, new Hasher(Hash.SHA256) },
-                    { Hash.SHA384, new Hasher(Hash.SHA384) },
-                    { Hash.SHA512, new Hasher(Hash.SHA512) },
-#if NET6_0_OR_GREATER
-                    { Hash.XxHash32, new Hasher(Hash.XxHash32) },
-                    { Hash.XxHash64, new Hasher(Hash.XxHash64) },
-#endif
-                };
-
-                // Initialize the hashing helpers
-                var loadBuffer = new ThreadLoadBuffer(input);
-                int buffersize = 3 * 1024 * 1024;
-                byte[] buffer0 = new byte[buffersize];
-                byte[] buffer1 = new byte[buffersize];
-
-                /*
-                Please note that some of the following code is adapted from
-                RomVault. This is a modified version of how RomVault does
-                threaded hashing. As such, some of the terminology and code
-                is the same, though variable names and comments may have
-                been tweaked to better fit this code base.
-                */
-
-                // Pre load the first buffer
-                long refsize = input.Length;
-                int next = refsize > buffersize ? buffersize : (int)refsize;
-                input.Read(buffer0, 0, next);
-                int current = next;
-                refsize -= next;
-                bool bufferSelect = true;
-
-                while (current > 0)
-                {
-                    // Trigger the buffer load on the second buffer
-                    next = refsize > buffersize ? buffersize : (int)refsize;
-                    if (next > 0)
-                        loadBuffer.Trigger(bufferSelect ? buffer1 : buffer0, next);
-
-                    byte[] buffer = bufferSelect ? buffer0 : buffer1;
-
-#if NET20 || NET35
-                    // Run hashers sequentially on each chunk
-                    foreach (var h in hashers)
-                    {
-                        h.Value.Process(buffer, current);
-                    }
-#else
-                    // Run hashers in parallel on each chunk
-                    Parallel.ForEach(hashers, h => h.Value.Process(buffer, current));
-#endif
-
-                    // Wait for the load buffer worker, if needed
-                    if (next > 0)
-                        loadBuffer.Wait();
-
-                    // Setup for the next hashing step
-                    current = next;
-                    refsize -= next;
-                    bufferSelect = !bufferSelect;
-                }
-
-                // Finalize all hashing helpers
-                loadBuffer.Finish();
-#if NET20 || NET35
-                foreach (var h in hashers)
-                {
-                    h.Value.Terminate();
-                }
-#else
-                Parallel.ForEach(hashers, h => h.Value.Terminate());
-#endif
-
-                // Get the results
-                hashDict[Hash.CRC32] = hashers[Hash.CRC32].CurrentHashString;
-#if NET6_0_OR_GREATER
-                hashDict[Hash.CRC64] = hashers[Hash.CRC64].CurrentHashString;
-#endif
-                hashDict[Hash.MD5] = hashers[Hash.MD5].CurrentHashString;
-                hashDict[Hash.SHA1] = hashers[Hash.SHA1].CurrentHashString;
-                hashDict[Hash.SHA256] = hashers[Hash.SHA256].CurrentHashString;
-                hashDict[Hash.SHA384] = hashers[Hash.SHA384].CurrentHashString;
-                hashDict[Hash.SHA512] = hashers[Hash.SHA512].CurrentHashString;
-#if NET6_0_OR_GREATER
-                hashDict[Hash.XxHash32] = hashers[Hash.XxHash32].CurrentHashString;
-                hashDict[Hash.XxHash64] = hashers[Hash.XxHash64].CurrentHashString;
-#endif
-
-                // Dispose of the hashers
-                loadBuffer.Dispose();
-                foreach (var hasher in hashers.Values)
-                {
-                    hasher.Dispose();
-                }
-
-                return hashDict;
-            }
-            catch (IOException)
-            {
-                return null;
-            }
-            finally
-            {
-                input.Dispose();
-            }
-        }
-
-#endregion
-
-        #region Hashing
-
-        /// <summary>
-        /// Process a buffer of some length with the internal hash algorithm
-        /// </summary>
-        public void Process(byte[] buffer, int size)
-        {
-            switch (_hasher)
-            {
-                case HashAlgorithm ha:
-                    ha.TransformBlock(buffer, 0, size, null, 0);
-                    break;
-                case NonCryptographicHashAlgorithm ncha:
-#if NET20 || NET35 || NET40
-                    byte[] bufferSpan = new byte[size];
-                    Array.Copy(buffer, bufferSpan, size);
-#else
-                    var bufferSpan = new ReadOnlySpan<byte>(buffer, 0, size);
-#endif
-                    ncha.Append(bufferSpan);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Finalize the internal hash algorigthm
-        /// </summary>
-        /// <remarks>NonCryptographicHashAlgorithm implementations do not need finalization</remarks>
-        public void Terminate()
-        {
-            byte[] emptyBuffer = [];
-            switch (_hasher)
-            {
-                case HashAlgorithm ha:
-                    ha.TransformFinalBlock(emptyBuffer, 0, 0);
-                    break;
-            }
-        }
-
-        #endregion
-
-        #region Helpers
-
-        /// <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;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Core/Hashing/OptimizedCRC.cs

@@ -1,184 +0,0 @@
-#if NETFRAMEWORK || NETCOREAPP3_1 || NET5_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
-{
-    /// <summary>
-    /// Shell class to trick older versions into using CRC-32 properly
-    /// </summary>
-    internal abstract class NonCryptographicHashAlgorithm
-    {
-#if NET20 || NET35 || NET40
-        /// <summary>
-        /// When overridden in a derived class, appends the contents of source to
-        /// the data already processed for the current hash computation.
-        /// </summary>
-        /// <param name="source">The data to process.</param>
-        public abstract void Append(byte[] source);
-#else
-        /// <summary>
-        /// When overridden in a derived class, appends the contents of source to
-        /// the data already processed for the current hash computation.
-        /// </summary>
-        /// <param name="source">The data to process.</param>
-        public abstract void Append(ReadOnlySpan<byte> source);
-#endif
-
-        /// <summary>
-        /// Gets the current computed hash value without modifying accumulated state.
-        /// </summary>
-        /// <returns>The hash value for the data already provided.</returns>
-        public abstract byte[] GetCurrentHash();
-    }
-
-    /// <remarks>
-    /// Some changes have been made to this code to make it more similar to the System.IO.Hashing implementations
-    /// </remarks>
-    internal class Crc32 : NonCryptographicHashAlgorithm, IDisposable
-    {
-        private const uint kCrcPoly = 0xEDB88320;
-        private const uint kInitial = 0xFFFFFFFF;
-        private const int CRC_NUM_TABLES = 8;
-        private static readonly uint[] Table;
-
-        static Crc32()
-        {
-            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 Crc32()
-        {
-            Init();
-        }
-
-        /// <summary>
-        /// Reset CRC
-        /// </summary>
-        public void Init()
-        {
-            UnsignedValue = kInitial;
-        }
-
-        /// <inheritdoc/>
-        public override byte[] GetCurrentHash()
-        {
-            return BitConverter.GetBytes(~UnsignedValue);
-        }
-
-        /// <inheritdoc/>
-#if NET20 || NET35 || NET40
-        public override void Append(byte[] source)
-        {
-            Update(source, 0, source.Length);
-        }
-#else
-        public override void Append(ReadOnlySpan<byte> source)
-        {
-            byte[] sourceBytes = source.ToArray();
-            Update(sourceBytes, 0, sourceBytes.Length);
-        }
-#endif
-
-        private void Update(byte[] data, int offset, int count)
-        {
-            _ = new ArraySegment<byte>(data, offset, count);     // check arguments
-            if (count == 0)
-            {
-                return;
-            }
-
-            var table = 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;
-        }
-
-        public void Dispose()
-        {
-            UnsignedValue = 0;
-        }
-    }
-}
-
-#endif

MPF.Core/Hashing/ThreadLoadBuffer.cs

@@ -1,81 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-
-//namespace Compress.ThreadReaders
-namespace MPF.Core.Hashing
-{
-    public sealed 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
-                {
-                    if (_buffer != null)
-                        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/InfoTool.cs

@@ -14,6 +14,7 @@ using MPF.Core.Modules;
 using MPF.Core.Utilities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using SabreTools.IO;
 using SabreTools.Models.PIC;
 using SabreTools.RedumpLib.Data;
 using Formatting = Newtonsoft.Json.Formatting;
@@ -168,7 +169,7 @@ namespace MPF.Core
         {
             try
             {
-                return new SabreTools.Serialization.Files.PIC().Deserialize(pic);
+                return SabreTools.Serialization.Deserializers.PIC.DeserializeFile(pic);
             }
             catch
             {
@@ -384,6 +385,11 @@ namespace MPF.Core
             return di.Units[0]?.Body?.DiscTypeIdentifier;
         }
 
+        /// <summary>
+        /// Get the EXE name from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="driveLetter">Drive letter to use to check</param>
+        /// <returns>Executable name on success, null otherwise</returns>
         internal static string? GetPlayStationExecutableName(char? driveLetter)
         {
             // If there's no drive letter, we can't get exe name
@@ -395,6 +401,11 @@ namespace MPF.Core
             return GetPlayStationExecutableName(drivePath);
         }
 
+        /// <summary>
+        /// Get the EXE name from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="drivePath">Drive path to use to check</param>
+        /// <returns>Executable name on success, null otherwise</returns>
         internal static string? GetPlayStationExecutableName(string? drivePath)
         {
             // If there's no drive path, we can't get exe name
@@ -411,7 +422,7 @@ namespace MPF.Core
 
             // Read the CNF file as an INI file
             var systemCnf = new IniFile(systemCnfPath);
-            string bootValue = string.Empty;
+            string? bootValue = string.Empty;
 
             // PlayStation uses "BOOT" as the key
             if (systemCnf.ContainsKey("BOOT"))
@@ -451,7 +462,7 @@ namespace MPF.Core
         /// <param name="serial">Internal disc serial, if possible</param>
         /// <param name="region">Output region, if possible</param>
         /// <param name="date">Output EXE date in "yyyy-mm-dd" format if possible, null on error</param>
-        /// <returns></returns>
+        /// <returns>True if information could be determined, false otherwise</returns>
         internal static bool GetPlayStationExecutableInfo(char? driveLetter, out string? serial, out Region? region, out string? date)
         {
             serial = null; region = null; date = null;
@@ -472,7 +483,7 @@ namespace MPF.Core
         /// <param name="serial">Internal disc serial, if possible</param>
         /// <param name="region">Output region, if possible</param>
         /// <param name="date">Output EXE date in "yyyy-mm-dd" format if possible, null on error</param>
-        /// <returns></returns>
+        /// <returns>True if information could be determined, false otherwise</returns>
         internal static bool GetPlayStationExecutableInfo(string? drivePath, out string? serial, out Region? region, out string? date)
         {
             serial = null; region = null; date = null;
@@ -1003,7 +1014,7 @@ namespace MPF.Core
             }
         }
 
-#endregion
+        #endregion
 
         #region Category Extraction
 
@@ -1495,6 +1506,61 @@ namespace MPF.Core
             return files;
         }
 
+        /// <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>
+        public 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 = Tools.ParseHexKey(discKeyString);
+                if (discKey == null)
+                    return (false, "Failed to create IRD: No key provided");
+
+                // Parse Disc ID from submission info (Optional)
+                byte[]? discID = Tools.ParseDiscID(discIDString);
+
+                // Parse PIC from submission info (Optional)
+                byte[]? pic = Tools.ParsePIC(picString);
+
+                // Parse CRC32 strings into ISO hash for Unique ID field (Optional)
+                uint? uid = Tools.ParseCRC32(crc32);
+
+                // Ensure layerbreak value is valid (Optional)
+                layerbreak = Tools.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
 
         #region Normalization
@@ -1877,14 +1943,29 @@ namespace MPF.Core
             for (int i = 1; i < splitTitle.Length; i++)
             {
                 string segment = splitTitle[i];
-                if (segment.EndsWith(":") || segment.EndsWith("-"))
+                if (!itemInserted && segment == ":")
                 {
                     itemInserted = true;
-                    newTitleBuilder.Append($"{segment}, {firstItem}");
+                    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} ");
+                    newTitleBuilder.Append($" {segment}");
                 }
             }
 

MPF.Core/MPF.Core.csproj

@@ -5,11 +5,12 @@
     <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <VersionPrefix>3.1.1</VersionPrefix>
+    <VersionPrefix>3.1.9</VersionPrefix>
 
     <!-- Package Properties -->
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
@@ -45,23 +46,18 @@
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
-    <PackageReference Include="System.IO.Hashing" Version="8.0.0" />
-  </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.0.2" GeneratePathProperty="true">
+    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.12" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="LibIRD" Version="0.9.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="psxt001z.Library" Version="0.21.0-beta3" />
-    <PackageReference Include="SabreTools.Models" Version="1.3.0" />
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
-    <PackageReference Include="SabreTools.Serialization" Version="1.3.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`))">
-    <PackageReference Include="LibIRD" Version="0.6.0" />
+    <PackageReference Include="psxt001z.Library" Version="0.21.0-rc1" />
+    <PackageReference Include="SabreTools.Hashing" Version="1.2.0" />
+    <PackageReference Include="SabreTools.Models" Version="1.4.8" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.8" />
+    <PackageReference Include="SabreTools.Serialization" Version="1.6.5" />
   </ItemGroup>
 
 </Project>

MPF.Core/Modules/Aaru/Parameters.cs

@@ -2486,7 +2486,7 @@ namespace MPF.Core.Modules.Aaru
             cueSheet.Files = [.. cueFiles];
             if (cueSheet != null && cueSheet != default)
             {
-                var ms = new SabreTools.Serialization.Streams.CueSheet().Serialize(cueSheet);
+                var ms = SabreTools.Serialization.Serializers.CueSheet.SerializeStream(cueSheet);
                 if (ms == null)
                     return null;
 

MPF.Core/Modules/BaseParameters.cs

@@ -994,11 +994,9 @@ namespace MPF.Core.Modules
                 if (!IsFlagSupported(longFlagString))
                     return null;
 
-                string[] commandParts = parts[i].Split('=');
-                if (commandParts.Length != 2)
-                    return null;
+                int loc = parts[i].IndexOf('=');
 
-                string valuePart = commandParts[1];
+                string valuePart = parts[i].Substring(loc + 1);
 
                 this[longFlagString] = true;
                 return valuePart.Trim('"');
@@ -1200,6 +1198,8 @@ namespace MPF.Core.Modules
                 if (trimLength > -1)
                     hex = hex.Substring(0, trimLength);
 
+                // TODO: Check for non-zero values in discarded PIC
+
                 return Regex.Replace(hex, ".{32}", "$0\n", RegexOptions.Compiled);
             }
             catch
@@ -1209,6 +1209,60 @@ namespace MPF.Core.Modules
             }
         }
 
+        /// <summary>
+        /// Get a isobuster-formatted PVD from a 2048 byte-per-sector image, if possible
+        /// </summary>
+        /// <param name="isoPath">Path to ISO file</param>
+        /// <param name="pvd">Formatted PVD string, otherwise null</param>
+        /// <returns>True if PVD was successfully parsed, otherwise false</returns>
+        protected static bool GetPVD(string isoPath, out string? pvd)
+        {
+            pvd = null;
+            try
+            {
+                // Get PVD bytes from ISO file
+                var buf = new byte[96];
+                using (FileStream iso = File.OpenRead(isoPath))
+                {
+                    // TODO: Don't hardcode 0x8320
+                    iso.Seek(0x8320, SeekOrigin.Begin);
+
+                    int offset = 0;
+                    while (offset < 96)
+                    {
+                        int read = iso.Read(buf, offset, buf.Length - offset);
+                        if (read == 0)
+                            throw new EndOfStreamException();
+                        offset += read;
+                    }
+                }
+
+                // Format PVD to isobuster standard
+                char[] pvdCharArray = new char[96];
+                for (int i = 0; i < 96; i++)
+                {
+                    if (buf[i] >= 0x20 && buf[i] <= 0x7E)
+                        pvdCharArray[i] = (char)buf[i];
+                    else
+                        pvdCharArray[i] = '.';
+                }
+                string pvdASCII = new string(pvdCharArray, 0, 96);
+                pvd = string.Empty;
+                for (int i = 0; i < 96; i += 16)
+                {
+                    pvd += $"{(0x0320 + i):X4} : {buf[i]:X2} {buf[i + 1]:X2} {buf[i + 2]:X2} {buf[i + 3]:X2} {buf[i + 4]:X2} {buf[i + 5]:X2} {buf[i + 6]:X2} {buf[i + 7]:X2}  " +
+                        $"{buf[i + 8]:X2} {buf[i + 9]:X2} {buf[i + 10]:X2} {buf[i + 11]:X2} {buf[i + 12]:X2} {buf[i + 13]:X2} {buf[i + 14]:X2} {buf[i + 15]:X2}   {pvdASCII.Substring(i, 16)}\n";
+                }
+
+                return true;
+            }
+            catch
+            {
+                // We don't care what the error is
+                return false;
+            }
+        }
+
         #endregion
     }
 }

MPF.Core/Modules/CleanRip/Parameters.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Text.RegularExpressions;
 using MPF.Core.Converters;
 using MPF.Core.Data;
+using SabreTools.Hashing;
 using SabreTools.RedumpLib;
 using SabreTools.RedumpLib.Data;
 
@@ -71,8 +72,6 @@ namespace MPF.Core.Modules.CleanRip
 
             // Get the Datafile information
             var datafile = GenerateCleanripDatafile(basePath + ".iso", basePath + "-dumpinfo.txt");
-
-            // Fill in the hash data
             info.TracksAndWriteOffsets!.ClrMameProData = InfoTool.GenerateDatfile(datafile);
 
             // Get the individual hash data, as per internal
@@ -182,6 +181,17 @@ namespace MPF.Core.Modules.CleanRip
                         sha1 = line.Substring(7);
                 }
 
+                // Ensure all checksums were found in log
+                if (crc == string.Empty || md5 == string.Empty || sha1 == string.Empty)
+                {
+                    if (HashTool.GetStandardHashes(iso, out long isoSize, out string? isoCRC, out string? isoMD5, out string? isoSHA1))
+                    {
+                        crc = isoCRC ?? crc;
+                        md5 = isoMD5 ?? md5;
+                        sha1 = isoSHA1 ?? sha1;
+                    }
+                }
+
                 return new Datafile
                 {
                     Games =

MPF.Core/Modules/DiscImageCreator/Parameters.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text.RegularExpressions;
 using MPF.Core.Converters;
 using MPF.Core.Data;
+using MPF.Core.Utilities;
 using SabreTools.RedumpLib;
 using SabreTools.RedumpLib.Data;
 
@@ -497,6 +498,8 @@ namespace MPF.Core.Modules.DiscImageCreator
                         int trimLength = -1;
                         switch (this.System)
                         {
+                            case RedumpSystem.MicrosoftXboxOne:
+                            case RedumpSystem.MicrosoftXboxSeriesXS:
                             case RedumpSystem.SonyPlayStation3:
                             case RedumpSystem.SonyPlayStation4:
                             case RedumpSystem.SonyPlayStation5:
@@ -558,9 +561,9 @@ namespace MPF.Core.Modules.DiscImageCreator
 
                     string xmidString;
                     if (string.IsNullOrEmpty(outputDirectory))
-                        xmidString = GetXGD1XMID($"{basePath}_DMI.bin");
+                        xmidString = Tools.GetXGD1XMID($"{basePath}_DMI.bin");
                     else
-                        xmidString = GetXGD1XMID(Path.Combine(outputDirectory, $"{basePath}_DMI.bin"));
+                        xmidString = Tools.GetXGD1XMID(Path.Combine(outputDirectory, $"{basePath}_DMI.bin"));
 
                     var xmid = SabreTools.Serialization.Wrappers.XMID.Create(xmidString);
                     if (xmid != null)
@@ -607,9 +610,9 @@ namespace MPF.Core.Modules.DiscImageCreator
                 case RedumpSystem.MicrosoftXbox360:
                     string xemidString;
                     if (string.IsNullOrEmpty(outputDirectory))
-                        xemidString = GetXGD23XeMID($"{basePath}_DMI.bin");
+                        xemidString = Tools.GetXGD23XeMID($"{basePath}_DMI.bin");
                     else
-                        xemidString = GetXGD23XeMID(Path.Combine(outputDirectory, $"{basePath}_DMI.bin"));
+                        xemidString = Tools.GetXGD23XeMID(Path.Combine(outputDirectory, $"{basePath}_DMI.bin"));
 
                     var xemid = SabreTools.Serialization.Wrappers.XeMID.Create(xemidString);
                     if (xemid != null)
@@ -3884,50 +3887,6 @@ namespace MPF.Core.Modules.DiscImageCreator
             }
         }
 
-        /// <summary>
-        /// Get the XGD1 Master ID (XMID) information
-        /// </summary>
-        /// <param name="dmi">DMI.bin file location</param>
-        /// <returns>String representation of the XGD1 DMI information, empty string on error</returns>
-        private static string GetXGD1XMID(string dmi)
-        {
-            if (!File.Exists(dmi))
-                return string.Empty;
-
-            try
-            {
-                using var br = new BinaryReader(File.OpenRead(dmi));
-                br.BaseStream.Seek(8, SeekOrigin.Begin);
-                return new string(br.ReadChars(8));
-            }
-            catch
-            {
-                return string.Empty;
-            }
-        }
-
-        /// <summary>
-        /// Get the XGD2/3 Master ID (XeMID) information
-        /// </summary>
-        /// <param name="dmi">DMI.bin file location</param>
-        /// <returns>String representation of the XGD2/3 DMI information, empty string on error</returns>
-        private static string GetXGD23XeMID(string dmi)
-        {
-            if (!File.Exists(dmi))
-                return string.Empty;
-
-            try
-            {
-                using var br = new BinaryReader(File.OpenRead(dmi));
-                br.BaseStream.Seek(64, SeekOrigin.Begin);
-                return new string(br.ReadChars(14));
-            }
-            catch
-            {
-                return string.Empty;
-            }
-        }
-
         #endregion
     }
 }

MPF.Core/Modules/PS3CFW/Parameters.cs

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

MPF.Core/Modules/Redumper/Constants.cs

@@ -10,6 +10,7 @@ namespace MPF.Core.Modules.Redumper
         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
@@ -77,6 +78,7 @@ namespace MPF.Core.Modules.Redumper
         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.Core/Modules/Redumper/Parameters.cs

@@ -231,7 +231,7 @@ namespace MPF.Core.Modules.Redumper
                             missingFiles.Add($"{basePath}.dat");
                         if (!File.Exists($"{basePath}.manufacturer") && !File.Exists($"{basePath}.1.manufacturer") && !File.Exists($"{basePath}.2.manufacturer"))
                             missingFiles.Add($"{basePath}.manufacturer");
-                        if (!File.Exists($"{basePath}.physical") && !File.Exists($"{basePath}.1.physical") && !File.Exists($"{basePath}.2.physical"))
+                        if (!File.Exists($"{basePath}.physical") && !File.Exists($"{basePath}.0.physical") && !File.Exists($"{basePath}.1.physical") && !File.Exists($"{basePath}.2.physical"))
                             missingFiles.Add($"{basePath}.physical");
                         if (!File.Exists($"{basePath}.state"))
                             missingFiles.Add($"{basePath}.state");
@@ -256,7 +256,7 @@ namespace MPF.Core.Modules.Redumper
                             missingFiles.Add($"{basePath}.log");
                         else if (GetDatfile($"{basePath}.log") == null)
                             missingFiles.Add($"{basePath}.dat");
-                        if (!File.Exists($"{basePath}.physical") && !File.Exists($"{basePath}.1.physical") && !File.Exists($"{basePath}.2.physical"))
+                        if (!File.Exists($"{basePath}.physical") && !File.Exists($"{basePath}.0.physical") && !File.Exists($"{basePath}.1.physical") && !File.Exists($"{basePath}.2.physical"))
                             missingFiles.Add($"{basePath}.physical");
                         if (!File.Exists($"{basePath}.state"))
                             missingFiles.Add($"{basePath}.state");
@@ -320,8 +320,11 @@ namespace MPF.Core.Modules.Redumper
                     info.TracksAndWriteOffsets.OtherWriteOffsets = cdWriteOffset;
 
                     // Attempt to get the error count
-                    long errorCount = GetErrorCount($"{basePath}.log");
-                    info.CommonDiscInfo.ErrorsCount = (errorCount == -1 ? "Error retrieving error count" : errorCount.ToString());
+                    if (GetErrorCount($"{basePath}.log", out long redumpErrors, out long c2Errors))
+                    {
+                        info.CommonDiscInfo.ErrorsCount = (redumpErrors == -1 ? "Error retrieving error count" : redumpErrors.ToString());
+                        info.DumpingInfo.C2ErrorsCount = (c2Errors == -1 ? "Error retrieving error count" : c2Errors.ToString());
+                    }
 
                     // Attempt to get multisession data
                     string cdMultiSessionInfo = GetMultisessionInformation($"{basePath}.log") ?? string.Empty;
@@ -373,6 +376,8 @@ namespace MPF.Core.Modules.Redumper
                         int trimLength = -1;
                         switch (this.System)
                         {
+                            case RedumpSystem.MicrosoftXboxOne:
+                            case RedumpSystem.MicrosoftXboxSeriesXS:
                             case RedumpSystem.SonyPlayStation3:
                             case RedumpSystem.SonyPlayStation4:
                             case RedumpSystem.SonyPlayStation5:
@@ -385,9 +390,14 @@ namespace MPF.Core.Modules.Redumper
                                 break;
                         }
 
-                        info.Extras!.PIC = GetPIC($"{basePath}.physical", trimLength) ?? string.Empty;
+                        info.Extras!.PIC = GetPIC($"{basePath}.physical", trimLength)
+                            ?? GetPIC($"{basePath}.0.physical", trimLength)
+                            ?? GetPIC($"{basePath}.1.physical", trimLength)
+                            ?? string.Empty;
 
-                        var di = InfoTool.GetDiscInformation($"{basePath}.physical");
+                        var di = InfoTool.GetDiscInformation($"{basePath}.physical")
+                            ?? InfoTool.GetDiscInformation($"{basePath}.0.physical")
+                            ?? InfoTool.GetDiscInformation($"{basePath}.1.physical");
                         info.SizeAndChecksums!.PICIdentifier = InfoTool.GetPICIdentifier(di);
                     }
 
@@ -413,16 +423,28 @@ namespace MPF.Core.Modules.Redumper
                     break;
 
                 case RedumpSystem.KonamiPython2:
-                    info.CommonDiscInfo!.EXEDateBuildDate = GetEXEDate($"{basePath}.log");
+                    // Get metadata from log if possible
+                    if (GetPlayStationInfo($"{basePath}.log", out string? kp2EXEDate, out string? kp2Serial, out string? kp2Version, out var _))
+                    {
+                        info.CommonDiscInfo!.EXEDateBuildDate = kp2EXEDate;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = kp2Serial ?? string.Empty;
+                        if (!string.IsNullOrEmpty(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.Region = InfoTool.GetPlayStationRegion(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]);
+                        info.VersionAndEditions!.Version = kp2Version ?? string.Empty;
+                    }
+
+                    // Get metadata from drive if not available from log
                     if (InfoTool.GetPlayStationExecutableInfo(drive?.Name, out var pythonTwoSerial, out Region? pythonTwoRegion, out var pythonTwoDate))
                     {
                         // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = pythonTwoSerial ?? string.Empty;
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? pythonTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate ??= pythonTwoDate;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = pythonTwoSerial ?? string.Empty;
+                        info.CommonDiscInfo.Region ??= pythonTwoRegion;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo.EXEDateBuildDate))
+                            info.CommonDiscInfo.EXEDateBuildDate = pythonTwoDate;
                     }
-
-                    info.VersionAndEditions!.Version = InfoTool.GetPlayStation2Version(drive?.Name) ?? string.Empty;
+                    if (string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                        info.VersionAndEditions.Version = InfoTool.GetPlayStation2Version(drive?.Name) ?? string.Empty;
                     break;
 
                 case RedumpSystem.MicrosoftXbox:
@@ -478,13 +500,24 @@ namespace MPF.Core.Modules.Redumper
                     break;
 
                 case RedumpSystem.SonyPlayStation:
-                    info.CommonDiscInfo!.EXEDateBuildDate = GetEXEDate($"{basePath}.log");
+                    // Get metadata from log if possible
+                    if (GetPlayStationInfo($"{basePath}.log", out string? psxEXEDate, out string? psxSerial, out var _, out var _))
+                    {
+                        info.CommonDiscInfo!.EXEDateBuildDate = psxEXEDate;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = psxSerial ?? string.Empty;
+                        if (!string.IsNullOrEmpty(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.Region = InfoTool.GetPlayStationRegion(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]);
+                    }
+
+                    // Get metadata from drive if not available from log
                     if (InfoTool.GetPlayStationExecutableInfo(drive?.Name, out var playstationSerial, out Region? playstationRegion, out var playstationDate))
                     {
                         // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = playstationSerial ?? string.Empty;
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate ??= playstationDate;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = playstationSerial ?? string.Empty;
+                        info.CommonDiscInfo.Region ??= playstationRegion;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo.EXEDateBuildDate))
+                            info.CommonDiscInfo.EXEDateBuildDate = playstationDate;
                     }
 
                     info.CopyProtection!.AntiModchip = GetPlayStationAntiModchipDetected($"{basePath}.log").ToYesNo();
@@ -494,34 +527,70 @@ namespace MPF.Core.Modules.Redumper
                     break;
 
                 case RedumpSystem.SonyPlayStation2:
-                    info.CommonDiscInfo!.EXEDateBuildDate = GetEXEDate($"{basePath}.log");
+                    // Get metadata from log if possible
+                    if (GetPlayStationInfo($"{basePath}.log", out string? ps2EXEDate, out string? ps2Serial, out var ps2Version, out var _))
+                    {
+                        info.CommonDiscInfo!.EXEDateBuildDate = ps2EXEDate;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = ps2Serial ?? string.Empty;
+                        if (!string.IsNullOrEmpty(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.Region = InfoTool.GetPlayStationRegion(info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName]);
+                        info.VersionAndEditions!.Version = ps2Version ?? string.Empty;
+                    }
+
+                    // Get metadata from drive if not available from log
                     if (InfoTool.GetPlayStationExecutableInfo(drive?.Name, out var playstationTwoSerial, out Region? playstationTwoRegion, out var playstationTwoDate))
                     {
                         // Ensure internal serial is pulled from local data
-                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = playstationTwoSerial ?? string.Empty;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                            info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = playstationTwoSerial ?? string.Empty;
                         info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate ??= playstationTwoDate;
+                        if (string.IsNullOrEmpty(info.CommonDiscInfo.EXEDateBuildDate))
+                            info.CommonDiscInfo.EXEDateBuildDate ??= playstationTwoDate;
                     }
-
-                    info.VersionAndEditions!.Version = InfoTool.GetPlayStation2Version(drive?.Name) ?? string.Empty;
+                    if (string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                        info.VersionAndEditions.Version = InfoTool.GetPlayStation2Version(drive?.Name) ?? string.Empty;
                     break;
 
                 case RedumpSystem.SonyPlayStation3:
-                    info.VersionAndEditions!.Version = InfoTool.GetPlayStation3Version(drive?.Name) ?? string.Empty;
-                    info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation3Serial(drive?.Name) ?? string.Empty;
-                    string? firmwareVersion = InfoTool.GetPlayStation3FirmwareVersion(drive?.Name);
+                    // Get metadata from log if possible
+                    if (GetPlayStationInfo($"{basePath}.log", out var _, out string? ps3Serial, out var ps3Version, out string? firmwareVersion))
+                    {
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = ps3Serial ?? string.Empty;
+                        info.VersionAndEditions!.Version = ps3Version ?? string.Empty;
+                    }
+
+                    // Get metadata from drive if not available from log
+                    if (string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                        info.VersionAndEditions.Version = InfoTool.GetPlayStation3Version(drive?.Name) ?? string.Empty;
+                    if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation3Serial(drive?.Name) ?? string.Empty;
+                    firmwareVersion ??= InfoTool.GetPlayStation3FirmwareVersion(drive?.Name);
                     if (firmwareVersion != null)
-                        info.CommonDiscInfo!.ContentsSpecialFields![SiteCode.Patches] = $"PS3 Firmware {firmwareVersion}";
+                        info.CommonDiscInfo.ContentsSpecialFields![SiteCode.Patches] = $"PS3 Firmware {firmwareVersion}";
                     break;
 
                 case RedumpSystem.SonyPlayStation4:
-                    info.VersionAndEditions!.Version = InfoTool.GetPlayStation4Version(drive?.Name) ?? string.Empty;
-                    info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation4Serial(drive?.Name) ?? string.Empty;
+                    if (GetPlayStationInfo($"{basePath}.log", out var _, out string? ps4Serial, out var ps4Version, out var _))
+                    {
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = ps4Serial ?? string.Empty;
+                        info.VersionAndEditions!.Version = ps4Version ?? string.Empty;
+                    }
+                    if (string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                        info.VersionAndEditions.Version = InfoTool.GetPlayStation4Version(drive?.Name) ?? string.Empty;
+                    if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation4Serial(drive?.Name) ?? string.Empty;
                     break;
 
                 case RedumpSystem.SonyPlayStation5:
-                    info.VersionAndEditions!.Version = InfoTool.GetPlayStation5Version(drive?.Name) ?? string.Empty;
-                    info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation5Serial(drive?.Name) ?? string.Empty;
+                    if (GetPlayStationInfo($"{basePath}.log", out var _, out string? ps5Serial, out var ps5Version, out var _))
+                    {
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName] = ps5Serial ?? string.Empty;
+                        info.VersionAndEditions!.Version = ps5Version ?? string.Empty;
+                    }
+                    if (string.IsNullOrEmpty(info.VersionAndEditions!.Version))
+                        info.VersionAndEditions.Version = InfoTool.GetPlayStation5Version(drive?.Name) ?? string.Empty;
+                    if (string.IsNullOrEmpty(info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.InternalSerialName]))
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalSerialName] = InfoTool.GetPlayStation5Serial(drive?.Name) ?? string.Empty;
                     break;
             }
 
@@ -549,6 +618,8 @@ namespace MPF.Core.Modules.Redumper
                     info.Artifacts["manufacturer2"] = GetBase64(GetFullFile($"{basePath}.2.manufacturer")) ?? string.Empty;
                 if (File.Exists($"{basePath}.physical"))
                     info.Artifacts["physical"] = GetBase64(GetFullFile($"{basePath}.physical")) ?? string.Empty;
+                if (File.Exists($"{basePath}.0.physical"))
+                    info.Artifacts["physical0"] = GetBase64(GetFullFile($"{basePath}.0.physical")) ?? string.Empty;
                 if (File.Exists($"{basePath}.1.physical"))
                     info.Artifacts["physical1"] = GetBase64(GetFullFile($"{basePath}.1.physical")) ?? string.Empty;
                 if (File.Exists($"{basePath}.2.physical"))
@@ -806,6 +877,10 @@ namespace MPF.Core.Modules.Redumper
             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);
@@ -874,6 +949,7 @@ namespace MPF.Core.Modules.Redumper
                     FlagStrings.DumpWriteOffset,
                     FlagStrings.DumpReadSize,
                     FlagStrings.OverreadLeadout,
+                    FlagStrings.ForceUnscrambled,
                     FlagStrings.LegacySubs,
                     FlagStrings.DisableCDText,
                 ],
@@ -918,7 +994,7 @@ namespace MPF.Core.Modules.Redumper
                         logFiles.Add($"{basePath}.toc");
 
                     // Include .hash and .skeleton for all files in cuesheet
-                    var cueSheet = new SabreTools.Serialization.Files.CueSheet().Deserialize($"{basePath}.cue");
+                    var cueSheet = SabreTools.Serialization.Deserializers.CueSheet.DeserializeFile($"{basePath}.cue");
                     string? baseDir = Path.GetDirectoryName(basePath);
                     if (cueSheet?.Files != null && baseDir != null)
                     {
@@ -958,6 +1034,8 @@ namespace MPF.Core.Modules.Redumper
                         logFiles.Add($"{basePath}.2.manufacturer");
                     if (File.Exists($"{basePath}.physical"))
                         logFiles.Add($"{basePath}.physical");
+                    if (File.Exists($"{basePath}.0.physical"))
+                        logFiles.Add($"{basePath}.0.physical");
                     if (File.Exists($"{basePath}.1.physical"))
                         logFiles.Add($"{basePath}.1.physical");
                     if (File.Exists($"{basePath}.2.physical"))
@@ -976,6 +1054,8 @@ namespace MPF.Core.Modules.Redumper
                         logFiles.Add($"{basePath}.log");
                     if (File.Exists($"{basePath}.physical"))
                         logFiles.Add($"{basePath}.physical");
+                    if (File.Exists($"{basePath}.0.physical"))
+                        logFiles.Add($"{basePath}.0.physical");
                     if (File.Exists($"{basePath}.1.physical"))
                         logFiles.Add($"{basePath}.1.physical");
                     if (File.Exists($"{basePath}.2.physical"))
@@ -998,7 +1078,9 @@ namespace MPF.Core.Modules.Redumper
                 || this.BaseCommand?.Contains(CommandStrings.DVD) == true
                 || this.BaseCommand?.Contains(CommandStrings.BluRay) == true
                 || this.BaseCommand?.Contains(CommandStrings.SACD) == true
-                || this.BaseCommand?.Contains(CommandStrings.Dump) == true;
+                || this.BaseCommand?.Contains(CommandStrings.New) == true
+                || this.BaseCommand?.Contains(CommandStrings.Dump) == true
+                || this.BaseCommand?.Contains(CommandStrings.DumpNew) == true;
         }
 
         /// <inheritdoc/>
@@ -1084,15 +1166,20 @@ namespace MPF.Core.Modules.Redumper
                 this[FlagStrings.Verbose] = options.RedumperEnableVerbose;
             if (options.RedumperEnableDebug)
                 this[FlagStrings.Debug] = options.RedumperEnableDebug;
-            if (options.RedumperUseBEReading)
+            if (options.RedumperReadMethod != RedumperReadMethod.NONE)
             {
                 this[FlagStrings.DriveReadMethod] = true;
-                DriveReadMethodValue = "BE_CDDA";
+                DriveReadMethodValue = options.RedumperReadMethod.ToString();
+            }
+            if (options.RedumperSectorOrder != RedumperSectorOrder.NONE)
+            {
+                this[FlagStrings.DriveSectorOrder] = true;
+                DriveSectorOrderValue = options.RedumperSectorOrder.ToString();
             }
             if (options.RedumperUseGenericDriveType)
             {
                 this[FlagStrings.DriveType] = true;
-                DriveTypeValue = "Generic";
+                DriveTypeValue = "GENERIC";
             }
 
             // Set the output paths
@@ -1115,6 +1202,12 @@ namespace MPF.Core.Modules.Redumper
 
             this[FlagStrings.Retries] = true;
             RetriesValue = options.RedumperRereadCount;
+
+            if (options.RedumperEnableLeadinRetry)
+            {
+                this[FlagStrings.PlextorLeadinRetries] = true;
+                PlextorLeadinRetriesValue = options.RedumperLeadinRetryCount;
+            }
         }
 
         /// <inheritdoc/>
@@ -1151,6 +1244,7 @@ namespace MPF.Core.Modules.Redumper
                     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
@@ -1360,6 +1454,9 @@ namespace MPF.Core.Modules.Redumper
                 // Overread Leadout
                 ProcessFlagParameter(parts, FlagStrings.OverreadLeadout, ref i);
 
+                // Force Unscrambled
+                ProcessFlagParameter(parts, FlagStrings.ForceUnscrambled, ref i);
+
                 // Legacy Subs
                 ProcessFlagParameter(parts, FlagStrings.LegacySubs, ref i);
 
@@ -1429,25 +1526,31 @@ namespace MPF.Core.Modules.Redumper
 
             try
             {
-                // Fast forward to the dat line
                 using var sr = File.OpenText(log);
-                while (!sr.EndOfStream && sr.ReadLine()?.TrimStart()?.StartsWith("dat:") == false) ;
-                if (sr.EndOfStream)
-                    return null;
+                string? datString = null;
 
-                // Now that we're at the relevant entries, read each line in and concatenate
-                var datString = string.Empty;
-                var line = sr.ReadLine()?.Trim();
-                while (line?.StartsWith("<rom") == true)
+                // Find all occurrences of the hash information 
+                while (!sr.EndOfStream)
                 {
-                    datString += line + "\n";
+                    // Fast forward to the dat line
+                    while (!sr.EndOfStream && sr.ReadLine()?.TrimStart()?.StartsWith("dat:") == false) ;
                     if (sr.EndOfStream)
                         break;
 
-                    line = sr.ReadLine()?.Trim();
+                    // Now that we're at the relevant entries, read each line in and concatenate
+                    datString = string.Empty;
+                    var line = sr.ReadLine()?.Trim();
+                    while (line?.StartsWith("<rom") == true)
+                    {
+                        datString += line + "\n";
+                        if (sr.EndOfStream)
+                            break;
+
+                        line = sr.ReadLine()?.Trim();
+                    }
                 }
 
-                return datString.TrimEnd('\n');
+                return datString?.TrimEnd('\n');
             }
             catch
             {
@@ -1655,86 +1758,54 @@ namespace MPF.Core.Modules.Redumper
         }
 
         /// <summary>
-        /// Get the detected error count from the input files, if possible
+        /// Get the detected error counts from the input files, if possible
         /// </summary>
         /// <param name="log">Log file location</param>
-        /// <returns>Error count if possible, -1 on error</returns>
-        public static long GetErrorCount(string log)
+        /// <returns>True if error counts could be retrieved, false otherwise</returns>
+        public static bool GetErrorCount(string log, out long redumpErrors, out long c2Errors)
         {
+            // Set the default values for error counts
+            redumpErrors = -1; c2Errors = -1;
+
             // If the file doesn't exist, we can't get info from it
             if (!File.Exists(log))
-                return -1;
+                return false;
 
             try
             {
-                // Fast forward to the errors lines
                 using var sr = File.OpenText(log);
-                while (!sr.EndOfStream && sr.ReadLine()?.Trim()?.StartsWith("CD-ROM [") == false) ;
-                if (sr.EndOfStream)
-                    return 0;
 
-                // Now that we're at the relevant lines, find the error count
+                // Find the error counts
                 while (!sr.EndOfStream)
                 {
-                    // Skip forward to the "REDUMP.ORG" line
-                    var line = string.Empty;
-                    while (!sr.EndOfStream && (line = sr.ReadLine()?.Trim())?.StartsWith("REDUMP.ORG errors") == false) ;
-                    if (string.IsNullOrEmpty(line))
+                    var line = sr.ReadLine()?.Trim();
+                    if (line == null)
                         break;
 
-                    // REDUMP.ORG errors: <error count>
-                    string[] parts = line!.Split(' ');
-                    if (long.TryParse(parts[2], out long redump))
-                        return redump;
-                    else
-                        return -1;
-                }
-
-                return -1;
-            }
-            catch
-            {
-                // We don't care what the exception is right now
-                return -1;
-            }
-        }
-
-        /// <summary>
-        /// Get the EXE Date from the log, if possible
-        /// </summary>
-        /// <param name="log">Log file location</param>
-        /// <returns>EXE date if possible, null otherwise</returns>
-        public static string? GetEXEDate(string log)
-        {
-            // If the file doesn't exist, we can't get the info
-            if (!File.Exists(log))
-                return null;
-
-            try
-            {
-                using var sr = File.OpenText(log);
-                var line = sr.ReadLine();
-                while (line != null)
-                {
-                    // Trim the line for later use
-                    line = line.Trim();
-
-                    // The exe date is listed in a single line
-                    if (line.StartsWith("EXE date:"))
+                    // C2: <error count>
+                    if (line.StartsWith("C2:"))
                     {
-                        // exe date: yyyy-MM-dd
-                        return line.Substring("EXE date: ".Length);
+                        string[] parts = line.Split(' ');
+                        if (!long.TryParse(parts[1], out c2Errors))
+                            c2Errors = -1;
                     }
 
-                    line = sr.ReadLine();   
+                    // REDUMP.ORG errors: <error count>
+                    else if (line.StartsWith("REDUMP.ORG errors:"))
+                    {
+                        string[] parts = line!.Split(' ');
+                        if (!long.TryParse(parts[2], out redumpErrors))
+                            redumpErrors = -1;
+                    }
                 }
 
-                return null;
+                // If the Redump error count is -1, then an issue occurred
+                return redumpErrors != -1;
             }
             catch
             {
                 // We don't care what the exception is right now
-                return null;
+                return false;
             }
         }
 
@@ -1989,6 +2060,75 @@ namespace MPF.Core.Modules.Redumper
             }
         }
 
+        /// <summary>
+        /// Get the info from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="log">Log file location</param>
+        /// <returns>True if section found, null on error</returns>
+        private static bool GetPlayStationInfo(string log, out string? exeDate, out string? serial, out string? version, out string? firmware)
+        {
+            // Set the default values
+            exeDate = null; serial = null; version = null; firmware = null;
+
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(log))
+                return false;
+
+            try
+            {
+                // Fast forward to the PS info line
+                using var sr = File.OpenText(log);
+                string? line;
+                while (!sr.EndOfStream)
+                {
+                    line = sr.ReadLine()?.TrimStart();
+                    if (line?.StartsWith("PSX [") == true ||
+                        line?.StartsWith("PS2 [") == true ||
+                        line?.StartsWith("PS3 [") == true ||
+                        line?.StartsWith("PS4 [") == true ||
+                        line?.StartsWith("PS5 [") == true)
+                        break;
+                }
+                if (sr.EndOfStream)
+                    return false;
+
+                while (!sr.EndOfStream)
+                {
+                    line = sr.ReadLine()?.TrimStart();
+                    if (line == null)
+                        break;
+
+                    if (line.StartsWith("EXE date:"))
+                    {
+                        exeDate = line.Substring("EXE date: ".Length).Trim();
+                    }
+                    else if (line.StartsWith("serial:"))
+                    {
+                        serial = line.Substring("serial: ".Length).Trim();
+                    }
+                    else if (line.StartsWith("version:"))
+                    {
+                        version = line.Substring("version: ".Length).Trim();
+                    }
+                    else if (line.StartsWith("firmware:"))
+                    {
+                        firmware = line.Substring("firmware: ".Length).Trim();
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+
+                return true;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
         /// <summary>
         /// Get the LibCrypt data from the input file, if possible
         /// </summary>

MPF.Core/Modules/UmdImageCreator/Parameters.cs

@@ -4,7 +4,7 @@ using System.IO;
 using System.Linq;
 using MPF.Core.Converters;
 using MPF.Core.Data;
-using MPF.Core.Hashing;
+using SabreTools.Hashing;
 using SabreTools.RedumpLib;
 using SabreTools.RedumpLib.Data;
 
@@ -72,13 +72,17 @@ namespace MPF.Core.Modules.UmdImageCreator
             info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
             info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(basePath + "_disc.txt")?.ToString("yyyy-MM-dd HH:mm:ss");
 
+            // Fill in the volume labels
+            if (GetVolumeLabels($"{basePath}_volDesc.txt", out var volLabels))
+                VolumeLabels = volLabels;
+
             // Extract info based generically on MediaType
             switch (this.Type)
             {
                 case MediaType.UMD:
                     info.Extras!.PVD = GetPVD(basePath + "_mainInfo.txt") ?? string.Empty;
 
-                    if (Hasher.GetFileHashes(basePath + ".iso", out long filesize, out var crc32, out var md5, out var sha1))
+                    if (HashTool.GetStandardHashes(basePath + ".iso", out long filesize, out var crc32, out var md5, out var sha1))
                     {
                         // Get the Datafile information
                         var datafile = new Datafile
@@ -114,16 +118,18 @@ namespace MPF.Core.Modules.UmdImageCreator
             {
                 info.Artifacts ??= [];
 
-                if (File.Exists(basePath + "_disc.txt"))
-                    info.Artifacts["disc"] = GetBase64(GetFullFile(basePath + "_disc.txt")) ?? string.Empty;
-                if (File.Exists(basePath + "_drive.txt"))
-                    info.Artifacts["drive"] = GetBase64(GetFullFile(basePath + "_drive.txt")) ?? string.Empty;
-                if (File.Exists(basePath + "_mainError.txt"))
-                    info.Artifacts["mainError"] = GetBase64(GetFullFile(basePath + "_mainError.txt")) ?? string.Empty;
-                if (File.Exists(basePath + "_mainInfo.txt"))
-                    info.Artifacts["mainInfo"] = GetBase64(GetFullFile(basePath + "_mainInfo.txt")) ?? string.Empty;
-                if (File.Exists(basePath + "_volDesc.txt"))
-                    info.Artifacts["volDesc"] = GetBase64(GetFullFile(basePath + "_volDesc.txt")) ?? string.Empty;
+                if (File.Exists($"{basePath}_disc.txt"))
+                    info.Artifacts["disc"] = GetBase64(GetFullFile($"{basePath}_disc.txt")) ?? string.Empty;
+                if (File.Exists($"{basePath}_drive.txt"))
+                    info.Artifacts["drive"] = GetBase64(GetFullFile($"{basePath}_drive.txt")) ?? string.Empty;
+                if (File.Exists($"{basePath}_mainError.txt"))
+                    info.Artifacts["mainError"] = GetBase64(GetFullFile($"{basePath}_mainError.txt")) ?? string.Empty;
+                if (File.Exists($"{basePath}_mainInfo.txt"))
+                    info.Artifacts["mainInfo"] = GetBase64(GetFullFile($"{basePath}_mainInfo.txt")) ?? string.Empty;
+                //if (File.Exists($"{basePath}_PFI.bin"))
+                //    info.Artifacts["pfi"] = Convert.ToBase64String(File.ReadAllBytes($"{basePath}_PFI.bin")) ?? string.Empty;
+                if (File.Exists($"{basePath}_volDesc.txt"))
+                    info.Artifacts["volDesc"] = GetBase64(GetFullFile($"{basePath}_volDesc.txt")) ?? string.Empty;
             }
         }
 
@@ -145,6 +151,9 @@ namespace MPF.Core.Modules.UmdImageCreator
                     if (File.Exists($"{basePath}_volDesc.txt"))
                         logFiles.Add($"{basePath}_volDesc.txt");
 
+                    if (File.Exists($"{basePath}_PFI.bin"))
+                        logFiles.Add($"{basePath}_PFI.bin");
+
                     break;
             }
 
@@ -237,6 +246,90 @@ namespace MPF.Core.Modules.UmdImageCreator
             }
         }
 
+        /// <summary>
+        /// Get all Volume Identifiers
+        /// </summary>
+        /// <param name="volDesc">_volDesc.txt file location</param>
+        /// <returns>Volume labels (by type), or null if none present</returns>
+        /// <remarks>This is a copy of the code from DiscImageCreator and has extrandous checks</remarks>
+        private static bool GetVolumeLabels(string volDesc, out Dictionary<string, List<string>> volLabels)
+        {
+            // If the file doesn't exist, can't get the volume labels
+            volLabels = [];
+            if (!File.Exists(volDesc))
+                return false;
+
+            try
+            {
+                using var sr = File.OpenText(volDesc);
+                var line = sr.ReadLine();
+
+                string volType = "UNKNOWN";
+                string label;
+                while (line != null)
+                {
+                    // Trim the line for later use
+                    line = line.Trim();
+
+                    // ISO9660 and extensions section
+                    if (line.StartsWith("Volume Descriptor Type: "))
+                    {
+                        Int32.TryParse(line.Substring("Volume Descriptor Type: ".Length), out int volTypeInt);
+                        volType = volTypeInt switch
+                        {
+                            // 0 => "Boot Record" // Should not not contain a Volume Identifier
+                            1 => "ISO", // ISO9660
+                            2 => "Joliet",
+                            // 3 => "Volume Partition Descriptor" // Should not not contain a Volume Identifier
+                            // 255 => "???" // Should not not contain a Volume Identifier
+                            _ => "UNKNOWN" // Should not contain a Volume Identifier
+                        };
+                    }
+                    // UDF section
+                    else if (line.StartsWith("Primary Volume Descriptor Number:"))
+                    {
+                        volType = "UDF";
+                    }
+                    // Identifier
+                    else if (line.StartsWith("Volume Identifier: "))
+                    {
+                        label = line.Substring("Volume Identifier: ".Length);
+
+                        // Remove leading non-printable character (unsure why DIC outputs this)
+                        if (Convert.ToUInt32(label[0]) == 0x7F || Convert.ToUInt32(label[0]) < 0x20)
+                            label = label.Substring(1);
+
+                        // Skip if label is blank
+                        if (label == null || label.Length <= 0)
+                        {
+                            volType = "UNKNOWN";
+                            line = sr.ReadLine();
+                            continue;
+                        }
+
+                        if (volLabels.ContainsKey(label))
+                            volLabels[label].Add(volType);
+                        else
+                            volLabels.Add(label, [volType]);
+
+                        // Reset volume type
+                        volType = "UNKNOWN";
+                    }
+
+                    line = sr.ReadLine();
+                }
+
+                // Return true if a volume label was found
+                return volLabels.Count > 0;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                volLabels = [];
+                return false;
+            }
+        }
+
         #endregion
     }
 }

MPF.Core/Modules/XboxBackupCreator/Parameters.cs

@@ -0,0 +1,677 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using MPF.Core.Utilities;
+using SabreTools.Hashing;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.XboxBackupCreator
+{
+    /// <summary>
+    /// Represents a generic set of Xbox Backup Creator parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.XboxBackupCreator;
+
+        #endregion
+
+        /// <inheritdoc/>
+        public Parameters(string? parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            var missingFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.DVD:
+                    if (!File.Exists($"{basePath}_logs.zip") || !preCheck)
+                    {
+                        string baseDir = Path.GetDirectoryName(basePath) + Path.DirectorySeparatorChar;
+                        string? logPath = GetLogName(baseDir);
+                        if (string.IsNullOrEmpty(logPath))
+                            missingFiles.Add($"{baseDir}Log.txt");
+                        if (!File.Exists($"{baseDir}DMI.bin"))
+                            missingFiles.Add($"{baseDir}DMI.bin");
+                        if (!File.Exists($"{baseDir}PFI.bin"))
+                            missingFiles.Add($"{baseDir}PFI.bin");
+                        if (!File.Exists($"{baseDir}SS.bin"))
+                            missingFiles.Add($"{baseDir}SS.bin");
+
+                        // Not required from XBC
+                        //if (!File.Exists($"{basePath}.dvd"))
+                        //    missingFiles.Add($"{basePath}.dvd");
+                    }
+
+                    break;
+
+                default:
+                    missingFiles.Add("Media and system combination not supported for XboxBackupCreator");
+                    break;
+            }
+
+            return (!missingFiles.Any(), missingFiles);
+        }
+
+        /// <inheritdoc/>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
+        {
+            // Ensure that required sections exist
+            info = Builder.EnsureAllSections(info);
+
+            // Get base directory
+            string baseDir = Path.GetDirectoryName(basePath) + Path.DirectorySeparatorChar;
+
+            // Get log filename
+            string? logPath = GetLogName(baseDir);
+            if (string.IsNullOrEmpty(logPath))
+                return;
+
+            // XBC dump info
+            info.DumpingInfo!.DumpingProgram = $"{EnumConverter.LongName(this.InternalProgram)} {GetVersion(logPath) ?? "Unknown Version"}";
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(logPath)?.ToString("yyyy-MM-dd HH:mm:ss");
+            info.DumpingInfo.Model = GetDrive(logPath) ?? "Unknown Drive";
+
+            // Look for read errors
+            if (GetReadErrors(logPath, out long readErrors))
+                info.CommonDiscInfo!.ErrorsCount = readErrors == -1 ? "Error retrieving error count" : readErrors.ToString();
+
+            // Extract info based generically on MediaType
+            switch (this.Type)
+            {
+                case MediaType.DVD:
+
+                    // Get Layerbreak from .dvd file if possible
+                    if (GetLayerbreak($"{basePath}.dvd", out long layerbreak))
+                        info.SizeAndChecksums!.Layerbreak = layerbreak;
+
+                    // Hash data
+                    if (HashTool.GetStandardHashes(basePath + ".iso", out long filesize, out var crc32, out var md5, out var sha1))
+                    {
+                        // Get the Datafile information
+                        var datafile = new Datafile
+                        {
+                            Games = [new Game { Roms = [new Rom { Name = string.Empty, Size = filesize.ToString(), Crc = crc32, Md5 = md5, Sha1 = sha1, }] }]
+                        };
+
+                        // Fill in the hash data
+                        info.TracksAndWriteOffsets!.ClrMameProData = InfoTool.GenerateDatfile(datafile);
+
+                        info.SizeAndChecksums!.Size = filesize;
+                        info.SizeAndChecksums.CRC32 = crc32;
+                        info.SizeAndChecksums.MD5 = md5;
+                        info.SizeAndChecksums.SHA1 = sha1;
+                    }
+
+                    switch (this.System)
+                    {
+                        case RedumpSystem.MicrosoftXbox:
+
+                            // Parse DMI.bin
+                            string xmidString = Tools.GetXGD1XMID($"{baseDir}DMI.bin");
+                            var xmid = SabreTools.Serialization.Wrappers.XMID.Create(xmidString);
+                            if (xmid != null)
+                            {
+                                info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.XMID] = xmidString?.TrimEnd('\0') ?? string.Empty;
+                                info.CommonDiscInfo.Serial = xmid.Serial ?? string.Empty;
+                                if (!options.EnableRedumpCompatibility)
+                                    info.VersionAndEditions!.Version = xmid.Version ?? string.Empty;
+
+                                info.CommonDiscInfo.Region = InfoTool.GetXGDRegion(xmid.Model.RegionIdentifier);
+                            }
+
+                            break;
+
+                        case RedumpSystem.MicrosoftXbox360:
+
+                            // Get PVD from ISO
+                            if (GetPVD(basePath + ".iso", out string? pvd))
+                                info.Extras!.PVD = pvd;
+
+                            // Parse Media ID
+                            //string? mediaID = GetMediaID(logPath);
+
+                            // Parse DMI.bin
+                            string xemidString = Tools.GetXGD23XeMID($"{baseDir}DMI.bin");
+                            var xemid = SabreTools.Serialization.Wrappers.XeMID.Create(xemidString);
+                            if (xemid != null)
+                            {
+                                info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.XeMID] = xemidString?.TrimEnd('\0') ?? string.Empty;
+                                info.CommonDiscInfo.Serial = xemid.Serial ?? string.Empty;
+                                if (!options.EnableRedumpCompatibility)
+                                    info.VersionAndEditions!.Version = xemid.Version ?? string.Empty;
+
+                                info.CommonDiscInfo.Region = InfoTool.GetXGDRegion(xemid.Model.RegionIdentifier);
+                            }
+
+                            break;
+                    }
+
+                    // Deal with SS.bin
+                    if (File.Exists($"{baseDir}SS.bin"))
+                    {
+                        // Save security sector ranges
+                        string? ranges = Tools.GetSSRanges($"{baseDir}SS.bin");
+                        if (!string.IsNullOrEmpty(ranges))
+                            info.Extras!.SecuritySectorRanges = ranges;
+
+                        // TODO: Determine SS version?
+                        //info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.SSVersion] = 
+
+                        // Recreate RawSS.bin
+                        RecreateSS(logPath!, $"{baseDir}SS.bin", $"{baseDir}RawSS.bin");
+
+                        // Run ss_sector_range to get repeatable SS hash
+                        Tools.CleanSS($"{baseDir}SS.bin", $"{baseDir}SS.bin");
+                    }
+
+                    // DMI/PFI/SS CRC32 hashes
+                    if (File.Exists($"{baseDir}DMI.bin"))
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.DMIHash] = HashTool.GetFileHash($"{baseDir}DMI.bin", HashType.CRC32)?.ToUpperInvariant() ?? string.Empty;
+                    if (File.Exists($"{baseDir}PFI.bin"))
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.PFIHash] = HashTool.GetFileHash($"{baseDir}PFI.bin", HashType.CRC32)?.ToUpperInvariant() ?? string.Empty;
+                    if (File.Exists($"{baseDir}SS.bin"))
+                        info.CommonDiscInfo!.CommentsSpecialFields![SiteCode.SSHash] = HashTool.GetFileHash($"{baseDir}SS.bin", HashType.CRC32)?.ToUpperInvariant() ?? string.Empty;
+
+                    break;
+            }
+
+            // Fill in any artifacts that exist, Base64-encoded, if we need to
+            if (includeArtifacts)
+            {
+                info.Artifacts ??= [];
+
+                if (File.Exists(logPath))
+                    info.Artifacts["log"] = GetBase64(GetFullFile(logPath!)) ?? string.Empty;
+                if (File.Exists($"{basePath}.dvd"))
+                    info.Artifacts["dvd"] = GetBase64(GetFullFile($"{basePath}.dvd")) ?? string.Empty;
+                //if (File.Exists($"{baseDir}DMI.bin"))
+                //    info.Artifacts["dmi"] = Convert.ToBase64String(File.ReadAllBytes($"{baseDir}DMI.bin")) ?? string.Empty;
+                // TODO: Include PFI artifact only if the hash doesn't match known PFI hashes
+                //if (File.Exists($"{baseDir}PFI.bin"))
+                //    info.Artifacts["pfi"] = Convert.ToBase64String(File.ReadAllBytes($"{baseDir}PFI.bin")) ?? string.Empty;
+                //if (File.Exists($"{baseDir}SS.bin"))
+                //    info.Artifacts["ss"] = Convert.ToBase64String(File.ReadAllBytes($"{baseDir}SS.bin")) ?? string.Empty;
+                //if (File.Exists($"{baseDir}RawSS.bin"))
+                //    info.Artifacts["rawss"] = Convert.ToBase64String(File.ReadAllBytes($"{baseDir}RawSS.bin")) ?? string.Empty;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetLogFilePaths(string basePath)
+        {
+            var logFiles = new List<string>();
+            string baseDir = Path.GetDirectoryName(basePath) + Path.DirectorySeparatorChar;
+            switch (this.Type)
+            {
+                case MediaType.DVD:
+                    string? logPath = GetLogName(baseDir);
+                    if (!string.IsNullOrEmpty(logPath))
+                        logFiles.Add(logPath!);
+                    if (File.Exists($"{basePath}.dvd"))
+                        logFiles.Add($"{basePath}.dvd");
+                    if (File.Exists($"{baseDir}DMI.bin"))
+                        logFiles.Add($"{baseDir}DMI.bin");
+                    if (File.Exists($"{baseDir}PFI.bin"))
+                        logFiles.Add($"{baseDir}PFI.bin");
+                    if (File.Exists($"{baseDir}SS.bin"))
+                        logFiles.Add($"{baseDir}SS.bin");
+                    if (File.Exists($"{baseDir}RawSS.bin"))
+                        logFiles.Add($"{baseDir}RawSS.bin");
+
+                    break;
+            }
+
+            return logFiles;
+        }
+
+        #endregion
+
+        #region Information Extraction Methods
+
+        /// <summary>
+        /// Determines the file path of the XBC log
+        /// </summary>
+        /// <param name="baseDir">Base directory to search in</param>
+        /// <returns>Log path if found, null otherwise</returns>
+        private static string? GetLogName(string baseDir)
+        {
+            if (IsSuccessfulLog($"{baseDir}Log.txt"))
+                return $"{baseDir}Log.txt";
+
+            // Search for a renamed log file (assume there is only one)
+            string[] files = Directory.GetFiles(baseDir, "*.txt", SearchOption.TopDirectoryOnly);
+            foreach (string file in files)
+            {
+                if (IsSuccessfulLog(file))
+                    return file;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Checks if Log file has a successful read in it
+        /// </summary>
+        /// <param name="log">Path to log file</param>
+        /// <returns>True if successful log found, false otherwise</returns>
+        private static bool IsSuccessfulLog(string log)
+        {
+            if (!File.Exists(log))
+                return false;
+
+            // Successful Example:
+            //    Read completed in 00:50:23
+            // Failed Example:
+            //    Read failed
+
+            try
+            {
+                // If Version is not found, not a valid log file
+                if (string.IsNullOrEmpty(GetVersion(log)))
+                    return false;
+
+                // Look for "   Read completed in " in log file
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine();
+                    if (line?.StartsWith("   Read completed in ") == true)
+                    {
+                        return true;
+                    }
+                }
+
+                // We couldn't find a successful dump
+                return false;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get the XBC version if possible
+        /// </summary>
+        /// <param name="log">Path to XBC log file</param>
+        /// <returns>Version if possible, null on error</returns>
+        private static string? GetVersion(string? log)
+        {
+            if (string.IsNullOrEmpty(log) || !File.Exists(log))
+                return null;
+
+            // Sample:
+            // ====================================================================
+            // Xbox Backup Creator v2.9 Build:0425 By Redline99
+            // 
+
+            try
+            {
+                // Assume version is appended after first mention of Xbox Backup Creator
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("Xbox Backup Creator ") == true)
+                        return line.Substring("Xbox Backup Creator ".Length).Trim();
+                }
+
+                // We couldn't detect the version
+                return null;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the drive model from the log
+        /// </summary>
+        /// <param name="log">Path to XBC log file</param>
+        /// <returns>Drive model if found, null otherwise</returns>
+        private static string? GetDrive(string? log)
+        {
+            if (string.IsNullOrEmpty(log) || !File.Exists(log))
+                return null;
+
+            // Example:
+            // ========================================
+            // < --Security Sector Details -->
+            // Source Drive: SH-D162D
+            // ----------------------------------------
+
+            try
+            {
+                // Parse drive model from log file
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("Source Drive: ") == true)
+                    {
+                        return line.Substring("Source Drive: ".Length).Trim();
+                    }
+                }
+
+                // We couldn't detect the drive model
+                return null;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the Layerbreak value if possible
+        /// </summary>
+        /// <param name="dvd">Path to layerbreak file</param>
+        /// <param name="layerbreak">Layerbreak value if found</param>
+        /// <returns>True if successful, otherwise false</returns>
+        /// <returns></returns>
+        private static bool GetLayerbreak(string? dvd, out long layerbreak)
+        {
+            layerbreak = 0;
+
+            if (string.IsNullOrEmpty(dvd) || !File.Exists(dvd))
+                return false;
+
+            // Example:
+            // LayerBreak=1913776
+            // track.iso
+
+            try
+            {
+                // Parse Layerbreak value from DVD file
+                using var sr = File.OpenText(dvd);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("LayerBreak=") == true)
+                    {
+                        return long.TryParse(line.Substring("LayerBreak=".Length).Trim(), out layerbreak);
+                    }
+                }
+
+                // We couldn't detect the Layerbreak
+                return false;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get the read error count if possible
+        /// </summary>
+        /// <param name="log">Path to XBC log file</param>
+        /// <param name="readErrors">Read error count if found, -1 otherwise</param>
+        /// <returns>True if sucessful, otherwise false</returns>
+        private bool GetReadErrors(string? log, out long readErrors)
+        {
+            readErrors = -1;
+
+            if (string.IsNullOrEmpty(log) || !File.Exists(log))
+                return false;
+
+            // TODO: Logic when more than one dump is in the logs
+
+            // Example: (replace [E] with drive letter)
+            // Creating SplitVid backup image [E]
+            // ...
+            //     Reading Game Partition
+            // Setting read speed to 1x
+            //     Unrecovered read error at Partition LBA: 0
+
+            // Example: (replace track with base filename)
+            // Creating Layer Break File
+            //     LayerBreak file saved as: "track.dvd"
+            //     A total of 1 sectors were zeroed out.
+
+            // Example: (for Original Xbox)
+            // A total of 65,536 sectors were zeroed out.
+            // A total of 31 sectors with read errors were recovered.
+
+            try
+            {
+                // Parse Layerbreak value from DVD file
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("Creating Layer Break File") == true)
+                    {
+                        // Read error count is two lines below
+                        line = sr.ReadLine()?.Trim();
+                        line = sr.ReadLine()?.Trim();
+                        if (line?.StartsWith("A total of ") == true && line?.EndsWith(" sectors were zeroed out.") == true)
+                        {
+                            string? errorCount = line.Substring("A total of ".Length, line.Length - 36).Replace(",", "").Trim();
+                            bool success = long.TryParse(errorCount, out readErrors);
+
+                            // Original Xbox should have 65536 read errors when dumping with XBC
+                            if (this.System == RedumpSystem.MicrosoftXbox)
+                            {
+                                if (readErrors == 65536)
+                                    readErrors = 0;
+                                else if (readErrors > 65536)
+                                    readErrors -= 65536;
+                            }
+
+                            return success;
+                        }
+                    }
+                }
+
+                // We couldn't detect the read error count
+                return false;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get Xbox360 Media ID from XBC log file
+        /// </summary>
+        /// <param name="log">Path to XBC log file</param>
+        /// <returns>Media ID if Log successfully parsed, null otherwise</returns>
+        private string? GetMediaID(string? log)
+        {
+            if (string.IsNullOrEmpty(log) || !File.Exists(log))
+                return null;
+
+            if (this.System == RedumpSystem.MicrosoftXbox)
+                return null;
+
+            // Example:
+            // ----------------------------------------
+            // Media ID
+            // A76B9983D170EFF8749A892BC-8B62A812
+            // ----------------------------------------
+
+            try
+            {
+                // Parse Layerbreak value from DVD file
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("Media ID") == true)
+                    {
+                        line = sr.ReadLine()?.Trim();
+                        return line?.Substring(25).Trim();
+                    }
+                }
+
+                // We couldn't detect the Layerbreak
+                return null;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Recreate an SS.bin file from XBC log and write it to a file
+        /// </summary>
+        /// <param name="log">Path to XBC log</param>
+        /// <param name="cleanSS">Path to the clean SS file to read from</param>
+        /// <param name="rawSS">Path to the raw SS file to write to</param>
+        /// <returns>True if successful, false otherwise</returns>
+        private static bool RecreateSS(string log, string cleanSS, string rawSS)
+        {
+            if (!File.Exists(log) || !File.Exists(cleanSS))
+                return false;
+
+            byte[] ss = File.ReadAllBytes(cleanSS);
+            if (ss.Length != 2048)
+                return false;
+
+            if (!RecreateSS(log!, ss))
+                return false;
+
+            File.WriteAllBytes(rawSS, ss);
+            return true;
+        }
+
+        /// <summary>
+        /// Recreate an SS.bin byte array from an XBC log.
+        /// With help from https://github.com/hadzz/SS-Angle-Fixer/
+        /// </summary>
+        /// <param name="log">Path to XBC log</param>
+        /// <param name="ss">Byte array of SS sector</param>
+        /// <returns>True if successful, false otherwise</returns>
+        private static bool RecreateSS(string log, byte[] ss)
+        {
+            // Log file must exist
+            if (!File.Exists(log))
+                return false;
+
+            // SS must be complete sector
+            if (ss.Length != 2048)
+                return false;
+
+            // Ignore XGD1 discs
+            if (!Tools.GetXGDType(ss, out int xgdType))
+                return false;
+            if (xgdType == 0)
+                return false;
+
+            // Don't recreate an already raw SS
+            // (but do save to file, so return true)
+            if (!Tools.IsCleanSS(ss))
+                 return true;
+
+            // Example replay table:
+            /*
+            ----------------------------------------
+            RT CID MOD DATA          Drive Response
+            -- --  --  ------------- -------------------
+            01 14  00  033100 0340FF B7D8C32A B703590100    
+            03 BE  00  244530 24552F F4B9B528 BE46360500    
+            01 97  00  DBBAD0 DBCACF DD7787F4 484977ED00    
+            03 45  00  FCAF00 FCBEFF FB7A7773 AAB662FC00    
+            05 6B  00  033100 033E7F 0A31252A 0200000200    
+            07 46  00  244530 2452AF F8E77EBC 5B00005B00    
+            05 36  00  DBBAD0 DBC84F F5DFA735 B50000B500    
+            07 A1  00  FCAF00 FCBC7F 6B749DBF 0E01000E01    
+            E0 50  00  42F4E1 00B6F7 00000000 0000000000    
+            --------------------------------------------
+            */
+
+            try
+            {
+                // Parse Replay Table from log
+                using var sr = File.OpenText(log);
+                while (!sr.EndOfStream)
+                {
+                    string? line = sr.ReadLine()?.Trim();
+                    if (line?.StartsWith("RT CID MOD DATA          Drive Response") == true)
+                    {
+                        // Ignore next line
+                        line = sr.ReadLine()?.Trim();
+                        if (sr.EndOfStream)
+                            return false;
+
+                        byte[][] responses = new byte[4][];
+
+                        // Parse the nine rows from replay table
+                        for (int i = 0; i < 9; i++)
+                        {
+                            line = sr.ReadLine()?.Trim();
+                            // Validate line
+                            if (sr.EndOfStream || string.IsNullOrEmpty(line) || line!.Length < 44)
+                                return false;
+
+                            // Save useful angle responses
+                            if (i >= 4 && i <= 7)
+                            {
+                                byte[]? angles = Tools.HexStringToByteArray(line!.Substring(34, 10));
+                                if (angles == null || angles.Length != 5)
+                                    return false;
+                                responses[i - 4] = angles!;
+                            }
+                        }
+
+                        int rtOffset = 0x204;
+                        if (xgdType == 3)
+                            rtOffset = 0x24;
+
+                        // Replace angles
+                        for (int i = 0; i < 4; i++)
+                        {
+                            int offset = rtOffset + (9 * (i + 4));
+                            for (int j = 0; j < 5; j++)
+                            {
+                                // Ignore the middle byte
+                                if (j == 2)
+                                    continue;
+
+                                ss[offset + j] = responses[i][j];
+                            }
+                        }
+
+                        return true;
+                    }
+                }
+
+                // We couldn't detect the replay table
+                return false;
+            }
+            catch
+            {
+                // We don't care what the exception is right now
+                return false;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Protection.cs

@@ -296,7 +296,7 @@ namespace MPF.Core
             // SafeDisc
             if (foundProtections.Any(p => p.StartsWith("SafeDisc")))
             {
-                if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                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.StartsWith("Macrovision Protected Application"))
                         .Where(p => !p.StartsWith("Macrovision Protection File"))
@@ -307,7 +307,7 @@ namespace MPF.Core
                         .Where(p => p != "SafeDisc 1/Lite")
                         .Where(p => p != "SafeDisc 2+");
                 }
-                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)))
+                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.StartsWith("Macrovision Protected Application"))
                         .Where(p => !p.StartsWith("Macrovision Protection File"))
@@ -317,7 +317,7 @@ namespace MPF.Core
                         .Where(p => p != "SafeDisc 1/Lite")
                         .Where(p => p != "SafeDisc 2+");
                 }
-                else if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
+                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.StartsWith("Macrovision Protected Application"))
                         .Where(p => !p.StartsWith("Macrovision Protection File"))

MPF.Core/SubmissionInfoTool.cs

@@ -89,6 +89,10 @@ namespace MPF.Core
                     Version = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty,
                     OtherEditions = options.AddPlaceholders ? "(VERIFY THIS) Original" : string.Empty,
                 },
+                DumpingInfo = new DumpingInfoSection()
+                {
+                    FrontendVersion = Utilities.Tools.GetCurrentVersion(),
+                },
             };
 
             // Ensure that required sections exist
@@ -279,6 +283,12 @@ namespace MPF.Core
                     info.CopyProtection.FullProtections = fullProtections as Dictionary<string, List<string>?> ?? [];
                     resultProgress?.Report(Result.Success("Copy protection scan complete!"));
 
+                    if (system == RedumpSystem.EnhancedCD)
+                        info.CommonDiscInfo!.Category ??= DiscCategory.Audio;
+
+                    if (system == RedumpSystem.SonyElectronicBook)
+                        info.CommonDiscInfo!.Category ??= DiscCategory.Multimedia;
+
                     break;
 
                 case RedumpSystem.AudioCD:
@@ -288,68 +298,78 @@ namespace MPF.Core
                     break;
 
                 case RedumpSystem.BandaiPlaydiaQuickInteractiveSystem:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
-                    info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? Region.Japan;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= info.CommonDiscInfo.Region ?? Region.Japan;
                     break;
 
                 case RedumpSystem.BDVideo:
-                    info.CommonDiscInfo!.Category ??= DiscCategory.BonusDiscs;
-                    info.CopyProtection!.Protection = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.HDDVDVideo:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    info.CopyProtection!.Protection ??= options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
                     break;
 
                 case RedumpSystem.CommodoreAmigaCD:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.CommodoreAmigaCD32:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     info.CommonDiscInfo.Region ??= Region.Europe;
                     break;
 
                 case RedumpSystem.CommodoreAmigaCDTV:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     info.CommonDiscInfo.Region ??= Region.Europe;
                     break;
 
-                case RedumpSystem.DVDVideo:
-                    info.CommonDiscInfo!.Category ??= DiscCategory.BonusDiscs;
-                    break;
-
                 case RedumpSystem.FujitsuFMTownsseries:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
-                    info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? Region.Japan;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo.Region ??= Region.Japan;
                     break;
 
                 case RedumpSystem.FujitsuFMTownsMarty:
                     info.CommonDiscInfo!.Region ??= Region.Japan;
                     break;
 
+                case RedumpSystem.HasbroVideoNow:
+                case RedumpSystem.HasbroVideoNowColor:
+                case RedumpSystem.HasbroVideoNowJr:
+                case RedumpSystem.VideoCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
+                    break;
+
+                case RedumpSystem.HasbroVideoNowXP:
+                case RedumpSystem.PhotoCD:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Multimedia;
+                    break;
+
                 case RedumpSystem.IncredibleTechnologiesEagle:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.KonamieAmusement:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.KonamiFireBeat:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.KonamiSystemGV:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.KonamiSystem573:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.KonamiTwinkle:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.MattelHyperScan:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.MicrosoftXboxOne:
@@ -379,7 +399,7 @@ namespace MPF.Core
                     break;
 
                 case RedumpSystem.NamcoSegaNintendoTriforce:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.NavisoftNaviken21:
@@ -401,23 +421,23 @@ namespace MPF.Core
                     break;
 
                 case RedumpSystem.SegaChihiro:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SegaDreamcast:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SegaNaomi:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SegaNaomi2:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SegaTitanVideo:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SharpX68000:
@@ -425,7 +445,7 @@ namespace MPF.Core
                     break;
 
                 case RedumpSystem.SNKNeoGeoCD:
-                    info.CommonDiscInfo!.EXEDateBuildDate = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.CommonDiscInfo!.EXEDateBuildDate ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.SonyPlayStation:
@@ -448,20 +468,21 @@ namespace MPF.Core
                     break;
 
                 case RedumpSystem.SonyPlayStation2:
-                    info.CommonDiscInfo!.LanguageSelection = [LanguageSelection.BiosSettings, LanguageSelection.LanguageSelector, LanguageSelection.OptionsMenu];
+                    info.CommonDiscInfo!.LanguageSelection ??= [];
                     break;
 
                 case RedumpSystem.SonyPlayStation3:
-                    info.Extras!.DiscKey = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
-                    info.Extras.DiscID = options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.Extras!.DiscKey ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
+                    info.Extras.DiscID ??= options.AddPlaceholders ? Template.RequiredValue : string.Empty;
                     break;
 
                 case RedumpSystem.TomyKissSite:
+                    info.CommonDiscInfo!.Category ??= DiscCategory.Video;
                     info.CommonDiscInfo!.Region ??= Region.Japan;
                     break;
 
                 case RedumpSystem.ZAPiTGamesGameWaveFamilyEntertainmentSystem:
-                    info.CopyProtection!.Protection = options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
+                    info.CopyProtection!.Protection ??= options.AddPlaceholders ? Template.RequiredIfExistsValue : string.Empty;
                     break;
             }
 
@@ -724,6 +745,9 @@ namespace MPF.Core
                     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;

MPF.Core/UI/ViewModels/CheckDumpViewModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using BinaryObjectScanner;
 using MPF.Core.Data;
 using MPF.Core.UI.ComboBoxItems;
@@ -179,6 +180,20 @@ namespace MPF.Core.UI.ViewModels
         }
         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
@@ -243,6 +258,7 @@ namespace MPF.Core.UI.ViewModels
             MediaTypeComboBoxEnabled = true;
             DumpingProgramComboBoxEnabled = true;
             CheckDumpButtonEnabled = false;
+            CancelButtonEnabled = true;
 
             MediaTypes = [];
             Systems = RedumpSystemComboBoxItem.GenerateElements().ToList();
@@ -310,6 +326,38 @@ namespace MPF.Core.UI.ViewModels
 
         #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>
@@ -354,7 +402,7 @@ namespace MPF.Core.UI.ViewModels
             InternalProgram internalProgram = this.Options.InternalProgram;
 
             // Create a static list of supported Check programs, not everything
-            var internalPrograms = new List<InternalProgram> { InternalProgram.Redumper, InternalProgram.DiscImageCreator, InternalProgram.Aaru, InternalProgram.CleanRip, InternalProgram.UmdImageCreator };
+            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
@@ -398,7 +446,7 @@ namespace MPF.Core.UI.ViewModels
         /// Performs MPF.Check functionality
         /// </summary>
         /// <returns>An error message if failed, otherwise string.Empty/null</returns>
-        public string? CheckDump(Func<SubmissionInfo?, (bool?, SubmissionInfo?)> processUserInfo)
+        public async Task<string?> CheckDump(Func<SubmissionInfo?, (bool?, SubmissionInfo?)> processUserInfo)
         {
             if (string.IsNullOrEmpty(InputPath))
                 return "Invalid Input path";
@@ -406,6 +454,11 @@ namespace MPF.Core.UI.ViewModels
             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);
 
@@ -416,13 +469,12 @@ namespace MPF.Core.UI.ViewModels
             protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
 
             // Finally, attempt to do the output dance
-#if NET40
-                var resultTask = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress);
-                resultTask.Wait();
-                var result = resultTask.Result;
-#else
-            var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress, processUserInfo).ConfigureAwait(false).GetAwaiter().GetResult();
-#endif
+            var result = await env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress, processUserInfo);
+
+            // Reenable UI and event handlers, if necessary
+            EnableUIElements();
+            if (cachedCanExecuteSelectionChanged)
+                EnableEventHandlers();
 
             return result.Message;
         }

MPF.Core/UI/ViewModels/CreateIRDViewModel.cs

@@ -2,9 +2,6 @@
 using System.ComponentModel;
 using System.IO;
 using MPF.Core.Utilities;
-#if NET6_0_OR_GREATER
-using LibIRD;
-#endif
 
 namespace MPF.Core.UI.ViewModels
 {
@@ -628,7 +625,7 @@ namespace MPF.Core.UI.ViewModels
             PICTextBoxEnabled = false;
             LayerbreakTextBoxEnabled = false;
 
-            if (ParseLog(LogPath, out byte[]? key, out byte[]? id, out byte[]? pic))
+            if (Tools.ParseGetKeyLog(LogPath, out byte[]? key, out byte[]? id, out byte[]? pic))
             {
                 Key = key;
                 DiscID = id;
@@ -678,7 +675,7 @@ namespace MPF.Core.UI.ViewModels
             LogPathTextBoxEnabled = false;
             LogPathBrowseButtonEnabled = false;
 
-            byte[]? id = ParseDiscID(DiscIDString);
+            byte[]? id = Tools.ParseDiscID(DiscIDString);
             if (id != null)
             {
                 DiscID = id;
@@ -717,7 +714,7 @@ namespace MPF.Core.UI.ViewModels
             LogPathBrowseButtonEnabled = false;
             HexKeyTextBoxEnabled = false;
 
-            byte[]? key = ParseKeyFile(KeyPath);
+            byte[]? key = Tools.ParseKeyFile(KeyPath);
             if (key != null)
             {
                 Key = key;
@@ -761,7 +758,7 @@ namespace MPF.Core.UI.ViewModels
             KeyPathTextBoxEnabled = false;
             KeyPathBrowseButtonEnabled = false;
 
-            byte[]? key = ParseHexKey(HexKey);
+            byte[]? key = Tools.ParseHexKey(HexKey);
             if (key != null)
             {
                 Key = key;
@@ -801,7 +798,7 @@ namespace MPF.Core.UI.ViewModels
             PICTextBoxEnabled = false;
             LayerbreakTextBoxEnabled = false;
 
-            PIC = ParsePICFile(PICPath);
+            PIC = Tools.ParsePICFile(PICPath);
             if (PIC != null)
             {
                 PICStatus = $"Using PIC from file: {Path.GetFileName(PICPath)}";
@@ -844,7 +841,7 @@ namespace MPF.Core.UI.ViewModels
             PICPathBrowseButtonEnabled = false;
             LayerbreakTextBoxEnabled = false;
 
-            PIC = ParsePIC(PICString);
+            PIC = Tools.ParsePIC(PICString);
             if (PIC != null)
             {
                 PICStatus = "Using provided PIC";
@@ -884,7 +881,7 @@ namespace MPF.Core.UI.ViewModels
             PICPathBrowseButtonEnabled = false;
             PICTextBoxEnabled = false;
 
-            Layerbreak = ParseLayerbreak(LayerbreakString);
+            Layerbreak = Tools.ParseLayerbreak(LayerbreakString);
             if (Layerbreak != null)
             {
                 PICStatus = $"Will generate a PIC using a Layerbreak of {Layerbreak}";
@@ -1049,9 +1046,8 @@ namespace MPF.Core.UI.ViewModels
 
             try
             {
-#if NET6_0_OR_GREATER
-                // Create IRD
-                ReIRD ird = new(InputPath, Key, Layerbreak);
+                // Create Redump-style reproducible IRD
+                LibIRD.ReIRD ird = new(InputPath, Key, Layerbreak);
                 if (PIC != null)
                     ird.PIC = PIC;
                 if (DiscID != null && ird.DiscID[15] != 0x00)
@@ -1059,9 +1055,6 @@ namespace MPF.Core.UI.ViewModels
                 ird.Write(outputPath);
                 CreateIRDStatus = "IRD Created Successfully";
                 return string.Empty;
-#else
-                return "LibIRD requires .NET Core 6 or greater.";
-#endif
             }
             catch (Exception e)
             {
@@ -1071,315 +1064,6 @@ namespace MPF.Core.UI.ViewModels
             }
         }
 
-        /// <summary>
-        /// Validates a getkey log to check for presence of valid PS3 key
-        /// </summary>
-        /// <param name="logPath">Path to getkey log file</param>
-        /// <param name="key">Output 16 byte key, null if not valid</param>
-        /// <returns>True if path to log file contains valid key, false otherwise</returns>
-        private static bool ParseLog(string? logPath, out byte[]? key, out byte[]? id, out byte[]? pic)
-        {
-            key = null;
-            id = null;
-            pic = null;
-
-            if (string.IsNullOrEmpty(logPath))
-                return false;
-
-            try
-            {
-                if (!File.Exists(logPath))
-                    return false;
-
-                // Protect from attempting to read from really long files
-                FileInfo logFile = new(logPath);
-                if (logFile.Length > 65536)
-                    return false;
-
-                // Read from .getkey.log file
-                using StreamReader sr = File.OpenText(logPath);
-
-                // Determine whether GetKey was successful
-                string? line;
-                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("get_dec_key succeeded!") == false) ;
-                if (line == null)
-                    return false;
-
-                // Look for Disc Key in log
-                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_key = ") == false) ;
-                // If end of file reached, no key found
-                if (line == null)
-                    return false;
-                // Get Disc Key from log
-                string discKeyStr = line.Substring("disc_key = ".Length);
-                // Validate Disc Key from log
-                if (discKeyStr.Length != 32)
-                    return false;
-                // Convert Disc Key to byte array
-                key = HexStringToByteArray(discKeyStr);
-                if (key == null)
-                    return false;
-
-                // Read Disc ID
-                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_id = ") == false) ;
-                // If end of file reached, no ID found
-                if (line == null)
-                    return false;
-                // Get Disc ID from log
-                string discIDStr = line.Substring("disc_id = ".Length);
-                // Validate Disc ID from log
-                if (discIDStr.Length != 32)
-                    return false;
-                // Replace X's in Disc ID with 00000001
-                discIDStr = discIDStr.Substring(0, 24) + "00000001";
-                // Convert Disc ID to byte array
-                id = HexStringToByteArray(discIDStr);
-                if (id == null)
-                    return false;
-
-                // Look for PIC in log
-                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("PIC:") == false) ;
-                // If end of file reached, no PIC found
-                if (line == null)
-                    return false;
-                // Get PIC from log
-                string discPICStr = "";
-                for (int i = 0; i < 8; i++)
-                    discPICStr += sr.ReadLine();
-                if (discPICStr == null)
-                    return false;
-                // Validate PIC from log
-                if (discPICStr.Length != 256)
-                    return false;
-                // Convert PIC to byte array
-                pic = HexStringToByteArray(discPICStr.Substring(0, 230));
-                if (pic == null)
-                    return false;
-
-                // Double check for warnings in .getkey.log
-                while ((line = sr.ReadLine()) != null)
-                {
-                    string t = line.Trim();
-                    if (t.StartsWith("WARNING"))
-                        return false;
-                    else if (t.StartsWith("SUCCESS"))
-                        return true;
-                }
-            }
-            catch
-            {
-                // We are not concerned with the error
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Validates a hexadecimal disc ID
-        /// </summary>
-        /// <param name="discID">String representing hexadecimal disc ID</param>
-        /// <returns>True if string is a valid disc ID, false otherwise</returns>
-        private static byte[]? ParseDiscID(string? discID)
-        {
-            if (string.IsNullOrEmpty(discID))
-                return null;
-
-            string cleandiscID = discID!.Trim().Replace("\n", string.Empty);
-
-            if (discID!.Length != 32)
-                return null;
-
-            // Censor last 4 bytes by replacing with 0x00000001
-            cleandiscID = cleandiscID.Substring(0, 24) + "00000001";
-
-            // Convert to byte array, null if invalid hex string
-            byte[]? id = HexStringToByteArray(cleandiscID);
-
-            return id;
-        }
-
-        /// <summary>
-        /// Validates a key file to check for presence of valid PS3 key
-        /// </summary>
-        /// <param name="keyPath">Path to key file</param>
-        /// <returns>Output 16 byte key, null if not valid</returns>
-        private static byte[]? ParseKeyFile(string? keyPath)
-        {
-            if (string.IsNullOrEmpty(keyPath))
-                return null;
-
-            // Try read from key file
-            try
-            {
-                if (!File.Exists(keyPath))
-                    return null;
-
-                // Key file must be exactly 16 bytes long
-                FileInfo keyFile = new(keyPath);
-                if (keyFile.Length != 16)
-                    return null;
-                byte[] key = new byte[16];
-
-                // Read 16 bytes from Key file
-                using FileStream fs = new(keyPath, FileMode.Open, FileAccess.Read);
-                using BinaryReader reader = new(fs);
-                int numBytes = reader.Read(key, 0, 16);
-                if (numBytes != 16)
-                    return null;
-
-                return key;
-            }
-            catch
-            {
-                // Not concerned with error
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Validates a hexadecimal key
-        /// </summary>
-        /// <param name="hexKey">String representing hexadecimal key</param>
-        /// <returns>Output 16 byte key, null if not valid</returns>
-        private static byte[]? ParseHexKey(string? hexKey)
-        {
-            if (string.IsNullOrEmpty(hexKey))
-                return null;
-
-            string cleanHexKey = hexKey!.Trim().Replace("\n", string.Empty);
-
-            if (hexKey!.Length != 32)
-                return null;
-
-            // Convert to byte array, null if invalid hex string
-            byte[]? key = HexStringToByteArray(cleanHexKey);
-
-            return key;
-        }
-
-        /// <summary>
-        /// Validates a PIC file path
-        /// </summary>
-        /// <param name="picPath">Path to PIC file</param>
-        /// <returns>Output PIC byte array, null if not valid</returns>
-        private static byte[]? ParsePICFile(string? picPath)
-        {
-            if (string.IsNullOrEmpty(picPath))
-                return null;
-
-            // Try read from PIC file
-            try
-            {
-                if (!File.Exists(picPath))
-                    return null;
-
-                // PIC file must be at least 115 bytes long
-                FileInfo picFile = new(picPath);
-                if (picFile.Length < 115)
-                    return null;
-                byte[] pic = new byte[115];
-
-                // Read 115 bytes from PIC file
-                using FileStream fs = new(picPath, FileMode.Open, FileAccess.Read);
-                using BinaryReader reader = new(fs);
-                int numBytes = reader.Read(pic, 0, 115);
-                if (numBytes != 115)
-                    return null;
-
-                // Validate that a PIC was read by checking first 6 bytes
-                if (pic[0] != 0x10 ||
-                    pic[1] != 0x02 ||
-                    pic[2] != 0x00 ||
-                    pic[3] != 0x00 ||
-                    pic[4] != 0x44 ||
-                    pic[5] != 0x49)
-                    return null;
-
-                return pic;
-            }
-            catch
-            {
-                // Not concerned with error
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Validates a PIC
-        /// </summary>
-        /// <param name="inputPIC">String representing PIC</param>
-        /// <returns>Output PIC byte array, null if not valid</returns>
-        private static byte[]? ParsePIC(string? inputPIC)
-        {
-            if (string.IsNullOrEmpty(inputPIC))
-                return null;
-
-            string cleanPIC = inputPIC!.Trim().Replace("\n", string.Empty);
-
-            if (cleanPIC.Length < 230)
-                return null;
-
-            // Convert to byte array, null if invalid hex string
-            byte[]? pic = HexStringToByteArray(cleanPIC);
-
-            return pic;
-        }
-
-        /// <summary>
-        /// Validates a layerbreak value (in sectors)
-        /// </summary>
-        /// <param name="inputLayerbreak">String representing layerbreak value</param>
-        /// <param name="layerbreak">Output layerbreak value, null if not valid</param>
-        /// <returns>True if layerbreak is valid, false otherwise</returns>
-        private static long? ParseLayerbreak(string? inputLayerbreak)
-        {
-            if (string.IsNullOrEmpty(inputLayerbreak))
-                return null;
-
-            if (!long.TryParse(inputLayerbreak, out long layerbreak))
-                return null;
-
-            // Check that layerbreak is positive number and smaller than largest disc size (in sectors)
-            if (layerbreak <= 0 || layerbreak > 24438784)
-                return null;
-
-            return layerbreak;
-        }
-
-        #endregion
-
-        #region Helper Functions
-
-        /// <summary>
-        /// Converts a hex string into a byte array
-        /// </summary>
-        /// <param name="hex">Hex string</param>
-        /// <returns>Converted byte array, or null if invalid hex string</returns>
-        private static byte[]? HexStringToByteArray(string? hexString)
-        {
-            // Valid hex string must be an even number of characters
-            if (string.IsNullOrEmpty(hexString) || hexString!.Length % 2 == 1)
-                return null;
-
-            // Convert ASCII to byte via lookup table
-            int[] hexLookup = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F];
-            byte[] byteArray = new byte[hexString.Length / 2];
-            for (int i = 0; i < hexString.Length; i += 2)
-            {
-                // Convert next two chars to ASCII value relative to '0'
-                int a = Char.ToUpper(hexString[i]) - '0';
-                int b = Char.ToUpper(hexString[i + 1]) - '0';
-                // Ensure hex string only has '0' through '9' and 'A' through 'F' (case insensitive)
-                if ((a < 0 || b < 0 || a > 22 || b > 22) || (a > 10 && a < 17) || (b > 10 && b < 17))
-                    return null;
-                byteArray[i / 2] = (byte)(hexLookup[a] << 4 | hexLookup[b]);
-            }
-
-            return byteArray;
-        }
-
         #endregion
     }
 }

MPF.Core/UI/ViewModels/MainViewModel.cs

@@ -76,20 +76,6 @@ namespace MPF.Core.UI.ViewModels
 
         #region Properties
 
-        /// <summary>
-        /// Indicates the inability to create IRDs
-        /// </summary>
-        public bool CannotCreateIRD
-        {
-            get => _cannotCreateIRD;
-            set
-            {
-                _cannotCreateIRD = value;
-                TriggerPropertyChanged(nameof(CannotCreateIRD));
-            }
-        }
-        private bool _cannotCreateIRD;
-
         /// <summary>
         /// Indicates the status of the check dump menu item
         /// </summary>
@@ -550,13 +536,7 @@ namespace MPF.Core.UI.ViewModels
 
             OptionsMenuItemEnabled = true;
             CheckDumpMenuItemEnabled = true;
-#if NET6_0_OR_GREATER
             CreateIRDMenuItemEnabled = true;
-            CannotCreateIRD = false;
-#else
-            CreateIRDMenuItemEnabled = false;
-            CannotCreateIRD = true;
-#endif
             SystemTypeComboBoxEnabled = true;
             MediaTypeComboBoxEnabled = true;
             OutputPathTextBoxEnabled = true;
@@ -721,16 +701,23 @@ namespace MPF.Core.UI.ViewModels
             bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
             DisableEventHandlers();
 
+            // Create a static list of supported programs, not everything
+            InternalPrograms = Enum.GetValues(typeof(InternalProgram)).Cast<InternalProgram>().Where(ip => InternalProgramExists(ip)).Select(ip => new Element<InternalProgram>(ip)).ToList();
+
             // Get the current internal program
             InternalProgram internalProgram = this.Options.InternalProgram;
 
-            // Create a static list of supported programs, not everything
-            var internalPrograms = new List<InternalProgram> { InternalProgram.Redumper, InternalProgram.DiscImageCreator, InternalProgram.Aaru };
-            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);
+            if (InternalPrograms.Count == 0)
+            {
+                // If no programs are found, default to InternalProgram.NONE
+                this.CurrentProgram = InternalProgram.NONE;
+            }
+            else
+            {   
+                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();
@@ -1290,9 +1277,7 @@ namespace MPF.Core.UI.ViewModels
         {
             OptionsMenuItemEnabled = false;
             CheckDumpMenuItemEnabled = false;
-#if NET6_0_OR_GREATER
             CreateIRDMenuItemEnabled = false;
-#endif
             SystemTypeComboBoxEnabled = false;
             MediaTypeComboBoxEnabled = false;
             OutputPathTextBoxEnabled = false;
@@ -1314,9 +1299,7 @@ namespace MPF.Core.UI.ViewModels
         {
             OptionsMenuItemEnabled = true;
             CheckDumpMenuItemEnabled = true;
-#if NET6_0_OR_GREATER
             CreateIRDMenuItemEnabled = true;
-#endif
             SystemTypeComboBoxEnabled = true;
             MediaTypeComboBoxEnabled = true;
             OutputPathTextBoxEnabled = true;
@@ -1341,7 +1324,10 @@ namespace MPF.Core.UI.ViewModels
 
             // Get the status to write out
             Result result = Tools.GetSupportStatus(_environment.System, _environment.Type);
-            this.Status = result.Message;
+            if (this.CurrentProgram == InternalProgram.NONE || _environment.Parameters == null)
+                this.Status = "No dumping program found";
+            else
+                this.Status = result.Message;
 
             // Enable or disable the button
             this.StartStopButtonEnabled = result && ShouldEnableDumpingButton();
@@ -1698,8 +1684,8 @@ namespace MPF.Core.UI.ViewModels
                 _environment.Drive?.RefreshDrive();
 
                 // Output to the label and log
-                this.Status = "Starting dumping process... Please wait!";
-                LogLn("Starting dumping process... Please wait!");
+                this.Status = "Starting dumping process... please wait!";
+                LogLn("Starting dumping process... please wait!");
                 if (this.Options.ToolsInSeparateWindow)
                     LogLn("Look for the separate command window for more details");
                 else
@@ -1792,6 +1778,9 @@ namespace MPF.Core.UI.ViewModels
         /// <returns>True if dumping should start, false otherwise</returns>
         private bool ValidateBeforeDumping()
         {
+            if (Parameters == null)
+                return false;
+
             // Validate that we have an output path of any sort
             if (string.IsNullOrEmpty(_environment?.OutputPath))
             {
@@ -1831,49 +1820,51 @@ namespace MPF.Core.UI.ViewModels
                     return false;
                 }
             }
-
-            // If a complete dump exists from a different program
-            InternalProgram? programFound = null;
-            if (programFound == null && _environment.InternalProgram != InternalProgram.Aaru)
+            else
             {
-                Modules.Aaru.Parameters parameters = new("")
+                // If a complete dump exists from a different program
+                InternalProgram? programFound = null;
+                if (programFound == null && _environment.InternalProgram != InternalProgram.Aaru)
                 {
-                    Type = _environment.Type,
-                    System = _environment.System
-                };
-                (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
-                if (foundOtherFiles)
-                    programFound = InternalProgram.Aaru;
-            }
-            if (programFound == null && _environment.InternalProgram != InternalProgram.DiscImageCreator)
-            {
-                Modules.DiscImageCreator.Parameters parameters = new("")
+                    Modules.Aaru.Parameters parameters = new("")
+                    {
+                        Type = _environment.Type,
+                        System = _environment.System
+                    };
+                    (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
+                    if (foundOtherFiles)
+                        programFound = InternalProgram.Aaru;
+                }
+                if (programFound == null && _environment.InternalProgram != InternalProgram.DiscImageCreator)
                 {
-                    Type = _environment.Type,
-                    System = _environment.System
-                };
-                (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
-                if (foundOtherFiles)
-                    programFound = InternalProgram.DiscImageCreator;
-            }
-            if (programFound == null && _environment.InternalProgram != InternalProgram.Redumper)
-            {
-                Modules.Redumper.Parameters parameters = new("")
+                    Modules.DiscImageCreator.Parameters parameters = new("")
+                    {
+                        Type = _environment.Type,
+                        System = _environment.System
+                    };
+                    (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
+                    if (foundOtherFiles)
+                        programFound = InternalProgram.DiscImageCreator;
+                }
+                if (programFound == null && _environment.InternalProgram != InternalProgram.Redumper)
                 {
-                    Type = _environment.Type,
-                    System = _environment.System
-                };
-                (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
-                if (foundOtherFiles)
-                    programFound = InternalProgram.Redumper;
-            }
-            if (programFound != null && _displayUserMessage != null)
-            {
-                bool? mbresult = _displayUserMessage("Overwrite?", $"A complete dump from {programFound} already exists! Dumping here may cause issues. Are you sure you want to overwrite?", 2, true);
-                if (mbresult != true)
+                    Modules.Redumper.Parameters parameters = new("")
+                    {
+                        Type = _environment.Type,
+                        System = _environment.System
+                    };
+                    (bool foundOtherFiles, _) = parameters.FoundAllFiles(outputDirectory, outputFilename, true);
+                    if (foundOtherFiles)
+                        programFound = InternalProgram.Redumper;
+                }
+                if (programFound != null && _displayUserMessage != null)
                 {
-                    LogLn("Dumping aborted!");
-                    return false;
+                    bool? mbresult = _displayUserMessage("Overwrite?", $"A complete dump from {programFound} already exists! Dumping here may cause issues. Are you sure you want to overwrite?", 2, true);
+                    if (mbresult != true)
+                    {
+                        LogLn("Dumping aborted!");
+                        return false;
+                    }
                 }
             }
 
@@ -1900,7 +1891,30 @@ namespace MPF.Core.UI.ViewModels
             return true;
         }
 
-#endregion
+        /// <summary>
+        /// Checks whether a internal program is found in its path
+        /// </summary>
+        /// <param name="program">Program to check for</param>
+        /// <returns>True if the program is found, false otherwise</returns>
+        private bool InternalProgramExists(InternalProgram program)
+        {
+            try
+            {
+                return program switch
+                {
+                    InternalProgram.Redumper => File.Exists(this.Options.RedumperPath),
+                    InternalProgram.Aaru => File.Exists(this.Options.AaruPath),
+                    InternalProgram.DiscImageCreator => File.Exists(this.Options.DiscImageCreatorPath),
+                    _ => false,
+                };
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        #endregion
 
         #region Progress Reporting
 

MPF.Core/UI/ViewModels/OptionsViewModel.cs

@@ -51,6 +51,16 @@ namespace MPF.Core.UI.ViewModels
         /// </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>
@@ -77,7 +87,7 @@ namespace MPF.Core.UI.ViewModels
         #region Population
 
         /// <summary>
-        /// Get a complete list of  supported internal programs
+        /// Get a complete list of supported internal programs
         /// </summary>
         private static List<Element<InternalProgram>> PopulateInternalPrograms()
         {
@@ -85,6 +95,24 @@ namespace MPF.Core.UI.ViewModels
             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
@@ -107,6 +135,17 @@ namespace MPF.Core.UI.ViewModels
 #endif
         }
 
+        /// <summary>
+        /// Reset Redumper non-redump options (Read Method, Sector Order, Drive Type)
+        /// </summary>
+        public void NonRedumpModeUnChecked()
+        {
+            Options.RedumperReadMethod = RedumperReadMethod.NONE;
+            Options.RedumperSectorOrder = RedumperSectorOrder.NONE;
+            Options.RedumperUseGenericDriveType = false;
+            TriggerPropertyChanged(nameof(Options));
+        }
+
         #endregion
 
         #region Property Updates

MPF.Core/Utilities/OptionsLoader.cs

@@ -26,7 +26,17 @@ namespace MPF.Core.Utilities
                 return false;
 
             // List options
-            if (args[0] == "-lm" || args[0] == "--listmedia")
+            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())
@@ -272,7 +282,8 @@ namespace MPF.Core.Utilities
             }
 
             var serializer = JsonSerializer.Create();
-            var reader = new StreamReader(ConfigurationPath);
+            var stream = File.Open(ConfigurationPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var reader = new StreamReader(stream);
             var settings = serializer.Deserialize(reader, typeof(Dictionary<string, string?>)) as Dictionary<string, string?>;
             return new Options(settings);
         }

MPF.Core/Utilities/Tools.cs

@@ -1,4 +1,6 @@
 using System;
+using System.IO;
+using System.Linq;
 using System.Net;
 using System.Reflection;
 using MPF.Core.Data;
@@ -71,6 +73,36 @@ namespace MPF.Core.Utilities
             return true;
         }
 
+        /// <summary>
+        /// Converts a hex string into a byte array
+        /// </summary>
+        /// <param name="hex">Hex string</param>
+        /// <returns>Converted byte array, or null if invalid hex string</returns>
+        public static byte[]? HexStringToByteArray(string? hexString)
+        {
+            // Valid hex string must be an even number of characters
+            if (string.IsNullOrEmpty(hexString) || hexString!.Length % 2 == 1)
+                return null;
+
+            // Convert ASCII to byte via lookup table
+            int[] hexLookup = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F];
+            byte[] byteArray = new byte[hexString.Length / 2];
+            for (int i = 0; i < hexString.Length; i += 2)
+            {
+                // Convert next two chars to ASCII value relative to '0'
+                int a = Char.ToUpper(hexString[i]) - '0';
+                int b = Char.ToUpper(hexString[i + 1]) - '0';
+
+                // Ensure hex string only has '0' through '9' and 'A' through 'F' (case insensitive)
+                if ((a < 0 || b < 0 || a > 22 || b > 22) || (a > 10 && a < 17) || (b > 10 && b < 17))
+                    return null;
+                byteArray[i / 2] = (byte)(hexLookup[a] << 4 | hexLookup[b]);
+            }
+
+            return byteArray;
+        }
+
         #endregion
 
         #region Support
@@ -261,5 +293,759 @@ namespace MPF.Core.Utilities
         }
 
         #endregion
+
+        #region PlayStation 3 specific tools
+
+        /// <summary>
+        /// Validates a getkey log to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="logPath">Path to getkey log file</param>
+        /// <param name="key">Output key string, null if not valid</param>
+        /// <param name="id">Output disc ID string, null if not valid</param>
+        /// <param name="pic">Output PIC string, null if not valid</param>
+        /// <returns>True if path to log file contains valid key, false otherwise</returns>
+        public static bool ParseGetKeyLog(string? logPath, out string? key, out string? id, out string? pic)
+        {
+            key = id = pic = null;
+
+            if (string.IsNullOrEmpty(logPath))
+                return false;
+
+            try
+            {
+                if (!File.Exists(logPath))
+                    return false;
+
+                // Protect from attempting to read from really long files
+                FileInfo logFile = new(logPath);
+                if (logFile.Length > 65536)
+                    return false;
+
+                // Read from .getkey.log file
+                using StreamReader sr = File.OpenText(logPath);
+
+                // Determine whether GetKey was successful
+                string? line;
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("get_dec_key succeeded!") == false) ;
+                if (line == null)
+                    return false;
+
+                // Look for Disc Key in log
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_key = ") == false) ;
+
+                // If end of file reached, no key found
+                if (line == null)
+                    return false;
+
+                // Get Disc Key from log
+                string discKeyStr = line.Substring("disc_key = ".Length);
+
+                // Validate Disc Key from log
+                if (discKeyStr.Length != 32)
+                    return false;
+
+                // Convert Disc Key to byte array
+                key = discKeyStr;
+                if (key == null)
+                    return false;
+
+                // Read Disc ID
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("disc_id = ") == false) ;
+
+                // If end of file reached, no ID found
+                if (line == null)
+                    return false;
+
+                // Get Disc ID from log
+                string discIDStr = line.Substring("disc_id = ".Length);
+
+                // Validate Disc ID from log
+                if (discIDStr.Length != 32)
+                    return false;
+
+                // Replace X's in Disc ID with 00000001
+                discIDStr = discIDStr.Substring(0, 24) + "00000001";
+
+                // Convert Disc ID to byte array
+                id = discIDStr;
+                if (id == null)
+                    return false;
+
+                // Look for PIC in log
+                while ((line = sr.ReadLine()) != null && line.Trim().StartsWith("PIC:") == false) ;
+
+                // If end of file reached, no PIC found
+                if (line == null)
+                    return false;
+
+                // Get PIC from log
+                string discPICStr = "";
+                for (int i = 0; i < 9; i++)
+                    discPICStr += sr.ReadLine();
+                if (discPICStr == null)
+                    return false;
+
+                // Validate PIC from log
+                if (discPICStr.Length != 264)
+                    return false;
+
+                // Convert PIC to byte array
+                pic = discPICStr;
+                if (pic == null)
+                    return false;
+
+                // Double check for warnings in .getkey.log
+                while ((line = sr.ReadLine()) != null)
+                {
+                    string t = line.Trim();
+                    if (t.StartsWith("WARNING"))
+                        return false;
+                    else if (t.StartsWith("SUCCESS"))
+                        return true;
+                }
+            }
+            catch
+            {
+                // We are not concerned with the error
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Validates a getkey log to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="logPath">Path to getkey log file</param>
+        /// <param name="key">Output 16 byte disc key, null if not valid</param>
+        /// <param name="id">Output 16 byte disc ID, null if not valid</param>
+        /// <param name="pic">Output 230 byte PIC, null if not valid</param>
+        /// <returns>True if path to log file contains valid key, false otherwise</returns>
+        public static bool ParseGetKeyLog(string? logPath, out byte[]? key, out byte[]? id, out byte[]? pic)
+        {
+            key = id = pic = null;
+            if (ParseGetKeyLog(logPath, out string? keyString, out string? idString, out string? picString))
+            {
+                if (string.IsNullOrEmpty(keyString) || string.IsNullOrEmpty(idString) || string.IsNullOrEmpty(picString) || picString!.Length < 230)
+                    return false;
+
+                key = Tools.HexStringToByteArray(keyString);
+                id = Tools.HexStringToByteArray(idString);
+                pic = Tools.HexStringToByteArray(picString.Substring(0, 230));
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Validates a hexadecimal disc ID
+        /// </summary>
+        /// <param name="discID">String representing hexadecimal disc ID</param>
+        /// <returns>True if string is a valid disc ID, false otherwise</returns>
+        public static byte[]? ParseDiscID(string? discID)
+        {
+            if (string.IsNullOrEmpty(discID))
+                return null;
+
+            string cleandiscID = discID!.Trim().Replace("\n", string.Empty);
+
+            if (discID!.Length != 32)
+                return null;
+
+            // Censor last 4 bytes by replacing with 0x00000001
+            cleandiscID = cleandiscID.Substring(0, 24) + "00000001";
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? id = Tools.HexStringToByteArray(cleandiscID);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Validates a key file to check for presence of valid PS3 key
+        /// </summary>
+        /// <param name="keyPath">Path to key file</param>
+        /// <returns>Output 16 byte key, null if not valid</returns>
+        public static byte[]? ParseKeyFile(string? keyPath)
+        {
+            if (string.IsNullOrEmpty(keyPath))
+                return null;
+
+            // Try read from key file
+            try
+            {
+                if (!File.Exists(keyPath))
+                    return null;
+
+                // Key file must be exactly 16 bytes long
+                FileInfo keyFile = new(keyPath);
+                if (keyFile.Length != 16)
+                    return null;
+                byte[] key = new byte[16];
+
+                // Read 16 bytes from Key file
+                using FileStream fs = new(keyPath, FileMode.Open, FileAccess.Read);
+                using BinaryReader reader = new(fs);
+                int numBytes = reader.Read(key, 0, 16);
+                if (numBytes != 16)
+                    return null;
+
+                return key;
+            }
+            catch
+            {
+                // Not concerned with error
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Validates a hexadecimal key
+        /// </summary>
+        /// <param name="hexKey">String representing hexadecimal key</param>
+        /// <returns>Output 16 byte key, null if not valid</returns>
+        public static byte[]? ParseHexKey(string? hexKey)
+        {
+            if (string.IsNullOrEmpty(hexKey))
+                return null;
+
+            string cleanHexKey = hexKey!.Trim().Replace("\n", string.Empty);
+
+            if (cleanHexKey.Length != 32)
+                return null;
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? key = Tools.HexStringToByteArray(cleanHexKey);
+
+            return key;
+        }
+
+        /// <summary>
+        /// Validates a PIC file path
+        /// </summary>
+        /// <param name="picPath">Path to PIC file</param>
+        /// <returns>Output PIC byte array, null if not valid</returns>
+        public static byte[]? ParsePICFile(string? picPath)
+        {
+            if (string.IsNullOrEmpty(picPath))
+                return null;
+
+            // Try read from PIC file
+            try
+            {
+                if (!File.Exists(picPath))
+                    return null;
+
+                // PIC file must be at least 115 bytes long
+                FileInfo picFile = new(picPath);
+                if (picFile.Length < 115)
+                    return null;
+                byte[] pic = new byte[115];
+
+                // Read 115 bytes from PIC file
+                using FileStream fs = new(picPath, FileMode.Open, FileAccess.Read);
+                using BinaryReader reader = new(fs);
+                int numBytes = reader.Read(pic, 0, 115);
+                if (numBytes != 115)
+                    return null;
+
+                // Validate that a PIC was read by checking first 6 bytes
+                if (pic[0] != 0x10 ||
+                    pic[1] != 0x02 ||
+                    pic[2] != 0x00 ||
+                    pic[3] != 0x00 ||
+                    pic[4] != 0x44 ||
+                    pic[5] != 0x49)
+                    return null;
+
+                return pic;
+            }
+            catch
+            {
+                // Not concerned with error
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Validates a PIC
+        /// </summary>
+        /// <param name="inputPIC">String representing PIC</param>
+        /// <returns>Output PIC byte array, null if not valid</returns>
+        public static byte[]? ParsePIC(string? inputPIC)
+        {
+            if (string.IsNullOrEmpty(inputPIC))
+                return null;
+
+            string cleanPIC = inputPIC!.Trim().Replace("\n", string.Empty);
+
+            if (cleanPIC.Length < 230)
+                return null;
+
+            // Convert to byte array, null if invalid hex string
+            byte[]? pic = Tools.HexStringToByteArray(cleanPIC.Substring(0, 230));
+
+            return pic;
+        }
+
+        /// <summary>
+        /// Validates a string representing a layerbreak value (in sectors)
+        /// </summary>
+        /// <param name="inputLayerbreak">String representing layerbreak value</param>
+        /// <param name="layerbreak">Output layerbreak value, null if not valid</param>
+        /// <returns>True if layerbreak is valid, false otherwise</returns>
+        public static long? ParseLayerbreak(string? inputLayerbreak)
+        {
+            if (string.IsNullOrEmpty(inputLayerbreak))
+                return null;
+
+            if (!long.TryParse(inputLayerbreak, out long layerbreak))
+                return null;
+
+            return ParseLayerbreak(layerbreak);
+        }
+
+        /// <summary>
+        /// Validates a layerbreak value (in sectors)
+        /// </summary>
+        /// <param name="inputLayerbreak">Number representing layerbreak value</param>
+        /// <param name="layerbreak">Output layerbreak value, null if not valid</param>
+        /// <returns>True if layerbreak is valid, false otherwise</returns>
+        public static long? ParseLayerbreak(long? layerbreak)
+        {
+            // Check that layerbreak is positive number and smaller than largest disc size (in sectors)
+            if (layerbreak <= 0 || layerbreak > 24438784)
+                return null;
+
+            return layerbreak;
+        }
+
+        /// <summary>
+        /// Converts a CRC32 hash hex string into uint32 representation
+        /// </summary>
+        /// <param name="inputLayerbreak">Hex string representing CRC32 hash</param>
+        /// <param name="layerbreak">Output CRC32 value, null if not valid</param>
+        /// <returns>True if CRC32 hash string is valid, false otherwise</returns>
+        public static uint? ParseCRC32(string? inputCRC32)
+        {
+            if (string.IsNullOrEmpty(inputCRC32))
+                return null;
+
+            byte[]? crc32 = Tools.HexStringToByteArray(inputCRC32);
+
+            if (crc32 == null || crc32.Length != 4)
+                return null;
+
+            return (uint)(0x01000000 * crc32[0] + 0x00010000 * crc32[1] + 0x00000100 * crc32[2] + 0x00000001 * crc32[3]);
+        }
+
+        #endregion
+
+        #region Xbox/Xbox360 specific tools
+
+        /// <summary>
+        /// Get the XGD1 Master ID (XMID) information
+        /// </summary>
+        /// <param name="dmi">DMI.bin file location</param>
+        /// <returns>String representation of the XGD1 DMI information, empty string on error</returns>
+        public static string GetXGD1XMID(string dmi)
+        {
+            if (!File.Exists(dmi))
+                return string.Empty;
+
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(dmi));
+                br.BaseStream.Seek(8, SeekOrigin.Begin);
+                return new string(br.ReadChars(8));
+            }
+            catch
+            {
+                return string.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get the XGD2/3 Master ID (XeMID) information
+        /// </summary>
+        /// <param name="dmi">DMI.bin file location</param>
+        /// <returns>String representation of the XGD2/3 DMI information, empty string on error</returns>
+        public static string GetXGD23XeMID(string dmi)
+        {
+            if (!File.Exists(dmi))
+                return string.Empty;
+
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(dmi));
+                br.BaseStream.Seek(64, SeekOrigin.Begin);
+                return new string(br.ReadChars(14));
+            }
+            catch
+            {
+                return string.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get XGD type from SS.bin file
+        /// </summary>
+        /// <param name="ss"></param>
+        /// <param name="xgdType"></param>
+        /// <returns></returns>
+        public static bool GetXGDType(string? ss, out int xgdType)
+        {
+            xgdType = 0;
+
+            if (string.IsNullOrEmpty(ss) || !File.Exists(ss))
+                return false;
+
+            using FileStream fs = File.OpenRead(ss);
+            byte[] buf = new byte[3];
+            int numBytes = fs.Read(buf, 13, 16);
+
+            if (numBytes != 3)
+                return false;
+
+            return GetXGDType(buf, out xgdType);
+        }
+
+        /// <summary>
+        /// Get XGD type from SS.bin sector
+        /// </summary>
+        /// <param name="ss">Byte array of SS.bin sector</param>
+        /// <param name="xgdType">XGD type</param>
+        /// <returns>True if successful, false otherwise</returns>
+        public static bool GetXGDType(byte[] ss, out int xgdType)
+        {
+            xgdType = 0;
+
+            // Concatenate the last three values
+            long lastThree = (((ss[13] << 8) | ss[14]) << 8) | ss[15];
+
+            // Return XGD type based on value
+            switch (lastThree)
+            {
+                case 0x2033AF:
+                    xgdType = 1;
+                    return true;
+                case 0x20339F:
+                    xgdType = 2;
+                    return true;
+                case 0x238E0F:
+                    xgdType = 3;
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determine if a given SS has already been cleaned
+        /// </summary>
+        /// <param name="ss">Byte array of SS sector</param>
+        /// <returns>True if SS is clean, false otherwise</returns>
+        public static bool IsCleanSS(byte[] ss)
+        {
+            if (ss.Length != 2048)
+                return false;
+
+            if (!GetXGDType(ss, out int xgdType))
+                return false;
+
+            if (xgdType == 3 && ss.Skip(32).Take(72).All(x => x == 0))
+            {
+                // Check for a cleaned SSv2
+
+                int rtOffset = 0x24;
+
+                if (ss[rtOffset + 36] != 0x01)
+                    return false;
+                if (ss[rtOffset + 37] != 0x00)
+                    return false;
+                if (ss[rtOffset + 39] != 0x01)
+                    return false;
+                if (ss[rtOffset + 40] != 0x00)
+                    return false;
+                if (ss[rtOffset + 45] != 0x5B)
+                    return false;
+                if (ss[rtOffset + 46] != 0x00)
+                    return false;
+                if (ss[rtOffset + 48] != 0x5B)
+                    return false;
+                if (ss[rtOffset + 49] != 0x00)
+                    return false;
+                if (ss[rtOffset + 54] != 0xB5)
+                    return false;
+                if (ss[rtOffset + 55] != 0x00)
+                    return false;
+                if (ss[rtOffset + 57] != 0xB5)
+                    return false;
+                if (ss[rtOffset + 58] != 0x00)
+                    return false;
+                if (ss[rtOffset + 63] != 0x0F)
+                    return false;
+                if (ss[rtOffset + 64] != 0x01)
+                    return false;
+                if (ss[rtOffset + 66] != 0x0F)
+                    return false;
+                if (ss[rtOffset + 67] != 0x01)
+                    return false;
+            }
+            else
+            {
+                // Check for a cleaned SSv1
+
+                int rtOffset = 0x204;
+
+                if (ss[rtOffset + 36] != 0x01)
+                    return false;
+                if (ss[rtOffset + 37] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 39] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 40] != 0x00)
+                    return false;
+                if (ss[rtOffset + 45] != 0x5B)
+                    return false;
+                if (ss[rtOffset + 46] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 48] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 49] != 0x00)
+                    return false;
+                if (ss[rtOffset + 54] != 0xB5)
+                    return false;
+                if (ss[rtOffset + 55] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 57] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 58] != 0x00)
+                    return false;
+                if (ss[rtOffset + 63] != 0x0F)
+                    return false;
+                if (ss[rtOffset + 64] != 0x01)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 66] != 0x00)
+                    return false;
+                if (xgdType == 2 && ss[rtOffset + 67] != 0x00)
+                    return false;
+            }
+
+            // All angles are as expected, it is clean
+            return true;
+        }
+
+        /// <summary>
+        /// Clean a rawSS.bin file and write it to a file
+        /// </summary>
+        /// <param name="rawSS">Path to the raw SS file to read from</param>
+        /// <param name="cleanSS">Path to the clean SS file to write to</param>
+        /// <returns>True if successful, false otherwise</returns>
+        public static bool CleanSS(string rawSS, string cleanSS)
+        {
+            if (!File.Exists(rawSS))
+                return false;
+
+            byte[] ss = File.ReadAllBytes(rawSS);
+            if (ss.Length != 2048)
+                return false;
+
+            if (!CleanSS(ss))
+                return false;
+
+            File.WriteAllBytes(cleanSS, ss);
+            return true;
+        }
+
+        /// <summary>
+        /// Fix a SS sector to its predictable clean form.
+        /// With help from ss_sector_range
+        /// </summary>
+        /// <param name="ss">Byte array of raw SS sector</param>
+        /// <returns>True if successful, false otherwise</returns>
+        public static bool CleanSS(byte[] ss)
+        {
+            // Must be entire sector
+            if (ss.Length != 2048)
+                return false;
+
+            // Determine XGD type
+            if (!GetXGDType(ss, out int xgdType))
+                return false;
+
+            switch (xgdType)
+            {
+                case 1:
+                    // Leave Original Xbox SS.bin unchanged
+                    return true;
+
+                case 2:
+                    // Fix standard SSv1 ss.bin
+                    ss[552] = 1;   // 0x01
+                    ss[553] = 0;   // 0x00
+                    ss[555] = 0;   // 0x00
+                    ss[556] = 0;   // 0x00
+
+                    ss[561] = 91;  // 0x5B
+                    ss[562] = 0;   // 0x00
+                    ss[564] = 0;   // 0x00
+                    ss[565] = 0;   // 0x00
+
+                    ss[570] = 181; // 0xB5
+                    ss[571] = 0;   // 0x00
+                    ss[573] = 0;   // 0x00
+                    ss[574] = 0;   // 0x00
+
+                    ss[579] = 15;  // 0x0F
+                    ss[580] = 1;   // 0x01
+                    ss[582] = 0;   // 0x00
+                    ss[583] = 0;   // 0x00
+                    return true;
+
+                case 3:
+                    // Determine if XGD3 SS.bin is SSv1 (Kreon) or SSv2 (0800)
+                    bool ssv2 = ss.Skip(32).Take(72).All(x => x == 0);
+
+                    if (ssv2)
+                    {
+                        ss[72] = 1;   // 0x01
+                        ss[73] = 0;   // 0x00
+                        ss[75] = 1;   // 0x01
+                        ss[76] = 0;   // 0x00
+
+                        ss[81] = 91;  // 0x5B
+                        ss[82] = 0;   // 0x00
+                        ss[84] = 91;  // 0x5B
+                        ss[85] = 0;   // 0x00
+
+                        ss[90] = 181; // 0xB5
+                        ss[91] = 0;   // 0x00
+                        ss[93] = 181; // 0xB5
+                        ss[94] = 0;   // 0x00
+
+                        ss[99] = 15;  // 0x0F
+                        ss[100] = 1;   // 0x01
+                        ss[102] = 15;  // 0x0F
+                        ss[103] = 1;   // 0x01
+                    }
+                    else
+                    {
+                        ss[552] = 1;   // 0x01
+                        ss[553] = 0;   // 0x00
+
+                        ss[561] = 91;  // 0x5B
+                        ss[562] = 0;   // 0x00
+
+                        ss[570] = 181; // 0xB5
+                        ss[571] = 0;   // 0x00
+
+                        ss[579] = 15;  // 0x0F
+                        ss[580] = 1;   // 0x01
+                    }
+
+                    return true;
+
+                default:
+                    // Unknown XGD type
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Get Security Sector ranges from SS.bin
+        /// </summary>
+        /// <param name="ssBin">Path to SS.bin file</param>
+        /// <returns>Sector ranges if found, null otherwise</returns>
+        public static string? GetSSRanges(string ssBin)
+        {
+            if (!File.Exists(ssBin))
+                return null;
+
+            byte[] ss = File.ReadAllBytes(ssBin);
+            if (ss.Length != 2048)
+                return null;
+
+            return GetSSRanges(ss);
+        }
+
+        /// <summary>
+        /// Get Security Sector ranges from SS sector.
+        /// With help from ss_sector_range
+        /// </summary>
+        /// <param name="ss">Byte array of SS sector</param>
+        /// <returns>Sector ranges if found, null otherwise</returns>
+        public static string? GetSSRanges(byte[] ss)
+        {
+            if (ss.Length != 2048)
+                return null;
+
+            if (!GetXGDType(ss, out int xgdType))
+                return null;
+
+            //uint numRanges = ss[1632];
+            uint numRanges;
+            if (xgdType == 1)
+                numRanges = 16;
+            else
+                numRanges = 4;
+
+
+            uint[] startLBA = new uint[numRanges];
+            uint[] endLBA = new uint[numRanges];
+            for (uint i = 0; i < numRanges; i++)
+            {
+                // Determine range Physical Sector Number
+                uint startPSN = (uint)((((ss[i * 9 + 1636] << 8) | ss[i * 9 + 1637]) << 8) | ss[i * 9 + 1638]);
+                uint endPSN = (uint)((((ss[i * 9 + 1639] << 8) | ss[i * 9 + 1640]) << 8) | ss[i * 9 + 1641]);
+                
+                // Determine range Logical Sector Number
+                if (xgdType == 1 && startPSN >= (1913776 + 0x030000))
+                {
+                    // Layer 1 of XGD1
+                    startLBA[i] = (1913776 + 0x030000) * 2 - (startPSN ^ 0xFFFFFF) - 0x030000 - 1;
+                    endLBA[i] = (1913776 + 0x030000) * 2 - (endPSN ^ 0xFFFFFF) - 0x030000 - 1;
+                }
+                else if (xgdType > 1 && startPSN >= (1913760 + 0x030000))
+                {
+                    // Layer 1 of XGD2 or XGD3
+                    startLBA[i] = (1913760 + 0x030000) * 2 - (startPSN ^ 0xFFFFFF) - 0x030000 - 1;
+                    endLBA[i] = (1913760 + 0x030000) * 2 - (endPSN ^ 0xFFFFFF) - 0x030000 - 1;
+                }
+                else
+                {
+                    // Layer 0
+                    startLBA[i] = startPSN - 0x030000;
+                    endLBA[i] = endPSN - 0x030000;
+                }
+            }
+
+            // Sort ranges for XGD1
+            if (xgdType == 1)
+                Array.Sort(startLBA, endLBA);
+
+            // Represent ranges as string
+            string? ranges = null;
+            if (xgdType == 1)
+            {
+                for (int i = 0; i < 16; i++)
+                {
+                    ranges += $"{startLBA[i]}-{endLBA[i]}";
+                    if (i != numRanges - 1)
+                        ranges += "\r\n";
+                }
+            }
+            else
+            {
+                ranges = $"{startLBA[0]}-{endLBA[0]}\r\n{startLBA[3]}-{endLBA[3]}";
+            }
+
+            return ranges;
+        }
+
+        #endregion
     }
 }

MPF.Test/MPF.Test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net6.0-windows;net8.0-windows</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
@@ -10,26 +10,26 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\MPF\MPF.csproj" />
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeCoverage" Version="17.9.0-preview-23531-01" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0-preview-23531-01" />
+    <PackageReference Include="Microsoft.CodeCoverage" Version="17.10.0-release-24177-07" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0-release-24177-07" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
-    <PackageReference Include="xunit" Version="2.6.2" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.8" />
+    <PackageReference Include="xunit" Version="2.8.0" />
     <PackageReference Include="xunit.abstractions" Version="2.0.3" />
-    <PackageReference Include="xunit.analyzers" Version="1.6.0" />
-    <PackageReference Include="xunit.assert" Version="2.6.2" />
-    <PackageReference Include="xunit.core" Version="2.6.2" />
-    <PackageReference Include="xunit.extensibility.core" Version="2.6.2" />
-    <PackageReference Include="xunit.extensibility.execution" Version="2.6.2" />
-    <PackageReference Include="xunit.runner.console" Version="2.6.2">
+    <PackageReference Include="xunit.analyzers" Version="1.13.0" />
+    <PackageReference Include="xunit.assert" Version="2.8.0" />
+    <PackageReference Include="xunit.core" Version="2.8.0" />
+    <PackageReference Include="xunit.extensibility.core" Version="2.8.0" />
+    <PackageReference Include="xunit.extensibility.execution" Version="2.8.0" />
+    <PackageReference Include="xunit.runner.console" Version="2.8.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.4">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

MPF.UI.Core/ElementConverter.cs

@@ -16,6 +16,8 @@ namespace MPF.UI.Core
                 DiscCategory discCategory => new Element<DiscCategory>(discCategory),
                 InternalProgram internalProgram => new Element<InternalProgram>(internalProgram),
                 MediaType mediaType => new Element<MediaType>(mediaType),
+                RedumperReadMethod readMethod => new Element<RedumperReadMethod>(readMethod),
+                RedumperSectorOrder sectorOrder => new Element<RedumperSectorOrder>(sectorOrder),
                 RedumpSystem redumpSystem => new RedumpSystemComboBoxItem(redumpSystem),
                 Region region => new Element<Region>(region),
 
@@ -35,6 +37,8 @@ namespace MPF.UI.Core
                 Element<DiscCategory> dcElement => dcElement.Value,
                 Element<InternalProgram> ipElement => ipElement.Value,
                 Element<MediaType> mtElement => mtElement.Value,
+                Element<RedumperReadMethod> rmElement => rmElement.Value,
+                Element<RedumperSectorOrder> soElement => soElement.Value,
                 RedumpSystemComboBoxItem rsElement => rsElement.Value,
                 Element<Region> reValue => reValue.Value,
                 _ => null,

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

@@ -6,14 +6,15 @@
     <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     <ImportFrameworkWinFXTargets Condition="$(TargetFramework.StartsWith(`net3`))">true</ImportFrameworkWinFXTargets>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <VersionPrefix>3.1.1</VersionPrefix>
     <UseWindowsForms>true</UseWindowsForms>
     <UseWPF>true</UseWPF>
+    <VersionPrefix>3.1.9</VersionPrefix>
 
     <!-- Package Properties -->
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
@@ -42,7 +43,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.8" />
   </ItemGroup>
 
   <ItemGroup>

MPF.UI.Core/Windows/CheckDumpWindow.xaml

@@ -117,7 +117,7 @@
                     <Button Name="CheckDumpButton" Height="25" Width="80" IsDefault="True" Content="Check Dump"
                             IsEnabled="{Binding CheckDumpButtonEnabled}" Style="{DynamicResource CustomButtonStyle}" />
                     <Button Name="CancelButton" Height="25" Width="80" IsCancel="True" Content="Cancel"
-                            Style="{DynamicResource CustomButtonStyle}" />
+                            IsEnabled="{Binding CancelButtonEnabled}" Style="{DynamicResource CustomButtonStyle}" />
                     <Label/>
                     <!-- Empty label for padding -->
                 </UniformGrid>

MPF.UI.Core/Windows/CheckDumpWindow.xaml.cs

@@ -209,9 +209,17 @@ namespace MPF.UI.Core.Windows
         /// <summary>
         /// Handler for CheckDumpButton Click event
         /// </summary>
+#if NET40
         private void OnCheckDumpClick(object sender, EventArgs e)
         {
-            string? errorMessage = CheckDumpViewModel.CheckDump(ShowDiscInformationWindow);
+            var checkTask = CheckDumpViewModel.CheckDump(ShowDiscInformationWindow);
+            checkTask.Wait();
+            string? errorMessage = checkTask.Result;
+#else
+        private async void OnCheckDumpClick(object sender, EventArgs e)
+        {
+            string? errorMessage = await CheckDumpViewModel.CheckDump(ShowDiscInformationWindow);
+#endif
             if (string.IsNullOrEmpty(errorMessage))
             {
                 bool? checkAgain = DisplayUserMessage("Check Complete", "The dump has been processed successfully! Would you like to check another dump?", 2, false);

MPF.UI.Core/Windows/CreateIRDWindow.xaml.cs

@@ -26,7 +26,7 @@ namespace MPF.UI.Core.Windows
 
         private Button? _InputPathBrowseButton => ItemHelper.FindChild<Button>(this, "InputPathBrowseButton");
         private TextBox? _InputPathTextBox => ItemHelper.FindChild<TextBox>(this, "InputPathTextBox");
-        
+
         private Button? _LogPathBrowseButton => ItemHelper.FindChild<Button>(this, "LogPathBrowseButton");
         private TextBox? _LogPathTextBox => ItemHelper.FindChild<TextBox>(this, "LogPathTextBox");
         private Button? _KeyPathBrowseButton => ItemHelper.FindChild<Button>(this, "KeyPathBrowseButton");
@@ -46,7 +46,15 @@ namespace MPF.UI.Core.Windows
         private System.Windows.Controls.Button? _CancelButton => ItemHelper.FindChild<System.Windows.Controls.Button>(this, "CancelButton");
 
         #endregion
-        
+
+        #region Expanders
+
+        private Expander? _KeyExpander => ItemHelper.FindChild<Expander>(this, "KeyExpander");
+        private Expander? _DiscIDExpander => ItemHelper.FindChild<Expander>(this, "DiscIDExpander");
+        private Expander? _PICExpander => ItemHelper.FindChild<Expander>(this, "PICExpander");
+
+        #endregion
+
 #endif
 
         /// <summary>
@@ -322,9 +330,15 @@ namespace MPF.UI.Core.Windows
         /// </summary>
         private void OnCreateIRDClick(object sender, EventArgs e)
         {
+#if NET35
+            if (_KeyExpander != null) _KeyExpander.IsExpanded = false;
+            if (_DiscIDExpander != null) _DiscIDExpander.IsExpanded = false;
+            if (_PICExpander != null) _PICExpander.IsExpanded = false;
+#else
             KeyExpander.IsExpanded = false;
             DiscIDExpander.IsExpanded = false;
             PICExpander.IsExpanded = false;
+#endif
             string tempStatus = CreateIRDViewModel.CreateIRDStatus;
             bool[] enabledFields = CreateIRDViewModel.DisableUIFields();
             CreateIRDViewModel.CreateIRDStatus = "Creating IRD... Please Wait";

MPF.UI.Core/Windows/DiscInformationWindow.xaml

@@ -172,6 +172,8 @@
                                     <controls:UserInput x:Name="CommentsTextBox" Label="Comments"
                                                         Text="{Binding SubmissionInfo.CommonDiscInfo.Comments, Mode=TwoWay}" TextHeight="50"
                                                         Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top" />
+                                    <controls:UserInput x:Name="CompatibleOSTextBox" Label="Compatible OS"
+                                                    Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)CompatibleOS], Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="DiscKeyTextBox" Label="Disc Key" Visibility="Collapsed"
                                                     Text="{Binding Path=SubmissionInfo.Extras.DiscKey, Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="DiscIDTextBox" Label="Disc ID" Visibility="Collapsed"
@@ -235,8 +237,12 @@
                                                         Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ActivisionID], Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="BandaiIDTextBox" Label="Bandai ID"
                                                         Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)BandaiID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="BethesdaIDTextBox" Label="Bandai ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)BethesdaID], Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="CDProjektIDTextBox" Label="CD Projekt ID"
                                                         Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)CDProjektID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="EidosIDTextBox" Label="Eidos ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)EidosID], Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="ElectronicArtsIDTextBox" Label="Electronic Arts ID"
                                                         Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ElectronicArtsID], Mode=TwoWay}"/>
                                     <controls:UserInput x:Name="FoxInteractiveIDTextBox" Label="Fox Interactive ID"
@@ -290,6 +296,11 @@
                                                 Text="{Binding SubmissionInfo.CommonDiscInfo.Contents, Mode=TwoWay}" TextHeight="50"
                                                 Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"/>
                             
+                            <!-- Applications -->
+                            <controls:UserInput x:Name="ApplicationsTextBox" Label="Applications" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Applications], Mode=TwoWay}"/>
+                            
                             <!-- Games -->
                             <controls:UserInput x:Name="GamesTextBox" Label="Games" TextHeight="50"
                                                 Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
@@ -399,6 +410,23 @@
                             <controls:UserInput x:Name="FullyMatchedID" Label="Fully Matched ID" IsReadOnly="True"
                                                 Text="{Binding SubmissionInfo.FullyMatchedID, Mode=TwoWay}"/>
                             <controls:UserInput x:Name="PartiallyMatchedIDs" Label="Partially Matched ID(s)" IsReadOnly="True"/>
+                            <controls:UserInput x:Name="HashData" Label="Hash Data" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.TracksAndWriteOffsets.ClrMameProData, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="HashDataSize" Label="Size" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.Size, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataCRC" Label="CRC-32" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.CRC32, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataMD5" Label="MD5" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.MD5, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataSHA1" Label="SHA-1" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.SHA1, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataLayerbreak1" Label="Layerbreak 1" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.Layerbreak, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataLayerbreak2" Label="Layerbreak 2" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.Layerbreak2, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="HashDataLayerbreak3" Label="Layerbreak 3" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.SizeAndChecksums.Layerbreak3, Mode=TwoWay}"/>
                             <controls:UserInput x:Name="AntiModchip" Label="Anti-Modchip" IsReadOnly="True"
                                                 Text="{Binding SubmissionInfo.CopyProtection.AntiModchip, Mode=TwoWay}"/>
                             <controls:UserInput x:Name="DiscOffset" Label="Disc Offset" IsReadOnly="True"

MPF.UI.Core/Windows/DiscInformationWindow.xaml.cs

@@ -77,6 +77,14 @@ namespace MPF.UI.Core.Windows
 
         private UserInput? _FullyMatchedID => ItemHelper.FindChild<UserInput>(this, "FullyMatchedID");
         private UserInput? _PartiallyMatchedIDs => ItemHelper.FindChild<UserInput>(this, "PartiallyMatchedIDs");
+        private UserInput? _HashData => ItemHelper.FindChild<UserInput>(this, "HashData");
+        private UserInput? _HashDataSize => ItemHelper.FindChild<UserInput>(this, "HashDataSize");
+        private UserInput? _HashDataCRC => ItemHelper.FindChild<UserInput>(this, "HashDataCRC");
+        private UserInput? _HashDataMD5 => ItemHelper.FindChild<UserInput>(this, "HashDataMD5");
+        private UserInput? _HashDataSHA1 => ItemHelper.FindChild<UserInput>(this, "HashDataSHA1");
+        private UserInput? _HashDataLayerbreak1 => ItemHelper.FindChild<UserInput>(this, "HashDataLayerbreak1");
+        private UserInput? _HashDataLayerbreak2 => ItemHelper.FindChild<UserInput>(this, "HashDataLayerbreak2");
+        private UserInput? _HashDataLayerbreak3 => ItemHelper.FindChild<UserInput>(this, "HashDataLayerbreak3");
         private UserInput? _AntiModchip => ItemHelper.FindChild<UserInput>(this, "AntiModchip");
         private UserInput? _DiscOffset => ItemHelper.FindChild<UserInput>(this, "DiscOffset");
         private UserInput? _DMIHash => ItemHelper.FindChild<UserInput>(this, "DMIHash");
@@ -295,6 +303,22 @@ namespace MPF.UI.Core.Windows
                 _PartiallyMatchedIDs!.Visibility = Visibility.Collapsed;
             else
                 _PartiallyMatchedIDs!.Text = string.Join(", ", submissionInfo.PartiallyMatchedIDs.Select(i => i.ToString()).ToArray());
+            if (string.IsNullOrEmpty(submissionInfo.TracksAndWriteOffsets?.ClrMameProData))
+                _HashData!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Size == null || submissionInfo.SizeAndChecksums.Size == 0)
+                _HashDataSize!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.CRC32))
+                _HashDataCRC!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.MD5))
+                _HashDataMD5!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.SHA1))
+                _HashDataSHA1!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak == null || submissionInfo.SizeAndChecksums.Layerbreak == 0)
+                _HashDataLayerbreak1!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak2 == null || submissionInfo.SizeAndChecksums.Layerbreak2 == 0)
+                _HashDataLayerbreak2!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak3 == null || submissionInfo.SizeAndChecksums.Layerbreak3 == 0)
+                _HashDataLayerbreak3!.Visibility = Visibility.Collapsed;
             if (submissionInfo.CopyProtection?.AntiModchip == null)
                 _AntiModchip!.Visibility = Visibility.Collapsed;
             if (submissionInfo.TracksAndWriteOffsets?.OtherWriteOffsets == null)
@@ -352,6 +376,22 @@ namespace MPF.UI.Core.Windows
                 PartiallyMatchedIDs.Visibility = Visibility.Collapsed;
             else
                 PartiallyMatchedIDs.Text = string.Join(", ", submissionInfo.PartiallyMatchedIDs.Select(i => i.ToString()).ToArray());
+            if (string.IsNullOrEmpty(submissionInfo.TracksAndWriteOffsets?.ClrMameProData))
+                HashData!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Size == null)
+                HashDataSize!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.CRC32))
+                HashDataCRC!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.MD5))
+                HashDataMD5!.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrEmpty(submissionInfo.SizeAndChecksums?.SHA1))
+                HashDataSHA1!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak == null || submissionInfo.SizeAndChecksums.Layerbreak == 0)
+                HashDataLayerbreak1!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak2 == null || submissionInfo.SizeAndChecksums.Layerbreak2 == 0)
+                HashDataLayerbreak2!.Visibility = Visibility.Collapsed;
+            if (submissionInfo.SizeAndChecksums?.Layerbreak3 == null || submissionInfo.SizeAndChecksums.Layerbreak3 == 0)
+                HashDataLayerbreak3!.Visibility = Visibility.Collapsed;
             if (submissionInfo.CopyProtection?.AntiModchip == null)
                 AntiModchip.Visibility = Visibility.Collapsed;
             if (submissionInfo.TracksAndWriteOffsets?.OtherWriteOffsets == null)
@@ -437,16 +477,16 @@ namespace MPF.UI.Core.Windows
 
 #if NET35
                     _L1Info!.Header = "Label Side";
-                    _L1MasteringRing!.Visibility = Visibility.Collapsed;
-                    _L1MasteringSID!.Visibility = Visibility.Collapsed;
-                    _L1Toolstamp!.Visibility = Visibility.Collapsed;
+                    _L1MasteringRing!.Label = "Mastering Ring";
+                    _L1MasteringSID!.Label = "Mastering SID";
+                    _L1Toolstamp!.Label = "Mastering SID";
                     _L1MouldSID!.Label = "Mould SID";
                     _L1AdditionalMould!.Label = "Additional Mould";
 #else
                     L1Info.Header = "Label Side";
-                    L1MasteringRing.Visibility = Visibility.Collapsed;
-                    L1MasteringSID.Visibility = Visibility.Collapsed;
-                    L1Toolstamp.Visibility = Visibility.Collapsed;
+                    L1MasteringRing.Label = "Mastering Ring";
+                    L1MasteringSID.Label = "Mastering SID";
+                    L1Toolstamp.Label = "Mastering SID";
                     L1MouldSID.Label = "Mould SID";
                     L1AdditionalMould.Label = "Additional Mould";
 #endif
@@ -647,16 +687,16 @@ namespace MPF.UI.Core.Windows
 
 #if NET35
                         _L1Info!.Header = "Label Side";
-                        _L1MasteringRing!.Visibility = Visibility.Collapsed;
-                        _L1MasteringSID!.Visibility = Visibility.Collapsed;
-                        _L1Toolstamp!.Visibility = Visibility.Collapsed;
+                        _L1MasteringRing!.Label = "Mastering Ring";
+                        _L1MasteringSID!.Label = "Mastering SID";
+                        _L1Toolstamp!.Label = "Toolstamp/Mastering Code";
                         _L1MouldSID!.Label = "Mould SID";
                         _L1AdditionalMould!.Label = "Additional Mould";
 #else
                         L1Info.Header = "Label Side";
-                        L1MasteringRing.Visibility = Visibility.Collapsed;
-                        L1MasteringSID.Visibility = Visibility.Collapsed;
-                        L1Toolstamp.Visibility = Visibility.Collapsed;
+                        L1MasteringRing.Label = "Mastering Ring";
+                        L1MasteringSID.Label = "Mastering SID";
+                        L1Toolstamp.Label = "Toolstamp/Mastering Code";
                         L1MouldSID.Label = "Mould SID";
                         L1AdditionalMould.Label = "Additional Mould";
 #endif

MPF.UI.Core/Windows/MainWindow.xaml

@@ -58,10 +58,6 @@
                                   Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
                                   Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
                                   Template="{DynamicResource CustomMenuItemTemplate}"
-                                  ToolTip="IRD Creation is only available on .NET Core 6 or newer."
-                                  ToolTipService.InitialShowDelay="0"
-                                  ToolTipService.IsEnabled="{Binding CannotCreateIRD}"
-                                  ToolTipService.ShowOnDisabled="True"
                                   IsEnabled="{Binding CreateIRDMenuItemEnabled}"/>
                             <MenuItem x:Name="OptionsMenuItem" Header="_Options" HorizontalAlignment="Left" Width="185"
                                   Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"

MPF.UI.Core/Windows/OptionsWindow.xaml

@@ -191,7 +191,7 @@
                 <TabItem Header="Dumping" Style="{DynamicResource CustomTabItemStyle}">
                     <StackPanel>
                         <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Dumping">
-                            <UniformGrid Columns="2" Rows="7">
+                            <UniformGrid Columns="2" Rows="8">
                                 <CheckBox VerticalAlignment="Center" Content="Show Separate Window"
                                      IsChecked="{Binding Options.ToolsInSeparateWindow}"
                                      ToolTip="Show program output in separate command window instead of in the log. Enable this if you have a weaker system as there is an increased processing load otherwise." Margin="0,4"
@@ -261,6 +261,11 @@
                                      IsChecked="{Binding Options.DeleteUnnecessaryFiles}"
                                      ToolTip="Delete unnecesary output files to reduce space" Margin="0,4"
                                      />
+
+                                <CheckBox VerticalAlignment="Center" Content="Create PS3 IRD After Dumping"
+                                     IsChecked="{Binding Options.CreateIRDAfterDumping}"
+                                     ToolTip="Automatically creates an IRD file after dumping a PS3 disc" Margin="0,4"
+                                     />
                             </UniformGrid>
                         </GroupBox>
 
@@ -365,7 +370,7 @@
                                 />
 
                                 <Label Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
-                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
                                          Text="{Binding Options.AaruRereadCount}"
                                          ToolTip="Specifies how many rereads are attempted for sector and subchannel errors"
                                 />
@@ -398,22 +403,23 @@
                                           IsChecked="{Binding Options.DICMultiSectorRead}"
                                           ToolTip="Enable the /mr flag for BD drive dumping" Margin="0,4"
                                 />
-                                <Label/>  <!-- Empty label for padding -->
+                                <Label/> 
+                                <!-- Empty label for padding -->
 
                                 <Label Content="Multi-Sector Read Value:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
-                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
                                           Text="{Binding Options.DICMultiSectorReadValue}" IsEnabled="{Binding Options.DICMultiSectorRead}"
                                           ToolTip="Set the default value for the /mr flag"
                                 />
 
                                 <Label Content="CD Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
-                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
                                           Text="{Binding Options.DICRereadCount}"
                                           ToolTip="Specifies how many rereads are attempted on C2 error [CD only]"
                                 />
 
                                 <Label Content="DVD/HD-DVD/BD Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
-                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
                                           Text="{Binding Options.DICDVDRereadCount}"
                                           ToolTip="Specifies how many rereads are attempted on read error [DVD/HD-DVD/BD only]"
                                 />
@@ -421,7 +427,7 @@
                         </GroupBox>
 
                         <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Redumper">
-                            <UniformGrid Columns="2" Rows="3">
+                            <UniformGrid Columns="2" Rows="7">
                                 <CheckBox VerticalAlignment="Center" Content="Enable Debug Output"
                                           IsChecked="{Binding Options.RedumperEnableDebug}"
                                           ToolTip="Enable debug output in logs" Margin="0,4"
@@ -432,20 +438,45 @@
                                           ToolTip="Enable verbose output in logs" Margin="0,4"
                                 />
 
-                                <CheckBox VerticalAlignment="Center" Content="Enable BE Drive Reading"
-                                          IsChecked="{Binding Options.RedumperUseBEReading}"
-                                          ToolTip="Enable setting drive read method to BE_CDDA by default" Margin="0,4"
+                                <Label Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
+                                         Text="{Binding Options.RedumperRereadCount}"
+                                         ToolTip="Specifies how many rereads are attempted on read error"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Set Default Plextor Lead-in Retries"
+                                          IsChecked="{Binding Options.RedumperEnableLeadinRetry}"
+                                          ToolTip="Enable custom lead-in retries for Plextor drives" Margin="0,4"
+                                />
+                                <Label/>
+                                <!-- Empty label for padding -->
+
+                                <Label Content="Plextor Lead-in Retries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center" Width="200" HorizontalAlignment="Left"
+                                         Text="{Binding Options.RedumperLeadinRetryCount}" IsEnabled ="{Binding Options.RedumperEnableLeadinRetry}"
+                                         ToolTip="Specifies how many retries are attempted for lead-in on Plextor drives"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Non-Redump Options" Click="NonRedumpModeClicked"
+                                          IsChecked="{Binding Options.RedumperNonRedumpMode}"
+                                          ToolTip="Enable non-redump options" Margin="0,4"
                                 />
 
                                 <CheckBox VerticalAlignment="Center" Content="Set Generic Drive Type"
-                                          IsChecked="{Binding Options.RedumperUseGenericDriveType}"
+                                          IsChecked="{Binding Options.RedumperUseGenericDriveType}" IsEnabled="{Binding Options.RedumperNonRedumpMode}"
                                           ToolTip="Enable setting drive type to Generic by default" Margin="0,4"
                                 />
 
-                                <Label Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
-                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
-                                         Text="{Binding Options.RedumperRereadCount}"
-                                          ToolTip="Specifies how many rereads are attempted on read error"
+                                <Label VerticalAlignment="Center" Content="Default Read Method:" HorizontalAlignment="Right" />
+                                <ComboBox x:Name="DefaultRedumperReadMethodComboBox" Height="22" Width="200" HorizontalAlignment="Left"
+                                          ItemsSource="{Binding RedumperReadMethods}" SelectedItem="{Binding Options.RedumperReadMethod, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                          Style="{DynamicResource CustomComboBoxStyle}" IsEnabled="{Binding Options.RedumperNonRedumpMode}"
+                                />
+
+                                <Label VerticalAlignment="Center" Content="Default Sector Order:" HorizontalAlignment="Right" />
+                                <ComboBox x:Name="DefaultRedumperSectorOrderComboBox" Height="22" Width="200" HorizontalAlignment="Left"
+                                          ItemsSource="{Binding RedumperSectorOrders}" SelectedItem="{Binding Options.RedumperSectorOrder, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                          Style="{DynamicResource CustomComboBoxStyle}" IsEnabled="{Binding Options.RedumperNonRedumpMode}"
                                 />
                             </UniformGrid>
                         </GroupBox>

MPF.UI.Core/Windows/OptionsWindow.xaml.cs

@@ -214,7 +214,7 @@ namespace MPF.UI.Core.Windows
                 CustomMessageBox.Show(this, message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
         }
 
-#endregion
+        #endregion
 
         #region Event Handlers
 
@@ -224,6 +224,17 @@ namespace MPF.UI.Core.Windows
         private void BrowseForPathClick(object sender, EventArgs e) =>
             BrowseForPath(this, sender as System.Windows.Controls.Button);
 
+        /// <summary>
+        /// Alert user of non-redump mode implications
+        /// </summary>
+        private void NonRedumpModeClicked(object sender, EventArgs e)
+        {
+            if (OptionsViewModel.Options.RedumperNonRedumpMode)
+                CustomMessageBox.Show(this, "All logs generated with these options will not be acceptable for Redump submission", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
+            else
+                OptionsViewModel.NonRedumpModeUnChecked();
+        }
+
         /// <summary>
         /// Handler for AcceptButton Click event
         /// </summary>

MPF.sln

@@ -13,9 +13,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		appveyor.yml = appveyor.yml
 		CHANGELIST.md = CHANGELIST.md
-		.github\ISSUE_TEMPLATE\feature-request.md = .github\ISSUE_TEMPLATE\feature-request.md
-		.github\ISSUE_TEMPLATE\informational.md = .github\ISSUE_TEMPLATE\informational.md
-		.github\ISSUE_TEMPLATE\issue-report.md = .github\ISSUE_TEMPLATE\issue-report.md
 		publish-nix.sh = publish-nix.sh
 		publish-win.ps1 = publish-win.ps1
 		README.md = README.md
@@ -27,6 +24,20 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.UI.Core", "MPF.UI.Core\
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MPF", "MPF", "{4160167D-681D-480B-ABC6-06AC869E5769}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ISSUE_TEMPLATE", "ISSUE_TEMPLATE", "{ADC5FDD7-F43F-4F9C-B222-19AA1D64D3D4}"
+	ProjectSection(SolutionItems) = preProject
+		.github\ISSUE_TEMPLATE\feature-request.md = .github\ISSUE_TEMPLATE\feature-request.md
+		.github\ISSUE_TEMPLATE\informational.md = .github\ISSUE_TEMPLATE\informational.md
+		.github\ISSUE_TEMPLATE\issue-report.md = .github\ISSUE_TEMPLATE\issue-report.md
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{440776E0-E6E2-46C6-8E85-09E64A8FC7D6}"
+	ProjectSection(SolutionItems) = preProject
+		.github\workflows\build_check.yml = .github\workflows\build_check.yml
+		.github\workflows\build_ui.yml = .github\workflows\build_ui.yml
+		.github\workflows\check_pr.yml = .github\workflows\check_pr.yml
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -63,6 +74,8 @@ Global
 		{8CFDE289-E171-4D49-A40D-5293265C1253} = {4160167D-681D-480B-ABC6-06AC869E5769}
 		{70B1265D-FE49-472A-A83D-0B462152D37A} = {4160167D-681D-480B-ABC6-06AC869E5769}
 		{EA3768DB-694A-4653-82E4-9FF71B8963F3} = {4160167D-681D-480B-ABC6-06AC869E5769}
+		{ADC5FDD7-F43F-4F9C-B222-19AA1D64D3D4} = {4D1DCF5A-F0B0-4E81-A05B-F1A7D37C9D9D}
+		{440776E0-E6E2-46C6-8E85-09E64A8FC7D6} = {4D1DCF5A-F0B0-4E81-A05B-F1A7D37C9D9D}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {73C62E6A-6584-4D93-83B5-ECB1FBDB469B}

MPF/MPF.csproj

@@ -2,20 +2,21 @@
 
   <PropertyGroup>
     <!-- Assembly Properties -->
-    <TargetFrameworks>net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0-windows;net6.0-windows;net7.0-windows;net8.0-windows</TargetFrameworks>
+    <TargetFrameworks>net40;net452;net462;net472;net48;netcoreapp3.1;net5.0-windows;net6.0-windows;net7.0-windows;net8.0-windows</TargetFrameworks>
     <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
     <OutputType>WinExe</OutputType>
     <ApplicationIcon>Images\Icon.ico</ApplicationIcon>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
     <ImportFrameworkWinFXTargets Condition="$(TargetFramework.StartsWith(`net3`))">true</ImportFrameworkWinFXTargets>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <VersionPrefix>3.1.1</VersionPrefix>
     <UseWindowsForms>true</UseWindowsForms>
     <UseWPF>true</UseWPF>
+    <VersionPrefix>3.1.9</VersionPrefix>
 
     <!-- Package Properties -->
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
@@ -69,10 +70,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.0.2" GeneratePathProperty="true">
+    <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.12" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.8" />
   </ItemGroup>
 
   <ItemGroup>

README.md

@@ -2,7 +2,9 @@
 
 Redumper/Aaru/DiscImageCreator UI in C#
 
-[![Build status](https://ci.appveyor.com/api/projects/status/3ldav3v0c373jeqa?svg=true)](https://ci.appveyor.com/project/mnadareski/MPF/build/artifacts)
+[![Build status](https://ci.appveyor.com/api/projects/status/3ldav3v0c373jeqa?svg=true)](https://ci.appveyor.com/project/mnadareski/MPF)
+[![UI Build](https://github.com/SabreTools/MPF/actions/workflows/build_ui.yml/badge.svg)](https://github.com/SabreTools/MPF/actions/workflows/build_ui.yml)
+[![Check Build](https://github.com/SabreTools/MPF/actions/workflows/build_check.yml/badge.svg)](https://github.com/SabreTools/MPF/actions/workflows/build_check.yml)
 
 This is a community project, so if you have some time and knowledge to give, we'll be glad to add you as a contributor to this project. If you have any suggestions, issues, bugs, or crashes, please look at the [Issues](https://github.com/SabreTools/MPF/issues) page first to see if it has been reported before and try out the latest AppVeyor WIP build below to see if it has already been addressed. If it hasn't, please open an issue that's as descriptive as you can be. Help me make this a better program for everyone :)
 
@@ -10,7 +12,7 @@ This is a community project, so if you have some time and knowledge to give, we'
 
 For the most recent stable build, download the latest release here: [Releases Page](https://github.com/SabreTools/MPF/releases)
 
-For the latest AppVeyor WIP build here: [AppVeyor](https://ci.appveyor.com/project/mnadareski/MPF/build/artifacts)
+For the latest WIP build here: [Rolling Release](https://github.com/SabreTools/MPF/releases/tag/rolling)
 
 ## Media Preservation Frontend UI (MPF)
 
@@ -24,6 +26,11 @@ The main UI has some known limitations that are documented in code and in some p
   - MAUI is not a viable alternative due to lack of out-of-box support for Linux
   - Avalonia is being heavily considered as an alternative
 - For those who need .NET Framework 4.8, there is an official fork: [MPF Legacy](https://github.com/Deterous/MPF-Legacy)
+- For those who require broader archive/installer compatibility for protection scanning (Windows-only), please use the x86 builds as there are some specific scanning libraries that only work with that build
+  - This is actively being worked on as part of [Binary Object Scanner](https://github.com/SabreTools/BinaryObjectScanner)
+  - Please consider contributing if you have experience in dealing with multiple archive and installer types
+  - Consider using a third-party scanning tool, such as Protection ID, if this is not sufficient for your needs
+  - See [Compatibility Notes](https://github.com/SabreTools/BinaryObjectScanner?tab=readme-ov-file#compatibility-notes) for more details
 
 ## Media Preservation Frontend Checker (MPF.Check)
 
@@ -33,8 +40,6 @@ MPF.Check is a commandline-only program that allows users to generate submission
 
 Both MPF UI and MPF.Check have the same system requirements for running, with the exception that MPF UI is Windows-only.
 
-- [Supported OS versions for .NET 6](https://github.com/dotnet/core/blob/main/release-notes/6.0/supported-os.md)
-  - Requires [.NET 6.0 Runtime](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) if built without bundled runtime
 - [Supported OS versions for .NET 8](https://github.com/dotnet/core/blob/main/release-notes/8.0/supported-os.md)
   - Requires [.NET 8.0 Runtime](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) if built without bundled runtime
 
@@ -42,30 +47,28 @@ Ensure that your operating system and runtimes are as up-to-date as possible, si
 
 ## Build Instructions
 
-To build for .NET 6.0 or .NET 8.0, ensure that the [.NET 8.0 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) (or later) is installed and included in your `PATH`. Then, run the following commands from command prompt, Powershell, Terminal, or shell:
+To build for .NET 8.0, ensure that the [.NET 8.0 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) (or later) is installed and included in your `PATH`. Then, run the following commands from command prompt, Powershell, Terminal, or shell:
 
 **MPF UI (Windows only):**
 
 ```bash
-dotnet build MPF/MPF.csproj --framework [net6.0-windows|net8.0-windows] --runtime win-x64
+dotnet build MPF/MPF.csproj --framework net8.0-windows --runtime [win-x86|win-x64]
 ```
 
 **MPF.Check (Windows, OSX, Linux):**
 
 ```bash
-dotnet build MPF.Check/MPF.Check.csproj --framework [net6.0|net8.0] --runtime [win-x64|linux-x64|osx-x64]
+dotnet build MPF.Check/MPF.Check.csproj --framework net8.0 --runtime [win-x86|win-x64|linux-x64|osx-x64]
 ```
 
-Choose one of `win-x64`, `linux-x64`, or `osx-x64` depending on the machine you are targeting.
+Choose one of `win-x86`, `win-x64`, `linux-x64`, or `osx-x64` depending on the machine you are targeting.
 
 ### Build Scripts
 
-Windows users may run `publish-win.ps1` and Linux users may run `publish-nix.sh` to perform a full release build.
+Windows users may run `publish-win.ps1` and Linux users may run `publish-nix.sh` to perform a full release build. Both scripts will build and package all variants of MPF UI and MPF.Check with commandline switches to control what is included.
 
-- `publish-win.ps1` will build and package all variants of MPF UI and MPF.Check
-  - The script requires [7-zip commandline](https://www.7-zip.org/download.html) and [Git for Windows](https://git-scm.com/downloads) to be installed and in `PATH`
-- `publish-nix.sh` will _only_ build and package all variants of MPF.Check
-  - The script requires `zip` and `git` to be installed and in `PATH`
+- `publish-win.ps1` requires [7-zip commandline](https://www.7-zip.org/download.html) and [Git for Windows](https://git-scm.com/downloads) to be installed and in `PATH`
+- `publish-nix.sh` requires `zip` and `git` to be installed and in `PATH`
 
 ## Information
 
@@ -79,7 +82,7 @@ A list of all changes in each stable release and current WIP builds can now be f
 
 MPF uses some external libraries to assist with additional information gathering after the dumping process.
 
-- **BinaryObjectScanner** - Protection scanning - [GitHub](https://github.com/SabreTools/BinaryObjectScanner)
+- **Binary Object Scanner** - Protection scanning - [GitHub](https://github.com/SabreTools/BinaryObjectScanner)
 - **WPFCustomMessageBox.thabse** - Custom message boxes in UI - [GitHub](https://github.com/thabse/WPFCustomMessageBox)
 
 ## Contributors

appveyor.yml

@@ -1,5 +1,5 @@
 # version format
-version: 3.1.1-{build}
+version: 3.1.9-{build}
 
 # pull request template
 pull_requests:
@@ -10,46 +10,7 @@ image: Visual Studio 2022
 
 # build step
 build_script:
-  - dotnet restore
-
-  # .NET 8.0 Debug
-  - dotnet publish MPF\MPF.csproj -f net8.0-windows -r win-x64 -c Debug --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r win-x64 -c Debug --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r linux-x64 -c Debug --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r osx-x64 -c Debug --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true
-
-  # .NET 8.0 Release
-  - dotnet publish MPF\MPF.csproj -f net8.0-windows -r win-x64 -c Release --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r win-x64 -c Release --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r linux-x64 -c Release --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-  - dotnet publish MPF.Check\MPF.Check.csproj -f net8.0 -r osx-x64 -c Release --self-contained true --version-suffix %APPVEYOR_REPO_COMMIT% -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-
-# post-build step
-after_build:
-
-# Aaru
-- ps: appveyor DownloadFile https://github.com/aaru-dps/Aaru/releases/download/v5.3.2/aaru-5.3.2_windows_x64.zip
-- 7z x aaru-5.3.2_windows_x64.zip -oMPF\bin\Debug\net8.0-windows\win-x64\publish\Programs\Aaru *
-
-# DiscImageCreator
-- ps: appveyor DownloadFile https://github.com/saramibreak/DiscImageCreator/files/11660558/DiscImageCreator_20230606.zip
-- 7z e DiscImageCreator_20230606.zip -oMPF\bin\Debug\net8.0-windows\win-x64\publish\Programs\Creator Release_ANSI\*
-
-# Redumper
-- ps: appveyor DownloadFile https://github.com/superg/redumper/releases/download/build_311/redumper-2024.01.08_build311-win64.zip
-- 7z e redumper-2024.01.08_build311-win64.zip -oMPF\bin\Debug\net8.0-windows\win-x64\publish\Programs\Redumper redumper-2024.01.08_build311-win64\bin\*
-
-# Create MPF Debug archives
-- cd %APPVEYOR_BUILD_FOLDER%\MPF\bin\Debug\net8.0-windows\win-x64\publish\
-- 7z a -tzip %APPVEYOR_BUILD_FOLDER%\MPF_%APPVEYOR_BUILD_NUMBER%_net8.0_win-x64_debug.zip *
-
-# Create MPF.Check Debug archives
-- cd %APPVEYOR_BUILD_FOLDER%\MPF.Check\bin\Debug\net8.0\win-x64\publish\
-- 7z a -tzip %APPVEYOR_BUILD_FOLDER%\MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_win-x64_debug.zip *
-- cd %APPVEYOR_BUILD_FOLDER%\MPF.Check\bin\Debug\net8.0\linux-x64\publish\
-- 7z a -tzip %APPVEYOR_BUILD_FOLDER%\MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_linux-x64_debug.zip *
-- cd %APPVEYOR_BUILD_FOLDER%\MPF.Check\bin\Debug\net8.0\osx-x64\publish\
-- 7z a -tzip %APPVEYOR_BUILD_FOLDER%\MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_osx-x64_debug.zip *
+  - dotnet build
 
 # success/failure tracking
 on_success:
@@ -57,16 +18,4 @@ on_success:
   - ps: ./send.ps1 success $env:WEBHOOK_URL
 on_failure:
   - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
-  - ps: ./send.ps1 failure $env:WEBHOOK_URL
-
-# artifact linking
-artifacts:
-- path: MPF_%APPVEYOR_BUILD_NUMBER%_net8.0_win-x64_debug.zip
-  name: MPF (.NET 8.0, Debug, Windows x64)
-
-- path: MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_win-x64_debug.zip
-  name: MPF.Check (.NET 8.0, Debug, Windows x64)
-- path: MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_linux-x64_debug.zip
-  name: MPF.Check (.NET 8.0, Debug, Linux x64)
-- path: MPF.Check_%APPVEYOR_BUILD_NUMBER%_net8.0_osx-x64_debug.zip
-  name: MPF.Check (.NET 8.0, Debug, OSX x64)
+  - ps: ./send.ps1 failure $env:WEBHOOK_URL

publish-nix.sh

@@ -15,9 +15,8 @@ USE_ALL=false
 INCLUDE_PROGRAMS=false
 NO_BUILD=false
 NO_ARCHIVE=false
-while getopts "upba" OPTION
-do
-    case $OPTION in 
+while getopts "upba" OPTION; do
+    case $OPTION in
     u)
         USE_ALL=true
         ;;
@@ -41,17 +40,16 @@ done
 BUILD_FOLDER=$PWD
 
 # Set the current commit hash
-COMMIT=`git log --pretty=%H -1`
+COMMIT=$(git log --pretty=%H -1)
 
 # Create the build matrix arrays
 UI_FRAMEWORKS=("net8.0-windows")
-UI_RUNTIMES=("win-x64")
+UI_RUNTIMES=("win-x86" "win-x64")
 CHECK_FRAMEWORKS=("net8.0")
-CHECK_RUNTIMES=("win-x64" "linux-x64" "osx-x64")
+CHECK_RUNTIMES=("win-x86" "win-x64" "linux-x64" "osx-x64")
 
 # Use expanded lists, if requested
-if [ $USE_ALL = true ]
-then
+if [ $USE_ALL = true ]; then
     UI_FRAMEWORKS=("net40" "net452" "net462" "net472" "net48" "netcoreapp3.1" "net5.0-windows" "net6.0-windows" "net7.0-windows" "net8.0-windows")
     UI_RUNTIMES=("win-x86" "win-x64")
     CHECK_FRAMEWORKS=("net20" "net35" "net40" "net452" "net462" "net472" "net48" "netcoreapp3.1" "net5.0" "net6.0" "net7.0" "net8.0")
@@ -64,50 +62,60 @@ VALID_CROSS_PLATFORM_FRAMEWORKS=("netcoreapp3.1" "net5.0" "net6.0" "net7.0" "net
 VALID_CROSS_PLATFORM_RUNTIMES=("win-arm64" "linux-x64" "linux-arm64" "osx-x64")
 
 # Only build if requested
-if [ $NO_BUILD = false ]
-then
+if [ $NO_BUILD = false ]; then
     # Restore Nuget packages for all builds
     echo "Restoring Nuget packages"
     dotnet restore
 
     # Build UI
-    for FRAMEWORK in "${UI_FRAMEWORKS[@]}"
-    do
-        for RUNTIME in "${UI_RUNTIMES[@]}"
-        do
+    for FRAMEWORK in "${UI_FRAMEWORKS[@]}"; do
+        for RUNTIME in "${UI_RUNTIMES[@]}"; do
+            # If we have an invalid combination of framework and runtime
+            if [[ ! $(echo ${VALID_CROSS_PLATFORM_FRAMEWORKS[@]} | fgrep -w $FRAMEWORK) ]]; then
+                if [[ $(echo ${VALID_CROSS_PLATFORM_RUNTIMES[@]} | fgrep -w $RUNTIME) ]]; then
+                    continue
+                fi
+            fi
+
             # Only .NET 5 and above can publish to a single file
-            if [[ $(echo ${SINGLE_FILE_CAPABLE[@]} | fgrep -w $FRAMEWORK) ]]
-            then
-                dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+            if [[ $(echo ${SINGLE_FILE_CAPABLE[@]} | fgrep -w $FRAMEWORK) ]]; then
+                # Only include Debug if building all
+                if [ $USE_ALL = true ]; then
+                    dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+                fi
                 dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
             else
-                dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                # Only include Debug if building all
+                if [ $USE_ALL = true ]; then
+                    dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                fi
                 dotnet publish MPF/MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
             fi
         done
     done
 
     # Build Check
-    for FRAMEWORK in "${CHECK_FRAMEWORKS[@]}"
-    do
-        for RUNTIME in "${CHECK_RUNTIMES[@]}"
-        do
+    for FRAMEWORK in "${CHECK_FRAMEWORKS[@]}"; do
+        for RUNTIME in "${CHECK_RUNTIMES[@]}"; do
             # If we have an invalid combination of framework and runtime
-            if [[ ! $(echo ${VALID_CROSS_PLATFORM_FRAMEWORKS[@]} | fgrep -w $FRAMEWORK) ]]
-            then
-                if [[ $(echo ${VALID_CROSS_PLATFORM_RUNTIMES[@]} | fgrep -w $RUNTIME) ]]
-                then
+            if [[ ! $(echo ${VALID_CROSS_PLATFORM_FRAMEWORKS[@]} | fgrep -w $FRAMEWORK) ]]; then
+                if [[ $(echo ${VALID_CROSS_PLATFORM_RUNTIMES[@]} | fgrep -w $RUNTIME) ]]; then
                     continue
                 fi
             fi
 
             # Only .NET 5 and above can publish to a single file
-            if [[ $(echo ${SINGLE_FILE_CAPABLE[@]} | fgrep -w $FRAMEWORK) ]]
-            then
-                dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+            if [[ $(echo ${SINGLE_FILE_CAPABLE[@]} | fgrep -w $FRAMEWORK) ]]; then
+                # Only include Debug if building all
+                if [ $USE_ALL = true ]; then
+                    dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+                fi
                 dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
             else
-                dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                # Only include Debug if building all
+                if [ $USE_ALL = true ]; then
+                    dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                fi
                 dotnet publish MPF.Check/MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
             fi
         done
@@ -115,50 +123,43 @@ then
 fi
 
 # Only create archives if requested
-if [ $NO_ARCHIVE = false ]
-then
+if [ $NO_ARCHIVE = false ]; then
     # Create UI archives
-    for FRAMEWORK in "${UI_FRAMEWORKS[@]}"
-    do
-        echo "Framework: $FRAMEWORK"
-        for RUNTIME in "${UI_RUNTIMES[@]}"
-        do
-            echo "Runtime: $RUNTIME"
-            cd $BUILD_FOLDER/MPF/bin/Debug/${FRAMEWORK}/${RUNTIME}/publish/
-            echo "PWD: $PWD"
-            if [ $INCLUDE_PROGRAMS = true ]
-            then
-                zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_debug.zip .
-            else
-                zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_debug.zip . -x 'Programs/\*'
+    for FRAMEWORK in "${UI_FRAMEWORKS[@]}"; do
+        for RUNTIME in "${UI_RUNTIMES[@]}"; do
+            # Only include Debug if building all
+            if [ $USE_ALL = true ]; then
+                cd $BUILD_FOLDER/MPF/bin/Debug/${FRAMEWORK}/${RUNTIME}/publish/
+                if [ $INCLUDE_PROGRAMS = true ]; then
+                    zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_debug.zip .
+                else
+                    zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_debug.zip . -x 'Programs/\*'
+                fi
             fi
             cd $BUILD_FOLDER/MPF/bin/Release/${FRAMEWORK}/${RUNTIME}/publish/
-            echo "PWD: $PWD"
-            if [ $INCLUDE_PROGRAMS = true ]
-            then
+            if [ $INCLUDE_PROGRAMS = true ]; then
                 zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_release.zip .
             else
-                zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_release.zip . -x 'Programs/\*' 
+                zip -r $BUILD_FOLDER/MPF_${FRAMEWORK}_${RUNTIME}_release.zip . -x 'Programs/\*'
             fi
         done
     done
 
     # Create Check archives
-    for FRAMEWORK in "${CHECK_FRAMEWORKS[@]}"
-    do
-        for RUNTIME in "${CHECK_RUNTIMES[@]}"
-        do
+    for FRAMEWORK in "${CHECK_FRAMEWORKS[@]}"; do
+        for RUNTIME in "${CHECK_RUNTIMES[@]}"; do
             # If we have an invalid combination of framework and runtime
-            if [[ ! $(echo ${VALID_CROSS_PLATFORM_FRAMEWORKS[@]} | fgrep -w $FRAMEWORK) ]]
-            then
-                if [[ $(echo ${VALID_CROSS_PLATFORM_RUNTIMES[@]} | fgrep -w $RUNTIME) ]]
-                then
+            if [[ ! $(echo ${VALID_CROSS_PLATFORM_FRAMEWORKS[@]} | fgrep -w $FRAMEWORK) ]]; then
+                if [[ $(echo ${VALID_CROSS_PLATFORM_RUNTIMES[@]} | fgrep -w $RUNTIME) ]]; then
                     continue
                 fi
             fi
 
-            cd $BUILD_FOLDER/MPF.Check/bin/Debug/${FRAMEWORK}/${RUNTIME}/publish/
-            zip -r $BUILD_FOLDER/MPF.Check_${FRAMEWORK}_${RUNTIME}_debug.zip .
+            # Only include Debug if building all
+            if [ $USE_ALL = true ]; then
+                cd $BUILD_FOLDER/MPF.Check/bin/Debug/${FRAMEWORK}/${RUNTIME}/publish/
+                zip -r $BUILD_FOLDER/MPF.Check_${FRAMEWORK}_${RUNTIME}_debug.zip .
+            fi
             cd $BUILD_FOLDER/MPF.Check/bin/Release/${FRAMEWORK}/${RUNTIME}/publish/
             zip -r $BUILD_FOLDER/MPF.Check_${FRAMEWORK}_${RUNTIME}_release.zip .
         done
@@ -166,4 +167,4 @@ then
 
     # Reset the directory
     cd $BUILD_FOLDER
-fi
+fi

publish-win.ps1

@@ -14,15 +14,15 @@ param(
     [Alias("UseAll")]
     [switch]$USE_ALL,
 
-	[Parameter(Mandatory = $false)]
+    [Parameter(Mandatory = $false)]
     [Alias("IncludePrograms")]
     [switch]$INCLUDE_PROGRAMS,
 
-	[Parameter(Mandatory = $false)]
+    [Parameter(Mandatory = $false)]
     [Alias("NoBuild")]
     [switch]$NO_BUILD,
 
-	[Parameter(Mandatory = $false)]
+    [Parameter(Mandatory = $false)]
     [Alias("NoArchive")]
     [switch]$NO_ARCHIVE
 )
@@ -35,13 +35,12 @@ $COMMIT = git log --pretty=format:"%H" -1
 
 # Create the build matrix arrays
 $UI_FRAMEWORKS = @('net8.0-windows')
-$UI_RUNTIMES = @('win-x64')
+$UI_RUNTIMES = @('win-x86', 'win-x64')
 $CHECK_FRAMEWORKS = @('net8.0')
-$CHECK_RUNTIMES = @('win-x64', 'linux-x64', 'osx-x64')
+$CHECK_RUNTIMES = @('win-x86', 'win-x64', 'linux-x64', 'osx-x64')
 
 # Use expanded lists, if requested
-if ($USE_ALL.IsPresent)
-{
+if ($USE_ALL.IsPresent) {
     $UI_FRAMEWORKS = @('net40', 'net452', 'net462', 'net472', 'net48', 'netcoreapp3.1', 'net5.0-windows', 'net6.0-windows', 'net7.0-windows', 'net8.0-windows')
     $UI_RUNTIMES = @('win-x86', 'win-x64')
     $CHECK_FRAMEWORKS = @('net20', 'net35', 'net40', 'net452', 'net462', 'net472', 'net48', 'netcoreapp3.1', 'net5.0', 'net6.0', 'net7.0', 'net8.0')
@@ -54,104 +53,108 @@ $VALID_CROSS_PLATFORM_FRAMEWORKS = @('netcoreapp3.1', 'net5.0', 'net6.0', 'net7.
 $VALID_CROSS_PLATFORM_RUNTIMES = @('win-arm64', 'linux-x64', 'linux-arm64', 'osx-x64')
 
 # Only build if requested
-if (!$NO_BUILD.IsPresent)
-{
-	# Restore Nuget packages for all builds
-	Write-Host "Restoring Nuget packages"
-	dotnet restore
+if (!$NO_BUILD.IsPresent) {
+    # Restore Nuget packages for all builds
+    Write-Host "Restoring Nuget packages"
+    dotnet restore
 
-	# Build UI
-	foreach ($FRAMEWORK in $UI_FRAMEWORKS)
-	{
-		foreach ($RUNTIME in $UI_RUNTIMES)
-		{
-			# Only .NET 5 and above can publish to a single file
-			if ($SINGLE_FILE_CAPABLE -contains $FRAMEWORK)
-			{
-				dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
-				dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-			}
-			else
-			{
-				dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
-				dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
-			}
-		}
-	}
+    # Build UI
+    foreach ($FRAMEWORK in $UI_FRAMEWORKS) {
+        foreach ($RUNTIME in $UI_RUNTIMES) {
+            # If we have an invalid combination of framework and runtime
+            if ($VALID_CROSS_PLATFORM_FRAMEWORKS -notcontains $FRAMEWORK -and $VALID_CROSS_PLATFORM_RUNTIMES -contains $RUNTIME) {
+                continue
+            }
 
-	# Build Check
-	foreach ($FRAMEWORK in $CHECK_FRAMEWORKS)
-	{
-		foreach ($RUNTIME in $CHECK_RUNTIMES)
-		{
-			# If we have an invalid combination of framework and runtime
-			if ($VALID_CROSS_PLATFORM_FRAMEWORKS -notcontains $FRAMEWORK -and $VALID_CROSS_PLATFORM_RUNTIMES -contains $RUNTIME)
-			{
-				continue
-			}
+            # Only .NET 5 and above can publish to a single file
+            if ($SINGLE_FILE_CAPABLE -contains $FRAMEWORK) {
+                # Only include Debug if building all
+                if ($USE_ALL.IsPresent) {
+                    dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+                }
+                dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
+            }
+            else {
+                # Only include Debug if building all
+                if ($USE_ALL.IsPresent) {
+                    dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                }
+                dotnet publish MPF\MPF.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
+            }
+        }
+    }
 
-			# Only .NET 5 and above can publish to a single file
-			if ($SINGLE_FILE_CAPABLE -contains $FRAMEWORK)
-			{
-				dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
-				dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
-			}
-			else
-			{
-				dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
-				dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
-			}
-		}
-	}
+    # Build Check
+    foreach ($FRAMEWORK in $CHECK_FRAMEWORKS) {
+        foreach ($RUNTIME in $CHECK_RUNTIMES) {
+            # If we have an invalid combination of framework and runtime
+            if ($VALID_CROSS_PLATFORM_FRAMEWORKS -notcontains $FRAMEWORK -and $VALID_CROSS_PLATFORM_RUNTIMES -contains $RUNTIME) {
+                continue
+            }
+
+            # Only .NET 5 and above can publish to a single file
+            if ($SINGLE_FILE_CAPABLE -contains $FRAMEWORK) {
+                # Only include Debug if building all
+                if ($USE_ALL.IsPresent) {
+                    dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true
+                }
+                dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:PublishSingleFile=true -p:DebugType=None -p:DebugSymbols=false
+            }
+            else {
+                # Only include Debug if building all
+                if ($USE_ALL.IsPresent) {
+                    dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Debug --self-contained true --version-suffix $COMMIT
+                }
+                dotnet publish MPF.Check\MPF.Check.csproj -f $FRAMEWORK -r $RUNTIME -c Release --self-contained true --version-suffix $COMMIT -p:DebugType=None -p:DebugSymbols=false
+            }
+        }
+    }
 }
 
 # Only create archives if requested
-if (!$NO_ARCHIVE.IsPresent)
-{
-	# Create UI archives
-	foreach ($FRAMEWORK in $UI_FRAMEWORKS)
-	{
-		foreach ($RUNTIME in $UI_RUNTIMES)
-		{
-			Set-Location -Path $BUILD_FOLDER\MPF\bin\Debug\${FRAMEWORK}\${RUNTIME}\publish\
-			if ($INCLUDE_PROGRAMS.IsPresent)
-			{
-				7z a -tzip $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_debug.zip *
-			}
-			else
-			{
-				7z a -tzip -x!Programs\* $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_debug.zip *
-			}
-			Set-Location -Path $BUILD_FOLDER\MPF\bin\Release\${FRAMEWORK}\${RUNTIME}\publish\
-			if ($INCLUDE_PROGRAMS.IsPresent)
-			{
-				7z a -tzip $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_release.zip *
-			}
-			else
-			{
-				7z a -tzip -x!Programs\* $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_release.zip *
-			}
-		}
-	}
+if (!$NO_ARCHIVE.IsPresent) {
+    # Create UI archives
+    foreach ($FRAMEWORK in $UI_FRAMEWORKS) {
+        foreach ($RUNTIME in $UI_RUNTIMES) {
+            # Only include Debug if building all
+            if ($USE_ALL.IsPresent) {
+                Set-Location -Path $BUILD_FOLDER\MPF\bin\Debug\${FRAMEWORK}\${RUNTIME}\publish\
+                if ($INCLUDE_PROGRAMS.IsPresent) {
+                    7z a -tzip $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_debug.zip *
+                }
+                else {
+                    7z a -tzip -x!Programs\* $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_debug.zip *
+                }
+            }
+            
+            Set-Location -Path $BUILD_FOLDER\MPF\bin\Release\${FRAMEWORK}\${RUNTIME}\publish\
+            if ($INCLUDE_PROGRAMS.IsPresent) {
+                7z a -tzip $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_release.zip *
+            }
+            else {
+                7z a -tzip -x!Programs\* $BUILD_FOLDER\MPF_${FRAMEWORK}_${RUNTIME}_release.zip *
+            }
+        }
+    }
 
-	# Create Check archives
-	foreach ($FRAMEWORK in $CHECK_FRAMEWORKS)
-	{
-		foreach ($RUNTIME in $CHECK_RUNTIMES)
-		{
-			# If we have an invalid combination of framework and runtime
-			if ($VALID_CROSS_PLATFORM_FRAMEWORKS -notcontains $FRAMEWORK -and $VALID_CROSS_PLATFORM_RUNTIMES -contains $RUNTIME)
-			{
-				continue
-			}
+    # Create Check archives
+    foreach ($FRAMEWORK in $CHECK_FRAMEWORKS) {
+        foreach ($RUNTIME in $CHECK_RUNTIMES) {
+            # If we have an invalid combination of framework and runtime
+            if ($VALID_CROSS_PLATFORM_FRAMEWORKS -notcontains $FRAMEWORK -and $VALID_CROSS_PLATFORM_RUNTIMES -contains $RUNTIME) {
+                continue
+            }
 
-			Set-Location -Path $BUILD_FOLDER\MPF.Check\bin\Debug\${FRAMEWORK}\${RUNTIME}\publish\
-			7z a -tzip $BUILD_FOLDER\MPF.Check_${FRAMEWORK}_${RUNTIME}_debug.zip *
-			Set-Location -Path $BUILD_FOLDER\MPF.Check\bin\Release\${FRAMEWORK}\${RUNTIME}\publish\
-			7z a -tzip $BUILD_FOLDER\MPF.Check_${FRAMEWORK}_${RUNTIME}_release.zip *
-		}
-	}
+            # Only include Debug if building all
+            if ($USE_ALL.IsPresent) {
+                Set-Location -Path $BUILD_FOLDER\MPF.Check\bin\Debug\${FRAMEWORK}\${RUNTIME}\publish\
+                7z a -tzip $BUILD_FOLDER\MPF.Check_${FRAMEWORK}_${RUNTIME}_debug.zip *
+            }
+            Set-Location -Path $BUILD_FOLDER\MPF.Check\bin\Release\${FRAMEWORK}\${RUNTIME}\publish\
+            7z a -tzip $BUILD_FOLDER\MPF.Check_${FRAMEWORK}_${RUNTIME}_release.zip *
+        }
+    }
 
-	# Reset the directory
-	Set-Location -Path $PSScriptRoot
+    # Reset the directory
+    Set-Location -Path $PSScriptRoot
 }