NvSIPLPipelineMgr.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2021, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, 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 NVSIPLPIPELINEMGR_HPP
#define NVSIPLPIPELINEMGR_HPP
 
#include "NvSIPLCommon.hpp"
#include "NvSIPLClient.hpp"
#include "NvSIPLPlatformCfg.hpp"
 
#include "nvmedia_image.h"
#include "nvmedia_surface.h"
 
#include <cstdint>
#include <vector>
 
namespace nvsipl
{
 
enum PluginType {
   NV_PLUGIN = 0,  
   CUSTOM_PLUGIN0, 
   MAX_NUM_PLUGINS 
};
 
class NvSIPLPipelineNotifier
{
    static const uint32_t MAX_DEVICE_GPIOS = 8U;
 
public:
    enum NotificationType
    {
        NOTIF_INFO_ICP_PROCESSING_DONE = 0,
 
        NOTIF_INFO_ISP_PROCESSING_DONE,
 
        NOTIF_INFO_ACP_PROCESSING_DONE,
 
        NOTIF_INFO_CDI_PROCESSING_DONE,
 
        NOTIF_WARN_ICP_FRAME_DROP = 100,
 
        NOTIF_WARN_ICP_FRAME_DISCONTINUITY,
 
        NOTIF_WARN_ICP_CAPTURE_TIMEOUT,
 
        NOTIF_ERROR_ICP_BAD_INPUT_STREAM = 200,
 
        NOTIF_ERROR_ICP_CAPTURE_FAILURE,
 
        NOTIF_ERROR_ICP_EMB_DATA_PARSE_FAILURE,
 
        NOTIF_ERROR_ISP_PROCESSING_FAILURE,
 
        NOTIF_ERROR_ACP_PROCESSING_FAILURE,
 
        NOTIF_ERROR_CDI_SET_SENSOR_CTRL_FAILURE,
 
        NOTIF_ERROR_DESER_LINK_FAILURE,
 
        NOTIF_ERROR_DESERIALIZER_FAILURE,
 
        NOTIF_ERROR_SERIALIZER_FAILURE,
 
        NOTIF_ERROR_SENSOR_FAILURE,
 
        NOTIF_ERROR_INTERNAL_FAILURE = 300,
    };
 
    struct NotificationData
    {
        NotificationType eNotifType;
        uint32_t uIndex;
        uint8_t uLinkMask;
        uint64_t frameCaptureTSC;
        uint32_t gpioIdxs[MAX_DEVICE_GPIOS];
        uint32_t numGpioIdxs;
    };
 
    virtual ~NvSIPLPipelineNotifier(void) = default;
};
 
#if !NV_IS_SAFETY
 
class NvSIPLImageGroupWriter
{
public:
    struct RawBuffer
    {
        NvMediaImageGroup *imageGroup;
        uint32_t uIndex;
        bool discontinuity;
    };
 
    virtual SIPLStatus FillRawBuffer(RawBuffer &oRawBuffer) = 0;
 
    virtual ~NvSIPLImageGroupWriter(void) = default;
};
#endif // !NV_IS_SAFETY
 
struct NvSIPLImageAttr {
    NvMediaSurfaceType surfaceType = NvMediaSurfaceType_Unsupported;
 
    std::vector<NvMediaSurfAllocAttr> surfaceAllocAttr;
};
 
struct NvSIPLDownscaleCropCfg
{
    bool ispInputCropEnable {false};
    NvMediaRect ispInputCrop;
 
    bool isp0OutputCropEnable {false};
    NvMediaRect isp0OutputCrop;
 
    bool isp1OutputCropEnable {false};
    NvMediaRect isp1OutputCrop;
 
    bool isp0DownscaleEnable {false};
    uint32_t isp0DownscaleWidth;
    uint32_t isp0DownscaleHeight;
 
    bool isp1DownscaleEnable {false};
    uint32_t isp1DownscaleWidth;
    uint32_t isp1DownscaleHeight;
};
 
struct NvSIPLPipelineConfiguration
{
    bool captureOutputRequested {false};
 
    bool isp0OutputRequested {false};
 
    bool isp1OutputRequested {false};
 
    NvSIPLDownscaleCropCfg downscaleCropCfg {};
 
#if !NV_IS_SAFETY
 
    NvSIPLImageGroupWriter* imageGroupWriter {nullptr};
#endif // !NV_IS_SAFETY
};
 
class INvSIPLFrameCompletionQueue
{
public:
 
    virtual SIPLStatus Get(INvSIPLClient::INvSIPLBuffer*& item,
                           size_t const timeoutUsec) = 0;
 
    virtual size_t GetCount() const = 0;
 
protected:
 
    INvSIPLFrameCompletionQueue() = default;
    virtual ~INvSIPLFrameCompletionQueue() = default;
 
private:
 
    INvSIPLFrameCompletionQueue(INvSIPLFrameCompletionQueue const& other) = delete;
    INvSIPLFrameCompletionQueue& operator=(INvSIPLFrameCompletionQueue const& rhs) = delete;
};
 
class INvSIPLNotificationQueue
{
public:
 
    virtual SIPLStatus Get(NvSIPLPipelineNotifier::NotificationData& item,
                           size_t const timeoutUsec) = 0;
 
    virtual size_t GetCount() const = 0;
 
protected:
 
    INvSIPLNotificationQueue() = default;
    virtual ~INvSIPLNotificationQueue() = default;
 
private:
 
    INvSIPLNotificationQueue(INvSIPLNotificationQueue const& other) = delete;
    INvSIPLNotificationQueue& operator=(INvSIPLNotificationQueue const& rhs) = delete;
};
 
struct NvSIPLPipelineQueues
{
    INvSIPLFrameCompletionQueue* captureCompletionQueue {nullptr};
 
    INvSIPLFrameCompletionQueue* isp0CompletionQueue {nullptr};
 
    INvSIPLFrameCompletionQueue* isp1CompletionQueue {nullptr};
 
    INvSIPLNotificationQueue* notificationQueue {nullptr};
};
 
struct NvSIPLDeviceBlockQueues
{
    INvSIPLNotificationQueue* notificationQueue[MAX_DEVICEBLOCKS_PER_PLATFORM];
};
 
}  // namespace nvsipl
 
 
#endif // NVSIPLPIPELINEMGR_HPP