Merge "Camera: Cache logical camera related info" (1e91e0ea) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/api2/CameraDeviceClient.cpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -123,6 +123,7 @@ status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr, const Stri
		physicalKeysEntry.data.i32 + physicalKeysEntry.count);
		}

		mProviderManager = providerPtr;
		return OK;
		}

		@@ -627,12 +628,11 @@ binder::Status CameraDeviceClient::createStream(

		if (physicalCameraId.size() > 0) {
		std::vector<std::string> physicalCameraIds;
		std::string physicalId(physicalCameraId.string());
		bool logicalCamera =
		CameraProviderManager::isLogicalCamera(mDevice->info(), &physicalCameraIds);
		mProviderManager->isLogicalCamera(mCameraIdStr.string(), &physicalCameraIds);
		if (!logicalCamera \|\|
		std::find(physicalCameraIds.begin(), physicalCameraIds.end(), physicalId) ==
		physicalCameraIds.end()) {
		std::find(physicalCameraIds.begin(), physicalCameraIds.end(),
		physicalCameraId.string()) == physicalCameraIds.end()) {
		String8 msg = String8::format("Camera %s: Camera doesn't support physicalCameraId %s.",
		mCameraIdStr.string(), physicalCameraId.string());
		ALOGE("%s: %s", __FUNCTION__, msg.string());

services/camera/libcameraservice/api2/CameraDeviceClient.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -301,6 +301,7 @@ private:
		std::unordered_map<int32_t, OutputStreamInfo> mStreamInfoMap;

		static const int32_t MAX_SURFACES_PER_STREAM = 2;
		sp<CameraProviderManager> mProviderManager;
		};

		}; // namespace android

services/camera/libcameraservice/common/CameraProviderManager.cpp

+35 −31

Original line number	Diff line number	Diff line
		@@ -396,35 +396,46 @@ metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
		return ret;
		}

		bool CameraProviderManager::isLogicalCamera(const CameraMetadata& staticInfo,
		std::vector<std::string>* physicalCameraIds) {
		bool isLogicalCam = false;
		camera_metadata_ro_entry_t entryCap;
		void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
		camera_metadata_entry_t entryCap;

		entryCap = staticInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
		entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
		for (size_t i = 0; i < entryCap.count; ++i) {
		uint8_t capability = entryCap.data.u8[i];
		if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
		isLogicalCam = true;
		mIsLogicalCamera = true;
		break;
		}
		}
		if (!isLogicalCam) {
		return false;
		if (!mIsLogicalCamera) {
		return;
		}

		camera_metadata_ro_entry_t entryIds = staticInfo.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
		camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
		ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
		const uint8_t* ids = entryIds.data.u8;
		size_t start = 0;
		for (size_t i = 0; i < entryIds.count; ++i) {
		if (ids[i] == '\0') {
		if (start != i) {
		physicalCameraIds->push_back((const char*)ids+start);
		mPhysicalIds.push_back((const char*)ids+start);
		}
		start = i+1;
		}
		}
		return true;
		}

		bool CameraProviderManager::isLogicalCamera(const std::string& id,
		std::vector<std::string>* physicalCameraIds) {
		std::lock_guard<std::mutex> lock(mInterfaceMutex);

		auto deviceInfo = findDeviceInfoLocked(id);
		if (deviceInfo == nullptr) return false;

		if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
		*physicalCameraIds = deviceInfo->mPhysicalIds;
		}
		return deviceInfo->mIsLogicalCamera;
		}

		bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
		@@ -449,9 +460,9 @@ bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId)
		}

		std::vector<std::string> physicalIds;
		if (isLogicalCamera(info, &physicalIds)) {
		if (std::find(physicalIds.begin(), physicalIds.end(), cameraId) !=
		physicalIds.end()) {
		if (deviceInfo->mIsLogicalCamera) {
		if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
		cameraId) != deviceInfo->mPhysicalIds.end()) {
		int deviceVersion = HARDWARE_DEVICE_API_VERSION(
		deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
		if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
		@@ -760,9 +771,8 @@ status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16
		}

		// Dump characteristics of non-standalone physical camera
		std::vector<std::string> physicalIds;
		if (isLogicalCamera(info2, &physicalIds)) {
		for (auto& id : physicalIds) {
		if (device->mIsLogicalCamera) {
		for (auto& id : device->mPhysicalIds) {
		// Skip if physical id is an independent camera
		if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
		!= mProviderPublicCameraIds.end()) {
		@@ -1130,6 +1140,7 @@ CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string&
		mHasFlashUnit = false;
		}

		queryPhysicalCameraIds();
		// Get physical camera characteristics if applicable
		auto castResult = device::V3_5::ICameraDevice::castFrom(mInterface);
		if (!castResult.isOk()) {
		@@ -1142,9 +1153,8 @@ CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string&
		return;
		}

		std::vector<std::string> physicalIds;
		if (CameraProviderManager::isLogicalCamera(mCameraCharacteristics, &physicalIds)) {
		for (auto& id : physicalIds) {
		if (mIsLogicalCamera) {
		for (auto& id : mPhysicalIds) {
		if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
		mPublicCameraIds.end()) {
		continue;
		@@ -1622,20 +1632,14 @@ void CameraProviderManager::filterLogicalCameraIdsLocked(
		std::unordered_set<std::string> removedIds;

		for (auto& deviceId : deviceIds) {
		CameraMetadata info;
		status_t res = getCameraCharacteristicsLocked(deviceId, &info);
		if (res != OK) {
		ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
		deviceId.c_str());
		return;
		}
		auto deviceInfo = findDeviceInfoLocked(deviceId);
		if (deviceInfo == nullptr) continue;

		// idCombo contains the ids of a logical camera and its physical cameras
		std::vector<std::string> idCombo;
		bool logicalCamera = isLogicalCamera(info, &idCombo);
		if (!logicalCamera) {
		if (!deviceInfo->mIsLogicalCamera) {
		continue;
		}
		// idCombo contains the ids of a logical camera and its physical cameras
		std::vector<std::string> idCombo = deviceInfo->mPhysicalIds;
		idCombo.push_back(deviceId);

		for (auto& id : deviceIds) {

services/camera/libcameraservice/common/CameraProviderManager.h

+6 −4

Original line number	Diff line number	Diff line
		@@ -231,11 +231,10 @@ public:
		hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;

		/*
		* Check if a camera with staticInfo is a logical camera. And if yes, return
		* Check if a camera is a logical camera. And if yes, return
		* the physical camera ids.
		*/
		static bool isLogicalCamera(const CameraMetadata& staticInfo,
		std::vector<std::string>* physicalCameraIds);
		bool isLogicalCamera(const std::string& id, std::vector<std::string>* physicalCameraIds);

		bool isHiddenPhysicalCamera(const std::string& cameraId);
		private:
		@@ -293,6 +292,8 @@ private:
		const std::string mId; // ID section of full name
		const hardware::hidl_version mVersion;
		const metadata_vendor_id_t mProviderTagid;
		bool mIsLogicalCamera;
		std::vector<std::string> mPhysicalIds;

		const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;

		@@ -319,7 +320,7 @@ private:
		const std::vector<std::string>& publicCameraIds,
		const hardware::camera::common::V1_0::CameraResourceCost& resourceCost) :
		mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
		mResourceCost(resourceCost),
		mIsLogicalCamera(false), mResourceCost(resourceCost),
		mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
		mHasFlashUnit(false), mPublicCameraIds(publicCameraIds) {}
		virtual ~DeviceInfo();
		@@ -383,6 +384,7 @@ private:
		private:
		CameraMetadata mCameraCharacteristics;
		std::unordered_map<std::string, CameraMetadata> mPhysicalCameraCharacteristics;
		void queryPhysicalCameraIds();
		};

		private:

services/camera/libcameraservice/device3/Camera3Device.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -128,7 +128,7 @@ status_t Camera3Device::initialize(sp<CameraProviderManager> manager, const Stri
		}

		std::vector<std::string> physicalCameraIds;
		bool isLogical = CameraProviderManager::isLogicalCamera(mDeviceInfo, &physicalCameraIds);
		bool isLogical = manager->isLogicalCamera(mId.string(), &physicalCameraIds);
		if (isLogical) {
		for (auto& physicalId : physicalCameraIds) {
		res = manager->getCameraCharacteristics(physicalId, &mPhysicalDeviceInfoMap[physicalId]);