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

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

namespace Wabbajack.Compression.BSA.FO4Archive;

public class FileEntry : IBA2FileEntry
{
    internal uint _align;
    internal Reader _bsa;
    internal uint _dirHash;
    internal string _extension;
    internal uint _flags;
    internal int _index;
    internal uint _nameHash;
    internal ulong _offset;
    internal uint _realSize;
    internal uint _size;

    public FileEntry(Reader ba2Reader, int index)
    {
        _index = index;
        _bsa = ba2Reader;
        var _rdr = ba2Reader._rdr;
        _nameHash = _rdr.ReadUInt32();
        FullPath = _nameHash.ToString("X");
        _extension = Encoding.UTF8.GetString(_rdr.ReadBytes(4));
        _dirHash = _rdr.ReadUInt32();
        _flags = _rdr.ReadUInt32();
        _offset = _rdr.ReadUInt64();
        _size = _rdr.ReadUInt32();
        _realSize = _rdr.ReadUInt32();
        _align = _rdr.ReadUInt32();
    }

    public bool Compressed => _size != 0;


    public string FullPath { get; set; }

    public RelativePath Path => FullPath.ToRelativePath();

    public uint Size => _realSize;

    public AFile State => new BA2File
    {
        NameHash = _nameHash,
        DirHash = _dirHash,
        Flags = _flags,
        Align = _align,
        Compressed = Compressed,
        Path = Path,
        Extension = _extension,
        Index = _index
    };

    public async ValueTask CopyDataTo(Stream output, CancellationToken token)
    {
        await using var fs = await _bsa._streamFactory.GetStream();
        fs.Seek((long) _offset, SeekOrigin.Begin);
        var len = Compressed ? _size : _realSize;

        var bytes = new byte[len];
        await fs.ReadAsync(bytes.AsMemory(0, (int) len), token);

        if (!Compressed)
        {
            await output.WriteAsync(bytes, token);
        }
        else
        {
            var uncompressed = new byte[_realSize];
            var inflater = new Inflater();
            inflater.SetInput(bytes);
            inflater.Inflate(uncompressed);
            await output.WriteAsync(uncompressed, token);
        }

        await output.FlushAsync(token);
    }

    public async ValueTask<IStreamFactory> GetStreamFactory(CancellationToken token)
    {
        var ms = new MemoryStream();
        await CopyDataTo(ms, token);
        ms.Position = 0;
        return new MemoryStreamFactory(ms, Path, _bsa._streamFactory.LastModifiedUtc);
    }
}