Merge "Added config reader for shared session config xml" into main (e7e7a0c2) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -73,6 +73,7 @@ cc_defaults {
		"libsensorprivacy",
		"libstagefright",
		"libstagefright_foundation",
		"libtinyxml2",
		"libvendorsupport",
		"libxml2",
		"libyuv",
		@@ -142,6 +143,8 @@ cc_library {
		"common/FrameProcessorBase.cpp",
		"common/hidl/HidlProviderInfo.cpp",
		"common/aidl/AidlProviderInfo.cpp",
		"config/SharedSessionConfigUtils.cpp",
		"config/SharedSessionConfigReader.cpp",
		"api1/Camera2Client.cpp",
		"api1/client2/Parameters.cpp",
		"api1/client2/FrameProcessor.cpp",
		@@ -221,6 +224,7 @@ cc_library {
		"libcamera_client",
		"libfmq",
		"libsensorprivacy",
		"libtinyxml2",
		],

		include_dirs: [

services/camera/libcameraservice/common/CameraProviderManager.cpp

+56 −45

Original line number	Diff line number	Diff line
		@@ -23,6 +23,8 @@

		#include "CameraProviderManager.h"

		#include "config/SharedSessionConfigReader.h"

		#include <aidl/android/hardware/camera/device/ICameraDevice.h>

		#include <algorithm>
		@@ -2090,60 +2092,69 @@ bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAutomotiveDevice() {
		return strncmp(value, "automotive", PROPERTY_VALUE_MAX) == 0;
		}

		status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addSharedSessionConfigurationTags() {
		status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addSharedSessionConfigurationTags(
		const std::string &cameraId) {
		status_t res = OK;
		if (flags::camera_multi_client()) {
		SharedSessionConfigReader configReader;
		ErrorCode status =
		configReader.parseSharedSessionConfig(
		(std::string(SHARED_SESSION_FILE_PATH)
		+ std::string(SHARED_SESSION_FILE_NAME)).c_str());
		if (status != 0) {
		ALOGE("%s: failed to initialize SharedSessionConfigReader with ErrorCode %s",
		__FUNCTION__, SharedSessionConfigUtils::toString(status));
		return BAD_VALUE;
		}
		const int32_t sharedColorSpaceTag = ANDROID_SHARED_SESSION_COLOR_SPACE;
		const int32_t sharedOutputConfigurationsTag = ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS;
		auto& c = mCameraCharacteristics;
		int32_t colorSpace = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED;

		status = configReader.getColorSpace(&colorSpace);
		if (status != 0) {
		ALOGE("%s: failed to get color space from config reader with ErrorCode %s",
		__FUNCTION__, SharedSessionConfigUtils::toString(status));
		return BAD_VALUE;
		}

		res = c.update(sharedColorSpaceTag, &colorSpace, 1);
		if (res != OK) {
		ALOGE("%s: failed to update sharedColorSpaceTag with error %d", __FUNCTION__, res);
		return res;
		}

		std::vector<SharedSessionConfigReader::SharedSessionConfig> outputConfigurations;
		status = configReader.getAvailableSharedSessionConfigs(cameraId.c_str(),
		&outputConfigurations);
		if (status != 0) {
		ALOGE("%s: failed to get output configurations from config reader with ErrorCode %s",
		__FUNCTION__, SharedSessionConfigUtils::toString(status));
		return BAD_VALUE;
		}

		// ToDo: b/372321187 Hardcoding the shared session configuration. Update the code to
		// take these values from XML instead.
		std::vector<int64_t> sharedOutputConfigEntries;
		int64_t surfaceType1 = OutputConfiguration::SURFACE_TYPE_IMAGE_READER;
		int64_t width = 1920;
		int64_t height = 1080;
		int64_t format1 = HAL_PIXEL_FORMAT_RGBA_8888;
		int64_t mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO;
		int64_t timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT;
		int64_t usage1 = 3;
		int64_t dataspace = 0;
		int64_t useReadoutTimestamp = 0;
		int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT;
		int64_t physicalCamIdLen = 0;

		// Stream 1 configuration hardcoded
		sharedOutputConfigEntries.push_back(surfaceType1);
		sharedOutputConfigEntries.push_back(width);
		sharedOutputConfigEntries.push_back(height);
		sharedOutputConfigEntries.push_back(format1);
		sharedOutputConfigEntries.push_back(mirrorMode);
		sharedOutputConfigEntries.push_back(useReadoutTimestamp);
		sharedOutputConfigEntries.push_back(timestampBase);
		sharedOutputConfigEntries.push_back(dataspace);
		sharedOutputConfigEntries.push_back(usage1);
		sharedOutputConfigEntries.push_back(streamUseCase);
		sharedOutputConfigEntries.push_back(physicalCamIdLen);

		// Stream 2 configuration hardcoded
		int64_t surfaceType2 = OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW;
		int64_t format2 = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
		int64_t usage2 = GraphicBuffer::USAGE_HW_TEXTURE \| GraphicBuffer::USAGE_HW_COMPOSER;

		sharedOutputConfigEntries.push_back(surfaceType2);
		sharedOutputConfigEntries.push_back(width);
		sharedOutputConfigEntries.push_back(height);
		sharedOutputConfigEntries.push_back(format2);
		sharedOutputConfigEntries.push_back(mirrorMode);
		sharedOutputConfigEntries.push_back(useReadoutTimestamp);
		sharedOutputConfigEntries.push_back(timestampBase);
		sharedOutputConfigEntries.push_back(dataspace);
		sharedOutputConfigEntries.push_back(usage2);
		sharedOutputConfigEntries.push_back(streamUseCase);
		sharedOutputConfigEntries.push_back(physicalCamIdLen);

		for (auto outputConfig : outputConfigurations) {
		sharedOutputConfigEntries.push_back(outputConfig.surfaceType);
		sharedOutputConfigEntries.push_back(outputConfig.width);
		sharedOutputConfigEntries.push_back(outputConfig.height);
		sharedOutputConfigEntries.push_back(outputConfig.format);
		sharedOutputConfigEntries.push_back(outputConfig.mirrorMode);
		sharedOutputConfigEntries.push_back(outputConfig.useReadoutTimestamp);
		sharedOutputConfigEntries.push_back(outputConfig.timestampBase);
		sharedOutputConfigEntries.push_back(outputConfig.dataSpace);
		sharedOutputConfigEntries.push_back(outputConfig.usage);
		sharedOutputConfigEntries.push_back(outputConfig.streamUseCase);
		if (strcmp(outputConfig.physicalCameraId.c_str(), "")) {
		sharedOutputConfigEntries.push_back(outputConfig.physicalCameraId.length());
		for (char c : outputConfig.physicalCameraId) {
		sharedOutputConfigEntries.push_back(c);
		}
		} else {
		sharedOutputConfigEntries.push_back(/* physical camera id len */ 0);
		}
		}

		res = c.update(sharedOutputConfigurationsTag, sharedOutputConfigEntries.data(),
		sharedOutputConfigEntries.size());

services/camera/libcameraservice/common/CameraProviderManager.h

+3 −1

Original line number	Diff line number	Diff line
		@@ -44,6 +44,8 @@
		#include <binder/IServiceManager.h>
		#include <camera/VendorTagDescriptor.h>

		#include "config/SharedSessionConfigUtils.h"

		namespace android {

		using hardware::camera2::utils::CameraIdAndSessionConfiguration;
		@@ -782,7 +784,7 @@ private:
		status_t addColorCorrectionAvailableModesTag(CameraMetadata& ch);
		status_t addAePriorityModeTags();
		status_t addSessionConfigQueryVersionTag();
		status_t addSharedSessionConfigurationTags();
		status_t addSharedSessionConfigurationTags(const std::string &cameraId);
		bool isAutomotiveDevice();

		static void getSupportedSizes(const CameraMetadata& ch, uint32_t tag,

services/camera/libcameraservice/common/aidl/AidlProviderInfo.cpp

+5 −2

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@

		#include "device3/DistortionMapper.h"
		#include "device3/ZoomRatioMapper.h"
		#include <filesystem>
		#include <utils/AttributionAndPermissionUtils.h>
		#include <utils/SessionConfigurationUtils.h>
		#include <utils/Trace.h>
		@@ -740,8 +741,10 @@ AidlProviderInfo::AidlDeviceInfo3::AidlDeviceInfo3(
		{ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, ANDROID_CONTROL_AE_TARGET_FPS_RANGE});
		}

		if (flags::camera_multi_client() && isAutomotiveDevice()) {
		addSharedSessionConfigurationTags();
		std::filesystem::path sharedSessionConfigFilePath =
		std::string(SHARED_SESSION_FILE_PATH) + std::string(SHARED_SESSION_FILE_NAME);
		if (flags::camera_multi_client() && std::filesystem::exists(sharedSessionConfigFilePath)) {
		addSharedSessionConfigurationTags(id);
		}

		if (!kEnableLazyHal) {

services/camera/libcameraservice/config/SharedSessionConfigReader.cpp

0 → 100644

+239 −0

Original line number	Diff line number	Diff line
		//
		// Copyright 2024 The Android Open Source Project
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		//

		#define LOG_TAG "SharedSessionConfigReader"

		#include "SharedSessionConfigReader.h"

		#include <fstream>
		#include <utils/Log.h>

		using tinyxml2::XML_SUCCESS;
		using tinyxml2::XMLDocument;
		namespace android {

		ErrorCode SharedSessionConfigReader::parseSharedSessionConfig(
		const char* sharedSessionConfigFilePath) {
		if (!mCameraIdToSharedSessionConfigs.empty()) {
		ALOGV("mCameraIdToSharedSessionConfigs already initialized.");
		return ErrorCode::STATUS_OK;
		}

		XMLDocument xmlDoc;

		// load and parse the configuration file
		xmlDoc.LoadFile(sharedSessionConfigFilePath);
		if (xmlDoc.ErrorID() != XML_SUCCESS) {
		ALOGE("%s: Failed to load/parse the configuration file: %s, with error: %s", __FUNCTION__,
		sharedSessionConfigFilePath, xmlDoc.ErrorStr());
		return ErrorCode::ERROR_READ_CONFIG_FILE;
		}

		ErrorCode status = parseSharedSessionConfigFromXMLDocument(xmlDoc);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: Error while parsing XML elements of file at: %s", __FUNCTION__,
		sharedSessionConfigFilePath);
		return status;
		}

		return ErrorCode::STATUS_OK;
		}

		ErrorCode SharedSessionConfigReader::parseSharedSessionConfigFromXMLDocument(
		const XMLDocument& xmlDoc) {
		const XMLElement* rootElem = xmlDoc.RootElement();
		if (strcmp(rootElem->Name(), "SharedCameraSessionConfigurations")) {
		ALOGE("%s: Expected root element to be 'SharedCameraSessionConfigurations'. Instead got %s",
		__FUNCTION__, rootElem->Name());
		return ErrorCode::ERROR_READ_CONFIG_FILE;
		}

		ErrorCode status;
		const char* colorSpaceStr = rootElem->Attribute("colorSpace");
		status = SharedSessionConfigUtils::getColorSpaceFromStr(colorSpaceStr, &mColorSpace);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getColorSpaceFromStr has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		std::unordered_map<std::string, std::vector<SharedSessionConfig>>
		cameraIdToSharedSessionConfigs;

		for (const XMLElement* sharedConfigElem =
		rootElem->FirstChildElement("SharedCameraSessionConfiguration");
		sharedConfigElem != nullptr;
		sharedConfigElem =
		sharedConfigElem->NextSiblingElement("SharedCameraSessionConfiguration")) {

		const char* cameraId = sharedConfigElem->Attribute("cameraId");
		if (cameraId == nullptr \|\| !strcmp(cameraId, "")) {
		ALOGE("%s: cameraId attribute is empty", __FUNCTION__);
		return ErrorCode::ERROR_CONFIG_FILE_FORMAT;
		}

		for (const XMLElement* outputConfigElem =
		sharedConfigElem->FirstChildElement("OutputConfiguration");
		outputConfigElem != nullptr;
		outputConfigElem = outputConfigElem->NextSiblingElement("OutputConfiguration")) {
		int64_t surfaceType;
		const XMLElement* surfaceTypeXml = outputConfigElem->FirstChildElement("surfaceType");
		status = SharedSessionConfigUtils::getSurfaceTypeFromXml(surfaceTypeXml, &surfaceType);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getSurfaceTypeFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t width;
		const XMLElement* widthXml = outputConfigElem->FirstChildElement("width");
		status = SharedSessionConfigUtils::getWidthFromXml(widthXml, &width);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getWidthFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t height;
		const XMLElement* heightXml = outputConfigElem->FirstChildElement("height");
		status = SharedSessionConfigUtils::getHeightFromXml(heightXml, &height);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getHeightFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		std::string physicalCameraId;
		const XMLElement* physicalCameraIdXml =
		outputConfigElem->FirstChildElement("physicalCameraId");
		status = SharedSessionConfigUtils::getPhysicalCameraIdFromXml(physicalCameraIdXml,
		&physicalCameraId);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getPhysicalCameraIdFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t streamUseCase;
		const XMLElement* streamUseCaseXml =
		outputConfigElem->FirstChildElement("streamUseCase");
		status = SharedSessionConfigUtils::getStreamUseCaseFromXml(streamUseCaseXml,
		&streamUseCase);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getStreamUseCaseFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t timestampBase;
		const XMLElement* timestampBaseXml =
		outputConfigElem->FirstChildElement("timestampBase");
		status = SharedSessionConfigUtils::getTimestampBaseFromXml(timestampBaseXml,
		&timestampBase);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getTimestampBaseFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t mirrorMode;
		const XMLElement* mirrorModeXml = outputConfigElem->FirstChildElement("mirrorMode");
		status = SharedSessionConfigUtils::getMirrorModeFromXml(mirrorModeXml, &mirrorMode);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getMirrorModeFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		bool useReadoutTimestamp;
		const XMLElement* useReadoutTimestampXml =
		outputConfigElem->FirstChildElement("useReadoutTimestamp");
		status = SharedSessionConfigUtils::getUseReadoutTimestampFromXml(useReadoutTimestampXml,
		&useReadoutTimestamp);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getUseReadoutTimestampFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t format;
		const XMLElement* formatXml = outputConfigElem->FirstChildElement("format");
		status = SharedSessionConfigUtils::getFormatFromXml(formatXml, &format, surfaceType);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getFormatFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t usage;
		const XMLElement* usageXml = outputConfigElem->FirstChildElement("usage");
		status = SharedSessionConfigUtils::getUsageFromXml(usageXml, &usage, surfaceType);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getUsageFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		int64_t dataSpace;
		const XMLElement* dataSpaceXml = outputConfigElem->FirstChildElement("dataSpace");
		status = SharedSessionConfigUtils::getDataSpaceFromXml(dataSpaceXml, &dataSpace);
		if (status != ErrorCode::STATUS_OK) {
		ALOGE("%s: getUsageFromXml has returned an error: %s", __FUNCTION__,
		SharedSessionConfigUtils::toString(status));
		return status;
		}

		cameraIdToSharedSessionConfigs[cameraId].push_back(
		SharedSessionConfig{surfaceType, width, height, physicalCameraId, streamUseCase,
		timestampBase, mirrorMode, useReadoutTimestamp, format,
		usage, dataSpace});
		}
		}

		if (cameraIdToSharedSessionConfigs.empty()) {
		ALOGE("%s: No elements with tag 'SharedCameraSessionConfiguration' in file", __FUNCTION__);
		return ErrorCode::ERROR_CONFIG_FILE_FORMAT;
		}

		mCameraIdToSharedSessionConfigs = cameraIdToSharedSessionConfigs;
		return ErrorCode::STATUS_OK;
		}

		ErrorCode SharedSessionConfigReader::getColorSpace(/* out / int32_t colorSpace) {
		*colorSpace = mColorSpace;
		return ErrorCode::STATUS_OK;
		}

		// Returns the cameraConfig parameters.
		ErrorCode SharedSessionConfigReader::getAvailableSharedSessionConfigs(
		const char* cameraId, /* out / std::vector<SharedSessionConfig> availableConfigurations) {
		if (mCameraIdToSharedSessionConfigs.empty()) {
		ALOGE("%s: mCameraIdToSharedSessionConfigs is empty. Call initialize() first.",
		__FUNCTION__);
		return ErrorCode::ERROR_CONFIG_READER_UNINITIALIZED;
		}

		if (!mCameraIdToSharedSessionConfigs.contains(cameraId)) {
		ALOGE("%s: cameraId: %s not found in mCameraIdToSharedSessionConfigs.", __FUNCTION__,
		cameraId);
		return ErrorCode::ERROR_BAD_PARAMETER;
		}

		*availableConfigurations = mCameraIdToSharedSessionConfigs[cameraId];
		return ErrorCode::STATUS_OK;
		}

		} // namespace android