From patchwork Thu Apr 22 09:40:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 12072 X-Patchwork-Delegate: paul.elder@ideasonboard.com Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 8B9C0BDB17 for ; Thu, 22 Apr 2021 09:41:25 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 1D8EE68868; Thu, 22 Apr 2021 11:41:25 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="h6DYH8Yg"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 60EFC6884C for ; Thu, 22 Apr 2021 11:41:22 +0200 (CEST) Received: from pyrite.rasen.tech (unknown [IPv6:2400:4051:61:600:2c71:1b79:d06d:5032]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 142F99DA; Thu, 22 Apr 2021 11:41:20 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1619084482; bh=YccilF9HvnDsp0N9neku+1bINCLZ/OJGPkBbPnWtCNU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=h6DYH8YgZxfpngYkBTEB/Blxl7OI62qzCyRMm2UIIqMgh0BS5nSbUVXyS8NIh4Lra LGK7AB+22eBWP73mfoCRVAjIXwSPTA+6tKAID52Vs32AnZVjcrtBTn/fToVzBx/hfe VAtQTIv5qnDinTBIXBIxFvGZDE/pvGKdesltC89E= From: Paul Elder To: libcamera-devel@lists.libcamera.org Date: Thu, 22 Apr 2021 18:40:55 +0900 Message-Id: <20210422094102.371772-6-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20210422094102.371772-1-paul.elder@ideasonboard.com> References: <20210422094102.371772-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [RFC PATCH v2 05/12] android: camera_device: Set static metadata for FULL requirements X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" 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 --- 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 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 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 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 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() * 1000LL, exposureInfo->second.max().get() * 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 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 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 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 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 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()); } 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 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 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 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 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 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(),