[libcamera-devel] [RFC PATCH v2 05/12] android: camera_device: Set static metadata for FULL requirements
Paul Elder
paul.elder at ideasonboard.com
Thu Apr 22 11:40:55 CEST 2021
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 at 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
+
+ // +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(),
--
2.27.0
More information about the libcamera-devel
mailing list