高通平台--camera驱动代码结构

1、camx/src/core

sensor、manager、pipeline等结构的实现

camxpipeline.h

 /// @brief Pipeline create input data
 struct PipelineCreateInputData
 {
     ChiContext*               pChiContext;                  ///< ChiContext pointer
     const PipelineDescriptor* pPipelineDescriptor;          ///< Pipeline descriptor
     UINT                      pipelineIndex;                ///< Pipeline Index from the Session
     BOOL                      isRealTime;                   ///< Is it a real time pipeline

     BOOL                      isSecureMode;                 ///< Mode of pipeline Secure/Non-secure
  };

 

  /// @brief Pipeline create output data
  struct PipelineCreateOutputData
  {
      Pipeline*                pPipeline;                 ///< Created pipeline
      UINT32                   numInputs;                 ///< Number of inputs
      /// @todo (CAMX-1512) Instead of Chi structures use wrappers
      ChiPipelineInputOptions* pPipelineInputOptions;     ///< Input buffer requirements for the create pipeline
  };

camxnode.h

  /// @brief Node create input data                                                                                                                                                                                                  
  struct NodeCreateInputData
  {
      const PerNodeInfo*           pNodeInfo;            ///< Node info
      Camera3Stream**              ppCamera3Streams;     ///< Camera3 streams
      Pipeline*                    pPipeline;            ///< Pipeline pointer
      UINT                         pipelineNodeIndex;    ///< This node instance's index in the pipeline nodes
      const HwFactory*             pFactory;             ///< HwFactory pointer
      ChiContext*                  pChiContext;          ///< Chi Context
      ChiNodeCallbacks*            pChiNodeCallbacks;    ///< CHINode callbacks pointer
      CHIAFALGORITHMCALLBACKS*     pAFAlgoCallbacks;     ///< Algo Calllback Interface for Chi
      CHIAECALGORITHMCALLBACKS*    pAECAlgoCallbacks;    ///< Algo Calllback Interface for Chi
      CHIAWBALGORITHMCALLBACKS*    pAWBAlgoCallbacks;    ///< Algo Calllback Interface for Chi
      CHIAFDALGORITHMCALLBACKS*    pAFDAlgoCallbacks;    ///< Algo Calllback Interface for Chi
      CHIASDALGORITHMCALLBACKS*    pASDAlgoCallbacks;    ///< Algo Calllback Interface for Chi
      CHIPDLIBRARYCALLBACKS*       pPDLibCallbacks;      ///< Algo Calllback Interface for Chi
      CHIISPHVXALGORITHMCALLBACKS* pHVXAlgoCallbacks;    ///< HVX Algo Callback Interface for Chi
  };
  /// @brief Node create output data
 struct NodeCreateOutputData                                                                                                                                                                                                        
  {
      Node*           pNode;                                ///< Created node object pointer
      const CHAR*     pNodeName;                            ///< Name of the node (filled in the by the derived node)
      NodeCreateFlags createFlags;                          ///< Create flags
      UINT            maxNumCmdBufferManagers;              ///< Max require number of command buffer managers
     UINT            maxOutputPorts;                       ///< Max number of output ports supported
      UINT            maxInputPorts;                        ///< Max number of input ports supported
      BufferGroup     bufferComposite;                      ///< Buffer composite info
  };

  /// @brief Node capture request data.
  struct NodeProcessRequestData
  {
      CaptureRequest*      pCaptureRequest;                    ///< Stream configuration pointer
      DependencyUnit       dependencyInfo[MaxDependencies];    ///< List of Dependency info that will be reported back
                                                              ///  to topology. Each element in the list is a set of
                                                               ///  property and buffer dependencies
      UINT                 numDependencyLists;                 ///  Number of entries in the Dependency List
      PerBatchedFrameInfo* pPerBatchedFrameInfo;               ///< Per batched frame info
      INT32                processSequenceId;                  ///< Identifier for the node to track its processing order
      BOOL                 bindIOBuffers;                      ///< Flag indicating whether node requested input, output buffers                                                                                                     
                                                               ///  to be available on this sequenceId
      BOOL                 isSequenceIdInternal;               ///< True if processSequenceId belongs to base node
  };
 

camxsession.h

 /// @brief Pipeline descriptor handle used to describe a pipeline
  struct PipelineDescriptor
  {
      PerPipelineInfo         pipelineInfo;                               ///< Pipeline info that will be used to create the
                                                                          ///  actual pipeline object
      UINT                    numOutputs;                                 ///< Number of outputs (<= MaxPipelineOutputs)
      PipelineOutputData      outputData[MaxPipelineOutputs];             ///< Output data
      UINT                    numInputs;                                  ///< Number of inputs  (<= MaxPipelineInputs)
      PipelineInputData       inputData[MaxPipelineInputs];               ///< Input data for this pipeline
      PipelineDescriptorFlags flags;                                      ///< Flags
      UINT                    numBatchedFrames;                           ///< Number of framework frames batched
      UINT                    maxFPSValue;                                ///< maxFPSValue info of batched frames
      UINT32                  cameraId;                                   ///< Camera Id of pipeline
      CHAR                    pipelineName[MaxStringLength256];           ///< Name of this pipeline
      VOID*                   pPrivData;                                  ///< Camx private data, carrying pipeline obj ptr.
      MetaBuffer*             pSessionMetadata;                           ///< Metadata buffer published by the Chi Usecase
  };
 

 

2、camx/src/core/hal

camera provider 在hal的接口实现

3、camx/src/core/chi

主要是于chi api的函数映射相关文件

4、camx/src/swl

软件流程和node实现，包括stats、jpeg、sensor等

5、camx/src/hwl

硬件相关流程与node的实现，平台支持。包括ife，bps，ipe等

6、vendor/qcom/proprietary/chi-cdk/vendor

chi api ，即hal3的拓展部分

actuator ：VCM驱动配置

sensor：sensor驱动配置

eeprom：eeprom驱动配置

module：模组驱动配置

flash：闪光灯驱动配置

fd：人脸参数配置

tuning：效果调试参数

ois：ois驱动配置

node：各个node的实现

topology：拓扑图xml

 

后续高通代码逻辑结构会在这里继续补充