OodleDataCompression.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Misc/CompressionFlags.h"
 
// OodleDataCompression :
//  Unreal API for direct access to Oodle Data lossless data compression
//  for manual encoding (not in Pak/iostore)
//  NOTE : for any data that will be stored to disk, you should not be compressing it yourself!
//      allow the pak/iostore system to choose the compressor!
//
// Let me emphasize again : for data to be stored in packages for shipping games, do NOT use this
//  let the pak/iostore system choose the compression from the config options and platform settings
//
// OodleDataCompression.h is for utility compression in non-shipping game package scenarios
//  eg. uassets, storage caches and back-ends, large network transfers
//
// For Compression to/from TArray and such higher level actions use OodleDataCompressionUtil.h
 
DECLARE_LOG_CATEGORY_EXTERN(OodleDataCompression, Log, All);
 
namespace FOodleDataCompression
{
 
//UENUM() // @todo Oodle might be nice if these were UENUM but can't pull UObject from inside Core?
// enum values should not change, they may be persisted
enum class ECompressor : uint8
{
    NotSet = 0,
    Selkie = 1,
    Mermaid = 2,
    Kraken  = 3,
    Leviathan = 4 // if another added update CompressorNameMap
};
 
// If the input is invalid, returns false, and doesn't touch output.
bool CORE_API ECompressorToString(ECompressor InCompressor, const TCHAR** OutName);
bool CORE_API ECompressorFromString(const class FString& InName, ECompressor& OutCompressor);
CORE_API const TCHAR* ECompressorToString(ECompressor InCompressor);
 
//UENUM() // @todo Oodle might be nice if these were UENUM but can't pull UObject from inside Core?
// ECompressionLevel must numerically match the Oodle internal enum values
enum class ECompressionLevel : int8
{
    HyperFast4 = -4,
    HyperFast3 = -3,
    HyperFast2 = -2,
    HyperFast1 = -1,
    None = 0,
    SuperFast = 1,
    VeryFast = 2,
    Fast = 3,
    Normal = 4,
    Optimal1 = 5,
    Optimal2 = 6,
    Optimal3 = 7,
    Optimal4 = 8,
    Optimal5 = 9, // if another added update CompressionLevelNameMap
};
 
// If the input is invalid, returns false, and doesn't touch output.
bool CORE_API ECompressionLevelFromValue(int8 InValue, ECompressionLevel& OutLevel);
bool CORE_API ECompressionLevelToString(ECompressionLevel InLevel, const TCHAR** OutName);
CORE_API const TCHAR * ECompressionLevelToString(ECompressionLevel InLevel);
CORE_API bool ECompressionLevelFromString(const TCHAR* InName, ECompressionLevel& OutLevel);
 
enum class ECompressionCommonUsage : uint8
{
    Default = 0,
    FastRealtimeEncode = 1,
    SlowerSmallerEncode = 2,
    SlowestOfflineDistributionEncode = 3
};
 
ECompressionCommonUsage CORE_API GetCommonUsageFromLegacyCompressionFlags(ECompressionFlags Flags);
 
void CORE_API GetCompressorAndLevelForCommonUsage(ECompressionCommonUsage Usage,ECompressor & OutCompressor,ECompressionLevel & OutLevel);
 
 
int64 CORE_API CompressedBufferSizeNeeded(int64 UncompressedSize);
 
int64 CORE_API GetMaximumCompressedSize(int64 UncompressedSize);
 
int64 CORE_API Compress(
                            void * OutCompressedData, int64 CompressedBufferSize,
                            const void * InUncompressedData, int64 UncompressedSize,
                            ECompressor Compressor,
                            ECompressionLevel Level,
                            bool CompressIndependentChunks = false,
                            int64 DictionaryBackup = 0);
 
int64 CORE_API CompressParallel(
                            void * OutCompressedData, int64 CompressedBufferSize,
                            const void * InUncompressedData, int64 UncompressedSize,
                            ECompressor Compressor, ECompressionLevel Level,
                            bool CompressIndependentChunks = false);
                            
int64 CORE_API CompressParallel(
                            TArray64<uint8> & OutCompressedData,
                            const void * InUncompressedData, int64 UncompressedSize,
                            ECompressor Compressor, ECompressionLevel Level,
                            bool CompressIndependentChunks = false);
 
bool CORE_API Decompress(
                        void * OutUncompressedData, int64 UncompressedSize,
                        const void * InCompressedData, int64 CompressedSize
                        );
 
bool CORE_API DecompressParallel(
                        void * OutUncompressedData, int64 UncompressedSize,
                        const void * InCompressedData, int64 CompressedSize
                        );
 
// from Compression.cpp :
void CORE_API CompressionFormatInitOnFirstUseFromLock();
 
// from LaunchEngineLoop :
void CORE_API StartupPreInit();
 
};