Aaru, Archives, CHDs all in folders

SabreTools.FileTypes/Archives/GZipArchive.cs

@@ -0,0 +1,505 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using SabreTools.IO;
+using Compress;
+using Compress.gZip;
+using Compress.ZipFile.ZLib;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a TorrentGZip archive for reading and writing
+    /// </summary>
+    public class GZipArchive : BaseArchive
+    {
+        #region Constants
+
+        /* (Torrent)GZ Header Format
+            https://tools.ietf.org/html/rfc1952
+
+            00-01		Identification (0x1F, 0x8B) GzSignature
+            02			Compression Method (0-7 reserved, 8 deflate; 0x08)
+            03			Flags (0 FTEXT, 1 FHCRC, 2 FEXTRA, 3 FNAME, 4 FCOMMENT, 5 reserved, 6 reserved, 7 reserved; 0x04)
+            04-07		Modification time (Unix format; 0x00, 0x00, 0x00, 0x00)
+            08			Extra Flags (2 maximum compression, 4 fastest algorithm; 0x00)
+            09			OS (See list on https://tools.ietf.org/html/rfc1952; 0x00)
+            0A-0B		Length of extra field (mirrored; 0x1C, 0x00)
+            0C-27		Extra field
+                0C-1B	MD5 Hash
+                1C-1F	CRC hash
+                20-27	Int64 size (mirrored)
+        */
+        private readonly static byte[] TorrentGZHeader = new byte[] { 0x1f, 0x8b, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00 };
+
+        #endregion
+
+        #region Fields
+
+        /// <summary>
+        /// Positive value for depth of the output depot, defaults to 4
+        /// </summary>
+        public int Depth { get; set; } = 4;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a new TorrentGZipArchive with no base file
+        /// </summary>
+        public GZipArchive()
+            : base()
+        {
+            this.Type = FileType.GZipArchive;
+        }
+
+        /// <summary>
+        /// Create a new TorrentGZipArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public GZipArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.GZipArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Decompress the _filename stream
+                FileStream outstream = File.Create(Path.Combine(outDir, Path.GetFileNameWithoutExtension(this.Filename)));
+                var gz = new gZip();
+                ZipReturn ret = gz.ZipFileOpen(this.Filename);
+                ret = gz.ZipFileOpenReadStream(0, out Stream gzstream, out ulong streamSize);
+                gzstream.CopyTo(outstream);
+
+                // Dispose of the streams
+                outstream.Dispose();
+                ret = gz.ZipFileCloseReadStream();
+                gz.ZipFileClose();
+
+                encounteredErrors = false;
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+            
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry;
+
+            try
+            {
+                // Decompress the _filename stream
+                realEntry = Path.GetFileNameWithoutExtension(this.Filename);
+                var gz = new gZip();
+                ZipReturn ret = gz.ZipFileOpen(this.Filename);
+                ret = gz.ZipFileOpenReadStream(0, out Stream gzstream, out ulong streamSize);
+
+                // Write the file out
+                byte[] gbuffer = new byte[_bufferSize];
+                int glen;
+                while ((glen = gzstream.Read(gbuffer, 0, _bufferSize)) > 0)
+                {
+
+                    ms.Write(gbuffer, 0, glen);
+                    ms.Flush();
+                }
+
+                // Dispose of the streams
+                gzstream.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            if (_children == null || _children.Count == 0)
+            {
+                _children = new List<BaseFile>();
+
+                string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+                BaseFile possibleTgz = GetTorrentGZFileInfo();
+
+                // If it was, then add it to the outputs and continue
+                if (possibleTgz != null && possibleTgz.Filename != null)
+                {
+                    _children.Add(possibleTgz);
+                }
+                else
+                {
+                    try
+                    {
+                        // Create a blank item for the entry
+                        BaseFile gzipEntryRom = new BaseFile();
+
+                        // Perform a quickscan, if flagged to
+                        if (this.AvailableHashes == Hash.CRC)
+                        {
+                            gzipEntryRom.Filename = gamename;
+                            using (BinaryReader br = new BinaryReader(File.OpenRead(this.Filename)))
+                            {
+                                br.BaseStream.Seek(-8, SeekOrigin.End);
+                                gzipEntryRom.CRC = br.ReadBytesBigEndian(4);
+                                gzipEntryRom.Size = br.ReadInt32BigEndian();
+                            }
+                        }
+                        // Otherwise, use the stream directly
+                        else
+                        {
+                            var gz = new gZip();
+                            ZipReturn ret = gz.ZipFileOpen(this.Filename);
+                            ret = gz.ZipFileOpenReadStream(0, out Stream gzstream, out ulong streamSize);
+                            gzipEntryRom = GetInfo(gzstream, hashes: this.AvailableHashes);
+                            gzipEntryRom.Filename = gz.Filename(0);
+                            gzipEntryRom.Parent = gamename;
+                            gzipEntryRom.Date = (gz.TimeStamp > 0 ? gz.TimeStamp.ToString() : null);
+                            gzstream.Dispose();
+                        }
+
+                        // Fill in comon details and add to the list
+                        gzipEntryRom.Parent = gamename;
+                        _children.Add(gzipEntryRom);
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.Error(ex);
+                        return null;
+                    }
+                }
+            }
+
+            return _children;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            // GZip files don't contain directories
+            return new List<string>();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            // Check for the file existing first
+            if (!File.Exists(this.Filename))
+                return false;
+
+            string datum = Path.GetFileName(this.Filename).ToLowerInvariant();
+            long filesize = new FileInfo(this.Filename).Length;
+
+            // If we have the romba depot files, just skip them gracefully
+            if (datum == ".romba_size" || datum == ".romba_size.backup")
+            {
+                logger.Verbose($"Romba depot file found, skipping: {this.Filename}");
+                return false;
+            }
+
+            // Check if the name is the right length
+            if (!Regex.IsMatch(datum, @"^[0-9a-f]{" + Constants.SHA1Length + @"}\.gz"))
+            {
+                logger.Warning($"Non SHA-1 filename found, skipping: '{Path.GetFullPath(this.Filename)}'");
+                return false;
+            }
+
+            // Check if the file is at least the minimum length
+            if (filesize < 40 /* bytes */)
+            {
+                logger.Warning($"Possibly corrupt file '{Path.GetFullPath(this.Filename)}' with size {filesize}");
+                return false;
+            }
+
+            // Get the Romba-specific header data
+            BinaryReader br = new BinaryReader(File.OpenRead(this.Filename));
+            byte[] header = br.ReadBytes(12); // Get preamble header for checking
+            br.ReadBytes(16); // headermd5
+            br.ReadBytes(4); // headercrc
+            br.ReadUInt64(); // headersz
+            br.Dispose();
+
+            // If the header is not correct, return a blank rom
+            bool correct = true;
+            for (int i = 0; i < header.Length; i++)
+            {
+                // This is a temp fix to ignore the modification time and OS until romba can be fixed
+                if (i == 4 || i == 5 || i == 6 || i == 7 || i == 9)
+                    continue;
+
+                correct &= (header[i] == TorrentGZHeader[i]);
+            }
+
+            if (!correct)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Retrieve file information for a single torrent GZ file
+        /// </summary>
+        /// <returns>Populated DatItem object if success, empty one on error</returns>
+        public BaseFile GetTorrentGZFileInfo()
+        {
+            // Check for the file existing first
+            if (!File.Exists(this.Filename))
+            {
+                return null;
+            }
+
+            string datum = Path.GetFileName(this.Filename).ToLowerInvariant();
+            long filesize = new FileInfo(this.Filename).Length;
+
+            // If we have the romba depot files, just skip them gracefully
+            if (datum == ".romba_size" || datum == ".romba_size.backup")
+            {
+                logger.Verbose($"Romba depot file found, skipping: {this.Filename}");
+                return null;
+            }
+
+            // Check if the name is the right length
+            if (!Regex.IsMatch(datum, @"^[0-9a-f]{" + Constants.SHA1Length + @"}\.gz"))
+            {
+                logger.Warning($"Non SHA-1 filename found, skipping: '{Path.GetFullPath(this.Filename)}'");
+                return null;
+            }
+
+            // Check if the file is at least the minimum length
+            if (filesize < 40 /* bytes */)
+            {
+                logger.Warning($"Possibly corrupt file '{Path.GetFullPath(this.Filename)}' with size {filesize}");
+                return null;
+            }
+
+            // Get the Romba-specific header data
+            byte[] header; // Get preamble header for checking
+            byte[] headermd5; // MD5
+            byte[] headercrc; // CRC
+            ulong headersz; // Int64 size
+            BinaryReader br = new BinaryReader(File.OpenRead(this.Filename));
+            header = br.ReadBytes(12);
+            headermd5 = br.ReadBytes(16);
+            headercrc = br.ReadBytes(4);
+            headersz = br.ReadUInt64();
+            br.Dispose();
+
+            // If the header is not correct, return a blank rom
+            bool correct = true;
+            for (int i = 0; i < header.Length; i++)
+            {
+                // This is a temp fix to ignore the modification time and OS until romba can be fixed
+                if (i == 4 || i == 5 || i == 6 || i == 7 || i == 9)
+                {
+                    continue;
+                }
+                correct &= (header[i] == TorrentGZHeader[i]);
+            }
+            if (!correct)
+            {
+                return null;
+            }
+
+            // Now convert the data and get the right position
+            long extractedsize = (long)headersz;
+
+            BaseFile baseFile = new BaseFile
+            {
+                Filename = Path.GetFileNameWithoutExtension(this.Filename).ToLowerInvariant(),
+                Size = extractedsize,
+                CRC = headercrc,
+                MD5 = headermd5,
+                SHA1 = Utilities.StringToByteArray(Path.GetFileNameWithoutExtension(this.Filename)),
+
+                Parent = Path.GetFileNameWithoutExtension(this.Filename).ToLowerInvariant(),
+            };
+
+            return baseFile;
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile = null)
+        {
+            // Check that the input file exists
+            if (!File.Exists(inputFile))
+            {
+                logger.Warning($"File '{inputFile}' does not exist!");
+                return false;
+            }
+
+            inputFile = Path.GetFullPath(inputFile);
+
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile = null)
+        {
+            bool success = false;
+
+            // If the stream is not readable, return
+            if (!inputStream.CanRead)
+                return success;
+
+            // Make sure the output directory exists
+            if (!Directory.Exists(outDir))
+                Directory.CreateDirectory(outDir);
+
+            outDir = Path.GetFullPath(outDir);
+
+            // Now get the Rom info for the file so we have hashes and size
+            baseFile = GetInfo(inputStream, keepReadOpen: true);
+
+            // Get the output file name
+            string outfile = Path.Combine(outDir, Utilities.GetDepotPath(Utilities.ByteArrayToString(baseFile.SHA1), Depth));
+
+            // Check to see if the folder needs to be created
+            if (!Directory.Exists(Path.GetDirectoryName(outfile)))
+                Directory.CreateDirectory(Path.GetDirectoryName(outfile));
+
+            // If the output file exists, don't try to write again
+            if (!File.Exists(outfile))
+            {
+                // Compress the input stream
+                FileStream outputStream = File.Create(outfile);
+
+                // Open the output file for writing
+                BinaryWriter sw = new BinaryWriter(outputStream);
+
+                // Write standard header and TGZ info
+                byte[] data = TorrentGZHeader
+                            .Concat(baseFile.MD5) // MD5
+                            .Concat(baseFile.CRC) // CRC
+                            .ToArray();
+                sw.Write(data);
+                sw.Write((ulong)(baseFile.Size ?? 0)); // Long size (Unsigned, Mirrored)
+
+                // Now create a deflatestream from the input file
+                ZlibBaseStream ds = new ZlibBaseStream(outputStream, CompressionMode.Compress, CompressionLevel.BestCompression, ZlibStreamFlavor.DEFLATE, true);
+
+                // Copy the input stream to the output
+                byte[] ibuffer = new byte[_bufferSize];
+                int ilen;
+                while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                {
+                    ds.Write(ibuffer, 0, ilen);
+                    ds.Flush();
+                }
+
+                ds.Dispose();
+
+                // Now write the standard footer
+                sw.Write(baseFile.CRC.Reverse().ToArray());
+                sw.Write((uint)(baseFile.Size ?? 0));
+
+                // Dispose of everything
+                sw.Dispose();
+                outputStream.Dispose();
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/LRZipArchive.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a TorrentLRZip archive for reading and writing
+    /// </summary>
+    /// TODO: Implement from source at https://github.com/ckolivas/lrzip
+    public class LRZipArchive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new LRZipArchive with no base file
+        /// </summary>
+        public LRZipArchive()
+            : base()
+        {
+            this.Type = FileType.LRZipArchive;
+        }
+
+        /// <summary>
+        /// Create a new LRZipArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public LRZipArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.LRZipArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/LZ4Archive.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a TorrentLRZip archive for reading and writing
+    /// </summary>
+    /// TODO: Implement from source at https://github.com/lz4/lz4
+    public class LZ4Archive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new LZ4Archive with no base file
+        /// </summary>
+        public LZ4Archive()
+            : base()
+        {
+            this.Type = FileType.LZ4Archive;
+        }
+
+        /// <summary>
+        /// Create a new LZ4Archive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public LZ4Archive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.LZ4Archive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile rom)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile rom)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/RarArchive.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using SabreTools.Core;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Rar;
+using SharpCompress.Readers;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a TorrentRAR archive for reading and writing
+    /// </summary>
+    public class RarArchive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new TorrentRARArchive with no base file
+        /// </summary>
+        public RarArchive()
+            : base()
+        {
+            this.Type = FileType.RarArchive;
+        }
+
+        /// <summary>
+        /// Create a new TorrentRARArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public RarArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.RarArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Extract all files to the temp directory
+                SharpCompress.Archives.Rar.RarArchive ra = SharpCompress.Archives.Rar.RarArchive.Open(this.Filename);
+                foreach (RarArchiveEntry entry in ra.Entries)
+                {
+                    entry.WriteToDirectory(outDir, new SharpCompress.Common.ExtractionOptions { PreserveFileTime = true, ExtractFullPath = true, Overwrite = true });
+                }
+                encounteredErrors = false;
+                ra.Dispose();
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry = null;
+
+            try
+            {
+                SharpCompress.Archives.Rar.RarArchive ra = SharpCompress.Archives.Rar.RarArchive.Open(this.Filename, new ReaderOptions { LeaveStreamOpen = false, });
+                foreach (RarArchiveEntry entry in ra.Entries)
+                {
+                    if (entry != null && !entry.IsDirectory && entry.Key.Contains(entryName))
+                    {
+                        // Write the file out
+                        realEntry = entry.Key;
+                        entry.WriteTo(ms);
+                    }
+                }
+                ra.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            List<BaseFile> found = new List<BaseFile>();
+            string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+            try
+            {
+                SharpCompress.Archives.Rar.RarArchive ra = SharpCompress.Archives.Rar.RarArchive.Open(File.OpenRead(this.Filename));
+                foreach (RarArchiveEntry entry in ra.Entries.Where(e => e != null && !e.IsDirectory))
+                {
+                    // Create a blank item for the entry
+                    BaseFile rarEntryRom = new BaseFile();
+
+                    // Perform a quickscan, if flagged to
+                    if (this.AvailableHashes == Hash.CRC)
+                    {
+                        rarEntryRom.Size = entry.Size;
+                        rarEntryRom.CRC = BitConverter.GetBytes(entry.Crc);
+                    }
+                    // Otherwise, use the stream directly
+                    else
+                    {
+                        using (Stream entryStream = entry.OpenEntryStream())
+                        {
+                            rarEntryRom = GetInfo(entryStream, size: entry.Size, hashes: this.AvailableHashes);
+                        }
+                    }
+
+                    // Fill in comon details and add to the list
+                    rarEntryRom.Filename = entry.Key;
+                    rarEntryRom.Parent = gamename;
+                    rarEntryRom.Date = entry.LastModifiedTime?.ToString("yyyy/MM/dd hh:mm:ss");
+                    found.Add(rarEntryRom);
+                }
+
+                // Dispose of the archive
+                ra.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                return null;
+            }
+
+            return found;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            List<string> empties = new List<string>();
+
+            try
+            {
+                SharpCompress.Archives.Rar.RarArchive ra = SharpCompress.Archives.Rar.RarArchive.Open(this.Filename, new ReaderOptions { LeaveStreamOpen = false });
+                List<RarArchiveEntry> rarEntries = ra.Entries.OrderBy(e => e.Key, new NaturalSort.NaturalReversedComparer()).ToList();
+                string lastRarEntry = null;
+                foreach (RarArchiveEntry entry in rarEntries)
+                {
+                    if (entry != null)
+                    {
+                        // If the current is a superset of last, we skip it
+                        if (lastRarEntry != null && lastRarEntry.StartsWith(entry.Key))
+                        {
+                            // No-op
+                        }
+                        // If the entry is a directory, we add it
+                        else if (entry.IsDirectory)
+                        {
+                            empties.Add(entry.Key);
+                            lastRarEntry = entry.Key;
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+            }
+
+            return empties;
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> roms)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/SevenZipArchive.cs

@@ -0,0 +1,806 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using Compress;
+using Compress.SevenZip;
+using Compress.ZipFile;
+using NaturalSort;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a Torrent7zip archive for reading and writing
+    /// </summary>
+    public class SevenZipArchive : BaseArchive
+    {
+        #region Constants
+
+        /* Torrent7z Header Format
+            http://cpansearch.perl.org/src/BJOERN/Compress-Deflate7-1.0/7zip/DOC/7zFormat.txt
+
+            00-05		Local file header signature (0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C) SevenZipSignature
+            06-07		ArchiveVersion (0x00, 0x03)
+            The rest is unknown
+        */
+        private readonly static byte[] Torrent7ZipHeader = new byte[] { 0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c, 0x00, 0x03 };
+        private readonly static byte[] Torrent7ZipSignature = new byte[] { 0xa9, 0xa9, 0x9f, 0xd1, 0x57, 0x08, 0xa9, 0xd7, 0xea, 0x29, 0x64, 0xb2,
+            0x36, 0x1b, 0x83, 0x52, 0x33, 0x00, 0x74, 0x6f, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x37, 0x7a, 0x5f, 0x30, 0x2e, 0x39, 0x62, 0x65, 0x74, 0x61 };
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a new TorrentSevenZipArchive with no base file
+        /// </summary>
+        public SevenZipArchive()
+            : base()
+        {
+            this.Type = FileType.SevenZipArchive;
+        }
+
+        /// <summary>
+        /// Create a new TorrentSevenZipArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public SevenZipArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.SevenZipArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Extract all files to the temp directory
+                SevenZ zf = new SevenZ();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
+                {
+                    // Open the read stream
+                    zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
+
+                    // Create the rest of the path, if needed
+                    if (!string.IsNullOrWhiteSpace(Path.GetDirectoryName(zf.Filename(i))))
+                        Directory.CreateDirectory(Path.Combine(outDir, Path.GetDirectoryName(zf.Filename(i))));
+
+                    // If the entry ends with a directory separator, continue to the next item, if any
+                    if (zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
+                    {
+                        zf.ZipFileCloseReadStream();
+                        continue;
+                    }
+
+                    FileStream writeStream = File.Create(Path.Combine(outDir, zf.Filename(i)));
+
+                    // If the stream is smaller than the buffer, just run one loop through to avoid issues
+                    if (streamsize < _bufferSize)
+                    {
+                        byte[] ibuffer = new byte[streamsize];
+                        int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                        writeStream.Write(ibuffer, 0, ilen);
+                        writeStream.Flush();
+                    }
+                    // Otherwise, we do the normal loop
+                    else
+                    {
+                        int realBufferSize = (streamsize < _bufferSize ? (int)streamsize : _bufferSize);
+                        byte[] ibuffer = new byte[realBufferSize];
+                        int ilen;
+                        while ((ilen = readStream.Read(ibuffer, 0, realBufferSize)) > 0)
+                        {
+                            writeStream.Write(ibuffer, 0, ilen);
+                            writeStream.Flush();
+                        }
+                    }
+
+                    zr = zf.ZipFileCloseReadStream();
+                    writeStream.Dispose();
+                }
+
+                zf.ZipFileClose();
+                encounteredErrors = false;
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry = null;
+
+            try
+            {
+                SevenZ zf = new SevenZ();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
+                {
+                    if (zf.Filename(i).Contains(entryName))
+                    {
+                        // Open the read stream
+                        realEntry = zf.Filename(i);
+                        zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
+
+                        // If the stream is smaller than the buffer, just run one loop through to avoid issues
+                        if (streamsize < _bufferSize)
+                        {
+                            byte[] ibuffer = new byte[streamsize];
+                            int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                            ms.Write(ibuffer, 0, ilen);
+                            ms.Flush();
+                        }
+                        // Otherwise, we do the normal loop
+                        else
+                        {
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while (streamsize > _bufferSize)
+                            {
+                                ilen = readStream.Read(ibuffer, 0, _bufferSize);
+                                ms.Write(ibuffer, 0, ilen);
+                                ms.Flush();
+                                streamsize -= _bufferSize;
+                            }
+
+                            ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                            ms.Write(ibuffer, 0, ilen);
+                            ms.Flush();
+                        }
+
+                        zr = zf.ZipFileCloseReadStream();
+                    }
+                }
+
+                zf.ZipFileClose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            List<BaseFile> found = new List<BaseFile>();
+            string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+            try
+            {
+                SevenZ zf = new SevenZ();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount(); i++)
+                {
+                    // If the entry is a directory (or looks like a directory), we don't want to open it
+                    if (zf.IsDirectory(i)
+                        || zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
+                    {
+                        continue;
+                    }
+
+                    // Open the read stream
+                    zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
+
+                    // If we get a read error, log it and continue
+                    if (zr != ZipReturn.ZipGood)
+                    {
+                        logger.Warning($"An error occurred while reading archive {this.Filename}: Zip Error - {zr}");
+                        zr = zf.ZipFileCloseReadStream();
+                        continue;
+                    }
+
+                    // Create a blank item for the entry
+                    BaseFile zipEntryRom = new BaseFile();
+
+                    // Perform a quickscan, if flagged to
+                    if (this.AvailableHashes == Hash.CRC)
+                    {
+                        zipEntryRom.Size = (long)zf.UncompressedSize(i);
+                        zipEntryRom.CRC = zf.CRC32(i);
+                    }
+                    // Otherwise, use the stream directly
+                    else
+                    {
+                        zipEntryRom = GetInfo(readStream, size: (long)zf.UncompressedSize(i), hashes: this.AvailableHashes, keepReadOpen: true);
+                    }
+
+                    // Fill in comon details and add to the list
+                    zipEntryRom.Filename = zf.Filename(i);
+                    zipEntryRom.Parent = gamename;
+                    found.Add(zipEntryRom);
+                }
+
+                // Dispose of the archive
+                zr = zf.ZipFileCloseReadStream();
+                zf.ZipFileClose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                return null;
+            }
+
+            return found;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            List<string> empties = new List<string>();
+
+            try
+            {
+                SevenZ zf = new SevenZ();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                List<(string, bool)> zipEntries = new List<(string, bool)>();
+                for (int i = 0; i < zf.LocalFilesCount(); i++)
+                {
+                    zipEntries.Add((zf.Filename(i), zf.IsDirectory(i)));
+                }
+
+                zipEntries = zipEntries.OrderBy(p => p.Item1, new NaturalReversedComparer()).ToList();
+                string lastZipEntry = null;
+                foreach ((string, bool) entry in zipEntries)
+                {
+                    // If the current is a superset of last, we skip it
+                    if (lastZipEntry != null && lastZipEntry.StartsWith(entry.Item1))
+                    {
+                        // No-op
+                    }
+                    // If the entry is a directory, we add it
+                    else
+                    {
+                        if (entry.Item2)
+                        {
+                            empties.Add(entry.Item1);
+                        }
+                        lastZipEntry = entry.Item1;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+            }
+
+            return empties;
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            SevenZ zf = new SevenZ();
+            ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+            if (zr != ZipReturn.ZipGood)
+            {
+                throw new Exception(ZipFile.ZipErrorMessageText(zr));
+            }
+
+            return zf.ZipStatus == ZipStatus.Trrnt7Zip;
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either input is null or empty, return
+            if (inputStream == null || baseFile == null || baseFile.Filename == null)
+                return success;
+
+            // If the stream is not readable, return
+            if (!inputStream.CanRead)
+                return success;
+
+            // Seek to the beginning of the stream
+            inputStream.Seek(0, SeekOrigin.Begin);
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFile.Parent) + (baseFile.Parent.EndsWith(".7z") ? string.Empty : ".7z"));
+
+            // Set internal variables
+            Stream writeStream = null;
+            SevenZ oldZipFile = new SevenZ();
+            SevenZ zipFile = new SevenZ();
+            ZipReturn zipReturn = ZipReturn.ZipGood;
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    inputStream.Seek(0, SeekOrigin.Begin);
+                    zipReturn = zipFile.ZipFileCreate(tempFile);
+
+                    // Open the input file for reading
+                    ulong istreamSize = (ulong)(inputStream.Length);
+
+                    DateTime dt = DateTime.Now;
+                    if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
+                    {
+                        uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                        zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, msDosDateTime, out writeStream);
+                    }
+                    else
+                    {
+                        zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, null, out writeStream);
+                    }
+
+                    // Copy the input stream to the output
+                    byte[] ibuffer = new byte[_bufferSize];
+                    int ilen;
+                    while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                    {
+                        writeStream.Write(ibuffer, 0, ilen);
+                        writeStream.Flush();
+                    }
+
+                    zipFile.ZipFileCloseWriteStream(baseFile.CRC);
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldZipFile.ZipFileOpen(archiveFileName, -1, true);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    var oldZipFileContents = new List<string>();
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        oldZipFileContents.Add(oldZipFile.Filename(i));
+                    }
+
+                    // If the old one doesn't contain the new file, then add it
+                    if (!oldZipFileContents.Contains(baseFile.Filename.Replace('\\', '/')))
+                    {
+                        inputIndexMap.Add(baseFile.Filename.Replace('\\', '/'), -1);
+                    }
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        inputIndexMap.Add(oldZipFile.Filename(i), i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= oldZipFile.LocalFilesCount())
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Otherwise, process the old zipfile
+                    zipFile.ZipFileCreate(tempFile);
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Open the input file for reading
+                            ulong istreamSize = (ulong)(inputStream.Length);
+
+                            DateTime dt = DateTime.Now;
+                            if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
+                            {
+                                uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                                zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, msDosDateTime, out writeStream);
+                            }
+                            else
+                            {
+                                zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, null, out writeStream);
+                            }
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            zipFile.ZipFileCloseWriteStream(baseFile.CRC);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Instantiate the streams
+                            oldZipFile.ZipFileOpenReadStream(index, out Stream zreadStream, out ulong istreamSize);
+                            zipFile.ZipFileOpenWriteStream(false, true, oldZipFile.Filename(index), istreamSize, 0, null, out writeStream);
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = zreadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            oldZipFile.ZipFileCloseReadStream();
+                            zipFile.ZipFileCloseWriteStream(oldZipFile.CRC32(index));
+                        }
+                    }
+                }
+
+                // Close the output zip file
+                zipFile.ZipFileClose();
+                oldZipFile.ZipFileClose();
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+            finally
+            {
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+                File.Delete(archiveFileName);
+
+            File.Move(tempFile, archiveFileName);
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either list of roms is null or empty, return
+            if (inputFiles == null || baseFiles == null || inputFiles.Count == 0 || baseFiles.Count == 0)
+            {
+                return success;
+            }
+
+            // If the number of inputs is less than the number of available roms, return
+            if (inputFiles.Count < baseFiles.Count)
+            {
+                return success;
+            }
+
+            // If one of the files doesn't exist, return
+            foreach (string file in inputFiles)
+            {
+                if (!File.Exists(file))
+                {
+                    return success;
+                }
+            }
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFiles[0].Parent) + (baseFiles[0].Parent.EndsWith(".7z") ? string.Empty : ".7z"));
+
+            // Set internal variables
+            Stream writeStream = null;
+            SevenZ oldZipFile = new SevenZ();
+            SevenZ zipFile = new SevenZ();
+            ZipReturn zipReturn = ZipReturn.ZipGood;
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+                }
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    zipReturn = zipFile.ZipFileCreate(tempFile);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), i);
+                    }
+
+                    // Sort the keys in TZIP order
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Now add all of the files in order
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // Open the input file for reading
+                        Stream freadStream = File.OpenRead(inputFiles[index]);
+                        ulong istreamSize = (ulong)(new FileInfo(inputFiles[index]).Length);
+
+                        DateTime dt = DateTime.Now;
+                        if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[index].Date) && DateTime.TryParse(baseFiles[index].Date.Replace('\\', '/'), out dt))
+                        {
+                            uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                            zipFile.ZipFileOpenWriteStream(false, false, baseFiles[index].Filename.Replace('\\', '/'), istreamSize, 0, msDosDateTime, out writeStream);
+                        }
+                        else
+                        {
+                            zipFile.ZipFileOpenWriteStream(false, true, baseFiles[index].Filename.Replace('\\', '/'), istreamSize, 0, null, out writeStream);
+                        }
+
+                        // Copy the input stream to the output
+                        byte[] ibuffer = new byte[_bufferSize];
+                        int ilen;
+                        while ((ilen = freadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                        {
+                            writeStream.Write(ibuffer, 0, ilen);
+                            writeStream.Flush();
+                        }
+
+                        freadStream.Dispose();
+                        zipFile.ZipFileCloseWriteStream(baseFiles[index].CRC);
+                    }
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldZipFile.ZipFileOpen(archiveFileName, -1, true);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        var oldZipFileContents = new List<string>();
+                        for (int j = 0; j < oldZipFile.LocalFilesCount(); j++)
+                        {
+                            oldZipFileContents.Add(oldZipFile.Filename(j));
+                        }
+
+                        // If the old one contains the new file, then just skip out
+                        if (oldZipFileContents.Contains(baseFiles[i].Filename.Replace('\\', '/')))
+                        {
+                            continue;
+                        }
+
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), -(i + 1));
+                    }
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        inputIndexMap.Add(oldZipFile.Filename(i), i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= oldZipFile.LocalFilesCount())
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Otherwise, process the old zipfile
+                    zipFile.ZipFileCreate(tempFile);
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Open the input file for reading
+                            Stream freadStream = File.OpenRead(inputFiles[-index - 1]);
+                            ulong istreamSize = (ulong)(new FileInfo(inputFiles[-index - 1]).Length);
+
+                            DateTime dt = DateTime.Now;
+                            if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[-index - 1].Date) && DateTime.TryParse(baseFiles[-index - 1].Date.Replace('\\', '/'), out dt))
+                            {
+                                uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                                zipFile.ZipFileOpenWriteStream(false, false, baseFiles[-index - 1].Filename.Replace('\\', '/'), istreamSize, 0, msDosDateTime, out writeStream);
+                            }
+                            else
+                            {
+                                zipFile.ZipFileOpenWriteStream(false, true, baseFiles[-index - 1].Filename.Replace('\\', '/'), istreamSize, 0, null, out writeStream);
+                            }
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = freadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+                            freadStream.Dispose();
+                            zipFile.ZipFileCloseWriteStream(baseFiles[-index - 1].CRC);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Instantiate the streams
+                            oldZipFile.ZipFileOpenReadStream(index, out Stream zreadStream, out ulong istreamSize);
+                            zipFile.ZipFileOpenWriteStream(false, true, oldZipFile.Filename(index), istreamSize, 0, null, out writeStream);
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = zreadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            zipFile.ZipFileCloseWriteStream(oldZipFile.CRC32(index));
+                        }
+                    }
+                }
+
+                // Close the output zip file
+                zipFile.ZipFileClose();
+                oldZipFile.ZipFileClose();
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+            {
+                File.Delete(archiveFileName);
+            }
+            File.Move(tempFile, archiveFileName);
+
+            return true;
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/TapeArchive.cs

@@ -0,0 +1,566 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using Compress.ZipFile;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Tar;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+using SharpCompress.Writers;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a Tape archive for reading and writing
+    /// </summary>
+    /// TODO: Don't try to read entries to MemoryStream during write
+    public class TapeArchive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new Tape archive with no base file
+        /// </summary>
+        public TapeArchive()
+            : base()
+        {
+            this.Type = FileType.TapeArchive;
+        }
+
+        /// <summary>
+        /// Create a new Tape archive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public TapeArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.TapeArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Extract all files to the temp directory
+                TarArchive ta = TarArchive.Open(this.Filename);
+                foreach (TarArchiveEntry entry in ta.Entries)
+                {
+                    entry.WriteToDirectory(outDir, new ExtractionOptions { PreserveFileTime = true, ExtractFullPath = true, Overwrite = true });
+                }
+                encounteredErrors = false;
+                ta.Dispose();
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry = null;
+
+            try
+            {
+                TarArchive ta = TarArchive.Open(this.Filename, new ReaderOptions { LeaveStreamOpen = false, });
+                foreach (TarArchiveEntry entry in ta.Entries)
+                {
+                    if (entry != null && !entry.IsDirectory && entry.Key.Contains(entryName))
+                    {
+                        // Write the file out
+                        realEntry = entry.Key;
+                        entry.WriteTo(ms);
+                    }
+                }
+                ta.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            List<BaseFile> found = new List<BaseFile>();
+            string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+            try
+            {
+                TarArchive ta = TarArchive.Open(File.OpenRead(this.Filename));
+                foreach (TarArchiveEntry entry in ta.Entries.Where(e => e != null && !e.IsDirectory))
+                {
+                    // Create a blank item for the entry
+                    BaseFile tarEntryRom = new BaseFile();
+
+                    // Perform a quickscan, if flagged to
+                    if (this.AvailableHashes == Hash.CRC)
+                    {
+                        tarEntryRom.Size = entry.Size;
+                        tarEntryRom.CRC = BitConverter.GetBytes(entry.Crc);
+                    }
+                    // Otherwise, use the stream directly
+                    else
+                    {
+                        using (Stream entryStream = entry.OpenEntryStream())
+                        {
+                            tarEntryRom = GetInfo(entryStream, size: entry.Size, hashes: this.AvailableHashes);
+                        }
+                    }
+
+                    // Fill in comon details and add to the list
+                    tarEntryRom.Filename = entry.Key;
+                    tarEntryRom.Parent = gamename;
+                    tarEntryRom.Date = entry.LastModifiedTime?.ToString("yyyy/MM/dd hh:mm:ss");
+                    found.Add(tarEntryRom);
+                }
+
+                // Dispose of the archive
+                ta.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                return null;
+            }
+
+            return found;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            List<string> empties = new List<string>();
+
+            try
+            {
+                TarArchive ta = TarArchive.Open(this.Filename, new ReaderOptions { LeaveStreamOpen = false });
+                List<TarArchiveEntry> tarEntries = ta.Entries.OrderBy(e => e.Key, new NaturalSort.NaturalReversedComparer()).ToList();
+                string lastTarEntry = null;
+                foreach (TarArchiveEntry entry in tarEntries)
+                {
+                    if (entry != null)
+                    {
+                        // If the current is a superset of last, we skip it
+                        if (lastTarEntry != null && lastTarEntry.StartsWith(entry.Key))
+                        {
+                            // No-op
+                        }
+                        // If the entry is a directory, we add it
+                        else if (entry.IsDirectory)
+                        {
+                            empties.Add(entry.Key);
+                            lastTarEntry = entry.Key;
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+            }
+
+            return empties;
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either input is null or empty, return
+            if (inputStream == null || baseFile == null || baseFile.Filename == null)
+                return success;
+
+            // If the stream is not readable, return
+            if (!inputStream.CanRead)
+                return success;
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFile.Parent) + (baseFile.Parent.EndsWith(".tar") ? string.Empty : ".tar"));
+
+            // Set internal variables
+            TarArchive oldTarFile = TarArchive.Create();
+            TarArchive tarFile = TarArchive.Create();
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    // Get temporary date-time if possible
+                    DateTime? usableDate = null;
+                    if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out DateTime dt))
+                        usableDate = dt;
+
+                    // Copy the input stream to the output
+                    inputStream.Seek(0, SeekOrigin.Begin);
+                    tarFile.AddEntry(baseFile.Filename, inputStream, size: baseFile.Size ?? 0, modified: usableDate);
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldTarFile = TarArchive.Open(archiveFileName);
+
+                    // Get a list of all current entries
+                    List<string> entries = oldTarFile.Entries.Select(i => i.Key).ToList();
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+
+                    // If the old one doesn't contain the new file, then add it
+                    if (!entries.Contains(baseFile.Filename.Replace('\\', '/')))
+                        inputIndexMap.Add(baseFile.Filename.Replace('\\', '/'), -1);
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < entries.Count; i++)
+                    {
+                        inputIndexMap.Add(entries[i], i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= entries.Count)
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // Get temporary date-time if possible
+                        DateTime? usableDate = null;
+                        if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out DateTime dt))
+                            usableDate = dt;
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Copy the input file to the output
+                            inputStream.Seek(0, SeekOrigin.Begin);
+                            tarFile.AddEntry(baseFile.Filename, inputStream, size: baseFile.Size ?? 0, modified: usableDate);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Get the stream from the original archive
+                            TarArchiveEntry tae = oldTarFile.Entries.ElementAt(index);
+                            MemoryStream entry = new MemoryStream();
+                            tae.OpenEntryStream().CopyTo(entry);
+
+                            // Copy the input stream to the output
+                            tarFile.AddEntry(key, entry, size: tae.Size, modified: tae.LastModifiedTime);
+                        }
+                    }
+                }
+
+                // Close the output tar file
+                tarFile.SaveTo(tempFile, new WriterOptions(CompressionType.None));
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+            finally
+            {
+                tarFile.Dispose();
+                oldTarFile.Dispose();
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+                File.Delete(archiveFileName);
+
+            File.Move(tempFile, archiveFileName);
+
+            return success;
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either list of roms is null or empty, return
+            if (inputFiles == null || baseFiles == null || inputFiles.Count == 0 || baseFiles.Count == 0)
+            {
+                return success;
+            }
+
+            // If the number of inputs is less than the number of available roms, return
+            if (inputFiles.Count < baseFiles.Count)
+            {
+                return success;
+            }
+
+            // If one of the files doesn't exist, return
+            foreach (string file in inputFiles)
+            {
+                if (!File.Exists(file))
+                {
+                    return success;
+                }
+            }
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFiles[0].Parent) + (baseFiles[0].Parent.EndsWith(".tar") ? string.Empty : ".tar"));
+
+            // Set internal variables
+            TarArchive oldTarFile = TarArchive.Create();
+            TarArchive tarFile = TarArchive.Create();
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+                }
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), i);
+                    }
+
+                    // Sort the keys in TZIP order
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Now add all of the files in order
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // Get temporary date-time if possible
+                        DateTime? usableDate = null;
+                        if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[index].Date) && DateTime.TryParse(baseFiles[index].Date.Replace('\\', '/'), out DateTime dt))
+                            usableDate = dt;
+
+                        // Copy the input stream to the output
+                        tarFile.AddEntry(baseFiles[index].Filename, File.OpenRead(inputFiles[index]), size: baseFiles[index].Size ?? 0, modified: usableDate);
+                    }
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldTarFile = TarArchive.Open(archiveFileName);
+
+                    // Get a list of all current entries
+                    List<string> entries = oldTarFile.Entries.Select(i => i.Key).ToList();
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        // If the old one contains the new file, then just skip out
+                        if (entries.Contains(baseFiles[i].Filename.Replace('\\', '/')))
+                        {
+                            continue;
+                        }
+
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), -(i + 1));
+                    }
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < entries.Count; i++)
+                    {
+                        inputIndexMap.Add(entries[i], i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= entries.Count)
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Get temporary date-time if possible
+                            DateTime? usableDate = null;
+                            if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[-index - 1].Date) && DateTime.TryParse(baseFiles[-index - 1].Date.Replace('\\', '/'), out DateTime dt))
+                                usableDate = dt;
+
+                            // Copy the input file to the output
+                            tarFile.AddEntry(baseFiles[-index - 1].Filename, File.OpenRead(inputFiles[-index - 1]), size: baseFiles[-index - 1].Size ?? 0, modified: usableDate);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Get the stream from the original archive
+                            TarArchiveEntry tae = oldTarFile.Entries.ElementAt(index);
+                            MemoryStream entry = new MemoryStream();
+                            tae.OpenEntryStream().CopyTo(entry);
+
+                            // Copy the input stream to the output
+                            tarFile.AddEntry(key, entry, size: tae.Size, modified: tae.LastModifiedTime);
+                        }
+                    }
+                }
+
+                // Close the output tar file
+                tarFile.SaveTo(tempFile, new WriterOptions(CompressionType.None));
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+            finally
+            {
+                tarFile.Dispose();
+                oldTarFile.Dispose();
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+            {
+                File.Delete(archiveFileName);
+            }
+            File.Move(tempFile, archiveFileName);
+
+            return true;
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/XZArchive.cs

@@ -0,0 +1,369 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using SabreTools.IO;
+using SharpCompress.Compressors.Xz;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a TorrentXZ archive for reading and writing
+    /// </summary>
+    public class XZArchive : BaseArchive
+    {
+        #region Constants
+
+        /* (Torrent)XZ Header Format
+            https://tukaani.org/xz/xz-file-format.txt
+
+            00-05		Identification (0xFD, '7', 'z', 'X', 'Z', 0x00) XzSignature
+            06			Flags (0x01 - CRC32, 0x04 - CRC64, 0x0A - SHA-256)
+            07-0A		Flags CRC32 (uint, little-endian)
+        */
+        private readonly static byte[] TorrentXZHeader = new byte[] { 0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x01, 0x69, 0x22, 0xde, 0x36 };
+
+        #endregion
+
+        #region Fields
+
+        /// <summary>
+        /// Positive value for depth of the output depot, defaults to 4
+        /// </summary>
+        public int Depth { get; set; } = 4;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a new TorrentGZipArchive with no base file
+        /// </summary>
+        public XZArchive()
+            : base()
+        {
+            this.Type = FileType.XZArchive;
+        }
+
+        /// <summary>
+        /// Create a new TorrentGZipArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public XZArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.XZArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Decompress the _filename stream
+                FileStream outstream = File.Create(Path.Combine(outDir, Path.GetFileNameWithoutExtension(this.Filename)));
+                var xz = new XZStream(File.OpenRead(this.Filename));
+                xz.CopyTo(outstream);
+
+                // Dispose of the streams
+                outstream.Dispose();
+                xz.Dispose();
+
+                encounteredErrors = false;
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry;
+
+            try
+            {
+                // Decompress the _filename stream
+                realEntry = Path.GetFileNameWithoutExtension(this.Filename);
+                var xz = new XZStream(File.OpenRead(this.Filename));
+
+                // Write the file out
+                byte[] xbuffer = new byte[_bufferSize];
+                int xlen;
+                while ((xlen = xz.Read(xbuffer, 0, _bufferSize)) > 0)
+                {
+
+                    ms.Write(xbuffer, 0, xlen);
+                    ms.Flush();
+                }
+
+                // Dispose of the streams
+                xz.Dispose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            if (_children == null || _children.Count == 0)
+            {
+                _children = new List<BaseFile>();
+
+                string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+                BaseFile possibleTxz = GetTorrentXZFileInfo();
+
+                // If it was, then add it to the outputs and continue
+                if (possibleTxz != null && possibleTxz.Filename != null)
+                {
+                    _children.Add(possibleTxz);
+                }
+                else
+                {
+                    try
+                    {
+                        // Create a blank item for the entry
+                        BaseFile xzEntryRom = new BaseFile();
+
+                        // Perform a quickscan, if flagged to
+                        if (this.AvailableHashes == Hash.CRC)
+                        {
+                            xzEntryRom.Filename = gamename;
+                            using (BinaryReader br = new BinaryReader(File.OpenRead(this.Filename)))
+                            {
+                                br.BaseStream.Seek(-8, SeekOrigin.End);
+                                xzEntryRom.CRC = br.ReadBytesBigEndian(4);
+                                xzEntryRom.Size = br.ReadInt32BigEndian();
+                            }
+                        }
+                        // Otherwise, use the stream directly
+                        else
+                        {
+                            var xzStream = new XZStream(File.OpenRead(this.Filename));
+                            xzEntryRom = GetInfo(xzStream, hashes: this.AvailableHashes);
+                            xzEntryRom.Filename = gamename;
+                            xzStream.Dispose();
+                        }
+
+                        // Fill in comon details and add to the list
+                        xzEntryRom.Parent = gamename;
+                        _children.Add(xzEntryRom);
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.Error(ex);
+                        return null;
+                    }
+                }
+            }
+
+            return _children;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            // XZ files don't contain directories
+            return new List<string>();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            // Check for the file existing first
+            if (!File.Exists(this.Filename))
+                return false;
+
+            string datum = Path.GetFileName(this.Filename).ToLowerInvariant();
+
+            // Check if the name is the right length
+            if (!Regex.IsMatch(datum, @"^[0-9a-f]{" + Constants.SHA1Length + @"}\.xz"))
+            {
+                logger.Warning($"Non SHA-1 filename found, skipping: '{Path.GetFullPath(this.Filename)}'");
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Retrieve file information for a single torrent XZ file
+        /// </summary>
+        /// <returns>Populated DatItem object if success, empty one on error</returns>
+        public BaseFile GetTorrentXZFileInfo()
+        {
+            // Check for the file existing first
+            if (!File.Exists(this.Filename))
+                return null;
+
+            string datum = Path.GetFileName(this.Filename).ToLowerInvariant();
+
+            // Check if the name is the right length
+            if (!Regex.IsMatch(datum, @"^[0-9a-f]{" + Constants.SHA1Length + @"}\.xz"))
+            {
+                logger.Warning($"Non SHA-1 filename found, skipping: '{Path.GetFullPath(this.Filename)}'");
+                return null;
+            }
+
+            BaseFile baseFile = new BaseFile
+            {
+                Filename = Path.GetFileNameWithoutExtension(this.Filename).ToLowerInvariant(),
+                SHA1 = Utilities.StringToByteArray(Path.GetFileNameWithoutExtension(this.Filename)),
+
+                Parent = Path.GetFileNameWithoutExtension(this.Filename).ToLowerInvariant(),
+            };
+
+            return baseFile;
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            // Check that the input file exists
+            if (!File.Exists(inputFile))
+            {
+                logger.Warning($"File '{inputFile}' does not exist!");
+                return false;
+            }
+
+            inputFile = Path.GetFullPath(inputFile);
+
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            bool success = false;
+
+            // If the stream is not readable, return
+            if (!inputStream.CanRead)
+                return success;
+
+            // Make sure the output directory exists
+            if (!Directory.Exists(outDir))
+                Directory.CreateDirectory(outDir);
+
+            outDir = Path.GetFullPath(outDir);
+
+            // Now get the Rom info for the file so we have hashes and size
+            baseFile = GetInfo(inputStream, keepReadOpen: true);
+
+            // Get the output file name
+            string outfile = Path.Combine(outDir, Utilities.GetDepotPath(Utilities.ByteArrayToString(baseFile.SHA1), Depth));
+            outfile = outfile.Replace(".gz", ".xz");
+
+            // Check to see if the folder needs to be created
+            if (!Directory.Exists(Path.GetDirectoryName(outfile)))
+                Directory.CreateDirectory(Path.GetDirectoryName(outfile));
+
+            // If the output file exists, don't try to write again
+            if (!File.Exists(outfile))
+            {
+                // Compress the input stream
+                XZStream outputStream = new XZStream(File.Create(outfile));
+                inputStream.CopyTo(outputStream);
+
+                // Dispose of everything
+                outputStream.Dispose();
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/ZPAQArchive.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a ZPAQArchive archive for reading and writing
+    /// </summary>
+    /// TODO: Implement from source at https://github.com/zpaq/zpaq - In progress as external DLL
+    public class ZPAQArchive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new ZPAQArchive with no base file
+        /// </summary>
+        public ZPAQArchive()
+            : base()
+        {
+            this.Type = FileType.ZPAQArchive;
+        }
+
+        /// <summary>
+        /// Create a new ZPAQArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public ZPAQArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.ZPAQArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/ZipArchive.cs

@@ -0,0 +1,818 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using Compress;
+using Compress.ZipFile;
+using NaturalSort;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a Zip archive for reading and writing
+    /// </summary>
+    public class ZipArchive : BaseArchive
+    {
+        #region Constants
+
+        private const uint LocalFileHeaderSignature = 0x04034b50;
+        private const uint EndOfLocalFileHeaderSignature = 0x08074b50;
+        private const uint CentralDirectoryHeaderSignature = 0x02014b50;
+        private const uint EndOfCentralDirSignature = 0x06054b50;
+        private const uint Zip64EndOfCentralDirSignature = 0x06064b50;
+        private const uint Zip64EndOfCentralDirectoryLocator = 0x07064b50;
+        private const uint TorrentZipFileDateTime = 0x2198BC00;
+
+        /* TorrentZip Header Format
+            https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE_6.2.0.txt
+            http://www.romvault.com/trrntzip_explained.doc
+
+            00-03		Local file header signature (0x50, 0x4B, 0x03, 0x04) ZipSignature
+            04-05		Version needed to extract (0x14, 0x00)
+            06-07		General purpose bit flag (0x02, 0x00)
+            08-09		Compression method (0x08, 0x00)
+            0A-0B		Last mod file time (0x00, 0xBC)
+            0C-0D		Last mod file date (0x98, 0x21)
+        */
+        private readonly static byte[] TorrentZipHeader = new byte[] { 0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0xbc, 0x98, 0x21 };
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a new TorrentZipArchive with no base file
+        /// </summary>
+        public ZipArchive()
+            : base()
+        {
+            this.Type = FileType.ZipArchive;
+        }
+
+        /// <summary>
+        /// Create a new TorrentZipArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="read">True for opening file as read, false for opening file as write</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public ZipArchive(string filename, bool getHashes = false)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.ZipArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            bool encounteredErrors = true;
+
+            try
+            {
+                // Create the temp directory
+                Directory.CreateDirectory(outDir);
+
+                // Extract all files to the temp directory
+                ZipFile zf = new ZipFile();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
+                {
+                    // Open the read stream
+                    zr = zf.ZipFileOpenReadStream(i, false, out Stream readStream, out ulong streamsize, out ushort cm);
+
+                    // Create the rest of the path, if needed
+                    if (!string.IsNullOrWhiteSpace(Path.GetDirectoryName(zf.Filename(i))))
+                    {
+                        Directory.CreateDirectory(Path.Combine(outDir, Path.GetDirectoryName(zf.Filename(i))));
+                    }
+
+                    // If the entry ends with a directory separator, continue to the next item, if any
+                    if (zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
+                    {
+                        zf.ZipFileCloseReadStream();
+                        continue;
+                    }
+
+                    FileStream writeStream = File.Create(Path.Combine(outDir, zf.Filename(i)));
+
+                    // If the stream is smaller than the buffer, just run one loop through to avoid issues
+                    if (streamsize < _bufferSize)
+                    {
+                        byte[] ibuffer = new byte[streamsize];
+                        int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                        writeStream.Write(ibuffer, 0, ilen);
+                        writeStream.Flush();
+                    }
+                    // Otherwise, we do the normal loop
+                    else
+                    {
+                        int realBufferSize = (streamsize < _bufferSize ? (int)streamsize : _bufferSize);
+                        byte[] ibuffer = new byte[realBufferSize];
+                        int ilen;
+                        while ((ilen = readStream.Read(ibuffer, 0, realBufferSize)) > 0)
+                        {
+                            writeStream.Write(ibuffer, 0, ilen);
+                            writeStream.Flush();
+                        }
+                    }
+
+                    zr = zf.ZipFileCloseReadStream();
+                    writeStream.Dispose();
+                }
+
+                zf.ZipFileClose();
+                encounteredErrors = false;
+            }
+            catch (EndOfStreamException ex)
+            {
+                // Catch this but don't count it as an error because SharpCompress is unsafe
+                logger.Verbose(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                logger.Warning(ex);
+                encounteredErrors = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                encounteredErrors = true;
+            }
+
+            return encounteredErrors;
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            // Try to extract a stream using the given information
+            (MemoryStream ms, string realEntry) = CopyToStream(entryName);
+
+            // If the memory stream and the entry name are both non-null, we write to file
+            if (ms != null && realEntry != null)
+            {
+                realEntry = Path.Combine(outDir, realEntry);
+
+                // Create the output subfolder now
+                Directory.CreateDirectory(Path.GetDirectoryName(realEntry));
+
+                // Now open and write the file if possible
+                FileStream fs = File.Create(realEntry);
+                if (fs != null)
+                {
+                    ms.Seek(0, SeekOrigin.Begin);
+                    byte[] zbuffer = new byte[_bufferSize];
+                    int zlen;
+                    while ((zlen = ms.Read(zbuffer, 0, _bufferSize)) > 0)
+                    {
+                        fs.Write(zbuffer, 0, zlen);
+                        fs.Flush();
+                    }
+
+                    ms?.Dispose();
+                    fs?.Dispose();
+                }
+                else
+                {
+                    ms?.Dispose();
+                    fs?.Dispose();
+                    realEntry = null;
+                }
+            }
+
+            return realEntry;
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            MemoryStream ms = new MemoryStream();
+            string realEntry = null;
+
+            try
+            {
+                ZipFile zf = new ZipFile();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
+                {
+                    if (zf.Filename(i).Contains(entryName))
+                    {
+                        // Open the read stream
+                        realEntry = zf.Filename(i);
+                        zr = zf.ZipFileOpenReadStream(i, false, out Stream readStream, out ulong streamsize, out ushort cm);
+
+                        // If the stream is smaller than the buffer, just run one loop through to avoid issues
+                        if (streamsize < _bufferSize)
+                        {
+                            byte[] ibuffer = new byte[streamsize];
+                            int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                            ms.Write(ibuffer, 0, ilen);
+                            ms.Flush();
+                        }
+                        // Otherwise, we do the normal loop
+                        else
+                        {
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while (streamsize > _bufferSize)
+                            {
+                                ilen = readStream.Read(ibuffer, 0, _bufferSize);
+                                ms.Write(ibuffer, 0, ilen);
+                                ms.Flush();
+                                streamsize -= _bufferSize;
+                            }
+
+                            ilen = readStream.Read(ibuffer, 0, (int)streamsize);
+                            ms.Write(ibuffer, 0, ilen);
+                            ms.Flush();
+                        }
+
+                        zr = zf.ZipFileCloseReadStream();
+                    }
+                }
+
+                zf.ZipFileClose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                ms = null;
+                realEntry = null;
+            }
+
+            return (ms, realEntry);
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            List<BaseFile> found = new List<BaseFile>();
+            string gamename = Path.GetFileNameWithoutExtension(this.Filename);
+
+            try
+            {
+                ZipFile zf = new ZipFile();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                for (int i = 0; i < zf.LocalFilesCount(); i++)
+                {
+                    // If the entry is a directory (or looks like a directory), we don't want to open it
+                    if (zf.IsDirectory(i)
+                        || zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString())
+                        || zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
+                    {
+                        continue;
+                    }
+
+                    // Open the read stream
+                    zr = zf.ZipFileOpenReadStream(i, false, out Stream readStream, out ulong streamsize, out ushort cm);
+
+                    // If we get a read error, log it and continue
+                    if (zr != ZipReturn.ZipGood)
+                    {
+                        logger.Warning($"An error occurred while reading archive {this.Filename}: Zip Error - {zr}");
+                        zr = zf.ZipFileCloseReadStream();
+                        continue;
+                    }
+
+                    // Create a blank item for the entry
+                    BaseFile zipEntryRom = new BaseFile();
+
+                    // Perform a quickscan, if flagged to
+                    if (this.AvailableHashes == Hash.CRC)
+                    {
+                        zipEntryRom.Size = (long)zf.UncompressedSize(i);
+                        zipEntryRom.CRC = zf.CRC32(i);
+                    }
+                    // Otherwise, use the stream directly
+                    else
+                    {
+                        zipEntryRom = GetInfo(readStream, size: (long)zf.UncompressedSize(i), hashes: this.AvailableHashes, keepReadOpen: true);
+                    }
+
+                    // Fill in comon details and add to the list
+                    zipEntryRom.Filename = zf.Filename(i);
+                    zipEntryRom.Parent = gamename;
+                    zipEntryRom.Date = zf.LastModified(i).ToString("yyyy/MM/dd hh:mm:ss");
+                    found.Add(zipEntryRom);
+                }
+
+                // Dispose of the archive
+                zr = zf.ZipFileCloseReadStream();
+                zf.ZipFileClose();
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                return null;
+            }
+
+            return found;
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            List<string> empties = new List<string>();
+
+            try
+            {
+                ZipFile zf = new ZipFile();
+                ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+                if (zr != ZipReturn.ZipGood)
+                {
+                    throw new Exception(ZipFile.ZipErrorMessageText(zr));
+                }
+
+                List<(string, bool)> zipEntries = new List<(string, bool)>();
+                for (int i = 0; i < zf.LocalFilesCount(); i++)
+                {
+                    zipEntries.Add((zf.Filename(i), zf.IsDirectory(i)));
+                }
+
+                zipEntries = zipEntries.OrderBy(p => p.Item1, new NaturalReversedComparer()).ToList();
+                string lastZipEntry = null;
+                foreach ((string, bool) entry in zipEntries)
+                {
+                    // If the current is a superset of last, we skip it
+                    if (lastZipEntry != null && lastZipEntry.StartsWith(entry.Item1))
+                    {
+                        // No-op
+                    }
+                    // If the entry is a directory, we add it
+                    else
+                    {
+                        if (entry.Item2)
+                        {
+                            empties.Add(entry.Item1);
+                        }
+                        lastZipEntry = entry.Item1;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+            }
+
+            return empties;
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            ZipFile zf = new ZipFile();
+            ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
+            if (zr != ZipReturn.ZipGood)
+            {
+                throw new Exception(ZipFile.ZipErrorMessageText(zr));
+            }
+
+            return zf.ZipStatus == ZipStatus.TrrntZip;
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            // Get the file stream for the file and write out
+            return Write(File.OpenRead(inputFile), outDir, baseFile);
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either input is null or empty, return
+            if (inputStream == null || baseFile == null || baseFile.Filename == null)
+                return success;
+
+            // If the stream is not readable, return
+            if (!inputStream.CanRead)
+                return success;
+
+            // Seek to the beginning of the stream
+            inputStream.Seek(0, SeekOrigin.Begin);
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFile.Parent) + (baseFile.Parent.EndsWith(".zip") ? string.Empty : ".zip"));
+
+            // Set internal variables
+            Stream writeStream = null;
+            ZipFile oldZipFile = new ZipFile();
+            ZipFile zipFile = new ZipFile();
+            ZipReturn zipReturn = ZipReturn.ZipGood;
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    inputStream.Seek(0, SeekOrigin.Begin);
+                    zipReturn = zipFile.ZipFileCreate(tempFile);
+
+                    // Open the input file for reading
+                    ulong istreamSize = (ulong)(inputStream.Length);
+
+                    DateTime dt = DateTime.Now;
+                    if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
+                    {
+                        uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                        zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+                    }
+                    else
+                    {
+                        zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, null, out writeStream);
+                    }
+
+                    // Copy the input stream to the output
+                    byte[] ibuffer = new byte[_bufferSize];
+                    int ilen;
+                    while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                    {
+                        writeStream.Write(ibuffer, 0, ilen);
+                        writeStream.Flush();
+                    }
+
+                    zipFile.ZipFileCloseWriteStream(baseFile.CRC);
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldZipFile.ZipFileOpen(archiveFileName, -1, true);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    var oldZipFileContents = new List<string>();
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        oldZipFileContents.Add(oldZipFile.Filename(i));
+                    }
+
+                    // If the old one doesn't contain the new file, then add it
+                    if (!oldZipFileContents.Contains(baseFile.Filename.Replace('\\', '/')))
+                        inputIndexMap.Add(baseFile.Filename.Replace('\\', '/'), -1);
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        inputIndexMap.Add(oldZipFile.Filename(i), i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= oldZipFile.LocalFilesCount())
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Otherwise, process the old zipfile
+                    zipFile.ZipFileCreate(tempFile);
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Open the input file for reading
+                            ulong istreamSize = (ulong)(inputStream.Length);
+
+                            DateTime dt = DateTime.Now;
+                            if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
+                            {
+                                uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                                zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+                            }
+                            else
+                            {
+                                zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, null, out writeStream);
+                            }
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            zipFile.ZipFileCloseWriteStream(baseFile.CRC);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Instantiate the streams
+                            oldZipFile.ZipFileOpenReadStream(index, false, out Stream zreadStream, out ulong istreamSize, out ushort icompressionMethod);
+                            uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(oldZipFile.LastModified(index));
+                            zipFile.ZipFileOpenWriteStream(false, true, oldZipFile.Filename(index), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = zreadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            oldZipFile.ZipFileCloseReadStream();
+                            zipFile.ZipFileCloseWriteStream(oldZipFile.CRC32(index));
+                        }
+                    }
+                }
+
+                // Close the output zip file
+                zipFile.ZipFileClose();
+                oldZipFile.ZipFileClose();
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+            finally
+            {
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+                File.Delete(archiveFileName);
+
+            File.Move(tempFile, archiveFileName);
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            bool success = false;
+            string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
+
+            // If either list of roms is null or empty, return
+            if (inputFiles == null || baseFiles == null || inputFiles.Count == 0 || baseFiles.Count == 0)
+            {
+                return success;
+            }
+
+            // If the number of inputs is less than the number of available roms, return
+            if (inputFiles.Count < baseFiles.Count)
+            {
+                return success;
+            }
+
+            // If one of the files doesn't exist, return
+            foreach (string file in inputFiles)
+            {
+                if (!File.Exists(file))
+                {
+                    return success;
+                }
+            }
+
+            // Get the output archive name from the first rebuild rom
+            string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFiles[0].Parent) + (baseFiles[0].Parent.EndsWith(".zip") ? string.Empty : ".zip"));
+
+            // Set internal variables
+            Stream writeStream = null;
+            ZipFile oldZipFile = new ZipFile();
+            ZipFile zipFile = new ZipFile();
+            ZipReturn zipReturn = ZipReturn.ZipGood;
+
+            try
+            {
+                // If the full output path doesn't exist, create it
+                if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
+                }
+
+                // If the archive doesn't exist, create it and put the single file
+                if (!File.Exists(archiveFileName))
+                {
+                    zipReturn = zipFile.ZipFileCreate(tempFile);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), i);
+                    }
+
+                    // Sort the keys in TZIP order
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Now add all of the files in order
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // Open the input file for reading
+                        Stream freadStream = File.OpenRead(inputFiles[index]);
+                        ulong istreamSize = (ulong)(new FileInfo(inputFiles[index]).Length);
+
+                        DateTime dt = DateTime.Now;
+                        if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[index].Date) && DateTime.TryParse(baseFiles[index].Date.Replace('\\', '/'), out dt))
+                        {
+                            uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                            zipFile.ZipFileOpenWriteStream(false, false, baseFiles[index].Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+                        }
+                        else
+                        {
+                            zipFile.ZipFileOpenWriteStream(false, true, baseFiles[index].Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, null, out writeStream);
+                        }
+
+                        // Copy the input stream to the output
+                        byte[] ibuffer = new byte[_bufferSize];
+                        int ilen;
+                        while ((ilen = freadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                        {
+                            writeStream.Write(ibuffer, 0, ilen);
+                            writeStream.Flush();
+                        }
+
+                        freadStream.Dispose();
+                        zipFile.ZipFileCloseWriteStream(baseFiles[index].CRC);
+                    }
+                }
+
+                // Otherwise, sort the input files and write out in the correct order
+                else
+                {
+                    // Open the old archive for reading
+                    oldZipFile.ZipFileOpen(archiveFileName, -1, true);
+
+                    // Map all inputs to index
+                    Dictionary<string, int> inputIndexMap = new Dictionary<string, int>();
+                    for (int i = 0; i < inputFiles.Count; i++)
+                    {
+                        var oldZipFileContents = new List<string>();
+                        for (int j = 0; j < oldZipFile.LocalFilesCount(); j++)
+                        {
+                            oldZipFileContents.Add(oldZipFile.Filename(j));
+                        }
+
+                        // If the old one contains the new file, then just skip out
+                        if (oldZipFileContents.Contains(baseFiles[i].Filename.Replace('\\', '/')))
+                        {
+                            continue;
+                        }
+
+                        inputIndexMap.Add(baseFiles[i].Filename.Replace('\\', '/'), -(i + 1));
+                    }
+
+                    // Then add all of the old entries to it too
+                    for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
+                    {
+                        inputIndexMap.Add(oldZipFile.Filename(i), i);
+                    }
+
+                    // If the number of entries is the same as the old archive, skip out
+                    if (inputIndexMap.Keys.Count <= oldZipFile.LocalFilesCount())
+                    {
+                        success = true;
+                        return success;
+                    }
+
+                    // Otherwise, process the old zipfile
+                    zipFile.ZipFileCreate(tempFile);
+
+                    // Get the order for the entries with the new file
+                    List<string> keys = inputIndexMap.Keys.ToList();
+                    keys.Sort(ZipFile.TrrntZipStringCompare);
+
+                    // Copy over all files to the new archive
+                    foreach (string key in keys)
+                    {
+                        // Get the index mapped to the key
+                        int index = inputIndexMap[key];
+
+                        // If we have the input file, add it now
+                        if (index < 0)
+                        {
+                            // Open the input file for reading
+                            Stream freadStream = File.OpenRead(inputFiles[-index - 1]);
+                            ulong istreamSize = (ulong)(new FileInfo(inputFiles[-index - 1]).Length);
+
+                            DateTime dt = DateTime.Now;
+                            if (UseDates && !string.IsNullOrWhiteSpace(baseFiles[-index - 1].Date) && DateTime.TryParse(baseFiles[-index - 1].Date.Replace('\\', '/'), out dt))
+                            {
+                                uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
+                                zipFile.ZipFileOpenWriteStream(false, false, baseFiles[-index - 1].Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+                            }
+                            else
+                            {
+                                zipFile.ZipFileOpenWriteStream(false, true, baseFiles[-index - 1].Filename.Replace('\\', '/'), istreamSize, (ushort)CompressionMethod.Deflated, null, out writeStream);
+                            }
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = freadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+                            freadStream.Dispose();
+                            zipFile.ZipFileCloseWriteStream(baseFiles[-index - 1].CRC);
+                        }
+
+                        // Otherwise, copy the file from the old archive
+                        else
+                        {
+                            // Instantiate the streams
+                            oldZipFile.ZipFileOpenReadStream(index, false, out Stream zreadStream, out ulong istreamSize, out ushort icompressionMethod);
+                            uint msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(oldZipFile.LastModified(index));
+                            zipFile.ZipFileOpenWriteStream(false, true, oldZipFile.Filename(index), istreamSize, (ushort)CompressionMethod.Deflated, msDosDateTime, out writeStream);
+
+                            // Copy the input stream to the output
+                            byte[] ibuffer = new byte[_bufferSize];
+                            int ilen;
+                            while ((ilen = zreadStream.Read(ibuffer, 0, _bufferSize)) > 0)
+                            {
+                                writeStream.Write(ibuffer, 0, ilen);
+                                writeStream.Flush();
+                            }
+
+                            zipFile.ZipFileCloseWriteStream(oldZipFile.CRC32(index));
+                        }
+                    }
+                }
+
+                // Close the output zip file
+                zipFile.ZipFileClose();
+                oldZipFile.ZipFileClose();
+
+                success = true;
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex);
+                success = false;
+            }
+
+            // If the old file exists, delete it and replace
+            if (File.Exists(archiveFileName))
+            {
+                File.Delete(archiveFileName);
+            }
+            File.Move(tempFile, archiveFileName);
+
+            return true;
+        }
+
+        #endregion
+    }
+}

SabreTools.FileTypes/Archives/ZstdArchive.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SabreTools.FileTypes.Archives
+{
+    /// <summary>
+    /// Represents a ZstdArchive archive for reading and writing
+    /// </summary>
+    /// TODO: Implement from source at https://github.com/skbkontur/ZstdNet
+    public class ZstdArchive : BaseArchive
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Create a new ZstdArchive with no base file
+        /// </summary>
+        public ZstdArchive()
+            : base()
+        {
+            this.Type = FileType.ZstdArchive;
+        }
+
+        /// <summary>
+        /// Create a new ZstdArchive from the given file
+        /// </summary>
+        /// <param name="filename">Name of the file to use as an archive</param>
+        /// <param name="getHashes">True if hashes for this file should be calculated, false otherwise (default)</param>
+        public ZstdArchive(string filename, bool getHashes)
+            : base(filename, getHashes)
+        {
+            this.Type = FileType.ZstdArchive;
+        }
+
+        #endregion
+
+        #region Extraction
+
+        /// <inheritdoc/>
+        public override bool CopyAll(string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override string CopyToFile(string entryName, string outDir)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override (MemoryStream, string) CopyToStream(string entryName)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Information
+
+        /// <inheritdoc/>
+        public override List<BaseFile> GetChildren()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetEmptyFolders()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool IsTorrent()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region Writing
+
+        /// <inheritdoc/>
+        public override bool Write(string inputFile, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        public override bool Write(List<string> inputFiles, string outDir, List<BaseFile> baseFiles)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}