1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hstream_metadata.h"
17
18 #include "camera_log.h"
19 #include "camera_service_ipc_interface_code.h"
20 #include "camera_util.h"
21 #include "hstream_common.h"
22 #include "ipc_skeleton.h"
23 #include "metadata_utils.h"
24 #include <cstdint>
25 #include <unordered_set>
26 #include "dp_utils.h"
27
28 namespace OHOS {
29 namespace CameraStandard {
30 constexpr int32_t DEFAULT_ITEMS = 1;
31 constexpr int32_t DEFAULT_DATA_LENGTH = 10;
32 static const std::unordered_map<MetadataObjectType, uint8_t> g_FwkToHALResultCameraMetaDetect_ = {
33 {MetadataObjectType::FACE, 0},
34 {MetadataObjectType::HUMAN_BODY, 1},
35 {MetadataObjectType::CAT_FACE, 2},
36 {MetadataObjectType::CAT_BODY, 3},
37 {MetadataObjectType::DOG_FACE, 4},
38 {MetadataObjectType::DOG_BODY, 5},
39 {MetadataObjectType::SALIENT_DETECTION, 6},
40 {MetadataObjectType::BAR_CODE_DETECTION, 7},
41 {MetadataObjectType::BASE_FACE_DETECTION, 8}
42 };
43
44 using namespace OHOS::HDI::Camera::V1_0;
HStreamMetadata(sptr<OHOS::IBufferProducer> producer,int32_t format,std::vector<int32_t> metadataTypes)45 HStreamMetadata::HStreamMetadata(sptr<OHOS::IBufferProducer> producer,
46 int32_t format, std::vector<int32_t> metadataTypes)
47 : HStreamCommon(StreamType::METADATA, producer, format, producer->GetDefaultWidth(), producer->GetDefaultHeight()),
48 metadataObjectTypes_(metadataTypes)
49 {}
50
~HStreamMetadata()51 HStreamMetadata::~HStreamMetadata()
52 {}
53
LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)54 int32_t HStreamMetadata::LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,
55 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)
56 {
57 CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr || cameraAbility == nullptr, CAMERA_INVALID_ARG,
58 "HStreamMetadata::LinkInput streamOperator is null");
59 SetStreamOperator(streamOperator);
60 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
61 cameraAbility_ = cameraAbility;
62 return CAMERA_OK;
63 }
64
SetStreamInfo(StreamInfo_V1_1 & streamInfo)65 void HStreamMetadata::SetStreamInfo(StreamInfo_V1_1 &streamInfo)
66 {
67 HStreamCommon::SetStreamInfo(streamInfo);
68 streamInfo.v1_0.intent_ = ANALYZE;
69 }
70
Start()71 int32_t HStreamMetadata::Start()
72 {
73 CAMERA_SYNC_TRACE;
74 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
75 isStarted_ = true;
76 return EnableOrDisableMetadataType(metadataObjectTypes_, true);
77 }
78
Stop()79 int32_t HStreamMetadata::Stop()
80 {
81 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
82 isStarted_ = false;
83 return EnableOrDisableMetadataType(metadataObjectTypes_, false);
84 }
85
Release()86 int32_t HStreamMetadata::Release()
87 {
88 std::lock_guard<std::mutex> lock(callbackLock_);
89 streamMetadataCallback_ = nullptr;
90 return ReleaseStream(false);
91 }
92
ReleaseStream(bool isDelay)93 int32_t HStreamMetadata::ReleaseStream(bool isDelay)
94 {
95 return HStreamCommon::ReleaseStream(isDelay);
96 }
97
DumpStreamInfo(CameraInfoDumper & infoDumper)98 void HStreamMetadata::DumpStreamInfo(CameraInfoDumper& infoDumper)
99 {
100 infoDumper.Title("metadata stream");
101 HStreamCommon::DumpStreamInfo(infoDumper);
102 }
103
OperatePermissionCheck(uint32_t interfaceCode)104 int32_t HStreamMetadata::OperatePermissionCheck(uint32_t interfaceCode)
105 {
106 switch (static_cast<StreamMetadataInterfaceCode>(interfaceCode)) {
107 case StreamMetadataInterfaceCode::CAMERA_STREAM_META_START: {
108 auto callerToken = IPCSkeleton::GetCallingTokenID();
109 CHECK_ERROR_RETURN_RET_LOG(callerToken_ != callerToken, CAMERA_OPERATION_NOT_ALLOWED,
110 "HStreamMetadata::OperatePermissionCheck fail, callerToken_ is : %{public}d, now token "
111 "is %{public}d", callerToken_, callerToken);
112 break;
113 }
114 default:
115 break;
116 }
117 return CAMERA_OK;
118 }
119
EnableMetadataType(std::vector<int32_t> metadataTypes)120 int32_t HStreamMetadata::EnableMetadataType(std::vector<int32_t> metadataTypes)
121 {
122 int32_t rc = EnableOrDisableMetadataType(metadataTypes, true);
123 CHECK_ERROR_RETURN_RET_LOG(rc != CAMERA_OK, rc, "HStreamMetadata::EnableMetadataType failed!");
124 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
125 for (auto& element : metadataTypes) {
126 metadataObjectTypes_.emplace_back(element);
127 }
128 return rc;
129 }
DisableMetadataType(std::vector<int32_t> metadataTypes)130 int32_t HStreamMetadata::DisableMetadataType(std::vector<int32_t> metadataTypes)
131 {
132 int32_t rc = EnableOrDisableMetadataType(metadataTypes, false);
133 CHECK_ERROR_RETURN_RET_LOG(rc != CAMERA_OK, rc, "HStreamMetadata::DisableMetadataType failed!");
134 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
135 removeMetadataType(metadataTypes, metadataObjectTypes_);
136 return rc;
137 }
138
OnMetaResult(int32_t streamId,const std::vector<uint8_t> & result)139 int32_t HStreamMetadata::OnMetaResult(int32_t streamId, const std::vector<uint8_t>& result)
140 {
141 CHECK_ERROR_RETURN_RET_LOG(result.size() == 0, CAMERA_INVALID_ARG, "onResult get null meta from HAL");
142 std::lock_guard<std::mutex> lock(callbackLock_);
143 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult = nullptr;
144 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, cameraResult);
145 if (cameraResult == nullptr) {
146 cameraResult = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
147 }
148 CHECK_EXECUTE(streamMetadataCallback_ != nullptr,
149 streamMetadataCallback_->OnMetadataResult(streamId, cameraResult));
150 return CAMERA_OK;
151 }
152
SetCallback(sptr<IStreamMetadataCallback> & callback)153 int32_t HStreamMetadata::SetCallback(sptr<IStreamMetadataCallback>& callback)
154 {
155 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, CAMERA_INVALID_ARG, "HStreamCapture::SetCallback input is null");
156 std::lock_guard<std::mutex> lock(callbackLock_);
157 streamMetadataCallback_ = callback;
158 return CAMERA_OK;
159 }
160
UnSetCallback()161 int32_t HStreamMetadata::UnSetCallback()
162 {
163 std::lock_guard<std::mutex> lock(callbackLock_);
164 streamMetadataCallback_ = nullptr;
165 return CAMERA_OK;
166 }
167
EnableOrDisableMetadataType(const std::vector<int32_t> & metadataTypes,const bool enable)168 int32_t HStreamMetadata::EnableOrDisableMetadataType(const std::vector<int32_t>& metadataTypes, const bool enable)
169 {
170 MEDIA_DEBUG_LOG("HStreamMetadata::EnableOrDisableMetadataType enable: %{public}d, metadataTypes size: %{public}zu",
171 enable, metadataTypes.size());
172 auto streamOperator = GetStreamOperator();
173 CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
174 "HStreamMetadata::EnableMetadataType streamOperator is nullptr");
175 streamOperator->GetVersion(majorVer_, minorVer_);
176 if (majorVer_ < HDI_VERSION_1 || minorVer_ < HDI_VERSION_3) {
177 MEDIA_DEBUG_LOG("EnableOrDisableMetadataType version: %{public}d.%{public}d", majorVer_, minorVer_);
178 return CAMERA_OK;
179 }
180 int32_t ret = PrepareCaptureId();
181 CHECK_ERROR_RETURN_RET_LOG(ret != CAMERA_OK, ret,
182 "HStreamMetadata::EnableMetadataType Failed to allocate a captureId");
183 sptr<OHOS::HDI::Camera::V1_3::IStreamOperator> streamOperatorV1_3 =
184 OHOS::HDI::Camera::V1_3::IStreamOperator::CastFrom(streamOperator);
185 CHECK_ERROR_RETURN_RET_LOG(streamOperatorV1_3 == nullptr, CAMERA_UNKNOWN_ERROR,
186 "HStreamMetadata::EnableMetadataType streamOperatorV1_3 castFrom failed!");
187 OHOS::HDI::Camera::V1_2::CamRetCode rc;
188 std::vector<uint8_t> typeTagToHal;
189 for (auto& type : metadataTypes) {
190 auto itr = g_FwkToHALResultCameraMetaDetect_.find(static_cast<MetadataObjectType>(type));
191 if (itr != g_FwkToHALResultCameraMetaDetect_.end()) {
192 typeTagToHal.emplace_back(itr->second);
193 MEDIA_DEBUG_LOG("EnableOrDisableMetadataType type: %{public}d", itr->second);
194 }
195 }
196 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata4Types =
197 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
198 uint32_t count = typeTagToHal.size();
199 uint8_t* typesToEnable = typeTagToHal.data();
200 bool status = metadata4Types->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, count);
201 CHECK_ERROR_RETURN_RET_LOG(!status, CAMERA_UNKNOWN_ERROR, "set_camera_metadata failed!");
202 std::vector<uint8_t> settings;
203 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metadata4Types, settings);
204 if (enable) {
205 rc = (OHOS::HDI::Camera::V1_2::CamRetCode)(streamOperatorV1_3->
206 EnableResult(-1, settings));
207 } else {
208 rc = (OHOS::HDI::Camera::V1_2::CamRetCode)(streamOperatorV1_3->
209 DisableResult(-1, settings));
210 }
211 ret = CAMERA_OK;
212 CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_2::NO_ERROR, HdiToServiceErrorV1_2(rc),
213 "HStreamCapture::ConfirmCapture failed with error Code: %{public}d", rc);
214 return ret;
215 }
216
removeMetadataType(std::vector<int32_t> & metaRes,std::vector<int32_t> & metaTarget)217 void HStreamMetadata::removeMetadataType(std::vector<int32_t>& metaRes, std::vector<int32_t>& metaTarget)
218 {
219 std::unordered_set<int32_t> set(metaRes.begin(), metaRes.end());
220 metaTarget.erase(std::remove_if(metaTarget.begin(), metaTarget.end(),
221 [&set](const int32_t &element) { return set.find(element) != set.end(); }),
222 metaTarget.end());
223 }
224 } // namespace Standard
225 } // namespace OHOS
226