Packer

using System;
using System.IO;

namespace ConsoleArchiver2
{
    delegate bool RLEOnChunk(/*float progress*/);
    class RLEPacker
    {
        private RLEOnChunk onChunk;
        private int chunkSize = 50;
        public void PackStream(Stream input, Stream output)
        {
            //init
            //cycle -- call OnChunk
            byte[] buffer = new byte[256];
            bool is_start = true;
            bool is_same = false;
            byte prev = 0;
            byte newb = 0;
            byte c = 0;
            int i = 0;

            try
            {
                prev = (byte) input.ReadByte();
            }
            catch
            {
                return;
            }

            try
            {
                while (true)
                {
                    i++;
                    if (i == chunkSize)
                    {
                        if (onChunk())
                            return;
                        i = 0;
                    }

                    if (is_start)
                    {
                        newb = (byte) input.ReadByte();

                        if (newb == prev)
                        {
                            c = 2;
                            is_same = true;
                        }
                        else //newb != prev
                        {
                            c = 0;
                            //EDIT?
                            buffer[c] = prev;
                            is_same = false;
                        }

                        is_start = false;
                    }
                    else //not is_start
                    {
                        prev = newb;
                        newb = (byte) input.ReadByte();

                        if (is_same)
                        {
                            if (newb == prev)
                            {
                                c++;
                                if (c == 255)
                                {
                                    output.WriteByte(c);
                                    output.WriteByte(newb);
                                    prev = (byte) input.ReadByte();
                                    is_start = true;
                                }
                            }
                            else //newb != prev
                            {
                                output.WriteByte(c);
                                output.WriteByte(prev);
                                prev = newb;
                                is_start = true;
                            }
                        }
                        else //not is_same
                        {
                            if (newb == prev)
                            {
                                output.WriteByte((byte) 0);
                                output.WriteByte(c);
                                output.Write(buffer, 0, c + 1);
                            }
                            else //newb != prev
                            {
                                c++;
                                buffer[c] = prev;
                                if (c == 254)
                                {
                                    //moot
                                    prev = newb;
                                    newb = (byte) input.ReadByte();
                                    if (newb == prev)
                                    {
                                        output.WriteByte((byte) 0);
                                        output.WriteByte(c);
                                        output.Write(buffer, 0, c + 1);
                                        c = 2;
                                        is_same = true;
                                    }
                                    else //newb != prev
                                    {
                                        c++;
                                        buffer[c] = prev;
                                        output.WriteByte((byte) 0);
                                        output.WriteByte(c);
                                        output.Write(buffer, 0, c + 1);
                                        prev = newb;
                                        is_start = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch
            {
                if (is_start)
                {
                    output.WriteByte((byte) 1);
                    output.WriteByte(prev);
                    return;
                }
                else //not is_start
                {
                    if (is_same)
                    {
                        if (c == 255)
                        {
                            return;
                        }
                        else //c != 255
                        {
                            output.WriteByte(c);
                            output.WriteByte(prev);
                            return;
                        }
                    }
                    else //not is_same
                    {
                        c++;
                        buffer[c] = prev;
                        output.WriteByte((byte) 0);
                        output.WriteByte(c);
                        output.Write(buffer, 0, c + 1);
                    }
                }
            }
        }
        public void UnpackStream(Stream input, Stream output)
        {
            //init
            //cycle -- call OnChunk
        }

        public void BindOnChunk(RLEOnChunk method)
        {
            onChunk = method;
        }
    }
}