OpenCamera

 

 1 //CameraProviderManager.cpp
 2 status_t CameraProviderManager::openSession(const std::string &id, const 
 3 sp<device::V3_2::ICameraDeviceCallback>& callback, sp<device::V3_2::
 4 ICameraDeviceSession> *session) {
 5  //
 6  std::lock_guard<std::mutex> lock(mInterfaceMutex);
 7  //idcamera
 8  auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3, 0}, 
 9 /*maxVersion*/ {4, 0});
10  if (deviceInfo == nullptr) return 
11 NAME_NOT_FOUND;
12  //deviceinfo*
13  auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>
14 (deviceInfo);
15  sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.
16 promote();
17  if (parentProvider == nullptr) return DEAD_OBJECT;
18  //Provider
19  const sp<provider::V2_4::ICameraProvider> provider = parentProvider-
20 >startProviderInterface();
21  if (provider == nullptr) return DEAD_OBJECT;
22  saveRef(DeviceMode::CAMERA, id, provider);
23  Status status;
24  hardware::Return<void> ret; 
25  //
26  auto interface = deviceInfo3-
27 >startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::
28 InterfaceT>();
29  if (interface == nullptr) return 
30 DEAD_OBJECT;
31  //camera
32  //status,ret
33  ret = interface->open(callback, [&status, &session](Status s, const 
34 sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
35  status = s;
36  if (status == Status::OK) 
37 *session = cameraSession;
38  });
39  
40  if (!ret.isOk()) {
41  removeRef(DeviceMode::CAMERA, 
42 id);
43  ALOGE("%s: Transaction error 
44 opening a session for camera device %s: %s", __FUNCTION__, id.c_str(), ret.
45 description().c_str());
46  return DEAD_OBJECT;}
47  //camerastatus
48  return mapToStatusT(status);
49 }
50 //
51 status_t CameraProviderManager::openSession(const std::string &id, const 
52 sp<device::V1_0::ICameraDeviceCallback>& callback, sp<device::V1_0::
53 ICameraDevice> *session) {
54  std::lock_guard<std::mutex> lock(mInterfaceMutex);
55  auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {1,0}, 
56 /*maxVersion*/ {2,0});
57  if (deviceInfo == nullptr) 
58 return NAME_NOT_FOUND;
59  auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>
60 (deviceInfo);
61  sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.
62 promote();
63  if (parentProvider == nullptr) 
64 return DEAD_OBJECT;
65  
66  const sp<provider::V2_4::ICameraProvider> provider = parentProvider-
67 >startProviderInterface();
68  if (provider == nullptr) 
69 return DEAD_OBJECT;
70  saveRef(DeviceMode::CAMERA, id, provider);
71  auto interface = deviceInfo1-
72 >startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo1::
73 InterfaceT>();
74  if (interface == nullptr) 
75 return DEAD_OBJECT;
76  //
77  hardware::Return<Status> status = interface->open(callback);
78  if (!status.isOk()) {
79  removeRef(DeviceMode::CAMERA, 
80 id);
81  ALOGE("%s: Transaction error 
82 opening a session for camera device %s: %s", __FUNCTION__, id.c_str(), 
83 status.description().c_str());
84  return DEAD_OBJECT;
85  }
86  if (status == Status::OK) 
87 *session = interface;
88  return mapToStatusT(status);
89 }
CameraProviderManager.cpp/CameraProviderManager::openSession
1 //CameraHal3entry.cpp
2 int open(const struct hw_module_t* pHwModuleAPI, const char* pCameraIdAPI, 
3 struct hw_device_t** ppHwDeviceAPI){
4  JumpTableHAL3* pHAL3 = static_cast<JumpTableHAL3*>(g_dispatchHAL3.
5 GetJumpTable());
6  CAMX_ASSERT(pHAL3);
7  CAMX_ASSERT(pHAL3->open);
8  return pHAL3->open(pHwModuleAPI, pCameraIdAPI, ppHwDeviceAPI);
9 }
CameraHal3entry.cpp/open
  1 //camxhal3.cpp
  2 static int open(const struct hw_module_t* pHwModuleAPI, const char* 
  3 pCameraIdAPI, struct hw_device_t** ppHwDeviceAPI){
  4  CAMX_ENTRYEXIT_SCOPE(CamxLogGroupHAL, SCOPEEventHAL3Open);
  5  CamxResult result = CamxResultSuccess;
  6  CAMX_ASSERT(NULL != pHwModuleAPI);
  7  CAMX_ASSERT(NULL != pHwModuleAPI->id);
  8  CAMX_ASSERT(NULL != pHwModuleAPI->name);
  9  CAMX_ASSERT(NULL != pHwModuleAPI->author);
 10  CAMX_ASSERT(NULL != pHwModuleAPI->methods);
 11  CAMX_ASSERT('\0' != pCameraIdAPI[0]);
 12  CAMX_ASSERT(NULL != pCameraIdAPI);
 13  CAMX_ASSERT(NULL != ppHwDeviceAPI);
 14  if ((NULL != pHwModuleAPI) && NULL != pHwModuleAPI->id) && NULL != 
 15 pHwModuleAPI->name) && NULL != pHwModuleAPI->author) && NULL != 
 16 pHwModuleAPI->methods) && ULL != pCameraIdAPI) && '\0' != pCameraIdAPI[0]) 
 17 && NULL != ppHwDeviceAPI)){
 18  
 19  CamX::OfflineLogger* pOfflineLoggerASCII = CamX::OfflineLogger::
 20 GetInstance(OfflineLoggerType::ASCII);
 21  if (NULL != pOfflineLoggerASCII) pOfflineLoggerASCII-
 22 >NotifyCameraOpen();
 23  CamX::OfflineLogger* pOfflineLoggerBinary = CamX::OfflineLogger::
 24 GetInstance(OfflineLoggerType::BINARY);
 25  if (NULL != pOfflineLoggerBinary) pOfflineLoggerBinary-
 26 >NotifyCameraOpen();
 27  UINT32 cameraId = 0;
 28  UINT32 logicalCameraId = 0;
 29  CHAR* pNameEnd = NULL;
 30  //cameraId
 31  cameraId = OsUtils::StrToUL(pCameraIdAPI, &pNameEnd, 10);
 32  if (*pNameEnd != '\0'){
 33  CAMX_LOG_ERROR(CamxLogGroupHAL, "Invalid camera id: %s", 
 34 pCameraIdAPI);
 35  result = CamxResultEInvalidArg;
 36  }
 37  if (CamxResultSuccess == result){
 38  // frameworkId 
 39  logicalCameraId = GetCHIAppCallbacks()->chi_remap_camera_id
 40 (cameraId, IdRemapCamera);
 41  //camera
 42  HAL3Module::GetInstance()->ReserveTorchForCamera
 43 (GetCHIAppCallbacks()->chi_remap_camera_id(cameraId, IdRemapTorch), 
 44 cameraId);
 45  // Sample code to show how the VOID* can be used in ExtendOpen
 46  CHIEXTENDSETTINGS extend = { 0 };
 47  CHISETTINGTOKEN tokenList[NumExtendSettings] = { { 0 } };
 48  extend.pTokens = tokenList;
 49  //
 50  GenerateExtendOpenData(NumExtendSettings, &extend);
 51  //cameraIdlog
 52  AMX_LOG_CONFIG(CamxLogGroupHAL, "HalOp: Begin OPEN, 
 53 logicalCameraId: %d, cameraId: %d", logicalCameraId, cameraId);
 54  
 55  //camera
 56  result = HAL3Module::GetInstance()->ProcessCameraOpen
 57 (logicalCameraId, &extend);
 58  }
 59  //
 60  if (CamxResultSuccess == result){
 61  
 62  ChiModifySettings setting[NumExtendSettings] = { { { 0 } } };
 63  GenerateModifySettingsData(setting);
 64  for (UINT i = 0; i < NumExtendSettings; i++) 
 65 GetCHIAppCallbacks()->chi_modify_settings(&setting[i]);
 66  //
 67  const StaticSettings* pStaticSettings = HwEnvironment::
 68 GetInstance()->GetStaticSettings();
 69  //log
 70  CAMX_LOG_INFO(CamxLogGroupHAL, "Open: overrideCameraClose is %
 71 d , overrideCameraOpen is %d ", StaticSettings->overrideCameraClose, 
 72 pStaticSettings->overrideCameraOpen);
 73  //HwModule*
 74  const HwModule* pHwModule = reinterpret_cast<const HwModule*>
 75 (pHwModuleAPI);
 76  //ididcamera
 77  HALDevice* pHALDevice = HALDevice::Create(pHwModule, 
 78 logicalCameraId, cameraId);
 79  if (NULL != pHALDevice){
 80  //camera3_device_t*
 81  camera3_device_t* pCamera3Device = 
 82 reinterpret_cast<camera3_device_t*>(pHALDevice->GetCameraDevice());
 83  camera3_device_t& rCamera3Device = *pCamera3Device;
 84  *ppHwDeviceAPI = &pCamera3Device->common;
 85  BINARY_LOG(LogEvent::HAL3_Open, rCamera3Device, 
 86 logicalCameraId, cameraId);
 87  }
 88  else{
 89  // HAL interface requires -ENODEV (EFailed) for all other 
 90 internal errors
 91  result = CamxResultEFailed;
 92  CAMX_LOG_ERROR(CamxLogGroupHAL, "Error while opening 
 93 camera");
 94  CHIEXTENDSETTINGS extend = { 0 };
 95  CHISETTINGTOKEN tokenList[NumExtendSettings] = { { 0 } };
 96  extend.pTokens = tokenList;
 97  GenerateExtendCloseData(NumExtendSettings, &extend);
 98  // Allow the camera to be reopened later
 99  HAL3Module::GetInstance()->ProcessCameraClose
100 (logicalCameraId, &extend);
101  ChiModifySettings setting[NumExtendSettings] = { { { 0 } } 
102 };
103  GenerateModifySettingsData(setting);
104  for (UINT i = 0; i < NumExtendSettings; i++) 
105 GetCHIAppCallbacks()->chi_modify_settings(&setting[i]);
106  }
107  }
108  //
109  if (CamxResultSuccess != result) cameraidHAL3Module::
110 GetInstance()->ReleaseTorchForCamera(GetCHIAppCallbacks()-
111 >chi_remap_camera_id(cameraId, IdRemapTorch), cameraId);
112  //log
113  CAMX_LOG_CONFIG(CamxLogGroupHAL, "HalOp: End OPEN, 
114 logicalCameraId: %d, cameraId: %d", logicalCameraId, cameraId);
115  }
116  else{
117  CAMX_LOG_ERROR(CamxLogGroupHAL, "Invalid argument(s) for open()");
118  // HAL interface requires -EINVAL (EInvalidArg) for invalid 
119 arguments
120  result = CamxResultEInvalidArg;
121  }
122  return Utils::CamxResultToErrno(result);
123 }
camxhal3.cpp/open
 1 //camxhal3module.cpp
 2 CamxResult HAL3Module::ProcessCameraOpen(UINT32 logicalCameraId, VOID* 
 3 pPriv){
 4  CamxResult result = CamxResultSuccess;
 5  //logicalCameraId
 6  if (logicalCameraId >= m_numLogicalCameras){
 7  CAMX_LOG_ERROR(CamxLogGroupHAL, "Invalid logical camera id: %d", 
 8 logicalCameraId);
 9  result = CamxResultEInvalidArg;
10  }
11  //cameraId
12  else if (TRUE == m_perCameraInfo[logicalCameraId].isCameraOpened){
13  CAMX_LOG_ERROR(CamxLogGroupHAL, "Camera id already in use: %d", 
14 logicalCameraId);
15  result = CamxResultEBusy;
16  }
17  //cameraId
18  else if ((m_numCamerasOpened + 1) > MaxConcurrentDevices){
19  CAMX_LOG_ERROR(CamxLogGroupHAL, "Too many concurrent devices to 
20 open camera id: %d", logicalCameraId);
21  result = CamxResultETooManyUsers;
22  }
23  //camera
24  else{
25  result = m_ChiAppCallbacks.chi_extend_open(logicalCameraId, pPriv);
26  if (CamxResultSuccess == result){
27  m_perCameraInfo[logicalCameraId].isCameraOpened = TRUE;
28  m_numCamerasOpened++;
29  CAMX_LOG_CONFIG(CamxLogGroupHAL, "number of Camera Opened %d", 
30 m_numCamerasOpened);
31  }
32  else CAMX_LOG_ERROR(CamxLogGroupHAL, "Camera Open failed with 
33 error status = %s", Utils::CamxResultToString(result));
34  }
35  // cameracameraTRUE
36  if (1 == m_numCamerasOpened) DisplayConfigInterface::SetCameraStatus
37 (TRUE);
38  return result;
39 }
camxhal3module.cpp/HAL3Module::ProcessCameraOpen
 1 //vendor/qcom/proprietary/camx/src/mapperutils/formatmapper
 2 /camxdisplayconfig.cpp
 3 CamxResult DisplayConfig::SetCameraStatus(UINT32 status){
 4  CamxResult result = CamxResultSuccess;
 5  Return<int32_t> ret = mDisplayConfig->setCameraLaunchStatus(status);
 6  if (false == ret.isOk()){
 7  CAMX_LOG_ERROR(CamxLogGroupFormat, "DisplayConfig Unable to send 
 8 response. Exception : %s", ret.description().c_str());
 9  mDisplayConfig.clear();
10  mDisplayConfig = NULL;
11  result = CamxResultEFailed;
12  }
13  else if (0 == ret){
14  CAMX_LOG_INFO(CamxLogGroupFormat, "setCameraLaunchStatus returned 
15 success, camera status %d", status);
16  }
17  else{
18  CAMX_LOG_ERROR(CamxLogGroupFormat, "setCameraLaunchStatus returned 
19 failure, camera status %d", status);
20  }
21  return result;
22 }
camxdisplayconfig.cpp/DisplayConfig::SetCameraStatus
1 //vendor/qcom/proprietary/chi-cdk/core/chiframework/chxextensioninterface.
2 cpp
3 static uint32_t chi_remap_camera_id(
4  uint32_t frameworkCameraId,
5  CameraIdRemapMode mode)
6 {
7  ExtensionModule* pExtensionModule = ExtensionModule::GetInstance();
8  return pExtensionModule->RemapCameraId(frameworkCameraId, mode);
9 }
chxextensioninterface.cpp/chi_remap_camera_id
1 //vendor/qcom/proprietary/chi-cdk/core/chiframework/chxextensioninterface.
2 cpp
3 static CDKResult chi_extend_open(uint32_t cameraId, void* priv){
4  ExtensionModule* pExtensionModule = ExtensionModule::GetInstance();
5  return pExtensionModule->ExtendOpen(cameraId, priv);
6 }
chxextensioninterface.cpp/chi_extend_open
  1 //vendor/qcom/proprietary/chi-cdk/core/chiframework/chxextensionmodule.cpp
  2 CDKResult ExtensionModule::ExtendOpen(
  3  uint32_t logicalCameraId,
  4  VOID* pPriv)
  5 {
  6  // The ExtensionModule has been initialized, and if there is any work 
  7 needed to be done during HAL open, this is where
  8  // to add that code
  9  // sample code...this uses the input to create a data structure used 
 10 to hold configuration settings
 11  ChiOverrideExtendSettings* pExtend = 
 12 static_cast<ChiOverrideExtendSettings*>(pPriv);
 13  CDKResult result = CDKResultSuccess;
 14  m_currentLogicalCameraId = logicalCameraId;
 15  if ((NULL == m_pConfigSettings) || (pExtend->numTokens > 
 16 MaxConfigSettings))
 17  {
 18  CHX_LOG_ERROR("ExtendOpen failed! m_pConfigSettings=%p, numTokens=%
 19 d MaxConfigSettings=%d",
 20  m_pConfigSettings, pExtend->numTokens, 
 21 MaxConfigSettings);
 22  result = CDKResultEInvalidArg;
 23  }
 24  if (CDKResultSuccess == result)
 25  {
 26  m_pResourcesUsedLock->Lock();
 27  if (!m_logicalCameraRCVBypassSet.empty())
 28  {
 29  CHX_LOG_INFO("[CHI_RC_DEBUG] Bypass resourceCost for logical 
 30 cameraId %u", logicalCameraId);
 31  }
 32  else
 33  {
 34  UINT32 activeResourceCost = GetActiveResourceCost();
 35  if ((m_logicalCameraInfo[logicalCameraId].maxResourceCost + 
 36 activeResourceCost) > m_totalResourceBudget)
 37  {
 38  CHX_LOG_ERROR("ExtendOpen failed! for cameraId %d HW 
 39 resource insufficient! maxresourceCost=%d"
 40  "activeResourseCost =%d, m_totalResourceBudget = %d", 
 41 logicalCameraId,
 42  m_logicalCameraInfo[logicalCameraId].maxResourceCost,
 43  activeResourceCost, m_totalResourceBudget);
 44  result = CamxResultETooManyUsers; // over capacity
 45  }
 46  }
 47  m_pResourcesUsedLock->Unlock();
 48  }
 49  if (CDKResultSuccess == result)
 50  {
 51  if (NULL == m_pPerfLockManager[logicalCameraId])
 52  {
 53  m_pPerfLockManager[logicalCameraId] = PerfLockManager::
 54 Create();
 55  if (NULL == m_pPerfLockManager[logicalCameraId])
 56  {
 57  CHX_LOG_ERROR("Failed to create perflock manager %d", 
 58 logicalCameraId);
 59  }
 60  }
 61  if (NULL != m_pPerfLockManager[logicalCameraId])
 62  {
 63  m_pPerfLockManager[logicalCameraId]->AcquirePerfLock
 64 (PERF_LOCK_OPEN_CAMERA, 1000);
 65  }
 66  MappingConfigSettings(pExtend->numTokens, static_cast<VOID*>
 67 (pExtend->pTokens));
 68  // Update camera open and close status in static settings
 69  for (UINT8 index = 0; index < m_logicalCameraInfo[logicalCameraId].
 70 numPhysicalCameras; index++)
 71  {
 72  UINT32 cameraId = m_logicalCameraInfo[logicalCameraId].
 73 ppDeviceInfo[index]->cameraId;
 74  *m_pOverrideCameraOpen |= (1 << cameraId);
 75  *m_pOverrideCameraClose &= ~(1 << cameraId);
 76  }
 77  if(CDKResultSuccess == result)
 78  {
 79  if ((EnableBLMClient()) && (NULL == m_pBLMClient))
 80  {
 81  m_pBLMClient = CHXBLMClient::Create();
 82  if (m_pBLMClient != NULL)
 83  {
 84  CHX_LOG_INFO("BLM Client Created");
 85  }
 86  else
 87  {
 88  CHX_LOG_ERROR("BLM Client creation failed");
 89  }
 90  }
 91  }
 92  m_pResourcesUsedLock->Lock();
 93  m_IFEResourceCost[logicalCameraId] = m_logicalCameraInfo
 94 [logicalCameraId].maxResourceCost;
 95  m_pResourcesUsedLock->Unlock();
 96  CHX_LOG_INFO("Open Logical cameraId: %d numPhysicalCameras: %d"
 97  "CameraOpen Mask = 0x%x CameraClose Mask 0x%x 
 98 maxresourceCost %d",
 99  logicalCameraId, m_logicalCameraInfo[logicalCameraId].
100 numPhysicalCameras,
101  *m_pOverrideCameraOpen, *m_pOverrideCameraClose,
102  m_logicalCameraInfo[logicalCameraId].maxResourceCost);
103  }
104  return result;
105 }
chxextensionmodule.cpp/ExtensionModule::ExtendOpen
 1 //vendor/qcom/proprietary/camx/src/core/hal/camxhaldevice.cpp
 2 HALDevice* HALDevice::Create(const HwModule* pHwModule, UINT32 cameraId, 
 3 UINT32 frameworkId)
 4 {
 5  CamxResult result = CamxResultENoMemory;
 6  HALDevice* pHALDevice = CAMX_NEW HALDevice;
 7  ATRACE_BEGIN("HALDevice::Create");
 8  if (NULL != pHALDevice)
 9  {
10  pHALDevice->m_fwId = frameworkId;
11  result = pHALDevice->Initialize(pHwModule, cameraId);
12  if (CamxResultSuccess != result)
13  {
14  pHALDevice->Destroy();
15  pHALDevice = NULL;
16  }
17  }
18  ATRACE_END();
19  return pHALDevice;
20 }
camxhaldevice.cpp/HALDevice::Create
 1 //vendor/qcom/proprietary/camx/src/core/hal/camxhaldevice.cpp
 2 CamxResult HALDevice::Initialize(const HwModule* pHwModule, 
 3 UINT32 cameraId)
 4 {
 5  CamxResult result = CamxResultSuccess;
 6  CSLCameraPlatform CSLPlatform = {};
 7  m_cameraId = cameraId;
 8  ATRACE_BEGIN("HALDevice::Initialize");
 9  // Find Device Type
10  result = CSLQueryCameraPlatform(&CSLPlatform);
11  // Enable static lib load only for all versions of Kamorta
12  if ((CameraTitanSocKamorta == CSLPlatform.socId) ||
13  (CameraTitanSocKamortaP == CSLPlatform.socId) ||
14  (CameraTitanSocKamortaHigh == CSLPlatform.socId) ||
15  (CameraTitanSocKamortaHighP == CSLPlatform.socId) ||
16  (CameraTitanSocKamortaQCM == CSLPlatform.socId) ||
17  (CameraTitanSocKamortaQCS == CSLPlatform.socId) ||
18  (CameraTitanSocAgatti == CSLPlatform.socId) ||
19  (CameraTitanSocAPQAgatti == CSLPlatform.socId) ||
20  (CameraTitanSocAgattiQCM == CSLPlatform.socId) ||
21  (CameraTitanSocAgattiQCS == CSLPlatform.socId))
22  {
23  // Load all static libs
24  LoadStaticlibs();
25  }
26  if (CamxResultSuccess == result)
27  {
28  m_camera3Device.hwDevice.tag = HARDWARE_DEVICE_TAG; /// @todo 
29 (CAMX-351) Get from local macro
30 #if ((CAMX_ANDROID_API) && (CAMX_ANDROID_API >= 28)) // Android-P or better
31  m_camera3Device.hwDevice.version = CAMERA_DEVICE_API_VERSION_3_5;
32 #else
33  m_camera3Device.hwDevice.version = CAMERA_DEVICE_API_VERSION_3_3;
34 #endif // ((CAMX_ANDROID_API) && (CAMX_ANDROID_API >= 28))
35  m_camera3Device.hwDevice.close = reinterpret_cast<CloseFunc>
36 (GetHwDeviceCloseFunc());
37  m_camera3Device.pDeviceOps = 
38 reinterpret_cast<Camera3DeviceOps*>(GetCamera3DeviceOps());
39  m_camera3Device.pPrivateData = this;
40  // NOWHINE CP036a: Need exception here
41  m_camera3Device.hwDevice.pModule = const_cast<HwModule*>
42 (pHwModule);
43  m_HALCallbacks.process_capture_result = ProcessCaptureResult;
44  m_HALCallbacks.notify_result = Notify;
45  }
46  ClearFrameworkRequestBuffer();
47  SIZE_T entryCapacity;
48  SIZE_T dataSize;
49  HAL3MetadataUtil::CalculateSizeAllMeta(&entryCapacity, &dataSize, 
50 TagSectionVisibleToFramework);
51  m_pResultMetadata = HAL3MetadataUtil::CreateMetadata(
52  entryCapacity,
53  dataSize);
54  for (UINT i = RequestTemplatePreview; i < RequestTemplateCount; i++)
55  {
56  if (NULL == m_pDefaultRequestMetadata[i])
57  {
58  ConstructDefaultRequestSettings
59 (static_cast<Camera3RequestTemplate>(i));
60  }
61  }
62  const StaticSettings* pStaticSettings = HwEnvironment::GetInstance()-
63 >GetStaticSettings();
64  m_numPartialResult = pStaticSettings->numMetadataResults;
65  /* We will increment the Partial result count by 1 if CHI also has its 
66 own implementation */
67  if (CHIPartialDataSeparate == pStaticSettings->enableCHIPartialData)
68  {
69  m_numPartialResult++;
70  }
71  m_tracingZoom = FALSE;
72  ATRACE_END();
73  return result;
74 }
camxhaldevice.cpp/HALDevice::Initialize
 1 //vendor/qcom/proprietary/camx/src/csl/camxcsl.cpp
 2 CamxResult CSLQueryCameraPlatform(
 3  CSLCameraPlatform* pCameraPlatform)
 4 {
 5  CAMX_ENTRYEXIT_SCOPE(CamxLogGroupCSL, CamX::
 6 SCOPEEventCSLQueryCameraPlatform);
 7  CAMX_ASSERT_MESSAGE(NULL != g_pCSLModeManager, "CSL not initialized");
 8  CSLJumpTable* pJumpTable = g_pCSLModeManager->GetJumpTable();
 9  return pJumpTable->CSLQueryCameraPlatform(pCameraPlatform);
10 }
camxcsl.cpp/CSLQueryCameraPlatform
  1 //vendor/qcom/proprietary/camx/src/core/hal/camxhaldevice.cpp
  2 VOID HALDevice::ProcessCaptureResult(
  3  const camera3_device_t* pCamera3Device,
  4  const camera3_capture_result_t* pCamera3_CaptureResult)
  5 {
  6  const Camera3CaptureResult* pCamera3CaptureResult = 
  7 reinterpret_cast<const Camera3CaptureResult*>(pCamera3_CaptureResult);
  8  HALDevice* pHALDevice = 
  9 static_cast<HALDevice*>(pCamera3Device->priv);
 10  CamxResult result = CamxResultSuccess;
 11  const StaticSettings* pSettings = HwEnvironment::
 12 GetInstance()->GetStaticSettings();
 13  BOOL updateFramework = TRUE;
 14  // Keep track of information related to request for error conditions
 15  FrameworkRequestData* pFrameworkRequest = pHALDevice-
 16 >GetFrameworkRequestData(
 17  pCamera3CaptureResult->frameworkFrameNum, FALSE);
 18  if (pFrameworkRequest->frameworkNum != pCamera3CaptureResult-
 19 >frameworkFrameNum)
 20  {
 21  updateFramework = FALSE;
 22  CAMX_LOG_WARN(CamxLogGroupCore, "Unexpected frame number: %d, 
 23 Can't send result to FWK"
 24  " Num Output Buffers: %d, num partial metadata: %d, 
 25 ResultMetdata: %p",
 26  pCamera3CaptureResult->frameworkFrameNum,
 27  pCamera3CaptureResult->numOutputBuffers,
 28  pCamera3CaptureResult->numPartialMetadata,
 29  pCamera3CaptureResult->pResultMetadata);
 30  pHALDevice->LogErrorAndAssert(UnexpectedFrameNumber);
 31  }
 32  // if Request error TRUE, do not send metadata or buffer
 33  if ((TRUE == pFrameworkRequest->requestStatus.notifyRequestError) &&
 34  (pFrameworkRequest->numBuffers == pFrameworkRequest-
 35 >numBuffersReceived))
 36  {
 37  updateFramework = FALSE;
 38  CAMX_LOG_WARN(CamxLogGroupCore, "Received metadata or buffer after 
 39 sending ERROR_REQUEST for Frame %u",
 40  pFrameworkRequest->frameworkNum);
 41  pHALDevice->LogRequest(pFrameworkRequest, -1, FALSE, StringFormat);
 42  }
 43  // if Result error TRUE, if result has metadata
 44  if (TRUE == pFrameworkRequest->requestStatus.notifyResultError)
 45  {
 46  if (NULL != pCamera3CaptureResult->pResultMetadata)
 47  {
 48  updateFramework = FALSE;
 49  CAMX_LOG_WARN(CamxLogGroupCore, "Received metadata after 
 50 sending ERROR_RESULT for Frame %u",
 51  pFrameworkRequest->frameworkNum);
 52  pHALDevice->LogRequest(pFrameworkRequest, -1, FALSE, 
 53 StringFormat);
 54  pHALDevice->LogErrorAndAssert(UnexpectedMetadata);
 55  }
 56  }
 57  if ((0 != pCamera3CaptureResult->numOutputBuffers) &&
 58  (pFrameworkRequest->numBuffersReceived == pFrameworkRequest-
 59 >numBuffers))
 60  {
 61  updateFramework = FALSE;
 62  CAMX_LOG_WARN(CamxLogGroupCore, "Receiving unexpected buffer for 
 63 Frame %u", pFrameworkRequest->frameworkNum);
 64  pHALDevice->LogRequest(pFrameworkRequest, -1, FALSE, StringFormat);
 65  pHALDevice->LogErrorAndAssert(UnexpectedOutputBuffer);
 66  }
 67  if (TRUE == updateFramework)
 68  {
 69  if (pCamera3CaptureResult->numOutputBuffers > 0)
 70  {
 71  for (UINT i = 0; i < pCamera3CaptureResult->numOutputBuffers; 
 72 i++)
 73  {
 74  Camera3StreamBuffer* pStreamBuffer =
 75  // NOWHINE CP036a: Google API requires const type
 76  const_cast<Camera3StreamBuffer*>
 77 (&pCamera3CaptureResult->pOutputBuffers[i]);
 78  pStreamBuffer->releaseFence = -1;
 79  CAMX_LOG_INFO(CamxLogGroupHAL,
 80  "Returning framework result Frame: %d, Metadata: %p, 
 81 Stream %p, Fmt: %d Width: %d Height: %d",
 82  pCamera3CaptureResult->frameworkFrameNum,
 83  pCamera3CaptureResult->pResultMetadata,
 84  pCamera3CaptureResult->pOutputBuffers[i].pStream,
 85  pCamera3CaptureResult->pOutputBuffers[i].pStream-
 86 >format,
 87  pCamera3CaptureResult->pOutputBuffers[i].pStream-
 88 >width,
 89  pCamera3CaptureResult->pOutputBuffers[i].pStream-
 90 >height,
 91  pCamera3CaptureResult->pOutputBuffers[i].releaseFence,
 92  pCamera3CaptureResult->pOutputBuffers[i].bufferStatus);
 93  }
 94  }
 95  if (NULL != pCamera3CaptureResult->pResultMetadata)
 96  {
 97  CAMX_LOG_INFO(CamxLogGroupHAL,
 98  "Returning framework result metadata only for frame: %d, 
 99 Metadata: %p",
100  pCamera3CaptureResult->frameworkFrameNum, 
101 pCamera3CaptureResult->pResultMetadata);
102  }
103  pHALDevice->UpdateFrameworkRequestBufferResult
104 (pCamera3CaptureResult, pFrameworkRequest);
105  pHALDevice->GetCallbackOps()->process_capture_result(pHALDevice-
106 >GetCallbackOps(), pCamera3_CaptureResult);
107  }
108 }
camxhaldevice.cpp/HALDevice::ProcessCaptureResult

 

posted @ 2023-03-12 23:53  归江渡鸟泅白浪  阅读(205)  评论(0)    收藏  举报