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_util.h"
20 #include "hstream_common.h"
21 #include "ipc_skeleton.h"
22 #include "metadata_utils.h"
23 #include <cstdint>
24 #include <unordered_set>
25 #include "dp_utils.h"
26
27 namespace OHOS {
28 namespace CameraStandard {
29 constexpr int32_t DEFAULT_ITEMS = 1;
30 constexpr int32_t DEFAULT_DATA_LENGTH = 10;
31
32 using namespace OHOS::HDI::Camera::V1_0;
HStreamMetadata(sptr<OHOS::IBufferProducer> producer,int32_t format,std::vector<int32_t> metadataTypes)33 HStreamMetadata::HStreamMetadata(sptr<OHOS::IBufferProducer> producer,
34 int32_t format, std::vector<int32_t> metadataTypes)
35 : HStreamCommon(StreamType::METADATA, producer, format, producer->GetDefaultWidth(), producer->GetDefaultHeight()),
36 metadataObjectTypes_(metadataTypes)
37 {}
38
~HStreamMetadata()39 HStreamMetadata::~HStreamMetadata()
40 {}
41
LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)42 int32_t HStreamMetadata::LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,
43 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)
44 {
45 CHECK_RETURN_RET_ELOG(streamOperator == nullptr || cameraAbility == nullptr, CAMERA_INVALID_ARG,
46 "HStreamMetadata::LinkInput streamOperator is null");
47 SetStreamOperator(streamOperator);
48 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
49 cameraAbility_ = cameraAbility;
50 return CAMERA_OK;
51 }
52
SetStreamInfo(StreamInfo_V1_1 & streamInfo)53 void HStreamMetadata::SetStreamInfo(StreamInfo_V1_1 &streamInfo)
54 {
55 HStreamCommon::SetStreamInfo(streamInfo);
56 streamInfo.v1_0.intent_ = ANALYZE;
57 }
58
Start()59 int32_t HStreamMetadata::Start()
60 {
61 CAMERA_SYNC_TRACE;
62 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
63 isStarted_ = true;
64 return EnableOrDisableMetadataType(metadataObjectTypes_, true);
65 }
66
Stop()67 int32_t HStreamMetadata::Stop()
68 {
69 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
70 isStarted_ = false;
71 return EnableOrDisableMetadataType(metadataObjectTypes_, false);
72 }
73
Release()74 int32_t HStreamMetadata::Release()
75 {
76 std::lock_guard<std::mutex> lock(callbackLock_);
77 streamMetadataCallback_ = nullptr;
78 return ReleaseStream(false);
79 }
80
ReleaseStream(bool isDelay)81 int32_t HStreamMetadata::ReleaseStream(bool isDelay)
82 {
83 return HStreamCommon::ReleaseStream(isDelay);
84 }
85
DumpStreamInfo(CameraInfoDumper & infoDumper)86 void HStreamMetadata::DumpStreamInfo(CameraInfoDumper& infoDumper)
87 {
88 infoDumper.Title("metadata stream");
89 HStreamCommon::DumpStreamInfo(infoDumper);
90 }
91
OperatePermissionCheck(uint32_t interfaceCode)92 int32_t HStreamMetadata::OperatePermissionCheck(uint32_t interfaceCode)
93 {
94 switch (static_cast<IStreamMetadataIpcCode>(interfaceCode)) {
95 case IStreamMetadataIpcCode::COMMAND_START: {
96 auto callerToken = IPCSkeleton::GetCallingTokenID();
97 CHECK_RETURN_RET_ELOG(callerToken_ != callerToken, CAMERA_OPERATION_NOT_ALLOWED,
98 "HStreamMetadata::OperatePermissionCheck fail, callerToken_ is : %{public}d, now token "
99 "is %{public}d", callerToken_, callerToken);
100 break;
101 }
102 case IStreamMetadataIpcCode::COMMAND_ENABLE_METADATA_TYPE:
103 case IStreamMetadataIpcCode::COMMAND_DISABLE_METADATA_TYPE: {
104 CHECK_RETURN_RET_ELOG(!CheckSystemApp(), CAMERA_NO_PERMISSION, "HStreamMetadata::CheckSystemApp fail");
105 break;
106 }
107 default:
108 break;
109 }
110 return CAMERA_OK;
111 }
112
CallbackEnter(uint32_t code)113 int32_t HStreamMetadata::CallbackEnter([[maybe_unused]] uint32_t code)
114 {
115 MEDIA_DEBUG_LOG("start, code:%{public}u", code);
116 DisableJeMalloc();
117 return OperatePermissionCheck(code);
118 }
CallbackExit(uint32_t code,int32_t result)119 int32_t HStreamMetadata::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result)
120 {
121 MEDIA_DEBUG_LOG("leave, code:%{public}u, result:%{public}d", code, result);
122 return CAMERA_OK;
123 }
124
EnableMetadataType(const std::vector<int32_t> & metadataTypes)125 int32_t HStreamMetadata::EnableMetadataType(const std::vector<int32_t>& metadataTypes)
126 {
127 int32_t rc = EnableOrDisableMetadataType(metadataTypes, true);
128 CHECK_RETURN_RET_ELOG(rc != CAMERA_OK, rc, "HStreamMetadata::EnableMetadataType failed!");
129 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
130 for (auto& element : metadataTypes) {
131 metadataObjectTypes_.emplace_back(element);
132 }
133 return rc;
134 }
DisableMetadataType(const std::vector<int32_t> & metadataTypes)135 int32_t HStreamMetadata::DisableMetadataType(const std::vector<int32_t>& metadataTypes)
136 {
137 int32_t rc = EnableOrDisableMetadataType(metadataTypes, false);
138 CHECK_RETURN_RET_ELOG(rc != CAMERA_OK, rc, "HStreamMetadata::DisableMetadataType failed!");
139 std::lock_guard<std::mutex> lock(metadataTypeMutex_);
140 removeMetadataType(metadataTypes, metadataObjectTypes_);
141 return rc;
142 }
143
OnMetaResult(int32_t streamId,std::shared_ptr<OHOS::Camera::CameraMetadata> result)144 int32_t HStreamMetadata::OnMetaResult(int32_t streamId, std::shared_ptr<OHOS::Camera::CameraMetadata> result)
145 {
146 if (result == nullptr) {
147 result = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
148 }
149 CHECK_EXECUTE(streamMetadataCallback_ != nullptr,
150 streamMetadataCallback_->OnMetadataResult(streamId, result));
151 return CAMERA_OK;
152 }
153
SetCallback(const sptr<IStreamMetadataCallback> & callback)154 int32_t HStreamMetadata::SetCallback(const sptr<IStreamMetadataCallback>& callback)
155 {
156 CHECK_RETURN_RET_ELOG(callback == nullptr, CAMERA_INVALID_ARG, "HStreamCapture::SetCallback input is null");
157 std::lock_guard<std::mutex> lock(callbackLock_);
158 streamMetadataCallback_ = callback;
159 return CAMERA_OK;
160 }
161
UnSetCallback()162 int32_t HStreamMetadata::UnSetCallback()
163 {
164 std::lock_guard<std::mutex> lock(callbackLock_);
165 streamMetadataCallback_ = nullptr;
166 return CAMERA_OK;
167 }
168
EnableOrDisableMetadataType(const std::vector<int32_t> & metadataTypes,const bool enable)169 int32_t HStreamMetadata::EnableOrDisableMetadataType(const std::vector<int32_t>& metadataTypes, const bool enable)
170 {
171 MEDIA_DEBUG_LOG("HStreamMetadata::EnableOrDisableMetadataType enable: %{public}d, metadataTypes size: %{public}zu",
172 enable, metadataTypes.size());
173 auto streamOperator = GetStreamOperator();
174 CHECK_RETURN_RET_ELOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
175 "HStreamMetadata::EnableOrDisableMetadataType streamOperator is nullptr");
176 streamOperator->GetVersion(majorVer_, minorVer_);
177 CHECK_RETURN_RET_DLOG(GetVersionId(majorVer_, minorVer_) < HDI_VERSION_ID_1_3, CAMERA_OK,
178 "EnableOrDisableMetadataType version: %{public}d.%{public}d", majorVer_, minorVer_);
179 int32_t ret = PrepareCaptureId();
180 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret,
181 "HStreamMetadata::EnableOrDisableMetadataType Failed to allocate a captureId");
182 sptr<OHOS::HDI::Camera::V1_3::IStreamOperator> streamOperatorV1_3 =
183 OHOS::HDI::Camera::V1_3::IStreamOperator::CastFrom(streamOperator);
184 CHECK_RETURN_RET_ELOG(streamOperatorV1_3 == nullptr, CAMERA_UNKNOWN_ERROR,
185 "HStreamMetadata::EnableOrDisableMetadataType streamOperatorV1_3 castFrom failed!");
186 OHOS::HDI::Camera::V1_2::CamRetCode rc;
187 std::vector<uint8_t> typeTagToHal;
188 for (auto& type : metadataTypes) {
189 auto itr = g_FwkToHALResultCameraMetaDetect_.find(static_cast<MetadataObjectType>(type));
190 if (itr != g_FwkToHALResultCameraMetaDetect_.end()) {
191 typeTagToHal.emplace_back(itr->second);
192 MEDIA_DEBUG_LOG("EnableOrDisableMetadataType type: %{public}d", itr->second);
193 }
194 }
195 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata4Types =
196 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
197 uint32_t count = typeTagToHal.size();
198 uint8_t* typesToEnable = typeTagToHal.data();
199 bool status = metadata4Types->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, count);
200 CHECK_RETURN_RET_ELOG(!status, CAMERA_UNKNOWN_ERROR, "set_camera_metadata failed!");
201 std::vector<uint8_t> settings;
202 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metadata4Types, settings);
203 if (enable) {
204 rc = (OHOS::HDI::Camera::V1_2::CamRetCode)(streamOperatorV1_3->
205 EnableResult(-1, settings));
206 } else {
207 rc = (OHOS::HDI::Camera::V1_2::CamRetCode)(streamOperatorV1_3->
208 DisableResult(-1, settings));
209 }
210 ret = CAMERA_OK;
211 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_2::NO_ERROR, HdiToServiceErrorV1_2(rc),
212 "HStreamCapture::ConfirmCapture failed with error Code: %{public}d", rc);
213 return ret;
214 }
215
removeMetadataType(const std::vector<int32_t> & metaRes,std::vector<int32_t> & metaTarget)216 void HStreamMetadata::removeMetadataType(const std::vector<int32_t>& metaRes, std::vector<int32_t>& metaTarget)
217 {
218 std::unordered_set<int32_t> set(metaRes.begin(), metaRes.end());
219 metaTarget.erase(std::remove_if(metaTarget.begin(), metaTarget.end(),
220 [&set](const int32_t &element) { return set.find(element) != set.end(); }),
221 metaTarget.end());
222 }
223
GetMetadataObjectTypes()224 std::vector<int32_t> HStreamMetadata::GetMetadataObjectTypes()
225 {
226 return metadataObjectTypes_;
227 }
228 } // namespace Standard
229 } // namespace OHOS
230