ChannelPacketImpl.hpp

Go to the documentation of this file.

 
// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless
// expressly authorized by NVIDIA.  Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2018-2022 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//
 
#ifndef DWFRAMEWORK_DWNODES_COMMON_CHANNELPACKETIMPL_HPP_
#define DWFRAMEWORK_DWNODES_COMMON_CHANNELPACKETIMPL_HPP_
 
#include <dw/egomotion/EgomotionState.h>
#include <dw/image/Image.h>
#include <dw/imageprocessing/features/FeatureList.h>
#include <dw/imageprocessing/pyramid/Pyramid.h>
#include <dw/interop/streamer/ImageStreamer.h>
#include <dw/pointcloudprocessing/pointcloud/PointCloud.h>
#include <dw/roadcast/base_types/RoadCastBaseTypes.h>
#include <dw/sensors/Codec.h>
#include <dw/sensors/lidar/Lidar.h>
#include <dwcgf/Exception.hpp>
#include <dwcgf/channel/ChannelPacketImpl.hpp>
#include <dwcgf/channel/ChannelPacketTypes.hpp>
#include <dwcgf/channel/IChannelPacket.hpp>
#include <dwframework/dwnodes/common/PointCloudProcessingCommonTypes.hpp>
#include <dwframework/dwnodes/common/SelfCalibrationTypes.hpp>
#include <dwframework/dwnodes/common/SensorCommonTypes.hpp>
 
namespace dw
{
namespace framework
{
 
 
class ImageHandlePacket : public IChannelPacket
{
public:
    ImageHandlePacket(const GenericData& specimen, dwContextHandle_t ctx)
    {
        auto* props = specimen.getData<dwImageProperties>();
        if (props)
        {
            m_prop = *props;
            FRWK_CHECK_DW_ERROR(dwImage_create(&m_imageHandle, m_prop, ctx));
            m_dispatchImage = m_imageHandle;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    GenericData getGenericData() override
    {
        return GenericData(&m_dispatchImage);
    }
 
    ~ImageHandlePacket()
    {
        dwImage_destroy(m_imageHandle);
    }
 
protected:
    dwImageHandle_t m_imageHandle   = DW_NULL_HANDLE;
    dwImageHandle_t m_dispatchImage = DW_NULL_HANDLE;
    dwImageProperties m_prop{};
};
 
template <>
class ChannelPacket<dwImageHandle_t> : public ImageHandlePacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : ImageHandlePacket(specimen, ctx)
        , m_ctx(ctx)
    {
        if (m_prop.type != DW_IMAGE_CPU)
        {
            // Allocate streamer to CPU
            m_prop.meta = {};
            FRWK_CHECK_DW_ERROR(dwImageStreamer_initialize(&m_streamerToCPU, &m_prop, DW_IMAGE_CPU, ctx));
        }
 
        // Allocate streamer from CPU back to original type
        dwImageProperties cpuProp = m_prop;
        cpuProp.type              = DW_IMAGE_CPU;
 
        if (m_prop.type != DW_IMAGE_CPU)
        {
            FRWK_CHECK_DW_ERROR(dwImageStreamer_initialize(&m_streamerFromCPU, &cpuProp, m_prop.type, ctx));
        }
 
        FRWK_CHECK_DW_ERROR(dwImage_create(&m_imageHandleCPU, cpuProp, ctx));
        FRWK_CHECK_DW_ERROR(dwImage_getDataLayout(&m_elementSize, &m_planeCount, m_planeChannelCount, m_planeSize, &cpuProp));
 
        // Compute buffer size needed for transfer
        size_t bufferSize = sizeof(dwImageCPU);
        for (size_t i = 0; i < m_planeCount; i++)
        {
            size_t planeRowBytes = m_elementSize * m_planeSize[i].x * m_planeChannelCount[i];
            bufferSize += planeRowBytes * m_planeSize[i].y;
        }
 
        initBuffer(bufferSize);
    }
 
    ~ChannelPacket() override
    {
        if (m_prop.type != DW_IMAGE_CPU)
        {
            dwImage_destroy(m_imageHandleCPU);
            dwImageStreamer_release(m_streamerToCPU);
            dwImageStreamer_release(m_streamerFromCPU);
        }
    }
 
    // Image serialization static functions to allow re-use in dwBlindnessDetectionOutput serialization.
    static size_t serializeImage(dwImageCPU* cpuImage, unsigned char* buffer_start, size_t bufferSize,
                                 size_t planeCount, size_t elementSize, uint32_t planeChannelCount[],
                                 dwVector2ui planeSize[])
    {
 
        memcpy(buffer_start, cpuImage, sizeof(dwImageCPU));
 
        size_t bufferOffset = sizeof(dwImageCPU);
        for (size_t i = 0; i < planeCount; i++)
        {
            size_t planeOffset   = 0U;
            size_t pitch         = cpuImage->pitch[i];
            size_t planeRowBytes = elementSize * planeSize[i].x * planeChannelCount[i];
            for (size_t j = 0; j < planeSize[i].y; j++)
            {
                if (bufferOffset + planeRowBytes > bufferSize)
                {
                    throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwImageHandle_t>: serialize: send packet size, buffer size mismatch.");
                }
                memcpy(buffer_start + bufferOffset, cpuImage->data[i] + planeOffset, planeRowBytes);
                planeOffset += pitch;
                bufferOffset += planeRowBytes;
            }
        }
        return bufferOffset;
    }
 
    static void deserializeImage(dwImageHandle_t copyToImage, unsigned char* buffer_start, size_t bufferSize,
                                 size_t planeCount, size_t elementSize, uint32_t planeChannelCount[],
                                 dwVector2ui planeSize[])
    {
 
        // Ensure metadata is a match
        dwImageCPU* cpuImage = nullptr;
        FRWK_CHECK_DW_ERROR(dwImage_getCPU(&cpuImage, copyToImage));
 
        size_t bufferOffset = sizeof(dwImageCPU);
        for (size_t i = 0; i < planeCount; i++)
        {
            size_t planeOffset   = 0U;
            size_t pitch         = cpuImage->pitch[i];
            size_t planeRowBytes = elementSize * planeSize[i].x * planeChannelCount[i];
            for (size_t j = 0; j < planeSize[i].y; j++)
            {
                if (bufferOffset + planeRowBytes > bufferSize)
                {
                    throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwImageHandle_t>: deserialize: recieve packet size, buffer size mismatch.");
                }
                memcpy(cpuImage->data[i] + planeOffset, buffer_start + bufferOffset, planeRowBytes);
                planeOffset += pitch;
                bufferOffset += planeRowBytes;
            }
        }
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        dwImageCPU* cpuImage           = nullptr;
        dwImageHandle_t recvImage      = nullptr;
        dwImageHandle_t* returnedImage = nullptr;
 
        if (m_prop.type != DW_IMAGE_CPU)
        {
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerSend(m_dispatchImage, m_streamerToCPU));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReceive(&recvImage, 0, m_streamerToCPU));
 
            FRWK_CHECK_DW_ERROR(dwImage_getCPU(&cpuImage, recvImage));
        }
        else
        {
            FRWK_CHECK_DW_ERROR(dwImage_getCPU(&cpuImage, m_dispatchImage));
        }
 
        serializeImage(cpuImage, m_buffer.get(), m_bufferSize, m_planeCount, m_elementSize, m_planeChannelCount, m_planeSize);
 
        if (m_prop.type != DW_IMAGE_CPU)
        {
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReturn(&recvImage, m_streamerToCPU));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerReturn(returnedImage, 0, m_streamerToCPU));
        }
    }
 
    // Deserializes the frame after transmission
    void deserialize(size_t) final
    {
        dwImageHandle_t copyToImage = m_dispatchImage;
        if (m_prop.type != DW_IMAGE_CPU)
        {
            copyToImage = m_imageHandleCPU;
        }
 
        // This needs to happen here to ensure that fields can be updated later.
        dwImageCPU recvImage{};
        memcpy(&recvImage, m_buffer.get(), sizeof(dwImageCPU));
 
        deserializeImage(copyToImage, m_buffer.get(), m_bufferSize, m_planeCount, m_elementSize, m_planeChannelCount, m_planeSize);
 
        if (m_prop.type != DW_IMAGE_CPU)
        {
            dwImageHandle_t recvImageHandle = nullptr;
            dwImageHandle_t* returnedImage  = nullptr;
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerSend(m_imageHandleCPU, m_streamerFromCPU));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReceive(&recvImageHandle, 0, m_streamerFromCPU));
 
            dwImage_copyConvert(m_dispatchImage, recvImageHandle, m_ctx);
            dwImage_setMetaData(&recvImage.prop.meta, m_dispatchImage);
            dwImage_setTimestamp(recvImage.timestamp_us, m_dispatchImage);
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReturn(&recvImageHandle, m_streamerFromCPU));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerReturn(returnedImage, 0, m_streamerFromCPU));
        }
    }
 
private:
    dwImageHandle_t m_imageHandleCPU = DW_NULL_HANDLE;
 
    size_t m_elementSize = 0;
    size_t m_planeCount  = 0;
    uint32_t m_planeChannelCount[DW_MAX_IMAGE_PLANES]{};
    dwVector2ui m_planeSize[DW_MAX_IMAGE_PLANES]{};
 
    dwImageStreamerHandle_t m_streamerToCPU   = DW_NULL_HANDLE;
    dwImageStreamerHandle_t m_streamerFromCPU = DW_NULL_HANDLE;
 
    dwContextHandle_t m_ctx = DW_NULL_HANDLE;
};
 
class LatencyPacket : public IChannelPacket
{
public:
    LatencyPacket(const GenericData& specimen)
    {
        auto* props = specimen.getData<dwLatency>();
        if (props)
        {
            m_data.size       = props->size;
            m_data.senderTime = props->senderTime;
            m_allocation      = std::make_unique<uint8_t[]>(props->size);
            m_data.data       = m_allocation.get();
            m_dataOrig        = m_data;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    GenericData getGenericData() override
    {
        return GenericData(&m_data);
    }
 
protected:
    std::unique_ptr<uint8_t[]> m_allocation{};
    dwLatency m_data;
    dwLatency m_dataOrig;
};
 
// dwLatency packet for channel socket which is used for measurement of latency/data rate across tegras.
template <>
class ChannelPacket<dwLatency> : public LatencyPacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t)
        : LatencyPacket(specimen)
    {
        m_objectSize = sizeof(uint8_t);
        m_maxCount   = m_data.size;
 
        m_headerSize = sizeof(dwLatency);
 
        // packet has fixed size for simplicity
        // variable length packet is currently not supported
        initBuffer(m_headerSize + m_maxCount * m_objectSize);
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        //copy packet data into buffer
        memcpy(m_buffer.get(), &m_data, m_headerSize);
 
        // deep copy objects data
        memcpy(m_buffer.get() + m_headerSize, m_data.data, m_data.size * m_objectSize);
    }
 
    // Deserializes the frame after transmission
    void deserialize(size_t) final
    {
        //retrieve dwLatency from buffer
        memcpy(&m_data, m_buffer.get(), m_headerSize);
 
        //retrieve object data
        // points objects to the correct location in byte buffer
        m_data.data = m_buffer.get() + m_headerSize;
    }
 
private:
    size_t m_headerSize;
    size_t m_objectSize;
    size_t m_maxCount;
};
 
class PyramidImagePacket : public IChannelPacket
{
public:
    PyramidImagePacket(const GenericData& specimen, dwContextHandle_t ctx)
    {
        auto* props = specimen.getData<dwPyramidImageProperties>();
        if (props)
        {
            m_props = *props;
            FRWK_CHECK_DW_ERROR(dwPyramid_createFromProperties(&m_pyramidImage, &m_props, ctx));
            m_dispatchPyramid = m_pyramidImage;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    GenericData getGenericData() override
    {
        return GenericData(&m_dispatchPyramid);
    }
 
    ~PyramidImagePacket()
    {
        dwPyramid_destroy(m_pyramidImage);
    }
 
protected:
    dwPyramidImage m_pyramidImage{};
    dwPyramidImage m_dispatchPyramid{};
    dwPyramidImageProperties m_props{};
};
 
template <>
class ChannelPacket<dwPyramidImage> : public PyramidImagePacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : PyramidImagePacket(specimen, ctx)
        , m_ctx(ctx)
    {
        size_t bufferSize = sizeof(dwImageCPU) * m_props.levelCount;
 
        for (uint32_t level = 0; level < m_props.levelCount; ++level)
        {
            dwImageProperties& prop = m_props.levelProps[level];
 
            dwImageProperties cpuProp = prop;
            cpuProp.type              = DW_IMAGE_CPU;
 
            FRWK_CHECK_DW_ERROR(dwImage_create(&m_imageHandleCPU[level], cpuProp, ctx));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_initialize(&m_streamerToCPU[level], &prop, DW_IMAGE_CPU, ctx));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_initialize(&m_streamerFromCPU[level], &cpuProp, prop.type, ctx));
 
            size_t elementSize = 0;
            uint32_t planeChannelCount[DW_MAX_IMAGE_PLANES]{};
            dwVector2ui planeSize[DW_MAX_IMAGE_PLANES]{};
 
            FRWK_CHECK_DW_ERROR(dwImage_getDataLayout(&elementSize, &m_planeCount[level], planeChannelCount, planeSize, &cpuProp));
 
            // Compute buffer size needed for transfer
            for (size_t i = 0; i < m_planeCount[level]; i++)
            {
                bufferSize += (elementSize * planeSize[i].x * planeChannelCount[i]) * planeSize[i].y;
            }
        }
 
        m_pyramidImage.levelCount = m_props.levelCount;
        initBuffer(bufferSize);
    }
 
    ~ChannelPacket() override
    {
        for (uint32_t level = 0; level < m_pyramidImage.levelCount; ++level)
        {
            dwImage_destroy(m_imageHandleCPU[level]);
            dwImageStreamer_release(m_streamerToCPU[level]);
            dwImageStreamer_release(m_streamerFromCPU[level]);
        }
    }
 
    // Serializes the frame before transmission
    void serializeImpl() override
    {
        size_t written = 0;
 
        for (uint32_t i = 0; i < m_pyramidImage.levelCount; i++)
        {
            dwImageHandle_t recvImage      = nullptr;
            dwImageHandle_t* returnedImage = nullptr;
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerSend(m_pyramidImage.levelImages[i], m_streamerToCPU[i]));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReceive(&recvImage, 0, m_streamerToCPU[i]));
 
            dwImageCPU* cpuImage = nullptr;
            FRWK_CHECK_DW_ERROR(dwImage_getCPU(&cpuImage, recvImage));
 
            memcpy(m_buffer.get() + written, cpuImage, sizeof(dwImageCPU));
            written += sizeof(dwImageCPU);
 
            for (size_t j = 0; j < m_planeCount[i]; j++)
            {
                size_t planeSize = cpuImage->pitch[j] * cpuImage->prop.height;
                memcpy(m_buffer.get() + written, cpuImage->data[j], planeSize);
                written += planeSize;
            }
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReturn(&recvImage, m_streamerToCPU[i]));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerReturn(returnedImage, 0, m_streamerToCPU[i]));
        }
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) override
    {
        size_t read = 0;
 
        for (uint32_t i = 0; i < m_pyramidImage.levelCount; i++)
        {
            dwImageCPU recvImage{};
            memcpy(&recvImage, m_buffer.get() + read, sizeof(dwImageCPU));
            read += sizeof(dwImageCPU);
 
            dwImageCPU* cpuImage = nullptr;
            FRWK_CHECK_DW_ERROR(dwImage_getCPU(&cpuImage, m_imageHandleCPU[i]));
 
            for (size_t j = 0; j < m_planeCount[i]; j++)
            {
                size_t planeSize = cpuImage->pitch[j] * cpuImage->prop.height;
                memcpy(cpuImage->data[j], m_buffer.get() + read, planeSize);
                read += planeSize;
            }
 
            dwImageHandle_t recvImageHandle = nullptr;
            dwImageHandle_t* returnedImage  = nullptr;
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerSend(m_imageHandleCPU[i], m_streamerFromCPU[i]));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReceive(&recvImageHandle, 0, m_streamerFromCPU[i]));
 
            dwImage_copyConvert(m_pyramidImage.levelImages[i], recvImageHandle, m_ctx);
            dwImage_setMetaData(&recvImage.prop.meta, m_pyramidImage.levelImages[i]);
            dwImage_setTimestamp(recvImage.timestamp_us, m_pyramidImage.levelImages[i]);
 
            FRWK_CHECK_DW_ERROR(dwImageStreamer_consumerReturn(&recvImageHandle, m_streamerFromCPU[i]));
            FRWK_CHECK_DW_ERROR(dwImageStreamer_producerReturn(returnedImage, 0, m_streamerFromCPU[i]));
        }
    }
 
private:
    size_t m_planeCount[DW_PYRAMID_LEVEL_MAX_COUNT]{0};
    dwImageStreamerHandle_t m_streamerToCPU[DW_PYRAMID_LEVEL_MAX_COUNT]{};
    dwImageStreamerHandle_t m_streamerFromCPU[DW_PYRAMID_LEVEL_MAX_COUNT]{};
    dwImageHandle_t m_imageHandleCPU[DW_PYRAMID_LEVEL_MAX_COUNT]{};
    dwContextHandle_t m_ctx = DW_NULL_HANDLE;
};
 
class FeatureNccScoresPacket : public IChannelPacket
{
public:
    FeatureNccScoresPacket(const GenericData& specimen)
    {
        auto* props = specimen.getData<dwFeatureNccScores>();
        if (props)
        {
            m_ncc.size = props->size;
            FRWK_CHECK_CUDA_ERROR(cudaMalloc(&m_ncc.d_nccScores, m_ncc.size));
            m_dispatchNcc = m_ncc;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    ~FeatureNccScoresPacket() override
    {
        cudaFree(m_ncc.d_nccScores);
    }
 
    GenericData getGenericData() override
    {
        return GenericData(&m_dispatchNcc);
    }
 
protected:
    dwFeatureNccScores m_ncc{};
    dwFeatureNccScores m_dispatchNcc{};
};
 
template <>
class ChannelPacket<dwFeatureNccScores> : public FeatureNccScoresPacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t)
        : FeatureNccScoresPacket(specimen)
    {
        initBuffer(m_ncc.size);
    }
 
    // Serializes the frame before transmission
    void serializeImpl() override
    {
        FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get(), m_ncc.d_nccScores, m_ncc.size, cudaMemcpyDeviceToHost, cudaStream_t(0)));
        FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) override
    {
        FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_ncc.d_nccScores, m_buffer.get(), m_bufferSize, cudaMemcpyHostToDevice, cudaStream_t(0)));
        FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
    }
};
 
class FeatureArrayPacket : public IChannelPacket
{
public:
    FeatureArrayPacket(const GenericData& specimen, dwContextHandle_t ctx)
    {
        auto* props = specimen.getData<dwFeatureArray>();
        if (props)
        {
            dwStatus ret = dwFeatureArray_create(&m_featureArray,
                                                 props->maxFeatures,
                                                 props->memoryType,
                                                 ctx);
            if (ret != DW_SUCCESS)
            {
                throw Exception(DW_BAD_ALLOC, "FeatureArrayPacket: cannot allocate packet");
            }
            m_featureArrayOrig = m_featureArray;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    ~FeatureArrayPacket() override
    {
        dwFeatureArray_destroy(m_featureArrayOrig);
    }
 
    GenericData getGenericData() override
    {
        return GenericData(&m_featureArray);
    }
 
protected:
    dwFeatureArray m_featureArray{};
    dwFeatureArray m_featureArrayOrig{};
};
 
template <>
class ChannelPacket<dwFeatureArray> : public FeatureArrayPacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : FeatureArrayPacket(specimen, ctx)
    {
        m_propIndex[0] = sizeof(dwFeatureArray);
        m_propIndex[1] = m_propIndex[0] + sizeof(dwFeature2DStatus) * m_featureArray.maxFeatures; // statuses
        m_propIndex[2] = m_propIndex[1] + sizeof(uint32_t) * m_featureArray.maxFeatures;          // ages
        m_propIndex[3] = m_propIndex[2] + sizeof(float32_t) * m_featureArray.maxFeatures;         // scales
        m_propIndex[4] = m_propIndex[3] + sizeof(uint32_t) * m_featureArray.maxFeatures;          // ids
        m_propIndex[5] = m_propIndex[4] + sizeof(uint32_t) * m_featureArray.maxFeatures;          // newToOldMap
        m_propIndex[6] = m_propIndex[5] + sizeof(dwVector2f) * m_featureArray.maxFeatures;        // locations
        m_propIndex[7] = m_propIndex[6] + sizeof(uint32_t);                                       // featureCount
        m_propIndex[8] = m_propIndex[7] + sizeof(uint32_t);                                       // validTrackedCount
 
        initBuffer(m_propIndex[8]);
    }
 
    // Serializes the frame before transmission
    void serializeImpl() override
    {
        static_assert(sizeof(dwFeatureArray) == 80, "dwFeatureArray size has changed, update serialization");
 
        memcpy(m_buffer.get(), &m_featureArray, m_propIndex[0]);
 
        if (m_featureArray.memoryType == DW_MEMORY_TYPE_CUDA)
        {
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[0], m_featureArray.statuses, m_propIndex[1] - m_propIndex[0], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[1], m_featureArray.ages, m_propIndex[2] - m_propIndex[1], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[2], m_featureArray.scales, m_propIndex[3] - m_propIndex[2], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[3], m_featureArray.ids, m_propIndex[4] - m_propIndex[3], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[4], m_featureArray.newToOldMap, m_propIndex[5] - m_propIndex[4], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[5], m_featureArray.locations, m_propIndex[6] - m_propIndex[5], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[6], m_featureArray.featureCount, m_propIndex[7] - m_propIndex[6], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_buffer.get() + m_propIndex[7], m_featureArray.validTrackedCount, m_propIndex[8] - m_propIndex[7], cudaMemcpyDeviceToHost, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(m_stream));
        }
        else if (m_featureArray.memoryType == DW_MEMORY_TYPE_CPU ||
                 m_featureArray.memoryType == DW_MEMORY_TYPE_PINNED)
        {
            memcpy(m_buffer.get() + m_propIndex[0], m_featureArray.statuses, m_propIndex[1] - m_propIndex[0]);
            memcpy(m_buffer.get() + m_propIndex[1], m_featureArray.ages, m_propIndex[2] - m_propIndex[1]);
            memcpy(m_buffer.get() + m_propIndex[2], m_featureArray.scales, m_propIndex[3] - m_propIndex[2]);
            memcpy(m_buffer.get() + m_propIndex[3], m_featureArray.ids, m_propIndex[4] - m_propIndex[3]);
            memcpy(m_buffer.get() + m_propIndex[4], m_featureArray.newToOldMap, m_propIndex[5] - m_propIndex[4]);
            memcpy(m_buffer.get() + m_propIndex[5], m_featureArray.locations, m_propIndex[6] - m_propIndex[5]);
            memcpy(m_buffer.get() + m_propIndex[6], m_featureArray.featureCount, m_propIndex[7] - m_propIndex[6]);
            memcpy(m_buffer.get() + m_propIndex[7], m_featureArray.validTrackedCount, m_propIndex[8] - m_propIndex[7]);
        }
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) override
    {
        static_assert(sizeof(dwFeatureArray) == 80, "dwFeatureArray size has changed, update deserialization");
 
        auto array = reinterpret_cast<dwFeatureArray*>(m_buffer.get()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        if (m_featureArray.maxFeatures != array->maxFeatures)
        {
            throw Exception(DW_INVALID_ARGUMENT, "ChannelPacket<dwFeatureArray>: deserialize: maxFeatures does not match");
        }
 
        if (m_featureArray.memoryType == DW_MEMORY_TYPE_CUDA)
        {
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.statuses, m_buffer.get() + m_propIndex[0], m_propIndex[1] - m_propIndex[0], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.ages, m_buffer.get() + m_propIndex[1], m_propIndex[2] - m_propIndex[1], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.scales, m_buffer.get() + m_propIndex[2], m_propIndex[3] - m_propIndex[2], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.ids, m_buffer.get() + m_propIndex[3], m_propIndex[4] - m_propIndex[3], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.newToOldMap, m_buffer.get() + m_propIndex[4], m_propIndex[5] - m_propIndex[4], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.locations, m_buffer.get() + m_propIndex[5], m_propIndex[6] - m_propIndex[5], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.featureCount, m_buffer.get() + m_propIndex[6], m_propIndex[7] - m_propIndex[6], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureArray.validTrackedCount, m_buffer.get() + m_propIndex[7], m_propIndex[8] - m_propIndex[7], cudaMemcpyHostToDevice, m_stream));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(m_stream));
        }
        else if (m_featureArray.memoryType == DW_MEMORY_TYPE_CPU ||
                 m_featureArray.memoryType == DW_MEMORY_TYPE_PINNED)
        {
            memcpy(m_featureArray.statuses, m_buffer.get() + m_propIndex[0], m_propIndex[1] - m_propIndex[0]);
            memcpy(m_featureArray.ages, m_buffer.get() + m_propIndex[1], m_propIndex[2] - m_propIndex[1]);
            memcpy(m_featureArray.scales, m_buffer.get() + m_propIndex[2], m_propIndex[3] - m_propIndex[2]);
            memcpy(m_featureArray.ids, m_buffer.get() + m_propIndex[3], m_propIndex[4] - m_propIndex[3]);
            memcpy(m_featureArray.newToOldMap, m_buffer.get() + m_propIndex[4], m_propIndex[5] - m_propIndex[4]);
            memcpy(m_featureArray.locations, m_buffer.get() + m_propIndex[5], m_propIndex[6] - m_propIndex[5]);
            memcpy(m_featureArray.featureCount, m_buffer.get() + m_propIndex[6], m_propIndex[7] - m_propIndex[6]);
            memcpy(m_featureArray.validTrackedCount, m_buffer.get() + m_propIndex[7], m_propIndex[8] - m_propIndex[7]);
        }
 
        m_featureArray.timeIdx = array->timeIdx;
    }
 
private:
    size_t m_propIndex[9] = {};
    cudaStream_t m_stream = cudaStream_t{nullptr};
};
 
class FeatureHistoryArrayPacket : public IChannelPacket
{
public:
    FeatureHistoryArrayPacket(const GenericData& specimen, dwContextHandle_t ctx)
    {
        auto* props = specimen.getData<dwFeatureHistoryArray>();
        if (props)
        {
            dwStatus ret = dwFeatureHistoryArray_create(&m_featureHistoryArray,
                                                        props->maxFeatures,
                                                        props->maxHistory,
                                                        props->memoryType,
                                                        ctx);
            if (ret != DW_SUCCESS)
            {
                throw Exception(DW_BAD_ALLOC, "FeatureHistoryArrayPacket: cannot allocate packet");
            }
            m_featureHistoryArrayOrig = m_featureHistoryArray;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    ~FeatureHistoryArrayPacket() override
    {
        dwFeatureHistoryArray_destroy(m_featureHistoryArrayOrig);
    }
 
    GenericData getGenericData() final
    {
        return GenericData(&m_featureHistoryArray);
    }
 
protected:
    dwFeatureHistoryArray m_featureHistoryArray{};
    dwFeatureHistoryArray m_featureHistoryArrayOrig{};
};
 
template <>
class ChannelPacket<dwFeatureHistoryArray> : public FeatureHistoryArrayPacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : FeatureHistoryArrayPacket(specimen, ctx)
    {
        initBuffer(sizeof(dwFeatureHistoryArray) + m_featureHistoryArray.bytes);
    }
 
    // Serializes the frame before transmission
    void serializeImpl() override
    {
        static_assert(sizeof(dwFeatureHistoryArray) == 104, "dwFeatureHistoryArray size has changed, update serialization");
 
        uint8_t* ptr = m_buffer.get() + sizeof(dwFeatureHistoryArray);
        memcpy(m_buffer.get(), &m_featureHistoryArray, sizeof(dwFeatureHistoryArray));
 
        if (m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_CUDA)
        {
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(ptr, m_featureHistoryArray.data, m_featureHistoryArray.bytes, cudaMemcpyDeviceToHost, cudaStream_t(0)));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
        }
        else if (m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_CPU ||
                 m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_PINNED)
        {
            memcpy(ptr, m_featureHistoryArray.data, m_featureHistoryArray.bytes);
        }
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) override
    {
        static_assert(sizeof(dwFeatureHistoryArray) == 104, "dwFeatureHistoryArray size has changed, update deserialization");
 
        auto array = reinterpret_cast<dwFeatureHistoryArray*>(m_buffer.get()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        if (m_featureHistoryArray.maxFeatures != array->maxFeatures || m_featureHistoryArray.maxHistory != array->maxHistory)
        {
            throw Exception(DW_INVALID_ARGUMENT, "ChannelPacket<dwFeatureHistoryArray>: deserialize: maxFeatures or maxHistory does not match");
        }
 
        uint8_t* ptr = m_buffer.get() + sizeof(dwFeatureHistoryArray);
        if (m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_CUDA)
        {
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_featureHistoryArray.data, ptr, m_featureHistoryArray.bytes, cudaMemcpyHostToDevice, cudaStream_t(0)));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
        }
        else if (m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_CPU ||
                 m_featureHistoryArray.memoryType == DW_MEMORY_TYPE_PINNED)
        {
            memcpy(m_featureHistoryArray.data, ptr, m_featureHistoryArray.bytes);
        }
 
        m_featureHistoryArray.currentTimeIdx = array->currentTimeIdx;
    }
};
 
// dwSensorRawData packet for channel socket
template <>
class ChannelPacket<dwSensorNodeRawData> : public ChannelPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : ChannelPacket(*specimen.getData<dwSensorNodeRawData>(), ctx)
    {
        auto* frame = getFrame();
        m_frame     = GenericData(frame);
    }
 
    ChannelPacket(dwSensorNodeRawData& ref, dwContextHandle_t)
        : ChannelPacketBase(ref.size)
        , m_data(ref)
    {
    }
 
    dwSensorNodeRawData* getFrame()
    {
        return &m_data;
    }
 
    void setBufferSize(size_t bufferSize)
    {
        m_bufferSize = bufferSize;
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        //copy packet data into buffer
        memcpy(m_buffer.get(), &m_data, m_bufferSize);
    }
 
    // Deserializes the frame after transmission
    void deserialize(size_t) final
    {
        //retrieve packet data from buffer
        memcpy(&m_data, m_buffer.get(), m_bufferSize);
    }
 
private:
    dwSensorNodeRawData m_data{};
};
 
// dwLidarDecodedPacket packet for channel socket
template <>
class ChannelPacket<dwLidarDecodedPacket> : public ChannelPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : ChannelPacket(*specimen.getData<dwLidarDecodedPacket>(), ctx)
    {
        auto* frame = getFrame();
        m_frame     = GenericData(frame);
    }
 
    ChannelPacket(dwLidarDecodedPacket& ref, dwContextHandle_t)
        : m_data(ref)
    {
        size_t bufferSize = sizeof(dwLidarDecodedPacket) + sizeof(dwLidarPointRTHI) * ref.maxPoints + sizeof(dwLidarPointXYZI) * ref.maxPoints;
 
        m_pointsRTHI = std::make_unique<uint8_t[]>(sizeof(dwLidarPointRTHI) * ref.maxPoints);
        m_pointsXYZI = std::make_unique<uint8_t[]>(sizeof(dwLidarPointXYZI) * ref.maxPoints);
 
        m_data.pointsRTHI = reinterpret_cast<const dwLidarPointRTHI*>(m_pointsRTHI.get()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        m_data.pointsXYZI = reinterpret_cast<const dwLidarPointXYZI*>(m_pointsXYZI.get()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 
        initBuffer(bufferSize);
    }
 
    dwLidarDecodedPacket* getFrame()
    {
        return &m_data;
    }
 
    void setBufferSize(size_t bufferSize)
    {
        m_bufferSize = bufferSize;
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        //copy packet data into buffer
        size_t header = sizeof(dwLidarDecodedPacket);
        memcpy(m_buffer.get(), &m_data, header);
        memcpy(m_buffer.get() + header, m_data.pointsRTHI, sizeof(dwLidarPointRTHI) * m_data.nPoints);
        header += sizeof(dwLidarPointRTHI) * m_data.nPoints;
        memcpy(m_buffer.get() + header, m_data.pointsXYZI, sizeof(dwLidarPointXYZI) * m_data.nPoints);
    }
 
    // Deserializes the frame after transmission
    void deserialize(size_t) final
    {
        //retrieve packet data from buffer
        memcpy(&m_data, m_buffer.get(), sizeof(dwLidarDecodedPacket));
        m_data.pointsRTHI = reinterpret_cast<const dwLidarPointRTHI*>(m_buffer.get() + // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
                                                                      sizeof(dwLidarDecodedPacket));
        m_data.pointsXYZI = reinterpret_cast<const dwLidarPointXYZI*>(m_buffer.get() + sizeof(dwLidarDecodedPacket) + // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
                                                                      sizeof(dwLidarPointRTHI) * m_data.nPoints);
    }
 
private:
    dwLidarDecodedPacket m_data{};
    std::unique_ptr<uint8_t[]> m_pointsRTHI;
    std::unique_ptr<uint8_t[]> m_pointsXYZI;
};
 
class EgomotionStateHandlePacket : public IChannelPacket
{
public:
    EgomotionStateHandlePacket(const GenericData& specimen, dwContextHandle_t ctx)
    {
        auto* props = specimen.getData<dwEgomotionStateParams>();
        if (props)
        {
            dwEgomotionState_createEmpty(&m_egomotionState, *props, ctx);
            m_dispatchEgomotionState = m_egomotionState;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    ~EgomotionStateHandlePacket()
    {
        dwEgomotionState_release(m_egomotionState);
    }
 
    GenericData getGenericData() final
    {
        return GenericData(&m_dispatchEgomotionState);
    }
 
protected:
    dwEgomotionStateHandle_t m_egomotionState         = DW_NULL_HANDLE;
    dwEgomotionStateHandle_t m_dispatchEgomotionState = DW_NULL_HANDLE;
};
 
template <>
class ChannelPacket<dwEgomotionStateHandle_t> : public EgomotionStateHandlePacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : EgomotionStateHandlePacket(specimen, ctx)
    {
        dwEgomotionState_getMaxNumBytes(&m_numBytes, m_egomotionState);
        m_bufferSize = m_numBytes + sizeof(m_numBytes);
        initBuffer(m_bufferSize);
    }
 
    ChannelPacket(dwEgomotionStateParams& params, dwContextHandle_t ctx)
        : ChannelPacket(GenericData(&params), ctx)
    {
    }
 
    dwEgomotionStateHandle_t* getFrame()
    {
        return &m_dispatchEgomotionState;
    }
 
    size_t getNumBytes()
    {
        size_t numBytes = 0;
        memcpy(&numBytes, m_buffer.get(), sizeof(numBytes));
        return numBytes;
    }
 
    void serializeImpl() final
    {
        // Serialize state at producer side
        dwEgomotionState_serialize(&m_numBytes,
                                   m_buffer.get() + sizeof(m_numBytes),
                                   m_bufferSize - sizeof(m_numBytes),
                                   m_dispatchEgomotionState);
        memcpy(m_buffer.get(), &m_numBytes, sizeof(m_numBytes));
    }
 
    void deserialize(size_t) final
    {
        memcpy(&m_numBytes, m_buffer.get(), sizeof(m_numBytes));
        if (m_numBytes > m_bufferSize - sizeof(m_numBytes))
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwEgomotionStateHandle_t>: deserialize: recv packet size mismatch available buffer size.");
        }
        // Deserialize state at consumer side
        dwEgomotionState_deserialize(m_buffer.get() + sizeof(m_numBytes),
                                     m_numBytes,
                                     m_dispatchEgomotionState);
    }
 
private:
    size_t m_numBytes = 0;
};
 
class PointCloudChannelPacket : public IChannelPacket
{
public:
    PointCloudChannelPacket(const GenericData& specimen)
    {
        auto* props = specimen.getData<dwPointCloud>();
        if (props != nullptr)
        {
            m_data        = *props;
            m_data.points = nullptr;
            dwStatus ret  = dwPointCloud_createBuffer(&m_data);
            if (ret != DW_SUCCESS)
            {
                throw Exception(DW_BAD_ALLOC, "PointCloudChannelPacket: cannot allocate packet");
            }
 
            m_dataOri = m_data;
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid reference data provided.");
        }
    }
 
    ~PointCloudChannelPacket() override
    {
        dwPointCloud_destroyBuffer(&m_dataOri);
    }
 
    GenericData getGenericData() final
    {
        return GenericData(&m_data);
    }
 
protected:
    dwPointCloud m_data{};
    dwPointCloud m_dataOri{};
};
 
// PointCloud packet for channel socket
template <>
class ChannelPacket<dwPointCloud> : public PointCloudChannelPacket, public ChannelSocketPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t)
        : PointCloudChannelPacket(specimen)
    {
        if (m_data.numAuxChannels > 0)
        {
            throw Exception(DW_NOT_IMPLEMENTED, "ChannelPacket<dwPointCloud>: time to add support for aux data: DRIV-8273");
        }
 
        m_objectSize = getFormatSize(m_data.format);
        m_maxCount   = m_data.capacity;
        m_headerSize = sizeof(dwPointCloud);
 
        initBuffer(m_headerSize + m_maxCount * m_objectSize);
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        uint8_t* ptr = m_buffer.get() + m_headerSize;
        memcpy(m_buffer.get(), &m_data, m_headerSize);
        if (m_data.type == DW_MEMORY_TYPE_CUDA)
        {
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(ptr, m_data.points, m_data.size * m_objectSize, cudaMemcpyDeviceToHost, cudaStream_t(0)));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
        }
        else if (m_data.type == DW_MEMORY_TYPE_CPU ||
                 m_data.type == DW_MEMORY_TYPE_PINNED)
        {
            memcpy(ptr, m_data.points, m_data.size * m_objectSize);
        }
    }
 
    void deserialize(size_t) final
    {
        uint8_t* ptr = m_buffer.get() + m_headerSize;
        memcpy(&m_data, m_buffer.get(), m_headerSize);
 
        if (m_data.type == DW_MEMORY_TYPE_CUDA)
        {
            m_data.points = m_dataOri.points;
            FRWK_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_data.points, ptr, m_data.size * m_objectSize, cudaMemcpyHostToDevice, cudaStream_t(0)));
            FRWK_CHECK_CUDA_ERROR(cudaStreamSynchronize(0));
        }
        else if (m_data.type == DW_MEMORY_TYPE_CPU ||
                 m_data.type == DW_MEMORY_TYPE_PINNED)
        {
            m_data.points = static_cast<void*>(m_buffer.get() + m_headerSize);
        }
    }
 
    static size_t getFormatSize(dwPointCloudFormat format)
    {
        uint32_t formatSize = 0;
        switch (format)
        {
        case DW_POINTCLOUD_FORMAT_XYZI:
            formatSize = sizeof(dwLidarPointXYZI);
            break;
        case DW_POINTCLOUD_FORMAT_RTHI:
            formatSize = sizeof(dwLidarPointRTHI);
            break;
        default:
            throw std::runtime_error("ChannelPacket<dwPointCloud>: unknown dwPointCloudFormat");
        }
        return formatSize;
    }
 
private:
    size_t m_headerSize{};
    size_t m_objectSize{};
    size_t m_maxCount{};
};
 
// dwLidarPacketsArray for channel socket
template <>
class ChannelPacket<dwLidarPacketsArray> : public ChannelPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : ChannelPacket(*specimen.getData<dwLidarPacketsArray>(), ctx)
    {
        auto* frame = getFrame();
        m_frame     = GenericData(frame);
    }
 
    ChannelPacket(dwLidarPacketsArray& ref, dwContextHandle_t)
        : m_data(ref)
    {
        m_headerSize                   = sizeof(dwLidarPacketsArray);
        size_t lidarDecodedPacketsSize = m_data.maxPacketsPerSpin * sizeof(dwLidarDecodedPacket);
        size_t pointsXYZISize          = m_data.maxPacketsPerSpin * m_data.maxPointsPerPacket * sizeof(dwLidarPointXYZI);
        size_t pointsRTHISize          = m_data.maxPacketsPerSpin * m_data.maxPointsPerPacket * sizeof(dwLidarPointRTHI);
 
        initBuffer(m_headerSize + lidarDecodedPacketsSize + pointsXYZISize + pointsRTHISize);
 
        m_lidarPacketsPtr = reinterpret_cast<dwLidarDecodedPacket*>(m_buffer.get() + m_headerSize);                                        // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        m_pointsXYZIPtr   = reinterpret_cast<dwLidarPointXYZI*>(m_buffer.get() + m_headerSize + lidarDecodedPacketsSize);                  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        m_pointsRTHIPtr   = reinterpret_cast<dwLidarPointRTHI*>(m_buffer.get() + m_headerSize + lidarDecodedPacketsSize + pointsXYZISize); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 
        m_data.packets         = m_lidarPacketsPtr;
        m_data.pointsXYZIArray = m_pointsXYZIPtr;
        m_data.pointsRTHIArray = m_pointsRTHIPtr;
    }
 
    dwLidarPacketsArray* getFrame()
    {
        return &m_data;
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        size_t lidarDecodedPacketsSize = m_data.packetSize * sizeof(dwLidarDecodedPacket);
        size_t pointsXYZISize          = m_data.packetSize * m_data.maxPointsPerPacket * sizeof(dwLidarPointXYZI);
        size_t pointsRTHISize          = m_data.packetSize * m_data.maxPointsPerPacket * sizeof(dwLidarPointRTHI);
 
        memcpy(m_buffer.get(), &m_data, m_headerSize);
 
        if (m_data.packets != m_lidarPacketsPtr)
        {
            memcpy(m_lidarPacketsPtr, m_data.packets, lidarDecodedPacketsSize);
        }
        if (m_data.pointsXYZIArray != m_pointsXYZIPtr)
        {
            memcpy(m_pointsXYZIPtr, m_data.pointsXYZIArray, pointsXYZISize);
        }
        if (m_data.pointsRTHIArray != m_pointsRTHIPtr)
        {
            memcpy(m_pointsRTHIPtr, m_data.pointsRTHIArray, pointsRTHISize);
        }
    }
 
    void deserialize(size_t) final
    {
        memcpy(&m_data, m_buffer.get(), m_headerSize);
        m_data.packets         = m_lidarPacketsPtr;
        m_data.pointsXYZIArray = m_pointsXYZIPtr;
        m_data.pointsRTHIArray = m_pointsRTHIPtr;
        for (size_t packetsIndex = 0; packetsIndex < m_data.packetSize; ++packetsIndex)
        {
            m_data.packets[packetsIndex].pointsXYZI = &(m_data.pointsXYZIArray[packetsIndex * m_data.maxPointsPerPacket]);
            m_data.packets[packetsIndex].pointsRTHI = &(m_data.pointsRTHIArray[packetsIndex * m_data.maxPointsPerPacket]);
        }
    }
 
private:
    dwLidarPacketsArray m_data{};
 
    size_t m_headerSize{};
 
    dwLidarDecodedPacket* m_lidarPacketsPtr{};
    dwLidarPointXYZI* m_pointsXYZIPtr{};
    dwLidarPointRTHI* m_pointsRTHIPtr{};
};
 
template <>
class ChannelPacket<dwTraceNodeData> : public ChannelPacketBase
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t ctx)
        : ChannelPacket(*specimen.getData<dwTraceNodeData>(), ctx)
    {
        auto* frame = getFrame();
        m_frame     = GenericData(frame);
    }
 
    ChannelPacket(dwTraceNodeData& ref, dwContextHandle_t)
        : m_data(ref), m_headerSize(sizeof(dwTraceNodeData)), m_maxDataSize(ref.maxDataSize)
    {
        initBuffer(m_headerSize + m_maxDataSize);
        m_TraceData = m_buffer.get() + m_headerSize;
        m_data.data = m_TraceData;
    }
 
    ~ChannelPacket() override = default;
 
    dwTraceNodeData* getFrame()
    {
        return &m_data;
    }
 
    // Serializes the frame before transmission
    void serializeImpl() final
    {
        // safety check. avoid error count caused memcpy failure
        if (m_data.dataSize > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwTraceNodeData>: serializeImpl: send packet size mismatch buffer size.");
        }
        memcpy(m_buffer.get(), &m_data, m_headerSize);
        if (m_data.data != m_TraceData && m_data.dataSize <= m_maxDataSize)
        {
            memcpy(m_TraceData, m_data.data, m_data.dataSize * sizeof(uint8_t)); //deep copy. only copy valid value
        }
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) final
    {
        memcpy(&m_data, m_buffer.get(), m_headerSize);
        // safety check. avoid error count caused read failure
        if (m_data.dataSize > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwTraceNodeData>: deserialize: recv packet size mismatch buffer size.");
        }
        m_data.data = m_buffer.get() + m_headerSize;
    }
 
private:
    dwTraceNodeData m_data{};
    size_t m_headerSize{};
    size_t m_maxDataSize{};
    uint8_t* m_TraceData;
};
 
// dwCodecPacket
class CodecPacket : public IChannelPacket
{
public:
    CodecPacket(const GenericData& specimen)
    {
        auto* size = specimen.getData<size_t>();
        if (size != nullptr)
        {
            m_dataBuffer  = std::make_unique<uint8_t[]>(*size);
            m_packet.data = static_cast<uint8_t*>(m_dataBuffer.get());
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid codec packet buffer size.");
        }
        m_maxDataSize = *size;
    }
 
    GenericData getGenericData() final
    {
        return GenericData(&m_packet);
    }
 
protected:
    dwCodecPacket m_packet{};
    std::unique_ptr<uint8_t[]> m_dataBuffer{};
    size_t m_maxDataSize;
};
 
template <>
class ChannelPacket<dwCodecPacket> : public ChannelSocketPacketBase, public CodecPacket
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t)
        : CodecPacket(specimen)
    {
        m_headerSize = sizeof(dwCodecPacket);
        initBuffer(m_headerSize + m_maxDataSize);
    }
 
    // Serializes the packet before transmission
    void serializeImpl() final
    {
        // safety check. avoid error count caused memcpy failure
        if (m_packet.dataSizeBytes > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwCodecPacket>: serializeImpl: send packet size mismatch buffer size.");
        }
        memcpy(m_buffer.get(), &m_packet, m_headerSize);
        // deep copy
        memcpy(m_buffer.get() + m_headerSize, m_packet.data, m_packet.dataSizeBytes);
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) final
    {
        memcpy(&m_packet, m_buffer.get(), m_headerSize);
        // safety check. avoid error count caused read failure
        if (m_packet.dataSizeBytes > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<dwCodecPacket>: deserialize: recv packet size mismatch buffer size.");
        }
        // deep copy
        memcpy(m_dataBuffer.get(), m_buffer.get() + m_headerSize, m_packet.dataSizeBytes);
        m_packet.data = static_cast<uint8_t*>(m_dataBuffer.get());
    }
 
private:
    size_t m_headerSize;
};
 
// SensorServiceNodeRawData
class SensorServiceNodeRawDataPacket : public IChannelPacket
{
public:
    SensorServiceNodeRawDataPacket(const GenericData& specimen)
    {
        auto* size = specimen.getData<size_t>();
        if (size != nullptr)
        {
            m_dataBuffer  = std::make_unique<uint8_t[]>(*size);
            m_packet.data = static_cast<uint8_t*>(m_dataBuffer.get());
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "Invalid maximum buffer size.");
        }
        m_maxDataSize = *size;
    }
 
    GenericData getGenericData() final
    {
        return GenericData(&m_packet);
    }
 
protected:
    SensorServiceNodeRawData m_packet{};
    std::unique_ptr<uint8_t[]> m_dataBuffer{};
    size_t m_maxDataSize;
};
 
template <>
class ChannelPacket<SensorServiceNodeRawData> : public ChannelSocketPacketBase, public SensorServiceNodeRawDataPacket
{
public:
    ChannelPacket(const GenericData& specimen, dwContextHandle_t)
        : SensorServiceNodeRawDataPacket(specimen)
    {
        m_headerSize = sizeof(SensorServiceNodeRawData);
        initBuffer(m_headerSize + m_maxDataSize);
    }
 
    // Serializes the packet before transmission
    void serializeImpl() final
    {
        // safety check. avoid error count caused memcpy failure
        if (m_packet.size > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<SensorServiceNodeRawData>: serializeImpl: send packet size mismatch buffer size.");
        }
        memcpy(m_buffer.get(), &m_packet, m_headerSize);
        // deep copy
        memcpy(m_buffer.get() + m_headerSize, m_packet.data, m_packet.size);
    }
 
    // Deserializes the frame before transmission
    void deserialize(size_t) final
    {
        memcpy(&m_packet, m_buffer.get(), m_headerSize);
        // safety check. avoid error count caused read failure
        if (m_packet.size > m_maxDataSize)
        {
            throw Exception(DW_OUT_OF_BOUNDS, "ChannelPacket<SensorServiceNodeRawData>: deserialize: recv packet size mismatch buffer size.");
        }
        // deep copy
        memcpy(m_dataBuffer.get(), m_buffer.get() + m_headerSize, m_packet.size);
        m_packet.data = static_cast<uint8_t*>(m_dataBuffer.get());
    }
 
private:
    size_t m_headerSize;
};
 
} // namespace framework
} // namespace dw
 
#endif // DWFRAMEWORK_DWNODES_COMMON_CHANNELPACKETIMPL_HPP_