peak_buffer_converter_ipl.hpp

Go to the documentation of this file.

#pragma once


#include <peak_ipl/peak_ipl.hpp>
#include <peak/data_stream/peak_data_stream.hpp>
#include <peak/device/peak_device.hpp>
#include <peak/peak_buffer_converter.hpp>

#include <cassert>


namespace peak
{

template <>
inline peak::ipl::Image BufferTo<peak::ipl::Image>(const std::shared_ptr<core::Buffer>& buffer)
{
    if (buffer->HasImage())
    {
        assert(buffer->PixelFormatNamespace() != core::PixelFormatNamespace::IIDC
            && buffer->PixelFormatNamespace() != core::PixelFormatNamespace::Custom);

        size_t usableHeight = buffer->Height();
        size_t cutOff = 0;

        if (buffer->HasChunks())
        {
            auto chunks = buffer->Chunks();
            for (const auto& chunk : chunks)
            {
                if (0x73020405 == chunk->ID())
                {
                    uint16_t* chunkBase = static_cast<uint16_t*>(chunk->BasePtr());

                    usableHeight = static_cast<size_t>(chunkBase[1]);
                    size_t usableOffsetY = static_cast<size_t>(chunkBase[3]);

                    // Pitch per line
                    size_t pitch = buffer->Size() / buffer->Height();
                    cutOff = pitch * usableOffsetY;

                    break;
                }
            }
        }

        return peak::ipl::Image(static_cast<peak::ipl::PixelFormatName>(buffer->PixelFormat()),
            static_cast<uint8_t*>(buffer->BasePtr()) + buffer->ImageOffset() + cutOff, buffer->Size() - buffer->ImageOffset() - cutOff,
            buffer->Width(), usableHeight);
    }
    else if (buffer->PayloadType() == core::BufferPayloadType::Chunk)
    {
        auto remoteNodeMap = buffer->ParentDataStream()->ParentDevice()->RemoteDevice()->NodeMaps()[0];
        remoteNodeMap->UpdateChunkNodes(buffer);

        auto chunkWidth = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkWidth");
        if (chunkWidth->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
        {
            throw core::InvalidCastException("Buffer has no ChunkWidth.");
        }
        auto width = chunkWidth->Value();

        auto chunkHeight = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkHeight");
        if (chunkHeight->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
        {
            throw core::InvalidCastException("Buffer has no ChunkHeight.");
        }
        auto height = chunkHeight->Value();

        auto chunkPixelFormat = remoteNodeMap->FindNode<core::nodes::EnumerationNode>("ChunkPixelFormat");
        if (chunkPixelFormat->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
        {
            throw core::InvalidCastException("Buffer has no ChunkPixelFormat.");
        }
        auto pixelFormatValue = chunkPixelFormat->CurrentEntry()->NumericValue();
        auto pixelFormat = static_cast<peak::ipl::PixelFormatName>(pixelFormatValue);

        // assume first chunks is image data
        auto imageData = buffer->Chunks()[0];

        auto expectedDataSize = peak::ipl::PixelFormat(pixelFormat).CalculateStorageSizeOfPixels(width * height);
        if (imageData->Size() < expectedDataSize)
        {
            std::stringstream msg;
            msg << "The buffer's first chunk's size (" << imageData->Size()
                << ") is smaller than the expected data size (" << expectedDataSize << ").";
            throw core::InvalidCastException(msg.str());
        }

        return peak::ipl::Image(pixelFormat, static_cast<uint8_t*>(imageData->BasePtr()), imageData->Size(),
            static_cast<size_t>(width), static_cast<size_t>(height));
    }
    else
    {
        throw core::InvalidCastException("Buffer has no image data and no chunks.");
    }
}

} /* namespace peak */