예제 #1
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;
                }
            }
        }
예제 #2
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;
        }