1 /*
2 * Copyright (c) 2021-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_repeat.h"
17
18 #include <cstdint>
19
20 #include "camera_device_ability_items.h"
21 #include "camera_log.h"
22 #include "camera_metadata_operator.h"
23 #include "camera_service_ipc_interface_code.h"
24 #include "display_manager.h"
25 #include "camera_util.h"
26 #include "hstream_common.h"
27 #include "ipc_skeleton.h"
28 #include "istream_repeat_callback.h"
29 #include "metadata_utils.h"
30 #include "camera_report_uitls.h"
31 #include "parameters.h"
32
33
34 namespace OHOS {
35 namespace CameraStandard {
36 using namespace OHOS::HDI::Camera::V1_0;
HStreamRepeat(sptr<OHOS::IBufferProducer> producer,int32_t format,int32_t width,int32_t height,RepeatStreamType type)37 HStreamRepeat::HStreamRepeat(
38 sptr<OHOS::IBufferProducer> producer, int32_t format, int32_t width, int32_t height, RepeatStreamType type)
39 : HStreamCommon(StreamType::REPEAT, producer, format, width, height), repeatStreamType_(type)
40 {
41 MEDIA_INFO_LOG("HStreamRepeat::HStreamRepeat construct, format:%{public}d size:%{public}dx%{public}d "
42 "repeatType:%{public}d, streamId:%{public}d",
43 format, width, height, type, GetFwkStreamId());
44 }
45
~HStreamRepeat()46 HStreamRepeat::~HStreamRepeat()
47 {
48 MEDIA_INFO_LOG("HStreamRepeat::~HStreamRepeat deconstruct, format:%{public}d size:%{public}dx%{public}d "
49 "repeatType:%{public}d, streamId:%{public}d, hdiStreamId:%{public}d",
50 format_, width_, height_, repeatStreamType_, GetFwkStreamId(), GetHdiStreamId());
51 }
52
LinkInput(sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)53 int32_t HStreamRepeat::LinkInput(sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,
54 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)
55 {
56 MEDIA_INFO_LOG(
57 "HStreamRepeat::LinkInput streamId:%{public}d ,repeatStreamType:%{public}d",
58 GetFwkStreamId(), repeatStreamType_);
59 int32_t ret = HStreamCommon::LinkInput(streamOperator, cameraAbility);
60 CHECK_ERROR_RETURN_RET_LOG(ret != CAMERA_OK, ret,
61 "HStreamRepeat::LinkInput err, streamId:%{public}d ,err:%{public}d", GetFwkStreamId(), ret);
62 if (repeatStreamType_ != RepeatStreamType::VIDEO) {
63 SetStreamTransform();
64 }
65 return CAMERA_OK;
66 }
67
SetVideoStreamInfo(StreamInfo_V1_1 & streamInfo)68 void HStreamRepeat::SetVideoStreamInfo(StreamInfo_V1_1& streamInfo)
69 {
70 streamInfo.v1_0.intent_ = StreamIntent::VIDEO;
71 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_H264;
72 MEDIA_INFO_LOG("HStreamRepeat::SetVideoStreamInfo Enter");
73 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
74 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
75 HDI::Camera::V1_3::ExtendedStreamInfoType::EXTENDED_STREAM_INFO_MAKER_INFO),
76 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
77 };
78 extendedStreamInfo.bufferQueue = metaSurfaceBufferQueue_;
79 MEDIA_INFO_LOG("HStreamRepeat::SetVideoStreamInfo end");
80 streamInfo.extendedStreamInfos = { extendedStreamInfo };
81 }
82
SetStreamInfo(StreamInfo_V1_1 & streamInfo)83 void HStreamRepeat::SetStreamInfo(StreamInfo_V1_1& streamInfo)
84 {
85 HStreamCommon::SetStreamInfo(streamInfo);
86 auto metaProducerSequenceable = metaProducer_ == nullptr ? nullptr : new BufferProducerSequenceable(metaProducer_);
87 HDI::Camera::V1_1::ExtendedStreamInfo metaExtendedStreamInfo {
88 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(4), .width = 0, .height = 0, .format = 0,
89 .dataspace = 0, .bufferQueue = metaProducerSequenceable
90 };
91 switch (repeatStreamType_) {
92 case RepeatStreamType::LIVEPHOTO:
93 streamInfo.v1_0.intent_ = StreamIntent::VIDEO;
94 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_H264;
95 streamInfo.extendedStreamInfos = { metaExtendedStreamInfo };
96 break;
97 case RepeatStreamType::VIDEO:
98 SetVideoStreamInfo(streamInfo);
99 break;
100 case RepeatStreamType::PREVIEW:
101 streamInfo.v1_0.intent_ = StreamIntent::PREVIEW;
102 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_NULL;
103 if (mEnableSecure) {
104 MEDIA_INFO_LOG("HStreamRepeat::SetStreamInfo Enter");
105 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
106 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
107 HDI::Camera::V1_3::ExtendedStreamInfoType::EXTENDED_STREAM_INFO_SECURE),
108 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
109 };
110 MEDIA_INFO_LOG("HStreamRepeat::SetStreamInfo end");
111 streamInfo.extendedStreamInfos = { extendedStreamInfo };
112 }
113 break;
114 case RepeatStreamType::SKETCH:
115 streamInfo.v1_0.intent_ = StreamIntent::PREVIEW;
116 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_NULL;
117 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
118 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
119 HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
120 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
121 };
122 streamInfo.extendedStreamInfos = { extendedStreamInfo };
123 break;
124 }
125 }
126
SetMetaProducer(sptr<OHOS::IBufferProducer> metaProducer)127 void HStreamRepeat::SetMetaProducer(sptr<OHOS::IBufferProducer> metaProducer)
128 {
129 std::lock_guard<std::mutex> lock(producerLock_);
130 metaProducer_ = metaProducer;
131 }
132
SetMovingPhotoStartCallback(std::function<void ()> callback)133 void HStreamRepeat::SetMovingPhotoStartCallback(std::function<void()> callback)
134 {
135 std::lock_guard<std::mutex> lock(movingPhotoCallbackLock_);
136 startMovingPhotoCallback_ = callback;
137 }
138
UpdateSketchStatus(SketchStatus status)139 void HStreamRepeat::UpdateSketchStatus(SketchStatus status)
140 {
141 if (repeatStreamType_ != RepeatStreamType::SKETCH) {
142 return;
143 }
144 auto parent = parentStreamRepeat_.promote();
145 if (parent == nullptr) {
146 return;
147 }
148 if (sketchStatus_ != status) {
149 sketchStatus_ = status;
150 parent->OnSketchStatusChanged(sketchStatus_);
151 }
152 }
153
StartSketchStream(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)154 void HStreamRepeat::StartSketchStream(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
155 {
156 CAMERA_SYNC_TRACE;
157 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream Enter");
158 sptr<HStreamRepeat> sketchStreamRepeat;
159 {
160 std::lock_guard<std::mutex> lock(sketchStreamLock_);
161 if (sketchStreamRepeat_ == nullptr || sketchStreamRepeat_->sketchRatio_ <= 0) {
162 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream sketchStreamRepeat_ is null or ratio is illegal");
163 return;
164 }
165 sketchStreamRepeat = sketchStreamRepeat_;
166 }
167 camera_metadata_item_t item;
168 int32_t ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
169 if (ret != CAM_META_SUCCESS || item.count <= 0) {
170 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream get OHOS_CONTROL_ZOOM_RATIO fail");
171 return;
172 }
173 float tagRatio = *item.data.f;
174 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream OHOS_CONTROL_ZOOM_RATIO >>> tagRatio:%{public}f -- "
175 "sketchRatio:%{public}f",
176 tagRatio, sketchStreamRepeat->sketchRatio_);
177 if (sketchStreamRepeat->sketchRatio_ > 0 &&
178 tagRatio - sketchStreamRepeat->sketchRatio_ >= -std::numeric_limits<float>::epsilon()) {
179 sketchStreamRepeat->Start();
180 }
181 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream Exit");
182 }
183
SetUsedAsPosition(camera_position_enum_t cameraPosition)184 void HStreamRepeat::SetUsedAsPosition(camera_position_enum_t cameraPosition)
185 {
186 MEDIA_INFO_LOG("HStreamRepeat::SetUsedAsPosition %{public}d", cameraPosition);
187 cameraUsedAsPosition_ = cameraPosition;
188 SetStreamTransform();
189 }
190
Start(std::shared_ptr<OHOS::Camera::CameraMetadata> settings,bool isUpdateSeetings)191 int32_t HStreamRepeat::Start(std::shared_ptr<OHOS::Camera::CameraMetadata> settings, bool isUpdateSeetings)
192 {
193 CAMERA_SYNC_TRACE;
194 auto streamOperator = GetStreamOperator();
195 CHECK_AND_RETURN_RET(streamOperator != nullptr, CAMERA_INVALID_STATE);
196 auto preparedCaptureId = GetPreparedCaptureId();
197 CHECK_ERROR_RETURN_RET_LOG(!isUpdateSeetings && preparedCaptureId != CAPTURE_ID_UNSET, CAMERA_INVALID_STATE,
198 "HStreamRepeat::Start, Already started with captureID: %{public}d", preparedCaptureId);
199 // If current is sketch stream, check parent is start or not.
200 if (repeatStreamType_ == RepeatStreamType::SKETCH) {
201 auto parentRepeat = parentStreamRepeat_.promote();
202 CHECK_ERROR_RETURN_RET_LOG(parentRepeat == nullptr || parentRepeat->GetPreparedCaptureId() == CAPTURE_ID_UNSET,
203 CAMERA_INVALID_STATE, "HStreamRepeat::Start sketch parent state is illegal");
204 }
205 if (!isUpdateSeetings) {
206 int32_t ret = PrepareCaptureId();
207 preparedCaptureId = GetPreparedCaptureId();
208 CHECK_ERROR_RETURN_RET_LOG(ret != CAMERA_OK || preparedCaptureId == CAPTURE_ID_UNSET, ret,
209 "HStreamRepeat::Start Failed to allocate a captureId");
210 }
211 UpdateSketchStatus(SketchStatus::STARTING);
212
213 std::vector<uint8_t> ability;
214 {
215 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
216 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraAbility_, ability);
217 }
218 std::shared_ptr<OHOS::Camera::CameraMetadata> dynamicSetting = nullptr;
219 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(ability, dynamicSetting);
220 if (dynamicSetting == nullptr) {
221 dynamicSetting = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
222 }
223 // open video dfx switch for hal, no need close
224 if (repeatStreamType_ == RepeatStreamType::PREVIEW) {
225 OpenVideoDfxSwitch(dynamicSetting);
226 }
227 if (repeatStreamType_ == RepeatStreamType::VIDEO || repeatStreamType_ == RepeatStreamType::LIVEPHOTO) {
228 UpdateVideoSettings(dynamicSetting);
229 }
230 if (repeatStreamType_ == RepeatStreamType::PREVIEW || repeatStreamType_ == RepeatStreamType::VIDEO) {
231 UpdateFrameRateSettings(dynamicSetting);
232 }
233 if (settings != nullptr) {
234 UpdateFrameMuteSettings(settings, dynamicSetting);
235 }
236
237 std::vector<uint8_t> captureSetting;
238 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(dynamicSetting, captureSetting);
239
240 CaptureInfo captureInfo;
241 captureInfo.streamIds_ = { GetHdiStreamId() };
242 captureInfo.captureSetting_ = captureSetting;
243 captureInfo.enableShutterCallback_ = false;
244 MEDIA_INFO_LOG("HStreamRepeat::Start streamId:%{public}d hdiStreamId:%{public}d With capture ID: %{public}d, "
245 "repeatStreamType:%{public}d",
246 GetFwkStreamId(), GetHdiStreamId(), preparedCaptureId, repeatStreamType_);
247 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
248 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
249 const std::string permissionName = "ohos.permission.CAMERA";
250 AddCameraPermissionUsedRecord(callingTokenId, permissionName);
251 }
252 int32_t ret = 0;
253 {
254 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
255 HStreamCommon::PrintCaptureDebugLog(dynamicSetting);
256 CamRetCode rc = (CamRetCode)(streamOperator->Capture(preparedCaptureId, captureInfo, true));
257 if (rc != HDI::Camera::V1_0::NO_ERROR) {
258 ResetCaptureId();
259 MEDIA_ERR_LOG("HStreamRepeat::Start Failed with error Code:%{public}d", rc);
260 CameraReportUtils::ReportCameraError(
261 "HStreamRepeat::Start", rc, true, CameraReportUtils::GetCallerInfo());
262 ret = HdiToServiceError(rc);
263 UpdateSketchStatus(SketchStatus::STOPED);
264 } else {
265 repeatStreamStatus_ = RepeatStreamStatus::STARTED;
266 }
267 }
268 if (settings != nullptr) {
269 StartSketchStream(settings);
270 }
271 return ret;
272 }
273
Start()274 int32_t HStreamRepeat::Start()
275 {
276 return Start(nullptr);
277 }
278
Stop()279 int32_t HStreamRepeat::Stop()
280 {
281 CAMERA_SYNC_TRACE;
282 auto streamOperator = GetStreamOperator();
283 CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
284 "HStreamRepeat::Stop streamOperator is null");
285 auto preparedCaptureId = GetPreparedCaptureId();
286 MEDIA_INFO_LOG("HStreamRepeat::Stop streamId:%{public}d hdiStreamId:%{public}d With capture ID: %{public}d, "
287 "repeatStreamType:%{public}d",
288 GetFwkStreamId(), GetHdiStreamId(), preparedCaptureId, repeatStreamType_);
289 CHECK_ERROR_RETURN_RET_LOG(preparedCaptureId == CAPTURE_ID_UNSET, CAMERA_INVALID_STATE,
290 "HStreamRepeat::Stop, Stream not started yet");
291 UpdateSketchStatus(SketchStatus::STOPPING);
292 int32_t ret = CAMERA_OK;
293 {
294 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
295 ret = StopStream();
296 if (ret != CAMERA_OK) {
297 MEDIA_ERR_LOG("HStreamRepeat::Stop Failed with errorCode:%{public}d, curCaptureID_: %{public}d",
298 ret, preparedCaptureId);
299 } else {
300 repeatStreamStatus_ = RepeatStreamStatus::STOPED;
301 }
302 }
303 {
304 std::lock_guard<std::mutex> lock(sketchStreamLock_);
305 if (sketchStreamRepeat_ != nullptr) {
306 sketchStreamRepeat_->Stop();
307 }
308 }
309 return ret;
310 }
311
Release()312 int32_t HStreamRepeat::Release()
313 {
314 return ReleaseStream(false);
315 }
316
ReleaseStream(bool isDelay)317 int32_t HStreamRepeat::ReleaseStream(bool isDelay)
318 {
319 {
320 std::lock_guard<std::mutex> lock(callbackLock_);
321 streamRepeatCallback_ = nullptr;
322 }
323
324 {
325 std::lock_guard<std::mutex> lock(sketchStreamLock_);
326 if (sketchStreamRepeat_ != nullptr) {
327 sketchStreamRepeat_->Release();
328 }
329 }
330 return HStreamCommon::ReleaseStream(isDelay);
331 }
332
SetCallback(sptr<IStreamRepeatCallback> & callback)333 int32_t HStreamRepeat::SetCallback(sptr<IStreamRepeatCallback>& callback)
334 {
335 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, CAMERA_INVALID_ARG, "HStreamRepeat::SetCallback callback is null");
336 std::lock_guard<std::mutex> lock(callbackLock_);
337 streamRepeatCallback_ = callback;
338 return CAMERA_OK;
339 }
340
OnFrameStarted()341 int32_t HStreamRepeat::OnFrameStarted()
342 {
343 CAMERA_SYNC_TRACE;
344 {
345 std::lock_guard<std::mutex> lock(callbackLock_);
346 if (streamRepeatCallback_ != nullptr) {
347 streamRepeatCallback_->OnFrameStarted();
348 }
349 }
350 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
351 // report video start dfx
352 DfxCaptureInfo captureInfo;
353 captureInfo.captureId = 1;
354 captureInfo.caller = CameraReportUtils::GetCallerInfo();
355 CameraReportUtils::GetInstance().SetVideoStartInfo(captureInfo);
356 }
357
358 UpdateSketchStatus(SketchStatus::STARTED);
359 return CAMERA_OK;
360 }
361
OnFrameEnded(int32_t frameCount)362 int32_t HStreamRepeat::OnFrameEnded(int32_t frameCount)
363 {
364 CAMERA_SYNC_TRACE;
365 {
366 std::lock_guard<std::mutex> lock(callbackLock_);
367 if (streamRepeatCallback_ != nullptr) {
368 streamRepeatCallback_->OnFrameEnded(frameCount);
369 }
370 }
371 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
372 // report video end dfx
373 CameraReportUtils::GetInstance().SetVideoEndInfo(1);
374 }
375 UpdateSketchStatus(SketchStatus::STOPED);
376 return CAMERA_OK;
377 }
378
OnDeferredVideoEnhancementInfo(CaptureEndedInfoExt captureEndedInfo)379 int32_t HStreamRepeat::OnDeferredVideoEnhancementInfo(CaptureEndedInfoExt captureEndedInfo)
380 {
381 CAMERA_SYNC_TRACE;
382 MEDIA_INFO_LOG("HStreamRepeat::OnDeferredVideoEnhancementInfo");
383 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
384 // report video end dfx
385 CameraReportUtils::GetInstance().SetVideoEndInfo(1);
386 std::lock_guard<std::mutex> lock(callbackLock_);
387 if (streamRepeatCallback_ != nullptr) {
388 streamRepeatCallback_->OnDeferredVideoEnhancementInfo(captureEndedInfo);
389 }
390 }
391 return CAMERA_OK;
392 }
393
OnFrameError(int32_t errorType)394 int32_t HStreamRepeat::OnFrameError(int32_t errorType)
395 {
396 std::lock_guard<std::mutex> lock(callbackLock_);
397 MEDIA_DEBUG_LOG("HStreamRepeat::OnFrameError %{public}d, %{public}d", errorType, streamRepeatCallback_ == nullptr);
398 if (errorType == HDI::Camera::V1_3::HIGH_TEMPERATURE_ERROR) {
399 UpdateSketchStatus(SketchStatus::STOPED);
400 }
401 if (streamRepeatCallback_ != nullptr) {
402 int32_t repeatErrorCode;
403 if (errorType == BUFFER_LOST) {
404 repeatErrorCode = CAMERA_STREAM_BUFFER_LOST;
405 } else {
406 repeatErrorCode = CAMERA_UNKNOWN_ERROR;
407 }
408 CAMERA_SYSEVENT_FAULT(CreateMsg("Preview OnFrameError! errorCode:%d", repeatErrorCode));
409 streamRepeatCallback_->OnFrameError(repeatErrorCode);
410 }
411 return CAMERA_OK;
412 }
413
OnSketchStatusChanged(SketchStatus status)414 int32_t HStreamRepeat::OnSketchStatusChanged(SketchStatus status)
415 {
416 std::lock_guard<std::mutex> lock(callbackLock_);
417 MEDIA_DEBUG_LOG("HStreamRepeat::OnSketchStatusChanged %{public}d", status);
418 if (streamRepeatCallback_ != nullptr) {
419 streamRepeatCallback_->OnSketchStatusChanged(status);
420 }
421 return CAMERA_OK;
422 }
423
AddDeferredSurface(const sptr<OHOS::IBufferProducer> & producer)424 int32_t HStreamRepeat::AddDeferredSurface(const sptr<OHOS::IBufferProducer>& producer)
425 {
426 MEDIA_INFO_LOG("HStreamRepeat::AddDeferredSurface called");
427 {
428 std::lock_guard<std::mutex> lock(producerLock_);
429 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, CAMERA_INVALID_ARG,
430 "HStreamRepeat::AddDeferredSurface producer is null");
431 producer_ = producer;
432 }
433 SetStreamTransform();
434 auto streamOperator = GetStreamOperator();
435 CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
436 "HStreamRepeat::CreateAndHandleDeferredStreams(), streamOperator_ == null");
437 MEDIA_INFO_LOG("HStreamRepeat::AttachBufferQueue start streamId:%{public}d, hdiStreamId:%{public}d",
438 GetFwkStreamId(), GetHdiStreamId());
439 sptr<BufferProducerSequenceable> bufferProducerSequenceable;
440 CamRetCode rc;
441 {
442 std::lock_guard<std::mutex> lock(producerLock_);
443 bufferProducerSequenceable = new BufferProducerSequenceable(producer_);
444 }
445 rc = (CamRetCode)(streamOperator->AttachBufferQueue(GetHdiStreamId(), bufferProducerSequenceable));
446 CHECK_ERROR_PRINT_LOG(rc != HDI::Camera::V1_0::NO_ERROR,
447 "HStreamRepeat::AttachBufferQueue(), Failed to AttachBufferQueue %{public}d", rc);
448 MEDIA_INFO_LOG("HStreamRepeat::AddDeferredSurface end %{public}d", rc);
449 std::lock_guard<std::mutex> lock(movingPhotoCallbackLock_);
450 if (startMovingPhotoCallback_) {
451 startMovingPhotoCallback_();
452 startMovingPhotoCallback_ = nullptr;
453 }
454 return CAMERA_OK;
455 }
456
ForkSketchStreamRepeat(int32_t width,int32_t height,sptr<IStreamRepeat> & sketchStream,float sketchRatio)457 int32_t HStreamRepeat::ForkSketchStreamRepeat(
458 int32_t width, int32_t height, sptr<IStreamRepeat>& sketchStream, float sketchRatio)
459 {
460 CAMERA_SYNC_TRACE;
461 std::lock_guard<std::mutex> lock(sketchStreamLock_);
462 CHECK_ERROR_RETURN_RET_LOG(width <= 0 || height <= 0, CAMERA_INVALID_ARG,
463 "HCameraService::ForkSketchStreamRepeat args is illegal");
464 if (sketchStreamRepeat_ != nullptr) {
465 sketchStreamRepeat_->Release();
466 }
467
468 auto streamRepeat = new (std::nothrow) HStreamRepeat(nullptr, format_, width, height, RepeatStreamType::SKETCH);
469 CHECK_ERROR_RETURN_RET_LOG(streamRepeat == nullptr, CAMERA_ALLOC_ERROR,
470 "HStreamRepeat::ForkSketchStreamRepeat HStreamRepeat allocation failed");
471 MEDIA_DEBUG_LOG(
472 "HStreamRepeat::ForkSketchStreamRepeat para is:%{public}dx%{public}d,%{public}f", width, height, sketchRatio);
473 sketchStream = streamRepeat;
474 sketchStreamRepeat_ = streamRepeat;
475 sketchStreamRepeat_->sketchRatio_ = sketchRatio;
476 sketchStreamRepeat_->parentStreamRepeat_ = this;
477 MEDIA_INFO_LOG("HCameraService::ForkSketchStreamRepeat end");
478 return CAMERA_OK;
479 }
480
RemoveSketchStreamRepeat()481 int32_t HStreamRepeat::RemoveSketchStreamRepeat()
482 {
483 CAMERA_SYNC_TRACE;
484 std::lock_guard<std::mutex> lock(sketchStreamLock_);
485 if (sketchStreamRepeat_ == nullptr) {
486 return CAMERA_OK;
487 }
488 sketchStreamRepeat_->Release();
489 sketchStreamRepeat_->parentStreamRepeat_ = nullptr;
490 sketchStreamRepeat_ = nullptr;
491
492 return CAMERA_OK;
493 }
494
SetFrameRate(int32_t minFrameRate,int32_t maxFrameRate)495 int32_t HStreamRepeat::SetFrameRate(int32_t minFrameRate, int32_t maxFrameRate)
496 {
497 streamFrameRateRange_ = {minFrameRate, maxFrameRate};
498 std::vector<uint8_t> ability;
499 std::vector<uint8_t> repeatSettings;
500 CHECK_ERROR_RETURN_RET_LOG(cameraAbility_ == nullptr, CAMERA_DEVICE_DISCONNECT,
501 "HStreamRepeat::SetFrameRate cameraAbility_ is null");
502 {
503 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
504 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraAbility_, ability);
505 std::shared_ptr<OHOS::Camera::CameraMetadata> dynamicSetting = nullptr;
506 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(ability, dynamicSetting);
507 if (dynamicSetting == nullptr) {
508 dynamicSetting = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
509 }
510 CHECK_AND_RETURN_RET_LOG(dynamicSetting != nullptr, CAMERA_INVALID_ARG,
511 "HStreamRepeat::SetFrameRate dynamicSetting is nullptr.");
512 camera_metadata_item_t item;
513 int ret = OHOS::Camera::FindCameraMetadataItem(dynamicSetting->get(), OHOS_CONTROL_FPS_RANGES, &item);
514 bool status = false;
515 if (ret == CAM_META_ITEM_NOT_FOUND) {
516 MEDIA_DEBUG_LOG("HStreamRepeat::SetFrameRate Failed to find frame range");
517 status = dynamicSetting->addEntry(
518 OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
519 } else if (ret == CAM_META_SUCCESS) {
520 MEDIA_DEBUG_LOG("HStreamRepeat::SetFrameRate success to find frame range");
521 status = dynamicSetting->updateEntry(
522 OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
523 }
524 CHECK_ERROR_PRINT_LOG(!status, "HStreamRepeat::SetFrameRate Failed to set frame range");
525 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(dynamicSetting, repeatSettings);
526 }
527
528 auto streamOperator = GetStreamOperator();
529
530 CamRetCode rc = HDI::Camera::V1_0::NO_ERROR;
531 if (streamOperator != nullptr) {
532 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
533 if (repeatStreamStatus_ == RepeatStreamStatus::STARTED) {
534 CaptureInfo captureInfo;
535 captureInfo.streamIds_ = {GetHdiStreamId()};
536 captureInfo.captureSetting_ = repeatSettings;
537 captureInfo.enableShutterCallback_ = false;
538 int32_t currentCaptureId = GetPreparedCaptureId();
539 MEDIA_INFO_LOG("HStreamRepeat::SetFramRate stream:%{public}d, with settingCapture ID:%{public}d",
540 GetFwkStreamId(), currentCaptureId);
541 rc = (CamRetCode)(streamOperator->Capture(currentCaptureId, captureInfo, true));
542 } else {
543 MEDIA_INFO_LOG("HStreamRepeat::SetFramRate stream The stream is not started. Save the parameters.");
544 }
545 CHECK_ERROR_PRINT_LOG(rc != HDI::Camera::V1_0::NO_ERROR,
546 "HStreamRepeat::SetFrameRate Failed with error Code:%{public}d", rc);
547 }
548 return rc;
549 }
550
SetMirror(bool isEnable)551 int32_t HStreamRepeat::SetMirror(bool isEnable)
552 {
553 enableMirror_ = isEnable;
554 return CAMERA_OK;
555 }
556
SetCameraRotation(bool isEnable,int32_t rotation)557 int32_t HStreamRepeat::SetCameraRotation(bool isEnable, int32_t rotation)
558 {
559 enableCameraRotation_ = isEnable;
560 CHECK_ERROR_RETURN_RET(rotation > STREAM_ROTATE_360, CAMERA_INVALID_ARG);
561 setCameraRotation_ = STREAM_ROTATE_360 - rotation;
562 SetStreamTransform();
563 return CAMERA_OK;
564 }
565
SetCameraApi(uint32_t apiCompatibleVersion)566 int32_t HStreamRepeat::SetCameraApi(uint32_t apiCompatibleVersion)
567 {
568 apiCompatibleVersion_ = apiCompatibleVersion;
569 return CAMERA_OK;
570 }
571
SetPreviewRotation(std::string & deviceClass)572 int32_t HStreamRepeat::SetPreviewRotation(std::string &deviceClass)
573 {
574 enableStreamRotate_ = true;
575 deviceClass_ = deviceClass;
576 return CAMERA_OK;
577 }
578
SetMirrorForLivePhoto(bool isEnable,int32_t mode)579 bool HStreamRepeat::SetMirrorForLivePhoto(bool isEnable, int32_t mode)
580 {
581 camera_metadata_item_t item;
582 const int32_t canMirrorVideoAndPhoto = 2;
583 int32_t res;
584 {
585 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
586 CHECK_ERROR_RETURN_RET(cameraAbility_ == nullptr, false);
587 res = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(),
588 OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &item);
589 }
590
591 bool isMirrorSupported = false;
592 if (res == CAM_META_SUCCESS) {
593 int step = 2;
594 for (int i = 0; i < static_cast<int>(item.count); i += step) {
595 MEDIA_DEBUG_LOG("mode u8[%{public}d]: %{public}d, u8[%{public}d], %{public}d",
596 i, item.data.u8[i], i + 1, item.data.u8[i + 1]);
597 if (mode == static_cast<int>(item.data.u8[i])) {
598 isMirrorSupported = (item.data.u8[i + 1] == canMirrorVideoAndPhoto) ? true : false;
599 }
600 }
601 }
602 if (isMirrorSupported) {
603 enableMirror_ = isEnable;
604 Start(nullptr, true);
605 } else {
606 MEDIA_ERR_LOG("HStreamRepeat::SetMirrorForLivePhoto not supported mirror with mode:%{public}d", mode);
607 }
608 return isMirrorSupported;
609 }
610
UpdateSketchRatio(float sketchRatio)611 int32_t HStreamRepeat::UpdateSketchRatio(float sketchRatio)
612 {
613 std::lock_guard<std::mutex> lock(sketchStreamLock_);
614 if (sketchStreamRepeat_ == nullptr) {
615 MEDIA_ERR_LOG("HCameraService::UpdateSketchRatio sketch stream not create!");
616 return CAMERA_INVALID_STATE;
617 }
618 sketchStreamRepeat_->sketchRatio_ = sketchRatio;
619 return CAMERA_OK;
620 }
621
GetSketchStream()622 sptr<HStreamRepeat> HStreamRepeat::GetSketchStream()
623 {
624 std::lock_guard<std::mutex> lock(sketchStreamLock_);
625 return sketchStreamRepeat_;
626 }
627
GetRepeatStreamType()628 RepeatStreamType HStreamRepeat::GetRepeatStreamType()
629 {
630 return repeatStreamType_;
631 }
632
DumpStreamInfo(CameraInfoDumper & infoDumper)633 void HStreamRepeat::DumpStreamInfo(CameraInfoDumper& infoDumper)
634 {
635 infoDumper.Title("repeat stream");
636 HStreamCommon::DumpStreamInfo(infoDumper);
637 }
638
SetStreamTransform(int disPlayRotation)639 void HStreamRepeat::SetStreamTransform(int disPlayRotation)
640 {
641 camera_metadata_item_t item;
642 int ret;
643 int32_t sensorOrientation;
644 camera_position_enum_t cameraPosition = OHOS_CAMERA_POSITION_BACK;
645 auto display = OHOS::Rosen::DisplayManager::GetInstance().GetDefaultDisplay();
646 CHECK_ERROR_RETURN_LOG(display == nullptr,
647 "HStreamRepeat::SetStreamTransform GetDefaultDisplay failed");
648 {
649 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
650 if (cameraAbility_ == nullptr) {
651 return;
652 }
653 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(), OHOS_SENSOR_ORIENTATION, &item);
654 CHECK_ERROR_RETURN_LOG(ret != CAM_META_SUCCESS,
655 "HStreamRepeat::SetStreamTransform get sensor orientation failed");
656 sensorOrientation = item.data.i32[0];
657 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform sensor orientation %{public}d", sensorOrientation);
658
659 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(), OHOS_ABILITY_CAMERA_POSITION, &item);
660 CHECK_ERROR_RETURN_LOG(ret != CAM_META_SUCCESS,
661 "HStreamRepeat::SetStreamTransform get camera position failed");
662 cameraPosition = static_cast<camera_position_enum_t>(item.data.u8[0]);
663 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform camera position: %{public}d", cameraPosition);
664 }
665 if (cameraUsedAsPosition_ != OHOS_CAMERA_POSITION_OTHER) {
666 cameraPosition = cameraUsedAsPosition_;
667 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform used camera position: %{public}d", cameraPosition);
668 }
669 if (enableCameraRotation_ && sensorOrientation != 0) {
670 ProcessCameraSetRotation(sensorOrientation, cameraPosition);
671 }
672 if (apiCompatibleVersion_ >= CAMERA_API_VERSION_BASE) {
673 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
674 return;
675 }
676 std::lock_guard<std::mutex> lock(producerLock_);
677 if (producer_ == nullptr) {
678 MEDIA_ERR_LOG("HStreamRepeat::SetStreamTransform failed, producer is null or GetDefaultDisplay failed");
679 return;
680 }
681 int mOritation = disPlayRotation;
682 if (enableStreamRotate_) {
683 if (mOritation == -1) {
684 CHECK_ERROR_RETURN_LOG(producer_ == nullptr || display == nullptr,
685 "HStreamRepeat::SetStreamTransform failed, producer is null or GetDefaultDisplay failed");
686 mOritation = static_cast<int>(display->GetRotation());
687 }
688 int32_t streamRotation = GetStreamRotation(sensorOrientation, cameraPosition, mOritation, deviceClass_);
689 ProcessCameraPosition(streamRotation, cameraPosition);
690 } else {
691 ProcessFixedTransform(sensorOrientation, cameraPosition);
692 }
693 }
694
ProcessFixedTransform(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)695 void HStreamRepeat::ProcessFixedTransform(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
696 {
697 if (enableCameraRotation_) {
698 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
699 return;
700 }
701 bool isTableFlag = system::GetBoolParameter("const.multimedia.enable_camera_rotation_compensation", 0);
702 bool isNeedChangeRotation = system::GetBoolParameter("const.multimedia.enable_camera_rotation_change", 0);
703 if (isTableFlag) {
704 ProcessFixedDiffDeviceTransform(cameraPosition);
705 return;
706 }
707 if (isNeedChangeRotation) {
708 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
709 return;
710 }
711 if (IsVerticalDevice()) {
712 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
713 } else {
714 ProcessFixedDiffDeviceTransform(cameraPosition);
715 }
716 }
717
ProcessFixedDiffDeviceTransform(camera_position_enum_t & cameraPosition)718 void HStreamRepeat::ProcessFixedDiffDeviceTransform(camera_position_enum_t& cameraPosition)
719 {
720 int ret = SurfaceError::SURFACE_ERROR_OK;
721 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
722 ret = producer_->SetTransform(GRAPHIC_FLIP_H);
723 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform filp for wide side devices");
724 } else {
725 ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
726 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform none rotate");
727 }
728 if (ret != SurfaceError::SURFACE_ERROR_OK) {
729 MEDIA_ERR_LOG("HStreamRepeat::ProcessFixedTransform failed %{public}d", ret);
730 }
731 }
732
ProcessCameraSetRotation(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)733 void HStreamRepeat::ProcessCameraSetRotation(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
734 {
735 sensorOrientation = STREAM_ROTATE_360 - setCameraRotation_;
736 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
737 sensorOrientation = (sensorOrientation == STREAM_ROTATE_180) ? GRAPHIC_ROTATE_NONE : (sensorOrientation == 0) ?
738 STREAM_ROTATE_180 : sensorOrientation;
739 }
740 if (sensorOrientation == GRAPHIC_ROTATE_NONE) {
741 int ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
742 MEDIA_ERR_LOG("HStreamRepeat::CameraSetRotation failed %{public}d", ret);
743 }
744 }
745
ProcessVerticalCameraPosition(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)746 void HStreamRepeat::ProcessVerticalCameraPosition(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
747 {
748 int ret = SurfaceError::SURFACE_ERROR_OK;
749 int32_t streamRotation = sensorOrientation;
750 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
751 switch (streamRotation) {
752 case STREAM_ROTATE_0: {
753 ret = producer_->SetTransform(GRAPHIC_FLIP_H);
754 break;
755 }
756 case STREAM_ROTATE_90: {
757 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT90);
758 break;
759 }
760 case STREAM_ROTATE_180: {
761 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT180);
762 break;
763 }
764 case STREAM_ROTATE_270: {
765 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT270);
766 break;
767 }
768 default: {
769 break;
770 }
771 }
772 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform filp rotate %{public}d", streamRotation);
773 } else {
774 streamRotation = STREAM_ROTATE_360 - sensorOrientation;
775 switch (streamRotation) {
776 case STREAM_ROTATE_0: {
777 ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
778 break;
779 }
780 case STREAM_ROTATE_90: {
781 ret = producer_->SetTransform(GRAPHIC_ROTATE_90);
782 break;
783 }
784 case STREAM_ROTATE_180: {
785 ret = producer_->SetTransform(GRAPHIC_ROTATE_180);
786 break;
787 }
788 case STREAM_ROTATE_270: {
789 ret = producer_->SetTransform(GRAPHIC_ROTATE_270);
790 break;
791 }
792 default: {
793 break;
794 }
795 }
796 MEDIA_INFO_LOG("HStreamRepeat::ProcessVerticalCameraPosition not flip rotate %{public}d", streamRotation);
797 }
798 CHECK_ERROR_PRINT_LOG(ret != SurfaceError::SURFACE_ERROR_OK,
799 "HStreamRepeat::ProcessVerticalCameraPosition failed %{public}d", ret);
800 }
801
ProcessCameraPosition(int32_t & streamRotation,camera_position_enum_t & cameraPosition)802 void HStreamRepeat::ProcessCameraPosition(int32_t& streamRotation, camera_position_enum_t& cameraPosition)
803 {
804 int ret = SurfaceError::SURFACE_ERROR_OK;
805 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
806 switch (streamRotation) {
807 case STREAM_ROTATE_0: {
808 ret = producer_->SetTransform(GRAPHIC_FLIP_H);
809 break;
810 }
811 case STREAM_ROTATE_90: {
812 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT90);
813 break;
814 }
815 case STREAM_ROTATE_180: {
816 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT180);
817 break;
818 }
819 case STREAM_ROTATE_270: {
820 ret = producer_->SetTransform(GRAPHIC_FLIP_H_ROT270);
821 break;
822 }
823 default: {
824 break;
825 }
826 }
827 } else {
828 switch (streamRotation) {
829 case STREAM_ROTATE_0: {
830 ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
831 break;
832 }
833 case STREAM_ROTATE_90: {
834 ret = producer_->SetTransform(GRAPHIC_ROTATE_90);
835 break;
836 }
837 case STREAM_ROTATE_180: {
838 ret = producer_->SetTransform(GRAPHIC_ROTATE_180);
839 break;
840 }
841 case STREAM_ROTATE_270: {
842 ret = producer_->SetTransform(GRAPHIC_ROTATE_270);
843 break;
844 }
845 default: {
846 break;
847 }
848 }
849 }
850 CHECK_ERROR_PRINT_LOG(ret != SurfaceError::SURFACE_ERROR_OK,
851 "HStreamRepeat::ProcessCameraPosition failed %{public}d", ret);
852 }
853
OperatePermissionCheck(uint32_t interfaceCode)854 int32_t HStreamRepeat::OperatePermissionCheck(uint32_t interfaceCode)
855 {
856 switch (static_cast<StreamRepeatInterfaceCode>(interfaceCode)) {
857 case CAMERA_START_VIDEO_RECORDING:
858 case CAMERA_FORK_SKETCH_STREAM_REPEAT: {
859 auto callerToken = IPCSkeleton::GetCallingTokenID();
860 if (callerToken_ != callerToken) {
861 MEDIA_ERR_LOG("HStreamRepeat::OperatePermissionCheck fail, callerToken not legal");
862 return CAMERA_OPERATION_NOT_ALLOWED;
863 }
864 break;
865 }
866 default:
867 break;
868 }
869 return CAMERA_OK;
870 }
871
OpenVideoDfxSwitch(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)872 void HStreamRepeat::OpenVideoDfxSwitch(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
873 {
874 bool status = false;
875 camera_metadata_item_t item;
876 uint8_t dfxSwitch = true;
877 CHECK_ERROR_RETURN_LOG(settings == nullptr, "HStreamRepeat::OpenVideoDfxSwitch fail, setting is null!");
878 int32_t ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_VIDEO_DEBUG_SWITCH, &item);
879 if (ret == CAM_META_ITEM_NOT_FOUND) {
880 status = settings->addEntry(OHOS_CONTROL_VIDEO_DEBUG_SWITCH, &dfxSwitch, 1);
881 MEDIA_INFO_LOG("HStreamRepeat::OpenVideoDfxSwitch success!");
882 } else {
883 status = true;
884 }
885 CHECK_ERROR_PRINT_LOG(!status, "HStreamRepeat::OpenVideoDfxSwitch fail!");
886 }
887
EnableSecure(bool isEnabled)888 int32_t HStreamRepeat::EnableSecure(bool isEnabled)
889 {
890 mEnableSecure = isEnabled;
891 return CAMERA_OK;
892 }
893
UpdateVideoSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)894 void HStreamRepeat::UpdateVideoSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
895 {
896 CHECK_AND_RETURN_LOG(settings != nullptr, "HStreamRepeat::UpdateVideoSettings settings is nullptr");
897 bool status = false;
898 camera_metadata_item_t item;
899
900 uint8_t mirror = enableMirror_;
901 MEDIA_DEBUG_LOG("HStreamRepeat::UpdateVideoSettings set Mirror %{public}d", mirror);
902 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_CAPTURE_MIRROR, &item);
903 if (ret == CAM_META_ITEM_NOT_FOUND) {
904 status = settings->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, 1);
905 } else if (ret == CAM_META_SUCCESS) {
906 status = settings->updateEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, 1);
907 }
908 CHECK_ERROR_PRINT_LOG(!status, "UpdateVideoSettings Failed to set mirroring in VideoSettings");
909 }
910
UpdateFrameRateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)911 void HStreamRepeat::UpdateFrameRateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
912 {
913 CHECK_ERROR_RETURN(settings == nullptr);
914 bool status = false;
915 camera_metadata_item_t item;
916
917 if (streamFrameRateRange_.size() != 0) {
918 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FPS_RANGES, &item);
919 if (ret == CAM_META_ITEM_NOT_FOUND) {
920 MEDIA_DEBUG_LOG("HStreamRepeat::SetFrameRate Failed to find frame range");
921 status = settings->addEntry(
922 OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
923 } else if (ret == CAM_META_SUCCESS) {
924 MEDIA_DEBUG_LOG("HStreamRepeat::SetFrameRate success to find frame range");
925 status = settings->updateEntry(
926 OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
927 }
928 CHECK_ERROR_PRINT_LOG(!status, "HStreamRepeat::SetFrameRate Failed to set frame range");
929 }
930 }
931
UpdateFrameMuteSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,std::shared_ptr<OHOS::Camera::CameraMetadata> & dynamicSetting)932 void HStreamRepeat::UpdateFrameMuteSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
933 std::shared_ptr<OHOS::Camera::CameraMetadata> &dynamicSetting)
934 {
935 CHECK_ERROR_RETURN(settings == nullptr);
936 bool status = false;
937 camera_metadata_item_t item;
938 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_MUTE_MODE, &item);
939 if (ret == CAM_META_ITEM_NOT_FOUND) {
940 return;
941 }
942 auto mode = item.data.u8[0];
943 int32_t count = 1;
944 CHECK_ERROR_RETURN_LOG(dynamicSetting == nullptr, "dynamicSetting is nullptr");
945 ret = OHOS::Camera::FindCameraMetadataItem(dynamicSetting->get(), OHOS_CONTROL_MUTE_MODE, &item);
946 if (ret == CAM_META_SUCCESS) {
947 status = dynamicSetting->updateEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
948 } else {
949 status = dynamicSetting->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
950 }
951 CHECK_ERROR_PRINT_LOG(!status, "HStreamRepeat::UpdateFrameMuteSettings Failed to set frame mute");
952 }
953
AttachMetaSurface(const sptr<OHOS::IBufferProducer> & producer,int32_t videoMetaType)954 int32_t HStreamRepeat::AttachMetaSurface(const sptr<OHOS::IBufferProducer>& producer, int32_t videoMetaType)
955 {
956 MEDIA_INFO_LOG("HStreamRepeat::AttachMetaSurface called");
957 {
958 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, CAMERA_INVALID_ARG,
959 "HStreamRepeat::AttachMetaSurface producer is null");
960 metaSurfaceBufferQueue_ = new BufferProducerSequenceable(producer);
961 }
962 return CAMERA_OK;
963 }
964 } // namespace CameraStandard
965 } // namespace OHOS
966