NvSIPLPipelineMgr.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020, 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 "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
{
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_INTERNAL_FAILURE = 300,
    };
 
    struct NotificationData
    {
        NotificationType eNotifType;
        std::uint32_t uIndex;
        std::uint64_t frameCaptureTSC;
    };
 
    virtual void OnEvent(NotificationData &oNotificationData)
    {
        return;
    }
 
    virtual ~NvSIPLPipelineNotifier(void) = default;
};
 
class NvSIPLImageGroupWriter
{
public:
    struct RawBuffer
    {
        NvMediaImageGroup *imageGroup;
        std::uint32_t uIndex;
        bool discontinuity;
    };
 
    virtual SIPLStatus FillRawBuffer(RawBuffer &oRawBuffer) = 0;
 
    virtual ~NvSIPLImageGroupWriter(void) = default;
};
 
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};
    std::uint32_t isp0DownscaleWidth;
    std::uint32_t isp0DownscaleHeight;
 
    bool isp1DownscaleEnable {false};
    std::uint32_t isp1DownscaleWidth;
    std::uint32_t isp1DownscaleHeight;
};
 
struct NvSIPLPipelineCfg
{
    std::vector<INvSIPLClient::ConsumerDesc> clients;
 
    NvSIPLDownscaleCropCfg downscaleCropCfg {};
 
    NvSIPLPipelineNotifier* notifier {nullptr};
 
    NvSIPLImageGroupWriter* imageGroupWriter {nullptr};
};
 
struct NvSIPLPipelineConfiguration
{
    bool captureOutputRequested {false};
 
    bool isp0OutputRequested {false};
 
    bool isp1OutputRequested {false};
 
    NvSIPLDownscaleCropCfg downscaleCropCfg {};
 
    NvSIPLImageGroupWriter* imageGroupWriter {nullptr};
};
 
class INvSIPLFrameCompletionQueue
{
public:
 
    virtual SIPLStatus Get(INvSIPLClient::INvSIPLBuffer*& item,
                           size_t 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 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;
 
    INvSIPLFrameCompletionQueue* isp0CompletionQueue;
 
    INvSIPLFrameCompletionQueue* isp1CompletionQueue;
 
    INvSIPLNotificationQueue* notificationQueue;
};
 
}  // namespace nvsipl
 
 
#endif // NVSIPLPIPELINEMGR_HPP