Esempio n. 1
0
        public Stream DecodeStream(Stream s)
        {
            Huffman4     huff      = new Huffman4();
            MemoryStream outStream = new MemoryStream();

            huff.Decompress(s, s.Length, outStream);
            outStream.Position = 0;
            return(outStream);
        }
Esempio n. 2
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);
                }
            }
        }
Esempio n. 3
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);
        }