コード例 #1
0
            public static Locations[] Read_Locations(Stream s)
            {
                helper    help = new helper();
                Locations l    = new Locations();

                Locations[] result = new Locations[Header.LocationCount];
                uint[]      index  = new uint[Header.LocationCount];
                ulong[]     offset = new ulong[Header.LocationCount];
                uint        pos    = 0;

                byte[] block = ReturnBlock(s, l.SizeOf);
                for (uint i = 0; i < Header.LocationCount; i++)
                {
                    offset[i] = help.ReadBits(block, pos, Header.LocationBitCount);
                    pos      += Header.LocationBitCount;
                    index[i]  = i;
                }
                Array.Sort(offset, index);
                for (uint i = 0; i < Header.LocationCount; i++)
                {
                    result[i]        = new Locations();
                    result[i].index  = index[i];
                    result[i].offset = offset[i];
                }
                return(result);
            }
コード例 #2
0
        public byte[] DecompressChunk(Stream fs, int offset, int rev)
        {
            //CPK_MAX_DECOMP_BUFFER_SIZE = 0x10000
            helper help = new helper();

            fs.Seek(offset, 0);
            uint DecompressedSize, Flag, CompressedSize;

            if (rev == 0)
            {
                DecompressedSize = help.ReadU16(fs);
                Flag             = help.ReadU16(fs);
                CompressedSize   = help.ReadU16(fs);
            }
            else
            {
                DecompressedSize = help.ReverseUInt16(help.ReadU16(fs));
                Flag             = help.ReverseUInt16(help.ReadU16(fs));
                CompressedSize   = help.ReverseUInt16(help.ReadU16(fs));
            }
            byte[] buff = new byte[CompressedSize];
            fs.Read(buff, 0, (int)CompressedSize);
            byte[] tmp = { };
            try
            {
                tmp = DecompressZlib(buff);
            }
            catch
            {
                tmp = buff;
            }
            return(tmp);
        }
コード例 #3
0
            public static FileName[] Read_FileName(Stream s)
            {
                helper help = new helper();

                FileName[] result = new FileName[Header.FileCount];
                for (int i = 0; i < Header.FileCount; i++)
                {
                    FileName fn = new FileName();
                    if (Header.MagicNumber.ToString("X8").Equals("A1B2C3D4"))
                    {
                        fn.offset = help.ReadU32(s);
                    }
                    if (Header.MagicNumber.ToString("X8").Equals("D4C3B2A1"))
                    {
                        fn.offset = help.ReverseUInt32(help.ReadU32(s));
                    }
                    result[i] = fn;
                }
                long pos = s.Position;

                for (int i = 0; i < Header.FileCount; i++)
                {
                    s.Seek(pos + result[i].offset, 0);
                    result[i].filename = help.ReadString(s);
                    result[i].fileHash = help.GetFileHash(result[i].filename);
                }
                return(result);
            }
コード例 #4
0
            public DecompressedSectorToCompressedSector()
            {
                helper help = new helper();

                SizeOf  = help.GetHighestBit(Header.CompSectorCount) * (((uint)Header.DecompressedFileSize + (uint)Header.CompSectorSize - 1) / (uint)Header.CompSectorSize);
                SizeOf += 7;
                SizeOf /= 8;
            }
コード例 #5
0
            public static CompressedSectorToDecompressedOffset[] Read_CompressedSectorToDecompressedOffset(Stream s)
            {
                helper help = new helper();
                CompressedSectorToDecompressedOffset c = new CompressedSectorToDecompressedOffset();
                uint pos = 0;

                byte[] block = ReturnBlock(s, c.SizeOf);
                CompressedSectorToDecompressedOffset[] result = new CompressedSectorToDecompressedOffset[Header.CompSectorCount];
                for (uint i = 0; i < Header.CompSectorCount; i++)
                {
                    result[i]                    = new CompressedSectorToDecompressedOffset();
                    result[i].SectorIndex        = i;
                    result[i].DecompressedOffset = help.ReadBits(block, pos, Header.LocationBitCount);
                    pos += Header.LocationBitCount;
                }
                return(result);
            }
コード例 #6
0
            public static Dictionary <uint, CompressedSectorChunk> ReadSectors(Stream s)
            {
                helper help = new helper();
                CompressedSectorChunk csc = new CompressedSectorChunk();
                uint  ChunkNumber         = 0;
                ulong doffset             = 0;

                s.Seek(Header.FirstSectorPosition, 0);
                Dictionary <uint, CompressedSectorChunk> result = new Dictionary <uint, CompressedSectorChunk>();

                if (Header.MagicNumber.ToString("X8").Equals("A1B2C3D4"))
                {
                    help.ReadU16(s); help.ReadU16(s); s.Seek(help.ReadU16(s), SeekOrigin.Current);
                }
                if (Header.MagicNumber.ToString("X8").Equals("D4C3B2A1"))
                {
                    help.ReverseUInt16(help.ReadU16(s)); help.ReverseUInt16(help.ReadU16(s)); s.Seek(help.ReverseUInt16(help.ReadU16(s)), SeekOrigin.Current);
                }

                for (uint sector = 0; sector <= Header.CompSectorCount; sector++)
                {
                    uint SectorStartPosition = Header.FirstSectorPosition + sector * Header.CompSectorSize;
                    uint NextSectorPosition  = SectorStartPosition + Header.CompSectorSize;
                    s.Seek(SectorStartPosition, 0);
                    while (s.Position + 0xf < NextSectorPosition)
                    {
                        csc          = new CompressedSectorChunk();
                        csc.position = (uint)s.Position;
                        ushort Size          = help.ReadU16(s);
                        ushort flag          = help.ReadU16(s);
                        ushort CompChunkSize = help.ReadU16(s);
                        csc.nr                = ChunkNumber;
                        csc.CompChunkSize     = CompChunkSize;
                        csc.DecompChunkSize   = Size;
                        csc.flag              = flag;
                        csc.CompSector        = sector;
                        doffset              += Size;
                        csc.StartDecompOffset = doffset - Size;
                        result.Add(ChunkNumber, csc);
                        ChunkNumber++;
                        s.Seek(CompChunkSize, SeekOrigin.Current);
                    }
                }
                return(result);
            }
コード例 #7
0
            public static DecompressedSectorToCompressedSector[] Read_DecompressedSectorToCompressedSector(Stream s)
            {
                helper help = new helper();
                uint   temp = help.GetHighestBit(Header.CompSectorCount);
                DecompressedSectorToCompressedSector d = new DecompressedSectorToCompressedSector();
                uint sector = (((uint)Header.DecompressedFileSize + (uint)Header.CompSectorSize - 1) / (uint)Header.CompSectorSize);
                uint pos    = 0;

                byte[] block = ReturnBlock(s, d.SizeOf);
                DecompressedSectorToCompressedSector[] result = new DecompressedSectorToCompressedSector[sector];

                for (uint i = 0; i < sector; i++)
                {
                    result[i] = new DecompressedSectorToCompressedSector();
                    result[i].DecompressedSector = i;
                    result[i].CompressedSector   = help.ReadBits(block, pos, temp);
                    pos += temp;
                }
                return(result);
            }
コード例 #8
0
            public HeaderStruct(Stream s, int rev)
            {
                s.Seek(0, SeekOrigin.End);
                FileSize = (uint)s.Position;
                helper help = new helper();

                s.Seek(0, 0);
                MagicNumber          = help.ReadU32(s);
                PackageVersion       = help.RUInt32(s, rev);
                DecompressedFileSize = help.RUInt64(s, rev);
                Flags                            = help.RUInt32(s, rev);
                FileCount                        = help.RUInt32(s, rev);
                LocationCount                    = help.RUInt32(s, rev);
                HeaderSector                     = help.RUInt32(s, rev);
                FileSizeBitCount                 = help.RUInt32(s, rev);
                FileLocationCountBitCount        = help.RUInt32(s, rev);
                FileLocationIndexBitCount        = help.RUInt32(s, rev);
                LocationBitCount                 = help.RUInt32(s, rev);
                CompSectorToDecomOffsetBitCount  = help.RUInt32(s, rev);
                DecompSectorToCompSectorBitCount = help.RUInt32(s, rev);
                CRC = help.RUInt32(s, rev);
                if (PackageVersion == 6)
                {
                    Unknown        = help.ReadU32(s);
                    ReadSectorSize = 0x10000;
                    CompSectorSize = 0x4000;
                    HeaderSize     = 64;
                }
                if (PackageVersion == 7)
                {
                    ReadSectorSize = (uint)help.RInt32(s, rev);
                    CompSectorSize = (uint)help.RInt32(s, rev);
                    HeaderSize     = 72;
                }
                CompSectorCount     = ((uint)CompSectorSize + FileSize - 1 - (uint)ReadSectorSize * HeaderSector) / (uint)CompSectorSize;
                FirstSectorPosition = (uint)(ReadSectorSize * HeaderSector) & 0xFFFF0000;
                if ((FirstSectorPosition % ReadSectorSize) != 0)
                {
                    FirstSectorPosition += ReadSectorSize;
                }
            }
コード例 #9
0
        static void Main(string[] args)
        {
            string path = "";

            if (args.Length == 0)
            {
                path = "D:\\Common.cpk";
            }
            else
            {
                path = args[0];
            }
            helper     help = new helper();
            FileStream fs   = new FileStream(path, FileMode.Open, FileAccess.Read);

            fs.Seek(0, 0);
            rev            = cpk.IsByteReverse(fs);
            HeaderStruct   = cpk.HeaderStruct.ReadHeader(fs, rev);
            SortedFileInfo = cpk.SortedFileInfo.Read_SortedFileInfo(fs);
            Locations      = cpk.Locations.Read_Locations(fs);
            CompressedSectorToDecompressedOffset = cpk.CompressedSectorToDecompressedOffset.Read_CompressedSectorToDecompressedOffset(fs);
            DecompressedSectorToCompressedSector = cpk.DecompressedSectorToCompressedSector.Read_DecompressedSectorToCompressedSector(fs);
            FileName = cpk.FileName.Read_FileName(fs);
            DictCompressedSectorChunk = cpk.CompressedSectorChunk.ReadSectors(fs);
            CompressedSectorChunk     = cpk.CompressedSectorChunk.Read_CompressedSectorChunk(DictCompressedSectorChunk);

            WriteHeader();
            for (int idx = 0; idx < Locations.Length; idx++)
            {
                int i = (int)Locations[idx].index;
                int a = GetLocationIndex(i);
                WriteFileInfo(a);
                WriteLocations((idx));
                WriteFileName(a);
            }

            fs.Close();
            Console.ReadKey();
        }
コード例 #10
0
            public static SortedFileInfo[] Read_SortedFileInfo(Stream s)
            {
                SortedFileInfo[] result = new SortedFileInfo[Header.FileCount];
                helper           help   = new helper();
                SortedFileInfo   sfi    = new SortedFileInfo();

                s.Position = HeaderSize;
                byte[] Htable   = ReturnBlock(s, sfi.SizeOf);
                uint   position = 0;

                for (uint i = 0; i < Header.FileCount; i++)
                {
                    result[i]                = new SortedFileInfo();
                    result[i].dwHash         = help.ReadBits(Htable, position, 64);
                    position                += 64;
                    result[i].nSize          = (uint)help.ReadBits(Htable, position, Header.FileSizeBitCount);
                    position                += Header.FileSizeBitCount;
                    result[i].nLocationCount = (uint)help.ReadBits(Htable, position, Header.FileLocationCountBitCount);
                    position                += Header.FileLocationCountBitCount;
                    result[i].nLocationIndex = (uint)help.ReadBits(Htable, position, Header.FileLocationIndexBitCount);
                    position                += Header.FileLocationIndexBitCount;
                }
                return(result);
            }
コード例 #11
0
        public static byte[] GetChunck(FileStream s, int i, int rev)
        {
            helper help = new helper();

            return(help.DecompressChunk(s, (int)CompressedSectorChunk[i].position, rev));
        }