Пример #1
0
        private static int CompressBest(string infile, MemoryStream output, out FormatCompress actualFormat, params FormatCompress[] formats)
        {
            // only read the input data once from the file.
            byte[] inputData;
            using (FileStream inStream = File.OpenRead(infile))
            {
                inputData = new byte[inStream.Length];
                inStream.Read(inputData, 0, inputData.Length);
            }

            MemoryStream bestOutput = null;
            int minCompSize = int.MaxValue;
            actualFormat = FormatCompress.GBA;
            foreach (FormatCompress format in formats)
            {
                #region compress the file in each format, and save the best one

                MemoryStream currentOutput = new MemoryStream();
                CompressionFormat realFormat = null;
                switch (format)
                {
                    case FormatCompress.HUFF4: Huffman.CompressBlockSize = Huffman.BlockSize.FOURBIT; realFormat = new Huffman(); break;
                    case FormatCompress.HUFF8: Huffman.CompressBlockSize = Huffman.BlockSize.EIGHTBIT; realFormat = new Huffman(); break;
                    case FormatCompress.LZ10: realFormat = new LZ10(); break;
                    case FormatCompress.LZ11: realFormat = new LZ11(); break;
                    case FormatCompress.LZOVL: realFormat = new LZOvl(); break;
                    case FormatCompress.RLE: realFormat = new RLE(); break;
                }

                int currentOutSize;
                try
                {
                    using (MemoryStream inStream = new MemoryStream(inputData))
                    {
                        currentOutSize = realFormat.Compress(inStream, inStream.Length, currentOutput);
                    }
                }
                catch (InputTooLargeException i)
                {
                    Console.WriteLine(i.Message);
                    actualFormat = format;
                    return -1;
                }
                catch (Exception)
                {
                    continue;
                }
                if (currentOutSize < minCompSize)
                {
                    bestOutput = currentOutput;
                    minCompSize = currentOutSize;
                    actualFormat = format;
                }

                #endregion
            }

            if (bestOutput == null)
            {
                Console.WriteLine(Main.Get_Traduction("S1A"));
                return -1;
            }
            bestOutput.WriteTo(output);
            return minCompSize;
        }
Пример #2
0
 private static long Decompress(MemoryStream inputStream, MemoryStream output, FormatCompress format)
 {
     CompressionFormat realFormat = null;
     switch (format)
     {
         case FormatCompress.HUFF:
             realFormat = new Huffman(); break;
         case FormatCompress.LZ10:
             realFormat = new LZ10(); break;
         case FormatCompress.LZ11:
             realFormat = new LZ11(); break;
         case FormatCompress.LZOVL:
             realFormat = new LZOvl(); break;
         case FormatCompress.RLE:
             realFormat = new RLE(); break;
         default:
             return -1;
     }
     if (!realFormat.Supports(inputStream, inputStream.Length))
         return -1;
     try
     {
         return realFormat.Decompress(inputStream, inputStream.Length, output);
     }
     catch (TooMuchInputException e)
     {
         Console.WriteLine(e.Message);
         return output.Length;
     }
     catch (Exception e)
     {
         Console.WriteLine(String.Format(Main.Get_Traduction("S1D"), format.ToString(), e.Message));
         return -1;
     }
 }
Пример #3
0
        public static FormatCompress Get_Format(FileStream input, bool arm9)
        {
            CompressionFormat fmt = null;

            foreach (FormatCompress f in Enum.GetValues(typeof(FormatCompress)))
            {
                switch (f)
                {
                    //case FormatCompress.LZOVL: fmt = new LZOvl(); break;
                    case FormatCompress.LZ10: fmt = new LZ10(); break;
                    case FormatCompress.LZ11: fmt = new LZ11(); break;
                    case FormatCompress.RLE: fmt = new RLE(); break;
                    case FormatCompress.HUFF: fmt = new Huffman(); break;
                }

                if (fmt == null)
                    continue;

                long fLength = input.Length;
                if (arm9)
                    fLength -= 0xC;

                if (fmt.Supports(input, fLength))
                    return f;
            }

            return FormatCompress.Invalid;
        }
Пример #4
0
        public static FormatCompress Get_Format(string input)
        {
            CompressionFormat fmt = null;

            foreach (FormatCompress f in Enum.GetValues(typeof(FormatCompress)))
            {
                switch (f)
                {
                    //case FormatCompress.LZOVL: fmt = new LZOvl(); break;
                    case FormatCompress.LZ10: fmt = new LZ10(); break;
                    case FormatCompress.LZ11: fmt = new LZ11(); break;
                    case FormatCompress.RLE: fmt = new RLE(); break;
                    case FormatCompress.HUFF: fmt = new Huffman(); break;
                }

                if (fmt == null)
                    continue;

                if (fmt.Supports(input))
                    return f;
            }

            return FormatCompress.Invalid;
        }
Пример #5
0
        public static int DoCompress(string infile, MemoryStream output, FormatCompress format, out FormatCompress actualFormat)
        {
            CompressionFormat fmt = null;
            switch (format)
            {
                case FormatCompress.LZ10: fmt = new LZ10(); break;
                case FormatCompress.LZ11: fmt = new LZ11(); break;
                case FormatCompress.LZOVL: fmt = new LZOvl(); break;
                case FormatCompress.RLE: fmt = new RLE(); break;
                case FormatCompress.HUFF4: Huffman.CompressBlockSize = Huffman.BlockSize.FOURBIT; fmt = new Huffman(); break;
                case FormatCompress.HUFF8: Huffman.CompressBlockSize = Huffman.BlockSize.EIGHTBIT; fmt = new Huffman(); break;
                case FormatCompress.HUFF:
                    return CompressHuff(infile, output, out actualFormat);
                case FormatCompress.GBA:
                    return CompressGBA(infile, output, out actualFormat);
                case FormatCompress.NDS:
                    return CompressNDS(infile, output, out actualFormat);
                default:
                    actualFormat = FormatCompress.Invalid;
                    return -1;
            }
            actualFormat = format;

            using (FileStream inStream = File.OpenRead(infile))
            {
                try
                {
                    return fmt.Compress(inStream, inStream.Length, output);
                }
                catch (Exception s)
                {
                    // any exception generated by compression is a fatal exception
                    Console.WriteLine(s.Message);
                    return -1;
                }
            }
        }
Пример #6
0
        private static int DoCompress(string infile, MemoryStream output, Formats format, out Formats actualFormat)
        {
            CompressionFormat fmt = null;
            switch (format)
            {
                case Formats.LZ10: fmt = new LZ10(); break;
                case Formats.LZ11: fmt = new LZ11(); break;
                case Formats.LZOVL: fmt = new LZOvl(); break;
                case Formats.RLE: fmt = new RLE(); break;
                case Formats.HUFF4: fmt = new Huffman4(); break;
                case Formats.HUFF8: fmt = new Huffman8(); break;
                case Formats.HUFF:
                    return CompressHuff(infile, output, out actualFormat);
                case Formats.GBA:
                    return CompressGBA(infile, output, out actualFormat);
                case Formats.NDS:
                    return CompressNDS(infile, output, out actualFormat);
                default:
                    throw new Exception("Unhandled compression format " + format);
            }
            actualFormat = format;

            using (FileStream inStream = File.OpenRead(infile))
            {
                try
                {
                    return fmt.Compress(inStream, inStream.Length, output);
                }
                catch (Exception s)
                {
                    // any exception generated by compression is a fatal exception
                    Console.WriteLine(s.Message);
                    return -1;
                }
            }
        }
Пример #7
0
        private static int CompressBest(string infile, MemoryStream output, out Formats actualFormat, params Formats[] formats)
        {
            // only read the input data once from the file.
            byte[] inputData;
            using (FileStream inStream = File.OpenRead(infile))
            {
                inputData = new byte[inStream.Length];
                inStream.Read(inputData, 0, inputData.Length);
            }

            MemoryStream bestOutput = null;
            int minCompSize = int.MaxValue;
            actualFormat = Formats.GBA;
            foreach (Formats format in formats)
            {
                #region compress the file in each format, and save the best one

                MemoryStream currentOutput = new MemoryStream();
                CompressionFormat realFormat = null;
                switch (format)
                {
                    case Formats.HUFF4: realFormat = new Huffman4(); break;
                    case Formats.HUFF8: realFormat = new Huffman8(); break;
                    case Formats.LZ10: realFormat = new LZ10(); break;
                    case Formats.LZ11: realFormat = new LZ11(); break;
                    case Formats.LZOVL: realFormat = new LZOvl(); break;
                    case Formats.RLE: realFormat = new RLE(); break;
                    default:
                        Console.WriteLine("Unsupported single format: "+format);
                        continue;
                }

                int currentOutSize;
                try
                {
                    using (MemoryStream inStream = new MemoryStream(inputData))
                    {
                        currentOutSize = realFormat.Compress(inStream, inStream.Length, currentOutput);
                    }
                }
                catch (InputTooLargeException i)
                {
                    Console.WriteLine(i.Message);
                    actualFormat = format;
                    return -1;
                }
                catch (Exception)
                {
                    continue;
                }
                if (currentOutSize < minCompSize)
                {
                    bestOutput = currentOutput;
                    minCompSize = currentOutSize;
                    actualFormat = format;
                }

                #endregion
            }

            if (bestOutput == null)
            {
                Console.WriteLine("The file could not be compressed in any format.");
                return -1;
            }
            bestOutput.WriteTo(output);
            return minCompSize;
        }