wabbajack/Wabbajack.Compression.BSA/FO4Archive/ChunkBuilder.cs

using System.IO;
using System.Threading;
using System.Threading.Tasks;
using ICSharpCode.SharpZipLib.Zip.Compression;
using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
using Wabbajack.Common;
using Wabbajack.DTOs.BSA.FileStates;

namespace Wabbajack.Compression.BSA.FO4Archive
{
    public class ChunkBuilder
    {
        private BA2Chunk _chunk;
        private Stream _dataSlab;
        private long _offsetOffset;
        private uint _packSize;

        public static async Task<ChunkBuilder> Create(BA2DX10File state, BA2Chunk chunk, Stream src,
            DiskSlabAllocator slab, CancellationToken token)
        {
            var builder = new ChunkBuilder { _chunk = chunk };

            if (!chunk.Compressed)
            {
                builder._dataSlab = slab.Allocate(chunk.FullSz);
                await src.CopyToLimitAsync(builder._dataSlab, (int)chunk.FullSz, token);
            }
            else
            {
                var deflater = new Deflater(Deflater.BEST_COMPRESSION);
                await using var ms = new MemoryStream();
                await using (var ds = new DeflaterOutputStream(ms, deflater))
                {
                    ds.IsStreamOwner = false;
                    await src.CopyToLimitAsync(ds, (int)chunk.FullSz, token);
                }

                builder._dataSlab = slab.Allocate(ms.Length);
                ms.Position = 0;
                await ms.CopyToLimitAsync(builder._dataSlab, (int)ms.Length, token);
                builder._packSize = (uint)ms.Length;
            }

            builder._dataSlab.Position = 0;

            return builder;
        }

        public void WriteHeader(BinaryWriter bw)
        {
            _offsetOffset = bw.BaseStream.Position;
            bw.Write((ulong)0);
            bw.Write(_packSize);
            bw.Write(_chunk.FullSz);
            bw.Write(_chunk.StartMip);
            bw.Write(_chunk.EndMip);
            bw.Write(_chunk.Align);
        }

        public async ValueTask WriteData(BinaryWriter bw, CancellationToken token)
        {
            var pos = bw.BaseStream.Position;
            bw.BaseStream.Position = _offsetOffset;
            bw.Write((ulong)pos);
            bw.BaseStream.Position = pos;
            await _dataSlab.CopyToLimitAsync(bw.BaseStream, (int)_dataSlab.Length, token);
            await _dataSlab.DisposeAsync();
        }
    }
}