From 82bf80d8588c2cbd04a7f3cd1ed32a57d14f55ed Mon Sep 17 00:00:00 2001 From: zhuxu Date: Sat, 25 Jun 2022 11:31:13 +0800 Subject: [PATCH] support set focus and exposure mode Signed-off-by: zhuxu --- .../dcamera_device/dmetadata_processor.h | 15 +- .../dstream_operator/dstream_operator.h | 3 +- .../src/dcamera_device/dcamera_device.cpp | 10 +- .../dcamera_device/dmetadata_processor.cpp | 177 +++++++++++++----- .../src/dstream_operator/dstream_operator.cpp | 17 +- .../include/callback/dcamera_input_callback.h | 13 +- .../client/include/icamera_operator.h | 4 +- .../src/callback/dcamera_input_callback.cpp | 41 +++- .../client/src/dcamera_client.cpp | 32 +++- .../client/src/dcamera_client_common.cpp | 3 +- .../cameraoperator/dcamera_client_test.cpp | 4 +- .../dcamera_sink_controller_state_callback.h | 4 +- .../dcamera_sink_controller.h | 4 +- ...dcamera_sink_controller_state_callback.cpp | 6 +- .../dcamera_sink_controller.cpp | 35 +++- .../dcamera_source_controller.cpp | 6 +- .../dcamera_stream_data_process.cpp | 4 +- .../color_format_process.cpp | 6 +- 18 files changed, 281 insertions(+), 103 deletions(-) diff --git a/camera_hdf/hdi_impl/include/dcamera_device/dmetadata_processor.h b/camera_hdf/hdi_impl/include/dcamera_device/dmetadata_processor.h index 4aa2c98c..4692bf5f 100644 --- a/camera_hdf/hdi_impl/include/dcamera_device/dmetadata_processor.h +++ b/camera_hdf/hdi_impl/include/dcamera_device/dmetadata_processor.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -18,6 +18,7 @@ #include #include +#include #include #include "constants.h" #include "dcamera.h" @@ -47,7 +48,8 @@ public: DCamRetCode DisableMetadataResult(const std::vector &results); DCamRetCode ResetEnableResults(); DCamRetCode SaveResultMetadata(std::string resultStr); - DCamRetCode UpdateResultMetadata(bool &needReturn, std::shared_ptr &result); + void UpdateResultMetadata(const uint64_t &resultTimestamp); + void SetResultCallback(std::function)> &resultCbk); void PrintDCameraMetadata(const common_metadata_header_t *metadata); private: @@ -58,10 +60,14 @@ private: void ConvertToCameraMetadata(common_metadata_header_t *&input, std::shared_ptr &output); void ResizeMetadataHeader(common_metadata_header_t *&header, uint32_t itemCapacity, uint32_t dataCapacity); + void UpdateAllResult(const uint64_t &resultTimestamp); + void UpdateOnChanged(const uint64_t &resultTimestamp); uint32_t GetDataSize(uint32_t type); + void* GetMetadataItemData(const camera_metadata_item_t &item); std::map> GetDCameraSupportedFormats(const std::string &abilityInfo); private: + std::function)> resultCallback_; std::shared_ptr dCameraAbility_; std::string protocolVersion_; std::string dCameraPosition_; @@ -70,12 +76,13 @@ private: ResultCallbackMode metaResultMode_; std::set allResultSet_; std::set enabledResultSet_; + std::mutex producerMutex_; // The latest result metadata that received from the sink device. - common_metadata_header_t *latestProducerResultMetadata_; + std::shared_ptr latestProducerMetadataResult_; // The latest result metadata that replied to the camera service. - common_metadata_header_t *latestConsumerResultMetadata_; + std::shared_ptr latestConsumerMetadataResult_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h b/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h index d2909a68..4e14f362 100644 --- a/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h +++ b/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -97,7 +97,6 @@ private: std::shared_ptr dMetadataProcessor_; OHOS::sptr dcStreamOperatorCallback_; function errorCallback_; - function)> resultCallback_; DHBase dhBase_; std::vector dcSupportedCodecType_; diff --git a/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp b/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp index f1348a29..dc9c03e4 100644 --- a/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp +++ b/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp @@ -70,12 +70,14 @@ DCamRetCode DCameraDevice::CreateDStreamOperator() ErrorCallback onErrorCallback = [this](ErrorType type, int32_t errorMsg) -> void { if (dCameraDeviceCallback_) { + DHLOGI("DCameraDevice onErrorCallback type: %u, errorMsg: %d", type, errorMsg); dCameraDeviceCallback_->OnError(type, errorMsg); } }; ResultCallback onResultCallback = [this](uint64_t timestamp, const std::shared_ptr &result) -> void { if (dCameraDeviceCallback_) { + DHLOGI("DCameraDevice onResultCallback timestamp: %llu", timestamp); dCameraDeviceCallback_->OnResult(timestamp, result); } }; @@ -119,11 +121,13 @@ CamRetCode DCameraDevice::UpdateSettings(const std::shared_ptr &s return CamRetCode::CAMERA_CLOSED; } - DCameraSettings dcSetting; + std::string abilityString = Camera::MetadataUtils::EncodeToString(settings); + std::string encodeString = Base64Encode(reinterpret_cast(abilityString.c_str()), + abilityString.length()); + DCameraSettings dcSetting; dcSetting.type_ = DCSettingsType::UPDATE_METADATA; - std::string abilityStr = Camera::MetadataUtils::EncodeToString(settings); - dcSetting.value_ = Base64Encode(reinterpret_cast(abilityStr.c_str()), abilityStr.length()); + dcSetting.value_ = encodeString; std::vector dcSettings; dcSettings.push_back(dcSetting); diff --git a/camera_hdf/hdi_impl/src/dcamera_device/dmetadata_processor.cpp b/camera_hdf/hdi_impl/src/dcamera_device/dmetadata_processor.cpp index 9fd16c9c..afc80e54 100644 --- a/camera_hdf/hdi_impl/src/dcamera_device/dmetadata_processor.cpp +++ b/camera_hdf/hdi_impl/src/dcamera_device/dmetadata_processor.cpp @@ -365,64 +365,86 @@ DCamRetCode DMetadataProcessor::ResetEnableResults() return SUCCESS; } -DCamRetCode DMetadataProcessor::UpdateResultMetadata(bool &needReturn, - std::shared_ptr &result) +void DMetadataProcessor::UpdateResultMetadata(const uint64_t &resultTimestamp) { - if (latestProducerResultMetadata_ == nullptr) { - needReturn = false; - return SUCCESS; + DHLOGD("DMetadataProcessor::UpdateResultMetadata result callback mode: %d", metaResultMode_); + if (metaResultMode_ != ResultCallbackMode::PER_FRAME) { + return; } - uint32_t itemCapacity = Camera::GetCameraMetadataItemCapacity(latestProducerResultMetadata_); - uint32_t dataCapacity = Camera::GetCameraMetadataDataSize(latestProducerResultMetadata_); + std::lock_guard autoLock(producerMutex_); + if (latestProducerMetadataResult_ == nullptr) { + DHLOGD("DMetadataProcessor::UpdateResultMetadata latest producer metadata result is null"); + return; + } - if (metaResultMode_ == ResultCallbackMode::PER_FRAME) { - ResizeMetadataHeader(latestConsumerResultMetadata_, itemCapacity, dataCapacity); - Camera::CopyCameraMetadataItems(latestConsumerResultMetadata_, latestProducerResultMetadata_); - ConvertToCameraMetadata(latestConsumerResultMetadata_, result); - needReturn = true; - return SUCCESS; - } else { - for (auto tag : enabledResultSet_) { - camera_metadata_item_t item; - camera_metadata_item_t anoItem; - int ret1 = Camera::FindCameraMetadataItem(latestProducerResultMetadata_, tag, &item); - int ret2 = Camera::FindCameraMetadataItem(latestConsumerResultMetadata_, tag, &anoItem); - if (ret1 == 0 && ret2 == 0) { - if (item.count != anoItem.count || item.data_type != anoItem.data_type) { - ResizeMetadataHeader(latestConsumerResultMetadata_, itemCapacity, dataCapacity); - Camera::CopyCameraMetadataItems(latestConsumerResultMetadata_, - latestProducerResultMetadata_); - ConvertToCameraMetadata(latestConsumerResultMetadata_, result); + UpdateAllResult(resultTimestamp); +} + +void DMetadataProcessor::SetResultCallback( + std::function)> &resultCbk) +{ + resultCallback_ = resultCbk; +} + +void DMetadataProcessor::UpdateAllResult(const uint64_t &resultTimestamp) +{ + uint32_t itemCap = Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); + uint32_t dataSize = Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); + DHLOGD("DMetadataProcessor::UpdateAllResult itemCapacity: %u, dataSize: %u", itemCap, dataSize); + std::shared_ptr result = std::make_shared(itemCap, dataSize); + int32_t ret = Camera::CopyCameraMetadataItems(result->get(), latestProducerMetadataResult_->get()); + if (ret != CAM_META_SUCCESS) { + DHLOGE("DMetadataProcessor::UpdateAllResult copy metadata item failed, ret: %d", ret); + return; + } + resultCallback_(resultTimestamp, result); +} + +void DMetadataProcessor::UpdateOnChanged(const uint64_t &resultTimestamp) +{ + bool needReturn = false; + uint32_t itemCap = Camera::GetCameraMetadataItemCapacity(latestProducerMetadataResult_->get()); + uint32_t dataSize = Camera::GetCameraMetadataDataSize(latestProducerMetadataResult_->get()); + DHLOGD("DMetadataProcessor::UpdateOnChanged itemCapacity: %u, dataSize: %u", itemCap, dataSize); + std::shared_ptr result = std::make_shared(itemCap, dataSize); + DHLOGD("DMetadataProcessor::UpdateOnChanged enabledResultSet size: %d", enabledResultSet_.size()); + for (auto tag : enabledResultSet_) { + DHLOGD("DMetadataProcessor::UpdateOnChanged cameta device metadata tag: %d", tag); + camera_metadata_item_t item; + camera_metadata_item_t anoItem; + int ret1 = Camera::FindCameraMetadataItem(latestProducerMetadataResult_->get(), tag, &item); + int ret2 = Camera::FindCameraMetadataItem(latestConsumerMetadataResult_->get(), tag, &anoItem); + DHLOGD("DMetadataProcessor::UpdateOnChanged find metadata item ret: %d, %d", ret1, ret2); + if (ret1 != CAM_META_SUCCESS) { + continue; + } + + if (ret2 == CAM_META_SUCCESS) { + if ((item.count != anoItem.count) || (item.data_type != anoItem.data_type)) { + needReturn = true; + result->addEntry(tag, GetMetadataItemData(item), item.count); + continue; + } + uint32_t size = GetDataSize(item.data_type); + DHLOGD("DMetadataProcessor::UpdateOnChanged data size: %u", size); + for (uint32_t i = 0; i < (size * static_cast(item.count)); i++) { + if (*(item.data.u8 + i) != *(anoItem.data.u8 + i)) { needReturn = true; - return SUCCESS; - } else { - uint32_t size = GetDataSize(item.data_type); - for (uint32_t i = 0; i < (size * static_cast(item.count)); i++) { - if (*(item.data.u8 + i) != *(anoItem.data.u8 + i)) { - ResizeMetadataHeader(latestConsumerResultMetadata_, itemCapacity, dataCapacity); - Camera::CopyCameraMetadataItems(latestConsumerResultMetadata_, - latestProducerResultMetadata_); - ConvertToCameraMetadata(latestConsumerResultMetadata_, result); - needReturn = true; - return SUCCESS; - } - } - ResizeMetadataHeader(latestConsumerResultMetadata_, itemCapacity, dataCapacity); - Camera::CopyCameraMetadataItems(latestConsumerResultMetadata_, - latestProducerResultMetadata_); - needReturn = false; + result->addEntry(tag, GetMetadataItemData(item), item.count); + break; } - } else if (ret1 == 0 || ret2 == 0) { - ResizeMetadataHeader(latestConsumerResultMetadata_, itemCapacity, dataCapacity); - Camera::CopyCameraMetadataItems(latestConsumerResultMetadata_, latestProducerResultMetadata_); - ConvertToCameraMetadata(latestConsumerResultMetadata_, result); - needReturn = true; - return SUCCESS; } + } else { + needReturn = true; + result->addEntry(tag, GetMetadataItemData(item), item.count); + continue; } } - return SUCCESS; + + if (needReturn) { + resultCallback_(resultTimestamp, result); + } } DCamRetCode DMetadataProcessor::SaveResultMetadata(std::string resultStr) @@ -432,17 +454,37 @@ DCamRetCode DMetadataProcessor::SaveResultMetadata(std::string resultStr) return DCamRetCode::INVALID_ARGUMENT; } - latestProducerResultMetadata_ = Camera::MetadataUtils::DecodeFromString(resultStr)->get(); - if (latestProducerResultMetadata_ == nullptr) { + std::string metadataStr = Base64Decode(resultStr); + std::lock_guard autoLock(producerMutex_); + latestConsumerMetadataResult_ = latestProducerMetadataResult_; + latestProducerMetadataResult_ = Camera::MetadataUtils::DecodeFromString(metadataStr); + if (latestProducerMetadataResult_ == nullptr) { DHLOGE("Failed to decode metadata setting from string."); return DCamRetCode::INVALID_ARGUMENT; } - if (!Camera::GetCameraMetadataItemCount(latestProducerResultMetadata_)) { + if (!Camera::GetCameraMetadataItemCount(latestProducerMetadataResult_->get())) { DHLOGE("Input result metadata item is empty."); return DCamRetCode::INVALID_ARGUMENT; } + DHLOGD("DMetadataProcessor::SaveResultMetadata result callback mode: %d", metaResultMode_); + if (metaResultMode_ != ResultCallbackMode::ON_CHANGED) { + return SUCCESS; + } + + uint64_t resultTimestamp = GetCurrentLocalTimeStamp(); + if (latestConsumerMetadataResult_ == nullptr) { + UpdateAllResult(resultTimestamp); + return SUCCESS; + } + + camera_metadata_item_entry_t* itemEntry = Camera::GetMetadataItems(latestProducerMetadataResult_->get()); + uint32_t count = latestProducerMetadataResult_->get()->item_count; + for (uint32_t i = 0; i < count; i++, itemEntry++) { + enabledResultSet_.insert((MetaType)(itemEntry->item)); + } + UpdateOnChanged(resultTimestamp); return SUCCESS; } @@ -488,6 +530,37 @@ uint32_t DMetadataProcessor::GetDataSize(uint32_t type) return size; } +void* DMetadataProcessor::GetMetadataItemData(const camera_metadata_item_t &item) +{ + switch (item.data_type) { + case META_TYPE_BYTE: { + return item.data.u8; + } + case META_TYPE_INT32: { + return item.data.i32; + } + case META_TYPE_UINT32: { + return item.data.ui32; + } + case META_TYPE_FLOAT: { + return item.data.f; + } + case META_TYPE_INT64: { + return item.data.i64; + } + case META_TYPE_DOUBLE: { + return item.data.d; + } + case META_TYPE_RATIONAL: { + return item.data.r; + } + default: { + DHLOGE("DMetadataProcessor::GetMetadataItemData invalid data type: %u", item.data_type); + return nullptr; + } + } +} + std::map> DMetadataProcessor::GetDCameraSupportedFormats(const std::string &abilityInfo) { std::map> supportedFormats; diff --git a/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp b/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp index e173080f..71685cb1 100644 --- a/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp +++ b/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp @@ -290,11 +290,11 @@ CamRetCode DStreamOperator::Capture(int captureId, const std::shared_ptrstreamIds_) { - if (halStreamMap_.find(id) == halStreamMap_.end()) { + auto iter = halStreamMap_.find(id); + if (iter == halStreamMap_.end()) { DHLOGE("Invalid stream id %d", id); return CamRetCode::INVALID_ARGUMENT; } - auto iter = halStreamMap_.find(id); if (!iter->second->HasBufferQueue()) { DHLOGE("Stream %d has not bufferQueue.", iter->first); return CamRetCode::INVALID_ARGUMENT; @@ -564,16 +564,7 @@ DCamRetCode DStreamOperator::ShutterBuffer(int streamId, const DCameraBuffer &bu } uint64_t resultTimestamp = GetCurrentLocalTimeStamp(); - bool needReturn = false; - std::shared_ptr result = nullptr; - DCamRetCode ret = dMetadataProcessor_->UpdateResultMetadata(needReturn, result); - if (ret != DCamRetCode::SUCCESS) { - DHLOGE("Cannot handle result metadata."); - return ret; - } - if (needReturn) { - resultCallback_(resultTimestamp, result); - } + dMetadataProcessor_->UpdateResultMetadata(resultTimestamp); auto anIter = enableShutterCbkMap_.find(streamId); if (anIter->second) { @@ -599,7 +590,7 @@ DCamRetCode DStreamOperator::SetDeviceCallback( std::function)> &resultCbk) { errorCallback_ = errorCbk; - resultCallback_ = resultCbk; + dMetadataProcessor_->SetResultCallback(resultCbk); return SUCCESS; } diff --git a/services/cameraservice/cameraoperator/client/include/callback/dcamera_input_callback.h b/services/cameraservice/cameraoperator/client/include/callback/dcamera_input_callback.h index 52c11d3d..5efe7702 100644 --- a/services/cameraservice/cameraoperator/client/include/callback/dcamera_input_callback.h +++ b/services/cameraservice/cameraoperator/client/include/callback/dcamera_input_callback.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -18,17 +18,26 @@ #include "camera_input.h" +#include + +#include "camera_device_ability_items.h" #include "icamera_operator.h" namespace OHOS { namespace DistributedHardware { -class DCameraInputCallback : public CameraStandard::ErrorCallback { +class DCameraInputCallback : public CameraStandard::ErrorCallback, public CameraStandard::FocusCallback { public: explicit DCameraInputCallback(const std::shared_ptr& callback); void OnError(const int32_t errorType, const int32_t errorMsg) const override; + void OnFocusState(FocusState state) override; private: std::shared_ptr callback_; + const std::map focusStateMap_ = { + {FocusCallback::SCAN, OHOS_CAMERA_FOCUS_STATE_SCAN}, + {FocusCallback::FOCUSED, OHOS_CAMERA_FOCUS_STATE_FOCUSED}, + {FocusCallback::UNFOCUSED, OHOS_CAMERA_FOCUS_STATE_UNFOCUSED} + }; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/cameraservice/cameraoperator/client/include/icamera_operator.h b/services/cameraservice/cameraoperator/client/include/icamera_operator.h index fe0ea192..1cee3a13 100644 --- a/services/cameraservice/cameraoperator/client/include/icamera_operator.h +++ b/services/cameraservice/cameraoperator/client/include/icamera_operator.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -35,7 +35,7 @@ public: virtual ~StateCallback() = default; virtual void OnStateChanged(std::shared_ptr& event) = 0; - virtual void OnMetadataResult() = 0; + virtual void OnMetadataResult(std::vector>& settings) = 0; }; class ResultCallback { diff --git a/services/cameraservice/cameraoperator/client/src/callback/dcamera_input_callback.cpp b/services/cameraservice/cameraoperator/client/src/callback/dcamera_input_callback.cpp index 8d980fd5..34f62a41 100644 --- a/services/cameraservice/cameraoperator/client/src/callback/dcamera_input_callback.cpp +++ b/services/cameraservice/cameraoperator/client/src/callback/dcamera_input_callback.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -15,8 +15,10 @@ #include "dcamera_input_callback.h" +#include "dcamera_utils_tools.h" #include "distributed_camera_constants.h" #include "distributed_hardware_log.h" +#include "metadata_utils.h" namespace OHOS { namespace DistributedHardware { @@ -37,5 +39,42 @@ void DCameraInputCallback::OnError(const int32_t errorType, const int32_t errorM event->eventResult_ = DCAMERA_EVENT_CAMERA_ERROR; callback_->OnStateChanged(event); } + +void DCameraInputCallback::OnFocusState(FocusState state) +{ + DHLOGI("DCameraInputCallback::OnFocusState, state: %d", state); + if (callback_ == nullptr) { + DHLOGE("DCameraInputCallback::OnFocusState StateCallback is null"); + return; + } + + auto iter = focusStateMap_.find(state); + if (iter == focusStateMap_.end()) { + DHLOGE("DCameraInputCallback::OnFocusState focusStateMap find %d state failed", state); + return; + } + + int32_t itemCapacity = 10; + int32_t dataCapacity = 100; + int32_t dataCount = 1; + uint8_t focusState = iter->second; + std::shared_ptr cameraMetadata = + std::make_shared(itemCapacity, dataCapacity); + if (!cameraMetadata->addEntry(OHOS_CONTROL_FOCUS_STATE, &focusState, dataCount)) { + DHLOGE("DCameraInputCallback::OnFocusState cameraMetadata add entry failed"); + return; + } + + std::string abilityString = Camera::MetadataUtils::EncodeToString(cameraMetadata); + std::string encodeString = Base64Encode(reinterpret_cast(abilityString.c_str()), + abilityString.length()); + + std::shared_ptr dcSetting = std::make_shared(); + dcSetting->type_ = DCSettingsType::METADATA_RESULT; + dcSetting->value_ = encodeString; + std::vector> settings; + settings.push_back(dcSetting); + callback_->OnMetadataResult(settings); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp index 0740f7b1..f33fed23 100644 --- a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp +++ b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -96,13 +96,36 @@ int32_t DCameraClient::UnInit() int32_t DCameraClient::UpdateSettings(std::vector>& settings) { DHLOGI("DCameraClient::UpdateCameraSettings cameraId: %s", GetAnonyString(cameraId_).c_str()); + if (cameraInput_ == nullptr) { + DHLOGI("DCameraClient::UpdateSettings cameraInput is null, cameraId: %s", GetAnonyString(cameraId_).c_str()); + return DCAMERA_BAD_VALUE; + } for (auto& setting : settings) { switch (setting->type_) { case UPDATE_METADATA: { DHLOGI("DCameraClient::UpdateCameraSettings %s update metadata settings", - GetAnonyString(cameraId_).c_str()); - std::string metadataStr = Base64Decode(setting->value_); - int32_t ret = ((sptr &)cameraInput_)->SetCameraSettings(metadataStr); + GetAnonyString(cameraId_).c_str()); + std::string dcSettingValue = setting->value_; + std::string metadataStr = Base64Decode(dcSettingValue); + + camera_metadata_item_t item; + std::shared_ptr cameraMetadata = + Camera::MetadataUtils::DecodeFromString(metadataStr); + int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_FOCUS_MODE, &item); + if (ret != CAM_META_SUCCESS) { + DHLOGE("DCameraClient::UpdateSettings camera metadata find focus mode failed, ret: %d", ret); + return ret; + } + DHLOGI("DCameraClient::UpdateSettings focus mode: %d", item.data.u8[0]); + + ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_EXPOSURE_MODE, &item); + if (ret != CAM_META_SUCCESS) { + DHLOGE("DCameraClient::UpdateSettings camera metadata find exposure mode failed, ret: %d", ret); + return ret; + } + DHLOGI("DCameraClient::UpdateSettings exposure mode: %d", item.data.u8[0]); + + ret = ((sptr &)cameraInput_)->SetCameraSettings(metadataStr); if (ret != DCAMERA_OK) { DHLOGE("DCameraClient::UpdateSettings %s update metadata settings failed, ret: %d", GetAnonyString(cameraId_).c_str(), ret); @@ -248,6 +271,7 @@ int32_t DCameraClient::ConfigCaptureSession(std::vector inputCallback = std::make_shared(stateCallback_); ((sptr &)cameraInput_)->SetErrorCallback(inputCallback); + ((sptr &)cameraInput_)->SetFocusCallback(inputCallback); captureSession_ = cameraManager_->CreateCaptureSession(); if (captureSession_ == nullptr) { diff --git a/services/cameraservice/cameraoperator/client/src/dcamera_client_common.cpp b/services/cameraservice/cameraoperator/client/src/dcamera_client_common.cpp index 2d6f0cb4..98d42566 100644 --- a/services/cameraservice/cameraoperator/client/src/dcamera_client_common.cpp +++ b/services/cameraservice/cameraoperator/client/src/dcamera_client_common.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -233,6 +233,7 @@ int32_t DCameraClient::ConfigCaptureSession(std::vector inputCallback = std::make_shared(stateCallback_); ((sptr &)cameraInput_)->SetErrorCallback(inputCallback); + ((sptr &)cameraInput_)->SetFocusCallback(inputCallback); captureSession_ = cameraManager_->CreateCaptureSession(); if (captureSession_ == nullptr) { diff --git a/services/cameraservice/cameraoperator/client/test/unittest/common/cameraoperator/dcamera_client_test.cpp b/services/cameraservice/cameraoperator/client/test/unittest/common/cameraoperator/dcamera_client_test.cpp index 9e6f6684..aad3c1f6 100644 --- a/services/cameraservice/cameraoperator/client/test/unittest/common/cameraoperator/dcamera_client_test.cpp +++ b/services/cameraservice/cameraoperator/client/test/unittest/common/cameraoperator/dcamera_client_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -34,7 +34,7 @@ public: event->eventType_, event->eventResult_); } - void OnMetadataResult() + void OnMetadataResult(std::vector>& settings) { DHLOGI("DCameraClientTestStateCallback::OnMetadataResult"); } diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/callback/dcamera_sink_controller_state_callback.h b/services/cameraservice/sinkservice/include/distributedcameramgr/callback/dcamera_sink_controller_state_callback.h index 70110cce..f1602672 100644 --- a/services/cameraservice/sinkservice/include/distributedcameramgr/callback/dcamera_sink_controller_state_callback.h +++ b/services/cameraservice/sinkservice/include/distributedcameramgr/callback/dcamera_sink_controller_state_callback.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -28,7 +28,7 @@ public: ~DCameraSinkControllerStateCallback() = default; void OnStateChanged(std::shared_ptr& event) override; - void OnMetadataResult() override; + void OnMetadataResult(std::vector>& settings) override; private: std::weak_ptr controller_; diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h index 6b759e6f..9b52949f 100644 --- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h +++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -52,7 +52,7 @@ public: void OnEvent(DCameraPostAuthorizationEvent& event) override; void OnStateChanged(std::shared_ptr& event); - void OnMetadataResult(); + void OnMetadataResult(std::vector>& settings); void OnSessionState(int32_t state); void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail); diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/callback/dcamera_sink_controller_state_callback.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/callback/dcamera_sink_controller_state_callback.cpp index ed6f9255..6987ad48 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/callback/dcamera_sink_controller_state_callback.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/callback/dcamera_sink_controller_state_callback.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -34,14 +34,14 @@ void DCameraSinkControllerStateCallback::OnStateChanged(std::shared_ptrOnStateChanged(event); } -void DCameraSinkControllerStateCallback::OnMetadataResult() +void DCameraSinkControllerStateCallback::OnMetadataResult(std::vector>& settings) { std::shared_ptr controller = controller_.lock(); if (controller == nullptr) { DHLOGE("DCameraSinkControllerStateCallback::OnMetadataResult controller is null"); return; } - controller->OnMetadataResult(); + controller->OnMetadataResult(settings); } } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp index 9501728a..a576ee1c 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -15,6 +15,7 @@ #include "dcamera_sink_controller.h" +#include #include #include "anonymous_string.h" @@ -312,9 +313,39 @@ void DCameraSinkController::OnStateChanged(std::shared_ptr& event) DCameraNotifyInner(DCAMERA_MESSAGE, DCAMERA_EVENT_CAMERA_ERROR, std::string("camera error")); } -void DCameraSinkController::OnMetadataResult() +void DCameraSinkController::OnMetadataResult(std::vector>& settings) { DHLOGI("DCameraSinkController::OnMetadataResult dhId: %s", GetAnonyString(dhId_).c_str()); + if (settings.empty()) { + DHLOGE("DCameraSinkController::OnMetadataResult camera settings is empty"); + return; + } + DCameraMetadataSettingCmd cmd; + cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE; + cmd.dhId_ = dhId_; + cmd.command_ = DCAMERA_PROTOCOL_CMD_METADATA_RESULT; + cmd.value_.assign(settings.begin(), settings.end()); + std::string jsonStr; + int32_t ret = cmd.Marshal(jsonStr); + if (ret != DCAMERA_OK) { + DHLOGE("DCameraSinkController::OnMetadataResult Marshal metadata settings failed, dhId: %s ret: %d", + GetAnonyString(dhId_).c_str(), ret); + return; + } + std::shared_ptr buffer = std::make_shared(jsonStr.length() + 1); + ret = memcpy_s(buffer->Data(), buffer->Capacity(), (uint8_t *)jsonStr.c_str(), jsonStr.length()); + if (ret != EOK) { + DHLOGE("DCameraSinkController::OnMetadataResult memcpy_s failed, dhId: %s ret: %d", + GetAnonyString(dhId_).c_str(), ret); + return; + } + ret = channel_->SendData(buffer); + if (ret != DCAMERA_OK) { + DHLOGE("DCameraSinkController::OnMetadataResult channel send data failed, dhId: %s ret: %d", + GetAnonyString(dhId_).c_str(), ret); + return; + } + DHLOGI("DCameraSinkController::OnMetadataResult dhId: %s success", GetAnonyString(dhId_).c_str()); } void DCameraSinkController::OnSessionState(int32_t state) diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp index 446fcf7e..212647a3 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -474,8 +474,8 @@ void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr) setting.type_ = (*iter)->type_; setting.value_ = (*iter)->value_; int32_t retHdi = camHdiProvider->OnSettingsResult(dhBase, setting); - DHLOGI("OnSettingsResult hal, ret: %d, devId: %s dhId: %s, type: %d, result: %d, content: %s", retHdi, - GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + DHLOGI("OnSettingsResult hal, ret: %d, devId: %s dhId: %s", retHdi, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str()); } } } // namespace DistributedHardware diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp index 70fb4d65..620dd696 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -28,7 +28,7 @@ namespace DistributedHardware { DCameraStreamDataProcess::DCameraStreamDataProcess(std::string devId, std::string dhId, DCStreamType streamType) : devId_(devId), dhId_(dhId), streamType_(streamType) { - DHLOGI("DCameraSourceDataProcess Constructor devId %s dhId %s", GetAnonyString(devId_).c_str(), + DHLOGI("DCameraStreamDataProcess Constructor devId %s dhId %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); pipeline_ = nullptr; listener_ = nullptr; diff --git a/services/data_process/src/pipeline_node/colorspace_conversion/color_format_process.cpp b/services/data_process/src/pipeline_node/colorspace_conversion/color_format_process.cpp index b6cb2507..88edf0f6 100644 --- a/services/data_process/src/pipeline_node/colorspace_conversion/color_format_process.cpp +++ b/services/data_process/src/pipeline_node/colorspace_conversion/color_format_process.cpp @@ -80,7 +80,7 @@ int32_t ColorFormatProcess::ProcessData(std::vector> } if (sourceConfig_.GetVideoformat() == processedConfig_.GetVideoformat()) { - DHLOGD("The target VideoCodecType : %d is the same as the source VideoCodecType : %d.", + DHLOGD("The target Video Format : %d is the same as the source Video Format : %d.", sourceConfig_.GetVideoformat(), processedConfig_.GetVideoformat()); return ColorFormatDone(inputBuffers); } @@ -158,8 +158,8 @@ int32_t ColorFormatProcess::GetImageUnitInfo(ImageUnitInfo& imgInfo, const std:: DHLOGE("Get the imgData of the imgBuf failed."); return DCAMERA_BAD_VALUE; } - DHLOGD("imgBuf info : Videoformat %d, alignedWidth %d, alignedHeight %d, width %d, height %d, chromaOffset %d, " + - "imgSize %d.", imgInfo.colorFormat, imgInfo.width, imgInfo.height, imgInfo.alignedWidth, + DHLOGD("ColorFormatProcess imgBuf info : Videoformat %d, alignedWidth %d, alignedHeight %d, width %d, height %d," + + " chromaOffset %d, imgSize %d.", imgInfo.colorFormat, imgInfo.width, imgInfo.height, imgInfo.alignedWidth, imgInfo.alignedHeight, imgInfo.chromaOffset, imgInfo.imgSize); return DCAMERA_OK; } -- Gitee