Merge "Camera: Apply max batch size for high speed video" into main (4f490e22) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/common/CameraProviderManager.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -86,6 +86,7 @@ enum SystemCameraKind {
		};

		#define CAMERA_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0)
		#define CAMERA_DEVICE_API_VERSION_1_2 HARDWARE_DEVICE_API_VERSION(1, 2)
		#define CAMERA_DEVICE_API_VERSION_3_0 HARDWARE_DEVICE_API_VERSION(3, 0)
		#define CAMERA_DEVICE_API_VERSION_3_1 HARDWARE_DEVICE_API_VERSION(3, 1)
		#define CAMERA_DEVICE_API_VERSION_3_2 HARDWARE_DEVICE_API_VERSION(3, 2)

services/camera/libcameraservice/device3/Camera3Device.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@
		#include <cutils/properties.h>
		#include <camera/StringUtils.h>

		#include <android-base/properties.h>
		#include <android/hardware/camera/device/3.7/ICameraInjectionSession.h>
		#include <android/hardware/camera2/ICameraDeviceUser.h>

		@@ -749,8 +750,7 @@ status_t Camera3Device::convertMetadataListToRequestListLocked(
		auto firstRequest = requestList->begin();
		for (auto& outputStream : (*firstRequest)->mOutputStreams) {
		if (outputStream->isVideoStream()) {
		(*firstRequest)->mBatchSize = requestList->size();
		outputStream->setBatchSize(requestList->size());
		applyMaxBatchSizeLocked(requestList, outputStream);
		break;
		}
		}

services/camera/libcameraservice/device3/Camera3Device.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -655,6 +655,15 @@ class Camera3Device :
		*/
		status_t initializeCommonLocked();

		/**
		* Update capture request list so that each batch size honors the batch_size_max report from
		* the HAL. Set the batch size to output stream for buffer operations.
		*
		* Must be called with mLock held.
		*/
		virtual void applyMaxBatchSizeLocked(
		RequestList* requestList, const sp<camera3::Camera3OutputStreamInterface>& stream) = 0;

		/**
		* Get the last request submitted to the hal by the request thread.
		*

services/camera/libcameraservice/device3/aidl/AidlCamera3Device.cpp

+75 −0

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

		#include <aidl/android/hardware/camera/device/ICameraInjectionSession.h>
		#include <aidlcommonsupport/NativeHandle.h>
		#include <android-base/properties.h>
		#include <android/binder_ibinder_platform.h>
		#include <android/hardware/camera2/ICameraDeviceUser.h>
		#include <camera/StringUtils.h>
		@@ -309,6 +310,20 @@ status_t AidlCamera3Device::initialize(sp<CameraProviderManager> manager,
		}
		}

		// batch size limit is applied to the device with camera device version larger than 3.2 which is
		// AIDL v2
		hardware::hidl_version maxVersion{0, 0};
		IPCTransport transport = IPCTransport::AIDL;
		res = manager->getHighestSupportedVersion(mId, &maxVersion, &transport);
		if (res != OK) {
		ALOGE("%s: Error in getting camera device version id: %s (%d)", __FUNCTION__,
		strerror(-res), res);
		return res;
		}
		int deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());

		mBatchSizeLimitEnabled = (deviceVersion >= CAMERA_DEVICE_API_VERSION_1_2);

		return initializeCommonLocked();
		}

		@@ -1572,6 +1587,66 @@ status_t AidlCamera3Device::AidlCamera3DeviceInjectionMethods::replaceHalInterfa
		return OK;
		}

		void AidlCamera3Device::applyMaxBatchSizeLocked(
		RequestList* requestList, const sp<camera3::Camera3OutputStreamInterface>& stream) {
		int batchSize = requestList->size();

		if (!mBatchSizeLimitEnabled) {
		(*requestList->begin())->mBatchSize = batchSize;
		stream->setBatchSize(batchSize);
		return;
		}

		const auto& metadata = (*requestList->begin())->mSettingsList.begin()->metadata;

		uint32_t tag = ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS;
		auto sensorPixelModeEntry = metadata.find(ANDROID_SENSOR_PIXEL_MODE);
		if (sensorPixelModeEntry.count != 0) {
		if (ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION == sensorPixelModeEntry.data.u8[0]) {
		tag = ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION;
		}
		}

		const auto fpsRange = metadata.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE);
		if (fpsRange.count > 1) {
		auto configEntry = mDeviceInfo.find(tag);
		for (size_t index = 4; index < configEntry.count; index += 5) {
		if (stream->getWidth() == static_cast<uint32_t>(configEntry.data.i32[index - 4]) &&
		stream->getHeight() == static_cast<uint32_t>(configEntry.data.i32[index - 3]) &&
		fpsRange.data.i32[0] == configEntry.data.i32[index - 2] &&
		fpsRange.data.i32[1] == configEntry.data.i32[index - 1]) {
		const int maxBatchSize = configEntry.data.i32[index - 1] / 30;
		const int reportedSize = configEntry.data.i32[index];

		if (maxBatchSize % reportedSize == 0 && requestList->size() % reportedSize == 0) {
		batchSize = reportedSize;
		ALOGVV("Matching high speed configuration found. Limit batch size to %d",
		batchSize);
		} else if (maxBatchSize % reportedSize == 0 &&
		reportedSize % requestList->size() == 0) {
		ALOGVV("Matching high speed configuration found, but requested batch size is "
		"divisor of batch_size_max. No need to limit batch size.");
		} else {
		ALOGW("Matching high speed configuration found, but batch_size_max is not a "
		"divisor of corresponding fps_max/30 or requested batch size is not a "
		"divisor of batch_size_max, (fps_max %d, batch_size_max %d, requested "
		"batch size %zu)",
		configEntry.data.i32[index - 1], reportedSize, requestList->size());
		}
		break;
		}
		}
		}

		for (auto request = requestList->begin(); request != requestList->end(); request++) {
		if (requestList->distance(requestList->begin(), request) % batchSize == 0) {
		(*request)->mBatchSize = batchSize;
		}
		}

		stream->setBatchSize(batchSize);
		}

		status_t AidlCamera3Device::injectionCameraInitialize(const std::string &injectedCamId,
		sp<CameraProviderManager> manager) {
		return (static_cast<AidlCamera3DeviceInjectionMethods *>

services/camera/libcameraservice/device3/aidl/AidlCamera3Device.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -252,6 +252,10 @@ class AidlCamera3Device :
		};

		private:
		virtual void applyMaxBatchSizeLocked(
		RequestList* requestList,
		const sp<camera3::Camera3OutputStreamInterface>& stream) override;

		virtual status_t injectionCameraInitialize(const std::string &injectCamId,
		sp<CameraProviderManager> manager) override;

		@@ -271,6 +275,9 @@ class AidlCamera3Device :

		std::shared_ptr<AidlCameraDeviceCallbacks> mCallbacks = nullptr;

		// Whether the batch_size_max field in the high speed configuration actually applied to
		// capture requests.
		bool mBatchSizeLimitEnabled = false;

		}; // class AidlCamera3Device