Preview pipeline: Display_Out SetupTargetBuffer

camx/src/core/hal/camxhaldevice.cpp

  CamxResult HALDevice::ProcessCaptureRequest(
      Camera3CaptureRequest* pRequest)
  {
          result = GetCHIAppCallbacks()->chi_override_process_request(reinterpret_cast<const camera3_device*>(&m_camera3Device),
                                                                      reinterpret_cast<camera3_capture_request_t*>(pRequest),
                                                                      NULL);

chi-cdk/core/chiframework/chxextensioninterface.cpp

  static CDKResult chi_override_process_request(
      const camera3_device_t*     camera3_device,
      camera3_capture_request_t*  capture_request,
      void*                       priv)
  {
      return pExtensionModule->OverrideProcessRequest(camera3_device, capture_request, priv);

chi-cdk/core/chiframework/chxextensionmodule.cpp 

CDKResult ExtensionModule::OverrideProcessRequest(
      const camera3_device_t*     camera3_device,
      camera3_capture_request_t*  pCaptureRequest,
      VOID*                       pPriv)
  {
                 result = m_pSelectedUsecase[logicalCameraId]->ProcessCaptureRequest(pCaptureRequest);

 

chi-cdk/core/chiframework/chxusecase.cpp

  CDKResult Usecase::ProcessCaptureRequest(
      camera3_capture_request_t* pRequest)
  {
         result = ExecuteCaptureRequest(pRequest);

chi-cdk/core/chiusecase/chxadvancedcamerausecase.cpp

  CDKResult AdvancedCameraUsecase::ExecuteCaptureRequest(
      camera3_capture_request_t* pRequest)
  {
              result = pFeature->ExecuteProcessRequest(pRequest);

chi-cdk/core/chifeature2/chifeature2wrapper.cpp

  CDKResult Feature2Wrapper::ExecuteProcessRequest(
      camera3_capture_request_t* pRequest)
  {
                  result = m_pChiFeatureGraphManager->ExecuteProcessRequest(pUsecaseRequestObject);  

chi-cdk/core/chifeature2/chifeature2graphmanager.cpp

  CDKResult ChiFeature2GraphManager::ExecuteProcessRequest(
      ChiFeature2UsecaseRequestObject* pRequestObject)
  {
              result = pFeatureGraph->ExecuteProcessRequest(pRequestObject);

 chi-cdk/core/chifeature2/chifeature2graph.cpp

  CDKResult ChiFeature2Graph::ExecuteProcessRequest(
      ChiFeature2UsecaseRequestObject* pUsecaseRequestObj)
  {
      CDKResult result = CDKResultSuccess;
  
      m_pUsecaseRequestObj = pUsecaseRequestObj;
  
      // Depending on state, either gather input dependencies for URO or set input dependencies from URO
      ChiFeature2UsecaseRequestObjectState requestState = pUsecaseRequestObj->GetRequestState();
  
      switch (requestState)
      {
          case ChiFeature2UsecaseRequestObjectState::Initialized:
              // Setup links, feature request objects, and gather input dependencies for the usecase request object
              result = WalkAllExtSinkLinks(pUsecaseRequestObj);
              break;
  
          case ChiFeature2UsecaseRequestObjectState::InputConfigPending:
              // Set any available input dependencies for the usecase request object
              result = WalkAllExtSrcLinks(pUsecaseRequestObj);
              break;
  
          default:
              CHX_LOG_ERROR("Unsupported ChiFeature2UsecaseRequestObjectState: %d", requestState);
              result = CDKResultEInvalidArg;
              break;
      }
  
      return result;
  }
  
  CDKResult ChiFeature2Graph::WalkAllExtSinkLinks(
      ChiFeature2UsecaseRequestObject* pUsecaseRequestObj)
  {
          // Walk back to the source node of the sink link, checking all of its output links to determine next step
          result = WalkBackFromLink(pUsecaseRequestObj, pExtSinkLinkData);
    
  CDKResult ChiFeature2Graph::WalkBackFromLink(
      ChiFeature2UsecaseRequestObject*    pUsecaseRequestObj,
      ChiFeature2GraphLinkData*           pOutputLinkData)
  {
              // Submit the feature request object, if all links have been visited
              result = ProcessUpstreamFeatureRequest(pUsecaseRequestObj, pOutputLinkData->pSrcGraphNode);
              
  CDKResult ChiFeature2Graph::ProcessUpstreamFeatureRequest(
      ChiFeature2UsecaseRequestObject*    pUsecaseRequestObj,
      ChiFeature2GraphNode*               pGraphNode)
  {
                      // Give the feature request object to the feature and continue the walk-back
                      result = pGraphNode->pFeatureBaseObj->ProcessRequest(pSrcFeatureRequestObj,
                                                                           ChiFeature2RequestCommands::Execute);

chi-cdk/core/chifeature2/chifeature2base.cpp

  CDKResult ChiFeature2Base::ProcessRequest(
      ChiFeature2RequestObject*  pRequestObject,
      ChiFeature2RequestCommands requestCommand)
  {
              switch (requestCommand)
              {
                  case ChiFeature2RequestCommands::InputResource:
                      result = ProcessInputResource(pRequestObject, requestId);
                      break;
  
                  case ChiFeature2RequestCommands::Execute:
                      result = ProcessExecute(pRequestObject, requestId);
                      break;
  
                  case ChiFeature2RequestCommands::OutputResource:
                      result = ProcessOutputResource(pRequestObject, requestId);
                      break;
  
                  case ChiFeature2RequestCommands::ReleaseResource:
                      result = ProcessReleaseResource(pRequestObject, requestId);
                      break;
  
                  case ChiFeature2RequestCommands::Complete:
                      ProcessComplete(pRequestObject, requestId);
                      break;
                  default:
                      break;
              }
  CDKResult ChiFeature2Base::ProcessExecute(
      ChiFeature2RequestObject* pRequestObject,
      UINT8                     requestId)
  {
              switch(requestState)
              {
                  case ChiFeature2RequestState::Initialized:
                      if (TRUE == static_cast<BOOL>(ChxUtils::AtomicLoadU32(&m_isFlushInProgress)))
                      {
                          CHX_LOG_WARN("%s requestId:%d has been dropped as flush is in progress",
                              pRequestObject->IdentifierString(), requestId);
                          result = CDKResultECancelledRequest;
                      }
                      else
                      {
                          result = HandlePrepareRequest(pRequestObject);
                          if (CDKResultSuccess != result)
                          {
                              CHX_LOG_ERROR("HandlePrepareRequest returned error: %d", result);
                          }
                      }
                      canExecute = TRUE;
                      break;
                  case ChiFeature2RequestState::ReadyToExecute:
                  case ChiFeature2RequestState::Executing:
                      result = OnProcessRequest(pRequestObject, requestId);
                      if (CDKResultSuccess != result)
                      {
                          CHX_LOG_ERROR("OnProcessRequest failed with result: %d", result);
                      }
                      canExecute = TRUE;
                      break;
                  case ChiFeature2RequestState::InputResourcePending:
                      result = ProcessDependency(pRequestObject, requestId);
                      canExecute = FALSE;
                      break;
                  case ChiFeature2RequestState::OutputResourcePending:
                  case ChiFeature2RequestState::Complete: // During flush error mechanism makes state to complete.
                      canExecute = FALSE;
                      break;
                  default:
                      canExecute = FALSE;
                      CHX_LOG_WARN("%s: Failed: FRO is in incorrect state: %d requestId:%d",
                          GetFeatureName(), requestState, requestId);
              }
  CDKResult ChiFeature2Base::OnProcessRequest(
      ChiFeature2RequestObject* pRequestObject,
      UINT8                     requestId)
  {
              switch (requestState)
              {
                  case ChiFeature2RequestState::ReadyToExecute:
                  case ChiFeature2RequestState::Executing:
                  {
                      result = HandleExecuteProcessRequest(pRequestObject, requestId);
                      if (CDKResultENoMore == result)
                      {
                          CHX_LOG_WARN("HandleExecuteProcessRequest is not continuing due to errors");
                      }
                      else if (CDKResultSuccess != result)
                      {
                          if (CDKResultECancelledRequest != result)
                          {
                              CHX_LOG_ERROR("HandleExecuteProcessRequest returned error: %d", result);
                          }
                          else
                          {
                              CHX_LOG_INFO("HandleExecuteProcessRequest request cancelled result: %d", result);
                          }
                      }
                      break;
                  }
                  case ChiFeature2RequestState::Complete:
                      CHX_LOG_INFO("Already in complete state for requestId: %d", requestId);
                      break;
                  default:
                      CHX_LOG_INFO("Move to State: %d", requestState);
                      break;
              }
  CDKResult ChiFeature2Base::HandleExecuteProcessRequest(
      ChiFeature2RequestObject* pRequestObject,
      UINT8                     requestId)
  {
                  result = OnExecuteProcessRequest(pRequestObject);

chi-cdk/oem/qcom/feature2/chifeature2rt/chifeature2realtime.cpp

  CDKResult ChiFeature2RealTime::OnExecuteProcessRequest(
      ChiFeature2RequestObject * pRequestObject
      ) const
  {
                              PopulatePortConfiguration(pRequestObject, NULL, &filtered);

chi-cdk/core/chifeature2/chifeature2base.cpp

  CDKResult ChiFeature2Base::PopulatePortConfiguration(
      ChiFeature2RequestObject*     pRequestObject,
      const ChiFeature2PortIdList*  pInputList,
      const ChiFeature2PortIdList*  pOutputList
      ) const
  {
                      // Check if the TBM of this port is shared with other linked port and the linked
                      // port has setup TBH, if yes, get TBH from the linked port. Otherwise, get
                      // TBH from TargetBufferManager.
                      bufferResult = GetBufferHandleFromLinkedPort(pRequestObject,
                          pPortData, requestId, 0, outputBufferMetaInfo);
                      if (CDKResultSuccess != bufferResult)
                      {
                          outputBufferMetaInfo.hBuffer = GetOutputBufferHandle(pPortData, pRequestData->frameNumber);
                          
  CHITARGETBUFFERINFOHANDLE ChiFeature2Base::GetOutputBufferHandle(
      const ChiFeaturePortData* pPortData,
      UINT32                    sequenceNumber
      ) const
  {
          pTargetBufferManager = pPortData->pOutputBufferTbm;
          hBuffer              = pTargetBufferManager->SetupTargetBuffer(sequenceNumber);

chi-cdk/core/chifeature2/chitargetbuffermanager.cpp