Exemplo n.º 1
0
            public async Task <byte[]> Save()
            {
                if (!this.WasCompressed)
                {
                    return(this.Data);
                }

                byte[] data;

                try
                {
                    using (MemoryStream inputStream = new MemoryStream(this.Data))
                        using (MemoryStream outputStream = new MemoryStream())
                        {
                            await Lzss.Compress(inputStream, this.Data.Length, outputStream, original : true);

                            data = outputStream.ToArray();
                        }
                }
                catch
                {
                    data = new byte[0];
                }

                return(data);
            }
Exemplo n.º 2
0
        public static async Task <bool> GarcPackMS(string folderPath, string garcPath, int version, int bytesPadding)
        {
            // Check to see if our input folder exists.
            if (!new DirectoryInfo(folderPath).Exists)
            {
                return(false);
            }

            if (version != Version4 && version != Version6)
            {
                throw new FormatException("Invalid GARC Version: 0x" + version.ToString("X4"));
            }

            // Okay some basic proofing is done. Proceed.
            int filectr = 0;

            // Get the paths of the files to pack up.
            string[] files   = Directory.GetFiles(folderPath);
            string[] folders = Directory.GetDirectories(folderPath, "*.*", SearchOption.TopDirectoryOnly);

            string[] packOrder = new string[files.Length + folders.Length];

            #region Reassemble a list of filenames.

            try
            {
                foreach (string f in files)
                {
                    string fn = Path.GetFileNameWithoutExtension(f);

                    if (fn == null)
                    {
                        continue;
                    }

                    int compressed = fn.IndexOf("dec_", StringComparison.Ordinal);
                    int fileNumber = compressed < 0
                                                                                 ? int.Parse(fn)
                                                                                 : int.Parse(fn.Substring(compressed + 4));

                    packOrder[fileNumber] = f;
                    filectr++;
                }
                foreach (string f in folders)
                {
                    packOrder[int.Parse(new DirectoryInfo(f).Name)] = f;
                    filectr += Directory.GetFiles(f).Length;
                }
            }
            catch (Exception)
            {
                return(false);
            }

            #endregion

            // Set Up the GARC template.
            GarcDef garc = new GarcDef {
                ContentPadToNearest = 4,
                Fato =
                {
                    // Magic = new[] { 'O', 'T', 'A', 'F' },
                    Entries    = new GarcDef.FatoEntry[packOrder.Length],
                    EntryCount = (ushort)packOrder.Length,
                    HeaderSize =              0xC + packOrder.Length * 4,
                    Padding    = 0xFFFF
                },
                Fatb =
                {
                    // Magic = new[] { 'B', 'T', 'A', 'F' },
                    Entries   = new GarcDef.FatbEntry[packOrder.Length],
                    FileCount = filectr
                }
            };
            if (version == Version6)
            {
                // Some files have larger bytes-to-pad values (ex/ 0x80 for a109)
                // Hopefully there's no problems defining this with a constant number.
                garc.ContentPadToNearest = 4;
            }

            #region Start Reassembling the FAT* tables.

            {
                int op = 0;
                int od = 0;
                int v  = 0;
                for (int i = 0; i < garc.Fatb.Entries.Length; i++)
                {
                    garc.Fato.Entries[i].Offset     = op; // FATO offset
                    garc.Fatb.Entries[i].SubEntries = new GarcDef.FatbSubEntry[32];
                    op += 4;                              // Vector
                    if (!Directory.Exists(packOrder[i]))  // is not folder
                    {
                        garc.Fatb.Entries[i].IsFolder             = false;
                        garc.Fatb.Entries[i].SubEntries[0].Exists = true;

                        string fn = Path.GetFileNameWithoutExtension(packOrder[i]);

                        if (fn == null)
                        {
                            continue;
                        }

                        int compressed = fn.IndexOf("dec_", StringComparison.Ordinal);
                        int fileNumber = compressed < 0
                                                                                         ? int.Parse(fn)
                                                                                         : int.Parse(fn.Substring(compressed + 4));

                        if (compressed >= 0)
                        {
                            string old = packOrder[i];
                            await Lzss.Compress(packOrder[i], packOrder[i] = Path.Combine(Path.GetDirectoryName(packOrder[i]), fileNumber.ToString()));

                            File.Delete(old);
                        }

                        // Assemble Vector
                        v = 1;

                        // Assemble Entry
                        FileInfo fi           = new FileInfo(packOrder[i]);
                        int      actualLength = (int)(fi.Length % 4 == 0
                                                                                                           ? fi.Length
                                                                                                           : fi.Length + 4 - fi.Length % 4);
                        garc.Fatb.Entries[i].SubEntries[0].Start  = od;
                        garc.Fatb.Entries[i].SubEntries[0].End    = actualLength + garc.Fatb.Entries[i].SubEntries[0].Start;
                        garc.Fatb.Entries[i].SubEntries[0].Length = (int)fi.Length;
                        od += actualLength;

                        op += 12;
                    }
                    else
                    {
                        garc.Fatb.Entries[i].IsFolder = true;
                        string[] subFiles = Directory.GetFiles(packOrder[i]);
                        foreach (string f in subFiles)
                        {
                            string s  = f;
                            string fn = Path.GetFileNameWithoutExtension(f);

                            if (fn == null)
                            {
                                continue;
                            }

                            int compressed = fn.IndexOf("dec_", StringComparison.Ordinal);
                            int fileNumber = compressed < 0
                                                                                                 ? int.Parse(fn)
                                                                                                 : int.Parse(fn.Substring(compressed + 4));
                            garc.Fatb.Entries[i].SubEntries[fileNumber].Exists = true;

                            if (compressed >= 0)
                            {
                                await Lzss.Compress(f, s = Path.Combine(Path.GetDirectoryName(f), fileNumber.ToString()));

                                File.Delete(f);
                            }

                            // Assemble Vector
                            v |= 1 << fileNumber;

                            // Assemble Entry
                            FileInfo fi           = new FileInfo(s);
                            int      actualLength = (int)(fi.Length % 4 == 0
                                                                                                                   ? fi.Length
                                                                                                                   : fi.Length + 4 - fi.Length % 4);
                            garc.Fatb.Entries[i].SubEntries[fileNumber].Start  = od;
                            garc.Fatb.Entries[i].SubEntries[fileNumber].End    = actualLength + garc.Fatb.Entries[i].SubEntries[fileNumber].Start;
                            garc.Fatb.Entries[i].SubEntries[fileNumber].Length = (int)fi.Length;
                            od += actualLength;

                            op += 12;
                        }
                    }
                    garc.Fatb.Entries[i].Vector = (uint)v;
                }
                garc.Fatb.HeaderSize = 0xC + op;
            }

            #endregion

            // Delete the old garc if it exists, then begin writing our new one
            try
            {
                File.Delete(garcPath);
            }
            catch
            {
                // ignored
            }

            // Set up the Header Info
            using (var newGarc = new FileStream(garcPath, FileMode.Create))
                using (var ms = new MemoryStream())
                    using (BinaryWriter gw = new BinaryWriter(ms))
                    {
                        #region Write GARC Headers

                        // Write GARC
                        gw.Write((uint)0x47415243);            // GARC
                        gw.Write((uint)(version == Version6
                                                                           ? 0x24
                                                                           : 0x1C)); // Header Length
                        gw.Write((ushort)0xFEFF);                                    // Endianness BOM
                        gw.Write((ushort)version);                                   // Version
                        gw.Write((uint)0x00000004);                                  // Section Count (4)
                        gw.Write((uint)0x00000000);                                  // Data Offset (temp)
                        gw.Write((uint)0x00000000);                                  // File Length (temp)
                        gw.Write((uint)0x00000000);                                  // Largest File Size (temp)

                        if (version == Version6)
                        {
                            gw.Write((uint)0x0);
                            gw.Write((uint)0x0);
                        }

                        // Write FATO
                        gw.Write((uint)0x4641544F);            // FATO
                        gw.Write(garc.Fato.HeaderSize);        // Header Size
                        gw.Write(garc.Fato.EntryCount);        // Entry Count
                        gw.Write(garc.Fato.Padding);           // Padding
                        for (int i = 0; i < garc.Fato.Entries.Length; i++)
                        {
                            gw.Write((uint)garc.Fato.Entries[i].Offset);
                        }

                        // Write FATB
                        gw.Write((uint)0x46415442);            // FATB
                        gw.Write(garc.Fatb.HeaderSize);        // Header Size
                        gw.Write(garc.Fatb.FileCount);         // File Count
                        foreach (var e in garc.Fatb.Entries)
                        {
                            gw.Write(e.Vector);
                            foreach (var s in e.SubEntries.Where(s => s.Exists))
                            {
                                gw.Write((uint)s.Start);
                                gw.Write((uint)s.End);
                                gw.Write((uint)s.Length);
                            }
                        }

                        // Write FIMB
                        gw.Write((uint)0x46494D42);      // FIMB
                        gw.Write((uint)0x0000000C);      // Header Length
                        var dataLen = gw.BaseStream.Position;
                        gw.Write((uint)0);               // Data Length - TEMP

                        gw.Seek(0x10, SeekOrigin.Begin); // Goto the start of the un-set 0 data we set earlier and set it.
                        var hdrLen = gw.BaseStream.Position;
                        gw.Write((uint)0);               // Write Data Offset - TEMP
                        gw.Write((uint)0);               // Write total GARC Length - TEMP

                        // Write Handling information
                        if (version == Version4)
                        {
                            gw.Write(garc.ContentLargestUnpadded);               // Write Largest File stat
                        }
                        else if (version == Version6)
                        {
                            gw.Write(garc.ContentLargestPadded);               // Write Largest With Padding
                            gw.Write(garc.ContentLargestUnpadded);             // Write Largest Without Padding
                            gw.Write(garc.ContentPadToNearest);
                        }

                        newGarc.Seek(0, SeekOrigin.End);           // Goto the end so we can copy the filedata after the GARC headers.

                        #endregion

                        #region Write Files

                        var ghLength = gw.BaseStream.Length;

                        long largestSize   = 0;       // Required memory to allocate to handle the largest file
                        long largestPadded = 0;       // Required memory to allocate to handle the largest PADDED file (Ver6 only)
                        foreach (string e in packOrder)
                        {
                            string[] fa = Directory.Exists(e)
                                                                          ? Directory.GetFiles(e)
                                                                          : new[] { e };
                            foreach (string f in fa)
                            {
                                // Update largest file length if necessary
                                long len     = new FileInfo(f).Length;
                                int  padding = (int)(len % bytesPadding);
                                if (padding != 0)
                                {
                                    padding = bytesPadding - padding;
                                }
                                bool largest = len > largestSize;
                                if (largest)
                                {
                                    largestSize   = len;
                                    largestPadded = len + padding;
                                }

                                // Write to FIMB
                                using (var x = File.OpenRead(f))
                                    x.CopyTo(newGarc);

                                // While length is not divisible by 4, pad with FF (unused byte)
                                while (padding-- > 0)
                                {
                                    gw.Write((byte)0xFF);
                                }
                            }
                        }
                        garc.ContentLargestUnpadded = (uint)largestSize;
                        garc.ContentLargestPadded   = (uint)largestPadded;
                        var gdLength = gw.BaseStream.Length - ghLength;

                        #endregion

                        gw.Seek((int)dataLen, SeekOrigin.Begin);
                        gw.Write((uint)gdLength);             // Data Length
                        gw.Seek((int)hdrLen, SeekOrigin.Begin);
                        gw.Write((uint)ghLength);             // Write Data Offset
                        gw.Write((uint)gw.BaseStream.Length); // Write total GARC Length

                        // Write Handling information
                        switch (version)
                        {
                        case Version4:
                            gw.Write(garc.ContentLargestUnpadded);                       // Write Largest File stat
                            break;

                        case Version6:
                            gw.Write(garc.ContentLargestPadded);                       // Write Largest With Padding
                            gw.Write(garc.ContentLargestUnpadded);                     // Write Largest Without Padding
                            gw.Write(garc.ContentPadToNearest);
                            break;
                        }

                        await ms.CopyToAsync(newGarc);

                        return(true);
                    }
        }