Esempio n. 1
0
        private void SaveCache(ulong build)
        {
            if (CacheFileExists(build))
            {
                return;
            }

            using (Stream file = File.OpenWrite(CacheFile(build)))
                using (LZ4Stream lz4Stream = new LZ4Stream(file, LZ4StreamMode.Compress, LZ4StreamFlags.HighCompression))
                    using (BinaryWriter writer = new BinaryWriter(lz4Stream)) {
                        writer.Write(APM_VERSION);
                        writer.WriteStructArray(Packages);
                        for (int i = 0; i < PackageEntries.Length; ++i)
                        {
                            writer.Write(Records[i].Length);

                            Types.CachePackageRecord[] cacheRecords = new Types.CachePackageRecord[Records[i].Length];
                            for (int j = 0; j < Records[i].Length; j++)
                            {
                                Types.PackageRecord record = Records[i][j];
                                cacheRecords[j] = new Types.CachePackageRecord {
                                    Index  = CMF.IndexMap[record.GUID],
                                    Flags  = record.Flags,
                                    Offset = record.Offset,
                                    Size   = record.Size
                                };
                            }
                            writer.WriteStructArray(cacheRecords);

                            writer.Write(PackageSiblings[i].Length);
                            writer.WriteStructArray(PackageSiblings[i]);
                        }
                    }
        }
Esempio n. 2
0
        private bool LoadCache(ulong build)
        {
            if (!CacheFileExists(build))
            {
                return(false);
            }

            using (Stream file = File.OpenRead(CacheFile(build)))
                using (LZ4Stream lz4Stream = new LZ4Stream(file, LZ4StreamMode.Decompress))
                    using (BinaryReader reader = new BinaryReader(lz4Stream)) {
                        if (reader.ReadUInt64() != APM_VERSION)
                        {
                            return(false);
                        }

                        int packageEntryCount = PackageEntries.Length;
                        Packages = reader.ReadArray <Types.Package>(packageEntryCount);

                        Records         = new Types.PackageRecord[packageEntryCount][];
                        PackageSiblings = new ulong[packageEntryCount][];

                        Types.CachePackageRecord[][] cacheRecords = new Types.CachePackageRecord[packageEntryCount][];

                        for (int i = 0; i < packageEntryCount; i++)
                        {
                            int recordCount = reader.ReadInt32();
                            cacheRecords[i] = reader.ReadArray <Types.CachePackageRecord>(recordCount);
                            int siblingCount = reader.ReadInt32();
                            PackageSiblings[i] = reader.ReadArray <ulong>(siblingCount);
                        }

                        Parallel.For(0, packageEntryCount, new ParallelOptions {
                            MaxDegreeOfParallelism = CASCConfig.MaxThreads
                        }, i =>
                        {
                            Types.CachePackageRecord[] cache = cacheRecords[i];
                            Records[i] = new Types.PackageRecord[cache.Length];

                            Types.Package package = Packages[i];
                            MD5Hash bundleLoadHash;
                            if (package.BundleGUID != 0)
                            {
                                bundleLoadHash = CMF.Map[package.BundleGUID].HashKey;
                            }

                            for (int j = 0; j < cache.Length; j++)
                            {
                                Types.CachePackageRecord cacheRecord   = cache[j];
                                ContentManifestFile.HashData cmfRecord = CMF.HashList[cacheRecord.Index];
                                Types.PackageRecord record             = new Types.PackageRecord {
                                    GUID   = cmfRecord.GUID,
                                    Size   = cacheRecord.Size,
                                    Flags  = cacheRecord.Flags,
                                    Offset = cacheRecord.Offset
                                };
                                if ((record.Flags & ContentFlags.Bundle) != 0)
                                {
                                    record.LoadHash = bundleLoadHash;
                                }
                                else
                                {
                                    record.LoadHash = cmfRecord.HashKey;
                                }
                                if (!FirstOccurence.ContainsKey(record.GUID))
                                {
                                    FirstOccurence.TryAdd(record.GUID, record);
                                }
                                Records[i][j] = record;
                            }
                        });
                    }

            return(true);
        }