示例#1
0
        public void Load(Stream inStream)
        {
            if (!inStream.CanRead)
            {
                return;
            }
            if (!inStream.CanSeek)
            {
                return;
            }
            if (inStream.Length < TagGroupHeader.Size)
            {
                return;
            }
            resources.Clear();
            TagGroup = null;

            using (BinaryReader reader = new BinaryReader(inStream))
            {
                TagGroupHeader header = reader.Read <TagGroupHeader>();
                inStream.Seek(TagGroupHeader.Size, SeekOrigin.Begin);
                if ((TagGroup = TagLookup.CreateTagGroup(header.GroupTag)) != null)
                {
                    TagGroup.Read(reader);
                }

                if (header.TagResourceCount > 0)
                {
                    int[] rawOffsets = new int[header.TagResourceCount];
                    inStream.Seek(header.RawOffsetsOffset, SeekOrigin.Begin);
                    for (int i = 0; i < header.TagResourceCount; i++)
                    {
                        rawOffsets[i] = reader.ReadInt32();
                    }

                    int[] lengths = new int[header.TagResourceCount];
                    inStream.Seek(header.RawLengthsOffset, SeekOrigin.Begin);
                    for (int i = 0; i < header.TagResourceCount; i++)
                    {
                        lengths[i] = reader.ReadInt32();
                    }

                    inStream.Seek(header.RawDataOffset, SeekOrigin.Begin);
                    for (int i = 0; i < header.TagResourceCount; i++)
                    {
                        if (!resources.ContainsKey(rawOffsets[i]))
                        {
                            resources.Add(rawOffsets[i], reader.ReadBytes(lengths[i]));
                        }
                    }
                }
            }

            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TagGroup)));
        }
示例#2
0
        public void Save(Stream outStream)
        {
            TagGroupHeader header = new TagGroupHeader
            {
                AbideTag         = "atag",
                GroupTag         = TagGroup.Tag,
                TagResourceCount = (uint)resources.Count,
            };

            using (BinaryWriter writer = new BinaryWriter(outStream))
                using (BinaryReader reader = new BinaryReader(outStream))
                {
                    outStream.Seek(TagGroupHeader.Size, SeekOrigin.Current); // skip header
                    TagGroup.Write(writer);

                    if (resources.Count > 0)
                    {
                        header.RawOffsetsOffset = (uint)outStream.Align(512);
                        foreach (int offset in resources.Keys)
                        {
                            writer.Write(offset);
                        }

                        header.RawLengthsOffset = (uint)outStream.Align(512);
                        foreach (byte[] resource in resources.Values)
                        {
                            writer.Write(resource.Length);
                        }

                        header.RawDataOffset = (uint)outStream.Align(512);
                        foreach (byte[] datum in resources.Values)
                        {
                            writer.Write(datum);
                        }
                    }

                    int count = (int)(outStream.Align(16) - TagGroupHeader.Size) / 4;

                    outStream.Seek(TagGroupHeader.Size, SeekOrigin.Begin);
                    for (int i = 0; i < count; i++)
                    {
                        header.Checksum ^= reader.ReadUInt32();
                    }

                    outStream.Seek(0, SeekOrigin.Begin);
                    writer.Write(header);
                }
        }