NvSIPLCamera.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 NVSIPLCAMERA_HPP
#define NVSIPLCAMERA_HPP
 
#include "NvSIPLCommon.hpp"
#include "NvSIPLPlatformCfg.hpp"
#include "NvSIPLPipelineMgr.hpp"
#include "INvSiplControlAuto.hpp"
#include "NvSIPLClient.hpp"
#include "INvSIPLDeviceInterfaceProvider.hpp"
 
#include "nvmedia_image.h"
 
#include "devblk_cdi.h"
 
#include "nvscisync.h"
#include "nvscistream.h"
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace nvsipl
{
 
#if !NV_IS_SAFETY
const size_t NITO_PARAMETER_SET_ID_SIZE = 16U;
const size_t NITO_SCHEMA_HASH_SIZE = 32U;
const size_t NITO_DATA_HASH_SIZE = 32U;
 
struct NvSIPLNitoMetadata
{
    uint8_t parameterSetID[NITO_PARAMETER_SET_ID_SIZE]; //< Identifier of the parameter set
    uint8_t schemaHash[NITO_SCHEMA_HASH_SIZE];          //< Hash value of the parameter set schema
    uint8_t dataHash[NITO_DATA_HASH_SIZE];              //< Hash value of parameter values
};
 
SIPLStatus GetNitoMetadataFromMemory(uint8_t const *const nitoMem,
                                     size_t const nitoMemLength,
                                     NvSIPLNitoMetadata *const metadataArray,
                                     size_t const metadataArrayLength,
                                     size_t *const metadataCount);
 
#endif // NV_IS_SAFETY
 
class INvSIPLCamera
{
 public:
    static std::unique_ptr<INvSIPLCamera> GetInstance(void);
 
    virtual SIPLStatus SetPlatformCfg(const PlatformCfg *const platformCfg) = 0;
 
    virtual SIPLStatus SetPlatformCfg(const PlatformCfg *const platformCfg, NvSIPLDeviceBlockQueues &queues) = 0;
 
    virtual SIPLStatus SetPipelineCfg(uint32_t index,
                                      const NvSIPLPipelineConfiguration &pipelineCfg,
                                      NvSIPLPipelineQueues& queues) = 0;
 
    virtual SIPLStatus RegisterAutoControlPlugin(uint32_t index,
                                                 PluginType type,
                                                 ISiplControlAuto *const autoControl,
                                                 const std::vector<uint8_t>& blob) = 0;
 
    virtual SIPLStatus Init(void) = 0;
 
    virtual SIPLStatus GetImageAttributes(uint32_t index,
                                          INvSIPLClient::ConsumerDesc::OutputType const outType,
                                          NvSIPLImageAttr &imageAttr) = 0;
 
    virtual SIPLStatus ReadEEPROMData(const uint32_t index,
                                      const uint16_t address,
                                      const uint32_t length,
                                      uint8_t * const buffer) = 0;
 
    virtual SIPLStatus RegisterImageGroups(uint32_t const index,
                                           const std::vector<NvMediaImageGroup*> &imageGroups) = 0;
 
    virtual SIPLStatus RegisterImages(uint32_t const index,
                                      INvSIPLClient::ConsumerDesc::OutputType const outType,
                                      const std::vector<NvMediaImage*> &images) = 0;
 
    virtual SIPLStatus Start(void) = 0;
 
    virtual SIPLStatus Stop(void) = 0;
 
    virtual SIPLStatus Deinit(void) = 0;
 
    virtual SIPLStatus GetMaxErrorSize(const uint32_t devBlkIndex,
                                       size_t & maxErrorSize) = 0;
 
    virtual SIPLStatus GetErrorGPIOEventInfo(const uint32_t devBlkIndex,
                                             const uint32_t gpioIndex,
                                             SIPLGpioEvent &event) = 0;
 
    virtual SIPLStatus GetDeserializerErrorInfo(const uint32_t devBlkIndex,
                                                SIPLErrorDetails * const deserializerErrorInfo,
                                                bool & isRemoteError,
                                                uint8_t& linkErrorMask) = 0;
 
    virtual SIPLStatus GetModuleErrorInfo(const uint32_t index,
                                          SIPLErrorDetails * const serializerErrorInfo,
                                          SIPLErrorDetails * const sensorErrorInfo,
                                          const SIPLModuleErrorReadFlag errorsToRead
                                           = NVSIPL_MODULE_ERROR_READ_ALL) = 0;
 
    virtual SIPLStatus DisableLink(uint32_t index) = 0;
 
    virtual SIPLStatus EnableLink(uint32_t index, bool const resetModule) = 0;
 
#if !NV_IS_SAFETY
 
    virtual SIPLStatus ToggleLED(uint32_t index, bool enable) = 0;
#endif // !NV_IS_SAFETY
 
    virtual ~INvSIPLCamera(void) = default;
 
    virtual SIPLStatus FillNvSciSyncAttrList(uint32_t index,
                                             INvSIPLClient::ConsumerDesc::OutputType const outType,
                                             NvSciSyncAttrList const attrList,
                                             NvMediaNvSciSyncClientType const clientType) = 0;
 
    virtual SIPLStatus RegisterNvSciSyncObj(uint32_t index,
                                            INvSIPLClient::ConsumerDesc::OutputType const outType,
                                            NvMediaNvSciSyncObjType const syncobjtype,
                                            NvSciSyncObj const syncobj) = 0;
 
    virtual SIPLStatus GetDeserializerInterfaceProvider(uint32_t const devBlkIndex,
                                                        IInterfaceProvider *&interfaceProvider) = 0;
 
    virtual SIPLStatus GetModuleInterfaceProvider(uint32_t const index,
                                                  IInterfaceProvider *&interfaceProvider) = 0;
 
}; // INvSIPLCamera
 
} // namespace nvsipl
 
 
 
#endif // NVSIPLCAMERA_HPP