public void Extract(string path, string dest_dir)
 {
     BZip2InputStream bz2stream = new BZip2InputStream(new FileStream( path, FileMode.Open));
     TarExtracter untar = new TarExtracter();
     untar.Extract(bz2stream, dest_dir);
     bz2stream.Close();
 }

		public void BasicRoundTrip()
		{
			MemoryStream ms = new MemoryStream();
			BZip2OutputStream outStream = new BZip2OutputStream(ms);
			
			byte[] buf = new byte[10000];
			System.Random rnd = new Random();
			rnd.NextBytes(buf);
			
			outStream.Write(buf, 0, buf.Length);
			outStream.Close();
			ms = new MemoryStream(ms.GetBuffer());
			ms.Seek(0, SeekOrigin.Begin);
			
			using (BZip2InputStream inStream = new BZip2InputStream(ms))
			{
				byte[] buf2 = new byte[buf.Length];
				int    pos  = 0;
				while (true) 
				{
					int numRead = inStream.Read(buf2, pos, 4096);
					if (numRead <= 0) 
					{
						break;
					}
					pos += numRead;
				}
			
				for (int i = 0; i < buf.Length; ++i) 
				{
					Assert.AreEqual(buf2[i], buf[i]);
				}
			}
		}

		public void CreateEmptyArchive()
		{
			MemoryStream ms = new MemoryStream();
			BZip2OutputStream outStream = new BZip2OutputStream(ms);
			outStream.Close();
			ms = new MemoryStream(ms.GetBuffer());
			
			ms.Seek(0, SeekOrigin.Begin);
			
			using (BZip2InputStream inStream = new BZip2InputStream(ms)) 
			{
				byte[] buffer = new byte[1024];
				int    pos  = 0;
				while (true) 
				{
					int numRead = inStream.Read(buffer, 0, buffer.Length);
					if (numRead <= 0) 
					{
						break;
					}
					pos += numRead;
				}
			
				Assert.AreEqual(pos, 0);
			}
		}

        public void BZip2_Compress_Extract_Test() {
            var plainStream = PlainText.ToStream();
            plainStream.Seek(0, SeekOrigin.Begin);

            var plainData = Encoding.UTF8.GetBytes(PlainText);
            byte[] compressedData;
            byte[] extractedData;

            // Compress
            using(var compressedStream = new MemoryStream())
            using(var bz2 = new BZip2OutputStream(compressedStream)) {
                bz2.Write(plainData, 0, plainData.Length);
                bz2.Close();
                compressedData = compressedStream.ToArray();
            }

            Assert.IsNotNull(compressedData);

            // Array.Resize(ref compressedData, compressedData.Length+1);
            // compressedData[compressedData.Length - 1] = (byte)0;

            // Extract
            using(var compressedStream = new MemoryStream(compressedData))
            using(var bz2 = new BZip2InputStream(compressedStream))
            using(var extractedStream = new MemoryStream()) {
                StreamTool.CopyStreamToStream(bz2, extractedStream);
                extractedData = extractedStream.ToArray();
            }


            Assert.IsNotNull(extractedData);
            string extractedText = Encoding.UTF8.GetString(extractedData).TrimEnd('\0');

            Assert.AreEqual(PlainText, extractedText);
        }

        /// <summary>
        /// 압축된 데이타를 복원한다.
        /// </summary>
        /// <param name="input">복원할 Data</param>
        /// <returns>복원된 Data</returns>
        public override byte[] Decompress(byte[] input) {
            if(IsDebugEnabled)
                log.Debug(CompressorTool.SR.DecompressStartMsg);

            // check input data
            if(input.IsZeroLength()) {
                if(IsDebugEnabled)
                    log.Debug(CompressorTool.SR.InvalidInputDataMsg);

                return CompressorTool.EmptyBytes;
            }

            byte[] output;
            using(var inStream = new MemoryStream(input)) {
                using(var bz2 = new BZip2InputStream(inStream))
                using(var outStream = new MemoryStream(input.Length * 2)) {
                    StreamTool.CopyStreamToStream(bz2, outStream, CompressorTool.BUFFER_SIZE);
                    output = outStream.ToArray();
                }
            }

            if(IsDebugEnabled)
                log.Debug(CompressorTool.SR.DecompressResultMsg, input.Length, output.Length, output.Length / (double)input.Length);

            return output;
        }

 public static void Untbz(Stream stream, string outDirPath)
 {
     using (var inputStream = new BZip2InputStream(stream)) {
         var archive = TarArchive.CreateInputTarArchive(inputStream);
         archive.AsciiTranslate = false;
         archive.ExtractContents(outDirPath);
     }
 }

        /// <summary> Loads a TrigradCompressed image from a stream. </summary>
        public TrigradCompressed(Stream s)
        {
            using (BZip2InputStream dezipper = new BZip2InputStream(s))
            using (BinaryReader reader = new BinaryReader(dezipper))
            {
                Width = reader.ReadUInt16();
                Height = reader.ReadUInt16();

                uint count = reader.ReadUInt32();

                Point[] points = new Point[count];

                for (int i = 0; i < count; i++)
                    points[i].X = reader.ReadUInt16();
                for (int i = 0; i < count; i++)
                    points[i].Y = reader.ReadUInt16();

                ColorStruct[] colors = new ColorStruct[count];

                for (int i = 0; i < count; i++)
                    colors[i].R = reader.ReadByte();
                for (int i = 0; i < count; i++)
                    colors[i].G = reader.ReadByte();
                for (int i = 0; i < count; i++)
                    colors[i].B = reader.ReadByte();

                for (int i = 0; i < count; i++)
                {
                    SampleTable.Add(points[i],colors[i].Color);
                }

                uint meshCount = reader.ReadUInt32();

                SampleTri[] tris = new SampleTri[meshCount];

                for (int i = 0; i < meshCount; i++)
                    tris[i] = new SampleTri();

                for (int i = 0; i < meshCount; i++)
                    tris[i].U = new Sample(points[reader.ReadInt32()], new Pixel(Color.Black));

                for (int i = 0; i < meshCount; i++)
                    tris[i].V = new Sample(points[reader.ReadInt32()], new Pixel(Color.Black));

                for (int i = 0; i < meshCount; i++)
                    tris[i].W = new Sample(points[reader.ReadInt32()], new Pixel(Color.Black));

                foreach (var tri in tris)
                {
                    tri.U.Color = SampleTable[tri.U.Point];
                    tri.V.Color = SampleTable[tri.V.Point];
                    tri.W.Color = SampleTable[tri.W.Point];
                }

                Mesh = tris.ToList();
            }
        }

        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine("Usage : MtUnZip {NameOfOsm.Bz2} {MtIsEnabled}");
                return;
            }

            if (!File.Exists(args[0]))
            {
                Console.WriteLine("File {0} does not exist", args[0]);
                return;
            }

            bool mtIsEnabled = bool.Parse(args[1]);

            var timer = Stopwatch.StartNew();

            var unzipper = new BZip2InputStream(File.OpenRead(args[0]));

            Stream bufferedReader = unzipper;
            if (mtIsEnabled)
                bufferedReader = new MultiThreadBufferedReader(unzipper);

            var rd = XmlReader.Create(bufferedReader);

            var nodeNameCounts = new List<NodeStats>();

            while (rd.Read())
            {
                if (rd.NodeType == XmlNodeType.Element)
                {
                    var name = rd.Name;

                    var stats = nodeNameCounts.FirstOrDefault(nodeStats => nodeStats.Name == name);
                    if (stats == null)
                    {
                        stats = new NodeStats(name);
                        nodeNameCounts.Add(stats);
                    }

                    stats.Update(rd);
                }
            }

            nodeNameCounts.Sort((lhs, rhs) => lhs.Name.CompareTo(rhs.Name));

            foreach (var stats in nodeNameCounts)
            {
                Console.WriteLine("{0,20} : {1,10:N0}", stats.Name, stats.Count);
            }

            Console.WriteLine("Took {0:N0} [ms]", timer.ElapsedMilliseconds);
            Console.WriteLine("Total Processor time {0:N0} [ms]", Process.GetCurrentProcess().TotalProcessorTime.TotalMilliseconds);
        }

        // about 800ms here, not that slow.
        public static void ExtractTemplate(string packedTemplatePath)
        {
            var appRootDir = Path.GetDirectoryName(Application.ExecutablePath);

            using (var packedTemplate = File.OpenRead(packedTemplatePath))
            using (var bz2 = new BZip2InputStream(packedTemplate))
            using (var tar = TarArchive.CreateInputTarArchive(bz2))
            {
                tar.ExtractContents(appRootDir);
            }
        }

		public static void Decompress(Stream instream, Stream outstream) 
		{
			System.IO.Stream bos = outstream;
			System.IO.Stream bis = instream;
			BZip2InputStream bzis = new BZip2InputStream(bis);
			int ch = bzis.ReadByte();
			while (ch != -1) {
				bos.WriteByte((byte)ch);
				ch = bzis.ReadByte();
			}
			bos.Flush();
		}

 private static void RemoveLineBreaks(string source, string destination)
 {
     Parallel.ForEach(Directory.GetFiles(source, "*.bz2"), file =>
     {
         using(var fileStream = new FileStream(file, FileMode.Open))
         using (var bz2Stream = new BZip2InputStream(fileStream))
         using(var reader = new StreamReader(bz2Stream))
         {
             var content = reader.ReadToEnd().Replace(Environment.NewLine, string.Empty);
             File.WriteAllText(Path.Combine(destination, Path.GetFileNameWithoutExtension(file)), content);
         }
     });
 }

        public static byte[] Decompress(byte[] input, int uncompressedLength)
        {
            Contract.Requires(input != null);
            Contract.Requires(uncompressedLength >= 0);
            Contract.Ensures(Contract.Result<byte[]>() != null);
            Contract.Ensures(Contract.Result<byte[]>().Length == uncompressedLength);

            var output = new byte[uncompressedLength];

            using (var stream = new BZip2InputStream(new MemoryStream(input, false)))
                stream.Read(output, 0, uncompressedLength);

            return output;
        }

        /// <summary>
        /// 解压缩字符串(ICSharpCode.SharpZipLib版)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string Decompress(string input)
        {
            string result = string.Empty;
            byte[] buffer = Convert.FromBase64String(input);
            using (Stream inputStream = new MemoryStream(buffer))
            {
                BZip2InputStream zipStream = new BZip2InputStream(inputStream);

                using (StreamReader reader = new StreamReader(zipStream, Encoding.UTF8))
                {
                    //输出
                    result = reader.ReadToEnd();
                }
            }
            return result;
        }

        /// <summary>
        /// Decompress the <paramref name="inStream">input</paramref> writing 
        /// uncompressed data to the <paramref name="outStream">output stream</paramref>
        /// </summary>
        /// <param name="inStream">The readable stream containing data to decompress.</param>
        /// <param name="outStream">The output stream to receive the decompressed data.</param>
        /// <param name="isStreamOwner">Both streams are closed on completion if true.</param>
        public static void Decompress(Stream inStream, Stream outStream, bool isStreamOwner) {
            if (inStream==null||outStream==null) {
                throw new Exception("Null Stream");
            }

            try {
                using (var bzipInput=new BZip2InputStream(inStream)) {
                    bzipInput.IsStreamOwner=isStreamOwner;
                    StreamUtils.Copy(bzipInput, outStream, new byte[4096]);
                }
            } finally {
                if (isStreamOwner) {
                    // inStream is closed by the BZip2InputStream if stream owner
                    outStream.Dispose();
                }
            }
        }

        private static Stopwatch ParseDisks(Action<Disk> addToBatch)
        {
            int i = 0;
            var parser = new Parser();
            var buffer = new byte[1024*1024];// more than big enough for all files

            var sp = Stopwatch.StartNew();

            using (var bz2 = new BZip2InputStream(File.Open(@"D:\Data\freedb-complete-20120101.tar.bz2", FileMode.Open)))
            using (var tar = new TarInputStream(bz2))
            {
                TarEntry entry;
                while((entry=tar.GetNextEntry()) != null)
                {
                    if(entry.Size == 0 || entry.Name == "README" || entry.Name == "COPYING")
                        continue;
                    var readSoFar = 0;
                    while(true)
                    {
                        var read = tar.Read(buffer, readSoFar, ((int) entry.Size) - readSoFar);
                        if (read == 0)
                            break;

                        readSoFar += read;
                    }
                    // we do it in this fashion to have the stream reader detect the BOM / unicode / other stuff
                    // so we can read the values properly
                    var fileText = new StreamReader(new MemoryStream(buffer,0, readSoFar)).ReadToEnd();
                    try
                    {
                        var disk = parser.Parse(fileText);
                        addToBatch(disk);
                        if (i++ % BatchSize == 0)
                            Console.Write("\r{0} {1:#,#}  {2}         ", entry.Name, i, sp.Elapsed);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine();
                        Console.WriteLine(entry.Name);
                        Console.WriteLine(e);
                        return sp;
                    }
                }
            }
            return sp;
        }

        public DebArchiveInputStream(Stream inputStream)
            : base(inputStream)
        {
            this.arIn = new ArArchiveInputStream (inputStream);

            ArArchiveEntry binary = arIn.GetNextArEntry ();
            if (!binary.Name.Equals ("debian-binary"))
            {
                // TODO Customize
                throw new IOException ("Invalid name, expected debian-binary, readed:" + binary.Name);
            }
            ArArchiveEntry control = arIn.GetNextArEntry ();
            if (!control.Name.Equals ("control.tar.gz"))
            {
                throw new IOException ("Invalid name, expected control.tar.gz, readed:" + control.Name);
            }
            ArArchiveEntry data = arIn.GetNextArEntry ();
            Stream compressedStream = null;
            if (data.Name.Equals ("data.tar.gz"))
            {
                compressedStream = new GZipStream (arIn, CompressionMode.Decompress);

            }
            else if (data.Name.Equals ("data.tar.bz2"))
            {
                compressedStream = new BZip2InputStream (arIn);
            }
            else if (data.Name.Equals ("data.tar.bz2"))
            {
                compressedStream = new LZMAInputStream (arIn);

            }
            else if (data.Name.Equals ("data.tar"))
            {
                compressedStream = arIn;
            }
            else
            {
                throw new IOException ("Unsupported compressed data:" + data.Name);
            }
            this.tarStream = new TarInputStream (compressedStream);
        }

		public static void Decompress(Stream inStream, Stream outStream) 
		{
			if ( inStream == null ) {
				throw new ArgumentNullException("inStream");
			}
			
			if ( outStream == null ) {
				throw new ArgumentNullException("outStream");
			}
			
			using ( outStream ) {
				using ( BZip2InputStream bzis = new BZip2InputStream(inStream) ) {
					int ch = bzis.ReadByte();
					while (ch != -1) {
						outStream.WriteByte((byte)ch);
						ch = bzis.ReadByte();
					}
				}
			}
		}

        private static void ParseDisks(BulkInsertOperation insert)
        {
            int i = 0;
            var parser = new Parser();
            var buffer = new byte[1024*1024];// more than big enough for all files

            using (var bz2 = new BZip2InputStream(File.Open(@"D:\Scratch\freedb-complete-20150101.tar.bz2", FileMode.Open)))
            using (var tar = new TarInputStream(bz2))
            {
                TarEntry entry;
                while((entry=tar.GetNextEntry()) != null)
                {
                    if(entry.Size == 0 || entry.Name == "README" || entry.Name == "COPYING")
                        continue;

                    var readSoFar = 0;
                    while(true)
                    {
                        var read = tar.Read(buffer, readSoFar, ((int) entry.Size) - readSoFar);
                        if (read == 0)
                            break;

                        readSoFar += read;
                    }
                    // we do it in this fashion to have the stream reader detect the BOM / unicode / other stuff
                    // so we can read the values properly
                    var fileText = new StreamReader(new MemoryStream(buffer,0, readSoFar)).ReadToEnd();
                    try
                    {
                        var disk = parser.Parse(fileText);
                        insert.Store(disk);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine();
                        Console.WriteLine(entry.Name);
                        Console.WriteLine(e);
                    }
                }
            }
        }

    public static string UnzipString(string compbytes)
    {
        string result;
        MemoryStream m_msBZip2 = null;
        BZip2InputStream m_isBZip2 = null;
        try
        {
            m_msBZip2 = new MemoryStream(Convert.FromBase64String(compbytes));
            // read final uncompressed string size stored in first 4 bytes
            //
            using (BinaryReader reader = new BinaryReader(m_msBZip2, System.Text.Encoding.ASCII))
            {
                Int32 size = reader.ReadInt32();

                m_isBZip2 = new BZip2InputStream(m_msBZip2);
                byte[] bytesUncompressed = new byte[size];
                m_isBZip2.Read(bytesUncompressed, 0, bytesUncompressed.Length);
                m_isBZip2.Close();
                m_msBZip2.Close();

                result = Encoding.ASCII.GetString(bytesUncompressed);

                reader.Close();
            }
        }
        finally
        {
            if (m_isBZip2 != null)
            {
                m_isBZip2.Dispose();
            }
            if (m_msBZip2 != null)
            {
                m_msBZip2.Dispose();
            }
        }
        return result;
    }

        /// <summary>
        /// required for applying a binary patch
        /// </summary>
        private FileStream bz2read(ref BZip2InputStream bz, Int32 offset, string fname)
        {
            FileStream ReturnValue;
            FileStream fs;

            try
            {
                fs = new FileStream(fname, FileMode.Open, FileAccess.Read, FileShare.Read);
                fs.Seek(offset, SeekOrigin.Begin);
                bz = new BZip2InputStream(fs);
                ReturnValue = fs;
            }
            catch (Exception e)
            {
                throw new Exception("Cannot open file " + fname + " for reading; " + e.Message);
            }
            return ReturnValue;
        }