peak_buffer_part.hpp

Go to the documentation of this file.

#pragma once


#include <peak/backend/peak_backend.h>
#include <peak/common/peak_common_structs.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>

#include <cstddef>
#include <cstdint>
#include <memory>


namespace peak
{
namespace core
{

enum class BufferPartType
{
    Unknown,
    Image2D,
    PlaneBiPlanar2D,
    PlaneTriPlanar2D,
    PlaneQuadPlanar2D,
    Image3D,
    PlaneBiPlanar3D,
    PlaneTriPlanar3D,
    PlaneQuadPlanar3D,
    ConfidenceMap,

    Custom = 1000
};

class Buffer;

class BufferPart
{
public:
    BufferPart() = delete;
    ~BufferPart() = default;
    BufferPart(const BufferPart& other) = delete;
    BufferPart& operator=(const BufferPart& other) = delete;
    BufferPart(BufferPart&& other) = delete;
    BufferPart& operator=(BufferPart&& other) = delete;

    RawInformation Info(int32_t infoCommand) const;
    uint64_t SourceID() const;
    void* BasePtr() const;
    size_t Size() const;
    BufferPartType Type() const;
    uint64_t Format() const;
    uint64_t FormatNamespace() const;
    size_t Width() const;
    size_t Height() const;
    size_t XOffset() const;
    size_t YOffset() const;
    size_t XPadding() const;
    size_t DeliveredImageHeight() const;

    std::shared_ptr<Buffer> ParentBuffer() const;

private:
    friend ClassCreator<BufferPart>;
    BufferPart(PEAK_BUFFER_PART_HANDLE bufferPartHandle, const std::weak_ptr<Buffer>& parentBuffer);
    PEAK_BUFFER_PART_HANDLE m_backendHandle;

    std::weak_ptr<Buffer> m_parentBuffer;
};

} /* namespace core */
} /* namespace peak */

/* Implementation */
namespace peak
{
namespace core
{

inline std::string ToString(BufferPartType entry)
{
    std::string entryString;

    if (entry == BufferPartType::Unknown)
    {
        entryString = "Unknown";
    }
    else if (entry == BufferPartType::Image2D)
    {
        entryString = "Image2D";
    }
    else if (entry == BufferPartType::PlaneBiPlanar2D)
    {
        entryString = "PlaneBiPlanar2D";
    }
    else if (entry == BufferPartType::PlaneTriPlanar2D)
    {
        entryString = "PlaneTriPlanar2D";
    }
    else if (entry == BufferPartType::PlaneQuadPlanar2D)
    {
        entryString = "PlaneQuadPlanar2D";
    }
    else if (entry == BufferPartType::Image3D)
    {
        entryString = "Image3D";
    }
    else if (entry == BufferPartType::PlaneBiPlanar3D)
    {
        entryString = "PlaneBiPlanar3D";
    }
    else if (entry == BufferPartType::PlaneTriPlanar3D)
    {
        entryString = "PlaneTriPlanar3D";
    }
    else if (entry == BufferPartType::PlaneQuadPlanar3D)
    {
        entryString = "PlaneQuadPlanar3D";
    }
    else if (entry == BufferPartType::ConfidenceMap)
    {
        entryString = "ConfidenceMap";
    }
    else if (entry >= BufferPartType::Custom)
    {
        entryString = "Custom";
    }

    return entryString;
}

inline BufferPart::BufferPart(PEAK_BUFFER_PART_HANDLE bufferPartHandle, const std::weak_ptr<Buffer>& parentBuffer)
    : m_backendHandle(bufferPartHandle)
    , m_parentBuffer(parentBuffer)
{}

inline RawInformation BufferPart::Info(int32_t infoCommand) const
{
    return QueryRawInformationFromCInterfaceFunction([&](int32_t* dataType, uint8_t* buffer, size_t* bufferSize) {
        return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetInfo(
            m_backendHandle, infoCommand, dataType, buffer, bufferSize);
    });
}

inline uint64_t BufferPart::SourceID() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* sourceId) {
        return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetSourceID(m_backendHandle, sourceId);
    });
}

inline void* BufferPart::BasePtr() const
{
    return QueryNumericFromCInterfaceFunction<void*>(
        [&](void** basePtr) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetBasePtr(m_backendHandle, basePtr); });
}

inline size_t BufferPart::Size() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* size) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetSize(m_backendHandle, size); });
}

inline BufferPartType BufferPart::Type() const
{
    return static_cast<BufferPartType>(
        QueryNumericFromCInterfaceFunction<PEAK_BUFFER_PART_TYPE>([&](PEAK_BUFFER_PART_TYPE* type) {
            return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetType(m_backendHandle, type);
        }));
}

inline uint64_t BufferPart::Format() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>(
        [&](uint64_t* format) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetFormat(m_backendHandle, format); });
}

inline uint64_t BufferPart::FormatNamespace() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* formatNamespace) {
        return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetFormatNamespace(m_backendHandle, formatNamespace);
    });
}

inline size_t BufferPart::Width() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* width) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetWidth(m_backendHandle, width); });
}

inline size_t BufferPart::Height() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* height) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetWidth(m_backendHandle, height); });
}

inline size_t BufferPart::XOffset() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* xOffset) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetXOffset(m_backendHandle, xOffset); });
}

inline size_t BufferPart::YOffset() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* yOffset) { return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetYOffset(m_backendHandle, yOffset); });
}

inline size_t BufferPart::XPadding() const
{
    return QueryNumericFromCInterfaceFunction<size_t>([&](size_t* xPadding) {
        return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetXPadding(m_backendHandle, xPadding);
    });
}

inline size_t BufferPart::DeliveredImageHeight() const
{
    return QueryNumericFromCInterfaceFunction<size_t>([&](size_t* deliveredImageHeight) {
        return PEAK_C_ABI_PREFIX PEAK_BufferPart_GetDeliveredImageHeight(m_backendHandle, deliveredImageHeight);
    });
}

inline std::shared_ptr<Buffer> BufferPart::ParentBuffer() const
{
    return LockOrThrow(m_parentBuffer);
}

} /* namespace core */
} /* namespace peak */