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