From patchwork Thu Sep 5 21:09:32 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1943 Return-Path: Received: from relay6-d.mail.gandi.net (relay6-d.mail.gandi.net [217.70.183.198]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 60AC661567 for ; Thu, 5 Sep 2019 23:08:14 +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 relay6-d.mail.gandi.net (Postfix) with ESMTPSA id 84614C0002; Thu, 5 Sep 2019 21:08:13 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Thu, 5 Sep 2019 23:09:32 +0200 Message-Id: <20190905210940.32358-2-jacopo@jmondi.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20190905210940.32358-1-jacopo@jmondi.org> References: <20190905210940.32358-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v7 1/9] 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: Thu, 05 Sep 2019 21:08:14 -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_; }