NvSIPLCamera.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates 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 "nvscisync.h"
#include "nvscistream.h"
#include "nvscibuf.h"
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace nvsipl
{
 
#if !NV_IS_SAFETY
 
static constexpr size_t NITO_PARAMETER_SET_ID_SIZE {16U};
static constexpr size_t NITO_SCHEMA_HASH_SIZE {32U};
static constexpr 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
 
enum NvSiplNvSciSyncClientType : std::uint8_t
{
    SIPL_SIGNALER,
    SIPL_WAITER
};
 
enum NvSiplNvSciSyncObjType : std::uint8_t {
    NVSIPL_PRESYNCOBJ,
    NVSIPL_EOFSYNCOBJ
};
 
 
class INvSIPLCamera
{
 public:
    static std::unique_ptr<INvSIPLCamera> GetInstance();
 
    virtual SIPLStatus SetPlatformCfg(PlatformCfg const* const platformConfig) = 0;
 
    virtual SIPLStatus SetPlatformCfg(PlatformCfg const* const platformConfig, NvSIPLDeviceBlockQueues &queues) = 0;
 
    virtual SIPLStatus SetPipelineCfg(uint32_t const index,
                                      NvSIPLPipelineConfiguration const &pipelineCfg,
                                      NvSIPLPipelineQueues& queues) = 0;
 
    virtual SIPLStatus RegisterAutoControlPlugin(uint32_t const index,
                                                 PluginType type,
                                                 ISiplControlAuto *const autoControl,
                                                 std::vector<uint8_t> const &blob) = 0;
 
    virtual SIPLStatus Init() = 0;
 
#if !NV_IS_SAFETY
 
    virtual SIPLStatus SetSensorCharMode(uint32_t const index, uint8_t expNo) = 0;
#endif // !NV_IS_SAFETY
 
    virtual SIPLStatus GetImageAttributes(uint32_t const index,
                                          INvSIPLClient::ConsumerDesc::OutputType const outType,
                                          NvSciBufAttrList const &imageAttr) = 0;
 
    virtual SIPLStatus ReadEEPROMData(uint32_t const index,
                                      uint16_t const address,
                                      uint32_t const length,
                                      uint8_t * const buffer) = 0;
 
    virtual SIPLStatus RegisterImages(uint32_t const index,
                                      INvSIPLClient::ConsumerDesc::OutputType const outType,
                                      std::vector<NvSciBufObj> const &images) = 0;
 
    virtual SIPLStatus Start() = 0;
 
    virtual SIPLStatus Stop() = 0;
 
    virtual SIPLStatus Deinit() = 0;
 
    virtual SIPLStatus GetMaxErrorSize(uint32_t const devBlkIndex,
                                       size_t & maxErrorSize) = 0;
 
    virtual SIPLStatus GetDeserializerErrorInfo(uint32_t const devBlkIndex,
                                                SIPLErrorDetails * const deserializerErrorInfo,
                                                bool & isRemoteError,
                                                uint8_t& linkErrorMask) = 0;
 
    virtual SIPLStatus GetModuleErrorInfo(uint32_t const index,
                                          SIPLErrorDetails * const serializerErrorInfo,
                                          SIPLErrorDetails * const sensorErrorInfo,
                                          SIPLModuleErrorReadFlag const errorsToRead
                                           = NVSIPL_MODULE_ERROR_READ_ALL) = 0;
 
    virtual SIPLStatus DisableLink(uint32_t const index) = 0;
 
    virtual SIPLStatus EnableLink(uint32_t const index, bool const resetModule) = 0;
 
#if !NV_IS_SAFETY
 
    virtual SIPLStatus ToggleLED(uint32_t const index, bool enable) = 0;
#endif // !NV_IS_SAFETY
 
    virtual ~INvSIPLCamera() = default;
 
    INvSIPLCamera(INvSIPLCamera& other) = delete;
 
    INvSIPLCamera& operator=(INvSIPLCamera& other) & = delete;
 
    INvSIPLCamera(INvSIPLCamera&& other) = delete;
 
    INvSIPLCamera& operator=(INvSIPLCamera&& other) & = delete;
 
    virtual SIPLStatus FillNvSciSyncAttrList(uint32_t const index,
                                             INvSIPLClient::ConsumerDesc::OutputType const outType,
                                             NvSciSyncAttrList const attrList,
                                             NvSiplNvSciSyncClientType const clientType) = 0;
 
    virtual SIPLStatus RegisterNvSciSyncObj(uint32_t const index,
                                            INvSIPLClient::ConsumerDesc::OutputType const outType,
                                            NvSiplNvSciSyncObjType const syncobjtype,
                                            NvSciSyncObj const syncobj) = 0;
 
    virtual SIPLStatus GetPipelineInterfaceProvider(uint32_t const index,
                                                    IInterfaceProvider *&interfaceProvider) noexcept = 0;
 
    virtual SIPLStatus GetDeserializerInterfaceProvider(uint32_t const devBlkIndex,
                                                        IInterfaceProvider *&interfaceProvider) = 0;
 
    virtual SIPLStatus GetModuleInterfaceProvider(uint32_t const index,
                                                  IInterfaceProvider *&interfaceProvider) = 0;
 
protected:
    INvSIPLCamera() = default;
 
}; // INvSIPLCamera
 
} // namespace nvsipl
 
 
 
#endif // NVSIPLCAMERA_HPP