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 151b480c98e82efd029679c66a02b1225805abb1..aa1c6b2affeb98ee090f7c355120d6dcc6e9f661 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 @@ -103,6 +103,7 @@ private: bool startSensorState_ = false; NodeBufferCb nodeBufferCb_ = nullptr; MetaDataCb metaDataCb_ = nullptr; + MetaDataCb fromDeviceMetaDataCb_ = nullptr; std::vector abilityMetaData_; std::mutex metaDataSetlock_; std::mutex metaDataFlaglock_; @@ -111,6 +112,7 @@ private: std::shared_ptr sensorVideo_; static std::map tagV4L2CidMap_; static std::map tagMethodMap_; + bool firstSetCallback_ = true; }; } // namespace OHOS::Camera #endif 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 19e8f9496096df2b8e0c394737de91ed67cd1fc5..5a24c7a7969784ba305c515b570874f11d59d18a 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 @@ -132,9 +132,19 @@ void SensorController::SetNodeCallBack(const NodeBufferCb cb) void SensorController::SetMetaDataCallBack(const MetaDataCb cb) { - CAMERA_LOGI("SensorController line: %{public}d", __LINE__); std::lock_guard lock(metaDataFlaglock_); - metaDataCb_ = cb; + if (firstSetCallback_) { + CAMERA_LOGI("SensorController line: %{public}d", __LINE__); + firstSetCallback_ = false; + fromDeviceMetaDataCb_ = cb; + metaDataCb_ = fromDeviceMetaDataCb_; + } else if (cb == nullptr) { + CAMERA_LOGI("SensorController line: %{public}d", __LINE__); + metaDataCb_ = fromDeviceMetaDataCb_; + } else { + CAMERA_LOGI("SensorController line: %{public}d", __LINE__); + metaDataCb_ = cb; + } } void SensorController::BufferCallback(std::shared_ptr buffer) @@ -399,11 +409,15 @@ void SensorController::GetExposureCompensation(SensorController *sensorControlle return; } int32_t exposureCompensation = value; - + constexpr uint32_t DATA_COUNT = 1; CAMERA_LOGI("Get CMD_FEXPOSURE_COMPENSATION [%{public}]", exposureCompensation); std::lock_guard lock(sensorController->metaDataFlaglock_); sensorController->metaDataFlag_ = true; - meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &exposureCompensation, 1); + meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &exposureCompensation, DATA_COUNT); + + // dummy data + uint8_t videoStabiliMode = OHOS_CAMERA_VIDEO_STABILIZATION_OFF; + meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT); } void SensorController::GetMeterMode(SensorController *sensorController, diff --git a/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_manager.cpp b/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_manager.cpp index 9acc90201726de376678e61398b1201bdd625bc0..4056acc0fa5c50ef29a2b6fea5bc76f68899c071 100644 --- a/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_manager.cpp +++ b/camera/hal/adapter/platform/v4l2/src/device_manager/sensor_manager.cpp @@ -154,8 +154,12 @@ void SensorManager::SetNodeCallBack(const NodeBufferCb cb, std::string hardwareN void SensorManager::SetMetaDataCallBack(const MetaDataCb cb, std::string hardwareName) { - (void) cb; - (void) hardwareName; + for (auto iter = sensorList_.cbegin(); iter != sensorList_.cend(); iter++) { + if ((*iter)->GetName() == hardwareName) { + (*iter)->SetMetaDataCallBack(cb); + return; + } + } } RetCode SensorManager::DestroyController(ControllerId controllerId, std::string hardwareName) diff --git a/camera/hal/hdi_impl/include/camera_host/hcs_deal.h b/camera/hal/hdi_impl/include/camera_host/hcs_deal.h index ca355eeabb6be3e150ab15b0ff7cd4a1d31c2def..de870a34e9259d5ac659f46975bc15f598022cd4 100644 --- a/camera/hal/hdi_impl/include/camera_host/hcs_deal.h +++ b/camera/hal/hdi_impl/include/camera_host/hcs_deal.h @@ -112,7 +112,9 @@ private: RetCode DealSensorOrientation( const struct DeviceResourceNode &metadataNode, std::shared_ptr &metadata); - + RetCode DealAvalialbleVideoStabilizationModes( + const struct DeviceResourceNode &metadataNode, + std::shared_ptr &metadata); private: std::string sPathName; const struct DeviceResourceIface *pDevResIns; diff --git a/camera/hal/hdi_impl/src/camera_host/hcs_deal.cpp b/camera/hal/hdi_impl/src/camera_host/hcs_deal.cpp index 53e0829887b92ec3f67d6acaf60598512e06ca60..0911ae82b686948e327bc47e7397ed54d455ff51 100644 --- a/camera/hal/hdi_impl/src/camera_host/hcs_deal.cpp +++ b/camera/hal/hdi_impl/src/camera_host/hcs_deal.cpp @@ -175,6 +175,7 @@ RetCode HcsDeal::DealMetadata(const std::string &cameraId, const struct DeviceRe DealMirrorSupported(node, metadata); DealAvaliableBasicConfigurations(node, metadata); DealSensorOrientation(node, metadata); + DealAvalialbleVideoStabilizationModes(node, metadata); cameraMetadataMap_.insert(std::make_pair(cameraId, metadata)); return RC_OK; @@ -756,6 +757,37 @@ RetCode HcsDeal::DealSensorOrientation( return RC_OK; } +RetCode HcsDeal::DealAvalialbleVideoStabilizationModes( + const struct DeviceResourceNode &metadataNode, + std::shared_ptr &metadata) +{ + uint8_t hcbRet = 0; + const char *nodeValue = nullptr; + std::vector videoStabilizationAvailableModes; + + int32_t elemNum = pDevResIns->GetElemNum( + &metadataNode, "videoStabilizationAvailableModes"); + CAMERA_LOGI("elemNum = %{public}d", elemNum); + for (int i = 0; i < elemNum; i++) { + hcbRet = pDevResIns->GetStringArrayElem( + &metadataNode, "videoStabilizationAvailableModes", i, &nodeValue, nullptr); + if (hcbRet != 0) { + CAMERA_LOGE("get videoStabilizationAvailableModes failed"); + continue; + } + CAMERA_LOGI("nodeValue = %{public}s", nodeValue); + videoStabilizationAvailableModes.push_back(videoStabilizationMap[std::string(nodeValue)]); + } + bool ret = metadata->addEntry(OHOS_ABILITY_VIDEO_STABILIZATION_MODES, + videoStabilizationAvailableModes.data(), videoStabilizationAvailableModes.size()); + if (!ret) { + CAMERA_LOGE("videoStabilizationAvailableModes add failed"); + return RC_ERROR; + } + CAMERA_LOGI("videoStabilizationAvailableModes add success"); + return RC_OK; +} + RetCode HcsDeal::GetMetadata(CameraMetadataMap &metadataMap) const { metadataMap = cameraMetadataMap_; diff --git a/camera/hal/test/v4l2/BUILD.gn b/camera/hal/test/v4l2/BUILD.gn index faca0666445843aaf58d63814118183bef574cfe..ce837693395c5f919ca779702673e16f9d021922 100644 --- a/camera/hal/test/v4l2/BUILD.gn +++ b/camera/hal/test/v4l2/BUILD.gn @@ -128,6 +128,7 @@ if (defined(ohos_lite)) { module_out_path = module_output_path sources = [ "./src/camera_ability_test.cpp", + "./src/camera_stabili_test.cpp", "./src/double_preview_test.cpp", "./src/hdfcamera_facedetect.cpp", "./src/open_camera_test.cpp", diff --git a/camera/hal/test/v4l2/include/camera_stabili_test.h b/camera/hal/test/v4l2/include/camera_stabili_test.h new file mode 100644 index 0000000000000000000000000000000000000000..2a351fc12ffe3aedc8f9a8deb76ed804323f821d --- /dev/null +++ b/camera/hal/test/v4l2/include/camera_stabili_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_STABILI_TEST_H +#define CAMERA_STABILI_TEST_H + +#include "test_display.h" + +class CameraStabiliTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + void GetAvalialbleVideoStabilizationModes(std::shared_ptr &ability); + std::shared_ptr display_ = nullptr; + std::vector videoStabilizationAvailableModes_; +}; +#endif /* CAMERA_STABILI_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 fff59fd4745add1d988afa07f33de7925d81d602..f36f06ace9a6f1fccc944eddf13bbd109c465790 100644 --- a/camera/hal/test/v4l2/include/test_display.h +++ b/camera/hal/test/v4l2/include/test_display.h @@ -161,4 +161,16 @@ public: void PrintFaceDetectInfo(const void *bufStart, const uint32_t size) const; int videoFd_ = -1; }; + +#ifndef CAMERA_BUILT_ON_OHOS_LITE +class DemoCameraDeviceCallback : public OHOS::Camera::CameraDeviceCallbackStub { +public: + DemoCameraDeviceCallback() = default; + virtual ~DemoCameraDeviceCallback() = default; + void OnError(OHOS::Camera::ErrorType type, int32_t errorMsg) override; + void OnResult(const uint64_t timestamp, + const std::shared_ptr& result) override; + void PrintStabiliInfo(const std::shared_ptr& result); +}; +#endif #endif diff --git a/camera/hal/test/v4l2/src/camera_stabili_test.cpp b/camera/hal/test/v4l2/src/camera_stabili_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7fb81833af0eb032bd08c486fe3d19ba311ee31b --- /dev/null +++ b/camera/hal/test/v4l2/src/camera_stabili_test.cpp @@ -0,0 +1,100 @@ +/* + * 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_stabili_test.h" + +using namespace testing::ext; + +void CameraStabiliTest::SetUpTestCase(void) +{} +void CameraStabiliTest::TearDownTestCase(void) +{} +void CameraStabiliTest::SetUp(void) +{ + if (display_ == nullptr) { + display_ = std::make_shared(); + } + display_->Init(); +} +void CameraStabiliTest::TearDown(void) +{ + display_->Close(); +} + +void CameraStabiliTest::GetAvalialbleVideoStabilizationModes( + std::shared_ptr &ability) +{ + common_metadata_header_t* data = ability->get(); + videoStabilizationAvailableModes_.clear(); + camera_metadata_item_t entry; + int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); + if (ret != 0) { + std::cout << "==========[test log] get OHOS_ABILITY_VIDEO_STABILIZATION_MODES error." << std::endl; + } + uint32_t count = entry.count; + for (int i = 0 ; i < count; i++) { + videoStabilizationAvailableModes_.push_back(*(entry.data.u8 + i)); + } + for (auto it = videoStabilizationAvailableModes_.begin(); it != videoStabilizationAvailableModes_.end(); it++) { + std::cout << "==========[test log] videoStabilizationAvailableModes : " << (int)*it << std::endl; + } +} + +/** + * @tc.name: stabili setting + * @tc.desc: UpdateSettings, OHOS_CONTROL_VIDEO_STABILIZATION_MODE. + * @tc.level: Level1 + * @tc.size: MediumTest + * @tc.type: Function + */ +static HWTEST_F(CameraStabiliTest, camera_stabili_001, TestSize.Level1) +{ + // get camera ability + if (display_->ability == nullptr) { + std::cout << "==========[test log] ability is null." << std::endl; + return; + } + GetAvalialbleVideoStabilizationModes(display_->ability); + + // get the stream manager + display_->AchieveStreamOperator(); + + // start stream + display_->intents = {OHOS::Camera::PREVIEW, OHOS::Camera::VIDEO}; + display_->StartStream(display_->intents); + + // updateSettings + constexpr uint32_t ITEM_CAPACITY = 100; + constexpr uint32_t DATA_CAPACITY = 2000; + constexpr uint32_t DATA_COUNT = 1; + std::shared_ptr meta = std::make_shared( + ITEM_CAPACITY, DATA_CAPACITY); + uint8_t videoStabiliMode = videoStabilizationAvailableModes_[0]; + bool addEntryRet = meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT); + + 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 e251faeaff5f71d46083800d3cb357aef8d097a7..af0393fdcd6139623af3e5b27e45502859550568 100644 --- a/camera/hal/test/v4l2/src/test_display.cpp +++ b/camera/hal/test/v4l2/src/test_display.cpp @@ -361,7 +361,7 @@ void TestDisplay::Init() if (cameraDevice == nullptr) { cameraHost->GetCameraIds(cameraIds); cameraHost->GetCameraAbility(cameraIds.front(), ability); - const OHOS::sptr callback = new CameraDeviceCallback(); + const OHOS::sptr callback = new DemoCameraDeviceCallback(); rc = cameraHost->OpenCamera(cameraIds.front(), callback, cameraDevice); if (rc != OHOS::Camera::NO_ERROR || cameraDevice == nullptr) { std::cout << "==========[test log] OpenCamera failed, rc = " << rc << std::endl; @@ -603,3 +603,39 @@ void TestDisplay::StopStream(std::vector& captureIds, std::vector& str } } } + +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; + } + uint8_t videoStabiliMode; + camera_metadata_item_t entry; + int ret = FindCameraMetadataItem(data, OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &entry); + if (ret != 0) { + CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error\n"); + return; + } + videoStabiliMode = *(entry.data.u8); + CAMERA_LOGI("videoStabiliMode: %{public}d", videoStabiliMode); + std::cout << "==========[test log] PrintStabiliInfo videoStabiliMode: " << (int)videoStabiliMode << std::endl; +} + +#ifndef CAMERA_BUILT_ON_OHOS_LITE +void DemoCameraDeviceCallback::OnError(const OHOS::Camera::ErrorType type, const int32_t errorMsg) +{ + CAMERA_LOGI("demo test: OnError type : %{public}d, errorMsg : %{public}d", type, errorMsg); +} + +void DemoCameraDeviceCallback::OnResult(const uint64_t timestamp, + const std::shared_ptr& result) +{ + PrintStabiliInfo(result); +} +#endif