LiveLinkCompression.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "LiveLinkTypes.h"
 
#include "LiveLinkCompression.generated.h"
 
#define UE_API LIVELINKMESSAGEBUSFRAMEWORK_API
 
USTRUCT()
struct FLiveLinkByteArray
{
    GENERATED_BODY()
 
    bool Serialize(FArchive& Ar)
    {
        int32 Num = Bytes.Num();
        Ar << Num;
        if (Ar.IsLoading())
        {
            Bytes.AddUninitialized(Num);
        }
        Ar.Serialize(Bytes.GetData(), Num);
        return true;
    }
 
    UPROPERTY()
    TArray<uint8> Bytes;
};
 
template<>
struct TStructOpsTypeTraits<FLiveLinkByteArray> : public TStructOpsTypeTraitsBase2<FLiveLinkByteArray>
{
    enum
    {
        WithSerializer = true,
    };
};
 
UENUM()
enum class ELiveLinkCompressionMethod : uint8
{
    Uncompressed,
 
    Oodle,
 
    Zlib
};
 
UENUM()
enum class ELiveLinkCompressionBias : uint8
{
    None,
 
    Size,
 
    Speed
};
 
namespace UE::LiveLink::Compression
{
 
    int32 GetConsoleVariableCompressionType();
 
    int32 GetConsoleVariableCompressionFlags();
 
    template <typename SizeType>
    inline bool ShouldCompress(SizeType DataSize)
    {
        static_assert(std::is_integral<SizeType>::value);
        const int32 CompressionLimit = 32;
        const int32 MinLimit = 512;
        if (CompressionLimit <= 0)
        {
            return DataSize > MinLimit;
        }
        const SizeType MaxPackageDataSizeForCompression = static_cast<SizeType>(CompressionLimit) * 1024 * 1024;
        return DataSize > MinLimit && DataSize <= MaxPackageDataSizeForCompression;
    }
 
    inline FName GetCompressionAlgorithm()
    {
        const int32 CompressionAlgo = GetConsoleVariableCompressionType();
        if (CompressionAlgo == 1)
        {
            return NAME_Oodle;
        }
        return NAME_Zlib;
    }
 
    inline ECompressionFlags GetCompressionFlags()
    {
        const int32 CompressionFlags = GetConsoleVariableCompressionFlags();
        if (CompressionFlags == 0)
        {
            return COMPRESS_NoFlags;
        }
        if (CompressionFlags == 1)
        {
            return COMPRESS_BiasSize;
        }
        return COMPRESS_BiasSpeed;
    }
 
    inline FName GetCompressionAlgorithm(ELiveLinkCompressionMethod Method)
    {
        return Method == ELiveLinkCompressionMethod::Oodle ? NAME_Oodle : NAME_Zlib;
    }
 
    inline ECompressionFlags GetCoreCompressionFlags(ELiveLinkCompressionBias InBias)
    {
        if (InBias == ELiveLinkCompressionBias::Size)
        {
            return COMPRESS_BiasSize;
        }
        else if (InBias == ELiveLinkCompressionBias::Speed)
        {
            return COMPRESS_BiasSpeed;
        }
        return COMPRESS_NoFlags;
    }
 
    inline ELiveLinkCompressionBias GetCompressionBias(ECompressionFlags Flags)
    {
        if (Flags == COMPRESS_BiasMemory)
        {
            return ELiveLinkCompressionBias::Size;
        }
        else if (Flags == COMPRESS_BiasSpeed)
        {
            return ELiveLinkCompressionBias::Speed;
        }
        else
        {
            return ELiveLinkCompressionBias::None;
        }
    }
 
    inline ELiveLinkCompressionMethod GetCompressionMethod(FName NamedMethod)
    {
        check(NamedMethod == NAME_Oodle || NamedMethod == NAME_Zlib);
        if (NamedMethod == NAME_Oodle)
        {
            return ELiveLinkCompressionMethod::Oodle;
        }
        else
        {
            return ELiveLinkCompressionMethod::Zlib;
        }
    }
}
 
UENUM()
enum class ELiveLinkPayloadSerializationMethod : uint8
{
    // The data will be serialized using standard platform method.
    Standard = 0,
    // The data will be serialized using Cbor method.
    Cbor,
};
 
UENUM()
enum class ELiveLinkPayloadCompressionType : uint8
{
    // The serialized data will not be compressed.
    None = 0,
    // The serialized data will be compressed based on struct size.
    Heuristic,
    // The serialized data will always be compressed.
    Always
};
 
USTRUCT()
struct FLiveLinkSerializedFrameData
{
    GENERATED_BODY()
 
    FLiveLinkSerializedFrameData() = default;
 
    FLiveLinkSerializedFrameData(ELiveLinkPayloadSerializationMethod SerializeMethod)
        : SerializationMethod(SerializeMethod)
    {
    }
 
    UE_API bool SetPayload(const FStructOnScope& InPayload, ELiveLinkPayloadCompressionType CompressionType = ELiveLinkPayloadCompressionType::Heuristic);
    UE_API bool SetPayload(const UScriptStruct* InPayloadType, const void* InPayloadData, ELiveLinkPayloadCompressionType CompressionType = ELiveLinkPayloadCompressionType::Heuristic);
 
    template <typename T>
    bool SetTypedPayload(const T& InPayloadData, ELiveLinkPayloadCompressionType CompressType = ELiveLinkPayloadCompressionType::Heuristic)
    {
        return SetPayload(TBaseStructure<T>::Get(), &InPayloadData, CompressType);
    }
 
    UE_API bool GetPayload(FStructOnScope& OutPayload) const;
    UE_API bool GetPayload(const UScriptStruct* InPayloadType, void* InOutPayloadData) const;
 
    UE_API bool IsTypeChildOf(const UScriptStruct* InPayloadType) const;
 
    template<typename T>
    bool IsTypeChildOf() const
    {
        return IsTypeChildOf(TBaseStructure<T>::Get());
    }
 
    template <typename T>
    bool GetTypedPayload(T& OutPayloadData) const
    {
        return GetPayload(TBaseStructure<T>::Get(), &OutPayloadData);
    }
 
    UPROPERTY(VisibleAnywhere, Category = "Payload")
    FName PayloadTypeName;
 
    UPROPERTY(VisibleAnywhere, Category = "Payload")
    ELiveLinkPayloadSerializationMethod SerializationMethod = ELiveLinkPayloadSerializationMethod::Standard;
 
    UPROPERTY(VisibleAnywhere, Category = "Payload")
    ELiveLinkCompressionMethod CompressionMethod = ELiveLinkCompressionMethod::Uncompressed;
 
    UPROPERTY(VisibleAnywhere, Category = "Payload")
    ELiveLinkCompressionBias CompressionBias = ELiveLinkCompressionBias::None;
 
    UPROPERTY(VisibleAnywhere, Category = "Payload")
    int32 PayloadSize = 0;
 
    UPROPERTY()
    FLiveLinkByteArray PayloadBytes;
};
 
#undef UE_API