peak_ipl_pixel_format.hpp

Go to the documentation of this file.

#pragma once

#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

#include <cstddef>
#include <cstdint>

namespace peak
{
namespace ipl
{

class PixelFormat final
{
public:
    PixelFormat()
        : m_name(peak::ipl::PixelFormatName::Invalid)
    {}

    PixelFormat(peak::ipl::PixelFormatName name); // NOLINT (note: implicitly used by Image...)


    ~PixelFormat() = default;

    PixelFormat(PixelFormat&& other) = default;

    PixelFormat(const PixelFormat& other) = default;

    PixelFormat& operator=(const PixelFormat& other) = default;

    PixelFormat& operator=(PixelFormat&& other) = default;

    PEAK_IPL_NO_DISCARD std::string Name() const
    {
        return peak::ipl::ToString(m_name);
    }

    PEAK_IPL_NO_DISCARD peak::ipl::PixelFormatName PixelFormatName() const
    {
        return m_name;
    }

    PEAK_IPL_NO_DISCARD bool operator==(const PixelFormat& other) const
    {
        return m_name == other.m_name;
    }

    PEAK_IPL_NO_DISCARD size_t NumSignificantBitsPerChannel() const;

    PEAK_IPL_NO_DISCARD size_t NumStorageBitsPerChannel() const;

    PEAK_IPL_NO_DISCARD size_t NumChannels() const;

    PEAK_IPL_NO_DISCARD uint32_t MaximumValuePerChannel() const;

    PEAK_IPL_NO_DISCARD size_t NumSignificantBitsPerPixel() const;

    PEAK_IPL_NO_DISCARD size_t NumStorageBitsPerPixel() const;


    PEAK_IPL_NO_DISCARD peak::ipl::Endianness Endianness() const;

    PEAK_IPL_NO_DISCARD uint64_t CalculateStorageSizeOfPixels(uint64_t numPixels) const;

    PEAK_IPL_NO_DISCARD bool IsPacked() const;

    PEAK_IPL_NO_DISCARD bool IsBayered() const;

    PEAK_IPL_NO_DISCARD peak::ipl::BayerPattern BayerPattern() const;

private:
    peak::ipl::PixelFormatName m_name{};
};

inline PixelFormat::PixelFormat(peak::ipl::PixelFormatName name)
    : m_name(name)
{}

inline size_t PixelFormat::NumSignificantBitsPerChannel() const
{
    size_t numSignificantBitsPerChannel = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numSignificantBitsPerChannel);
    });

    return numSignificantBitsPerChannel;
}

inline size_t PixelFormat::NumStorageBitsPerChannel() const
{
    size_t numStorageBitsPerChannel = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numStorageBitsPerChannel);
    });

    return numStorageBitsPerChannel;
}

inline size_t PixelFormat::NumChannels() const
{
    size_t numChannels = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumChannels(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numChannels);
    });

    return numChannels;
}

inline uint32_t PixelFormat::MaximumValuePerChannel() const
{
    uint32_t maximumValuePerChannel = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &maximumValuePerChannel);
    });

    return maximumValuePerChannel;
}

inline size_t PixelFormat::NumSignificantBitsPerPixel() const
{
    size_t numSignificantBitsPerPixel = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numSignificantBitsPerPixel);
    });

    return numSignificantBitsPerPixel;
}

inline size_t PixelFormat::NumStorageBitsPerPixel() const
{
    size_t numStorageBitsPerPixel = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numStorageBitsPerPixel);
    });

    return numStorageBitsPerPixel;
}

inline peak::ipl::Endianness PixelFormat::Endianness() const
{
    peak::ipl::Endianness endianness = peak::ipl::Endianness::LittleEndian;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetEndianness(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_ENDIANNESS*>(&endianness));
    });

    return endianness;
}

inline uint64_t PixelFormat::CalculateStorageSizeOfPixels(uint64_t numPixels) const
{
    uint64_t sizeOfPixels = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), numPixels, &sizeOfPixels);
    });

    return sizeOfPixels;
}

inline bool PixelFormat::IsPacked() const
{
    bool isPacked = false;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsPacked(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&isPacked));
    });

    return isPacked;
}

inline bool PixelFormat::IsBayered() const
{
    bool isPacked = false;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsBayered(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&isPacked));
    });

    return isPacked;
}

inline peak::ipl::BayerPattern PixelFormat::BayerPattern() const
{
    peak::ipl::BayerPattern pattern = peak::ipl::BayerPattern::Unknown;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetBayerPattern(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BAYER_PATTERN*>(&pattern));
    });

    return pattern;
}

} /* namespace ipl */
} /* namespace peak */