CnC_Remastered_Collection

MegafileBuilder.cs (6859B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // The Command & Conquer Map Editor and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // The Command & Conquer Map Editor and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 
 namespace MobiusEditor.Utility
 {
     public class MegafileBuilder : IDisposable
     {
         #region IDisposable Support
         private bool disposedValue = false;
 
         protected virtual void Dispose(bool disposing)
         {
             if (!disposedValue)
             {
                 if (disposing)
                 {
                     Out.Dispose();
                 }
 
                 disposedValue = true;
             }
         }
 
         public void Dispose()
         {
             Dispose(true);
         }
         #endregion
 
         private const float Version = 0.99f;
 
         public string RootPath { get; private set; }
 
         private Stream Out { get; set; }
 
         private List<(string, object)> Files = new List<(string, object)>();
 
         public MegafileBuilder(string rootPath, string outFile)
         {
             RootPath = rootPath.ToUpper();
             Out = new FileStream(outFile, FileMode.Create);
         }
 
         public void AddFile(string path)
         {
             if (File.Exists(path))
             {
                 Files.Add((Path.GetFileName(path), path));
             }
         }
 
         public void AddFile(string path, Stream stream)
         {
             Files.Add((Path.GetFileName(path), stream));
         }
 
         public void AddDirectory(string path)
         {
             AddDirectory(path, "*.*");
         }
 
         public void AddDirectory(string path, string searchPattern)
         {
             var uriPath = new Uri(path);
             foreach (var file in Directory.GetFiles(path, searchPattern, SearchOption.AllDirectories))
             {
                 var relativePath = Uri.UnescapeDataString(uriPath.MakeRelativeUri(new Uri(file)).ToString()).Replace('/', Path.DirectorySeparatorChar);
                 Files.Add((relativePath, file));
             }
         }
 
         public void Write()
         {
             var headerSize = sizeof(uint) * 6U;
             headerSize += SubFileData.Size * (uint)Files.Count;
 
             var strings = new List<string>();
             Func<string, ushort> stringIndex = (string value) =>
             {
                 var index = strings.IndexOf(value);
                 if (index < 0)
                 {
                     index = strings.Count;
                     if (index > ushort.MaxValue)
                     {
                         throw new IndexOutOfRangeException();
                     }
                     strings.Add(value);
                 }
                 return (ushort)index;
             };
 
             var files = new List<(ushort index, uint crc, Stream stream, bool dispose)>();
             foreach (var (filename, source) in Files)
             {
                 var name = Encoding.ASCII.GetBytes(filename);
                 var crc = CRC.Calculate(name);
 
                 if (source is string)
                 {
                     var file = source as string;
                     if (File.Exists(file))
                     {
                         files.Add((stringIndex(Path.Combine(RootPath, filename).ToUpper()), crc, new FileStream(file, FileMode.Open, FileAccess.Read), true));
                     }
                 }
                 else if (source is Stream)
                 {
                     files.Add((stringIndex(Path.Combine(RootPath, filename).ToUpper()), crc, source as Stream, false));
                 }
             }
             files = files.OrderBy(x => x.crc).ToList();
 
             var stringsSize = sizeof(ushort) * (uint)strings.Count;
             stringsSize += (uint)strings.Sum(x => x.Length);
             headerSize += stringsSize;
 
             var subfileImageOffset = headerSize;
             using (var writer = new BinaryWriter(Out))
             {
                 writer.Write(0xFFFFFFFF);
                 writer.Write(Version);
                 writer.Write(headerSize);
 
                 writer.Write((uint)Files.Count);
                 writer.Write((uint)strings.Count);
                 writer.Write(stringsSize);
 
                 foreach (var item in strings)
                 {
                     writer.Write((ushort)item.Length);
                     writer.Write(item.ToCharArray());
                 }
 
                 using (var fileStream = new MemoryStream())
                 {
                     for (var i = 0; i < files.Count; ++i)
                     {
                         var (index, crc, stream, dispose) = files[i];
 
                         var fileSize = (uint)(stream.Length - stream.Position);
                         var fileBytes = new byte[fileSize];
                         stream.Read(fileBytes, 0, fileBytes.Length);
                         fileStream.Write(fileBytes, 0, fileBytes.Length);
 
                         if (dispose)
                         {
                             stream.Dispose();
                         }
 
                         SubFileData data = new SubFileData
                         {
                             Flags = 0,
                             CRCValue = crc,
                             SubfileIndex = i,
                             SubfileSize = fileSize,
                             SubfileImageDataOffset = subfileImageOffset,
                             SubfileNameIndex = index
                         };
 
                         var ptr = Marshal.AllocHGlobal((int)SubFileData.Size);
                         Marshal.StructureToPtr(data, ptr, false);
                         var bytes = new byte[SubFileData.Size];
                         Marshal.Copy(ptr, bytes, 0, bytes.Length);
                         Marshal.FreeHGlobal(ptr);
 
                         writer.Write(bytes);
 
                         subfileImageOffset += data.SubfileSize;
                     }
 
                     fileStream.Seek(0, SeekOrigin.Begin);
                     fileStream.CopyTo(writer.BaseStream);
                 }
             }
         }
     }
 }