diff --git a/camera/hal/adapter/platform/v4l2/src/device_manager/include/sensor_controller.h b/camera/hal/adapter/platform/v4l2/src/device_manager/include/sensor_controller.h index aa1c6b2affeb98ee090f7c355120d6dcc6e9f661..b30c9274bff2be10e690290c90c733b6ba6443f9 100644 --- a/camera/hal/adapter/platform/v4l2/src/device_manager/include/sensor_controller.h +++ b/camera/hal/adapter/platform/v4l2/src/device_manager/include/sensor_controller.h @@ -78,8 +78,8 @@ private: std::shared_ptr meta, const int32_t &value); static void GetBasicConfigurations(SensorController *sensorController, std::shared_ptr meta, const int32_t &value); - static void GetFpsRange(SensorController *sensorController, - std::shared_ptr meta, const int32_t &value); + void GetFpsRange(SensorController *sensorController, + std::shared_ptr meta); static void GetJpegOrientation(SensorController *sensorController, std::shared_ptr meta, const int32_t &value); static void GetJpegQuality(SensorController *sensorController, @@ -113,6 +113,7 @@ private: static std::map tagV4L2CidMap_; static std::map tagMethodMap_; bool firstSetCallback_ = true; + std::vector fpsRange_; }; } // namespace OHOS::Camera #endif diff --git a/camera/hal/adapter/platform/v4l2/src/device_manager/include/v4l2_device_manager.h b/camera/hal/adapter/platform/v4l2/src/device_manager/include/v4l2_device_manager.h index eda17f67db0066dd60269739f42c4e4c1de6ca40..401c56b3cd696c93d819a9a96baab6700ce53d27 100644 --- a/camera/hal/adapter/platform/v4l2/src/device_manager/include/v4l2_device_manager.h +++ b/camera/hal/adapter/platform/v4l2/src/device_manager/include/v4l2_device_manager.h @@ -44,7 +44,7 @@ public: void Configure(std::shared_ptr meta); void SetMetaDataCallBack(const MetaDataCb cb, CameraId cameraId = CAMERA_MAX); void SetHotplugDevCallBack(HotplugDevCb cb); - void SetAbilityMetaDataTag(std::vector& abilityMetaDataTag); + void SetAbilityMetaDataTag(std::vector abilityMetaDataTag); private: void UvcCallBack(const std::string hardwareName, std::vector& deviceControl, diff --git a/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_controller.cpp b/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_controller.cpp index 5a24c7a7969784ba305c515b570874f11d59d18a..5302cc02302b0226b3118dfabd1fc85d98aee7c7 100644 --- a/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_controller.cpp +++ b/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_controller.cpp @@ -44,6 +44,12 @@ RetCode SensorController::Init() CAMERA_LOGE("%s Create HosV4L2Dev fail", __FUNCTION__); return RC_ERROR; } + + // push default value + constexpr uint32_t FPS_FIVE = 5; + constexpr uint32_t FPS_TEN = 10; + fpsRange_.push_back(FPS_FIVE); + fpsRange_.push_back(FPS_TEN); return RC_OK; } @@ -267,8 +273,7 @@ RetCode SensorController::GetSensorMetaData(std::shared_ptr meta GetFocusMode(this, meta, outValue); outValue = 1; GetMeterMode(this, meta, outValue); - outValue = 1; - GetFpsRange(this, meta, outValue); + GetFpsRange(this, meta); outValue = 1; GetFlashMode(this, meta, outValue); rc = RC_OK; @@ -481,23 +486,32 @@ void SensorController::GetCaptureMirror(SensorController *sensorController, } void SensorController::GetFpsRange(SensorController *sensorController, - std::shared_ptr meta, const int32_t &value) + std::shared_ptr meta) { if (meta == nullptr) { CAMERA_LOGE("meta is nullptr"); return; } - std::vector vfpsRange; - int32_t fpsRange = value; - CAMERA_LOGI("Get CMD_FPS_RANGES [%{public}]", fpsRange); - vfpsRange.push_back(fpsRange); - vfpsRange.push_back(fpsRange); - std::lock_guard lock(sensorController->metaDataFlaglock_); - sensorController->metaDataFlag_ = true; - meta->addEntry(OHOS_CONTROL_FPS_RANGES, - vfpsRange.data(), - vfpsRange.size()); + for (auto iter = abilityMetaData_.cbegin(); iter != abilityMetaData_.cend(); iter++) { + switch (*iter) { + case OHOS_CONTROL_FPS_RANGES: { + DeviceFormat format; + std::lock_guard lock(sensorController->metaDataFlaglock_); + sensorController->metaDataFlag_ = true; + RetCode rc = sensorVideo_->ConfigSys(GetName(), CMD_V4L2_GET_FPS, format); + if (rc == RC_ERROR) { + CAMERA_LOGE("CMD_V4L2_GET_FPS ConfigSys fail"); + } + + // dummy data + meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange_.data(), fpsRange_.size()); + break; + } + default: + break; + } + } } RetCode SensorController::SendSensorMetaData(std::shared_ptr meta) @@ -707,15 +721,25 @@ RetCode SensorController::SendFlashMetaData(common_metadata_header_t *data) RetCode SensorController::SendFpsMetaData(common_metadata_header_t *data) { RetCode rc = RC_OK; - std::vector fpsRange; camera_metadata_item_t entry; + constexpr uint32_t GROUP_LEN = 2; + DeviceFormat format; + fpsRange_.clear(); int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry); if (ret == 0) { for (int i = 0; i < entry.count; i++) { - fpsRange.push_back(*(entry.data.i32 + i)); - CAMERA_LOGI("Set CMD_FPS_RANGE [%{public}d]", *(entry.data.i32 + i)); + fpsRange_.push_back(*(entry.data.i32 + i)); + } + if (fpsRange_.size() != GROUP_LEN) { + CAMERA_LOGE("fpsRange size error"); + return RC_ERROR; } - rc = sensorVideo_->UpdateSetting(GetName(), CMD_FPS_RANGE, (int*)&fpsRange); + CAMERA_LOGI("Set CMD_FPS_RANGE [%{public}d, %{public}d]", fpsRange_[0], fpsRange_[1]); + format.fmtdesc.fps.denominator = (fpsRange_[0] + fpsRange_[1]) / GROUP_LEN; + format.fmtdesc.fps.numerator = 1; + CAMERA_LOGI("fps.denominator: %{public}d, fps.numerator: %{public}d", + format.fmtdesc.fps.denominator, format.fmtdesc.fps.numerator); + rc = sensorVideo_->ConfigSys(GetName(), CMD_V4L2_SET_FPS, format); if (rc == RC_ERROR) { CAMERA_LOGE("Send CMD_FPS_RANGE fail"); } diff --git a/camera/hal/adapter/platform/v4l2/src/device_manager/v4l2_device_manager.cpp b/camera/hal/adapter/platform/v4l2/src/device_manager/v4l2_device_manager.cpp index c317253a756a38fe7c4c378e0b85adcb45ef29df..4b3c0b3bf782ba70774eeb7d9e6223c0ad3fd1a0 100644 --- a/camera/hal/adapter/platform/v4l2/src/device_manager/v4l2_device_manager.cpp +++ b/camera/hal/adapter/platform/v4l2/src/device_manager/v4l2_device_manager.cpp @@ -273,7 +273,7 @@ void V4L2DeviceManager::SetMetaDataCallBack(const MetaDataCb cb, CameraId camera } } -void V4L2DeviceManager::SetAbilityMetaDataTag(std::vector& abilityMetaDataTag) +void V4L2DeviceManager::SetAbilityMetaDataTag(std::vector abilityMetaDataTag) { CAMERA_LOGI("V4L2DeviceManager %{public}s: line: %{public}d", __FUNCTION__, __LINE__); CameraId cameraId = CAMERA_FIRST; diff --git a/camera/hal/pipeline_core/ipp/include/ipp_node.h b/camera/hal/pipeline_core/ipp/include/ipp_node.h index 5554a5c0352c23cc6f5ca5b1dba030406da154f2..25099390effe18ef092d036eaf817877df5d0284 100644 --- a/camera/hal/pipeline_core/ipp/include/ipp_node.h +++ b/camera/hal/pipeline_core/ipp/include/ipp_node.h @@ -52,7 +52,6 @@ protected: RetCode SendNodeMetaData(const std::shared_ptr meta); RetCode SendExposureMetaData(const common_metadata_header_t *data); RetCode SendFocusMetaData(const common_metadata_header_t *data); - RetCode SendFaceModeMetaData(const common_metadata_header_t *data); void GetNodeMetaData(std::shared_ptr meta); void GetFocusMode(std::shared_ptr meta); void GetFocusState(std::shared_ptr meta); @@ -60,10 +59,6 @@ protected: void GetExposureTime(std::shared_ptr meta); void GetExposureCompensation(std::shared_ptr meta); void GetExposureState(std::shared_ptr meta); - void GetCameraFaceDetectSwitch(std::shared_ptr meta); - void GetCameraFaceRectangles(std::shared_ptr meta); - void GetCameraFaceIds(std::shared_ptr meta); - void GetTimestamp(std::shared_ptr meta); protected: std::shared_ptr algoPluginManager_ = nullptr; diff --git a/camera/hal/pipeline_core/ipp/src/ipp_node.cpp b/camera/hal/pipeline_core/ipp/src/ipp_node.cpp index 16537f313756bf136614b8353937a1b9a32d844b..8a70d0a8a9a9745137d688e6195f3f044df78926 100644 --- a/camera/hal/pipeline_core/ipp/src/ipp_node.cpp +++ b/camera/hal/pipeline_core/ipp/src/ipp_node.cpp @@ -23,10 +23,12 @@ IppNode::IppNode(const std::string& name, const std::string& type) IppNode::~IppNode() { - GetDeviceController(); - sensorController_->SetMetaDataCallBack([this](const std::shared_ptr& metadata) { - CAMERA_LOGE("V4L2 ipp node already been destroyed!"); - }); + RetCode rc = GetDeviceController(); + if (rc == RC_ERROR) { + CAMERA_LOGE("GetDeviceController failed."); + return; + } + sensorController_->SetMetaDataCallBack(nullptr); } RetCode IppNode::Init(const int32_t streamId) @@ -81,7 +83,11 @@ RetCode IppNode::SetCallback(const MetaDataCb cb) { CAMERA_LOGI("IppNode line: %{public}d", __LINE__); metaDataCb_ = cb; - GetDeviceController(); + RetCode rc = GetDeviceController(); + if (rc == RC_ERROR) { + CAMERA_LOGE("GetDeviceController failed."); + return RC_ERROR; + } sensorController_->SetMetaDataCallBack([this](const std::shared_ptr& metadata) { OnMetadataChanged(metadata); }); @@ -218,10 +224,6 @@ RetCode IppNode::SendNodeMetaData(const std::shared_ptr meta) if (rc == RC_ERROR) { CAMERA_LOGE("SendFocusMetaData fail"); } - rc = SendFaceModeMetaData(data); - if (rc == RC_ERROR) { - CAMERA_LOGE("SendFaceModeMetaData fail"); - } return rc; } @@ -278,24 +280,6 @@ RetCode IppNode::SendFocusMetaData(const common_metadata_header_t *data) return RC_OK; } -RetCode IppNode::SendFaceModeMetaData(const common_metadata_header_t *data) -{ - RetCode rc = RC_OK; - uint8_t faceMode = 0; - camera_metadata_item_t entry; - (void) data; - - int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_SWITCH, &entry); - if (ret != 0) { - rc = RC_ERROR; - CAMERA_LOGE("Facemode not found in metadata."); - return rc; - } - faceMode = *(entry.data.u8); - CAMERA_LOGI("Set faceMode [%{public}d]", faceMode); - return rc; -} - void IppNode::DeliverBuffer(std::shared_ptr& buffer) { std::vector> cache; diff --git a/camera/hal/test/v4l2/BUILD.gn b/camera/hal/test/v4l2/BUILD.gn index 7dbc99e49565f9244a7d7e53feec0b96115e68e7..f93dbdfac06fe32ba5bc981b895af59e5c441ae9 100644 --- a/camera/hal/test/v4l2/BUILD.gn +++ b/camera/hal/test/v4l2/BUILD.gn @@ -129,6 +129,7 @@ if (defined(ohos_lite)) { sources = [ "./src/camera_ability_test.cpp", "./src/camera_capture_test.cpp", + "./src/camera_fps_test.cpp", "./src/camera_preview_test.cpp", "./src/camera_stabili_test.cpp", "./src/camera_video_test.cpp", diff --git a/camera/hal/test/v4l2/include/camera_fps_test.h b/camera/hal/test/v4l2/include/camera_fps_test.h new file mode 100644 index 0000000000000000000000000000000000000000..a937362c45ffc13df5c1feadb7baa3b6b0989692 --- /dev/null +++ b/camera/hal/test/v4l2/include/camera_fps_test.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file expected in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CAMERA_FPS_TEST_H +#define CAMERA_FPS_TEST_H + +#include "test_display.h" + +class CameraFpsTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + void GetFpsRange(std::shared_ptr &ability); + std::shared_ptr display_ = nullptr; + std::vector fpsRange_; +}; +#endif /* CAMERA_FPS_TEST_H */ \ No newline at end of file diff --git a/camera/hal/test/v4l2/include/test_display.h b/camera/hal/test/v4l2/include/test_display.h index 1cdf86070f9d148b4034d1e2c0103d6fd1260199..e644bebb1b7e09669816ef23aa527e87e0773b7e 100644 --- a/camera/hal/test/v4l2/include/test_display.h +++ b/camera/hal/test/v4l2/include/test_display.h @@ -172,6 +172,7 @@ public: void OnResult(const uint64_t timestamp, const std::shared_ptr& result) override; void PrintStabiliInfo(const std::shared_ptr& result); + void PrintFpsInfo(const std::shared_ptr& result); }; #endif #endif diff --git a/camera/hal/test/v4l2/src/camera_fps_test.cpp b/camera/hal/test/v4l2/src/camera_fps_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8c3d5fa3e463124f6c626d636b590fe67a915d05 --- /dev/null +++ b/camera/hal/test/v4l2/src/camera_fps_test.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file expected in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "camera_fps_test.h" + +using namespace testing::ext; + +void CameraFpsTest::SetUpTestCase(void) +{} +void CameraFpsTest::TearDownTestCase(void) +{} +void CameraFpsTest::SetUp(void) +{ + if (display_ == nullptr) { + display_ = std::make_shared(); + } + display_->Init(); +} +void CameraFpsTest::TearDown(void) +{ + display_->Close(); +} + +void CameraFpsTest::GetFpsRange(std::shared_ptr &ability) +{ + common_metadata_header_t* data = ability->get(); + fpsRange_.clear(); + camera_metadata_item_t entry; + int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); + if (ret != 0) { + std::cout << "==========[test log] get OHOS_ABILITY_FPS_RANGES error." << std::endl; + } + + uint32_t count = entry.count; + for (int i = 0 ; i < count; i++) { + fpsRange_.push_back(*(entry.data.i32 + i)); + } + + for (auto it = fpsRange_.begin(); it != fpsRange_.end(); it++) { + std::cout << "==========[test log] fpsRange : " << *it << std::endl; + } +} + +/** + * @tc.name: fps Setting + * @tc.desc: UpdateSettings, fps. + * @tc.level: Level1 + * @tc.size: MediumTest + * @tc.type: Function + */ +static HWTEST_F(CameraFpsTest, camera_fps_001, TestSize.Level1) +{ + // get camera ability + if (display_->ability == nullptr) { + std::cout << "==========[test log] ability is null." << std::endl; + return; + } + GetFpsRange(display_->ability); + + // get the stream manager + display_->AchieveStreamOperator(); + + // enable result + std::vector resultsList; + resultsList.push_back(OHOS_CONTROL_FPS_RANGES); + display_->cameraDevice->EnableResult(resultsList); + + // start stream + display_->intents = {OHOS::Camera::PREVIEW}; + display_->StartStream(display_->intents); + + // updateSettings + constexpr uint32_t ITEM_CAPACITY = 100; + constexpr uint32_t DATA_CAPACITY = 2000; + std::shared_ptr meta = std::make_shared( + ITEM_CAPACITY, DATA_CAPACITY); + std::vector fpsRange; + fpsRange.push_back(fpsRange_[0]); + fpsRange.push_back(fpsRange_[1]); + meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size()); + display_->rc = display_->cameraDevice->UpdateSettings(meta); + if (display_->rc == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log] UpdateSettings success." << std::endl; + } else { + std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl; + } + + // get preview + display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true); + + // release stream + display_->captureIds = {display_->captureId_preview}; + display_->streamIds = {display_->streamId_preview}; + display_->StopStream(display_->captureIds, display_->streamIds); +} \ No newline at end of file diff --git a/camera/hal/test/v4l2/src/test_display.cpp b/camera/hal/test/v4l2/src/test_display.cpp index 33ef9e77a78757c8cd8a90eb198c293c1e3728dc..d6db825c9b789fba1d32c023051cfce43149df22 100644 --- a/camera/hal/test/v4l2/src/test_display.cpp +++ b/camera/hal/test/v4l2/src/test_display.cpp @@ -638,6 +638,33 @@ void DemoCameraDeviceCallback::PrintStabiliInfo(const std::shared_ptr& result) +{ + if (result == nullptr) { + CAMERA_LOGE("TestDisplay: result is null"); + return; + } + common_metadata_header_t* data = result->get(); + if (data == nullptr) { + CAMERA_LOGE("TestDisplay: data is null"); + return; + } + std::vector fpsRange; + camera_metadata_item_t entry; + int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry); + if (ret != 0) { + CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error\n"); + return; + } + + for (int i = 0; i < entry.count; i++) { + fpsRange.push_back(*(entry.data.i32 + i)); + } + CAMERA_LOGI("Set fpsRange: [%{public}d, %{public}d]", fpsRange[0], fpsRange[1]); + std::cout << "==========[test log] PrintFpsInfo fpsRange: [" << fpsRange[0] << ", " << + fpsRange[1] << "]" << std::endl; +} + #ifndef CAMERA_BUILT_ON_OHOS_LITE void DemoCameraDeviceCallback::OnError(const OHOS::Camera::ErrorType type, const int32_t errorMsg) { @@ -648,5 +675,6 @@ void DemoCameraDeviceCallback::OnResult(const uint64_t timestamp, const std::shared_ptr& result) { PrintStabiliInfo(result); + PrintFpsInfo(result); } #endif