CompressedBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "Math/NumericLimits.h"
#include "Memory/CompositeBuffer.h"
#include "Memory/MemoryFwd.h"
#include "Memory/SharedBuffer.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/RemoveReference.h"
#include "Templates/UnrealTemplate.h"
 
class FArchive;
struct FIoHash;
 
namespace FOodleDataCompression { enum class ECompressionLevel : int8; }
namespace FOodleDataCompression { enum class ECompressor : uint8; }
 
namespace UE::CompressedBuffer::Private { struct FHeader; }
 
using ECompressedBufferCompressionLevel = FOodleDataCompression::ECompressionLevel;
using ECompressedBufferCompressor = FOodleDataCompression::ECompressor;
 
enum class ECompressedBufferDecompressFlags : uint32
{
    None = 0,
 
    IntermediateBuffer = 1 << 0,
};
 
ENUM_CLASS_FLAGS(ECompressedBufferDecompressFlags);
 
class FCompressedBuffer
{
public:
    [[nodiscard]] CORE_API static FCompressedBuffer Compress(const FCompositeBuffer& RawData);
    [[nodiscard]] CORE_API static FCompressedBuffer Compress(const FSharedBuffer& RawData);
 
    [[nodiscard]] CORE_API static FCompressedBuffer Compress(
        const FCompositeBuffer& RawData,
        ECompressedBufferCompressor Compressor,
        ECompressedBufferCompressionLevel CompressionLevel,
        uint64 BlockSize = 0);
    [[nodiscard]] CORE_API static FCompressedBuffer Compress(
        const FSharedBuffer& RawData,
        ECompressedBufferCompressor Compressor,
        ECompressedBufferCompressionLevel CompressionLevel,
        uint64 BlockSize = 0);
 
    [[nodiscard]] CORE_API static FCompressedBuffer FromCompressed(const FCompositeBuffer& CompressedData);
    [[nodiscard]] CORE_API static FCompressedBuffer FromCompressed(FCompositeBuffer&& CompressedData);
    [[nodiscard]] CORE_API static FCompressedBuffer FromCompressed(const FSharedBuffer& CompressedData);
    [[nodiscard]] CORE_API static FCompressedBuffer FromCompressed(FSharedBuffer&& CompressedData);
 
    [[nodiscard]] CORE_API static FCompressedBuffer Load(FArchive& Ar);
 
    CORE_API void Save(FArchive& Ar) const;
 
    inline void Reset() { CompressedData.Reset(); }
 
    [[nodiscard]] inline explicit operator bool() const { return !IsNull(); }
 
    [[nodiscard]] inline bool IsNull() const { return CompressedData.IsNull(); }
 
    [[nodiscard]] inline bool IsOwned() const { return CompressedData.IsOwned(); }
 
    [[nodiscard]] inline FCompressedBuffer MakeOwned() const & { return FromCompressed(CompressedData.MakeOwned()); }
    [[nodiscard]] inline FCompressedBuffer MakeOwned() && { return FromCompressed(MoveTemp(CompressedData).MakeOwned()); }
 
    [[nodiscard]] inline const FCompositeBuffer& GetCompressed() const & { return CompressedData; }
    [[nodiscard]] inline FCompositeBuffer GetCompressed() && { return MoveTemp(CompressedData); }
 
    [[nodiscard]] CORE_API uint64 GetCompressedSize() const;
 
    [[nodiscard]] CORE_API uint64 GetRawSize() const;
 
    [[nodiscard]] CORE_API FIoHash GetRawHash() const;
 
    [[nodiscard]] CORE_API bool TryGetCompressParameters(
        ECompressedBufferCompressor& OutCompressor,
        ECompressedBufferCompressionLevel& OutCompressionLevel,
        uint64& OutBlockSize) const;
 
    [[nodiscard]] CORE_API bool TryDecompressTo(FMutableMemoryView RawView,
        ECompressedBufferDecompressFlags Flags = ECompressedBufferDecompressFlags::None) const;
 
    [[nodiscard]] CORE_API FSharedBuffer Decompress() const;
    [[nodiscard]] CORE_API FCompositeBuffer DecompressToComposite() const;
 
    CORE_API static const FCompressedBuffer Null;
 
private:
    FCompositeBuffer CompressedData;
};
 
CORE_API FArchive& operator<<(FArchive& Ar, FCompressedBuffer& Buffer);
 
namespace UE::CompressedBuffer::Private
{
 
struct FDecoderContext
{
    uint64 HeaderOffset = MAX_uint64;
    uint64 HeaderSize = 0;
    uint32 HeaderCrc32 = 0;
    uint32 RawBlockIndex = MAX_uint32;
 
    FUniqueBuffer Header;
    FUniqueBuffer RawBlock;
    FUniqueBuffer CompressedBlock;
};
 
} // UE::CompressedBuffer::Private
 
class FCompressedBufferReader
{
public:
    FCompressedBufferReader() = default;
 
    CORE_API explicit FCompressedBufferReader(FArchive& Archive);
 
    CORE_API explicit FCompressedBufferReader(const FCompressedBuffer& Buffer);
 
    CORE_API void ResetBuffers();
 
    CORE_API void ResetSource();
 
    CORE_API void SetSource(FArchive& Archive);
    CORE_API void SetSource(const FCompressedBuffer& Buffer);
 
    [[nodiscard]] inline bool HasSource() const { return SourceArchive || SourceBuffer; }
 
    [[nodiscard]] CORE_API uint64 GetCompressedSize();
 
    [[nodiscard]] CORE_API uint64 GetRawSize();
 
    [[nodiscard]] CORE_API FIoHash GetRawHash();
 
    [[nodiscard]] CORE_API bool TryGetCompressParameters(
        ECompressedBufferCompressor& OutCompressor,
        ECompressedBufferCompressionLevel& OutCompressionLevel,
        uint64& OutBlockSize);
 
    [[nodiscard]] CORE_API bool TryDecompressTo(FMutableMemoryView RawView, uint64 RawOffset = 0,
        ECompressedBufferDecompressFlags Flags = ECompressedBufferDecompressFlags::None);
 
    [[nodiscard]] CORE_API FSharedBuffer Decompress(uint64 RawOffset = 0, uint64 RawSize = MAX_uint64);
    [[nodiscard]] CORE_API FCompositeBuffer DecompressToComposite(uint64 RawOffset = 0, uint64 RawSize = MAX_uint64);
 
private:
    bool TryReadHeader(UE::CompressedBuffer::Private::FHeader& OutHeader, FMemoryView& OutHeaderView);
 
    FArchive* SourceArchive = nullptr;
    const FCompressedBuffer* SourceBuffer = nullptr;
    UE::CompressedBuffer::Private::FDecoderContext Context;
};
 
class FCompressedBufferReaderSourceScope
{
public:
    inline FCompressedBufferReaderSourceScope(FCompressedBufferReader& InReader, FArchive& InArchive)
        : Reader(InReader)
    {
        Reader.SetSource(InArchive);
    }
 
    inline FCompressedBufferReaderSourceScope(FCompressedBufferReader& InReader, const FCompressedBuffer& InBuffer)
        : Reader(InReader)
    {
        Reader.SetSource(InBuffer);
    }
 
    inline ~FCompressedBufferReaderSourceScope()
    {
        Reader.ResetSource();
    }
 
private:
    FCompressedBufferReader& Reader;
};