Пример #1
0
        private unsafe void method_20(
            Class442 page,
            MemoryStream sectionStream,
            ulong crcSeed,
            ulong pageSize,
            out byte[] pageData)
        {
            page.CrcSeed          = crcSeed;
            page.DecompressedSize = (ulong)sectionStream.Length;
            page.DecompressedCrc  = Class656.class656_1.method_0(sectionStream.GetBuffer(), 0U, (uint)sectionStream.Length, Class656.smethod_0(crcSeed, (uint)sectionStream.Length));
            MemoryStream memoryStream = new MemoryStream();

            new Class955().method_1(sectionStream.GetBuffer(), 0, (int)sectionStream.Length, (Stream)memoryStream);
            if (memoryStream.Length >= sectionStream.Length)
            {
                memoryStream = sectionStream;
            }
            page.CompressedSize = (ulong)memoryStream.Length;
            page.CompressedCrc  = Class656.class656_1.method_0(memoryStream.GetBuffer(), 0U, (uint)memoryStream.Length, Class656.smethod_0(crcSeed, (uint)memoryStream.Length));
            ulong num1 = (ulong)(memoryStream.Length + 8L - 1L & -8L);
            int   num2 = (int)((long)num1 - memoryStream.Length);

            for (int index = 0; index < num2; ++index)
            {
                memoryStream.WriteByte((byte)0);
            }
            ulong num3 = pageSize / (ulong)byte.MaxValue;
            ulong num4 = num3 * (ulong)Class746.class746_0.K;

            page.DataRepeatCount = num4 / num1;
            for (int index = 1; index < (int)page.DataRepeatCount; ++index)
            {
                memoryStream.Write(memoryStream.GetBuffer(), 0, (int)num1);
            }
            pageData = new byte[pageSize];
            fixed(byte *source = memoryStream.GetBuffer())
            fixed(byte *destination = pageData)
            {
                uint  num5    = (uint)(this.method_28(destination, source, (int)memoryStream.Length, Class746.class746_0) * (int)byte.MaxValue);
                byte *pagePtr = destination + (int)num5;
                uint  num6    = (uint)num3 * (uint)byte.MaxValue;
                uint  num7    = num6 - num5;

                for (int index = 0; (long)index < (long)num7; ++index)
                {
                    *pagePtr++ = (byte)0;
                }
                uint paddingSize = (uint)pageSize - num6;

                this.method_24(pagePtr, paddingSize);
                if (pagePtr + (int)paddingSize - destination != (long)pageSize)
                {
                    throw new Exception();
                }
            }
        }
Пример #2
0
        private unsafe void method_22(
            Class504 section,
            byte[] buffer,
            ulong position,
            ulong uncompressedLength)
        {
            Class443 class443 = new Class443();

            class443.PageSize         = section.MaxDecompressedPageSize;
            class443.DataOffset       = position;
            class443.DecompressedSize = uncompressedLength;
            class443.CheckSum         = (ulong)Class996.smethod_3((ulong)this.uint_0, buffer, (uint)position, (uint)uncompressedLength);
            Class746     class7461    = Class746.class746_1;
            MemoryStream memoryStream = new MemoryStream();

            if (section.Compressed)
            {
                new Class955().method_1(buffer, (int)position, (int)uncompressedLength, (Stream)memoryStream);
                if (memoryStream.Length >= (long)uncompressedLength)
                {
                    memoryStream = new MemoryStream();
                    memoryStream.Write(buffer, (int)position, (int)uncompressedLength);
                }
            }
            else
            {
                memoryStream.Write(buffer, (int)position, (int)uncompressedLength);
            }
            class443.CompressedSize = (ulong)memoryStream.Length;
            class443.Crc            = Class656.class656_1.method_0(memoryStream.GetBuffer(), 0U, (uint)memoryStream.Length, Class656.smethod_0((ulong)this.uint_0, (uint)memoryStream.Length));
            ulong num1 = (ulong)(memoryStream.Length + 8L - 1L & -8L);
            int   num2 = (int)((ulong)((long)num1 + (long)class7461.K - 1L) / (ulong)class7461.K);

            byte[] data;
            if (section.Encoding == 4UL)
            {
                data = new byte[(long)num2 * (long)class7461.N];
                int num3 = (int)((long)num1 - memoryStream.Length);
                for (int index = 0; index < num3; ++index)
                {
                    memoryStream.WriteByte((byte)0);
                    fixed(byte *destination = data)
                    fixed(byte *source = memoryStream.GetBuffer())
                    this.method_28(destination, source, (int)memoryStream.Length, class7461);
            }
            else
            {
                if (section.Encoding != 1UL)
                {
                    throw new Exception();
                }
                uint num3 = (uint)(num1 - (ulong)memoryStream.Length);
                for (uint index = 0; index < num3; ++index)
                {
                    memoryStream.WriteByte((byte)0);
                }
                data = new byte[num1 + (ulong)num2 * (ulong)(class7461.N - class7461.K)];

                fixed(byte *dataBufferPtr = data)
                fixed(byte *sourcePtr = memoryStream.GetBuffer())
                this.method_26(dataBufferPtr, dataBufferPtr + num1, sourcePtr, (int)memoryStream.Length, class7461);
            }
            this.method_23((Class441)class443, data, 0, data.Length);
            if (class443.Id > 0L)
            {
                ++section.PageCount;
            }
            section.Pages.Add(class443);
        }
Пример #3
0
        private unsafe void method_1()
        {
            this.stream_0.Position             = this.stream_0.Length;
            this.class954_0.FileSize           = (ulong)(this.stream_0.Length + 1024L);
            this.class954_0.Header2Offset      = (ulong)(this.stream_0.Position - 1152L);
            this.class954_0.SectionsMapCrcSeed = this.class995_0.method_2((uint)this.class954_0.SectionsMapCrcSeed);
            this.class954_0.PagesMapCrcSeed    = this.class995_0.method_2((uint)this.class954_0.PagesMapCrcSeed);
            Class888 class888 = new Class888();

            class888.method_0(this.class954_0.CrcSeed, this.class995_0);
            this.class954_0.CrcSeedEncoded = this.class995_0.method_2((uint)(this.class954_0.CrcSeed & (ulong)ushort.MaxValue));
            MemoryStream memoryStream1 = new MemoryStream();
            Class889     byteStream    = Class889.Create((Stream)memoryStream1, this.dxfVersion_0, this.encoding_0);

            this.method_3(byteStream);
            ulong num1 = Class656.class656_0.method_0(memoryStream1.GetBuffer(), 0U, (uint)memoryStream1.Length, Class656.smethod_1(0UL, (uint)memoryStream1.Length));

            memoryStream1.Position = 264L;
            byteStream.vmethod_15(num1);
            Class955     class955      = new Class955();
            MemoryStream memoryStream2 = new MemoryStream();

            class955.method_1(memoryStream1.GetBuffer(), 0, (int)memoryStream1.Length, (Stream)memoryStream2);
            if (memoryStream2.Length >= memoryStream1.Length)
            {
                memoryStream2 = memoryStream1;
            }
            ulong        num2          = Class656.class656_0.method_0(memoryStream2.GetBuffer(), 0U, (uint)memoryStream2.Length, Class656.smethod_1(0UL, (uint)memoryStream2.Length));
            MemoryStream memoryStream3 = new MemoryStream(12);
            Class889     class889_1    = Class889.Create((Stream)memoryStream3, this.dxfVersion_0, this.encoding_0);
            ulong        control       = this.class995_0.method_1();

            class889_1.vmethod_15(control);
            class889_1.vmethod_15(Class888.smethod_0(control, control));
            ulong        num3          = Class656.class656_0.method_0(memoryStream3.GetBuffer(), 0U, (uint)memoryStream3.Length, Class656.smethod_0(0UL, (uint)memoryStream3.Length));
            MemoryStream memoryStream4 = new MemoryStream(1024);
            Class889     class889_2    = Class889.Create((Stream)memoryStream4, this.dxfVersion_0, this.encoding_0);

            class889_2.vmethod_15(num3);
            class889_2.vmethod_15(control);
            class889_2.vmethod_15(num2);
            if (memoryStream2.Length < 272L)
            {
                class889_2.vmethod_13(memoryStream2.Length);
            }
            else
            {
                if (memoryStream2.Length != 272L)
                {
                    throw new Exception();
                }
                class889_2.vmethod_13(-272L);
            }
            memoryStream4.Write(memoryStream2.GetBuffer(), 0, (int)memoryStream2.Length);
            uint num4         = Class746.class746_0.K * 3U;
            uint length       = (uint)class889_2.Stream.Length;
            uint num5         = (uint)((ulong)(uint)((int)length + 8 - 1) & 18446744073709551608UL);
            uint paddingSize1 = num5 - length;

            this.method_25((Stream)memoryStream4, paddingSize1);
            uint num6 = num4 / num5;

            for (int index = 1; (long)index < (long)num6; ++index)
            {
                memoryStream4.Write(memoryStream4.GetBuffer(), 0, (int)num5);
            }
            uint paddingSize2 = num4 - (uint)memoryStream4.Length;

            this.method_25((Stream)memoryStream4, paddingSize2);
            byte[] buffer = new byte[1024];
            fixed(byte *source = memoryStream4.GetBuffer())
            fixed(byte *destination = buffer)
            {
                this.method_28(destination, source, (int)num4, Class746.class746_0);
                this.method_24(destination + 765, 259U);
            }
            MemoryStream memoryStream5 = new MemoryStream(buffer, true);

            memoryStream5.Position = memoryStream5.Length - 40L;
            class888.Write((Stream)memoryStream5);
            if (memoryStream5.Length != 1024L)
            {
                throw new Exception();
            }
            this.stream_0.Write(buffer, 0, buffer.Length);
            this.stream_0.Position = 128L;
            this.stream_0.Write(buffer, 0, buffer.Length);
        }