ImagePixelData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Misc/CoreDefines.h"
#include "Math/IntPoint.h"
#include "IImageWrapper.h"
#include "Templates/UniquePtr.h"
#include "ImageCore.h"
 
class FFloat16Color;
template<typename PixelType> struct TImagePixelDataTraits;
 
 
// todo : use ImageCore ERawImageFormat instead
enum class EImagePixelType
{
    Color,
    Float16,
    Float32,
};
 
struct IImagePixelDataPayload
{
    virtual ~IImagePixelDataPayload() {}
};
 
typedef TSharedPtr<IImagePixelDataPayload, ESPMode::ThreadSafe> FImagePixelPayloadPtr;
 
 
// @todo Oodle : use ImageCore FImage instead
//  get rid of this whole class and TImagePixelData too
//  just use an FImage instead
struct FImagePixelData
{
    virtual ~FImagePixelData() {}
    
    // NOTE : before, U8 would be written to EXR *linear*
    //  now it will get gamma corrected if bSRGB (which is on by default)
 
    EImagePixelType GetType() const
    {
        return Type;
    }
 
    FIntPoint GetSize() const
    {
        return Size;
    }
 
    ERGBFormat GetPixelLayout() const
    {
        return PixelLayout;
    }
 
    uint8 GetBitDepth() const
    {
        return BitDepth;
    }
 
    uint8 GetNumChannels() const
    {
        return NumChannels;
    }
    
    FImageView GetImageView() const
    {
        const void* RawPtr    = nullptr;
        int64       SizeBytes = 0;
 
        FImageView Ret;
 
        if ( ! GetRawData(RawPtr, SizeBytes) )
        {
            return FImageView();
        }
        
        check( NumChannels == 4 );
 
        switch(Type)
        {
        case EImagePixelType::Color:
            check(PixelLayout == ERGBFormat::BGRA );
            check(BitDepth == 8 );
            Ret = FImageView( (const FColor *)RawPtr, Size.X, Size.Y, bSRGB ? EGammaSpace::sRGB : EGammaSpace::Linear );
            break;
 
        case EImagePixelType::Float16:
            check(PixelLayout == ERGBFormat::RGBAF );
            check(BitDepth == 16 );
            Ret = FImageView( (const FFloat16Color *)RawPtr, Size.X, Size.Y );
            break;
 
        case EImagePixelType::Float32:
            check(PixelLayout == ERGBFormat::RGBAF );
            check(BitDepth == 32 );
            Ret = FImageView( (const FLinearColor *)RawPtr, Size.X, Size.Y );
            break;
 
        default:
            check(0);
            return FImageView();
        }
 
        check( Ret.GetImageSizeBytes() == SizeBytes );
        return Ret;
    }
 
    void SetAlphaOpaque()
    {
        FImageCore::SetAlphaOpaque( GetImageView() );
    }
 
    bool IsDataWellFormed() const
    {
        const void* RawPtr    = nullptr;
        int64       SizeBytes = 0;
 
        return GetRawData(RawPtr, SizeBytes);
    }
 
    bool GetRawData(const void*& OutRawData, int64& OutSizeBytes) const
    {
        const void* RawPtr    = nullptr;
        int64       SizeBytes = 0;
 
        RetrieveData(RawPtr, SizeBytes);
 
        int64 FoundTotalSize = int64(Size.X)*int64(Size.Y)*int64(BitDepth / 8)*int64(NumChannels);
        if (RawPtr && SizeBytes == FoundTotalSize)
        {
            OutRawData = RawPtr;
            OutSizeBytes = SizeBytes;
            return true;
        }
        return false;
    }
 
    int64 GetRawDataSizeInBytes() const
    {
        const void* RawPtr    = nullptr;
        int64       SizeBytes = 0;
 
        RetrieveData(RawPtr, SizeBytes);
        return SizeBytes;
    }
 
    TUniquePtr<FImagePixelData> CopyImageData() const
    {
        return Copy();
    }
 
    TUniquePtr<FImagePixelData> MoveImageDataToNew()
    {
        return Move();
    }
 
    template<typename T>
    T* GetPayload() { return static_cast<T*>(Payload.Get()); }
 
    template<typename T>
    const T* GetPayload() const { return static_cast<T*>(Payload.Get()); }
 
    void SetPayload(FImagePixelPayloadPtr NewPayload) { Payload = NewPayload; }
 
    bool GetSRGB() const { return bSRGB; }
    void SetSRGB(bool InSRGB) { bSRGB = InSRGB; }
 
protected:
 
    FImagePixelData(const FIntPoint& InSize, EImagePixelType InPixelType, ERGBFormat InPixelLayout, uint8 InBitDepth, uint8 InNumChannels, FImagePixelPayloadPtr InPayload)
        : Size(InSize)
        , Type(InPixelType)
        , PixelLayout(InPixelLayout)
        , BitDepth(InBitDepth)
        , NumChannels(InNumChannels)
        , Payload(InPayload)
    {
        // FColor is sRGB by default, floats are Linear
        bSRGB = ( InPixelType == EImagePixelType::Color );
    }
 
private:
 
    virtual void RetrieveData(const void*& OutDataPtr, int64& OutSizeBytes) const = 0;
    virtual TUniquePtr<FImagePixelData> Copy() const = 0;
    virtual TUniquePtr<FImagePixelData> Move() = 0;
 
    FIntPoint Size;
 
    EImagePixelType Type;
 
    ERGBFormat PixelLayout;
 
    uint8 BitDepth;
 
    uint8 NumChannels;
 
    bool bSRGB;
 
    FImagePixelPayloadPtr Payload;
};
 
template<typename PixelType>
struct TImagePixelData : FImagePixelData
{
    TArray64<PixelType> Pixels;
 
    TImagePixelData(const FIntPoint& InSize)
        : FImagePixelData(InSize, TImagePixelDataTraits<PixelType>::PixelType, TImagePixelDataTraits<PixelType>::PixelLayout, TImagePixelDataTraits<PixelType>::BitDepth, TImagePixelDataTraits<PixelType>::NumChannels, nullptr)
    {}
 
    TImagePixelData(const FIntPoint& InSize, TArray64<PixelType>&& InPixels)
        : FImagePixelData(InSize, TImagePixelDataTraits<PixelType>::PixelType, TImagePixelDataTraits<PixelType>::PixelLayout, TImagePixelDataTraits<PixelType>::BitDepth, TImagePixelDataTraits<PixelType>::NumChannels, nullptr)
        , Pixels(MoveTemp(InPixels))
    {}
 
    TImagePixelData(const FIntPoint& InSize, FImagePixelPayloadPtr InPayload)
        : FImagePixelData(InSize, TImagePixelDataTraits<PixelType>::PixelType, TImagePixelDataTraits<PixelType>::PixelLayout, TImagePixelDataTraits<PixelType>::BitDepth, TImagePixelDataTraits<PixelType>::NumChannels, InPayload)
    {}
 
    TImagePixelData(const FIntPoint& InSize, TArray64<PixelType>&& InPixels, FImagePixelPayloadPtr InPayload)
        : FImagePixelData(InSize, TImagePixelDataTraits<PixelType>::PixelType, TImagePixelDataTraits<PixelType>::PixelLayout, TImagePixelDataTraits<PixelType>::BitDepth, TImagePixelDataTraits<PixelType>::NumChannels, InPayload)
        , Pixels(MoveTemp(InPixels))
    {}
 
    virtual TUniquePtr<FImagePixelData> Move() override
    {
        return MakeUnique<TImagePixelData<PixelType>>(MoveTemp(*this));
    }
 
    virtual TUniquePtr<FImagePixelData> Copy() const override
    {
        return MakeUnique<TImagePixelData<PixelType>>(*this);
    }
 
    virtual void RetrieveData(const void*& OutDataPtr, int64& OutSizeBytes) const override
    {
        OutDataPtr = static_cast<const void*>(&Pixels[0]);
        OutSizeBytes = Pixels.Num() * sizeof(PixelType);
    }
};
 
template<> struct TImagePixelDataTraits<FColor>
{
    static const ERGBFormat PixelLayout = ERGBFormat::BGRA;
    static const EImagePixelType PixelType = EImagePixelType::Color;
 
    enum { BitDepth = 8, NumChannels = 4 };
};
 
template<> struct TImagePixelDataTraits<FFloat16Color>
{
    static const ERGBFormat PixelLayout = ERGBFormat::RGBAF;
    static const EImagePixelType PixelType = EImagePixelType::Float16;
 
    enum { BitDepth = 16, NumChannels = 4 };
};
 
template<> struct TImagePixelDataTraits<FLinearColor>
{
    static const ERGBFormat PixelLayout = ERGBFormat::RGBAF;
    static const EImagePixelType PixelType = EImagePixelType::Float32;
 
    enum { BitDepth = 32, NumChannels = 4 };
};