Ejemplo n.º 1
0
        byte[] DecodeStream(Stream file, GgaMetaData meta)
        {
            int dst    = 0;
            var output = new byte[meta.Width * meta.Height * 4];

            using (var input = new BinaryReader(file, Encoding.ASCII, true))
            {
                var end_pos = input.BaseStream.Position + meta.CompSize;
                while (input.BaseStream.Position < end_pos)
                {
                    int code = input.ReadByte();
                    switch (code)
                    {
                    case 0:
                    {
                        int src   = dst - 4;
                        int count = input.ReadByte() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 1:
                    {
                        int src   = dst - 4;
                        int count = input.ReadUInt16() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 2:
                    {
                        int l   = input.ReadByte();
                        int src = dst - (l << 2);
                        System.Buffer.BlockCopy(output, src, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    case 3:
                    {
                        int l   = input.ReadUInt16();
                        int src = dst - (l << 2);
                        System.Buffer.BlockCopy(output, src, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    case 4:
                    {
                        int l     = input.ReadByte();
                        int src   = dst - (l << 2);
                        int count = input.ReadByte() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 5:
                    {
                        int l     = input.ReadByte();
                        int src   = dst - (l << 2);
                        int count = input.ReadUInt16() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 6:
                    {
                        int l     = input.ReadUInt16();
                        int src   = dst - (l << 2);
                        int count = input.ReadByte() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 7:
                    {
                        int l     = input.ReadUInt16();
                        int src   = dst - (l << 2);
                        int count = input.ReadUInt16() * 4;
                        Binary.CopyOverlapped(output, src, dst, count);
                        dst += count;
                        break;
                    }

                    case 8:
                    {
                        System.Buffer.BlockCopy(output, dst - 4, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    case 9:
                    {
                        int src = dst - (int)meta.Width * 4;
                        System.Buffer.BlockCopy(output, src, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    case 0x0a:
                    {
                        int src = dst - ((int)meta.Width * 4 + 4);
                        System.Buffer.BlockCopy(output, src, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    case 0x0b:
                    {
                        int src = dst - ((int)meta.Width * 4 - 4);
                        System.Buffer.BlockCopy(output, src, output, dst, 4);
                        dst += 4;
                        break;
                    }

                    default:
                    {
                        int count = (code - 11) * 4;
                        if (count != input.Read(output, dst, count))
                        {
                            throw new InvalidFormatException("Unexpected end of input");
                        }
                        dst += count;
                        break;
                    }
                    }
                }
                return(output);
            }
        }
Ejemplo n.º 2
0
 byte[] DecodeStream(Stream file, GgaMetaData meta)
 {
     int dst = 0;
     var output = new byte[meta.Width*meta.Height*4];
     using (var input = new BinaryReader (file, Encoding.ASCII, true))
     {
         var end_pos = input.BaseStream.Position + meta.CompSize;
         while (input.BaseStream.Position < end_pos)
         {
             int code = input.ReadByte();
             switch (code)
             {
             case 0:
                 {
                     int src = dst - 4;
                     int count = input.ReadByte() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 1:
                 {
                     int src = dst - 4;
                     int count = input.ReadUInt16() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 2:
                 {
                     int l = input.ReadByte();
                     int src = dst - (l << 2);
                     System.Buffer.BlockCopy (output, src, output, dst, 4);
                     dst += 4;
                     break;
                 }
             case 3:
                 {
                     int l = input.ReadUInt16();
                     int src = dst - (l << 2);
                     System.Buffer.BlockCopy (output, src, output, dst, 4);
                     dst += 4;
                     break;
                 }
             case 4:
                 {
                     int l = input.ReadByte();
                     int src = dst - (l << 2);
                     int count = input.ReadByte() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 5:
                 {
                     int l = input.ReadByte();
                     int src = dst - (l << 2);
                     int count = input.ReadUInt16() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 6:
                 {
                     int l = input.ReadUInt16();
                     int src = dst - (l << 2);
                     int count = input.ReadByte() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 7:
                 {
                     int l = input.ReadUInt16();
                     int src = dst - (l << 2);
                     int count = input.ReadUInt16() * 4;
                     Binary.CopyOverlapped (output, src, dst, count);
                     dst += count;
                     break;
                 }
             case 8:
                 {
                     System.Buffer.BlockCopy (output, dst-4, output, dst, 4);
                     dst += 4;
                     break;
                 }
             case 9:
                 {
                     int src = dst - (int)meta.Width * 4;
                     System.Buffer.BlockCopy (output, src, output, dst, 4);
                     dst += 4;
                     break;
                 }
             case 0x0a:
                 {
                     int src = dst - ((int)meta.Width * 4 + 4);
                     System.Buffer.BlockCopy (output, src, output, dst, 4);
                     dst += 4;
                     break;
                 }
             case 0x0b:
                 {
                     int src = dst - ((int)meta.Width * 4 - 4);
                     System.Buffer.BlockCopy (output, src, output, dst, 4);
                     dst += 4;
                     break;
                 }
             default:
                 {
                     int count = (code-11)*4;
                     if (count != input.Read (output, dst, count))
                         throw new InvalidFormatException ("Unexpected end of input");
                     dst += count;
                     break;
                 }
             }
         }
         return output;
     }
 }