OodleDataCompressionUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "HAL/Platform.h"
#include "OodleDataCompression.h"
 
// OodleDataCompressionUtil : utilities for common Unreal actions built on top of OodleDataCompression
 
namespace FOodleCompressedArray
{
    bool CORE_API CompressData(TArray<uint8>& OutCompressed, const void* InData, int32 InDataSize, FOodleDataCompression::ECompressor InCompressor, FOodleDataCompression::ECompressionLevel InLevel);
    bool CORE_API CompressData64(TArray64<uint8>& OutCompressed, const void* InData, int64 InDataSize, FOodleDataCompression::ECompressor InCompressor, FOodleDataCompression::ECompressionLevel InLevel);
 
    inline int32 PeekSizes(TArray<uint8> const& InCompressed, int32& OutCompressedSize, int32& OutDecompressedSize)
    {
        // At minimum we need 8 bytes.
        if (InCompressed.Num() < sizeof(int32)*2)
        {
            return 0;
        }
 
        const int32* Sizes = (const int32*)InCompressed.GetData();
        OutDecompressedSize = Sizes[0];
        OutCompressedSize = Sizes[1];
 
#if !PLATFORM_LITTLE_ENDIAN
        OutDecompressedSize = BYTESWAP_ORDER32(OutDecompressedSize);
        OutCompressedSize = BYTESWAP_ORDER32(OutCompressedSize);
#endif
 
        // If the compressed size has highest bit set, we are 64 bit,
        // and need to call PeekSizes64.
        if (OutCompressedSize & 0x80000000)
        {
            return 0;
        }
 
        return sizeof(int32) * 2;
    }
    inline int32 PeekSizes64(TArray64<uint8> const& InCompressed, int64& OutCompressedSize, int64& OutDecompressedSize)
    {
        if (InCompressed.Num() < sizeof(int32)*2)
        {
            return 0;
        }
 
        const int32* Sizes = (const int32*)InCompressed.GetData();
        int32 DecompressedSize32 = Sizes[0];
        int32 CompressedSize32 = Sizes[1];
 
#if !PLATFORM_LITTLE_ENDIAN
        DecompressedSize32 = BYTESWAP_ORDER32(DecompressedSize32);
        CompressedSize32 = BYTESWAP_ORDER32(CompressedSize32);
#endif
 
        OutCompressedSize = CompressedSize32;
        OutDecompressedSize = DecompressedSize32;
 
        // If the compressed size has highest bit set, we are 64 bit. This
        // is expected to be rare
        if (CompressedSize32 & 0x80000000)
        {
            // Now two int64s.
            if (InCompressed.Num() < sizeof(int64)*2)
            {
                return 0;
            }
 
            // So now the marker bit is the top bit from decompressed size
            const int64* Sizes64 = (const int64*)InCompressed.GetData();
            int64 DecompressedSize64 = Sizes64[0];
            int64 CompressedSize64 = Sizes64[1];
 
#if !PLATFORM_LITTLE_ENDIAN
            DecompressedSize64 = BYTESWAP_ORDER64(DecompressedSize64);
            CompressedSize64 = BYTESWAP_ORDER64(CompressedSize64);
#endif
 
            // clear the 64 bit indicator from decompressed size
            DecompressedSize64 &= ~0x8000000000000000ULL;
 
            OutDecompressedSize = DecompressedSize64;
            OutCompressedSize = CompressedSize64;
 
            return sizeof(int64) * 2;
        }
 
        return sizeof(int32) * 2;
    }
 
    bool CORE_API DecompressToExistingBuffer(void* InDestinationBuffer, int64 InDestinationBufferSize,  TArray<uint8> const& InCompressed);
    bool CORE_API DecompressToExistingBuffer64(void* InDestinationBuffer, int64 InDestinationBufferSize, TArray64<uint8> const& InCompressed);
 
    bool CORE_API DecompressToAllocatedBuffer(void*& OutDestinationBuffer, int32& OutDestinationBufferSize, TArray<uint8> const& InCompressed);
    bool CORE_API DecompressToAllocatedBuffer64(void*& OutDestinationBuffer, int64& OutDestinationBufferSize, TArray64<uint8> const& InCompressed);
 
 
    template <class T>
    bool CompressTArray(TArray<uint8>& OutCompressed, const TArray<T>& InBuffer, FOodleDataCompression::ECompressor InCompressor, FOodleDataCompression::ECompressionLevel InLevel)
    {
        return CompressData(OutCompressed, (const void*)InBuffer.GetData(), InBuffer.Num() * sizeof(T), InCompressor, InLevel);
    }
    template <class T>
    bool CompressTArray64(TArray64<uint8>& OutCompressed, const TArray64<T>& InBuffer, FOodleDataCompression::ECompressor InCompressor, FOodleDataCompression::ECompressionLevel InLevel)
    {
        return CompressData64(OutCompressed, (const void*)InBuffer.GetData(), InBuffer.Num() * sizeof(T), InCompressor, InLevel);
    }
 
    template <class T>
    bool DecompressToTArray(TArray<T>& OutDecompressed, TArray<uint8> const& InCompressed)
    {
        int32 DecompressedSize, CompressedSize;
        if (PeekSizes(InCompressed, CompressedSize, DecompressedSize) == 0)
        {
            return false;
        }
 
        if ((DecompressedSize % sizeof(T)) != 0)
        {
            // We must be able to evenly fit our decompressed data in to the desired output.
            return false;
        }
 
        OutDecompressed.SetNum(DecompressedSize / sizeof(T));
        return DecompressToExistingBuffer(OutDecompressed.GetData(),DecompressedSize, InCompressed);
    }
    template <class T>
    bool DecompressToTArray64(TArray64<T>& OutDecompressed, TArray64<uint8> const& InCompressed)
    {
        int64 DecompressedSize, CompressedSize;
        if (PeekSizes64(InCompressed, CompressedSize, DecompressedSize) == 0)
        {
            return false;
        }
 
        if ((DecompressedSize % sizeof(T)) != 0)
        {
            // We must be able to evenly fit our decompressed data in to the desired output.
            return false;
        }
 
        OutDecompressed.SetNum(DecompressedSize / sizeof(T));
        return DecompressToExistingBuffer64(OutDecompressed.GetData(),DecompressedSize, InCompressed);
    }
};