blob: 4227d28bf03338a6a4bf08eda8ddb39609feac3b [file] [log] [blame]
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "CameraProviderManager"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include "CameraProviderManager.h"
22
Rucha Katakwar38284522021-11-10 11:25:21 -080023#include <android/hardware/camera/device/3.8/ICameraDevice.h>
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070024
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080025#include <algorithm>
Yin-Chia Yeh65405092017-01-13 15:42:28 -080026#include <chrono>
Emilian Peevcbf174b2019-01-25 14:38:59 -080027#include "common/DepthPhotoProcessor.h"
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070028#include "hidl/HidlProviderInfo.h"
Emilian Peevcbf174b2019-01-25 14:38:59 -080029#include <dlfcn.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070030#include <future>
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070031#include <inttypes.h>
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070032#include <android/hidl/manager/1.2/IServiceManager.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080033#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000034#include <functional>
35#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080036#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070037#include <android-base/logging.h>
38#include <cutils/properties.h>
39#include <hwbinder/IPCThreadState.h>
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080040#include <utils/SessionConfigurationUtils.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070041#include <utils/Trace.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080042
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080043#include "api2/HeicCompositeStream.h"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080044#include "device3/ZoomRatioMapper.h"
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080045
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080046namespace android {
47
48using namespace ::android::hardware::camera;
Austin Borgerea931242021-12-13 23:10:41 +000049using namespace ::android::camera3;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070050using android::hardware::camera::common::V1_0::Status;
51using namespace camera3::SessionConfigurationUtils;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070052using std::literals::chrono_literals::operator""s;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080053using hardware::camera2::utils::CameraIdAndSessionConfiguration;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080054
55namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070056const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Valentin Iftime29e2e152021-08-13 15:17:33 +020057const std::string kExternalProviderName = "external/0";
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080058} // anonymous namespace
59
Emilian Peev538c90e2018-12-17 18:03:19 +000060const float CameraProviderManager::kDepthARTolerance = .1f;
61
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070062CameraProviderManager::HidlServiceInteractionProxyImpl
63CameraProviderManager::sHidlServiceInteractionProxy{};
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080064
65CameraProviderManager::~CameraProviderManager() {
66}
67
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070068hardware::hidl_vec<hardware::hidl_string>
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070069CameraProviderManager::HidlServiceInteractionProxyImpl::listServices() {
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070070 hardware::hidl_vec<hardware::hidl_string> ret;
71 auto manager = hardware::defaultServiceManager1_2();
72 if (manager != nullptr) {
73 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
74 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
75 ret = registered;
76 });
77 }
78 return ret;
79}
80
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080081status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070082 HidlServiceInteractionProxy* hidlProxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080083 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070084 if (hidlProxy == nullptr) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080085 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
86 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080087 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080088 mListener = listener;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070089 mHidlServiceProxy = hidlProxy;
90 mDeviceState = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080091
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080092 // Registering will trigger notifications for all already-known providers
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070093 bool success = mHidlServiceProxy->registerForNotifications(
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080094 /* instance name, empty means no filter */ "",
95 this);
96 if (!success) {
97 ALOGE("%s: Unable to register with hardware service manager for notifications "
98 "about camera providers", __FUNCTION__);
99 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -0800100 }
Emilian Peev5d7e5152017-02-22 15:37:48 +0000101
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700102 for (const auto& instance : mHidlServiceProxy->listServices()) {
103 this->addHidlProviderLocked(instance);
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700104 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800105
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700106 IPCThreadState::self()->flushCommands();
107
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800108 return OK;
109}
110
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700111std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800112 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700113 int systemCameraCount = 0;
114 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800115 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700116 for (auto &id : provider->mUniqueCameraIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700117 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
118 if (getSystemCameraKindLocked(id, &deviceKind) != OK) {
119 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.c_str());
120 continue;
121 }
122 switch(deviceKind) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700123 case SystemCameraKind::PUBLIC:
124 publicCameraCount++;
125 break;
126 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
127 systemCameraCount++;
128 break;
129 default:
130 break;
131 }
132 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800133 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700134 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800135}
136
137std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
138 std::lock_guard<std::mutex> lock(mInterfaceMutex);
139 std::vector<std::string> deviceIds;
140 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700141 for (auto& id : provider->mUniqueCameraIds) {
142 deviceIds.push_back(id);
143 }
144 }
145 return deviceIds;
146}
147
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700148void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
149 std::vector<std::string>& publicDeviceIds,
150 std::vector<std::string>& systemDeviceIds) const {
151 for (auto &deviceId : deviceIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700152 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
153 if (getSystemCameraKindLocked(deviceId, &deviceKind) != OK) {
154 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, deviceId.c_str());
155 continue;
156 }
157 if (deviceKind == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700158 systemDeviceIds.push_back(deviceId);
159 } else {
160 publicDeviceIds.push_back(deviceId);
161 }
162 }
163}
164
Emilian Peevf53f66e2017-04-11 14:29:43 +0100165std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700166 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700167 std::vector<std::string> publicDeviceIds;
168 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700169 std::vector<std::string> deviceIds;
170 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700171 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700172 // Secure cameras should not be exposed through camera 1 api
173 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
174 [this](const std::string& s) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700175 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
176 if (getSystemCameraKindLocked(s, &deviceKind) != OK) {
177 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, s.c_str());
178 return true;
179 }
180 return deviceKind == SystemCameraKind::HIDDEN_SECURE_CAMERA;}),
181 providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700182 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700183 // for each camera facing, only take the first id advertised by HAL in
184 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700185 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700186 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800187 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700188 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800189 [](const std::string& a, const std::string& b) -> bool {
190 uint32_t aUint = 0, bUint = 0;
191 bool aIsUint = base::ParseUint(a, &aUint);
192 bool bIsUint = base::ParseUint(b, &bUint);
193
194 // Uint device IDs first
195 if (aIsUint && bIsUint) {
196 return aUint < bUint;
197 } else if (aIsUint) {
198 return true;
199 } else if (bIsUint) {
200 return false;
201 }
202 // Simple string compare if both id are not uint
203 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700204 };
205 // We put device ids for system cameras at the end since they will be pared
206 // off for processes not having system camera permissions.
207 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
208 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
209 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
210 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800211 return deviceIds;
212}
213
214bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
215 std::lock_guard<std::mutex> lock(mInterfaceMutex);
216 return isValidDeviceLocked(id, majorVersion);
217}
218
219bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
220 for (auto& provider : mProviders) {
221 for (auto& deviceInfo : provider->mDevices) {
222 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
223 return true;
224 }
225 }
226 }
227 return false;
228}
229
230bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
231 std::lock_guard<std::mutex> lock(mInterfaceMutex);
232
233 auto deviceInfo = findDeviceInfoLocked(id);
234 if (deviceInfo == nullptr) return false;
235
236 return deviceInfo->hasFlashUnit();
237}
238
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800239bool CameraProviderManager::supportNativeZoomRatio(const std::string &id) const {
240 std::lock_guard<std::mutex> lock(mInterfaceMutex);
241
242 auto deviceInfo = findDeviceInfoLocked(id);
243 if (deviceInfo == nullptr) return false;
244
245 return deviceInfo->supportNativeZoomRatio();
246}
247
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800248status_t CameraProviderManager::getResourceCost(const std::string &id,
249 CameraResourceCost* cost) const {
250 std::lock_guard<std::mutex> lock(mInterfaceMutex);
251
252 auto deviceInfo = findDeviceInfoLocked(id);
253 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
254
255 *cost = deviceInfo->mResourceCost;
256 return OK;
257}
258
259status_t CameraProviderManager::getCameraInfo(const std::string &id,
260 hardware::CameraInfo* info) const {
261 std::lock_guard<std::mutex> lock(mInterfaceMutex);
262
263 auto deviceInfo = findDeviceInfoLocked(id);
264 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
265
266 return deviceInfo->getCameraInfo(info);
267}
268
Emilian Peev35ae8262018-11-08 13:11:32 +0000269status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700270 const SessionConfiguration &configuration, bool overrideForPerfClass,
Emilian Peev35ae8262018-11-08 13:11:32 +0000271 bool *status /*out*/) const {
272 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Emilian Peev35ae8262018-11-08 13:11:32 +0000273 auto deviceInfo = findDeviceInfoLocked(id);
274 if (deviceInfo == nullptr) {
275 return NAME_NOT_FOUND;
276 }
277
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700278 return deviceInfo->isSessionConfigurationSupported(configuration, overrideForPerfClass, status);
Emilian Peev35ae8262018-11-08 13:11:32 +0000279}
280
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800281status_t CameraProviderManager::getCameraIdIPCTransport(const std::string &id,
282 IPCTransport *providerTransport) const {
283 std::lock_guard<std::mutex> lock(mInterfaceMutex);
284 auto deviceInfo = findDeviceInfoLocked(id);
285 if (deviceInfo == nullptr) {
286 return NAME_NOT_FOUND;
287 }
288 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
289 if (parentProvider == nullptr) {
290 return DEAD_OBJECT;
291 }
292 *providerTransport = parentProvider->getIPCTransport();
293 return OK;
294}
295
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800296status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700297 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800298 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700299 return getCameraCharacteristicsLocked(id, overrideForPerfClass, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800300}
301
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700302// Till hidl is removed from the android source tree, we use this for aidl as
303// well. We artificially give aidl camera device version 1 a major version 3 and minor
304// version 8.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800305status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
306 hardware::hidl_version *v) {
307 std::lock_guard<std::mutex> lock(mInterfaceMutex);
308
309 hardware::hidl_version maxVersion{0,0};
310 bool found = false;
311 for (auto& provider : mProviders) {
312 for (auto& deviceInfo : provider->mDevices) {
313 if (deviceInfo->mId == id) {
314 if (deviceInfo->mVersion > maxVersion) {
315 maxVersion = deviceInfo->mVersion;
316 found = true;
317 }
318 }
319 }
320 }
321 if (!found) {
322 return NAME_NOT_FOUND;
323 }
324 *v = maxVersion;
325 return OK;
326}
327
Rucha Katakwar38284522021-11-10 11:25:21 -0800328status_t CameraProviderManager::getTorchStrengthLevel(const std::string &id,
329 int32_t* torchStrength /*out*/) {
330 std::lock_guard<std::mutex> lock(mInterfaceMutex);
331
332 auto deviceInfo = findDeviceInfoLocked(id);
333 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
334
335 return deviceInfo->getTorchStrengthLevel(torchStrength);
336}
337
338status_t CameraProviderManager::turnOnTorchWithStrengthLevel(const std::string &id,
339 int32_t torchStrength) {
340 std::lock_guard<std::mutex> lock(mInterfaceMutex);
341
342 auto deviceInfo = findDeviceInfoLocked(id);
343 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
344
345 return deviceInfo->turnOnTorchWithStrengthLevel(torchStrength);
346}
347
348bool CameraProviderManager::shouldSkipTorchStrengthUpdate(const std::string &id,
349 int32_t torchStrength) const {
350 std::lock_guard<std::mutex> lock(mInterfaceMutex);
351
352 auto deviceInfo = findDeviceInfoLocked(id);
353 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
354
355 if (deviceInfo->mTorchStrengthLevel == torchStrength) {
356 ALOGV("%s: Skipping torch strength level updates prev_level: %d, new_level: %d",
357 __FUNCTION__, deviceInfo->mTorchStrengthLevel, torchStrength);
358 return true;
359 }
360 return false;
361}
362
363int32_t CameraProviderManager::getTorchDefaultStrengthLevel(const std::string &id) const {
364 std::lock_guard<std::mutex> lock(mInterfaceMutex);
365
366 auto deviceInfo = findDeviceInfoLocked(id);
367 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
368
369 return deviceInfo->mTorchDefaultStrengthLevel;
370}
371
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700372bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700373 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700374 for (auto& provider : mProviders) {
375 auto deviceInfo = findDeviceInfoLocked(id);
376 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700377 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700378 }
379 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700380 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700381}
382
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800383status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
384 std::lock_guard<std::mutex> lock(mInterfaceMutex);
385
386 auto deviceInfo = findDeviceInfoLocked(id);
387 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
388
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700389 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
390 // that are currently in use.
Shuzhen Wang79680432020-03-05 11:53:46 -0800391 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
392 if (parentProvider == nullptr) {
393 return DEAD_OBJECT;
394 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700395 std::shared_ptr<HalCameraProvider> halCameraProvider = nullptr;
396 IPCTransport providerTransport = parentProvider->getIPCTransport();
397 if (providerTransport == IPCTransport::HIDL) {
398 HidlProviderInfo * hidlProviderInfo = static_cast<HidlProviderInfo *>(parentProvider.get());
399 const sp<provider::V2_4::ICameraProvider> hidlInterface =
400 hidlProviderInfo->startProviderInterface();
401 if (hidlInterface == nullptr) {
402 return DEAD_OBJECT;
403 }
404 halCameraProvider =
405 std::make_shared<HidlHalCameraProvider>(hidlInterface, hidlInterface->descriptor);
406 } else if (providerTransport == IPCTransport::AIDL) {
407 ALOGE("%s AIDL hal providers not supported yet", __FUNCTION__);
408 return INVALID_OPERATION;
409 } else {
410 ALOGE("%s Invalid provider transport", __FUNCTION__);
411 return INVALID_OPERATION;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700412 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700413 saveRef(DeviceMode::TORCH, deviceInfo->mId, halCameraProvider);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700414
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800415 return deviceInfo->setTorchMode(enabled);
416}
417
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800418status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000419 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
420
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800421 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800422 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800423 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000424
425 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
426
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800427 return OK;
428}
429
Valentin Iftime29e2e152021-08-13 15:17:33 +0200430sp<CameraProviderManager::ProviderInfo> CameraProviderManager::startExternalLazyProvider() const {
431 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
432 std::lock_guard<std::mutex> lock(mInterfaceMutex);
433
434 for (const auto& providerInfo : mProviders) {
435 if (providerInfo->isExternalLazyHAL()) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700436 if (!providerInfo->successfullyStartedProviderInterface()) {
Valentin Iftime29e2e152021-08-13 15:17:33 +0200437 return nullptr;
438 } else {
439 return providerInfo;
440 }
441 }
442 }
443 return nullptr;
444}
445
446status_t CameraProviderManager::notifyUsbDeviceEvent(int32_t eventId,
447 const std::string& usbDeviceId) {
448 if (!kEnableLazyHal) {
449 return OK;
450 }
451
452 ALOGV("notifySystemEvent: %d usbDeviceId : %s", eventId, usbDeviceId.c_str());
453
454 if (eventId == android::hardware::ICameraService::EVENT_USB_DEVICE_ATTACHED) {
455 sp<ProviderInfo> externalProvider = startExternalLazyProvider();
456 if (externalProvider != nullptr) {
457 auto usbDevices = mExternalUsbDevicesForProvider.first;
458 usbDevices.push_back(usbDeviceId);
459 mExternalUsbDevicesForProvider = {usbDevices, externalProvider};
460 }
461 } else if (eventId
462 == android::hardware::ICameraService::EVENT_USB_DEVICE_DETACHED) {
463 usbDeviceDetached(usbDeviceId);
464 }
465
466 return OK;
467}
468
469status_t CameraProviderManager::usbDeviceDetached(const std::string &usbDeviceId) {
470 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
471 std::lock_guard<std::mutex> interfaceLock(mInterfaceMutex);
472
473 auto usbDevices = mExternalUsbDevicesForProvider.first;
474 auto foundId = std::find(usbDevices.begin(), usbDevices.end(), usbDeviceId);
475 if (foundId != usbDevices.end()) {
476 sp<ProviderInfo> providerInfo = mExternalUsbDevicesForProvider.second;
477 if (providerInfo == nullptr) {
478 ALOGE("%s No valid external provider for USB device: %s",
479 __FUNCTION__,
480 usbDeviceId.c_str());
481 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
482 return DEAD_OBJECT;
483 } else {
484 mInterfaceMutex.unlock();
485 providerInfo->removeAllDevices();
486 mInterfaceMutex.lock();
487 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
488 }
489 } else {
490 return DEAD_OBJECT;
491 }
492 return OK;
493}
494
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700495status_t CameraProviderManager::notifyDeviceStateChange(int64_t newState) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800496 std::lock_guard<std::mutex> lock(mInterfaceMutex);
497 mDeviceState = newState;
498 status_t res = OK;
499 for (auto& provider : mProviders) {
500 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
501 __FUNCTION__, provider->mProviderName.c_str(), newState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700502 // b/199240726 Camera providers can for example try to add/remove
503 // camera devices as part of the state change notification. Holding
504 // 'mInterfaceMutex' while calling 'notifyDeviceStateChange' can
505 // result in a recursive deadlock.
506 mInterfaceMutex.unlock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800507 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700508 mInterfaceMutex.lock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800509 if (singleRes != OK) {
510 ALOGE("%s: Unable to notify provider %s about device state change",
511 __FUNCTION__,
512 provider->mProviderName.c_str());
513 res = singleRes;
514 // continue to do the rest of the providers instead of returning now
515 }
Emilian Peevb50402e2021-09-24 17:41:57 -0700516 provider->notifyDeviceInfoStateChangeLocked(mDeviceState);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800517 }
518 return res;
519}
520
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700521status_t CameraProviderManager::openHidlSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800522 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800523 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800524 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800525
526 std::lock_guard<std::mutex> lock(mInterfaceMutex);
527
528 auto deviceInfo = findDeviceInfoLocked(id,
529 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
530 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
531
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700532 auto *hidlDeviceInfo3 = static_cast<HidlProviderInfo::HidlDeviceInfo3*>(deviceInfo);
Shuzhen Wang79680432020-03-05 11:53:46 -0800533 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
534 if (parentProvider == nullptr) {
535 return DEAD_OBJECT;
536 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700537 const sp<provider::V2_4::ICameraProvider> provider =
538 static_cast<HidlProviderInfo *>(parentProvider.get())->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700539 if (provider == nullptr) {
540 return DEAD_OBJECT;
541 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700542 std::shared_ptr<HalCameraProvider> halCameraProvider =
543 std::make_shared<HidlHalCameraProvider>(provider, provider->descriptor);
544 saveRef(DeviceMode::CAMERA, id, halCameraProvider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800545
546 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700547 hardware::Return<void> ret;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700548 auto interface = hidlDeviceInfo3->startDeviceInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700549 if (interface == nullptr) {
550 return DEAD_OBJECT;
551 }
552
553 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800554 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
555 status = s;
556 if (status == Status::OK) {
557 *session = cameraSession;
558 }
559 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700560 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700561 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700562 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
563 __FUNCTION__, id.c_str(), ret.description().c_str());
564 return DEAD_OBJECT;
565 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700566 return HidlProviderInfo::mapToStatusT(status);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800567}
568
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700569void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700570 std::shared_ptr<HalCameraProvider> provider) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700571 if (!kEnableLazyHal) {
572 return;
573 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700574 ALOGV("Saving camera provider %s for camera device %s", provider->mDescriptor.c_str(),
575 cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700576 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700577 std::unordered_map<std::string, std::shared_ptr<HalCameraProvider>> *primaryMap, *alternateMap;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700578 if (usageType == DeviceMode::TORCH) {
579 primaryMap = &mTorchProviderByCameraId;
580 alternateMap = &mCameraProviderByCameraId;
581 } else {
582 primaryMap = &mCameraProviderByCameraId;
583 alternateMap = &mTorchProviderByCameraId;
584 }
585 auto id = cameraId.c_str();
586 (*primaryMap)[id] = provider;
587 auto search = alternateMap->find(id);
588 if (search != alternateMap->end()) {
589 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
590 "That should not be possible", __FUNCTION__, id);
591 }
592 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
593}
594
595void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
596 if (!kEnableLazyHal) {
597 return;
598 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800599 ALOGV("Removing camera device %s", cameraId.c_str());
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700600 std::unordered_map<std::string, std::shared_ptr<HalCameraProvider>> *providerMap;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700601 if (usageType == DeviceMode::TORCH) {
602 providerMap = &mTorchProviderByCameraId;
603 } else {
604 providerMap = &mCameraProviderByCameraId;
605 }
606 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
607 auto search = providerMap->find(cameraId.c_str());
608 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800609 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
610 // added delay) because hwservicemanager guarantees to hold the reference for at least five
611 // more seconds. We depend on this behavior so that if the provider is unreferenced and
612 // then referenced again quickly, we do not let the HAL exit and then need to immediately
613 // restart it. An example when this could happen is switching from a front-facing to a
614 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
615 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700616 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800617 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700618 } else {
619 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
620 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
621 cameraId.c_str());
622 }
623}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800624
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800625hardware::Return<void> CameraProviderManager::onRegistration(
626 const hardware::hidl_string& /*fqName*/,
627 const hardware::hidl_string& name,
Emilian Peevc93cac22020-08-17 16:00:10 -0700628 bool preexisting) {
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700629 status_t res = OK;
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700630 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100631 {
632 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800633
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700634 res = addHidlProviderLocked(name, preexisting);
Emilian Peevaee727d2017-05-04 16:35:48 +0100635 }
636
637 sp<StatusListener> listener = getStatusListener();
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700638 if (nullptr != listener.get() && res == OK) {
Emilian Peevaee727d2017-05-04 16:35:48 +0100639 listener->onNewProviderRegistered();
640 }
641
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700642 IPCThreadState::self()->flushCommands();
643
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800644 return hardware::Return<void>();
645}
646
647status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
648 std::lock_guard<std::mutex> lock(mInterfaceMutex);
649
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800650 for (auto& provider : mProviders) {
651 provider->dump(fd, args);
652 }
653 return OK;
654}
655
656CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800657 const std::string& id,
658 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800659 for (auto& provider : mProviders) {
660 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800661 if (deviceInfo->mId == id &&
662 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800663 return deviceInfo.get();
664 }
665 }
666 }
667 return nullptr;
668}
669
Emilian Peev71c73a22017-03-21 16:35:51 +0000670metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
671 const std::string& id, hardware::hidl_version minVersion,
672 hardware::hidl_version maxVersion) const {
673 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
674
675 std::lock_guard<std::mutex> lock(mInterfaceMutex);
676 for (auto& provider : mProviders) {
677 for (auto& deviceInfo : provider->mDevices) {
678 if (deviceInfo->mId == id &&
679 minVersion <= deviceInfo->mVersion &&
680 maxVersion >= deviceInfo->mVersion) {
681 return provider->mProviderTagid;
682 }
683 }
684 }
685
686 return ret;
687}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800688
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700689void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
690 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700691
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700692 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700693 for (size_t i = 0; i < entryCap.count; ++i) {
694 uint8_t capability = entryCap.data.u8[i];
695 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700696 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700697 break;
698 }
699 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700700 if (!mIsLogicalCamera) {
701 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700702 }
703
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700704 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
705 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700706 const uint8_t* ids = entryIds.data.u8;
707 size_t start = 0;
708 for (size_t i = 0; i < entryIds.count; ++i) {
709 if (ids[i] == '\0') {
710 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700711 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700712 }
713 start = i+1;
714 }
715 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700716}
717
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700718SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800719 camera_metadata_entry_t entryCap;
720 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700721 if (entryCap.count == 1 &&
722 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
723 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800724 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700725
726 // Go through the capabilities and check if it has
727 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
728 for (size_t i = 0; i < entryCap.count; ++i) {
729 uint8_t capability = entryCap.data.u8[i];
730 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
731 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
732 }
733 }
734 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800735}
736
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000737void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
738 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
739 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
740 if (sizes == nullptr) {
741 return;
742 }
743
744 auto scalerDims = ch.find(tag);
745 if (scalerDims.count > 0) {
746 // Scaler entry contains 4 elements (format, width, height, type)
747 for (size_t i = 0; i < scalerDims.count; i += 4) {
748 if ((scalerDims.data.i32[i] == format) &&
749 (scalerDims.data.i32[i+3] ==
750 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
751 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
752 scalerDims.data.i32[i+2]));
753 }
754 }
755 }
756}
757
758void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
759 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
760 const std::vector<std::tuple<size_t, size_t>>& sizes,
761 std::vector<int64_t> *durations/*out*/) {
762 if (durations == nullptr) {
763 return;
764 }
765
766 auto availableDurations = ch.find(tag);
767 if (availableDurations.count > 0) {
768 // Duration entry contains 4 elements (format, width, height, duration)
769 for (size_t i = 0; i < availableDurations.count; i += 4) {
770 for (const auto& size : sizes) {
771 int64_t width = std::get<0>(size);
772 int64_t height = std::get<1>(size);
773 if ((availableDurations.data.i64[i] == format) &&
774 (availableDurations.data.i64[i+1] == width) &&
775 (availableDurations.data.i64[i+2] == height)) {
776 durations->push_back(availableDurations.data.i64[i+3]);
777 }
778 }
779 }
780 }
781}
782void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
783 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
784 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
785 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
786 return;
787 }
788
789 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
790 // Processing time on camera service side can vary greatly depending on multiple
791 // variables which are not under our control. Make a guesstimate by taking the maximum
792 // corresponding duration value from depth and blob.
793 auto depthDuration = depthDurations.begin();
794 auto blobDuration = blobDurations.begin();
795 dynamicDepthDurations->reserve(depthDurations.size());
796 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
797 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
798 depthDuration++; blobDuration++;
799 }
800}
801
802void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
803 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
804 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
805 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
806 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
807 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
808 return;
809 }
810
811 // The dynamic depth spec. does not mention how close the AR ratio should be.
812 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000813 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000814
815 for (const auto& blobSize : blobSizes) {
816 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
817 static_cast<float>(std::get<1>(blobSize));
818 bool found = false;
819 for (const auto& depthSize : depthSizes) {
820 if (depthSize == blobSize) {
821 internalDepthSizes->push_back(depthSize);
822 found = true;
823 break;
824 } else {
825 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
826 static_cast<float>(std::get<1>(depthSize));
827 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
828 internalDepthSizes->push_back(depthSize);
829 found = true;
830 break;
831 }
832 }
833 }
834
835 if (found) {
836 dynamicDepthSizes->push_back(blobSize);
837 }
838 }
839}
840
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800841status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags(
842 bool maxResolution) {
843 const int32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
844
845 const int32_t scalerSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700846 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800847 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
848 const int32_t scalerMinFrameDurationsTag =
849 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
850 const int32_t scalerStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700851 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800852 ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, maxResolution);
853
854 const int32_t depthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700855 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800856 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
857 const int32_t depthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700858 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800859 ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, maxResolution);
860 const int32_t depthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700861 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800862 ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
863
864 const int32_t dynamicDepthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700865 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800866 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
867 const int32_t dynamicDepthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700868 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800869 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS, maxResolution);
870 const int32_t dynamicDepthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700871 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800872 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
873
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000874 auto& c = mCameraCharacteristics;
875 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
876 supportedDynamicDepthSizes, internalDepthSizes;
877 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
878 if (chTags.count == 0) {
879 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
880 return BAD_VALUE;
881 }
882
883 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
884 depthExclTag) != (chTags.data.i32 + chTags.count);
885 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800886 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000887 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
888 // No depth support, nothing more to do.
889 return OK;
890 }
891
892 auto depthExclusiveEntry = c.find(depthExclTag);
893 if (depthExclusiveEntry.count > 0) {
894 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
895 // Depth support is exclusive, nothing more to do.
896 return OK;
897 }
898 } else {
899 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
900 return BAD_VALUE;
901 }
902
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800903 getSupportedSizes(c, scalerSizesTag, HAL_PIXEL_FORMAT_BLOB,
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000904 &supportedBlobSizes);
905 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
906 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
907 // Nothing to do in this case.
908 return OK;
909 }
910
911 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
912 &supportedDynamicDepthSizes, &internalDepthSizes);
913 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000914 // Nothing more to do.
915 return OK;
916 }
917
918 std::vector<int32_t> dynamicDepthEntries;
919 for (const auto& it : supportedDynamicDepthSizes) {
920 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
921 static_cast<int32_t> (std::get<1>(it)),
922 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
923 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
924 }
925
926 std::vector<int64_t> depthMinDurations, depthStallDurations;
927 std::vector<int64_t> blobMinDurations, blobStallDurations;
928 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
929
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800930 getSupportedDurations(c, depthMinFrameDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
931 &depthMinDurations);
932 getSupportedDurations(c, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
933 supportedDynamicDepthSizes, &blobMinDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000934 if (blobMinDurations.empty() || depthMinDurations.empty() ||
935 (depthMinDurations.size() != blobMinDurations.size())) {
936 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
937 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
938 return BAD_VALUE;
939 }
940
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800941 getSupportedDurations(c, depthStallDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
942 &depthStallDurations);
943 getSupportedDurations(c, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
944 supportedDynamicDepthSizes, &blobStallDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000945 if (blobStallDurations.empty() || depthStallDurations.empty() ||
946 (depthStallDurations.size() != blobStallDurations.size())) {
947 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
948 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
949 return BAD_VALUE;
950 }
951
952 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
953 &dynamicDepthMinDurations);
954 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
955 &dynamicDepthStallDurations);
956 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
957 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
958 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
959 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
960 return BAD_VALUE;
961 }
962
963 std::vector<int64_t> dynamicDepthMinDurationEntries;
964 auto itDuration = dynamicDepthMinDurations.begin();
965 auto itSize = supportedDynamicDepthSizes.begin();
966 while (itDuration != dynamicDepthMinDurations.end()) {
967 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
968 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
969 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
970 entry + 4);
971 itDuration++; itSize++;
972 }
973
974 std::vector<int64_t> dynamicDepthStallDurationEntries;
975 itDuration = dynamicDepthStallDurations.begin();
976 itSize = supportedDynamicDepthSizes.begin();
977 while (itDuration != dynamicDepthStallDurations.end()) {
978 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
979 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
980 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
981 entry + 4);
982 itDuration++; itSize++;
983 }
984
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000985 std::vector<int32_t> supportedChTags;
986 supportedChTags.reserve(chTags.count + 3);
987 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
988 chTags.data.i32 + chTags.count);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800989 supportedChTags.push_back(dynamicDepthSizesTag);
990 supportedChTags.push_back(dynamicDepthMinFrameDurationsTag);
991 supportedChTags.push_back(dynamicDepthStallDurationsTag);
992 c.update(dynamicDepthSizesTag, dynamicDepthEntries.data(), dynamicDepthEntries.size());
993 c.update(dynamicDepthMinFrameDurationsTag, dynamicDepthMinDurationEntries.data(),
994 dynamicDepthMinDurationEntries.size());
995 c.update(dynamicDepthStallDurationsTag, dynamicDepthStallDurationEntries.data(),
996 dynamicDepthStallDurationEntries.size());
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000997 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
998 supportedChTags.size());
999
1000 return OK;
1001}
1002
Shuzhen Wang268a1362018-10-16 16:32:59 -07001003status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
1004 status_t res = OK;
1005 auto& c = mCameraCharacteristics;
1006
1007 // Override static metadata for MONOCHROME camera with older device version
1008 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
1009 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1010 for (size_t i = 0; i < cap.count; i++) {
1011 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
1012 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
1013 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
1014 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
1015 if (res != OK) {
1016 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
1017 __FUNCTION__, strerror(-res), res);
1018 return res;
1019 }
1020
1021 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
1022 const std::vector<uint32_t> sKeys = {
1023 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
1024 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
1025 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
1026 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
1027 ANDROID_SENSOR_COLOR_TRANSFORM1,
1028 ANDROID_SENSOR_COLOR_TRANSFORM2,
1029 ANDROID_SENSOR_FORWARD_MATRIX1,
1030 ANDROID_SENSOR_FORWARD_MATRIX2,
1031 };
1032 res = removeAvailableKeys(c, sKeys,
1033 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1034 if (res != OK) {
1035 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
1036 __FUNCTION__, strerror(-res), res);
1037 return res;
1038 }
1039
1040 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
1041 const std::vector<uint32_t> reqKeys = {
1042 ANDROID_COLOR_CORRECTION_MODE,
1043 ANDROID_COLOR_CORRECTION_TRANSFORM,
1044 ANDROID_COLOR_CORRECTION_GAINS,
1045 };
1046 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
1047 if (res != OK) {
1048 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
1049 __FUNCTION__, strerror(-res), res);
1050 return res;
1051 }
1052
1053 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
1054 const std::vector<uint32_t> resKeys = {
1055 ANDROID_SENSOR_GREEN_SPLIT,
1056 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
1057 ANDROID_COLOR_CORRECTION_MODE,
1058 ANDROID_COLOR_CORRECTION_TRANSFORM,
1059 ANDROID_COLOR_CORRECTION_GAINS,
1060 };
1061 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
1062 if (res != OK) {
1063 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
1064 __FUNCTION__, strerror(-res), res);
1065 return res;
1066 }
1067
1068 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
1069 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
1070 for (size_t j = 1; j < blEntry.count; j++) {
1071 blEntry.data.i32[j] = blEntry.data.i32[0];
1072 }
1073 }
1074 }
1075 }
1076 return res;
1077}
1078
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001079status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addRotateCropTags() {
1080 status_t res = OK;
1081 auto& c = mCameraCharacteristics;
1082
1083 auto availableRotateCropEntry = c.find(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES);
1084 if (availableRotateCropEntry.count == 0) {
1085 uint8_t defaultAvailableRotateCropEntry = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
1086 res = c.update(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
1087 &defaultAvailableRotateCropEntry, 1);
1088 }
1089 return res;
1090}
1091
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -07001092status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addPreCorrectionActiveArraySize() {
1093 status_t res = OK;
1094 auto& c = mCameraCharacteristics;
1095
1096 auto activeArraySize = c.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
1097 auto preCorrectionActiveArraySize = c.find(
1098 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1099 if (activeArraySize.count == 4 && preCorrectionActiveArraySize.count == 0) {
1100 std::vector<int32_t> preCorrectionArray(
1101 activeArraySize.data.i32, activeArraySize.data.i32+4);
1102 res = c.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
1103 preCorrectionArray.data(), 4);
1104 if (res != OK) {
1105 ALOGE("%s: Failed to add ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s(%d)",
1106 __FUNCTION__, strerror(-res), res);
1107 return res;
1108 }
1109 } else {
1110 return res;
1111 }
1112
1113 auto charTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1114 bool hasPreCorrectionActiveArraySize = std::find(charTags.data.i32,
1115 charTags.data.i32 + charTags.count,
1116 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE) !=
1117 (charTags.data.i32 + charTags.count);
1118 if (!hasPreCorrectionActiveArraySize) {
1119 std::vector<int32_t> supportedCharTags;
1120 supportedCharTags.reserve(charTags.count + 1);
1121 supportedCharTags.insert(supportedCharTags.end(), charTags.data.i32,
1122 charTags.data.i32 + charTags.count);
1123 supportedCharTags.push_back(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1124
1125 res = c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedCharTags.data(),
1126 supportedCharTags.size());
1127 if (res != OK) {
1128 ALOGE("%s: Failed to update ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s(%d)",
1129 __FUNCTION__, strerror(-res), res);
1130 return res;
1131 }
1132 }
1133
1134 return res;
1135}
1136
Shuzhen Wang268a1362018-10-16 16:32:59 -07001137status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
1138 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
1139 status_t res = OK;
1140
1141 camera_metadata_entry keysEntry = c.find(keyTag);
1142 if (keysEntry.count == 0) {
1143 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
1144 return res;
1145 }
1146 std::vector<int32_t> vKeys;
1147 vKeys.reserve(keysEntry.count);
1148 for (size_t i = 0; i < keysEntry.count; i++) {
1149 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
1150 vKeys.push_back(keysEntry.data.i32[i]);
1151 }
1152 }
1153 res = c.update(keyTag, vKeys.data(), vKeys.size());
1154 return res;
1155}
1156
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001157status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
1158 std::vector<int32_t>* outputs,
1159 std::vector<int64_t>* durations,
1160 std::vector<int64_t>* stallDurations,
1161 const camera_metadata_entry& halStreamConfigs,
1162 const camera_metadata_entry& halStreamDurations) {
1163 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
1164 return BAD_VALUE;
1165 }
1166
1167 static bool supportInMemoryTempFile =
1168 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
1169 if (!supportInMemoryTempFile) {
1170 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
1171 __FUNCTION__);
1172 return OK;
1173 }
1174
1175 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
1176 int32_t format = halStreamConfigs.data.i32[i];
1177 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
1178 // image.
1179 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
1180 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
1181 continue;
1182 }
1183
1184 bool sizeAvail = false;
1185 for (size_t j = 0; j < outputs->size(); j+= 4) {
1186 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
1187 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
1188 sizeAvail = true;
1189 break;
1190 }
1191 }
1192 if (sizeAvail) continue;
1193
1194 int64_t stall = 0;
Susmitha Gummallafca67142020-03-05 14:58:30 -08001195 bool useHeic = false;
1196 bool useGrid = false;
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001197 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
1198 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
1199 &useHeic, &useGrid, &stall)) {
1200 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
1201 continue;
1202 }
1203
1204 // HEIC configuration
1205 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1206 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1207 outputs->insert(outputs->end(), config, config + 4);
1208
1209 // HEIC minFrameDuration
1210 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1211 if (halStreamDurations.data.i64[j] == format &&
1212 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1213 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1214 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1215 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1216 durations->insert(durations->end(), duration, duration+4);
1217 break;
1218 }
1219 }
1220
1221 // HEIC stallDuration
1222 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1223 halStreamConfigs.data.i32[i+2], stall};
1224 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1225 }
1226 }
1227 return OK;
1228}
1229
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001230status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags(bool maxResolution) {
1231 int32_t scalerStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001232 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001233 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
1234 int32_t scalerMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001235 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001236 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, maxResolution);
1237
1238 int32_t heicStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001239 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001240 ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, maxResolution);
1241 int32_t heicMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001242 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001243 ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, maxResolution);
1244 int32_t heicStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001245 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001246 ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, maxResolution);
1247
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001248 auto& c = mCameraCharacteristics;
1249
1250 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1251 if (halHeicSupport.count > 1) {
1252 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1253 __FUNCTION__, halHeicSupport.count);
1254 return BAD_VALUE;
1255 } else if (halHeicSupport.count == 0 ||
1256 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1257 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1258 return OK;
1259 }
1260
1261 camera_metadata_entry maxJpegAppsSegments =
1262 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1263 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1264 maxJpegAppsSegments.data.u8[0] > 16) {
1265 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1266 __FUNCTION__);
1267 return BAD_VALUE;
1268 }
1269
1270 // Populate HEIC output configurations and its related min frame duration
1271 // and stall duration.
1272 std::vector<int32_t> heicOutputs;
1273 std::vector<int64_t> heicDurations;
1274 std::vector<int64_t> heicStallDurations;
1275
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001276 camera_metadata_entry halStreamConfigs = c.find(scalerStreamSizesTag);
1277 camera_metadata_entry minFrameDurations = c.find(scalerMinFrameDurationsTag);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001278
1279 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1280 halStreamConfigs, minFrameDurations);
1281 if (res != OK) {
1282 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1283 strerror(-res), res);
1284 return res;
1285 }
1286
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001287 c.update(heicStreamSizesTag, heicOutputs.data(), heicOutputs.size());
1288 c.update(heicMinFrameDurationsTag, heicDurations.data(), heicDurations.size());
1289 c.update(heicStallDurationsTag, heicStallDurations.data(), heicStallDurations.size());
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001290
1291 return OK;
1292}
1293
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001294bool CameraProviderManager::isLogicalCameraLocked(const std::string& id,
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001295 std::vector<std::string>* physicalCameraIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001296 auto deviceInfo = findDeviceInfoLocked(id);
1297 if (deviceInfo == nullptr) return false;
1298
1299 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1300 *physicalCameraIds = deviceInfo->mPhysicalIds;
1301 }
1302 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001303}
1304
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001305bool CameraProviderManager::isLogicalCamera(const std::string& id,
1306 std::vector<std::string>* physicalCameraIds) {
1307 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1308 return isLogicalCameraLocked(id, physicalCameraIds);
1309}
1310
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001311status_t CameraProviderManager::getSystemCameraKind(const std::string& id,
1312 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001313 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001314 return getSystemCameraKindLocked(id, kind);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001315}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001316
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001317status_t CameraProviderManager::getSystemCameraKindLocked(const std::string& id,
1318 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001319 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001320 if (deviceInfo != nullptr) {
1321 *kind = deviceInfo->mSystemCameraKind;
1322 return OK;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001323 }
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001324 // If this is a hidden physical camera, we should return what kind of
1325 // camera the enclosing logical camera is.
1326 auto isHiddenAndParent = isHiddenPhysicalCameraInternal(id);
1327 if (isHiddenAndParent.first) {
1328 LOG_ALWAYS_FATAL_IF(id == isHiddenAndParent.second->mId,
1329 "%s: hidden physical camera id %s and enclosing logical camera id %s are the same",
1330 __FUNCTION__, id.c_str(), isHiddenAndParent.second->mId.c_str());
1331 return getSystemCameraKindLocked(isHiddenAndParent.second->mId, kind);
1332 }
1333 // Neither a hidden physical camera nor a logical camera
1334 return NAME_NOT_FOUND;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001335}
1336
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001337bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) const {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001338 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001339 return isHiddenPhysicalCameraInternal(cameraId).first;
1340}
1341
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001342status_t CameraProviderManager::filterSmallJpegSizes(const std::string& cameraId) {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001343 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wang89db2992021-05-20 13:09:48 -07001344 for (auto& provider : mProviders) {
1345 for (auto& deviceInfo : provider->mDevices) {
1346 if (deviceInfo->mId == cameraId) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001347 return deviceInfo->filterSmallJpegSizes();
Shuzhen Wang89db2992021-05-20 13:09:48 -07001348 }
1349 }
1350 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001351 return NAME_NOT_FOUND;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001352}
1353
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001354std::pair<bool, CameraProviderManager::ProviderInfo::DeviceInfo *>
1355CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraId) const {
1356 auto falseRet = std::make_pair(false, nullptr);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001357 for (auto& provider : mProviders) {
1358 for (auto& deviceInfo : provider->mDevices) {
1359 if (deviceInfo->mId == cameraId) {
1360 // cameraId is found in public camera IDs advertised by the
1361 // provider.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001362 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001363 }
1364 }
1365 }
1366
1367 for (auto& provider : mProviders) {
1368 for (auto& deviceInfo : provider->mDevices) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001369 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001370 if (deviceInfo->mIsLogicalCamera) {
1371 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1372 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001373 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1374 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1375 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1376 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1377 __FUNCTION__, deviceVersion, cameraId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001378 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001379 } else {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001380 return std::make_pair(true, deviceInfo.get());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001381 }
1382 }
1383 }
1384 }
1385 }
1386
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001387 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001388}
1389
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001390status_t CameraProviderManager::tryToInitializeHidlProviderLocked(
Emilian Peevc93cac22020-08-17 16:00:10 -07001391 const std::string& providerName, const sp<ProviderInfo>& providerInfo) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001392 sp<provider::V2_4::ICameraProvider> interface;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001393 interface = mHidlServiceProxy->tryGetService(providerName);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001394
1395 if (interface == nullptr) {
Shuzhen Wang77d04192021-04-02 12:33:54 -07001396 // The interface may not be started yet. In that case, this is not a
1397 // fatal error.
1398 ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
Emilian Peevc93cac22020-08-17 16:00:10 -07001399 providerName.c_str());
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001400 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001401 }
1402
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001403 HidlProviderInfo *hidlProviderInfo = static_cast<HidlProviderInfo *>(providerInfo.get());
1404 return hidlProviderInfo->initializeHidlProvider(interface, mDeviceState);
Emilian Peevc93cac22020-08-17 16:00:10 -07001405}
1406
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001407status_t CameraProviderManager::addHidlProviderLocked(const std::string& newProvider,
Emilian Peevc93cac22020-08-17 16:00:10 -07001408 bool preexisting) {
1409 // Several camera provider instances can be temporarily present.
1410 // Defer initialization of a new instance until the older instance is properly removed.
1411 auto providerInstance = newProvider + "-" + std::to_string(mProviderInstanceId);
1412 bool providerPresent = false;
1413 for (const auto& providerInfo : mProviders) {
1414 if (providerInfo->mProviderName == newProvider) {
1415 ALOGW("%s: Camera provider HAL with name '%s' already registered",
1416 __FUNCTION__, newProvider.c_str());
Valentin Iftime29e2e152021-08-13 15:17:33 +02001417 // Do not add new instances for lazy HAL external provider
1418 if (preexisting || providerInfo->isExternalLazyHAL()) {
Emilian Peevc93cac22020-08-17 16:00:10 -07001419 return ALREADY_EXISTS;
Valentin Iftime29e2e152021-08-13 15:17:33 +02001420 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07001421 ALOGW("%s: The new provider instance will get initialized immediately after the"
1422 " currently present instance is removed!", __FUNCTION__);
1423 providerPresent = true;
1424 break;
1425 }
1426 }
1427 }
1428
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001429 sp<HidlProviderInfo> providerInfo = new HidlProviderInfo(newProvider, providerInstance, this);
Emilian Peevc93cac22020-08-17 16:00:10 -07001430 if (!providerPresent) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001431 status_t res = tryToInitializeHidlProviderLocked(newProvider, providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07001432 if (res != OK) {
1433 return res;
1434 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001435 }
1436
1437 mProviders.push_back(providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07001438 mProviderInstanceId++;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001439
1440 return OK;
1441}
1442
1443status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001444 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001445 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1446 std::vector<String8> removedDeviceIds;
1447 status_t res = NAME_NOT_FOUND;
Emilian Peevc93cac22020-08-17 16:00:10 -07001448 std::string removedProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001449 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
Emilian Peevc93cac22020-08-17 16:00:10 -07001450 if ((*it)->mProviderInstance == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001451 removedDeviceIds.reserve((*it)->mDevices.size());
1452 for (auto& deviceInfo : (*it)->mDevices) {
1453 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1454 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001455 removedProviderName = (*it)->mProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001456 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001457 res = OK;
1458 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001459 }
1460 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001461 if (res != OK) {
1462 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1463 provider.c_str());
1464 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07001465 // Check if there are any newer camera instances from the same provider and try to
1466 // initialize.
1467 for (const auto& providerInfo : mProviders) {
1468 if (providerInfo->mProviderName == removedProviderName) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001469 IPCTransport providerTransport = providerInfo->getIPCTransport();
1470 switch(providerTransport) {
1471 case IPCTransport::HIDL:
1472 return tryToInitializeHidlProviderLocked(removedProviderName, providerInfo);
1473 default:
1474 ALOGE("%s Unsupported Transport %d", __FUNCTION__, providerTransport);
1475 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001476 }
1477 }
1478
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001479 // Inform camera service of loss of presence for all the devices from this provider,
1480 // without lock held for reentrancy
1481 sp<StatusListener> listener = getStatusListener();
1482 if (listener != nullptr) {
1483 lock.unlock();
1484 for (auto& id : removedDeviceIds) {
1485 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1486 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001487 lock.lock();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001488 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001489
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001490 }
1491 return res;
1492}
1493
1494sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1495 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001496}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001497/**** Methods for ProviderInfo ****/
1498
1499
1500CameraProviderManager::ProviderInfo::ProviderInfo(
1501 const std::string &providerName,
Emilian Peevc93cac22020-08-17 16:00:10 -07001502 const std::string &providerInstance,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001503 CameraProviderManager *manager) :
1504 mProviderName(providerName),
Emilian Peevc93cac22020-08-17 16:00:10 -07001505 mProviderInstance(providerInstance),
Emilian Peev71c73a22017-03-21 16:35:51 +00001506 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001507 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001508 mManager(manager) {
1509 (void) mManager;
1510}
1511
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001512const std::string& CameraProviderManager::ProviderInfo::getType() const {
1513 return mType;
1514}
1515
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001516void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1517 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1518 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001519 mUniqueCameraIds.erase(id);
1520 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001521 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
Valentin Iftime29e2e152021-08-13 15:17:33 +02001522 mUniqueAPI1CompatibleCameraIds.begin(),
1523 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001524 }
Valentin Iftime29e2e152021-08-13 15:17:33 +02001525
1526 // Remove reference to camera provider to avoid pointer leak when
1527 // unplugging external camera while in use with lazy HALs
1528 mManager->removeRef(DeviceMode::CAMERA, id);
1529 mManager->removeRef(DeviceMode::TORCH, id);
1530
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001531 mDevices.erase(it);
1532 break;
1533 }
1534 }
1535}
1536
Valentin Iftime29e2e152021-08-13 15:17:33 +02001537void CameraProviderManager::ProviderInfo::removeAllDevices() {
1538 std::lock_guard<std::mutex> lock(mLock);
1539
1540 auto itDevices = mDevices.begin();
1541 while (itDevices != mDevices.end()) {
1542 std::string id = (*itDevices)->mId;
1543 std::string deviceName = (*itDevices)->mName;
1544 removeDevice(id);
1545 // device was removed, reset iterator
1546 itDevices = mDevices.begin();
1547
1548 //notify CameraService of status change
1549 sp<StatusListener> listener = mManager->getStatusListener();
1550 if (listener != nullptr) {
1551 mLock.unlock();
1552 ALOGV("%s: notify device not_present: %s",
1553 __FUNCTION__,
1554 deviceName.c_str());
1555 listener->onDeviceStatusChanged(String8(id.c_str()),
1556 CameraDeviceStatus::NOT_PRESENT);
1557 mLock.lock();
1558 }
1559 }
1560}
1561
1562bool CameraProviderManager::ProviderInfo::isExternalLazyHAL() const {
1563 return kEnableLazyHal && (mProviderName == kExternalProviderName);
1564}
1565
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001566status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001567 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
Emilian Peevc93cac22020-08-17 16:00:10 -07001568 mProviderInstance.c_str(),
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001569 mMinorVersion,
1570 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001571 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001572
1573 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001574 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1575 device->mVersion.get_major(), device->mVersion.get_minor());
1576 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1577 if (device->mResourceCost.conflictingDevices.size() == 0) {
1578 dprintf(fd, " Conflicting devices: None\n");
1579 } else {
1580 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001581 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001582 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001583 device->mResourceCost.conflictingDevices[i].c_str());
1584 }
1585 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001586 dprintf(fd, " API1 info:\n");
1587 dprintf(fd, " Has a flash unit: %s\n",
1588 device->hasFlashUnit() ? "true" : "false");
1589 hardware::CameraInfo info;
1590 status_t res = device->getCameraInfo(&info);
1591 if (res != OK) {
1592 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1593 strerror(-res), res);
1594 } else {
1595 dprintf(fd, " Facing: %s\n",
1596 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1597 dprintf(fd, " Orientation: %d\n", info.orientation);
1598 }
1599 CameraMetadata info2;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001600 res = device->getCameraCharacteristics(true /*overrideForPerfClass*/, &info2);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001601 if (res == INVALID_OPERATION) {
1602 dprintf(fd, " API2 not directly supported\n");
1603 } else if (res != OK) {
1604 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1605 strerror(-res), res);
1606 } else {
1607 dprintf(fd, " API2 camera characteristics:\n");
1608 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1609 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001610
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001611 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001612 if (device->mIsLogicalCamera) {
1613 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001614 // Skip if physical id is an independent camera
1615 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1616 != mProviderPublicCameraIds.end()) {
1617 continue;
1618 }
1619
1620 CameraMetadata physicalInfo;
1621 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1622 if (status == OK) {
1623 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1624 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1625 }
1626 }
1627 }
1628
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001629 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1630 device->mVersion.get_major(), device->mVersion.get_minor());
1631 res = device->dumpState(fd);
1632 if (res != OK) {
1633 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1634 device->mName.c_str(), strerror(-res), res);
1635 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001636 }
1637 return OK;
1638}
1639
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001640std::vector<std::unordered_set<std::string>>
1641CameraProviderManager::ProviderInfo::getConcurrentCameraIdCombinations() {
1642 std::lock_guard<std::mutex> lock(mLock);
1643 return mConcurrentCameraIdCombinations;
1644}
1645
Emilian Peevb50402e2021-09-24 17:41:57 -07001646void CameraProviderManager::ProviderInfo::notifyDeviceInfoStateChangeLocked(
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001647 int64_t newDeviceState) {
Emilian Peevb50402e2021-09-24 17:41:57 -07001648 std::lock_guard<std::mutex> lock(mLock);
1649 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1650 (*it)->notifyDeviceStateChange(newDeviceState);
1651 }
1652}
1653
Shuzhen Wang394ad702020-07-23 13:01:54 -07001654void CameraProviderManager::ProviderInfo::notifyInitialStatusChange(
1655 sp<StatusListener> listener,
1656 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus) {
1657 for (auto& statusInfo : *cachedStatus) {
1658 if (statusInfo.isPhysicalCameraStatus) {
1659 listener->onDeviceStatusChanged(String8(statusInfo.cameraId.c_str()),
1660 String8(statusInfo.physicalCameraId.c_str()), statusInfo.status);
1661 } else {
1662 listener->onDeviceStatusChanged(
1663 String8(statusInfo.cameraId.c_str()), statusInfo.status);
1664 }
1665 }
1666}
1667
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001668CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001669 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001670 uint16_t minorVersion,
1671 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001672 sp<ProviderInfo> parentProvider,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001673 const std::vector<std::string>& publicCameraIds) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001674 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001675 publicCameraIds, resourceCost, parentProvider) { }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001676
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001677void CameraProviderManager::ProviderInfo::DeviceInfo3::notifyDeviceStateChange(int64_t newState) {
Emilian Peevb50402e2021-09-24 17:41:57 -07001678 if (!mDeviceStateOrientationMap.empty() &&
1679 (mDeviceStateOrientationMap.find(newState) != mDeviceStateOrientationMap.end())) {
1680 mCameraCharacteristics.update(ANDROID_SENSOR_ORIENTATION,
1681 &mDeviceStateOrientationMap[newState], 1);
1682 }
1683}
1684
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001685status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
1686 hardware::CameraInfo *info) const {
1687 if (info == nullptr) return BAD_VALUE;
1688
1689 camera_metadata_ro_entry facing =
1690 mCameraCharacteristics.find(ANDROID_LENS_FACING);
1691 if (facing.count == 1) {
1692 switch (facing.data.u8[0]) {
1693 case ANDROID_LENS_FACING_BACK:
1694 info->facing = hardware::CAMERA_FACING_BACK;
1695 break;
1696 case ANDROID_LENS_FACING_EXTERNAL:
1697 // Map external to front for legacy API
1698 case ANDROID_LENS_FACING_FRONT:
1699 info->facing = hardware::CAMERA_FACING_FRONT;
1700 break;
1701 }
1702 } else {
1703 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
1704 return NAME_NOT_FOUND;
1705 }
1706
1707 camera_metadata_ro_entry orientation =
1708 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
1709 if (orientation.count == 1) {
1710 info->orientation = orientation.data.i32[0];
1711 } else {
1712 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
1713 return NAME_NOT_FOUND;
1714 }
1715
1716 return OK;
1717}
Emilian Peevf53f66e2017-04-11 14:29:43 +01001718bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07001719 // Do not advertise NIR cameras to API1 camera app.
1720 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
1721 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
1722 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
1723 return false;
1724 }
1725
Emilian Peevf53f66e2017-04-11 14:29:43 +01001726 bool isBackwardCompatible = false;
1727 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
1728 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1729 for (size_t i = 0; i < caps.count; i++) {
1730 if (caps.data.u8[i] ==
1731 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
1732 isBackwardCompatible = true;
1733 break;
1734 }
1735 }
1736
1737 return isBackwardCompatible;
1738}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001739
1740status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001741 bool overrideForPerfClass, CameraMetadata *characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001742 if (characteristics == nullptr) return BAD_VALUE;
1743
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001744 if (!overrideForPerfClass && mCameraCharNoPCOverride != nullptr) {
1745 *characteristics = *mCameraCharNoPCOverride;
1746 } else {
1747 *characteristics = mCameraCharacteristics;
1748 }
1749
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001750 return OK;
1751}
1752
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001753status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
1754 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
1755 if (characteristics == nullptr) return BAD_VALUE;
1756 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
1757 mPhysicalCameraCharacteristics.end()) {
1758 return NAME_NOT_FOUND;
1759 }
1760
1761 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
1762 return OK;
1763}
1764
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001765status_t CameraProviderManager::ProviderInfo::DeviceInfo3::filterSmallJpegSizes() {
1766 int32_t thresholdW = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_W;
1767 int32_t thresholdH = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_H;
1768
1769 if (mCameraCharNoPCOverride != nullptr) return OK;
1770
1771 mCameraCharNoPCOverride = std::make_unique<CameraMetadata>(mCameraCharacteristics);
Shuzhen Wang89db2992021-05-20 13:09:48 -07001772
1773 // Remove small JPEG sizes from available stream configurations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001774 size_t largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001775 std::vector<int32_t> newStreamConfigs;
1776 camera_metadata_entry streamConfigs =
1777 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
1778 for (size_t i = 0; i < streamConfigs.count; i += 4) {
1779 if ((streamConfigs.data.i32[i] == HAL_PIXEL_FORMAT_BLOB) && (streamConfigs.data.i32[i+3] ==
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001780 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
1781 if (streamConfigs.data.i32[i+1] < thresholdW ||
1782 streamConfigs.data.i32[i+2] < thresholdH) {
1783 continue;
1784 } else {
1785 largeJpegCount ++;
1786 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07001787 }
1788 newStreamConfigs.insert(newStreamConfigs.end(), streamConfigs.data.i32 + i,
1789 streamConfigs.data.i32 + i + 4);
1790 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001791 if (newStreamConfigs.size() == 0 || largeJpegCount == 0) {
1792 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001793 }
1794
1795 // Remove small JPEG sizes from available min frame durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001796 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001797 std::vector<int64_t> newMinDurations;
1798 camera_metadata_entry minDurations =
1799 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
1800 for (size_t i = 0; i < minDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001801 if (minDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
1802 if (minDurations.data.i64[i+1] < thresholdW ||
1803 minDurations.data.i64[i+2] < thresholdH) {
1804 continue;
1805 } else {
1806 largeJpegCount++;
1807 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07001808 }
1809 newMinDurations.insert(newMinDurations.end(), minDurations.data.i64 + i,
1810 minDurations.data.i64 + i + 4);
1811 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001812 if (newMinDurations.size() == 0 || largeJpegCount == 0) {
1813 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001814 }
1815
1816 // Remove small JPEG sizes from available stall durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001817 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001818 std::vector<int64_t> newStallDurations;
1819 camera_metadata_entry stallDurations =
1820 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS);
1821 for (size_t i = 0; i < stallDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001822 if (stallDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
1823 if (stallDurations.data.i64[i+1] < thresholdW ||
1824 stallDurations.data.i64[i+2] < thresholdH) {
1825 continue;
1826 } else {
1827 largeJpegCount++;
1828 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07001829 }
1830 newStallDurations.insert(newStallDurations.end(), stallDurations.data.i64 + i,
1831 stallDurations.data.i64 + i + 4);
1832 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001833 if (newStallDurations.size() == 0 || largeJpegCount == 0) {
1834 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001835 }
1836
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001837 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
1838 newStreamConfigs.data(), newStreamConfigs.size());
1839 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
1840 newMinDurations.data(), newMinDurations.size());
1841 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
1842 newStallDurations.data(), newStallDurations.size());
1843
Shuzhen Wang89db2992021-05-20 13:09:48 -07001844 // Re-generate metadata tags that have dependencies on BLOB sizes
1845 auto res = addDynamicDepthTags();
1846 if (OK != res) {
1847 ALOGE("%s: Failed to append dynamic depth tags: %s (%d)", __FUNCTION__,
1848 strerror(-res), res);
Shuzhen Wang2ebb8392021-06-21 23:31:10 -07001849 // Allow filtering of small JPEG sizes to succeed even if dynamic depth
1850 // tags fail to generate.
Shuzhen Wang89db2992021-05-20 13:09:48 -07001851 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001852
1853 return OK;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001854}
1855
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001856status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
1857 std::string *type, uint32_t *id) {
1858 // Format must be "<type>/<id>"
1859#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
1860 "Should match '<type>/<id>' - "
1861
1862 if (!type || !id) return INVALID_OPERATION;
1863
1864 std::string::size_type slashIdx = name.find('/');
1865 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
1866 ALOGE(ERROR_MSG_PREFIX
1867 "does not have / separator between type and id",
1868 __FUNCTION__, name.c_str());
1869 return BAD_VALUE;
1870 }
1871
1872 std::string typeVal = name.substr(0, slashIdx);
1873
1874 char *endPtr;
1875 errno = 0;
1876 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
1877 if (errno != 0) {
1878 ALOGE(ERROR_MSG_PREFIX
1879 "cannot parse provider id as an integer: %s (%d)",
1880 __FUNCTION__, name.c_str(), strerror(errno), errno);
1881 return BAD_VALUE;
1882 }
1883 if (endPtr != name.c_str() + name.size()) {
1884 ALOGE(ERROR_MSG_PREFIX
1885 "provider id has unexpected length",
1886 __FUNCTION__, name.c_str());
1887 return BAD_VALUE;
1888 }
1889 if (idVal < 0) {
1890 ALOGE(ERROR_MSG_PREFIX
1891 "id is negative: %ld",
1892 __FUNCTION__, name.c_str(), idVal);
1893 return BAD_VALUE;
1894 }
1895
1896#undef ERROR_MSG_PREFIX
1897
1898 *type = typeVal;
1899 *id = static_cast<uint32_t>(idVal);
1900
1901 return OK;
1902}
1903
Emilian Peev71c73a22017-03-21 16:35:51 +00001904metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
1905 const std::string &name) {
1906 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
1907 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
1908 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
1909 ret = 0;
1910 }
1911
1912 return ret;
1913}
1914
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001915status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
1916 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
1917
1918 // Format must be "device@<major>.<minor>/<type>/<id>"
1919
1920#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
1921 "Should match 'device@<major>.<minor>/<type>/<id>' - "
1922
1923 if (!major || !minor || !type || !id) return INVALID_OPERATION;
1924
1925 // Verify starting prefix
1926 const char expectedPrefix[] = "device@";
1927
1928 if (name.find(expectedPrefix) != 0) {
1929 ALOGE(ERROR_MSG_PREFIX
1930 "does not start with '%s'",
1931 __FUNCTION__, name.c_str(), expectedPrefix);
1932 return BAD_VALUE;
1933 }
1934
1935 // Extract major/minor versions
1936 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
1937 std::string::size_type dotIdx = name.find('.', atIdx);
1938 if (dotIdx == std::string::npos) {
1939 ALOGE(ERROR_MSG_PREFIX
1940 "does not have @<major>. version section",
1941 __FUNCTION__, name.c_str());
1942 return BAD_VALUE;
1943 }
1944 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
1945 if (typeSlashIdx == std::string::npos) {
1946 ALOGE(ERROR_MSG_PREFIX
1947 "does not have .<minor>/ version section",
1948 __FUNCTION__, name.c_str());
1949 return BAD_VALUE;
1950 }
1951
1952 char *endPtr;
1953 errno = 0;
1954 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
1955 if (errno != 0) {
1956 ALOGE(ERROR_MSG_PREFIX
1957 "cannot parse major version: %s (%d)",
1958 __FUNCTION__, name.c_str(), strerror(errno), errno);
1959 return BAD_VALUE;
1960 }
1961 if (endPtr != name.c_str() + dotIdx) {
1962 ALOGE(ERROR_MSG_PREFIX
1963 "major version has unexpected length",
1964 __FUNCTION__, name.c_str());
1965 return BAD_VALUE;
1966 }
1967 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
1968 if (errno != 0) {
1969 ALOGE(ERROR_MSG_PREFIX
1970 "cannot parse minor version: %s (%d)",
1971 __FUNCTION__, name.c_str(), strerror(errno), errno);
1972 return BAD_VALUE;
1973 }
1974 if (endPtr != name.c_str() + typeSlashIdx) {
1975 ALOGE(ERROR_MSG_PREFIX
1976 "minor version has unexpected length",
1977 __FUNCTION__, name.c_str());
1978 return BAD_VALUE;
1979 }
1980 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
1981 ALOGE(ERROR_MSG_PREFIX
1982 "major/minor version is out of range of uint16_t: %ld.%ld",
1983 __FUNCTION__, name.c_str(), majorVal, minorVal);
1984 return BAD_VALUE;
1985 }
1986
1987 // Extract type and id
1988
1989 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
1990 if (instanceSlashIdx == std::string::npos) {
1991 ALOGE(ERROR_MSG_PREFIX
1992 "does not have /<type>/ component",
1993 __FUNCTION__, name.c_str());
1994 return BAD_VALUE;
1995 }
1996 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
1997
1998 if (instanceSlashIdx == name.size() - 1) {
1999 ALOGE(ERROR_MSG_PREFIX
2000 "does not have an /<id> component",
2001 __FUNCTION__, name.c_str());
2002 return BAD_VALUE;
2003 }
2004 std::string idVal = name.substr(instanceSlashIdx + 1);
2005
2006#undef ERROR_MSG_PREFIX
2007
2008 *major = static_cast<uint16_t>(majorVal);
2009 *minor = static_cast<uint16_t>(minorVal);
2010 *type = typeVal;
2011 *id = idVal;
2012
2013 return OK;
2014}
2015
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002016CameraProviderManager::ProviderInfo::~ProviderInfo() {
Shuzhen Wang394ad702020-07-23 13:01:54 -07002017 if (mInitialStatusCallbackFuture.valid()) {
2018 mInitialStatusCallbackFuture.wait();
2019 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002020 // Destruction of ProviderInfo is only supposed to happen when the respective
2021 // CameraProvider interface dies, so do not unregister callbacks.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002022}
2023
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002024// Expects to have mInterfaceMutex locked
2025std::vector<std::unordered_set<std::string>>
Jayant Chowdharycad23c22020-03-10 15:04:59 -07002026CameraProviderManager::getConcurrentCameraIds() const {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002027 std::vector<std::unordered_set<std::string>> deviceIdCombinations;
2028 std::lock_guard<std::mutex> lock(mInterfaceMutex);
2029 for (auto &provider : mProviders) {
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08002030 for (auto &combinations : provider->getConcurrentCameraIdCombinations()) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002031 deviceIdCombinations.push_back(combinations);
2032 }
2033 }
2034 return deviceIdCombinations;
2035}
2036
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002037// Checks if the containing vector of sets has any set that contains all of the
2038// camera ids in cameraIdsAndSessionConfigs.
2039static bool checkIfSetContainsAll(
2040 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
2041 const std::vector<std::unordered_set<std::string>> &containingSets) {
2042 for (auto &containingSet : containingSets) {
2043 bool didHaveAll = true;
2044 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
2045 if (containingSet.find(cameraIdAndSessionConfig.mCameraId) == containingSet.end()) {
2046 // a camera id doesn't belong to this set, keep looking in other
2047 // sets
2048 didHaveAll = false;
2049 break;
2050 }
2051 }
2052 if (didHaveAll) {
2053 // found a set that has all camera ids, lets return;
2054 return true;
2055 }
2056 }
2057 return false;
2058}
2059
2060status_t CameraProviderManager::isConcurrentSessionConfigurationSupported(
2061 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002062 const std::set<std::string>& perfClassPrimaryCameraIds,
2063 int targetSdkVersion, bool *isSupported) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002064 std::lock_guard<std::mutex> lock(mInterfaceMutex);
2065 // Check if all the devices are a subset of devices advertised by the
2066 // same provider through getConcurrentStreamingCameraIds()
2067 // TODO: we should also do a findDeviceInfoLocked here ?
2068 for (auto &provider : mProviders) {
2069 if (checkIfSetContainsAll(cameraIdsAndSessionConfigs,
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08002070 provider->getConcurrentCameraIdCombinations())) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002071 return provider->isConcurrentSessionConfigurationSupported(
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002072 cameraIdsAndSessionConfigs, perfClassPrimaryCameraIds, targetSdkVersion,
2073 isSupported);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002074 }
2075 }
2076 *isSupported = false;
2077 //The set of camera devices were not found
2078 return INVALID_OPERATION;
2079}
2080
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002081status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002082 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002083 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3, 0}, /*maxVersion*/ {5, 0});
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002084 if (deviceInfo != nullptr) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002085 return deviceInfo->getCameraCharacteristics(overrideForPerfClass, characteristics);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002086 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002087
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002088 // Find hidden physical camera characteristics
2089 for (auto& provider : mProviders) {
2090 for (auto& deviceInfo : provider->mDevices) {
2091 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2092 if (res != NAME_NOT_FOUND) return res;
2093 }
2094 }
2095
2096 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002097}
2098
2099void CameraProviderManager::filterLogicalCameraIdsLocked(
2100 std::vector<std::string>& deviceIds) const
2101{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002102 // Map between camera facing and camera IDs related to logical camera.
2103 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002104
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002105 // Collect all logical and its underlying physical camera IDs for each
2106 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002107 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002108 auto deviceInfo = findDeviceInfoLocked(deviceId);
2109 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002110
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002111 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002112 continue;
2113 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002114
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002115 // combo contains the ids of a logical camera and its physical cameras
2116 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
2117 combo.push_back(deviceId);
2118
2119 hardware::CameraInfo info;
2120 status_t res = deviceInfo->getCameraInfo(&info);
2121 if (res != OK) {
2122 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
2123 continue;
2124 }
2125 idCombos[info.facing].insert(combo.begin(), combo.end());
2126 }
2127
2128 // Only expose one camera ID per facing for all logical and underlying
2129 // physical camera IDs.
2130 for (auto& r : idCombos) {
2131 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002132 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002133 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
2134 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002135 continue;
2136 }
2137
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002138 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002139 break;
2140 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002141 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2142 [&removedIds](const std::string& s) {
2143 return removedIds.find(s) != removedIds.end();}),
2144 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002145 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002146}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002147
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002148} // namespace android