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();
    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 BufferPart::~BufferPart()
{
    (void)PEAK_C_ABI_PREFIX PEAK_BufferPart_Destruct(m_backendHandle);
}
 
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_GetHeight(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 */