IoChunkEncoding.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "IO/IoOffsetLength.h"
#include "IO/IoStatus.h"
#include "Memory/MemoryView.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
 
class FIoBuffer;
struct FIoHash;
 
using FIoBlockHash = uint32;
 
enum class EIoEncryptionMethod : uint8
{
    None    = 0,
    AES     = (1 << 0)
};
 
struct FIoChunkEncodingParams
{
    FName CompressionFormat = TEXT("Oodle");
    FMemoryView EncryptionKey;
    uint32 BlockSize = (64 << 10);
};
 
struct FIoChunkDecodingParams
    : public FIoChunkEncodingParams
{
    uint64 TotalRawSize = 0;
    uint64 RawOffset = 0;
    uint64 EncodedOffset = 0;
    TConstArrayView<uint32> EncodedBlockSize;
    TConstArrayView<FIoBlockHash> BlockHash;
};
 
enum class EIoDecodeFlags : uint8
{
    None        = 0,
    WriteOnly   = 1 << 0
};
ENUM_CLASS_FLAGS(EIoDecodeFlags);
 
enum class EIoSignatureHashFunction : uint8
{
    Sha1
};
 
struct FIoChunkBlockDecodingParams
{
    FMemoryView                 EncryptionKey;
    FMemoryView                 BlockHash;
    FName                       CompressionFormat;
    EIoSignatureHashFunction    HashFunction = EIoSignatureHashFunction::Sha1;
};
 
struct FIoChunkBlockDecodeResult
{
    FMutableMemoryView  DecodedBlock;
    EIoErrorCode        ErrorCode = EIoErrorCode::Unknown;
};
 
class FIoChunkEncoding
{
public:
    static constexpr uint32 ExpectedMagic = 0x2e696f; // .io
    static constexpr uint32 DefaultBlockSize = (64 << 10);
    static constexpr uint32 MaxBlockCount = (1 << 24);
    static constexpr uint64 MaxSize = (uint64(1) << 40);
 
    struct FHeader
    {
        uint64 Magic: 24;
        uint64 RawSize: 40;
        uint64 EncodedSize: 40;
        uint64 BlockSizeExponent: 8;
        uint64 Flags: 8;
        uint64 Pad: 8;
 
        CORE_API bool IsValid() const;
        CORE_API uint32 GetBlockSize() const;
        CORE_API uint32 GetBlockCount() const;
        CORE_API TConstArrayView<uint32> GetBlocks() const;
        CORE_API uint64 GetTotalHeaderSize() const;
 
        static CORE_API const FHeader* Decode(FMemoryView HeaderData);
    };
 
    static_assert(sizeof(FHeader) == 16, "I/O chunk header size mismatch");
 
    static CORE_API bool Encode(const FIoChunkEncodingParams& Params, FMemoryView RawData, FIoBuffer& OutEncodedData);
    static CORE_API bool Encode(const FIoChunkEncodingParams& Params, FMemoryView RawData, FIoBuffer& OutHeader, FIoBuffer& OutEncodedBlocks);
    static CORE_API bool Decode(const FIoChunkDecodingParams& Params, FMemoryView EncodedBlocks, FMutableMemoryView OutRawData, EIoDecodeFlags Flags = EIoDecodeFlags::None);
    static CORE_API bool Decode(FMemoryView EncodedData, FName CompressionFormat, FMemoryView EncryptionKey, FMutableMemoryView OutRawData, uint64 Offset = 0);
    static CORE_API FIoChunkBlockDecodeResult DecodeBlock(const FIoChunkBlockDecodingParams Params, FMutableMemoryView EncodedBlock, FMutableMemoryView OutDecodedBlock);
 
    static CORE_API TIoStatusOr<FIoOffsetAndLength> GetChunkRange(uint64 TotalRawSize, uint32 RawBlockSize, TConstArrayView<uint32> EncodedBlockSize, uint64 RawOffset, uint64 RawSize);
    static CORE_API TIoStatusOr<FIoOffsetAndLength> GetChunkRange(const FIoChunkDecodingParams& Params, uint64 RawSize);
    static CORE_API uint64 GetTotalEncodedSize(TConstArrayView<uint32> EncodedBlockSize);
    static CORE_API FIoBlockHash HashBlock(FMemoryView Block);
};
 
using FIoBlockDecoded = TUniqueFunction<void(FIoChunkBlockDecodeResult&&, struct FIoChunkBlockDecodeRequest&)>;
 
struct FIoChunkBlockDecodeRequest
{
    bool                        IsValid() const { return OnDecoded.IsSet(); }
 
    FIoChunkBlockDecodingParams Params;
    FMutableMemoryView          EncodedBlock;
    FMutableMemoryView          DecodedBlock;
    FIoBlockDecoded             OnDecoded;
};
 
class IIoChunkBlockDecoder
{
public:
    virtual         ~IIoChunkBlockDecoder() = default;
    virtual void    Enqueue(FIoChunkBlockDecodeRequest&& DecodeRequest) = 0;
};
 
class FIoChunkBlockDecoder
{
public:
    CORE_API static void                    Set(IIoChunkBlockDecoder& Instance);
    CORE_API static IIoChunkBlockDecoder&   Get();
    CORE_API static void                    Release();
 
private:
    static IIoChunkBlockDecoder* Instance;
};