From patchwork Wed Sep 4 12:08:44 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1911 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id F1A1260BB2 for ; Wed, 4 Sep 2019 14:07:22 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 27D3C2000D; Wed, 4 Sep 2019 12:07:20 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Cc: Jacopo Mondi , kamesan@google.com, jcliang@google.com, shik@google.com, wtlee@google.com, =?utf-8?q?Niklas_S=C3=B6derlund?= , Laurent Pinchart Date: Wed, 4 Sep 2019 14:08:44 +0200 Message-Id: <20190904120847.11934-2-jacopo@jmondi.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20190904120847.11934-1-jacopo@jmondi.org> References: <20190904120847.11934-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v3 1/4] android: camera_device: Add missing static metadata X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 04 Sep 2019 12:07:23 -0000 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 Acked-by: Laurent Pinchart Signed-off-by: Jacopo Mondi --- src/android/camera_device.cpp | 272 +++++++++++++++++++++++++++++++--- 1 file changed, 248 insertions(+), 24 deletions(-) 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 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 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 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 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 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 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 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 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 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 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 availableMaxRegions = { + 0, 0, 0, + }; + ret = add_camera_metadata_entry(staticMetadata_, + ANDROID_CONTROL_MAX_REGIONS, + availableMaxRegions.data(), availableMaxRegions.size()); + METADATA_ASSERT(ret); + + std::vector 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 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 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 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, + ×tampSource, 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 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 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 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 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 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_; } From patchwork Wed Sep 4 12:08:45 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1912 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 7C90B60BB2 for ; Wed, 4 Sep 2019 14:07:24 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 23C3E20010; Wed, 4 Sep 2019 12:07:22 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Cc: Jacopo Mondi , kamesan@google.com, jcliang@google.com, shik@google.com, wtlee@google.com, Laurent Pinchart Date: Wed, 4 Sep 2019 14:08:45 +0200 Message-Id: <20190904120847.11934-3-jacopo@jmondi.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20190904120847.11934-1-jacopo@jmondi.org> References: <20190904120847.11934-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v3 2/4] android: camera_device: Use correct sizes for static metadata X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 04 Sep 2019 12:07:24 -0000 Use more opportune sizes for the static metadata pack, and for the dynamic metadata sizes which where wrongly set to use the ones defined for the static pack. Acked-by: Laurent Pinchart Signed-off-by: Jacopo Mondi --- src/android/camera_device.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp index 15f57a7fe731..dee60e3d2931 100644 --- a/src/android/camera_device.cpp +++ b/src/android/camera_device.cpp @@ -128,11 +128,11 @@ camera_metadata_t *CameraDevice::getStaticMetadata() * more. */ - /* \todo Use correct sizes */ - #define STATIC_ENTRY_CAP 256 - #define STATIC_DATA_CAP 6688 - staticMetadata_ = allocate_camera_metadata(STATIC_ENTRY_CAP, - STATIC_DATA_CAP); + /* + * \todo Keep this in sync with the actual number of entries. + * Currently: 46 entries, 390 bytes + */ + staticMetadata_ = allocate_camera_metadata(50, 500); /* Color correction static metadata. */ std::vector aberrationModes = { @@ -966,11 +966,11 @@ camera_metadata_t *CameraDevice::getResultMetadata(int frame_number, { int ret; - /* \todo Use correct sizes */ - #define RESULT_ENTRY_CAP 256 - #define RESULT_DATA_CAP 6688 - camera_metadata_t *resultMetadata = - allocate_camera_metadata(STATIC_ENTRY_CAP, STATIC_DATA_CAP); + /* + * \todo Keep this in sync with the actual number of entries. + * Currently: 13 entries, 36 bytes + */ + camera_metadata_t *resultMetadata = allocate_camera_metadata(15, 50); const uint8_t ae_state = ANDROID_CONTROL_AE_STATE_CONVERGED; ret = add_camera_metadata_entry(resultMetadata, ANDROID_CONTROL_AE_STATE, From patchwork Wed Sep 4 12:08:46 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1913 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id DD18261567 for ; Wed, 4 Sep 2019 14:07:25 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 9F0EE20011; Wed, 4 Sep 2019 12:07:24 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Cc: Jacopo Mondi , kamesan@google.com, jcliang@google.com, shik@google.com, wtlee@google.com Date: Wed, 4 Sep 2019 14:08:46 +0200 Message-Id: <20190904120847.11934-4-jacopo@jmondi.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20190904120847.11934-1-jacopo@jmondi.org> References: <20190904120847.11934-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v3 3/4] android: camera_device: Rework template generation X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 04 Sep 2019 12:07:26 -0000 Rework the template generation procedure by adding two missing requested keys, fixing the capture intent to update it based on the requested template type, and removing static metadata keys which didn't belong there. Signed-off-by: Jacopo Mondi --- src/android/camera_device.cpp | 123 +++++++--------------------------- 1 file changed, 24 insertions(+), 99 deletions(-) diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp index dee60e3d2931..eaa0e1de12c2 100644 --- a/src/android/camera_device.cpp +++ b/src/android/camera_device.cpp @@ -544,52 +544,29 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type) return nullptr; } - if (requestTemplate_) + if (requestTemplate_) { + camera_metadata_entry_t captureIntentEntry; + + find_camera_metadata_entry(requestTemplate_, + ANDROID_CONTROL_CAPTURE_INTENT, &captureIntentEntry); + ret = update_camera_metadata_entry(requestTemplate_, + captureIntentEntry.index, + &captureIntent, 1, &captureIntentEntry); + METADATA_ASSERT(ret); + return requestTemplate_; + } - /* \todo Use correct sizes */ - #define REQUEST_TEMPLATE_ENTRIES 30 - #define REQUEST_TEMPLATE_DATA 2048 - requestTemplate_ = allocate_camera_metadata(REQUEST_TEMPLATE_ENTRIES, - REQUEST_TEMPLATE_DATA); + /* + * \todo Keep this in sync with the actual number of entries. + * Currently: 12 entries, 15 bytes + */ + requestTemplate_ = allocate_camera_metadata(15, 20); if (!requestTemplate_) { LOG(HAL, Error) << "Failed to allocate template metadata"; return nullptr; } - /* Set to 0 the number of 'processed and stalling' streams (ie JPEG). */ - int32_t maxOutStream[] = { 0, 2, 0 }; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, - maxOutStream, 3); - METADATA_ASSERT(ret); - - uint8_t maxPipelineDepth = 5; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_PIPELINE_MAX_DEPTH, - &maxPipelineDepth, 1); - METADATA_ASSERT(ret); - - int32_t inputStreams = 0; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, - &inputStreams, 1); - METADATA_ASSERT(ret); - - int32_t partialResultCount = 1; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_PARTIAL_RESULT_COUNT, - &partialResultCount, 1); - METADATA_ASSERT(ret); - - uint8_t availableCapabilities[] = { - ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE, - }; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_AVAILABLE_CAPABILITIES, - availableCapabilities, 1); - METADATA_ASSERT(ret); - uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON; ret = add_camera_metadata_entry(requestTemplate_, ANDROID_CONTROL_AE_MODE, @@ -632,12 +609,6 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type) &awbLock, 1); METADATA_ASSERT(ret); - uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_CONTROL_AWB_LOCK_AVAILABLE, - &awbLockAvailable, 1); - METADATA_ASSERT(ret); - uint8_t flashMode = ANDROID_FLASH_MODE_OFF; ret = add_camera_metadata_entry(requestTemplate_, ANDROID_FLASH_MODE, @@ -650,67 +621,21 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type) &faceDetectMode, 1); METADATA_ASSERT(ret); + uint8_t noiseReduction = ANDROID_NOISE_REDUCTION_MODE_OFF; ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_CONTROL_CAPTURE_INTENT, - &captureIntent, 1); + ANDROID_NOISE_REDUCTION_MODE, &noiseReduction, 1); METADATA_ASSERT(ret); - /* - * This is quite hard to list at the moment wihtout knowing what - * we could control. - * - * For now, just list in the available Request keys and in the available - * result keys the control and reporting of the AE algorithm. - */ - std::vector availableRequestKeys = { - ANDROID_CONTROL_AE_MODE, - ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, - ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, - ANDROID_CONTROL_AE_LOCK, - ANDROID_CONTROL_AF_TRIGGER, - ANDROID_CONTROL_AWB_MODE, - ANDROID_CONTROL_AWB_LOCK, - ANDROID_CONTROL_AWB_LOCK_AVAILABLE, - ANDROID_CONTROL_CAPTURE_INTENT, - ANDROID_FLASH_MODE, - ANDROID_STATISTICS_FACE_DETECT_MODE, - }; - + uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF; ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, - availableRequestKeys.data(), - availableRequestKeys.size()); - METADATA_ASSERT(ret); - - std::vector availableResultKeys = { - ANDROID_CONTROL_AE_MODE, - ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, - ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, - ANDROID_CONTROL_AE_LOCK, - ANDROID_CONTROL_AF_TRIGGER, - ANDROID_CONTROL_AWB_MODE, - ANDROID_CONTROL_AWB_LOCK, - ANDROID_CONTROL_AWB_LOCK_AVAILABLE, - ANDROID_CONTROL_CAPTURE_INTENT, - ANDROID_FLASH_MODE, - ANDROID_STATISTICS_FACE_DETECT_MODE, - }; - ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, - availableResultKeys.data(), - availableResultKeys.size()); + ANDROID_COLOR_CORRECTION_ABERRATION_MODE, + &aberrationMode, 1); METADATA_ASSERT(ret); - /* - * \todo The available characteristics are be the tags reported - * as part of the static metadata reported at hal_get_camera_info() - * time. As of now, report an empty list. - */ - std::vector availableCharacteristicsKeys = {}; + /* Use the capture matching the requested template type. */ ret = add_camera_metadata_entry(requestTemplate_, - ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, - availableCharacteristicsKeys.data(), - availableCharacteristicsKeys.size()); + ANDROID_CONTROL_CAPTURE_INTENT, + &captureIntent, 1); METADATA_ASSERT(ret); return requestTemplate_; From patchwork Wed Sep 4 12:08:47 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1914 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 4E9F761928 for ; Wed, 4 Sep 2019 14:07:27 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 0FF3B2000C; Wed, 4 Sep 2019 12:07:25 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Cc: Jacopo Mondi , kamesan@google.com, jcliang@google.com, shik@google.com, wtlee@google.com Date: Wed, 4 Sep 2019 14:08:47 +0200 Message-Id: <20190904120847.11934-5-jacopo@jmondi.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20190904120847.11934-1-jacopo@jmondi.org> References: <20190904120847.11934-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v3 4/4] android: camera_device: Report available keys X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 04 Sep 2019 12:07:27 -0000 Report the list of available static metadata tags (characteristicKeys), of supported controls (requestKeys) and produced metadata (resultKeys) in the static metadata pack. Signed-off-by: Jacopo Mondi Reviewed-by: Laurent Pinchart --- src/android/camera_device.cpp | 99 ++++++++++++++++++++++++++++++++++- 1 file changed, 97 insertions(+), 2 deletions(-) diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp index eaa0e1de12c2..5707a1ddeda1 100644 --- a/src/android/camera_device.cpp +++ b/src/android/camera_device.cpp @@ -130,9 +130,9 @@ camera_metadata_t *CameraDevice::getStaticMetadata() /* * \todo Keep this in sync with the actual number of entries. - * Currently: 46 entries, 390 bytes + * Currently: 49 entries, 666 bytes */ - staticMetadata_ = allocate_camera_metadata(50, 500); + staticMetadata_ = allocate_camera_metadata(50, 700); /* Color correction static metadata. */ std::vector aberrationModes = { @@ -505,6 +505,101 @@ camera_metadata_t *CameraDevice::getStaticMetadata() availableCapabilities.size()); METADATA_ASSERT(ret); + std::vector availableCharacteristicsKeys = { + ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, + ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, + ANDROID_CONTROL_AE_AVAILABLE_MODES, + ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, + ANDROID_CONTROL_AE_COMPENSATION_RANGE, + ANDROID_CONTROL_AE_COMPENSATION_STEP, + ANDROID_CONTROL_AF_AVAILABLE_MODES, + ANDROID_CONTROL_AVAILABLE_EFFECTS, + ANDROID_CONTROL_AVAILABLE_SCENE_MODES, + ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, + ANDROID_CONTROL_AWB_AVAILABLE_MODES, + ANDROID_CONTROL_MAX_REGIONS, + ANDROID_CONTROL_SCENE_MODE_OVERRIDES, + ANDROID_CONTROL_AE_LOCK_AVAILABLE, + ANDROID_CONTROL_AWB_LOCK_AVAILABLE, + ANDROID_CONTROL_AVAILABLE_MODES, + ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, + ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, + ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, + ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, + ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, + ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, + ANDROID_SENSOR_ORIENTATION, + ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES, + ANDROID_SENSOR_INFO_PHYSICAL_SIZE, + ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, + ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, + ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, + ANDROID_SYNC_MAX_LATENCY, + ANDROID_FLASH_INFO_AVAILABLE, + ANDROID_LENS_INFO_AVAILABLE_APERTURES, + ANDROID_LENS_FACING, + ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, + ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, + ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, + ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, + ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, + ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, + ANDROID_SCALER_AVAILABLE_FORMATS, + ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, + ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, + ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, + ANDROID_SCALER_CROPPING_TYPE, + ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, + ANDROID_REQUEST_PARTIAL_RESULT_COUNT, + ANDROID_REQUEST_PIPELINE_MAX_DEPTH, + ANDROID_REQUEST_AVAILABLE_CAPABILITIES, + }; + ret = add_camera_metadata_entry(staticMetadata_, + ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, + availableCharacteristicsKeys.data(), + availableCharacteristicsKeys.size()); + METADATA_ASSERT(ret); + + std::vector availableRequestKeys = { + ANDROID_CONTROL_AE_MODE, + ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, + ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, + ANDROID_CONTROL_AE_LOCK, + ANDROID_CONTROL_AF_TRIGGER, + ANDROID_CONTROL_AWB_MODE, + ANDROID_CONTROL_AWB_LOCK, + ANDROID_FLASH_MODE, + ANDROID_STATISTICS_FACE_DETECT_MODE, + ANDROID_NOISE_REDUCTION_MODE, + ANDROID_COLOR_CORRECTION_ABERRATION_MODE, + ANDROID_CONTROL_CAPTURE_INTENT, + }; + ret = add_camera_metadata_entry(staticMetadata_, + ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, + availableRequestKeys.data(), + availableRequestKeys.size()); + METADATA_ASSERT(ret); + + std::vector availableResultKeys = { + ANDROID_CONTROL_AE_STATE, + ANDROID_CONTROL_AE_LOCK, + ANDROID_CONTROL_AF_STATE, + ANDROID_CONTROL_AWB_STATE, + ANDROID_CONTROL_AWB_LOCK, + ANDROID_LENS_STATE, + ANDROID_SCALER_CROP_REGION, + ANDROID_SENSOR_TIMESTAMP, + ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, + ANDROID_SENSOR_EXPOSURE_TIME, + ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, + ANDROID_STATISTICS_SCENE_FLICKER, + }; + ret = add_camera_metadata_entry(staticMetadata_, + ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, + availableResultKeys.data(), + availableResultKeys.size()); + METADATA_ASSERT(ret); + return staticMetadata_; }