Fix bug for small encrypted regions

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "DiscUtils"]
-	path = DiscUtils
+	path = LibIRD/DiscUtils
 	url = https://github.com/Deterous/DiscUtils

IRDKit/IRDKit.csproj

@@ -3,19 +3,20 @@
   <PropertyGroup>
     <!-- Assembly Properties -->
     <OutputType>Exe</OutputType>
-    <PackAsTool>true</PackAsTool>
+    <TargetName>irdkit</TargetName>
-    <ToolCommandName>irdkit</ToolCommandName>
+    <AssemblyName>irdkit</AssemblyName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
+	<TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
-    <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <LangVersion>latest</LangVersion>
-	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <Version>0.3.0</Version>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Version>0.8.0</Version>
     
     <!-- Package Properties -->
     <Authors>Deterous</Authors>
     <Description>Library for ISO Rebuild Data</Description>
-    <Copyright>Copyright (c) Deterous 2023</Copyright>
+    <Copyright>Copyright (c) Deterous 2023-2024</Copyright>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <RepositoryUrl>https://github.com/Deterous/LibIRD</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -28,11 +29,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\LibIRD\LibIRD.csproj" />
-	  <ProjectReference Include="..\DiscUtils\Library\DiscUtils.Core\DiscUtils.Core.csproj" />
-	  <ProjectReference Include="..\DiscUtils\Library\DiscUtils.Iso9660\DiscUtils.Iso9660.csproj" />
     <PackageReference Include="CommandLineParser" Version="2.9.1" />
-    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.2" />
+    <PackageReference Include="SabreTools.Hashing" Version="1.1.4" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.3.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LibIRD\LibIRD.csproj" />
   </ItemGroup>
 
 </Project>

IRDKit/Program.cs

@@ -1,16 +1,14 @@
-using CommandLine;
+using System;
-using DiscUtils;
-using DiscUtils.Iso9660;
-using LibIRD;
-using SabreTools.RedumpLib.Web;
-using System;
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
-using System.IO.Hashing;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Text;
+using System.Xml.Linq;
+using CommandLine;
+using LibIRD;
+using SabreTools.Hashing;
+using SabreTools.RedumpLib.Web;
 
 namespace IRDKit
 {
@@ -24,14 +22,14 @@ namespace IRDKit
         [Verb("create", HelpText = "Create an IRD from an ISO")]
         public class CreateOptions
         {
-            [Value(0, Required = true, HelpText = "Path to an ISO file, or directory of ISO files")]
+            [Value(0, Required = true, HelpText = "Path to ISO file(s), or directory of ISO files")]
             public IEnumerable<string> ISOPath { get; set; }
 
             [Option('o', "output", HelpText = "Path to the IRD file to be created (will overwrite)")]
             public string IRDPath { get; set; }
 
             [Option('b', "layerbreak", HelpText = "Layerbreak value in bytes (use with BD-Video hybrid discs). Default: 12219392")]
-            public long? Layerbreak {  get; set; }
+            public long? Layerbreak { get; set; }
 
             [Option('k', "key", HelpText = "Hexadecimal representation of the disc key")]
             public string Key { get; set; }
@@ -44,6 +42,9 @@ namespace IRDKit
 
             [Option('r', "recurse", HelpText = "Recurse through all subdirectories and generate IRDs for all ISOs")]
             public bool Recurse { get; set; }
+
+            [Option('v', "verbose", HelpText = "Print more information during IRD creation")]
+            public bool Verbose { get; set; }
         }
 
         /// <summary>
@@ -52,7 +53,7 @@ namespace IRDKit
         [Verb("info", HelpText = "Print information from an IRD or ISO")]
         public class InfoOptions
         {
-            [Value(0, Required = true, HelpText = "Path to an IRD or ISO file, or directory of IRD and/or ISO files")]
+            [Value(0, Required = true, HelpText = "Path to IRD/ISO file(s), or directory of IRD/ISO files")]
             public IEnumerable<string> InPath { get; set; }
 
             [Option('o', "output", HelpText = "Path to the text or json file to be created (will overwrite)")]
@@ -65,9 +66,9 @@ namespace IRDKit
             public bool Recurse { get; set; }
         }
 
-       /// <summary>
+        /// <summary>
-       /// IRD diff command
+        /// IRD diff command
-       /// </summary>
+        /// </summary>
         [Verb("diff", HelpText = "Compare two IRDs and print their differences")]
         public class DiffOptions
         {
@@ -81,6 +82,31 @@ namespace IRDKit
             public string OutPath { get; set; }
         }
 
+        /// <summary>
+        /// IRD rename command
+        /// </summary>
+        [Verb("rename", HelpText = "Rename one or more IRD files according to the redump PS3 DAT")]
+        public class RenameOptions
+        {
+            [Value(0, Required = true, HelpText = "Path to IRD file(s), or directory of IRD files")]
+            public IEnumerable<string> IRDPath { get; set; }
+
+            [Option('d', "datfile", Required = true, HelpText = "Path to the redump PS3 Datfile")]
+            public string DATPath { get; set; }
+
+            [Option('s', "serial", HelpText = "Appends disc serial to new IRD filename")]
+            public bool Serial { get; set; }
+
+            [Option('c', "crc", HelpText = "Appends ISO CRC to new IRD filename")]
+            public bool CRC { get; set; }
+
+            [Option('r', "recurse", HelpText = "Recurse through all subdirectories and rename all IRDs")]
+            public bool Recurse { get; set; }
+
+            [Option('v', "verbose", HelpText = "Print more information about the renaming")]
+            public bool Verbose { get; set; }
+        }
+
         #endregion
 
         #region Program
@@ -95,7 +121,7 @@ namespace IRDKit
             Console.OutputEncoding = Encoding.UTF8;
 
             // Parse arguments
-            var result = Parser.Default.ParseArguments<CreateOptions, InfoOptions, DiffOptions>(args).WithParsed(Run);
+            var result = Parser.Default.ParseArguments<CreateOptions, InfoOptions, DiffOptions, RenameOptions>(args).WithParsed(Run);
         }
 
         /// <summary>
@@ -111,12 +137,17 @@ namespace IRDKit
                 case CreateOptions opt:
 
                     // Validate ISO paths
-                    ArgumentNullException.ThrowIfNull(opt.ISOPath);
+                    if (opt.ISOPath == null || !opt.ISOPath.Any())
+                    {
+                        Console.Error.WriteLine("Provide a valid ISO path to create an IRD");
+                        return;
+                    }
 
                     foreach (string isoPath in opt.ISOPath)
                     {
                         // Validate ISO path
-                        ArgumentNullException.ThrowIfNull(isoPath);
+                        if (string.IsNullOrEmpty(isoPath))
+                            continue;
 
                         // If directory, search for all ISOs in current directory
                         if (Directory.Exists(isoPath))
@@ -125,47 +156,59 @@ namespace IRDKit
                             IEnumerable<string> isoFiles;
                             if (opt.Recurse)
                             {
-                                if (isoPath == ".")
+                                if (opt.Verbose && isoPath == ".")
                                     Console.WriteLine($"Recursively searching for ISOs in current directory");
-                                else
+                                else if (opt.Verbose)
                                     Console.WriteLine($"Recursively searching for ISOs in {isoPath}");
                                 isoFiles = Directory.EnumerateFiles(isoPath, "*.iso", SearchOption.AllDirectories);
                             }
                             else
                             {
-                                if (isoPath == ".")
+                                if (opt.Verbose && isoPath == ".")
                                     Console.WriteLine($"Searching for ISOs in current directory");
-                                else
+                                else if (opt.Verbose)
                                     Console.WriteLine($"Searching for ISOs in {isoPath}");
                                 isoFiles = Directory.EnumerateFiles(isoPath, "*.iso", SearchOption.TopDirectoryOnly);
                             }
 
                             // Warn if no files are found
                             if (!isoFiles.Any())
-                                Console.WriteLine("No ISOs found (ensure .iso extension)");
+                            {
+                                if (opt.Recurse)
+                                    Console.Error.WriteLine($"No ISOs found in {isoPath} (ensure .iso extension)");
+                                else
+                                    Console.Error.WriteLine($"No ISOs found in {isoPath} (ensure .iso extension, or try use -r)");
+                                continue;
+                            }
+
+                            // Determine output IRD folder
+                            string outputPath = opt.IRDPath;
+                            if (File.Exists(opt.IRDPath))
+                                outputPath = Path.GetDirectoryName(opt.IRDPath);
 
                             // Create an IRD file for all ISO files found
-                            foreach (string file in isoFiles)
+                            foreach (string file in isoFiles.OrderBy(x => x))
-                                ISO2IRD(file);
+                                ISO2IRD(file, irdPath: outputPath, keyPath: opt.KeyFile, verbose: opt.Verbose);
                         }
                         else
                         {
                             // Check that given file exists
-                            if (!File.Exists(isoPath)) throw new ArgumentException("Not a valid file or directory");
+                            if (!File.Exists(isoPath))
+                            {
+                                Console.Error.WriteLine($"ISO not found: {isoPath}");
+                                continue;
+                            }
 
-                            // Save to given output path, if only 1 IRD is being created
+                            string irdPath;
-                            if (opt.ISOPath.Count() == 1 && opt.IRDPath != null && opt.IRDPath != "")
+                            // Save to given output path and filename, if only 1 IRD is being created
-                            {
+                            if (opt.ISOPath.Count() == 1)
-                                string irdPath = ISO2IRD(isoPath, opt.IRDPath, opt.Key, opt.KeyFile, opt.GetKeyLog, opt.Layerbreak);
+                                irdPath = ISO2IRD(isoPath, irdPath: opt.IRDPath, hexKey: opt.Key, keyPath: opt.KeyFile, getKeyLog: opt.GetKeyLog, layerbreak: opt.Layerbreak, verbose: opt.Verbose);
-                                if (irdPath != null)
+                            // Save to given output path, if more than 1 IRD is being created
-                                    Console.WriteLine($"IRD saved to {irdPath}");
-                            }
                             else
-                            {
+                                irdPath = ISO2IRD(isoPath, irdPath: Path.GetDirectoryName(opt.IRDPath), verbose: opt.Verbose);
-                                string irdPath = ISO2IRD(isoPath, null, opt.Key, opt.KeyFile, opt.GetKeyLog, opt.Layerbreak);
+
-                                if (irdPath != null)
+                            if (irdPath != null)
-                                    Console.WriteLine($"IRD saved to {irdPath}");
+                                Console.WriteLine($"IRD saved to {irdPath}");
-                            }
                         }
                     }
 
@@ -175,7 +218,11 @@ namespace IRDKit
                 case InfoOptions opt:
 
                     // Validate required parameter
-                    ArgumentNullException.ThrowIfNull(opt.InPath);
+                    if (opt.InPath == null || !opt.InPath.Any())
+                    {
+                        Console.Error.WriteLine("Provide a valid ISO or IRD path to print info about");
+                        return;
+                    }
 
                     // Clear the output file path if it exists
                     if (opt.OutPath != null && opt.OutPath != "")
@@ -184,7 +231,8 @@ namespace IRDKit
                     foreach (string filePath in opt.InPath)
                     {
                         // Validate path
-                        ArgumentNullException.ThrowIfNull(filePath);
+                        if (string.IsNullOrEmpty(filePath))
+                            continue;
 
                         // If directory, search for all ISOs in current directory
                         if (Directory.Exists(filePath))
@@ -213,7 +261,10 @@ namespace IRDKit
 
                             // Warn if no files are found
                             if (!isoFiles.Any() && !irdFiles.Any())
-                                Console.WriteLine("No IRDs or ISOs found (ensure .ird and .iso extensions)");
+                            {
+                                Console.Error.WriteLine("No IRDs or ISOs found (ensure .ird and .iso extensions)");
+                                return;
+                            }
 
                             // Open JSON object
                             if (opt.Json)
@@ -241,11 +292,11 @@ namespace IRDKit
                                 {
                                     PrintISO(file, opt.Json, file.Equals(lastISO), opt.OutPath);
                                 }
-                                catch (InvalidFileSystemException)
+                                catch (IOException)
                                 {
                                     // Not a valid ISO file despite extension, assume file is an IRD
                                     if (!opt.Json)
-                                        Console.WriteLine($"{file} is not a valid ISO file\n");
+                                        Console.Error.WriteLine($"{file} is not a valid ISO file\n");
                                 }
                             }
 
@@ -264,7 +315,11 @@ namespace IRDKit
                         else
                         {
                             // Check that given file exists
-                            if (!File.Exists(filePath)) throw new ArgumentException($"{filePath} is not a valid file or directory");
+                            if (!File.Exists(filePath))
+                            {
+                                Console.Error.WriteLine($"{filePath} is not a valid file");
+                                continue;
+                            }
 
                             // Print info from given file
                             PrintInfo(filePath, opt.Json, true, opt.OutPath);
@@ -279,11 +334,12 @@ namespace IRDKit
                 // Process options from a `diff` command
                 case DiffOptions opt:
 
-                    // Validate required parameter
+                    // Validate required parameters
-                    ArgumentNullException.ThrowIfNull(opt.InPath1);
+                    if (opt.InPath1 == null || opt.InPath2 == null || !File.Exists(opt.InPath1) || !File.Exists(opt.InPath2))
-                    ArgumentNullException.ThrowIfNull(opt.InPath2);
+                    {
-                    if (!File.Exists(opt.InPath1)) throw new ArgumentException($"{opt.InPath1} is not a valid file or directory");
+                        Console.Error.WriteLine("Provide two paths to IRDs to compare");
-                    if (!File.Exists(opt.InPath2)) throw new ArgumentException($"{opt.InPath2} is not a valid file or directory");
+                        return;
+                    }
 
                     // Clear the output file path if it exists
                     if (opt.OutPath != null && opt.OutPath != "")
@@ -297,6 +353,99 @@ namespace IRDKit
 
                     break;
 
+                // Process options from a 'rename' command
+                case RenameOptions opt:
+
+                    // Validate required parameters
+                    if (opt.IRDPath == null || !opt.IRDPath.Any())
+                    {
+                        Console.Error.WriteLine("Provide a valid IRD path to rename");
+                        return;
+                    }
+
+                    // Read DAT file
+                    XDocument datfile = DatParser(opt.DATPath);
+                    if (datfile == null)
+                    {
+                        Console.Error.WriteLine("Unable to parse DAT file");
+                        return;
+                    }
+
+                    foreach (string irdPath in opt.IRDPath)
+                    {
+                        // Validate IRD path
+                        if (string.IsNullOrEmpty(irdPath))
+                            continue;
+
+                        // If directory, search for all ISOs in current directory
+                        if (Directory.Exists(irdPath))
+                        {
+                            // If recurse option enabled, search recursively
+                            IEnumerable<string> irdFiles;
+                            if (opt.Recurse)
+                            {
+                                if (opt.Verbose && irdPath == ".")
+                                    Console.WriteLine($"Recursively renaming IRDs in current directory");
+                                else if (opt.Verbose)
+                                    Console.WriteLine($"Recursively renaming IRDs in {irdPath}");
+                                irdFiles = Directory.EnumerateFiles(irdPath, "*.ird", SearchOption.AllDirectories);
+                            }
+                            else
+                            {
+                                if (opt.Verbose && irdPath == ".")
+                                    Console.WriteLine($"Renaming IRDs in current directory");
+                                else if (opt.Verbose)
+                                    Console.WriteLine($"Renaming IRDs in {irdPath}");
+                                irdFiles = Directory.EnumerateFiles(irdPath, "*.ird", SearchOption.TopDirectoryOnly);
+                            }
+
+                            // Warn if no files are found
+                            if (!irdFiles.Any())
+                            {
+                                if (opt.Recurse)
+                                    Console.Error.WriteLine($"No IRDs found in {irdPath} (ensure .ird extension)");
+                                else
+                                    Console.Error.WriteLine($"No IRDs found in {irdPath} (ensure .ird extension, or try use -r)");
+                                continue;
+                            }
+
+                            // Rename all IRD files found
+                            foreach (string file in irdFiles.OrderBy(x => x))
+                            {
+                                try
+                                {
+                                    RenameIRD(file, datfile, serial: opt.Serial, crc: opt.CRC, verbose: opt.Verbose);
+                                }
+                                catch (Exception e)
+                                {
+                                    Console.Error.WriteLine(e);
+                                }
+                            }
+
+                        }
+                        else
+                        {
+                            // Check that given file exists
+                            if (!File.Exists(irdPath))
+                            {
+                                Console.Error.WriteLine($"IRD not found: {irdPath}");
+                                continue;
+                            }
+
+                            // Rename provided IRD path
+                            try
+                            {
+                                RenameIRD(irdPath, datfile, serial: opt.Serial, crc: opt.CRC, verbose: opt.Verbose);
+                            }
+                            catch (Exception e)
+                            {
+                                Console.Error.WriteLine(e);
+                            }
+                        }
+                    }
+
+                    break;
+
                 // Unknown command
                 default:
                     break;
@@ -324,7 +473,7 @@ namespace IRDKit
                     PrintISO(inPath, json, single, outPath);
                     return;
                 }
-                catch (InvalidFileSystemException)
+                catch (IOException)
                 {
                     // Not a valid ISO file despite extension, try open as IRD
                 }
@@ -355,9 +504,9 @@ namespace IRDKit
                 if (json)
                     return;
                 if (isISO)
-                    Console.WriteLine($"{inPath} is not a valid ISO file\n");
+                    Console.Error.WriteLine($"{inPath} is not a valid ISO file\n");
                 else
-                    Console.WriteLine($"{inPath} is not a valid IRD file\n");
+                    Console.Error.WriteLine($"{inPath} is not a valid IRD file\n");
             }
         }
 
@@ -372,17 +521,20 @@ namespace IRDKit
         public static void PrintISO(string isoPath, bool json, bool single = true, string outPath = null)
         {
             // Open ISO file for reading
-            using FileStream fs = new FileStream(isoPath, FileMode.Open, FileAccess.Read) ?? throw new FileNotFoundException(isoPath);
+            using FileStream fs = new(isoPath, FileMode.Open, FileAccess.Read);
             // Validate ISO file stream
-            if (!CDReader.Detect(fs))
+            if (fs == null || !LibIRD.DiscUtils.Iso9660.CDReader.Detect(fs))
-                throw new InvalidFileSystemException($"{isoPath} is not a valid ISO file");
+            {
+                Console.Error.WriteLine($"{isoPath} is not a valid ISO file");
+                return;
+            }
             // Create new ISO reader
-            using CDReader reader = new(fs, true, true);
+            using LibIRD.DiscUtils.Iso9660.CDReader reader = new(fs);
 
             // Write PS3_DISC.SFB info
             try
             {
-                using DiscUtils.Streams.SparseStream s = reader.OpenFile("\\PS3_DISC.SFB", FileMode.Open, FileAccess.Read);
+                using LibIRD.DiscUtils.Streams.SparseStream s = reader.OpenFile("\\PS3_DISC.SFB", FileMode.Open, FileAccess.Read);
                 PS3_DiscSFB ps3_DiscSFB = new(s);
                 if (json)
                 {
@@ -412,14 +564,14 @@ namespace IRDKit
             catch (FileNotFoundException)
             {
                 if (!json)
-                    Console.WriteLine($"{isoPath} is not a valid PS3 ISO file\n");
+                    Console.Error.WriteLine($"{isoPath} is not a valid PS3 ISO file\n");
                 return;
             }
 
             // Write PARAM.SFO info
             try
             {
-                using DiscUtils.Streams.SparseStream s = reader.OpenFile("\\PS3_GAME\\PARAM.SFO", FileMode.Open, FileAccess.Read);
+                using LibIRD.DiscUtils.Streams.SparseStream s = reader.OpenFile("\\PS3_GAME\\PARAM.SFO", FileMode.Open, FileAccess.Read);
                 ParamSFO paramSFO = new(s);
                 if (json)
                 {
@@ -435,7 +587,7 @@ namespace IRDKit
             catch (FileNotFoundException)
             {
                 if (!json)
-                    Console.WriteLine($"\\PS3_GAME\\PARAM.SFO not found in {isoPath}\n");
+                    Console.Error.WriteLine($"\\PS3_GAME\\PARAM.SFO not found in {isoPath}\n");
             }
 
             // End JSON object
@@ -469,7 +621,7 @@ namespace IRDKit
             // Check they are different IRDs
             if (Path.GetFullPath(irdPath1) == Path.GetFullPath(irdPath2))
             {
-                Console.WriteLine("Provide two different IRDs for a diff");
+                Console.Error.WriteLine("Provide two different IRDs for a diff");
                 return;
             }
 
@@ -480,45 +632,69 @@ namespace IRDKit
             // Build a formatted diff
             StringBuilder printText = new();
 
+            // Print any version difference
             if (IRD1.Version != IRD2.Version)
                 printText.AppendLine($"Version: {IRD1.Version} vs {IRD2.Version}");
 
+            // Print any title ID difference
             if (IRD1.TitleID != IRD2.TitleID)
                 printText.AppendLine($"TitleID: {IRD1.TitleID} vs {IRD2.TitleID}");
 
+            // Print any title difference
             if (IRD1.Title != IRD2.Title)
-                printText.AppendLine($"Title: {IRD1.Title} vs {IRD2.Title}");
+                printText.AppendLine($"Title: \"{IRD1.Title}\" vs \"{IRD2.Title}\"");
 
+            // Print any system version difference
             if (IRD1.SystemVersion != IRD2.SystemVersion)
                 printText.AppendLine($"PUP Version: {IRD1.SystemVersion} vs {IRD2.SystemVersion}");
 
+            // Print any disc version difference
             if (IRD1.DiscVersion != IRD2.DiscVersion)
                 printText.AppendLine($"Disc Version: {IRD1.DiscVersion} vs {IRD2.DiscVersion}");
 
+            // Print any app version difference
             if (IRD1.AppVersion != IRD2.AppVersion)
                 printText.AppendLine($"App Version: {IRD1.AppVersion} vs {IRD2.AppVersion}");
 
+            // Un-gzip the headers to compare them
             byte[] header1 = Decompress(IRD1.Header);
             byte[] header2 = Decompress(IRD2.Header);
 
+            // Print the difference in header length, if not 0
             if (header1.Length != header2.Length)
                 printText.AppendLine($"Header Length: {header1.Length} vs {header2.Length}");
 
-            if (!header1.SequenceEqual(header2))
+            // Print number of bytes that the headers differ by, if not 0
-                printText.AppendLine($"Header: Differs");
+            int headerDiff;
+            if (header1.Length < header2.Length)
+                headerDiff = header2.Length - header1.Length + header1.Where((x, i) => x != header2[i]).Count();
+            else
+                headerDiff = header1.Length - header2.Length + header2.Where((x, i) => x != header1[i]).Count();
+            if (headerDiff != 0)
+                printText.AppendLine($"Header: Differs by {headerDiff} bytes");
 
+            // Un-gzip the footers to compare them
             byte[] footer1 = Decompress(IRD1.Footer);
             byte[] footer2 = Decompress(IRD2.Footer);
 
+            // Print the difference in footer length, if not 0
             if (footer1.Length != footer2.Length)
                 printText.AppendLine($"Footer Length: {footer1.Length} vs {footer2.Length}");
 
-            if (!footer1.SequenceEqual(footer2))
+            // Print number of bytes that the footers differ by, if not 0
-                printText.AppendLine($"Footer: Differs");
+            int footerDiff;
+            if (footer1.Length < footer2.Length)
+                footerDiff = footer2.Length - footer1.Length + footer1.Where((x, i) => x != footer2[i]).Count();
+            else
+                footerDiff = footer1.Length - footer2.Length + footer2.Where((x, i) => x != footer1[i]).Count();
+            if (footerDiff != 0)
+                printText.AppendLine($"Footer: Differs by {footerDiff} bytes");
 
+            // Print the difference in number of regions, if not 0
             if (IRD1.RegionCount != IRD2.RegionCount)
                 printText.AppendLine($"Region Count: {IRD1.RegionCount} vs {IRD2.RegionCount}");
 
+            // Print any differences in region hashes
             int regionCount = IRD2.RegionCount < IRD1.RegionCount ? IRD2.RegionCount : IRD1.RegionCount;
             if (regionCount > IRD1.RegionHashes.Length)
                 regionCount = IRD1.RegionHashes.Length;
@@ -527,47 +703,61 @@ namespace IRDKit
             for (int i = 0; i < regionCount; i++)
             {
                 if (!IRD1.RegionHashes[i].SequenceEqual(IRD2.RegionHashes[i]))
-                    printText.AppendLine($"Region {i} Hash: {Convert.ToHexString(IRD1.RegionHashes[i])} vs {Convert.ToHexString(IRD2.RegionHashes[i])}");
+                    printText.AppendLine($"Region {i} Hash: {LibIRD.IRD.ByteArrayToHexString(IRD1.RegionHashes[i])} vs {LibIRD.IRD.ByteArrayToHexString(IRD2.RegionHashes[i])}");
             }
 
+            // Print the difference in number of files, if not 0
             if (IRD1.FileCount != IRD2.FileCount)
                 printText.AppendLine($"File Count: {IRD1.FileCount} vs {IRD2.FileCount}");
 
-            int fileCount = IRD2.FileCount < IRD1.FileCount ? (int)IRD2.FileCount : (int)IRD1.FileCount;
+            // Print the mismatch file hashes, for each file offset at which they differ
-            if (fileCount > IRD1.FileKeys.Length)
+            List<long> missingOffsets1 = [];
-                fileCount = IRD1.FileKeys.Length;
+            List<long> missingOffsets2 = [];
-            if (fileCount > IRD2.FileKeys.Length)
+            for (int i = 0; i < IRD1.FileKeys.Length; i++)
-                fileCount = IRD2.FileKeys.Length;
-            if (fileCount > IRD1.FileHashes.Length)
-                fileCount = IRD1.FileHashes.Length;
-            if (fileCount > IRD2.FileHashes.Length)
-                fileCount = IRD2.FileHashes.Length;
-            for (int i = 0; i < fileCount; i++)
             {
-                if (IRD1.FileKeys[i] != IRD2.FileKeys[i])
+                int j = Array.FindIndex(IRD2.FileKeys, element => element == IRD1.FileKeys[i]);
-                    printText.AppendLine($"File {i} Offset: {IRD1.FileKeys[i]} vs {IRD2.FileKeys[i]}");
+                if (j == -1)
-                if (!IRD1.FileHashes[i].SequenceEqual(IRD2.FileHashes[i]))
+                    missingOffsets2.Add(IRD1.FileKeys[i]);
-                    printText.AppendLine($"File {i} Hash: {Convert.ToHexString(IRD1.FileHashes[i])} vs {Convert.ToHexString(IRD2.FileHashes[i])}");
+                if (j != -1 && !IRD1.FileHashes[i].SequenceEqual(IRD2.FileHashes[j]))
+                    printText.AppendLine($"File Hash at Offset {IRD1.FileKeys[i]}: {LibIRD.IRD.ByteArrayToHexString(IRD1.FileHashes[i])} vs {LibIRD.IRD.ByteArrayToHexString(IRD2.FileHashes[j])}");
             }
+            for (int i = 0; i < IRD2.FileKeys.Length; i++)
+            {
+                int j = Array.FindIndex(IRD1.FileKeys, element => element == IRD2.FileKeys[i]);
+                if (j == -1)
+                    missingOffsets1.Add(IRD2.FileKeys[i]);
+            }
+            // Print the file offsets that differ
+            if (missingOffsets1.Count > 0)
+                printText.AppendLine($"File Offsets not Present in {irdPath1}: {string.Join(", ", missingOffsets1)}");
+            if (missingOffsets2.Count > 0)
+                printText.AppendLine($"File Offsets not Present in {irdPath2}: {string.Join(", ", missingOffsets2)}");
 
+            // Print any extra config data difference
             if (IRD1.ExtraConfig != IRD2.ExtraConfig)
                 printText.AppendLine($"Extra Config: {IRD1.ExtraConfig:X4} vs {IRD2.ExtraConfig:X4}");
 
+            // Print any attachments data difference
             if (IRD1.Attachments != IRD2.Attachments)
                 printText.AppendLine($"Attachments: {IRD1.Attachments:X4} vs {IRD2.Attachments:X4}");
 
+            // Print any unique ID difference
             if (IRD1.UID != IRD2.UID)
                 printText.AppendLine($"Unique ID: {IRD1.UID:X8} vs {IRD2.UID:X8}");
 
+            // Print any data 1 key difference
             if (!IRD1.Data1Key.SequenceEqual(IRD2.Data1Key))
-                printText.AppendLine($"Data 1 Key: {Convert.ToHexString(IRD1.Data1Key)} vs {Convert.ToHexString(IRD2.Data1Key)}");
+                printText.AppendLine($"Data 1 Key: {LibIRD.IRD.ByteArrayToHexString(IRD1.Data1Key)} vs {LibIRD.IRD.ByteArrayToHexString(IRD2.Data1Key)}");
 
+            // Print any data 2 key difference
             if (!IRD1.Data2Key.SequenceEqual(IRD2.Data2Key))
-                printText.AppendLine($"Data 2 Key: {Convert.ToHexString(IRD1.Data2Key)} vs {Convert.ToHexString(IRD2.Data2Key)}");
+                printText.AppendLine($"Data 2 Key: {LibIRD.IRD.ByteArrayToHexString(IRD1.Data2Key)} vs {LibIRD.IRD.ByteArrayToHexString(IRD2.Data2Key)}");
 
+            // Print any PIC difference
             if (!IRD1.PIC.SequenceEqual(IRD2.PIC))
-                printText.AppendLine($"PIC: {Convert.ToHexString(IRD1.PIC)} vs {Convert.ToHexString(IRD2.PIC)}");
+                printText.AppendLine($"PIC: {LibIRD.IRD.ByteArrayToHexString(IRD1.PIC)} vs {LibIRD.IRD.ByteArrayToHexString(IRD2.PIC)}");
 
+            // Write formatted string to file if output path provided, otherwise to console
             if (outPath != null)
                 File.AppendAllText(outPath, printText.ToString());
             else
@@ -583,17 +773,32 @@ namespace IRDKit
         /// <param name="keyPath">Disc key file (overridden by hex string if present)</param>
         /// <param name="getKeyLog">GetKey log file (overridden by disc key or key file if present)</param>
         /// <param name="layerbreak">Layerbreak value of disc</param>
-        public static string ISO2IRD(string isoPath, string irdPath = null, string hexKey = null, string keyPath = null, string getKeyLog = null, long? layerbreak = null)
+        public static string ISO2IRD(string isoPath, string irdPath = null, string hexKey = null, string keyPath = null, string getKeyLog = null, long? layerbreak = null, bool verbose = false)
         {
             // Check file exists
-            FileInfo iso = new(isoPath);
+            FileInfo iso;
+            try
+            {
+                iso = new(isoPath);
+            }
+            catch (Exception e)
+            {
+                Console.Error.WriteLine(e.Message + ", failed to create IRD");
+                return null;
+            }
             if (!iso.Exists)
             {
-                Console.WriteLine($"{nameof(isoPath)} is not a valid file or directory");
+                Console.Error.WriteLine($"{nameof(isoPath)} is not a valid file or directory");
                 return null;
             }
 
+            // Determine IRD path if only folder given
+            if (Directory.Exists(irdPath))
+                irdPath = Path.Combine(irdPath, Path.GetFileName(Path.ChangeExtension(isoPath, ".ird")));
+
             // Determine IRD path if none given
+            if (irdPath == string.Empty)
+                irdPath = Path.GetFileName(Path.ChangeExtension(isoPath, ".ird"));
             irdPath ??= Path.ChangeExtension(isoPath, ".ird");
 
             // Create new reproducible redump-style IRD with a given hex key
@@ -602,23 +807,22 @@ namespace IRDKit
                 try
                 {
                     // Get disc key from hex string
-                    byte[] discKey = Convert.FromHexString(hexKey);
+                    byte[] discKey = LibIRD.IRD.HexStringToByteArray(hexKey);
                     if (discKey == null || discKey.Length != 16)
-                        throw new ArgumentException(hexKey);
+                        Console.Error.WriteLine($"{hexKey} is not a valid key, detecting key automatically...");
-
+                    else
-                    Console.WriteLine($"Creating {irdPath} with Key: {hexKey}");
+                    {
-                    IRD ird1 = new ReIRD(isoPath, discKey, layerbreak);
+                        Console.WriteLine($"Creating {irdPath} with Key: {hexKey}");
-                    ird1.Write(irdPath);
+                        IRD ird1 = new ReIRD(isoPath, discKey, layerbreak);
-                    ird1.Print();
+                        ird1.Write(irdPath);
-                    return irdPath;
+                        if (verbose)
+                            ird1.Print();
+                        return irdPath;
+                    }
                 }
-                catch (ArgumentException)
+                catch (Exception e)
                 {
-                    Console.Error.WriteLine($"{hexKey} is not a valid key, detecting key automatically...");
+                    Console.Error.WriteLine(e.Message + ", failed to create IRD");
-                }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
                     return null;
                 }
             }
@@ -626,23 +830,30 @@ namespace IRDKit
             // Create new reproducible redump-style IRD with a given key file
             if (keyPath != null)
             {
-                // Read key from .key file
-                byte[] discKey = File.ReadAllBytes(keyPath);
                 try
                 {
-                    IRD ird2 = new ReIRD(isoPath, discKey, layerbreak);
+                    // If key directory was given, append filename and .key
-                    Console.WriteLine($"Creating {irdPath} with Key: {Convert.ToHexString(discKey)}");
+                    if (Directory.Exists(keyPath))
-                    ird2.Write(irdPath);
+                    {
-                    ird2.Print();
+                        keyPath = Path.Combine(keyPath, Path.ChangeExtension(Path.GetFileName(isoPath), ".key"));
-                    return irdPath;
+                    }
+                    // Read key from .key file
+                    byte[] discKey = File.ReadAllBytes(keyPath);
+                    if (discKey == null || discKey.Length != 16)
+                        Console.Error.WriteLine($"{hexKey} is not a valid key, detecting key automatically...");
+                    else
+                    {
+                        Console.WriteLine($"Creating {irdPath} with Key: {LibIRD.IRD.ByteArrayToHexString(discKey)}");
+                        IRD ird1 = new ReIRD(isoPath, discKey, layerbreak);
+                        ird1.Write(irdPath);
+                        if (verbose)
+                            ird1.Print();
+                        return irdPath;
+                    }
                 }
-                catch (ArgumentException)
+                catch (Exception e)
                 {
-                    Console.Error.WriteLine($"{Convert.ToHexString(discKey)} is not a valid key, detecting key automatically...");
+                    Console.Error.WriteLine(e.Message + ", failed to create IRD");
-                }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
                     return null;
                 }
             }
@@ -653,14 +864,15 @@ namespace IRDKit
                 try
                 {
                     Console.WriteLine($"Creating {irdPath} with key from: {getKeyLog}");
-                    IRD ird3 = new ReIRD(isoPath, getKeyLog);
+                    IRD ird1 = new ReIRD(isoPath, getKeyLog);
-                    ird3.Write(irdPath);
+                    ird1.Write(irdPath);
-                    ird3.Print();
+                    if (verbose)
+                        ird1.Print();
                     return irdPath;
                 }
-                catch (FileNotFoundException)
+                catch (Exception e)
                 {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
+                    Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
             }
@@ -676,21 +888,20 @@ namespace IRDKit
                     // Read key from .key file
                     byte[] discKey = File.ReadAllBytes(keyfilePath);
                     if (discKey == null || discKey.Length != 16)
-                        throw new ArgumentException(keyfilePath);
+                        Console.Error.WriteLine($"{hexKey} is not a valid key, detecting key automatically...");
-
+                    else
-                    Console.WriteLine($"Creating {irdPath} with Key: {Convert.ToHexString(discKey)}");
+                    {
-                    IRD ird2 = new ReIRD(isoPath, discKey, layerbreak);
+                        Console.WriteLine($"Creating {irdPath} with Key: {LibIRD.IRD.ByteArrayToHexString(discKey)}");
-                    ird2.Write(irdPath);
+                        IRD ird1 = new ReIRD(isoPath, discKey, layerbreak);
-                    ird2.Print();
+                        ird1.Write(irdPath);
-                    return irdPath;
+                        if (verbose)
+                            ird1.Print();
+                        return irdPath;
+                    }
                 }
-                catch (ArgumentException)
+                catch (Exception e)
                 {
-                    Console.Error.WriteLine("Given key file not valid, detecting key automatically...");
+                    Console.Error.WriteLine(e.Message + ", failed to create IRD");
-                }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
                     return null;
                 }
             }
@@ -704,88 +915,161 @@ namespace IRDKit
                 try
                 {
                     Console.WriteLine($"Creating {irdPath} with key from: {logfilePath}");
-                    IRD ird3 = new ReIRD(isoPath, logfilePath);
+                    IRD ird1 = new ReIRD(isoPath, logfilePath);
-                    ird3.Write(irdPath);
+                    ird1.Write(irdPath);
-                    ird3.Print();
+                    if (verbose)
+                        ird1.Print();
                     return irdPath;
                 }
-                catch (FileNotFoundException)
+                catch (Exception e)
                 {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
+                    Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
             }
 
             // No key provided, try get key from redump.org
-            Console.WriteLine("No key provided... Searching for key on redump.org");
+            if (verbose)
+                Console.WriteLine("No key provided... Searching for key on redump.org");
 
             // Compute CRC32 hash
-            byte[] crc32;
+            byte[] crc32 = HashTool.GetFileHashArray(isoPath, HashType.CRC32);
-            using (FileStream fs = File.OpenRead(isoPath))
+            string crc32String = LibIRD.IRD.ByteArrayToHexString(crc32).ToLowerInvariant();
-            {
+
-                Crc32 hasher = new();
+            // Convert to UInt for use as UID in IRD
-                hasher.Append(fs);
+            Array.Reverse(crc32);
-                crc32 = hasher.GetCurrentHash();
+            uint crc32UInt = BitConverter.ToUInt32(crc32, 0);
-                // Change endianness
-                Array.Reverse(crc32);
-            }
-            string crc32_hash = Convert.ToHexString(crc32).ToLower();
 
             // Search for ISO on redump.org
+#if !NETFRAMEWORK
             RedumpHttpClient redump = new();
-            List<int> ids = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + crc32_hash).ConfigureAwait(false).GetAwaiter().GetResult();
+            List<int> ids = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + crc32String).ConfigureAwait(false).GetAwaiter().GetResult();
+#else
+            RedumpWebClient redump = new();
+            List<int> ids = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + crc32String);
+#endif
             int id;
             if (ids.Count == 0)
             {
-                Console.WriteLine("ISO not found in redump, cannot automatically retreive key");
+                Console.Error.WriteLine("ISO not found in redump and no valid key provided, cannot create IRD");
                 return null;
             }
             else if (ids.Count > 1)
             {
-                // Compute SHA1 hash
+                // More than one result for the CRC32 hash, compute SHA1 hash instead
-                byte[] sha1;
+                string sha1String = HashTool.GetFileHash(isoPath, HashType.SHA1);
-                using (FileStream fs = File.OpenRead(isoPath))
-                {
-                    SHA1 hasher = SHA1.Create();
-                    sha1 = hasher.ComputeHash(fs);
-                }
-                string sha1_hash = Convert.ToHexString(sha1).ToLower();
 
                 // Search redump.org for SHA1 hash
-                List<int> ids2 = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + sha1_hash).ConfigureAwait(false).GetAwaiter().GetResult();
+#if !NETFRAMEWORK
+                List<int> ids2 = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + sha1String).ConfigureAwait(false).GetAwaiter().GetResult();
+#else
+                List<int> ids2 = redump.CheckSingleSitePage("http://redump.org/discs/system/ps3/quicksearch/" + sha1String);
+#endif
                 if (ids2.Count == 0)
                 {
-                    Console.WriteLine("ISO not found in redump, cannot automatically retreive key");
+                    Console.Error.WriteLine("ISO not found in redump and no valid key provided, cannot create IRD");
                     return null;
                 }
                 else if (ids2.Count > 1)
                 {
-                    Console.WriteLine("Cannot automatically get key from redump. Please search redump.org and run again with -k");
+                    Console.Error.WriteLine("Cannot automatically get key from redump. Please search redump.org and run again with -k");
                     return null;
                 }
                 id = ids2[0];
             }
             else
             {
+                // One result found, assume it is the PS3 ISO
                 id = ids[0];
             }
 
             // Download key file from redump.org
+#if !NETFRAMEWORK
             byte[] key = redump.GetByteArrayAsync($"http://redump.org/disc/{id}/key").ConfigureAwait(false).GetAwaiter().GetResult();
+#else
+            byte[] key = redump.DownloadData($"http://redump.org/disc/{id}/key");
+#endif
             if (key.Length != 16)
             {
-                Console.WriteLine("Invalid key obtained from redump");
+                Console.Error.WriteLine("Invalid key obtained from redump and no valid key provided, cannot create IRD");
+                return null;
             }
 
             // Create IRD with key from redump
-            Console.WriteLine($"Creating {irdPath} with Key: {Convert.ToHexString(key)}");
+            Console.WriteLine($"Creating {irdPath} with Key from redump.org: {LibIRD.IRD.ByteArrayToHexString(key)}");
-            IRD ird = new ReIRD(isoPath, key, layerbreak);
+            try
-            ird.Write(irdPath);
+            {
-            ird.Print();
+                IRD ird = new ReIRD(isoPath, key, layerbreak, crc32UInt);
-            return irdPath;
+                ird.Write(irdPath);
+                if (verbose)
+                    ird.Print();
+                return irdPath;
+            }
+            catch (Exception e)
+            {
+                Console.Error.WriteLine(e.Message + ", failed to create IRD");
+                return null;
+            }
         }
 
-        #endregion
+        public static XDocument DatParser(string datpath = null)
+        {
+            try
+            {
+                if (!File.Exists(datpath))
+                    return null;
+
+                return XDocument.Load(datpath);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        public static string GetDatFilename(IRD ird, XDocument datfile)
+        {
+            string crc32 = ird.UID.ToString("X8").ToLower();
+            XElement node = datfile.Root.Elements("game").Where(e => e.Element("rom").Attribute("crc").Value == crc32).FirstOrDefault() ?? throw new ArgumentException("Cannot find ISO in redump DAT");
+            return node.Attribute("name").Value;
+        }
+
+        public static void RenameIRD(string irdPath, XDocument datfile, bool serial = false, bool crc = false, bool verbose = false)
+        {
+            IRD ird = IRD.Read(irdPath);
+
+            if (ird.ExtraConfig != 0x0001)
+                throw new ArgumentException($"{irdPath} is not a redump-style IRD");
+
+            string filename = GetDatFilename(ird, datfile) ?? throw new ArgumentException($"Cannot determine DAT filename for {irdPath}");
+            if (serial)
+                filename += $" [{ird.TitleID.Substring(0, 4)}-{ird.TitleID.Substring(5, 5)}]";
+            if (crc)
+                filename += $" [{ird.UID:X8}]";
+
+            // Rename irdPath to filename
+            string directory = Path.GetDirectoryName(Path.GetFullPath(filename));
+            string filepath;
+            if (!string.IsNullOrEmpty(directory))
+                filepath = Path.Combine(Path.GetDirectoryName(irdPath), filename + ".ird");
+            else
+                filepath = filename + ".ird";
+
+            // Rename IRD to new name
+            if (irdPath != filepath)
+            {
+                if (verbose)
+                    Console.WriteLine($"Renaming {Path.GetFileName(irdPath)} to {Path.GetFileName(filepath)}");
+                File.Move(irdPath, filepath);
+            }
+            else
+            {
+                if (verbose)
+                    Console.WriteLine($"Skipping {Path.GetFileName(irdPath)}, already named correctly");
+            }
+        }
+
+#endregion
 
         #region Helper Functions
 

IRDKit/README.md

@@ -1,7 +1,41 @@
-## How to use IRDKit
+# How to use IRDKit
 
-IRDKit is a tool that allows direct use of LibIRD functionality from the command line interface. The basic usage is:
+IRDKit is a tool that allows direct use of LibIRD functionality from the command line interface.
-```
+For full help instructions, run `irdkit help`
-irdkit game.iso game.ird
+
-```
+## Creating ISOs
-For detailed usage, run `irdkit --help`
+
+For all options, run `irdkit help create`
+
+To create an IRD from an ISO, run `irdkit create game.iso`
+Multiple ISOs can be processed at once with `irdkit create game1.iso game2.iso`
+Or a whole directory of ISOs can be processed with `irdkit create ./ISO`, or recursively with `irdkit create -r ./ISO`
+
+The IRD will be created in the same folder as the ISO, with the same filename.
+A different IRD path and/or filename can be defined with `-o` or `--output=`
+
+### Key
+By default, IRDs will be created by pulling keys from redump.org
+A key can be manually provided with `-k` or `--key=`
+A key file can be provided with `-f game.key` or `--key-file=`
+A key from GetKey log file can be used with `-l game.getkey.log` or `--getkey-log=`
+
+### PIC
+By default, a PIC will be generated assuming a default layerbreak
+A layerbreak value can be provided with `-b` or `--layerbreak=`
+A PIC from a GetKey log file can be used with `-l game.getkey.log` or `--getkey-log=`
+
+## Printing info
+
+For all options, run `irdkit help info`
+
+To print info about an ISO or IRD file, run `irdkit info game.iso` or `irdkit info game.ird`
+The info can be printed to a file, e.g. `-o out.txt` or `--output=`
+The info can be formatted as a JSON with `-j` or `--json`
+
+## Comparing IRDs
+
+For all options, run `irdkit help diff`
+
+To compare two IRDs, run `irdkit diff game1.ird game2.ird`
+The comparison can be printed to a file, e.g. `-o out.txt` or `--output=`

LibIRD.sln

@@ -11,16 +11,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		.gitattributes = .gitattributes
 		.gitignore = .gitignore
+		.gitmodules = .gitmodules
 		LICENSE.txt = LICENSE.txt
+		publish-irdkit.ps1 = publish-irdkit.ps1
 		README.md = README.md
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DiscUtils.Core", "DiscUtils\Library\DiscUtils.Core\DiscUtils.Core.csproj", "{9E71F5CD-887D-4A61-8460-9F7E8F110B46}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DiscUtils.Iso9660", "DiscUtils\Library\DiscUtils.Iso9660\DiscUtils.Iso9660.csproj", "{9E1EF05F-388B-42C6-A4E7-98BE20C7C8EC}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DiscUtils.Streams", "DiscUtils\Library\DiscUtils.Streams\DiscUtils.Streams.csproj", "{E8D0B8B0-F165-4FA1-AC7B-194F5F48A5F9}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -35,18 +31,6 @@ Global
 		{9060E3AF-E4FB-436F-93A1-5C47389CB88E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9060E3AF-E4FB-436F-93A1-5C47389CB88E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9060E3AF-E4FB-436F-93A1-5C47389CB88E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9E71F5CD-887D-4A61-8460-9F7E8F110B46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9E71F5CD-887D-4A61-8460-9F7E8F110B46}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9E71F5CD-887D-4A61-8460-9F7E8F110B46}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9E71F5CD-887D-4A61-8460-9F7E8F110B46}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9E1EF05F-388B-42C6-A4E7-98BE20C7C8EC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9E1EF05F-388B-42C6-A4E7-98BE20C7C8EC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9E1EF05F-388B-42C6-A4E7-98BE20C7C8EC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9E1EF05F-388B-42C6-A4E7-98BE20C7C8EC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E8D0B8B0-F165-4FA1-AC7B-194F5F48A5F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E8D0B8B0-F165-4FA1-AC7B-194F5F48A5F9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E8D0B8B0-F165-4FA1-AC7B-194F5F48A5F9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E8D0B8B0-F165-4FA1-AC7B-194F5F48A5F9}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

LibIRD/LibIRD.csproj

@@ -2,16 +2,18 @@
 
   <PropertyGroup>
     <!-- Assembly Properties -->
-    <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <LangVersion>latest</LangVersion>
-	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <Version>0.3.0</Version>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Version>0.8.0</Version>
+    <PackageOutputPath>../nupkg</PackageOutputPath>
     
     <!-- Package Properties -->
     <Authors>Deterous</Authors>
     <Description>Library for ISO Rebuild Data</Description>
-    <Copyright>Copyright (c) Deterous 2024</Copyright>
+    <Copyright>Copyright (c) Deterous 2023-2024</Copyright>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <RepositoryUrl>https://github.com/Deterous/LibIRD/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -19,16 +21,22 @@
     <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
   </PropertyGroup>
+  
+  <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+    <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+  </PropertyGroup>
+  
+  <PropertyGroup Condition="!$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+    <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
+  </PropertyGroup>
 
   <ItemGroup>
     <None Include="./README.md" Pack="true" PackagePath="" />
   </ItemGroup>
-  
+
   <ItemGroup>
-    <ProjectReference Include="..\DiscUtils\Library\DiscUtils.Core\DiscUtils.Core.csproj" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <ProjectReference Include="..\DiscUtils\Library\DiscUtils.Iso9660\DiscUtils.Iso9660.csproj" />
+    <PackageReference Include="SabreTools.Hashing" Version="1.1.4" />
-    <ProjectReference Include="..\DiscUtils\Library\DiscUtils.Streams\DiscUtils.Streams.csproj" />
-    <PackageReference Include="System.IO.Hashing" Version="8.0.0" />
   </ItemGroup>
 
 </Project>

LibIRD/PS3_DiscSFB.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using System.Text.Json;
+using Newtonsoft.Json;
 
 namespace LibIRD
 {
@@ -27,18 +27,14 @@ namespace LibIRD
         /// A field within the PS3_DISC.SFB file
         /// </summary>
         /// <remarks>string Key, string Value</remarks>
-        public Dictionary<string, string> Field {  get; private set; }
+        public Dictionary<string, string> Field { get; private set; }
 
         /// <summary>
         /// Constructor using a PARAM.SFO file path
         /// </summary>
         /// <param name="sfbPath">Full file path to the PS3_DISC.SFB file</param>
-        /// <exception cref="ArgumentNullException"></exception>
         public PS3_DiscSFB(string sfbPath)
         {
-            // Validate file path
-            ArgumentNullException.ThrowIfNull(sfbPath, nameof(sfbPath));
-
             // Read file as a stream, and parse file
             using FileStream fs = new(sfbPath, FileMode.Open, FileAccess.Read);
             Parse(fs);
@@ -72,7 +68,7 @@ namespace LibIRD
             // Read SFB file version
             byte[] buf = br.ReadBytes(2);
             Array.Reverse(buf);
-            Version = BitConverter.ToUInt16(buf);
+            Version = BitConverter.ToUInt16(buf, 0);
 
             // Process all field headers
             sfbStream.Seek(0x20, SeekOrigin.Begin);
@@ -142,7 +138,7 @@ namespace LibIRD
         public void PrintJson(string jsonPath = null)
         {
             // Serialise PS3_Disc.SFB data to a JSON object
-            string json = JsonSerializer.Serialize(Field, new JsonSerializerOptions { WriteIndented = true });
+            string json = JsonConvert.SerializeObject(Field, Formatting.Indented);
 
             // If no path given, output to console
             if (jsonPath == null)

LibIRD/ParamSFO.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using System.Text.Json;
+using Newtonsoft.Json;
 
 namespace LibIRD
 {
@@ -43,13 +43,8 @@ namespace LibIRD
         /// Constructor using a PARAM.SFO file path
         /// </summary>
         /// <param name="sfoPath">Full file path to the PARAM.SFO file</param>
-        /// <exception cref="ArgumentNullException"></exception>
         public ParamSFO(string sfoPath)
         {
-            // Validate file path
-            if (sfoPath == null || sfoPath.Length <= 0)
-                throw new ArgumentNullException(nameof(sfoPath));
-
             // Read file as a stream, and parse file
             using FileStream fs = new(sfoPath, FileMode.Open, FileAccess.Read);
             Parse(fs);
@@ -103,7 +98,7 @@ namespace LibIRD
                               - keyOffset[i];
 
                 // Read ith key name
-                string key = Encoding.ASCII.GetString(br.ReadBytes((int) keyLen)).TrimEnd('\0');
+                string key = Encoding.ASCII.GetString(br.ReadBytes((int)keyLen)).TrimEnd('\0');
 
                 // Move stream to ith data
                 sfoStream.Position = dataTableStart + dataOffset[i];
@@ -112,13 +107,13 @@ namespace LibIRD
                 Field[key] = dataFormat[i] switch
                 {
                     // Non-null-terminated UTF-8 String
-                    0x0004 => Encoding.UTF8.GetString(br.ReadBytes((int) dataLength[i])),
+                    0x0004 => Encoding.UTF8.GetString(br.ReadBytes((int)dataLength[i])),
                     // Null-terminated UTF-8 String
-                    0x0204 => Encoding.UTF8.GetString(br.ReadBytes((int) dataLength[i])).TrimEnd('\0'),
+                    0x0204 => Encoding.UTF8.GetString(br.ReadBytes((int)dataLength[i])).TrimEnd('\0'),
                     // Integer
                     0x0404 => br.ReadInt32().ToString(),
                     // Unknown data format, assume null-terminated string
-                    _ => Encoding.UTF8.GetString(br.ReadBytes((int) dataLength[i])).TrimEnd('\0'),
+                    _ => Encoding.UTF8.GetString(br.ReadBytes((int)dataLength[i])).TrimEnd('\0'),
                 };
             }
         }
@@ -166,7 +161,7 @@ namespace LibIRD
         public void PrintJson(string jsonPath = null)
         {
             // Serialise PS3_Disc.SFB data to a JSON object
-            string json = JsonSerializer.Serialize(Field, new JsonSerializerOptions { WriteIndented = true });
+            string json = JsonConvert.SerializeObject(Field, Formatting.Indented);
 
             // If no path given, output to console
             if (jsonPath == null)

LibIRD/ReIRD.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.IO.Hashing;
 
 namespace LibIRD
 {
@@ -51,15 +50,6 @@ namespace LibIRD
     /// </summary>
     public class ReIRD : IRD
     {
-        #region Properties
-
-        /// <summary>
-        /// ISO file size
-        /// </summary>
-        private long Size { get; set; }
-
-        #endregion
-
         #region Constructors
 
         /// <summary>
@@ -67,26 +57,7 @@ namespace LibIRD
         /// </summary>
         /// <param name="isoPath">Path to the ISO</param>
         /// <param name="getKeyLog">Path to the GetKey log file</param>
-        /// <param name="layerbreak">Layerbreak value, in sectors</param>
+        public ReIRD(string isoPath, string getKeyLog) : base(isoPath, getKeyLog, true) { }
-        /// <exception cref="InvalidDataException"></exception>
-        public ReIRD(string isoPath, string getKeyLog, long? layerbreak = null) : base(isoPath, getKeyLog, true)
-        {
-            // Generate Unique Identifier using ISO CRC32
-            UID = GenerateUID(isoPath);
-
-            // Determine ISO file size
-            Size = CalculateSize(isoPath);
-
-            // Generate Data 2 using Disc ID
-            DiscID = GenerateID(Size);
-
-            // Generate Disc PIC
-            byte[] pic = GeneratePIC(Size, layerbreak * SectorSize);
-
-            // Check that GetKey log matches expected PIC
-            if (!((ReadOnlySpan<byte>)PIC).SequenceEqual(pic))
-                throw new InvalidDataException("Unexpected PIC in .getkey.log");
-        }
 
         /// <summary>
         /// Constructor with optional additional region to generate a specific Disc ID
@@ -94,23 +65,24 @@ namespace LibIRD
         /// <param name="isoPath">Path to the ISO</param>
         /// <param name="key">Disc Key, redump-style (AES encrypted Data 1)</param>
         /// <param name="layerbreak">Layerbreak value, in sectors</param>
+        /// <param name="uid">Unique ID, crc32 hash of ISO</param>
         /// <param name="region">Disc Region</param>
-        public ReIRD(string isoPath, byte[] key, long? layerbreak = null, Region region = Region.NONE) : base()
+        public ReIRD(string isoPath, byte[] key, long? layerbreak = null, uint? uid = null, Region region = Region.NONE) : base()
         {
-            // Generate Unique Identifier using ISO CRC32
+            // If the ISO CRC32 is provided, use it as the Unique ID
-            UID = GenerateUID(isoPath);
+            UID = uid == null ? 0x00000000 : (uint)uid;
 
             // Determine ISO file size
-            Size = CalculateSize(isoPath);
+            long size = CalculateSize(isoPath);
 
             // Set Disc Key
             DiscKey = key;
 
             // Generate Data 2 using Disc ID
-            DiscID = GenerateID(Size, region);
+            DiscID = GenerateID(size, region);
 
             // Generate Disc PIC
-            PIC = GeneratePIC(Size, layerbreak * SectorSize);
+            PIC = GeneratePIC(isoPath, size, layerbreak * SectorSize);
 
             // Generate IRD fields
             GenerateIRD(isoPath, true);
@@ -143,12 +115,13 @@ namespace LibIRD
         /// <param name="layerbreak">Layer break value, byte at which disc layers are split across</param>
         /// <param name="exactIRD">True to generate a PIC in 3k3y style (0x03 at 115th byte for BD-50 discs)</param>
         /// <exception cref="ArgumentException"></exception>
-        private static byte[] GeneratePIC(long size, long? layerbreak = null, bool exactIRD = false)
+        private static byte[] GeneratePIC(string isoPath, long size, long? layerbreak = null, bool exactIRD = false)
         {
             // Validate size
             if (size <= 0 || (size % SectorSize) != 0)
                 throw new ArgumentException("ISO Size in bytes must be a positive integer multiple of 2048", nameof(size));
-            // Validate layerbreak
+
+            // Validate provided layerbreak
             if (layerbreak != null)
             {
                 if (layerbreak <= 0 || (layerbreak >= size))
@@ -156,70 +129,78 @@ namespace LibIRD
                 if (layerbreak >= 2 * BDLayerSize || layerbreak % SectorSize != 0)
                     throw new ArgumentException("Unexpected layerbreak value", nameof(size));
             }
-            // If layerbreak value was not set, assume it is a non-hybrid disc with default layerbreak
+            else if (size > BDLayerSize)
-            long layer_break = layerbreak ?? BDLayerSize;
+            {
+                // If no layerbreak provided, ensure ISO is not BD-Video hybrid
+                using FileStream fs = new FileStream(isoPath, FileMode.Open, FileAccess.Read) ?? throw new FileNotFoundException(isoPath);
+                DiscUtils.Iso9660.CDReader reader = new(fs);
+                if (reader.DirectoryExists("\\BDMV"))
+                    throw new ArgumentException("Layerbreak must be provided for BD-Video hybrid discs");
+                // Assume disc has default layerbreak
+                layerbreak = BDLayerSize;
+            }
 
             // Generate the PIC based on the size and layerbreak of the ISO
             byte[] pic;
             if (size > BDLayerSize) // if BD-50
             {
                 // Layer 0 start sector = 0x01000000
-             	long l0_start_sector = 1048576;
+                long l0_start_sector = 1048576;
-			
+
-			    // Layer 0 end sector = start sector + layerbreak - 2
+                // Layer 0 end sector = start sector + layerbreak - 2
-			    long l0_end_sector = (layer_break / SectorSize) + l0_start_sector - 2;
+                long l0_end_sector = ((long)layerbreak / SectorSize) + l0_start_sector - 2;
-			    // Convert end sector location to hex values for PIC
+                // Convert end sector location to hex values for PIC
-			    byte[] l0es = [(byte)((l0_end_sector >> 24) & 0xFF),
+                byte[] l0es = [(byte)((l0_end_sector >> 24) & 0xFF),
-						       (byte)((l0_end_sector >> 16) & 0xFF),
+                    (byte)((l0_end_sector >> 16) & 0xFF),
-						       (byte)((l0_end_sector >> 8) & 0xFF),
+                    (byte)((l0_end_sector >> 8) & 0xFF),
-						       (byte)((l0_end_sector >> 0) & 0xFF)];
+                    (byte)((l0_end_sector >> 0) & 0xFF)];
 
                 // Layer 1 start sector = end of disc (0x01EFFFFE) - layerbreak + 2
-                long l1_start_sector = 32505854 - (layer_break / SectorSize) + 2;
+                long l1_start_sector = 32505854 - ((long)layerbreak! / SectorSize) + 2;
-			    // Convert start of start sector location to hex values for PIC
+                // Convert start of start sector location to hex values for PIC
-			    byte[] l1ss = [(byte)((l1_start_sector >> 24) & 0xFF),
+                byte[] l1ss = [(byte)((l1_start_sector >> 24) & 0xFF),
-						       (byte)((l1_start_sector >> 16) & 0xFF),
+                    (byte)((l1_start_sector >> 16) & 0xFF),
-						       (byte)((l1_start_sector >> 8) & 0xFF),
+                    (byte)((l1_start_sector >> 8) & 0xFF),
-						       (byte)((l1_start_sector >> 0) & 0xFF)];
+                    (byte)((l1_start_sector >> 0) & 0xFF)];
-			
-			    // Total sectors used = num_sectors + Layer 0 start + sectors_between_layers (usually 0x01358C00 - 0x00CA73FE - 3)
-			    long total_sectors = (size / SectorSize) + l0_start_sector + (l1_start_sector - l0_end_sector - 3);
-			    byte[] ts = BitConverter.GetBytes((uint) total_sectors);
 
-			    // Define the PIC
+                // Total sectors used = num_sectors + Layer 0 start + sectors_between_layers (usually 0x01358C00 - 0x00CA73FE - 3)
-			    pic = [
+                long total_sectors = (size / SectorSize) + l0_start_sector + (l1_start_sector - l0_end_sector - 3);
-				    // Initial portion of PIC (24 bytes)
+                byte[] ts = BitConverter.GetBytes((uint)total_sectors);
-				    // [4098 bytes] [2x 0x00] ["DI"]   [v1] [10units] [DI num]
+
+                // Define the PIC
+                pic = [
+                    // Initial portion of PIC (24 bytes)
+                    // [4098 bytes] [2x 0x00] ["DI"]   [v1] [10units] [DI num]
 				    0x10, 0x02, 0x00, 0x00, 0x44, 0x49, 0x01, 0x10, 0x00, 0x00, 0x20, 0x00,
-				    //   ["BDR"]         [2 layers]
+                    //   ["BDR"]         [2 layers]
 				    0x42, 0x44, 0x4F, 0x01, 0x21, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-				    // Total sectors used on disc (4 bytes)
+                    // Total sectors used on disc (4 bytes)
 				    ts[3], ts[2], ts[1], ts[0],
-				    // 1st Layer sector start location (4 bytes)
+                    // 1st Layer sector start location (4 bytes)
 				    0x00, 0x10, 0x00, 0x00,
-				    // 1st Layer sector end location (4 bytes), 0x00CA73FE for default BD layerbreak of 12219392
+                    // 1st Layer sector end location (4 bytes), 0x00CA73FE for default BD layerbreak of 12219392
 				    l0es[0], l0es[1], l0es[2], l0es[3],
-				    // 32 bytes of zeros
+                    // 32 bytes of zeros
 				    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-				    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-				    // Initial portion of PIC again, for 2nd layer
+                    // Initial portion of PIC again, for 2nd layer
-				    // ["DI"]  [v1] [11unit][DI num]
+                    // ["DI"]  [v1] [11unit][DI num]
 				    0x44, 0x49, 0x01, 0x11, 0x00, 0x01, 0x20, 0x00,
-				    //   ["BDR"]           [2 layers]
+                    //   ["BDR"]           [2 layers]
 				    0x42, 0x44, 0x4F, 0x01, 0x21, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-				    // Total sectors used on disc
+                    // Total sectors used on disc
 				    ts[3], ts[2], ts[1], ts[0],
-				    // 2nd Layer sector start location, 0x01358C00 for default BD layerbreak of 12219392
+                    // 2nd Layer sector start location, 0x01358C00 for default BD layerbreak of 12219392
 				    l1ss[0], l1ss[1], l1ss[2], l1ss[3],
-				    // 2nd Layer sector end location
+                    // 2nd Layer sector end location
 				    0x01, 0xEF, 0xFF, 0xFE,
-				    // Remaining 32 bytes are zeroes
+                    // Remaining 32 bytes are zeroes
 				    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ];
-			    // 3k3y style: 0x03 at last byte
+                // 3k3y style: 0x03 at last byte
-			    if (exactIRD)
+                if (exactIRD)
-				    pic[114] = 0x03;
+                    pic[114] = 0x03;
 
-		    }
+            }
             else // if BD-25
             {
                 // Total sectors used on disc: num_sectors + layer_sector_end (0x00100000) - 1
@@ -245,52 +226,28 @@ namespace LibIRD
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ];
             }
-            
+
             return pic;
         }
 
-        /// <summary>
-        /// Generates the UID field by computing the CRC32 hash of the ISO
-        /// </summary>
-        /// <param name="isoPath">Path to the ISO</param>
-        /// <exception cref="ArgumentNullException"></exception>
-        /// <exception cref="FileNotFoundException"></exception>
-        private static uint GenerateUID(string isoPath)
-        {
-            // Validate ISO path
-            ArgumentNullException.ThrowIfNull(isoPath, nameof(isoPath));
-
-            // Check file exists
-            var iso = new FileInfo(isoPath);
-            if (!iso.Exists)
-                throw new FileNotFoundException(nameof(isoPath));
-
-            // Compute CRC32 hash
-            byte[] crc32;
-            using (FileStream fs = File.OpenRead(isoPath))
-            {
-                Crc32 hasher = new();
-                hasher.Append(fs);
-                crc32 = hasher.GetCurrentHash();
-            }
-
-            // Redump ISO CRC32 hash is used as the Unique ID in the reproducible IRD
-            return BitConverter.ToUInt32(crc32, 0);
-        }
-
         /// <summary>
         /// Calculates ISO file size
         /// </summary>
         /// <param name="isoPath">Path to the ISO</param>
-        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="ArgumentException"></exception>
         /// <exception cref="FileNotFoundException"></exception>
         private static long CalculateSize(string isoPath)
         {
-            // Validate ISO path
-            ArgumentNullException.ThrowIfNull(isoPath, nameof(isoPath));
-
             // Check file exists
-            var iso = new FileInfo(isoPath);
+            FileInfo iso;
+            try
+            {
+                iso = new FileInfo(isoPath);
+            }
+            catch (Exception e)
+            {
+                throw new ArgumentException("Invalid ISO Path: " + e.Message);
+            }
             if (!iso.Exists)
                 throw new FileNotFoundException(nameof(isoPath));
 

README.md

@@ -13,6 +13,8 @@ IRDKit is a tool that allows direct use of LibIRD functionality from a command l
 - Printing info about all ISOs and IRDs in a folder: `irdkit info .`
 - Creating an IRD from an ISO: `irdkit create game.iso`
 - Finding differences between two IRDs: `irdkit diff game1.ird game2.ird`
+- Renaming a folder of IRDs using a redump DAT: `irdkit rename -d redump.dat IRDs\`
+
 For detailed usage, read more [here](IRDKit).
 
 ## Using the LibIRD library

publish-irdkit.ps1

@@ -0,0 +1,15 @@
+dotnet publish -c Release -f net8.0 -r win-x86 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r win-x64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r win-arm64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r linux-x64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r linux-arm64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r osx-x64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+dotnet publish -c Release -f net8.0 -r osx-arm64 --self-contained=false  -p:PublishSingleFile=true -p:DebugType=None IRDKit\IRDKit.csproj
+
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/win-x86/publish/irdkit.exe" -Destination "./irdkit-win-x86.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/win-x64/publish/irdkit.exe" -Destination "./irdkit-win-x64.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/win-arm64/publish/irdkit.exe" -Destination "./irdkit-win-arm64.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/linux-x64/publish/irdkit" -Destination "./irdkit-linux-x64.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/linux-arm64/publish/irdkit" -Destination "./irdkit-linux-arm64.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/osx-x64/publish/irdkit" -Destination "./irdkit-osx-x64.zip" -CompressionLevel "Optimal"
+Compress-Archive -Path "./IRDKit/bin/Release/net8.0/osx-arm64/publish/irdkit" -Destination "./irdkit-osx-arm64.zip" -CompressionLevel "Optimal"