From patchwork Fri May 14 06:43:01 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 12285 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 16656C31F6 for ; Fri, 14 May 2021 06:43:26 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id CACA668920; Fri, 14 May 2021 08:43: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="mcHbrs9F"; 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 0BFD5602B4 for ; Fri, 14 May 2021 08:43:25 +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 389EC9F0; Fri, 14 May 2021 08:43:22 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1620974604; bh=KgXsb3qm8FN88kwW+gkYf6fPufr8KbU0EszNGCecN2E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=mcHbrs9FotIIfh4m3xamhDxi5mbBuoAZA64FQ2rKwm6uzSmXuOuKBdiFfn0Z50WG6 TQ55XtVxLvD7tJdCYZI8eoSm9XtBpAFXEqAnEzrftj95RHbNpl+U1PN0drRs9u4bCq LwvTfRq4SWnz16qc53R1WYOF4bVqYwa/I3D+c6BY= From: Paul Elder To: libcamera-devel@lists.libcamera.org Date: Fri, 14 May 2021 15:43:01 +0900 Message-Id: <20210514064303.798045-2-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20210514064303.798045-1-paul.elder@ideasonboard.com> References: <20210514064303.798045-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v5 1/3] android: camera_metadata: Auto-resize CameraMetadata 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" Previously we had to manually declare the size of CameraMetadata on allocation, and its count could not be changed after construction. Change CameraMetadata's behavior so that the user can simply add or update entries, and the CameraMetadata will auto-resize (double the size) as necessary. Also remove everything involved with calculating the initial size for any CameraMetadata instances. Signed-off-by: Paul Elder Reviewed-by: Niklas Söderlund Reviewed-by: Kieran Bingham --- Changes in v5: - add overload for C arrays Changes in v4: - upgrade the second overload to allow STL containers instead of just vector - the main use case I'm imagining is vector and array. C arrays won't work because they don't have .data() and .size() (the latter is the more important one) - libcamera::Span doesn't work because the template engine can't match std::vector/std::array to libcamera::Span - ‘std::vector’ is not derived from ‘libcamera::Span’ - return bool from addEntry and updateEntry Changes in v3: - dependency on "FULL hardware level fixes" removed - split addEntry and updateEntry - i think the lookup on every (merged) addEntry isn't worth it, since the user probably knows if they need to add or update - add auto-resize (and corresponding check) to updateEntry as well - add the templates and overloads to updateEntry as well - increase the default size for the static metadata to be above what we had before - valid_ is now used to indicate a failed addEntry/updateEntry in addition to metadata_ == nullptr. this way the user doesn't have to check the return value of every single addEntry/updateEntry call, and can just check valid_ at the end - print resize when it happens - updateEntry resizes if the new data size is greater than the old data Question: I think on failure of addEntry/updateEntry the metadata could still be "valid", it's just that the content isn't what the user expects. Should we keep valid_ as I've repurposed it here in v3, or should we add another flag? Changes in v2: - add overloading of addEntry - better logging with the separation of core code vs template code - addEntry failure makes the metadata invalid The main feature of v2 is the overloading of addEntry. I have three overloads and the main one: - tag, single piece of data (reference) - tag, C array (v5) - tag, STL container (v3: s/span/vector/) (v4: s/vector/STL container/) - tag, data pointer, count - tag, data pointer, count, size of one instance of the data The last one is the main one, and is not templated. The first two are nice and convenient, because now we can do things like: uint32_t orientation = 0; resultMetadata->addEntry(ANDROID_JPEG_ORIENTATION, orientation); and std::vector availableStates = { SOME_STATE_1, SOME_STATE_2 }; metadata->addEntry(ANDROID_AVAILABLE_STATES, availableStates); The third is for when android metadata is copied directly from another piece of android metadata. All the old calls are backward-compatible using this overload. --- src/android/camera_device.cpp | 47 +----------------- src/android/camera_device.h | 1 - src/android/camera_metadata.cpp | 84 +++++++++++++++++++++++++++++---- src/android/camera_metadata.h | 52 +++++++++++++++++++- 4 files changed, 127 insertions(+), 57 deletions(-) diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp index 7d4d0feb..74f6915c 100644 --- a/src/android/camera_device.cpp +++ b/src/android/camera_device.cpp @@ -773,43 +773,6 @@ void CameraDevice::setCallbacks(const camera3_callback_ops_t *callbacks) callbacks_ = callbacks; } -std::tuple CameraDevice::calculateStaticMetadataSize() -{ - /* - * \todo Keep this in sync with the actual number of entries. - * Currently: 54 entries, 874 bytes of static metadata - */ - uint32_t numEntries = 54; - uint32_t byteSize = 874; - - /* - * Calculate space occupation in bytes for dynamically built metadata - * entries. - * - * Each stream configuration entry requires 48 bytes: - * 4 32bits integers for ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS - * 4 64bits integers for ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS - */ - byteSize += streamConfigurations_.size() * 48; - - /* - * 2 32bits integers for each HAL_PIXEL_FORMAT_BLOB for thumbnail sizes - * 2 32bits integers for the (0, 0) thumbnail size - * - * This is a worst case estimates as different configurations with the - * same aspect ratio will generate the same size. - */ - for (const auto &entry : streamConfigurations_) { - if (entry.androidFormat != HAL_PIXEL_FORMAT_BLOB) - continue; - - byteSize += 8; - } - byteSize += 8; - - return std::make_tuple(numEntries, byteSize); -} - /* * Return static information for the camera. */ @@ -818,15 +781,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() if (staticMetadata_) return staticMetadata_->get(); - /* - * The here reported metadata are enough to implement a basic capture - * example application, but a real camera implementation will require - * more. - */ - uint32_t numEntries; - uint32_t byteSize; - std::tie(numEntries, byteSize) = calculateStaticMetadataSize(); - staticMetadata_ = std::make_unique(numEntries, byteSize); + staticMetadata_ = std::make_unique(64, 1024); if (!staticMetadata_->isValid()) { LOG(HAL, Error) << "Failed to allocate static metadata"; staticMetadata_.reset(); diff --git a/src/android/camera_device.h b/src/android/camera_device.h index 23457e47..ae162a45 100644 --- a/src/android/camera_device.h +++ b/src/android/camera_device.h @@ -98,7 +98,6 @@ private: std::vector getRawResolutions(const libcamera::PixelFormat &pixelFormat); - std::tuple calculateStaticMetadataSize(); libcamera::FrameBuffer *createFrameBuffer(const buffer_handle_t camera3buffer); void notifyShutter(uint32_t frameNumber, uint64_t timestamp); void notifyError(uint32_t frameNumber, camera3_stream_t *stream); diff --git a/src/android/camera_metadata.cpp b/src/android/camera_metadata.cpp index 6f1bcdbe..bf8d2781 100644 --- a/src/android/camera_metadata.cpp +++ b/src/android/camera_metadata.cpp @@ -63,11 +63,64 @@ bool CameraMetadata::getEntry(uint32_t tag, camera_metadata_ro_entry_t *entry) c return true; } -bool CameraMetadata::addEntry(uint32_t tag, const void *data, size_t count) +/* + * \brief Resize the metadata container, if necessary + * \param[in] count Number of entries to add to the container + * \param[in] size Total size of entries to add, in bytes + * \return True if resize was successful or unnecessary, false otherwise + */ +bool CameraMetadata::resize(size_t count, size_t size) +{ + if (!valid_) + return false; + + if (!count && !size) + return true; + + size_t currentEntryCount = get_camera_metadata_entry_count(metadata_); + size_t currentEntryCapacity = get_camera_metadata_entry_capacity(metadata_); + size_t newEntryCapacity = currentEntryCapacity < currentEntryCount + count ? + currentEntryCapacity * 2 : currentEntryCapacity; + + size_t currentDataCount = get_camera_metadata_data_count(metadata_); + size_t currentDataCapacity = get_camera_metadata_data_capacity(metadata_); + size_t newDataCapacity = currentDataCapacity < currentDataCount + size ? + currentDataCapacity * 2 : currentDataCapacity; + + if (newEntryCapacity > currentEntryCapacity || + newDataCapacity > currentDataCapacity) { + camera_metadata_t *oldMetadata = metadata_; + metadata_ = allocate_camera_metadata(newEntryCapacity, newDataCapacity); + if (!metadata_) { + metadata_ = oldMetadata; + return false; + } + + LOG(CameraMetadata, Info) + << "Resized: old entry capacity " << currentEntryCapacity + << ", old data capacity " << currentDataCapacity + << ", new entry capacity " << newEntryCapacity + << ", new data capacity " << newDataCapacity; + + append_camera_metadata(metadata_, oldMetadata); + free_camera_metadata(oldMetadata); + } + + return true; +} + +bool CameraMetadata::addEntry(uint32_t tag, const void *data, size_t count, + size_t sizeofT) { if (!valid_) return false; + if (!resize(1, count * sizeofT)) { + LOG(CameraMetadata, Error) << "Failed to resize"; + valid_ = false; + return false; + } + if (!add_camera_metadata_entry(metadata_, tag, data, count)) return true; @@ -99,16 +152,31 @@ bool CameraMetadata::updateEntry(uint32_t tag, const void *data, size_t count) return false; } - ret = update_camera_metadata_entry(metadata_, entry.index, data, - count, nullptr); - if (ret) { - const char *name = get_camera_metadata_tag_name(tag); - LOG(CameraMetadata, Error) - << "Failed to update tag " << (name ? name : ""); + size_t oldSize = + calculate_camera_metadata_entry_data_size(entry.type, + entry.count); + size_t newSize = + calculate_camera_metadata_entry_data_size(entry.type, + count); + size_t sizeIncrement = newSize - oldSize > 0 ? newSize - oldSize : 0; + if (!resize(0, sizeIncrement)) { + LOG(CameraMetadata, Error) << "Failed to resize"; + valid_ = false; return false; } - return true; + ret = update_camera_metadata_entry(metadata_, entry.index, data, + count, nullptr); + if (!ret) + return true; + + const char *name = get_camera_metadata_tag_name(tag); + LOG(CameraMetadata, Error) + << "Failed to update tag " << (name ? name : ""); + + valid_ = false; + + return false; } camera_metadata_t *CameraMetadata::get() diff --git a/src/android/camera_metadata.h b/src/android/camera_metadata.h index d653e2f0..07afd4b2 100644 --- a/src/android/camera_metadata.h +++ b/src/android/camera_metadata.h @@ -8,6 +8,7 @@ #define __ANDROID_CAMERA_METADATA_H__ #include +#include #include @@ -23,9 +24,56 @@ public: CameraMetadata &operator=(const CameraMetadata &other); bool isValid() const { return valid_; } + bool resize(size_t count, size_t size); bool getEntry(uint32_t tag, camera_metadata_ro_entry_t *entry) const; - bool addEntry(uint32_t tag, const void *data, size_t data_count); - bool updateEntry(uint32_t tag, const void *data, size_t data_count); + + template> * = nullptr> + bool addEntry(uint32_t tag, const T &data) + { + return addEntry(tag, &data, 1, sizeof(T)); + } + + template + bool addEntry(uint32_t tag, const T (&data)[size]) + { + return addEntry(tag, data, size, sizeof(T)); + } + + template + bool addEntry(uint32_t tag, S &data) + { + return addEntry(tag, data.data(), data.size(), sizeof(T)); + } + + template + bool addEntry(uint32_t tag, const T *data, size_t count) + { + return addEntry(tag, data, count, sizeof(T)); + } + + template + bool updateEntry(uint32_t tag, const T &data) + { + return updateEntry(tag, &data, 1); + } + + template + bool updateEntry(uint32_t tag, const T (&data)[size]) + { + return updateEntry(tag, data, size, sizeof(T)); + } + + template + bool updateEntry(uint32_t tag, S &data) + { + return updateEntry(tag, data.data(), data.size()); + } + + bool addEntry(uint32_t tag, const void *data, size_t count, size_t sizeofT); + bool updateEntry(uint32_t tag, const void *data, size_t count); camera_metadata_t *get(); const camera_metadata_t *get() const; From patchwork Fri May 14 06:43:02 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 12286 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 B7FF4C31F6 for ; Fri, 14 May 2021 06:43:29 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 72CA968919; Fri, 14 May 2021 08:43:29 +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="fjrM4AP3"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 22276602B4 for ; Fri, 14 May 2021 08:43:27 +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 5E5091051; Fri, 14 May 2021 08:43:25 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1620974606; bh=j2WPhZ7GqsY/QVxOGmbDObqcdVOTNgBWgHDMuoYevuM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fjrM4AP3r+2O7g6PcJ96SxMhe5LIkq+Oh3CQtzLLapoOcYAUMIasylKA1GghxQRYA nTv0/bOhR2V4g3IWytu6WbRT4FnWdHocmAlsPX1nFI0xeyEQe7Wg7yOgxbyx2UlNi+ 2FYLVbHdiYd6J85Tx8hgF8zZJmbbfrOrhFMy6ml0= From: Paul Elder To: libcamera-devel@lists.libcamera.org Date: Fri, 14 May 2021 15:43:02 +0900 Message-Id: <20210514064303.798045-3-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20210514064303.798045-1-paul.elder@ideasonboard.com> References: <20210514064303.798045-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v5 2/3] android: camera_device: Use the new CameraMetadata functions 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" Now that CameraMetadata supports more convenient functions, use those instead. Signed-off-by: Paul Elder Reviewed-by: Niklas Söderlund Reviewed-by: Kieran Bingham --- Changes in v5: - also convert the calls that use C arrays Changes in v4: - also convert the calls that use std::array New in v3 --- src/android/camera_device.cpp | 243 +++++++++++++++------------------- 1 file changed, 106 insertions(+), 137 deletions(-) diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp index 74f6915c..b32e8be5 100644 --- a/src/android/camera_device.cpp +++ b/src/android/camera_device.cpp @@ -803,7 +803,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() data.push_back(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF); } staticMetadata_->addEntry(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, - data.data(), data.size()); + data); } /* Control static metadata. */ @@ -814,15 +814,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO, }; staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, - aeAvailableAntiBandingModes.data(), - aeAvailableAntiBandingModes.size()); + aeAvailableAntiBandingModes); std::vector aeAvailableModes = { ANDROID_CONTROL_AE_MODE_ON, }; staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES, - aeAvailableModes.data(), - aeAvailableModes.size()); + aeAvailableModes); int64_t minFrameDurationNsec = -1; int64_t maxFrameDurationNsec = -1; @@ -864,15 +862,14 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() minFps, maxFps, maxFps, maxFps }; staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, - availableAeFpsTarget, 4); + availableAeFpsTarget); } std::vector aeCompensationRange = { 0, 0, }; staticMetadata_->addEntry(ANDROID_CONTROL_AE_COMPENSATION_RANGE, - aeCompensationRange.data(), - aeCompensationRange.size()); + aeCompensationRange); const camera_metadata_rational_t aeCompensationStep[] = { { 0, 1 } @@ -884,29 +881,25 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_CONTROL_AF_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_CONTROL_AF_AVAILABLE_MODES, - availableAfModes.data(), - availableAfModes.size()); + availableAfModes); std::vector availableEffects = { ANDROID_CONTROL_EFFECT_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_EFFECTS, - availableEffects.data(), - availableEffects.size()); + availableEffects); std::vector availableSceneModes = { ANDROID_CONTROL_SCENE_MODE_DISABLED, }; staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, - availableSceneModes.data(), - availableSceneModes.size()); + availableSceneModes); std::vector availableStabilizationModes = { ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, - availableStabilizationModes.data(), - availableStabilizationModes.size()); + availableStabilizationModes); /* * \todo Inspect the Camera capabilities to report the available @@ -916,15 +909,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_CONTROL_AWB_MODE_AUTO, }; staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES, - availableAwbModes.data(), - availableAwbModes.size()); + availableAwbModes); std::vector availableMaxRegions = { 0, 0, 0, }; staticMetadata_->addEntry(ANDROID_CONTROL_MAX_REGIONS, - availableMaxRegions.data(), - availableMaxRegions.size()); + availableMaxRegions); std::vector sceneModesOverride = { ANDROID_CONTROL_AE_MODE_ON, @@ -932,20 +923,19 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_CONTROL_AF_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_CONTROL_SCENE_MODE_OVERRIDES, - sceneModesOverride.data(), - sceneModesOverride.size()); + sceneModesOverride); uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE; staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE, - &aeLockAvailable, 1); + aeLockAvailable); uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, - &awbLockAvailable, 1); + awbLockAvailable); char availableControlModes = ANDROID_CONTROL_MODE_AUTO; staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES, - &availableControlModes, 1); + availableControlModes); /* JPEG static metadata. */ @@ -983,9 +973,9 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() thumbnailEntries.push_back(size.height); } staticMetadata_->addEntry(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, - thumbnailEntries.data(), thumbnailEntries.size()); + thumbnailEntries); - staticMetadata_->addEntry(ANDROID_JPEG_MAX_SIZE, &maxJpegBufferSize_, 1); + staticMetadata_->addEntry(ANDROID_JPEG_MAX_SIZE, maxJpegBufferSize_); /* Sensor static metadata. */ std::array pixelArraySize; @@ -994,7 +984,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() pixelArraySize[0] = size.width; pixelArraySize[1] = size.height; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, - pixelArraySize.data(), pixelArraySize.size()); + pixelArraySize); } if (properties.contains(properties::UnitCellSize)) { @@ -1004,7 +994,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() cellSize.height * pixelArraySize[1] / 1e6f }; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, - physicalSize.data(), physicalSize.size()); + physicalSize); } { @@ -1017,20 +1007,20 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() static_cast(rects[0].height), }; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, - data.data(), data.size()); + data); } int32_t sensitivityRange[] = { 32, 2400, }; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, - &sensitivityRange, 2); + sensitivityRange); /* Report the color filter arrangement if the camera reports it. */ if (properties.contains(properties::draft::ColorFilterArrangement)) { uint8_t filterArr = properties.get(properties::draft::ColorFilterArrangement); staticMetadata_->addEntry(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, - &filterArr, 1); + filterArr); } const auto &exposureInfo = controlsInfo.find(&controls::ExposureTime); @@ -1040,25 +1030,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() exposureInfo->second.max().get() * 1000LL, }; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, - &exposureTimeRange, 2); + exposureTimeRange, 2); } - staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, &orientation_, 1); + staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, orientation_); std::vector testPatterModes = { ANDROID_SENSOR_TEST_PATTERN_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES, - testPatterModes.data(), - testPatterModes.size()); + testPatterModes); uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; staticMetadata_->addEntry(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, - ×tampSource, 1); + timestampSource); if (maxFrameDurationNsec > 0) staticMetadata_->addEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, - &maxFrameDurationNsec, 1); + maxFrameDurationNsec); /* Statistics static metadata. */ uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; @@ -1067,7 +1056,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() int32_t maxFaceCount = 0; staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, - &maxFaceCount, 1); + maxFaceCount); { std::vector data; @@ -1080,25 +1069,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() data.push_back(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF); } staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, - data.data(), data.size()); + data); } /* Sync static metadata. */ int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN; - staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1); + staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, maxLatency); /* Flash static metadata. */ char flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE; staticMetadata_->addEntry(ANDROID_FLASH_INFO_AVAILABLE, - &flashAvailable, 1); + flashAvailable); /* Lens static metadata. */ std::vector lensApertures = { 2.53 / 100, }; staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_APERTURES, - lensApertures.data(), - lensApertures.size()); + lensApertures); uint8_t lensFacing; switch (facing_) { @@ -1113,29 +1101,27 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() lensFacing = ANDROID_LENS_FACING_EXTERNAL; break; } - staticMetadata_->addEntry(ANDROID_LENS_FACING, &lensFacing, 1); + staticMetadata_->addEntry(ANDROID_LENS_FACING, lensFacing); - std::vector lensFocalLenghts = { + std::vector lensFocalLengths = { 1, }; staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - lensFocalLenghts.data(), - lensFocalLenghts.size()); + lensFocalLengths); std::vector opticalStabilizations = { ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF, }; staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, - opticalStabilizations.data(), - opticalStabilizations.size()); + opticalStabilizations); float hypeFocalDistance = 0; staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, - &hypeFocalDistance, 1); + hypeFocalDistance); float minFocusDistance = 0; staticMetadata_->addEntry(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, - &minFocusDistance, 1); + minFocusDistance); /* Noise reduction modes. */ { @@ -1149,7 +1135,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF); } staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, - data.data(), data.size()); + data); } /* Scaler static metadata. */ @@ -1174,7 +1160,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() 1.0f * max.height / min.height); } staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, - &maxZoom, 1); + maxZoom); std::vector availableStreamConfigurations; availableStreamConfigurations.reserve(streamConfigurations_.size() * 4); @@ -1193,8 +1179,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_SCALER_AVAILABLE_FORMATS_BLOB, 2560, 1920, 33333333, }; staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, - availableStallDurations.data(), - availableStallDurations.size()); + availableStallDurations); /* Use the minimum frame duration for all the YUV/RGB formats. */ if (minFrameDurationNsec > 0) { @@ -1207,22 +1192,21 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() minFrameDurations.push_back(minFrameDurationNsec); } staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, - minFrameDurations.data(), - minFrameDurations.size()); + minFrameDurations); } uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY; - staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1); + staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, croppingType); /* Info static metadata. */ uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, - &supportedHWLevel, 1); + supportedHWLevel); /* Request static metadata. */ int32_t partialResultCount = 1; staticMetadata_->addEntry(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, - &partialResultCount, 1); + partialResultCount); { /* Default the value to 2 if not reported by the camera. */ @@ -1231,13 +1215,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() if (infoMap != controlsInfo.end()) maxPipelineDepth = infoMap->second.max().get(); staticMetadata_->addEntry(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, - &maxPipelineDepth, 1); + maxPipelineDepth); } /* LIMITED does not support reprocessing. */ uint32_t maxNumInputStreams = 0; staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, - &maxNumInputStreams, 1); + maxNumInputStreams); std::vector availableCapabilities = { ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE, @@ -1261,11 +1245,10 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() /* Number of { RAW, YUV, JPEG } supported output streams */ int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 }; staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, - &numOutStreams, 3); + numOutStreams); staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, - availableCapabilities.data(), - availableCapabilities.size()); + availableCapabilities); std::vector availableCharacteristicsKeys = { ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, @@ -1320,8 +1303,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_SYNC_MAX_LATENCY, }; staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, - availableCharacteristicsKeys.data(), - availableCharacteristicsKeys.size()); + availableCharacteristicsKeys); std::vector availableRequestKeys = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE, @@ -1352,8 +1334,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_STATISTICS_FACE_DETECT_MODE }; staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, - availableRequestKeys.data(), - availableRequestKeys.size()); + availableRequestKeys); std::vector availableResultKeys = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE, @@ -1402,8 +1383,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata() ANDROID_STATISTICS_SCENE_FLICKER, }; staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, - availableResultKeys.data(), - availableResultKeys.size()); + availableResultKeys); if (!staticMetadata_->isValid()) { LOG(HAL, Error) << "Failed to construct static metadata"; @@ -1442,69 +1422,63 @@ std::unique_ptr CameraDevice::requestTemplatePreview() entry.data.i32, 2); uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON; - requestTemplate->addEntry(ANDROID_CONTROL_AE_MODE, - &aeMode, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AE_MODE, aeMode); int32_t aeExposureCompensation = 0; requestTemplate->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, - &aeExposureCompensation, 1); + aeExposureCompensation); uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; requestTemplate->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, - &aePrecaptureTrigger, 1); + aePrecaptureTrigger); uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; - requestTemplate->addEntry(ANDROID_CONTROL_AE_LOCK, - &aeLock, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AE_LOCK, aeLock); uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; requestTemplate->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, - &aeAntibandingMode, 1); + aeAntibandingMode); uint8_t afMode = ANDROID_CONTROL_AF_MODE_OFF; - requestTemplate->addEntry(ANDROID_CONTROL_AF_MODE, &afMode, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AF_MODE, afMode); uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; - requestTemplate->addEntry(ANDROID_CONTROL_AF_TRIGGER, - &afTrigger, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AF_TRIGGER, afTrigger); uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO; - requestTemplate->addEntry(ANDROID_CONTROL_AWB_MODE, - &awbMode, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AWB_MODE, awbMode); uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; - requestTemplate->addEntry(ANDROID_CONTROL_AWB_LOCK, - &awbLock, 1); + requestTemplate->addEntry(ANDROID_CONTROL_AWB_LOCK, awbLock); uint8_t flashMode = ANDROID_FLASH_MODE_OFF; - requestTemplate->addEntry(ANDROID_FLASH_MODE, - &flashMode, 1); + requestTemplate->addEntry(ANDROID_FLASH_MODE, flashMode); uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; requestTemplate->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, - &faceDetectMode, 1); + faceDetectMode); uint8_t noiseReduction = ANDROID_NOISE_REDUCTION_MODE_OFF; requestTemplate->addEntry(ANDROID_NOISE_REDUCTION_MODE, - &noiseReduction, 1); + noiseReduction); uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF; requestTemplate->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, - &aberrationMode, 1); + aberrationMode); uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; - requestTemplate->addEntry(ANDROID_CONTROL_MODE, &controlMode, 1); + requestTemplate->addEntry(ANDROID_CONTROL_MODE, controlMode); float lensAperture = 2.53 / 100; - requestTemplate->addEntry(ANDROID_LENS_APERTURE, &lensAperture, 1); + requestTemplate->addEntry(ANDROID_LENS_APERTURE, lensAperture); uint8_t opticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; requestTemplate->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, - &opticalStabilization, 1); + opticalStabilization); uint8_t captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; requestTemplate->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, - &captureIntent, 1); + captureIntent); return requestTemplate; } @@ -1580,7 +1554,7 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type) } requestTemplate->updateEntry(ANDROID_CONTROL_CAPTURE_INTENT, - &captureIntent, 1); + captureIntent); requestTemplates_[type] = std::move(requestTemplate); return requestTemplates_[type]->get(); @@ -2154,20 +2128,20 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons uint8_t value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF; resultMetadata->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, - &value, 1); + value); value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, value); int32_t value32 = 0; resultMetadata->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, - &value32, 1); + value32); value = ANDROID_CONTROL_AE_LOCK_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_AE_LOCK, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AE_LOCK, value); value = ANDROID_CONTROL_AE_MODE_ON; - resultMetadata->addEntry(ANDROID_CONTROL_AE_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AE_MODE, value); if (settings.getEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, &entry)) /* @@ -2178,109 +2152,104 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons resultMetadata->addEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, entry.data.i32, 2); - value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; found = settings.getEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &entry); - resultMetadata->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, - found ? entry.data.u8 : &value, 1); + value = found ? *entry.data.u8 : + (uint8_t)ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; + resultMetadata->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, value); value = ANDROID_CONTROL_AE_STATE_CONVERGED; - resultMetadata->addEntry(ANDROID_CONTROL_AE_STATE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AE_STATE, value); value = ANDROID_CONTROL_AF_MODE_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_AF_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AF_MODE, value); value = ANDROID_CONTROL_AF_STATE_INACTIVE; - resultMetadata->addEntry(ANDROID_CONTROL_AF_STATE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AF_STATE, value); value = ANDROID_CONTROL_AF_TRIGGER_IDLE; - resultMetadata->addEntry(ANDROID_CONTROL_AF_TRIGGER, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AF_TRIGGER, value); value = ANDROID_CONTROL_AWB_MODE_AUTO; - resultMetadata->addEntry(ANDROID_CONTROL_AWB_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AWB_MODE, value); value = ANDROID_CONTROL_AWB_LOCK_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_AWB_LOCK, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AWB_LOCK, value); value = ANDROID_CONTROL_AWB_STATE_CONVERGED; - resultMetadata->addEntry(ANDROID_CONTROL_AWB_STATE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_AWB_STATE, value); value = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; - resultMetadata->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, value); value = ANDROID_CONTROL_EFFECT_MODE_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_EFFECT_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_EFFECT_MODE, value); value = ANDROID_CONTROL_MODE_AUTO; - resultMetadata->addEntry(ANDROID_CONTROL_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_MODE, value); value = ANDROID_CONTROL_SCENE_MODE_DISABLED; - resultMetadata->addEntry(ANDROID_CONTROL_SCENE_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_SCENE_MODE, value); value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; - resultMetadata->addEntry(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, value); value = ANDROID_FLASH_MODE_OFF; - resultMetadata->addEntry(ANDROID_FLASH_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_FLASH_MODE, value); value = ANDROID_FLASH_STATE_UNAVAILABLE; - resultMetadata->addEntry(ANDROID_FLASH_STATE, &value, 1); + resultMetadata->addEntry(ANDROID_FLASH_STATE, value); if (settings.getEntry(ANDROID_LENS_APERTURE, &entry)) resultMetadata->addEntry(ANDROID_LENS_APERTURE, entry.data.f, 1); float focal_length = 1.0; - resultMetadata->addEntry(ANDROID_LENS_FOCAL_LENGTH, &focal_length, 1); + resultMetadata->addEntry(ANDROID_LENS_FOCAL_LENGTH, focal_length); value = ANDROID_LENS_STATE_STATIONARY; - resultMetadata->addEntry(ANDROID_LENS_STATE, &value, 1); + resultMetadata->addEntry(ANDROID_LENS_STATE, value); value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; resultMetadata->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, - &value, 1); + value); value32 = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; - resultMetadata->addEntry(ANDROID_SENSOR_TEST_PATTERN_MODE, - &value32, 1); + resultMetadata->addEntry(ANDROID_SENSOR_TEST_PATTERN_MODE, value32); value = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; - resultMetadata->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, - &value, 1); + resultMetadata->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, value); value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF; resultMetadata->addEntry(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, - &value, 1); + value); value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF; - resultMetadata->addEntry(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, - &value, 1); + resultMetadata->addEntry(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, value); value = ANDROID_STATISTICS_SCENE_FLICKER_NONE; - resultMetadata->addEntry(ANDROID_STATISTICS_SCENE_FLICKER, - &value, 1); + resultMetadata->addEntry(ANDROID_STATISTICS_SCENE_FLICKER, value); value = ANDROID_NOISE_REDUCTION_MODE_OFF; - resultMetadata->addEntry(ANDROID_NOISE_REDUCTION_MODE, &value, 1); + resultMetadata->addEntry(ANDROID_NOISE_REDUCTION_MODE, value); /* 33.3 msec */ const int64_t rolling_shutter_skew = 33300000; resultMetadata->addEntry(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, - &rolling_shutter_skew, 1); + rolling_shutter_skew); /* Add metadata tags reported by libcamera. */ const int64_t timestamp = metadata.get(controls::SensorTimestamp); - resultMetadata->addEntry(ANDROID_SENSOR_TIMESTAMP, ×tamp, 1); + resultMetadata->addEntry(ANDROID_SENSOR_TIMESTAMP, timestamp); if (metadata.contains(controls::draft::PipelineDepth)) { uint8_t pipeline_depth = metadata.get(controls::draft::PipelineDepth); resultMetadata->addEntry(ANDROID_REQUEST_PIPELINE_DEPTH, - &pipeline_depth, 1); + pipeline_depth); } if (metadata.contains(controls::ExposureTime)) { int64_t exposure = metadata.get(controls::ExposureTime) * 1000ULL; - resultMetadata->addEntry(ANDROID_SENSOR_EXPOSURE_TIME, - &exposure, 1); + resultMetadata->addEntry(ANDROID_SENSOR_EXPOSURE_TIME, exposure); } if (metadata.contains(controls::ScalerCrop)) { @@ -2289,7 +2258,7 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons crop.x, crop.y, static_cast(crop.width), static_cast(crop.height), }; - resultMetadata->addEntry(ANDROID_SCALER_CROP_REGION, cropRect, 4); + resultMetadata->addEntry(ANDROID_SCALER_CROP_REGION, cropRect); } /* From patchwork Fri May 14 06:43:03 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 12287 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 19400C31F6 for ; Fri, 14 May 2021 06:43:31 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id D209D68929; Fri, 14 May 2021 08:43:30 +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="lul7Cuw3"; 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 77EC768923 for ; Fri, 14 May 2021 08:43:29 +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 A1DE29F0; Fri, 14 May 2021 08:43:27 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1620974609; bh=Eyziw5oMErkJuocq4vAEo09DeHrAGEbTZfzrhvydDg8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lul7Cuw3NZiETot/ysKcspOIwSgnpIP1LWl03jyGKyFSISZOPRyvaxz2PswcW9dcK QndOJQX/L8WhPY0lT5U2slTkHZ2FLqAQmz3rUNxsA3euW1zGbfyh3qllunNfKfMtdl Nshx8PJUm85dSX5hZ3K2R37r36Hv1ad1xDT67CWA= From: Paul Elder To: libcamera-devel@lists.libcamera.org Date: Fri, 14 May 2021 15:43:03 +0900 Message-Id: <20210514064303.798045-4-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20210514064303.798045-1-paul.elder@ideasonboard.com> References: <20210514064303.798045-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v5 3/3] android: jpeg: post_processor: Use the new metadata functions 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" Now that CameraMetadata supports more convenient functions, use those instead. Signed-off-by: Paul Elder Reviewed-by: Niklas Söderlund Reviewed-by: Kieran Bingham --- No change in v5 No change in v4 New in v3 --- src/android/jpeg/post_processor_jpeg.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/android/jpeg/post_processor_jpeg.cpp b/src/android/jpeg/post_processor_jpeg.cpp index 3bf16996..2ecf5578 100644 --- a/src/android/jpeg/post_processor_jpeg.cpp +++ b/src/android/jpeg/post_processor_jpeg.cpp @@ -15,6 +15,7 @@ #include "exif.h" #include +#include #include "libcamera/internal/log.h" @@ -103,7 +104,7 @@ int PostProcessorJpeg::process(const FrameBuffer &source, ret = requestMetadata.getEntry(ANDROID_JPEG_ORIENTATION, &entry); const uint32_t jpegOrientation = ret ? *entry.data.i32 : 0; - resultMetadata->addEntry(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); + resultMetadata->addEntry(ANDROID_JPEG_ORIENTATION, jpegOrientation); exif.setOrientation(jpegOrientation); exif.setSize(streamSize_); @@ -129,7 +130,7 @@ int PostProcessorJpeg::process(const FrameBuffer &source, if (ret) { exif.setGPSDateTimestamp(*entry.data.i64); resultMetadata->addEntry(ANDROID_JPEG_GPS_TIMESTAMP, - entry.data.i64, 1); + *entry.data.i64); } ret = requestMetadata.getEntry(ANDROID_JPEG_THUMBNAIL_SIZE, &entry); @@ -140,7 +141,7 @@ int PostProcessorJpeg::process(const FrameBuffer &source, ret = requestMetadata.getEntry(ANDROID_JPEG_THUMBNAIL_QUALITY, &entry); uint8_t quality = ret ? *entry.data.u8 : 95; - resultMetadata->addEntry(ANDROID_JPEG_THUMBNAIL_QUALITY, &quality, 1); + resultMetadata->addEntry(ANDROID_JPEG_THUMBNAIL_QUALITY, quality); if (thumbnailSize != Size(0, 0)) { std::vector thumbnail; @@ -172,7 +173,7 @@ int PostProcessorJpeg::process(const FrameBuffer &source, ret = requestMetadata.getEntry(ANDROID_JPEG_QUALITY, &entry); const uint8_t quality = ret ? *entry.data.u8 : 95; - resultMetadata->addEntry(ANDROID_JPEG_QUALITY, &quality, 1); + resultMetadata->addEntry(ANDROID_JPEG_QUALITY, quality); int jpeg_size = encoder_->encode(source, destination->plane(0), exif.data(), quality); @@ -190,7 +191,7 @@ int PostProcessorJpeg::process(const FrameBuffer &source, blob->jpeg_size = jpeg_size; /* Update the JPEG result Metadata. */ - resultMetadata->addEntry(ANDROID_JPEG_SIZE, &jpeg_size, 1); + resultMetadata->addEntry(ANDROID_JPEG_SIZE, jpeg_size); return 0; }