System.IO.BinaryReader.ReadUInt16BE()

Here are the examples of the csharp api System.IO.BinaryReader.ReadUInt16BE() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1 Examples 7

19 Source : Decompressor.cs
with MIT License
from Pathos0925

public static byte[] Attempt(byte[] input)
        {
            using (Stream abInputStream = new MemoryStream(input))
            {
                //replacedetbundles are BigEndien
                using (BinaryReader abReader = new BinaryReader(abInputStream))
                {
                    //strings end with a zero byte
                    string signature = abReader.ReadZeroedString();
                    int generation = abReader.ReadInt32BE();
                    string PlayerVersion = abReader.ReadZeroedString();
                    string engineVersion = abReader.ReadZeroedString();

                    Int64 bundlesize = abReader.ReadInt64BE();
                    long metadataCompressedSizeLocation = abInputStream.Position;
                    Int32 MetadataCompressedSize = abReader.ReadInt32BE();
                    Int32 MetadataDecompressedSize = abReader.ReadInt32BE();

                    var Flags = (BundleFlag)abReader.ReadInt32BE();


                    long dataPosition = abInputStream.Position;
                    dataPosition += MetadataCompressedSize;

                    Int32 blockInfoLength;
                    UInt32 blockDecompressedSize;
                    UInt32 blockCompressedSize;
                    BundleFlag blockFlags;
                    List<MetadataInfo> metadataList = new List<MetadataInfo>();
                    Int32 metaDataCount;
                    //Int64 mdoffset;
                    //Int64 mdsize;
                    //Int32 mdblobindex;
                    //string mdname;

                    using (MemoryStream memStream = new MemoryStream(MetadataDecompressedSize))
                    {
                        byte[] compressedBytes = new byte[MetadataCompressedSize];
                        abInputStream.Read(compressedBytes, 0, MetadataCompressedSize);
                        abInputStream.Position -= MetadataCompressedSize;

                        byte[] LZ4decompressBuffer = new byte[MetadataDecompressedSize];
                        Debug.Log("LZ4 decompressing...");
                        LZ4Codec.Decode(compressedBytes, 0, compressedBytes.Length, LZ4decompressBuffer, 0, LZ4decompressBuffer.Length, true); //WebGL compatable LZMA

                        //LZ4decompressBuffer = LZ4.decompressBuffer(compressedBytes, false, MetadataDecompressedSize);
                        /*
                        using (Lz4Stream lzStream = new Lz4Stream(stream, MetadataCompressedSize))
                        {
                            long read = lzStream.Read(memStream, MetadataDecompressedSize);
                        }
                        */

                        byte[] shouldBe = new byte[MetadataDecompressedSize];
                        memStream.Position = 0;
                        memStream.Read(shouldBe, 0, MetadataDecompressedSize);

                        memStream.Position = 0;
                        memStream.Write(LZ4decompressBuffer, 0, MetadataDecompressedSize);


                        memStream.Position = 0;

                        using (BinaryReader metadataReader = new BinaryReader(memStream))
                        {
                            memStream.Position += 0x10;

                            blockInfoLength = metadataReader.ReadInt32BE();//1
                            blockDecompressedSize = metadataReader.ReadUInt32BE();
                            blockCompressedSize = metadataReader.ReadUInt32BE();
                            blockFlags = (BundleFlag)metadataReader.ReadUInt16BE();

                            metaDataCount = metadataReader.ReadInt32BE();//1
                            for (int i = 0; i < metaDataCount; i++)
                            {
                                var newInfo = new MetadataInfo();
                                newInfo.offset = metadataReader.ReadInt64BE();//0
                                newInfo.size = metadataReader.ReadInt64BE();
                                newInfo.blobIndex = metadataReader.ReadInt32BE();//4
                                newInfo.name = metadataReader.ReadZeroedString();//guid
                                metadataList.Add(newInfo);
                            }
                            
                        }
                    }

                    MetadataCompressedSize = MetadataDecompressedSize; //update
                    blockFlags &= (BundleFlag)(~BundleCompressType.LZMA); //remove compression flag

                    using (MemoryStream outWriterStream = new MemoryStream())
                    {
                        using (BinaryReader outWriter = new BinaryReader(outWriterStream, new System.Text.UTF8Encoding(false)))
                        {
                            outWriter.WriteZeroedString(signature);

                            outWriter.Write((Int32)generation);
                            outWriter.WriteZeroedString(PlayerVersion);
                            
                            outWriter.WriteZeroedString(engineVersion);
                            var bundleSizePos = outWriterStream.Position;
                            outWriter.Write((long)bundlesize);

                            var metaDataCompressedSizePos = outWriterStream.Position;
                            outWriter.Write((Int32)MetadataDecompressedSize);//placeholder
                            outWriter.Write((Int32)MetadataDecompressedSize);

                            outWriter.Write((Int32)(Flags));


                            long preCompressLocation = 0;
                            using (MemoryStream mdStreamWriter = new MemoryStream())
                            {
                                using (BinaryReader mdwriter = new BinaryReader(mdStreamWriter, new System.Text.UTF8Encoding(false)))
                                {
                                    mdwriter.Write(new byte[16]);//unknown, presumed buffer
                                    mdwriter.Write((Int32)blockInfoLength);
                                    mdwriter.Write(blockDecompressedSize);//would have been compressed size
                                    mdwriter.Write(blockDecompressedSize);
                                    mdwriter.Write((UInt16)blockFlags);
                                    mdwriter.Write((Int32)metaDataCount);//metadata count //should be 1
                                    for (int i = 0; i < metaDataCount; i++)
                                    {
                                        mdwriter.Write(metadataList[i].offset);
                                        mdwriter.Write(metadataList[i].size);
                                        mdwriter.Write(metadataList[i].blobIndex);
                                        mdwriter.WriteZeroedString(metadataList[i].name);
                                    }
  

                                    mdStreamWriter.Position = 0;

                                    preCompressLocation = outWriterStream.Position;

                                    byte[] mdUncompressed = new byte[mdStreamWriter.Length];
                                    byte[] LZ4CompressBuffer = new byte[mdUncompressed.Length];
                                    mdStreamWriter.Read(mdUncompressed, 0, mdUncompressed.Length);
                                    Debug.Log("LZ4 recompressing...");

                                    //LZ4CompressBuffer = LZ4.compressBuffer(mdUncompressed, 1, false);
                                    //var outputLength = LZ4Codec.Encode(inputBuffer, 0, inputLength,outputBuffer, 0, maximumLength);
                                    //recompress metadata. Appearently, it cannot be uncompressed.
                                    var outputLength = LZ4Codec.Encode(mdUncompressed, 0, mdUncompressed.Length, LZ4CompressBuffer, 0, mdUncompressed.Length);

                                    Array.Resize<byte>(ref LZ4CompressBuffer, outputLength); //care for heap size

                                    outWriterStream.Write(LZ4CompressBuffer, 0, LZ4CompressBuffer.Length);
                                }
                            }


                            long postCompressLocation = outWriterStream.Position;
                            var compressedSize = postCompressLocation - preCompressLocation;

                            outWriterStream.Position = metaDataCompressedSizePos;
                            outWriter.Write((Int32)compressedSize);//update compressed size
                            outWriterStream.Position = postCompressLocation;

                            long totalSize = 0;

                            abInputStream.Position = dataPosition;
                            var compressedBuffer = new byte[blockCompressedSize];
                            var lzmaProperties = new byte[5]; //probably not needed?
                            abInputStream.Read(lzmaProperties, 0, lzmaProperties.Length);

                            abInputStream.Read(compressedBuffer, 0, (int)blockCompressedSize - lzmaProperties.Length); // 

                            var decompressedBuffer = new byte[blockDecompressedSize];
                            Debug.Log("LZMA decompressing, good luck!");
                            var result = lzma.decompressBufferFixed(compressedBuffer, ref decompressedBuffer, false, false, (int)blockDecompressedSize);


                            //lzma.decompressreplacedetBundle(compressedBuffer, ref decompressedBuffer);
                            /*
                            using (MemoryStream memStream2 = new MemoryStream())
                            {
                                SevenZipHelper.DecompressLZMAStream(stream, blockCompressedSize, memStream2, blockDecompressedSize);
                                totalSize = memStream2.Length;
                                memStream2.Position = 0;
                                memStream2.CopyTo(memStream);
                            }
                            */

                            Debug.Log("Writing buffer to stream, size: " + blockDecompressedSize.ToString());
                            outWriterStream.Write(decompressedBuffer, 0, (int)blockDecompressedSize);
                            totalSize = outWriterStream.Length; //I dont think this is used? Should this be only the size of the decompressed block?

                            outWriterStream.Position = bundleSizePos;
                            outWriter.Write((long)totalSize);
                            outWriterStream.Position = 0;


                            Debug.Log("Allocating return bytes, size: " + totalSize.ToString());
                            byte[] bytes = new byte[totalSize];
                            Debug.Log("Reading stream to bytes...");
                            outWriterStream.Read(bytes, 0, (int)totalSize);
                            //bytes[138] = (byte)20; // I had hoped it was that easy


                            //WebGL can *probably* parse replacedetbundles made for standalone windows, so we'll just say that it is
                            //Appearently this doesnt work in later versions of unity. Interesting.
                            Debug.Log("Finding platform id...");
                            byte[] toFind = new byte[] { 0x35, 0x2E, 0x36, 0x2E, 0x33, 0x70, 0x31, 0x00 };
                            bool found = false;
                            int index = (int)postCompressLocation;
                            while (!found)
                            {
                                byte[] buffer = new byte[toFind.Length];
                                Array.Copy(bytes, index, buffer, 0, buffer.Length);
                                index++;
                                bool match = true;
                                for (int i = 0; i < buffer.Length; i++)
                                {
                                    //Look for: 5.*.*** 
                                    //consider using regex

                                    if (i == 0 || i == 1 || i == 3)
                                    {
                                        if (buffer[i] != toFind[i])
                                        {
                                            break;
                                        }
                                    }   
                                    
                                    if (i == buffer.Length - 1)
                                        found = true;
                                }
                                if (index > 200)
                                {
                                    Debug.Log("Couldent find platform id location."); //avatar will not load, and will probably crash the webgl player
                                    return null;
                                }
                            }
                            bytes[index + toFind.Length - 1] = (byte)20; // 20 is for WebGL compiled replacedetbundles.

                            Debug.Log("Returning bytes");
                            return bytes;
                        }
                    }
                }
            }

            return null;
        }