NvSIPLDeviceBlock.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019, 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;
};

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];
};

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