NvSIPLDeviceBlock.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-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 NVSIPLDEVICEBLOCK_HPP
#define NVSIPLDEVICEBLOCK_HPP
 
#include "NvSIPLCommon.hpp"
 
#include "nvmedia_core.h"
#include "nvmedia_icp.h"
#include "nvmedia_isc.h"
 
#include <string>
#include <cstdint>
#include <memory>
 
namespace nvsipl
{
 
static const std::uint32_t MAX_DEVICEBLOCKS_PER_PLATFORM = 4U;
 
static const std::uint32_t MAX_CAMERAMODULES_PER_BLOCK = 4U;
 
static const std::uint32_t MAX_SENSORS_PER_CAMERA_MODULE = 2U;
 
static const std::uint32_t MAX_EEPROMS_PER_CAMERA_MODULE = MAX_SENSORS_PER_CAMERA_MODULE;
 
static const std::uint32_t MAX_VIRTUAL_CHANNELS_PER_SENSOR = 4U;
 
static const std::uint32_t MAX_CAMERAMODULES_PER_PLATFORM = MAX_DEVICEBLOCKS_PER_PLATFORM * MAX_CAMERAMODULES_PER_BLOCK;
 
static const std::uint32_t MAX_SENSORS_PER_PLATFORM = MAX_CAMERAMODULES_PER_PLATFORM * MAX_SENSORS_PER_CAMERA_MODULE;
 
struct SensorInfo
{
 
    struct Resolution
    {
        std::uint32_t width = 0U;  
        std::uint32_t height = 0U; 
    };
 
    struct VirtualChannelInfo
    {
        std::uint32_t cfa = 0U;
        std::uint32_t embeddedTopLines = -1U;
        std::uint32_t embeddedBottomLines = -1U;
        std::string inputFormat = "";
        Resolution resolution;
        float fps = 0;
        bool isEmbeddedDataTypeEnabled = false;
    };
 
    std::uint32_t id = -1U;
    std::string name = "";
    std::string description = "";
    uint32_t i2cAddress = -1U;
    uint32_t numVirtualChannels;
    VirtualChannelInfo vcInfoList[MAX_VIRTUAL_CHANNELS_PER_SENSOR];
    bool isTriggerModeEnabled = false;
    bool isTPGEnabled = false;
    uint32_t patternMode = 0;
};
 
struct EEPROMInfo
{
    std::string name = "";
    std::string description = "";
    std::uint32_t i2cAddress = -1U;
};
 
struct SerInfo
{
    std::string name = "";
    std::string description = "";
    std::uint32_t i2cAddress = -1U;
    bool longCable = false;
};
 
struct CameraModuleInfo
{
    std::string name = "";
    std::string description = "";
    std::uint32_t linkIndex = -1U;
    SerInfo serInfo;
    uint32_t numEEPROMs = 0;
    EEPROMInfo eepromInfoList[MAX_EEPROMS_PER_CAMERA_MODULE];
    uint32_t numSensors = 0;
    SensorInfo sensorInfoList[MAX_SENSORS_PER_CAMERA_MODULE];
};
 
struct DeserInfo
{
    std::string name = "";
    std::string description = "";
    std::uint32_t i2cAddress = -1U;
};
 
struct DeviceBlockInfo
{
    bool isSimulatorModeEnabled = false;
    bool isSlaveModeEnabled = false;
    NvMediaICPInterfaceType csiPort = NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_A;
    NvMediaICPCsiPhyMode phyMode = NVMEDIA_ICP_CSI_DPHY_MODE;
    bool isGroupInitProg = false;
    std::uint32_t i2cDevice = -1U;
    DeserInfo deserInfo;
    bool isPwrCtrlDisabled = false;
 
    uint32_t numCameraModules = 0;
    CameraModuleInfo cameraModuleInfoList[MAX_CAMERAMODULES_PER_BLOCK];
    bool longCables[MAX_CAMERAMODULES_PER_BLOCK] = {false, false, false, false};
};
 
class INvSIPLDeviceBlock
{
public:
    typedef struct
    {
        std::uint32_t numOfSensors;
 
        typedef struct
        {
            std::uint32_t numOfVCs;
 
            typedef struct
            {
                std::uint32_t virtualChannelIndex;
 
                NvMediaICPSettings icpSettings;
 
                NvMediaRect clipRect;
 
                std::uint32_t embeddedTop;
 
                std::uint32_t embeddedBot;
 
                std::uint32_t frameRate;
            } VirtualChannelProperty;
 
            std::uint32_t sensorIndex;
 
            VirtualChannelProperty virtualChannelProperty[MAX_VIRTUAL_CHANNELS_PER_SENSOR];
 
            NvMediaISCDevice *sensorHandle;
 
            NvMediaISCDevice *EEPROMHandle;
        } SensorProperty;
 
        SensorProperty sensorProperty[MAX_SENSORS_PER_CAMERA_MODULE];
 
    } CameraModuleProperty;
 
    typedef struct
    {
        std::uint32_t numOfModules;
 
        CameraModuleProperty cameraModuleProperty[MAX_CAMERAMODULES_PER_BLOCK];
    } DeviceBlockProperty;
 
    static constexpr std::uint32_t MAJOR_VER  = 1U;
    static constexpr std::uint32_t MINOR_VER  = 0U;
    static constexpr std::uint32_t PATCH_VER  = 0U;
    struct Version
    {
        std::uint32_t uMajor = MAJOR_VER; 
        std::uint32_t uMinor = MINOR_VER; 
        std::uint32_t uPatch = PATCH_VER; 
    };
 
    static void GetVersion(Version& version);
 
    static std::unique_ptr <INvSIPLDeviceBlock> Create(void);
 
    virtual SIPLStatus SetConfig(const DeviceBlockInfo* deviceBlockInfo) = 0;
 
    virtual SIPLStatus Init(void) = 0;
 
    virtual SIPLStatus Start(void) = 0;
 
    virtual SIPLStatus Stop(void) = 0;
 
    virtual SIPLStatus Deinit(void) = 0;
 
    virtual SIPLStatus GetProperty(DeviceBlockProperty& property) const = 0;
 
    virtual SIPLStatus WaitForError(void) = 0;
 
    virtual SIPLStatus DetectErrors(std::uint8_t& cameraModules) = 0;
 
    virtual SIPLStatus ReconfigureModule(std::uint8_t cameraModules) = 0;
 
    virtual ~INvSIPLDeviceBlock() = default;
};
 
} // namespace nvsipl
 
#endif //NVSIPLDEVICEBLOCK_HPP