[libcamera-devel,RFC,v2,05/12] android: camera_device: Set static metadata for FULL requirements
diff mbox series

Message ID 20210422094102.371772-6-paul.elder@ideasonboard.com
State Superseded
Delegated to: Paul Elder
Headers show
Series
  • FULL hardware level fixes
Related show

Commit Message

Paul Elder April 22, 2021, 9:40 a.m. UTC 
Set the static metadata as required by CTS for FULL hardware level.

The tests that this fixes are:
android.hardware.camera2.cts.StaticMetadataTest#testHwSupportedLevel

Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>

---
This patch actually introduces more failures in CTS, but that's because
we report that we support many more things in the static metadata.

The main thing I'm not sure of in this patch is if the entries in any
AVAILABLE_* tags require allocated space in the static metadata. Also
the android docs say that they need to be int32_t while CTS (and other
HAL implementations) say that they need to be uint8_t.
---
 src/android/camera_device.cpp | 148 +++++++++++++++++++++++++++++++---
 1 file changed, 139 insertions(+), 9 deletions(-)

Comments

Laurent Pinchart April 27, 2021, 4:44 a.m. UTC | #1 
Hi Paul,

Thank you for the patch.

On Thu, Apr 22, 2021 at 06:40:55PM +0900, Paul Elder wrote:
> Set the static metadata as required by CTS for FULL hardware level.
> 
> The tests that this fixes are:
> android.hardware.camera2.cts.StaticMetadataTest#testHwSupportedLevel
> 
> Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
> 
> ---
> This patch actually introduces more failures in CTS, but that's because
> we report that we support many more things in the static metadata.
> 
> The main thing I'm not sure of in this patch is if the entries in any
> AVAILABLE_* tags require allocated space in the static metadata. Also
> the android docs say that they need to be int32_t while CTS (and other
> HAL implementations) say that they need to be uint8_t.

Hiro, do you think you could get more information on this ?

> ---
>  src/android/camera_device.cpp | 148 +++++++++++++++++++++++++++++++---
>  1 file changed, 139 insertions(+), 9 deletions(-)
> 
> diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
> index a11ad848..7f0f8f1a 100644
> --- a/src/android/camera_device.cpp
> +++ b/src/android/camera_device.cpp
> @@ -776,10 +776,19 @@ std::tuple<uint32_t, uint32_t> CameraDevice::calculateStaticMetadataSize()
>  {
>  	/*
>  	 * \todo Keep this in sync with the actual number of entries.
> -	 * Currently: 54 entries, 874 bytes of static metadata
> +	 * Currently: 63 entries, 990 bytes of static metadata
>  	 */
> -	uint32_t numEntries = 54;
> -	uint32_t byteSize = 874;
> +	uint32_t numEntries = 63;
> +	uint32_t byteSize = 990;
> +
> +	// do i need to add for entries in the available keys?
> +	// +1, +4 for EDGE_AVAILABLE_EDGE_MODES
> +	// +1, +4 for LENS_INFO_AVAILABLE_FILTER_DENSITIES
> +	// +1, +4 for BLACK_LEVEL_PATTERN
> +	// +1, +4 for TONEMAP_AVAILABLE_TONE_MAP_MODES
> +	// +1, +4 for TONEMAP_MAX_CURVE_POINTS
> +
> +	// +36 for new request keys

C-style comments.

A question for Jacopo maybe ?

I think it's time to bite the bullet and stop computing sizes manually.

>  
>  	/*
>  	 * Calculate space occupation in bytes for dynamically built metadata
> @@ -861,7 +870,9 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  aeAvailableAntiBandingModes.data(),
>  				  aeAvailableAntiBandingModes.size());
>  
> +	/* \todo FULL requires OFF */
>  	std::vector<uint8_t> aeAvailableModes = {
> +		ANDROID_CONTROL_AE_MODE_OFF,
>  		ANDROID_CONTROL_AE_MODE_ON,
>  	};

This needs to be plumbed to the pipeline handler, and made conditional
on a property. Same in several locations below I suppose. We can't
hardcode metadata for FULL mode only, we need to make sure we can
support LIMITED mode devices.

>  	staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES,
> @@ -958,9 +969,11 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  
>  	/*
>  	 * \todo Inspect the Camera capabilities to report the available
> -	 * AWB modes. Default to AUTO as CTS tests require it.
> +	 * AWB modes. Default to AUTO as CTS tests require it. FULL requires
> +	 * OFF.
>  	 */
>  	std::vector<uint8_t> availableAwbModes = {
> +		ANDROID_CONTROL_AWB_MODE_OFF,
>  		ANDROID_CONTROL_AWB_MODE_AUTO,
>  	};
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
> @@ -983,17 +996,32 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  sceneModesOverride.data(),
>  				  sceneModesOverride.size());
>  
> -	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
> +	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
> +	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
>  				  &aeLockAvailable, 1);
>  
> -	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
> +	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
> +	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
>  				  &awbLockAvailable, 1);
>  
>  	char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES,
>  				  &availableControlModes, 1);
> +	/*
> +	 * FULL - always support OFF
> +	 * camera devices that support YUV_REPROCESSING or PRIVATE_REPROCESSING - ZERO_SHUTTER_LAG
> +	 * all devices will list FAST
> +	 */
> +	std::vector<uint8_t> availableEdgeModes = {
> +		ANDROID_EDGE_MODE_OFF,
> +		ANDROID_EDGE_MODE_FAST,
> +		ANDROID_EDGE_MODE_HIGH_QUALITY,
> +	};
> +	staticMetadata_->addEntry(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
> +				  availableEdgeModes.data(),
> +				  availableEdgeModes.size());
>  
>  	/* JPEG static metadata. */
>  
> @@ -1079,10 +1107,20 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  			exposureInfo->second.min().get<int32_t>() * 1000LL,
>  			exposureInfo->second.max().get<int32_t>() * 1000LL,
>  		};
> +		/* min must be at most 100us, max at least 100ms */
> +		if (exposureTimeRange[0] > 100000)
> +			exposureTimeRange[0] = 100000;
> +		if (exposureTimeRange[1] < 100000000)
> +			exposureTimeRange[1] = 100000000;
>  		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
>  					  &exposureTimeRange, 2);
>  	}
>  
> +	/* min at most 100, max at least 800 */
> +	int32_t maxAnalogSensitivity = 800;
> +	staticMetadata_->addEntry(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
> +				  &maxAnalogSensitivity, 1);
> +
>  	staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, &orientation_, 1);
>  
>  	std::vector<int32_t> testPatterModes = {
> @@ -1092,6 +1130,21 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  testPatterModes.data(),
>  				  testPatterModes.size());
>  
> +	/*
> +	 * required for FULL (docs don't say it is, but cts says it is)
> +	 * \todo figure out how this works
> +	 */
> +	std::vector<int32_t> blackLevelPattern = { 0, 0, 0, 0 };
> +	staticMetadata_->addEntry(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
> +				  blackLevelPattern.data(),
> +				  blackLevelPattern.size());
> +
> +	/* range of valid values: > 255 (8-bit output) */
> +	/* this xnor BLACK_LEVEL_PATTERN must be available */
> +	int32_t whiteLevel = 256;
> +	staticMetadata_->addEntry(ANDROID_SENSOR_INFO_WHITE_LEVEL,
> +				  &whiteLevel, 1);
> +
>  	std::vector<float> physicalSize = {
>  		2592, 1944,
>  	};
> @@ -1131,7 +1184,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	}
>  
>  	/* Sync static metadata. */
> -	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
> +	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;
>  	staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1);
>  
>  	/* Flash static metadata. */
> @@ -1147,6 +1200,15 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  lensApertures.data(),
>  				  lensApertures.size());
>  
> +	/*
> +	 * Required for FULL
> +	 * \todo get this information from the camera, in ascending order
> +	 */
> +	std::vector<float> availableFilterDensities = { 0 };
> +	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
> +				  availableFilterDensities.data(),
> +				  availableFilterDensities.size());
> +
>  	uint8_t lensFacing;
>  	switch (facing_) {
>  	default:
> @@ -1176,6 +1238,11 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  opticalStabilizations.data(),
>  				  opticalStabilizations.size());
>  
> +	/* \todo set this based on camera capability */
> +	int distanceCalibration = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;
> +	staticMetadata_->addEntry(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
> +				  &distanceCalibration, 1);
> +
>  	float hypeFocalDistance = 0;
>  	staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
>  				  &hypeFocalDistance, 1);
> @@ -1188,12 +1255,18 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	{
>  		std::vector<uint8_t> data;
>  		data.reserve(5);
> +		/*
> +		 * \todo if this doesn't have OFF and FAST and HIGH_QUALITY
> +		 * then this camera does not support FULL
> +		 */
>  		const auto &infoMap = controlsInfo.find(&controls::draft::NoiseReductionMode);
>  		if (infoMap != controlsInfo.end()) {
>  			for (const auto &value : infoMap->second.values())
>  				data.push_back(value.get<int32_t>());
>  		} else {
>  			data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF);
> +			data.push_back(ANDROID_NOISE_REDUCTION_MODE_FAST);
> +			data.push_back(ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY);
>  		}
>  		staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
>  					  data.data(), data.size());
> @@ -1261,6 +1334,16 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
>  	staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1);
>  
> +	/* \todo figure out if this should be int32 as documented */
> +	std::vector<uint8_t> shadingAvailableModes = {
> +		ANDROID_SHADING_MODE_OFF,
> +		ANDROID_SHADING_MODE_FAST,
> +		ANDROID_SHADING_MODE_HIGH_QUALITY,
> +	};
> +	staticMetadata_->addEntry(ANDROID_SHADING_AVAILABLE_MODES,
> +				  shadingAvailableModes.data(),
> +				  shadingAvailableModes.size());
> +
>  	/* Info static metadata. */
>  	uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL;
>  	staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
> @@ -1288,6 +1371,10 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  
>  	std::vector<uint8_t> availableCapabilities = {
>  		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
>  	};
>  
>  	/* Report if camera supports RAW. */
> @@ -1306,7 +1393,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	}
>  
>  	/* Number of { RAW, YUV, JPEG } supported output streams */
> -	int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 };
> +	int32_t numOutStreams[] = { rawStreamAvailable, 3, 1 };
>  	staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
>  				  &numOutStreams, 3);
>  
> @@ -1314,6 +1401,29 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  availableCapabilities.data(),
>  				  availableCapabilities.size());
>  
> +	/*
> +	 * required for FULL
> +	 * at least one of the below mode combinations:
> +	 * - CONTRAST_CURVE, FAST, HIGH_QUALITY
> +	 * - GAMMA_VALUE, PRESET_CURVE, FAST, HIGH_QUALITY
> +	 */
> +	std::vector<uint8_t> availableTonemapModes = {
> +		ANDROID_TONEMAP_MODE_CONTRAST_CURVE,
> +		ANDROID_TONEMAP_MODE_FAST,
> +		ANDROID_TONEMAP_MODE_HIGH_QUALITY,
> +	};
> +	staticMetadata_->addEntry(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
> +				  availableTonemapModes.data(),
> +				  availableTonemapModes.size());
> +
> +	/*
> +	 * required for FULL
> +	 * \todo get from camera (camCapabilities[camId]->tonemapCurvePoints?)
> +	 */
> +	int32_t tonemapCurvePoints = 0;
> +	staticMetadata_->addEntry(ANDROID_TONEMAP_MAX_CURVE_POINTS,
> +				  &tonemapCurvePoints, 1);
> +
>  	std::vector<int32_t> availableCharacteristicsKeys = {
>  		ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
>  		ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
> @@ -1331,14 +1441,17 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
>  		ANDROID_CONTROL_MAX_REGIONS,
>  		ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
> +		ANDROID_EDGE_AVAILABLE_EDGE_MODES,
>  		ANDROID_FLASH_INFO_AVAILABLE,
>  		ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
>  		ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
>  		ANDROID_JPEG_MAX_SIZE,
>  		ANDROID_LENS_FACING,
>  		ANDROID_LENS_INFO_AVAILABLE_APERTURES,
> +		ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
>  		ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
>  		ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
> +		ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
>  		ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
>  		ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
>  		ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
> @@ -1353,6 +1466,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
>  		ANDROID_SCALER_CROPPING_TYPE,
>  		ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
> +		ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
>  		ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
>  		ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
>  		ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
> @@ -1361,17 +1475,25 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
>  		ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
>  		ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
> +		ANDROID_SENSOR_INFO_WHITE_LEVEL,
> +		ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
>  		ANDROID_SENSOR_ORIENTATION,
> +		ANDROID_SHADING_AVAILABLE_MODES,
>  		ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
>  		ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
>  		ANDROID_SYNC_MAX_LATENCY,
> +		ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
> +		ANDROID_TONEMAP_MAX_CURVE_POINTS,
>  	};
>  	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
>  				  availableCharacteristicsKeys.data(),
>  				  availableCharacteristicsKeys.size());
>  
>  	std::vector<int32_t> availableRequestKeys = {
> +		ANDROID_BLACK_LEVEL_LOCK,
>  		ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
> +		ANDROID_COLOR_CORRECTION_GAINS,
> +		ANDROID_COLOR_CORRECTION_TRANSFORM,
>  		ANDROID_CONTROL_AE_ANTIBANDING_MODE,
>  		ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
>  		ANDROID_CONTROL_AE_LOCK,
> @@ -1387,16 +1509,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_CONTROL_MODE,
>  		ANDROID_CONTROL_SCENE_MODE,
>  		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
> +		ANDROID_EDGE_MODE,
>  		ANDROID_FLASH_MODE,
>  		ANDROID_JPEG_ORIENTATION,
>  		ANDROID_JPEG_QUALITY,
>  		ANDROID_JPEG_THUMBNAIL_QUALITY,
>  		ANDROID_JPEG_THUMBNAIL_SIZE,
>  		ANDROID_LENS_APERTURE,
> +		ANDROID_LENS_FILTER_DENSITY,
>  		ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
>  		ANDROID_NOISE_REDUCTION_MODE,
>  		ANDROID_SCALER_CROP_REGION,
> -		ANDROID_STATISTICS_FACE_DETECT_MODE
> +		ANDROID_SENSOR_EXPOSURE_TIME,
> +		ANDROID_SENSOR_FRAME_DURATION,
> +		ANDROID_SENSOR_SENSITIVITY,
> +		ANDROID_SHADING_MODE,
> +		ANDROID_STATISTICS_FACE_DETECT_MODE,
> +		ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
> +		ANDROID_TONEMAP_MODE,
>  	};
>  	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
>  				  availableRequestKeys.data(),
Jacopo Mondi April 27, 2021, 8:15 a.m. UTC | #2 
Hi Paul,

On Thu, Apr 22, 2021 at 06:40:55PM +0900, Paul Elder wrote:
> Set the static metadata as required by CTS for FULL hardware level.
>
> The tests that this fixes are:
> android.hardware.camera2.cts.StaticMetadataTest#testHwSupportedLevel
>
> Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
>
> ---
> This patch actually introduces more failures in CTS, but that's because
> we report that we support many more things in the static metadata.
>
> The main thing I'm not sure of in this patch is if the entries in any
> AVAILABLE_* tags require allocated space in the static metadata. Also
> the android docs say that they need to be int32_t while CTS (and other
> HAL implementations) say that they need to be uint8_t.
> ---
>  src/android/camera_device.cpp | 148 +++++++++++++++++++++++++++++++---
>  1 file changed, 139 insertions(+), 9 deletions(-)
>
> diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
> index a11ad848..7f0f8f1a 100644
> --- a/src/android/camera_device.cpp
> +++ b/src/android/camera_device.cpp
> @@ -776,10 +776,19 @@ std::tuple<uint32_t, uint32_t> CameraDevice::calculateStaticMetadataSize()
>  {
>  	/*
>  	 * \todo Keep this in sync with the actual number of entries.
> -	 * Currently: 54 entries, 874 bytes of static metadata
> +	 * Currently: 63 entries, 990 bytes of static metadata
>  	 */
> -	uint32_t numEntries = 54;
> -	uint32_t byteSize = 874;
> +	uint32_t numEntries = 63;
> +	uint32_t byteSize = 990;
> +
> +	// do i need to add for entries in the available keys?
> +	// +1, +4 for EDGE_AVAILABLE_EDGE_MODES
> +	// +1, +4 for LENS_INFO_AVAILABLE_FILTER_DENSITIES
> +	// +1, +4 for BLACK_LEVEL_PATTERN
> +	// +1, +4 for TONEMAP_AVAILABLE_TONE_MAP_MODES
> +	// +1, +4 for TONEMAP_MAX_CURVE_POINTS

For each new tag you add in availableCharacteristicsKeys is +4, for
new value associated with an existing or a new tag, it depends which
type the tag accepts

I've not validated the above calculations yet


> +
> +	// +36 for new request keys
>
>  	/*
>  	 * Calculate space occupation in bytes for dynamically built metadata
> @@ -861,7 +870,9 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  aeAvailableAntiBandingModes.data(),
>  				  aeAvailableAntiBandingModes.size());
>
> +	/* \todo FULL requires OFF */
>  	std::vector<uint8_t> aeAvailableModes = {
> +		ANDROID_CONTROL_AE_MODE_OFF,

+1

>  		ANDROID_CONTROL_AE_MODE_ON,
>  	};
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES,
> @@ -958,9 +969,11 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>
>  	/*
>  	 * \todo Inspect the Camera capabilities to report the available
> -	 * AWB modes. Default to AUTO as CTS tests require it.
> +	 * AWB modes. Default to AUTO as CTS tests require it. FULL requires
> +	 * OFF.
>  	 */
>  	std::vector<uint8_t> availableAwbModes = {
> +		ANDROID_CONTROL_AWB_MODE_OFF,

+1

I wonder if it is correct to make this unconditional.
The drawback is that it requires an IPA and requires the PH to
register property correctly. If for the IPU3 we have that, I would
fetch this information from the Camera.

>  		ANDROID_CONTROL_AWB_MODE_AUTO,
>  	};
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
> @@ -983,17 +996,32 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  sceneModesOverride.data(),
>  				  sceneModesOverride.size());
>
> -	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
> +	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
> +	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
>  				  &aeLockAvailable, 1);

Again, should this come from the camera ?

>
> -	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
> +	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
> +	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
>  				  &awbLockAvailable, 1);

ditto

>
>  	char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
>  	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES,
>  				  &availableControlModes, 1);
> +	/*
> +	 * FULL - always support OFF
> +	 * camera devices that support YUV_REPROCESSING or PRIVATE_REPROCESSING - ZERO_SHUTTER_LAG
> +	 * all devices will list FAST
> +	 */
> +	std::vector<uint8_t> availableEdgeModes = {
> +		ANDROID_EDGE_MODE_OFF,
> +		ANDROID_EDGE_MODE_FAST,
> +		ANDROID_EDGE_MODE_HIGH_QUALITY,
> +	};

+3

> +	staticMetadata_->addEntry(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
> +				  availableEdgeModes.data(),
> +				  availableEdgeModes.size());

Edging I'm not sure we have it from Camera

>
>  	/* JPEG static metadata. */
>
> @@ -1079,10 +1107,20 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  			exposureInfo->second.min().get<int32_t>() * 1000LL,
>  			exposureInfo->second.max().get<int32_t>() * 1000LL,
>  		};
> +		/* min must be at most 100us, max at least 100ms */
> +		if (exposureTimeRange[0] > 100000)
> +			exposureTimeRange[0] = 100000;
> +		if (exposureTimeRange[1] < 100000000)
> +			exposureTimeRange[1] = 100000000;

Underated and probably worth a separate patch ?

>  		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
>  					  &exposureTimeRange, 2);
>  	}
>
> +	/* min at most 100, max at least 800 */
> +	int32_t maxAnalogSensitivity = 800;
> +	staticMetadata_->addEntry(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
> +				  &maxAnalogSensitivity, 1);

+4

An information for the sensor database ?
Also, we might want a draft control, and plum this from the db, to the
pipeline handler, to the HAL

> +

empty line not required

>  	staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, &orientation_, 1);


>
>  	std::vector<int32_t> testPatterModes = {
> @@ -1092,6 +1130,21 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  testPatterModes.data(),
>  				  testPatterModes.size());
>
> +	/*
> +	 * required for FULL (docs don't say it is, but cts says it is)
> +	 * \todo figure out how this works
> +	 */
> +	std::vector<int32_t> blackLevelPattern = { 0, 0, 0, 0 };

+16

> +	staticMetadata_->addEntry(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
> +				  blackLevelPattern.data(),
> +				  blackLevelPattern.size());
> +
> +	/* range of valid values: > 255 (8-bit output) */
> +	/* this xnor BLACK_LEVEL_PATTERN must be available */
> +	int32_t whiteLevel = 256;

+4

> +	staticMetadata_->addEntry(ANDROID_SENSOR_INFO_WHITE_LEVEL,
> +				  &whiteLevel, 1);
> +

I'm not sure where these info should come from

>  	std::vector<float> physicalSize = {
>  		2592, 1944,
>  	};
> @@ -1131,7 +1184,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	}
>
>  	/* Sync static metadata. */
> -	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
> +	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;

This is an hard statement to make :)

>  	staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1);
>
>  	/* Flash static metadata. */
> @@ -1147,6 +1200,15 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  lensApertures.data(),
>  				  lensApertures.size());
>
> +	/*
> +	 * Required for FULL
> +	 * \todo get this information from the camera, in ascending order
> +	 */
> +	std::vector<float> availableFilterDensities = { 0 };

+4

> +	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
> +				  availableFilterDensities.data(),
> +				  availableFilterDensities.size());
> +

Lens info should come from the ConfigurationFile. Add a \todo maybe ?
>  	uint8_t lensFacing;
>  	switch (facing_) {
>  	default:
> @@ -1176,6 +1238,11 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  opticalStabilizations.data(),
>  				  opticalStabilizations.size());
>
> +	/* \todo set this based on camera capability */

Or configuration file

> +	int distanceCalibration = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;

it's a BYTE

> +	staticMetadata_->addEntry(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
> +				  &distanceCalibration, 1);
> +
>  	float hypeFocalDistance = 0;
>  	staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
>  				  &hypeFocalDistance, 1);
> @@ -1188,12 +1255,18 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	{
>  		std::vector<uint8_t> data;
>  		data.reserve(5);
> +		/*
> +		 * \todo if this doesn't have OFF and FAST and HIGH_QUALITY
> +		 * then this camera does not support FULL
> +		 */
>  		const auto &infoMap = controlsInfo.find(&controls::draft::NoiseReductionMode);
>  		if (infoMap != controlsInfo.end()) {
>  			for (const auto &value : infoMap->second.values())
>  				data.push_back(value.get<int32_t>());
>  		} else {
>  			data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF);
> +			data.push_back(ANDROID_NOISE_REDUCTION_MODE_FAST);
> +			data.push_back(ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY);
>  		}
>  		staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
>  					  data.data(), data.size());
> @@ -1261,6 +1334,16 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
>  	staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1);
>
> +	/* \todo figure out if this should be int32 as documented */

doc says byte x n
> +	std::vector<uint8_t> shadingAvailableModes = {
> +		ANDROID_SHADING_MODE_OFF,
> +		ANDROID_SHADING_MODE_FAST,
> +		ANDROID_SHADING_MODE_HIGH_QUALITY,
> +	};

So +3

> +	staticMetadata_->addEntry(ANDROID_SHADING_AVAILABLE_MODES,
> +				  shadingAvailableModes.data(),
> +				  shadingAvailableModes.size());
> +
>  	/* Info static metadata. */
>  	uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL;
>  	staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
> @@ -1288,6 +1371,10 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>
>  	std::vector<uint8_t> availableCapabilities = {
>  		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
> +		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,

Are all of these required for FULL mode ?

>  	};
>
>  	/* Report if camera supports RAW. */
> @@ -1306,7 +1393,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  	}
>
>  	/* Number of { RAW, YUV, JPEG } supported output streams */
> -	int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 };
> +	int32_t numOutStreams[] = { rawStreamAvailable, 3, 1 };

We should do a little more than just bumping this number up to claim
this :)

>  	staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
>  				  &numOutStreams, 3);
>
> @@ -1314,6 +1401,29 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  				  availableCapabilities.data(),
>  				  availableCapabilities.size());
>
> +	/*
> +	 * required for FULL
> +	 * at least one of the below mode combinations:
> +	 * - CONTRAST_CURVE, FAST, HIGH_QUALITY
> +	 * - GAMMA_VALUE, PRESET_CURVE, FAST, HIGH_QUALITY
> +	 */
> +	std::vector<uint8_t> availableTonemapModes = {
> +		ANDROID_TONEMAP_MODE_CONTRAST_CURVE,
> +		ANDROID_TONEMAP_MODE_FAST,
> +		ANDROID_TONEMAP_MODE_HIGH_QUALITY,
> +	};
> +	staticMetadata_->addEntry(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
> +				  availableTonemapModes.data(),
> +				  availableTonemapModes.size());

I'm sincerely not sure where these info sould come from

> +
> +	/*
> +	 * required for FULL
> +	 * \todo get from camera (camCapabilities[camId]->tonemapCurvePoints?)
> +	 */
> +	int32_t tonemapCurvePoints = 0;
> +	staticMetadata_->addEntry(ANDROID_TONEMAP_MAX_CURVE_POINTS,
> +				  &tonemapCurvePoints, 1);
> +
>  	std::vector<int32_t> availableCharacteristicsKeys = {
>  		ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
>  		ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
> @@ -1331,14 +1441,17 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
>  		ANDROID_CONTROL_MAX_REGIONS,
>  		ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
> +		ANDROID_EDGE_AVAILABLE_EDGE_MODES,
>  		ANDROID_FLASH_INFO_AVAILABLE,
>  		ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
>  		ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
>  		ANDROID_JPEG_MAX_SIZE,
>  		ANDROID_LENS_FACING,
>  		ANDROID_LENS_INFO_AVAILABLE_APERTURES,
> +		ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
>  		ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
>  		ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
> +		ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
>  		ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
>  		ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
>  		ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
> @@ -1353,6 +1466,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
>  		ANDROID_SCALER_CROPPING_TYPE,
>  		ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
> +		ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
>  		ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
>  		ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
>  		ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
> @@ -1361,17 +1475,25 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
>  		ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
>  		ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
> +		ANDROID_SENSOR_INFO_WHITE_LEVEL,
> +		ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
>  		ANDROID_SENSOR_ORIENTATION,
> +		ANDROID_SHADING_AVAILABLE_MODES,
>  		ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
>  		ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
>  		ANDROID_SYNC_MAX_LATENCY,
> +		ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
> +		ANDROID_TONEMAP_MAX_CURVE_POINTS,

Each new one is +4

>  	};
>  	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
>  				  availableCharacteristicsKeys.data(),
>  				  availableCharacteristicsKeys.size());
>
>  	std::vector<int32_t> availableRequestKeys = {
> +		ANDROID_BLACK_LEVEL_LOCK,
>  		ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
> +		ANDROID_COLOR_CORRECTION_GAINS,
> +		ANDROID_COLOR_CORRECTION_TRANSFORM,
>  		ANDROID_CONTROL_AE_ANTIBANDING_MODE,
>  		ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
>  		ANDROID_CONTROL_AE_LOCK,
> @@ -1387,16 +1509,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
>  		ANDROID_CONTROL_MODE,
>  		ANDROID_CONTROL_SCENE_MODE,
>  		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
> +		ANDROID_EDGE_MODE,
>  		ANDROID_FLASH_MODE,
>  		ANDROID_JPEG_ORIENTATION,
>  		ANDROID_JPEG_QUALITY,
>  		ANDROID_JPEG_THUMBNAIL_QUALITY,
>  		ANDROID_JPEG_THUMBNAIL_SIZE,
>  		ANDROID_LENS_APERTURE,
> +		ANDROID_LENS_FILTER_DENSITY,
>  		ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
>  		ANDROID_NOISE_REDUCTION_MODE,
>  		ANDROID_SCALER_CROP_REGION,
> -		ANDROID_STATISTICS_FACE_DETECT_MODE
> +		ANDROID_SENSOR_EXPOSURE_TIME,
> +		ANDROID_SENSOR_FRAME_DURATION,
> +		ANDROID_SENSOR_SENSITIVITY,
> +		ANDROID_SHADING_MODE,
> +		ANDROID_STATISTICS_FACE_DETECT_MODE,
> +		ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
> +		ANDROID_TONEMAP_MODE,

I've done this multiple time, but I'll just re-state that we're
claiming support for controls without actually handling them

Thanks
   j
>  	};

>  	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
>  				  availableRequestKeys.data(),
> --
> 2.27.0
>
> _______________________________________________
> libcamera-devel mailing list
> libcamera-devel@lists.libcamera.org
> https://lists.libcamera.org/listinfo/libcamera-devel

Patch
diff mbox series 

diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
index a11ad848..7f0f8f1a 100644
--- a/src/android/camera_device.cpp
+++ b/src/android/camera_device.cpp
@@ -776,10 +776,19 @@  std::tuple<uint32_t, uint32_t> CameraDevice::calculateStaticMetadataSize()
 {
 	/*
 	 * \todo Keep this in sync with the actual number of entries.
-	 * Currently: 54 entries, 874 bytes of static metadata
+	 * Currently: 63 entries, 990 bytes of static metadata
 	 */
-	uint32_t numEntries = 54;
-	uint32_t byteSize = 874;
+	uint32_t numEntries = 63;
+	uint32_t byteSize = 990;
+
+	// do i need to add for entries in the available keys?
+	// +1, +4 for EDGE_AVAILABLE_EDGE_MODES
+	// +1, +4 for LENS_INFO_AVAILABLE_FILTER_DENSITIES
+	// +1, +4 for BLACK_LEVEL_PATTERN
+	// +1, +4 for TONEMAP_AVAILABLE_TONE_MAP_MODES
+	// +1, +4 for TONEMAP_MAX_CURVE_POINTS
+
+	// +36 for new request keys
 
 	/*
 	 * Calculate space occupation in bytes for dynamically built metadata
@@ -861,7 +870,9 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  aeAvailableAntiBandingModes.data(),
 				  aeAvailableAntiBandingModes.size());
 
+	/* \todo FULL requires OFF */
 	std::vector<uint8_t> aeAvailableModes = {
+		ANDROID_CONTROL_AE_MODE_OFF,
 		ANDROID_CONTROL_AE_MODE_ON,
 	};
 	staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES,
@@ -958,9 +969,11 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 
 	/*
 	 * \todo Inspect the Camera capabilities to report the available
-	 * AWB modes. Default to AUTO as CTS tests require it.
+	 * AWB modes. Default to AUTO as CTS tests require it. FULL requires
+	 * OFF.
 	 */
 	std::vector<uint8_t> availableAwbModes = {
+		ANDROID_CONTROL_AWB_MODE_OFF,
 		ANDROID_CONTROL_AWB_MODE_AUTO,
 	};
 	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
@@ -983,17 +996,32 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  sceneModesOverride.data(),
 				  sceneModesOverride.size());
 
-	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
+	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
+	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
 	staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
 				  &aeLockAvailable, 1);
 
-	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
+	/* true for MANUAL_SENSOR or BURST_CAPTURE capable devices */
+	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
 	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
 				  &awbLockAvailable, 1);
 
 	char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
 	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES,
 				  &availableControlModes, 1);
+	/*
+	 * FULL - always support OFF
+	 * camera devices that support YUV_REPROCESSING or PRIVATE_REPROCESSING - ZERO_SHUTTER_LAG
+	 * all devices will list FAST
+	 */
+	std::vector<uint8_t> availableEdgeModes = {
+		ANDROID_EDGE_MODE_OFF,
+		ANDROID_EDGE_MODE_FAST,
+		ANDROID_EDGE_MODE_HIGH_QUALITY,
+	};
+	staticMetadata_->addEntry(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
+				  availableEdgeModes.data(),
+				  availableEdgeModes.size());
 
 	/* JPEG static metadata. */
 
@@ -1079,10 +1107,20 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 			exposureInfo->second.min().get<int32_t>() * 1000LL,
 			exposureInfo->second.max().get<int32_t>() * 1000LL,
 		};
+		/* min must be at most 100us, max at least 100ms */
+		if (exposureTimeRange[0] > 100000)
+			exposureTimeRange[0] = 100000;
+		if (exposureTimeRange[1] < 100000000)
+			exposureTimeRange[1] = 100000000;
 		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
 					  &exposureTimeRange, 2);
 	}
 
+	/* min at most 100, max at least 800 */
+	int32_t maxAnalogSensitivity = 800;
+	staticMetadata_->addEntry(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
+				  &maxAnalogSensitivity, 1);
+
 	staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, &orientation_, 1);
 
 	std::vector<int32_t> testPatterModes = {
@@ -1092,6 +1130,21 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  testPatterModes.data(),
 				  testPatterModes.size());
 
+	/*
+	 * required for FULL (docs don't say it is, but cts says it is)
+	 * \todo figure out how this works
+	 */
+	std::vector<int32_t> blackLevelPattern = { 0, 0, 0, 0 };
+	staticMetadata_->addEntry(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
+				  blackLevelPattern.data(),
+				  blackLevelPattern.size());
+
+	/* range of valid values: > 255 (8-bit output) */
+	/* this xnor BLACK_LEVEL_PATTERN must be available */
+	int32_t whiteLevel = 256;
+	staticMetadata_->addEntry(ANDROID_SENSOR_INFO_WHITE_LEVEL,
+				  &whiteLevel, 1);
+
 	std::vector<float> physicalSize = {
 		2592, 1944,
 	};
@@ -1131,7 +1184,7 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 	}
 
 	/* Sync static metadata. */
-	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
+	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;
 	staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1);
 
 	/* Flash static metadata. */
@@ -1147,6 +1200,15 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  lensApertures.data(),
 				  lensApertures.size());
 
+	/*
+	 * Required for FULL
+	 * \todo get this information from the camera, in ascending order
+	 */
+	std::vector<float> availableFilterDensities = { 0 };
+	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
+				  availableFilterDensities.data(),
+				  availableFilterDensities.size());
+
 	uint8_t lensFacing;
 	switch (facing_) {
 	default:
@@ -1176,6 +1238,11 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  opticalStabilizations.data(),
 				  opticalStabilizations.size());
 
+	/* \todo set this based on camera capability */
+	int distanceCalibration = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;
+	staticMetadata_->addEntry(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
+				  &distanceCalibration, 1);
+
 	float hypeFocalDistance = 0;
 	staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
 				  &hypeFocalDistance, 1);
@@ -1188,12 +1255,18 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 	{
 		std::vector<uint8_t> data;
 		data.reserve(5);
+		/*
+		 * \todo if this doesn't have OFF and FAST and HIGH_QUALITY
+		 * then this camera does not support FULL
+		 */
 		const auto &infoMap = controlsInfo.find(&controls::draft::NoiseReductionMode);
 		if (infoMap != controlsInfo.end()) {
 			for (const auto &value : infoMap->second.values())
 				data.push_back(value.get<int32_t>());
 		} else {
 			data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF);
+			data.push_back(ANDROID_NOISE_REDUCTION_MODE_FAST);
+			data.push_back(ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY);
 		}
 		staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
 					  data.data(), data.size());
@@ -1261,6 +1334,16 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 	uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
 	staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1);
 
+	/* \todo figure out if this should be int32 as documented */
+	std::vector<uint8_t> shadingAvailableModes = {
+		ANDROID_SHADING_MODE_OFF,
+		ANDROID_SHADING_MODE_FAST,
+		ANDROID_SHADING_MODE_HIGH_QUALITY,
+	};
+	staticMetadata_->addEntry(ANDROID_SHADING_AVAILABLE_MODES,
+				  shadingAvailableModes.data(),
+				  shadingAvailableModes.size());
+
 	/* Info static metadata. */
 	uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL;
 	staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
@@ -1288,6 +1371,10 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 
 	std::vector<uint8_t> availableCapabilities = {
 		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
+		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
+		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
+		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
+		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
 	};
 
 	/* Report if camera supports RAW. */
@@ -1306,7 +1393,7 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 	}
 
 	/* Number of { RAW, YUV, JPEG } supported output streams */
-	int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 };
+	int32_t numOutStreams[] = { rawStreamAvailable, 3, 1 };
 	staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
 				  &numOutStreams, 3);
 
@@ -1314,6 +1401,29 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 				  availableCapabilities.data(),
 				  availableCapabilities.size());
 
+	/*
+	 * required for FULL
+	 * at least one of the below mode combinations:
+	 * - CONTRAST_CURVE, FAST, HIGH_QUALITY
+	 * - GAMMA_VALUE, PRESET_CURVE, FAST, HIGH_QUALITY
+	 */
+	std::vector<uint8_t> availableTonemapModes = {
+		ANDROID_TONEMAP_MODE_CONTRAST_CURVE,
+		ANDROID_TONEMAP_MODE_FAST,
+		ANDROID_TONEMAP_MODE_HIGH_QUALITY,
+	};
+	staticMetadata_->addEntry(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
+				  availableTonemapModes.data(),
+				  availableTonemapModes.size());
+
+	/*
+	 * required for FULL
+	 * \todo get from camera (camCapabilities[camId]->tonemapCurvePoints?)
+	 */
+	int32_t tonemapCurvePoints = 0;
+	staticMetadata_->addEntry(ANDROID_TONEMAP_MAX_CURVE_POINTS,
+				  &tonemapCurvePoints, 1);
+
 	std::vector<int32_t> availableCharacteristicsKeys = {
 		ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
 		ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
@@ -1331,14 +1441,17 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 		ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
 		ANDROID_CONTROL_MAX_REGIONS,
 		ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
+		ANDROID_EDGE_AVAILABLE_EDGE_MODES,
 		ANDROID_FLASH_INFO_AVAILABLE,
 		ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
 		ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
 		ANDROID_JPEG_MAX_SIZE,
 		ANDROID_LENS_FACING,
 		ANDROID_LENS_INFO_AVAILABLE_APERTURES,
+		ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
 		ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
 		ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
+		ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
 		ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
 		ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
 		ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
@@ -1353,6 +1466,7 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
 		ANDROID_SCALER_CROPPING_TYPE,
 		ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
+		ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
 		ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
 		ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
 		ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
@@ -1361,17 +1475,25 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 		ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
 		ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
 		ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
+		ANDROID_SENSOR_INFO_WHITE_LEVEL,
+		ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
 		ANDROID_SENSOR_ORIENTATION,
+		ANDROID_SHADING_AVAILABLE_MODES,
 		ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
 		ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
 		ANDROID_SYNC_MAX_LATENCY,
+		ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
+		ANDROID_TONEMAP_MAX_CURVE_POINTS,
 	};
 	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
 				  availableCharacteristicsKeys.data(),
 				  availableCharacteristicsKeys.size());
 
 	std::vector<int32_t> availableRequestKeys = {
+		ANDROID_BLACK_LEVEL_LOCK,
 		ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
+		ANDROID_COLOR_CORRECTION_GAINS,
+		ANDROID_COLOR_CORRECTION_TRANSFORM,
 		ANDROID_CONTROL_AE_ANTIBANDING_MODE,
 		ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
 		ANDROID_CONTROL_AE_LOCK,
@@ -1387,16 +1509,24 @@  const camera_metadata_t *CameraDevice::getStaticMetadata()
 		ANDROID_CONTROL_MODE,
 		ANDROID_CONTROL_SCENE_MODE,
 		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
+		ANDROID_EDGE_MODE,
 		ANDROID_FLASH_MODE,
 		ANDROID_JPEG_ORIENTATION,
 		ANDROID_JPEG_QUALITY,
 		ANDROID_JPEG_THUMBNAIL_QUALITY,
 		ANDROID_JPEG_THUMBNAIL_SIZE,
 		ANDROID_LENS_APERTURE,
+		ANDROID_LENS_FILTER_DENSITY,
 		ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
 		ANDROID_NOISE_REDUCTION_MODE,
 		ANDROID_SCALER_CROP_REGION,
-		ANDROID_STATISTICS_FACE_DETECT_MODE
+		ANDROID_SENSOR_EXPOSURE_TIME,
+		ANDROID_SENSOR_FRAME_DURATION,
+		ANDROID_SENSOR_SENSITIVITY,
+		ANDROID_SHADING_MODE,
+		ANDROID_STATISTICS_FACE_DETECT_MODE,
+		ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
+		ANDROID_TONEMAP_MODE,
 	};
 	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
 				  availableRequestKeys.data(),