SHARE
TWEET

Packer

a guest Oct 21st, 2019 88 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.IO;
  3.  
  4. namespace ConsoleArchiver2
  5. {
  6.     delegate bool RLEOnChunk(/*float progress*/);
  7.     class RLEPacker
  8.     {
  9.         private RLEOnChunk onChunk;
  10.         private int chunkSize = 50;
  11.         public void PackStream(Stream input, Stream output)
  12.         {
  13.             //init
  14.             //cycle -- call OnChunk
  15.             byte[] buffer = new byte[256];
  16.             bool is_start = true;
  17.             bool is_same = false;
  18.             byte prev = 0;
  19.             byte newb = 0;
  20.             byte c = 0;
  21.             int i = 0;
  22.  
  23.             try
  24.             {
  25.                 prev = (byte) input.ReadByte();
  26.             }
  27.             catch
  28.             {
  29.                 return;
  30.             }
  31.  
  32.             try
  33.             {
  34.                 while (true)
  35.                 {
  36.                     i++;
  37.                     if (i == chunkSize)
  38.                     {
  39.                         if (onChunk())
  40.                             return;
  41.                         i = 0;
  42.                     }
  43.  
  44.                     if (is_start)
  45.                     {
  46.                         newb = (byte) input.ReadByte();
  47.  
  48.                         if (newb == prev)
  49.                         {
  50.                             c = 2;
  51.                             is_same = true;
  52.                         }
  53.                         else //newb != prev
  54.                         {
  55.                             c = 0;
  56.                             //EDIT?
  57.                             buffer[c] = prev;
  58.                             is_same = false;
  59.                         }
  60.  
  61.                         is_start = false;
  62.                     }
  63.                     else //not is_start
  64.                     {
  65.                         prev = newb;
  66.                         newb = (byte) input.ReadByte();
  67.  
  68.                         if (is_same)
  69.                         {
  70.                             if (newb == prev)
  71.                             {
  72.                                 c++;
  73.                                 if (c == 255)
  74.                                 {
  75.                                     output.WriteByte(c);
  76.                                     output.WriteByte(newb);
  77.                                     prev = (byte) input.ReadByte();
  78.                                     is_start = true;
  79.                                 }
  80.                             }
  81.                             else //newb != prev
  82.                             {
  83.                                 output.WriteByte(c);
  84.                                 output.WriteByte(prev);
  85.                                 prev = newb;
  86.                                 is_start = true;
  87.                             }
  88.                         }
  89.                         else //not is_same
  90.                         {
  91.                             if (newb == prev)
  92.                             {
  93.                                 output.WriteByte((byte) 0);
  94.                                 output.WriteByte(c);
  95.                                 output.Write(buffer, 0, c + 1);
  96.                             }
  97.                             else //newb != prev
  98.                             {
  99.                                 c++;
  100.                                 buffer[c] = prev;
  101.                                 if (c == 254)
  102.                                 {
  103.                                     //moot
  104.                                     prev = newb;
  105.                                     newb = (byte) input.ReadByte();
  106.                                     if (newb == prev)
  107.                                     {
  108.                                         output.WriteByte((byte) 0);
  109.                                         output.WriteByte(c);
  110.                                         output.Write(buffer, 0, c + 1);
  111.                                         c = 2;
  112.                                         is_same = true;
  113.                                     }
  114.                                     else //newb != prev
  115.                                     {
  116.                                         c++;
  117.                                         buffer[c] = prev;
  118.                                         output.WriteByte((byte) 0);
  119.                                         output.WriteByte(c);
  120.                                         output.Write(buffer, 0, c + 1);
  121.                                         prev = newb;
  122.                                         is_start = true;
  123.                                     }
  124.                                 }
  125.                             }
  126.                         }
  127.                     }
  128.                 }
  129.             }
  130.             catch
  131.             {
  132.                 if (is_start)
  133.                 {
  134.                     output.WriteByte((byte) 1);
  135.                     output.WriteByte(prev);
  136.                     return;
  137.                 }
  138.                 else //not is_start
  139.                 {
  140.                     if (is_same)
  141.                     {
  142.                         if (c == 255)
  143.                         {
  144.                             return;
  145.                         }
  146.                         else //c != 255
  147.                         {
  148.                             output.WriteByte(c);
  149.                             output.WriteByte(prev);
  150.                             return;
  151.                         }
  152.                     }
  153.                     else //not is_same
  154.                     {
  155.                         c++;
  156.                         buffer[c] = prev;
  157.                         output.WriteByte((byte) 0);
  158.                         output.WriteByte(c);
  159.                         output.Write(buffer, 0, c + 1);
  160.                     }
  161.                 }
  162.             }
  163.         }
  164.         public void UnpackStream(Stream input, Stream output)
  165.         {
  166.             //init
  167.             //cycle -- call OnChunk
  168.         }
  169.  
  170.         public void BindOnChunk(RLEOnChunk method)
  171.         {
  172.             onChunk = method;
  173.         }
  174.     }
  175. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top