[libcamera-devel,v7,1/9] android: camera_device: Add missing static metadata
diff mbox series

Message ID 20190905210940.32358-2-jacopo@jmondi.org
State Accepted
Headers show
Series
  • android: Rework metadata tags
Related show

Commit Message

Jacopo Mondi Sept. 5, 2019, 9:09 p.m. UTC 
Add all the static metadata keys part of the BC (backward compatible)
metadata group, which represent the minimum requirement for devices
supporting the LIMITED hardware level.

Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Jacopo Mondi <jacopo@jmondi.org>
---
 src/android/camera_device.cpp | 272 +++++++++++++++++++++++++++++++---
 1 file changed, 248 insertions(+), 24 deletions(-)

Patch
diff mbox series 

diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
index c27175ac090d..15f57a7fe731 100644
--- a/src/android/camera_device.cpp
+++ b/src/android/camera_device.cpp
@@ -134,6 +134,149 @@  camera_metadata_t *CameraDevice::getStaticMetadata()
 	staticMetadata_ = allocate_camera_metadata(STATIC_ENTRY_CAP,
 						   STATIC_DATA_CAP);
 
+	/* Color correction static metadata. */
+	std::vector<uint8_t> aberrationModes = {
+		ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
+			aberrationModes.data(), aberrationModes.size());
+	METADATA_ASSERT(ret);
+
+	/* Control static metadata. */
+	std::vector<uint8_t> aeAvailableAntiBandingModes = {
+		ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
+		ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ,
+		ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ,
+		ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
+			aeAvailableAntiBandingModes.data(),
+			aeAvailableAntiBandingModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> aeAvailableModes = {
+		ANDROID_CONTROL_AE_MODE_ON,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_AVAILABLE_MODES,
+			aeAvailableModes.data(), aeAvailableModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<int32_t> availableAeFpsTarget = {
+		15, 30,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
+			availableAeFpsTarget.data(),
+			availableAeFpsTarget.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<int32_t> aeCompensationRange = {
+		0, 0,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_COMPENSATION_RANGE,
+			aeCompensationRange.data(),
+			aeCompensationRange.size());
+	METADATA_ASSERT(ret);
+
+	const camera_metadata_rational_t aeCompensationStep[] = {
+		{ 0, 1 }
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_COMPENSATION_STEP,
+			aeCompensationStep, 1);
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableAfModes = {
+		ANDROID_CONTROL_AF_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AF_AVAILABLE_MODES,
+			availableAfModes.data(), availableAfModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableEffects = {
+		ANDROID_CONTROL_EFFECT_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AVAILABLE_EFFECTS,
+			availableEffects.data(), availableEffects.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableSceneModes = {
+		ANDROID_CONTROL_SCENE_MODE_DISABLED,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
+			availableSceneModes.data(), availableSceneModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableStabilizationModes = {
+		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
+			availableStabilizationModes.data(),
+			availableStabilizationModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableAwbModes = {
+		ANDROID_CONTROL_AWB_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AWB_AVAILABLE_MODES,
+			availableAwbModes.data(), availableAwbModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<int32_t> availableMaxRegions = {
+		0, 0, 0,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_MAX_REGIONS,
+			availableMaxRegions.data(), availableMaxRegions.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> sceneModesOverride = {
+		ANDROID_CONTROL_AE_MODE_ON,
+		ANDROID_CONTROL_AWB_MODE_AUTO,
+		ANDROID_CONTROL_AF_MODE_AUTO,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
+			sceneModesOverride.data(), sceneModesOverride.size());
+	METADATA_ASSERT(ret);
+
+	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AE_LOCK_AVAILABLE,
+			&aeLockAvailable, 1);
+	METADATA_ASSERT(ret);
+
+	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
+			&awbLockAvailable, 1);
+	METADATA_ASSERT(ret);
+
+	char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_CONTROL_AVAILABLE_MODES,
+			&availableControlModes, 1);
+	METADATA_ASSERT(ret);
+
+	/* JPEG static metadata. */
+	std::vector<int32_t> availableThumbnailSizes = {
+		0, 0,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
+			availableThumbnailSizes.data(),
+			availableThumbnailSizes.size());
+	METADATA_ASSERT(ret);
+
 	/* Sensor static metadata. */
 	int32_t pixelArraySize[] = {
 		2592, 1944,
@@ -179,6 +322,47 @@  camera_metadata_t *CameraDevice::getStaticMetadata()
 				&orientation, 1);
 	METADATA_ASSERT(ret);
 
+	std::vector<int32_t> testPatterModes = {
+		ANDROID_SENSOR_TEST_PATTERN_MODE_OFF,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+				ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
+				testPatterModes.data(), testPatterModes.size());
+	METADATA_ASSERT(ret);
+
+	std::vector<float> physicalSize = {
+		2592, 1944,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+				ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
+				physicalSize.data(), physicalSize.size());
+	METADATA_ASSERT(ret);
+
+	uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
+			&timestampSource, 1);
+	METADATA_ASSERT(ret);
+
+	/* Statistics static metadata. */
+	uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
+			&faceDetectMode, 1);
+	METADATA_ASSERT(ret);
+
+	int32_t maxFaceCount = 0;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
+			&maxFaceCount, 1);
+	METADATA_ASSERT(ret);
+
+	/* Sync static metadata. */
+	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1);
+	METADATA_ASSERT(ret);
+
 	/* Flash static metadata. */
 	char flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE;
 	ret = add_camera_metadata_entry(staticMetadata_,
@@ -187,50 +371,63 @@  camera_metadata_t *CameraDevice::getStaticMetadata()
 	METADATA_ASSERT(ret);
 
 	/* Lens static metadata. */
-	float fn = 2.53 / 100;
+	std::vector<float> lensApertures = {
+		2.53 / 100,
+	};
 	ret = add_camera_metadata_entry(staticMetadata_,
-				ANDROID_LENS_INFO_AVAILABLE_APERTURES, &fn, 1);
+				ANDROID_LENS_INFO_AVAILABLE_APERTURES,
+				lensApertures.data(), lensApertures.size());
 	METADATA_ASSERT(ret);
 
-	/* Control metadata. */
-	char controlMetadata = ANDROID_CONTROL_MODE_AUTO;
+	uint8_t lensFacing = ANDROID_LENS_FACING_FRONT;
 	ret = add_camera_metadata_entry(staticMetadata_,
-			ANDROID_CONTROL_AVAILABLE_MODES,
-			&controlMetadata, 1);
+				ANDROID_LENS_FACING, &lensFacing, 1);
 	METADATA_ASSERT(ret);
 
-	char availableAntiBandingModes[] = {
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
+	std::vector<float> lensFocalLenghts = {
+		1,
 	};
 	ret = add_camera_metadata_entry(staticMetadata_,
-			ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-			availableAntiBandingModes, 4);
+				ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
+				lensFocalLenghts.data(),
+				lensFocalLenghts.size());
 	METADATA_ASSERT(ret);
 
-	char aeAvailableModes[] = {
-		ANDROID_CONTROL_AE_MODE_ON,
-		ANDROID_CONTROL_AE_MODE_OFF,
+	std::vector<uint8_t> opticalStabilizations = {
+		ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF,
 	};
 	ret = add_camera_metadata_entry(staticMetadata_,
-			ANDROID_CONTROL_AE_AVAILABLE_MODES,
-			aeAvailableModes, 2);
+				ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
+				opticalStabilizations.data(),
+				opticalStabilizations.size());
 	METADATA_ASSERT(ret);
 
-	controlMetadata = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
+	float hypeFocalDistance = 0;
 	ret = add_camera_metadata_entry(staticMetadata_,
-			ANDROID_CONTROL_AE_LOCK_AVAILABLE,
-			&controlMetadata, 1);
+				ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
+				&hypeFocalDistance, 1);
 	METADATA_ASSERT(ret);
 
-	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
+	float minFocusDistance = 0;
 	ret = add_camera_metadata_entry(staticMetadata_,
-			ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
-			&awbLockAvailable, 1);
+				ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
+				&minFocusDistance, 1);
+	METADATA_ASSERT(ret);
+
+	/* Noise reduction modes. */
+	uint8_t noiseReductionModes = ANDROID_NOISE_REDUCTION_MODE_OFF;
+	ret = add_camera_metadata_entry(staticMetadata_,
+				ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
+				&noiseReductionModes, 1);
+	METADATA_ASSERT(ret);
 
 	/* Scaler static metadata. */
+	float maxDigitalZoom = 1;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
+			&maxDigitalZoom, 1);
+	METADATA_ASSERT(ret);
+
 	std::vector<uint32_t> availableStreamFormats = {
 		ANDROID_SCALER_AVAILABLE_FORMATS_BLOB,
 		ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888,
@@ -275,12 +472,39 @@  camera_metadata_t *CameraDevice::getStaticMetadata()
 			minFrameDurations.data(), minFrameDurations.size());
 	METADATA_ASSERT(ret);
 
+	uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1);
+	METADATA_ASSERT(ret);
+
 	/* Info static metadata. */
 	uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
 	ret = add_camera_metadata_entry(staticMetadata_,
 			ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
 			&supportedHWLevel, 1);
 
+	/* Request static metadata. */
+	int32_t partialResultCount = 1;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
+			&partialResultCount, 1);
+	METADATA_ASSERT(ret);
+
+	uint8_t maxPipelineDepth = 2;
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
+			&maxPipelineDepth, 1);
+	METADATA_ASSERT(ret);
+
+	std::vector<uint8_t> availableCapabilities = {
+		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
+	};
+	ret = add_camera_metadata_entry(staticMetadata_,
+			ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
+			availableCapabilities.data(),
+			availableCapabilities.size());
+	METADATA_ASSERT(ret);
+
 	return staticMetadata_;
 }