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 #include <mutex>
20
21 #ifdef NOTIFICATION_ENABLE
22 #include "camera_beauty_notification.h"
23 #endif
24 #include "camera_device_ability_items.h"
25 #include "camera_log.h"
26 #include "camera_metadata.h"
27 #include "camera_metadata_operator.h"
28 #include "display_manager.h"
29 #include "camera_util.h"
30 #include "hstream_common.h"
31 #include "ipc_skeleton.h"
32 #include "istream_repeat_callback.h"
33 #include "metadata_utils.h"
34 #include "camera_report_uitls.h"
35 #include "parameters.h"
36 #include "session/capture_scene_const.h"
37 #ifdef HOOK_CAMERA_OPERATOR
38 #include "camera_rotate_plugin.h"
39 #endif
40 #include "display/graphic/common/v2_1/cm_color_space.h"
41
42 namespace OHOS {
43 namespace CameraStandard {
44 using namespace OHOS::HDI::Camera::V1_0;
45 using CM_ColorSpaceType_V2_1 = OHOS::HDI::Display::Graphic::Common::V2_1::CM_ColorSpaceType;
HStreamRepeat(sptr<OHOS::IBufferProducer> producer,int32_t format,int32_t width,int32_t height,RepeatStreamType type)46 HStreamRepeat::HStreamRepeat(
47 sptr<OHOS::IBufferProducer> producer, int32_t format, int32_t width, int32_t height, RepeatStreamType type)
48 : HStreamCommon(StreamType::REPEAT, producer, format, width, height), repeatStreamType_(type)
49 {
50 MEDIA_INFO_LOG("HStreamRepeat::HStreamRepeat construct, format:%{public}d size:%{public}dx%{public}d "
51 "repeatType:%{public}d, streamId:%{public}d",
52 format, width, height, type, GetFwkStreamId());
53 }
54
~HStreamRepeat()55 HStreamRepeat::~HStreamRepeat()
56 {
57 MEDIA_INFO_LOG("HStreamRepeat::~HStreamRepeat deconstruct, format:%{public}d size:%{public}dx%{public}d "
58 "repeatType:%{public}d, streamId:%{public}d, hdiStreamId:%{public}d",
59 format_, width_, height_, repeatStreamType_, GetFwkStreamId(), GetHdiStreamId());
60 #ifdef NOTIFICATION_ENABLE
61 CancelNotification();
62 #endif
63 }
64
LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)65 int32_t HStreamRepeat::LinkInput(wptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator,
66 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility)
67 {
68 MEDIA_INFO_LOG(
69 "HStreamRepeat::LinkInput streamId:%{public}d ,repeatStreamType:%{public}d",
70 GetFwkStreamId(), repeatStreamType_);
71 int32_t ret = HStreamCommon::LinkInput(streamOperator, cameraAbility);
72 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret,
73 "HStreamRepeat::LinkInput err, streamId:%{public}d ,err:%{public}d", GetFwkStreamId(), ret);
74 CHECK_EXECUTE(repeatStreamType_ != RepeatStreamType::VIDEO, SetStreamTransform());
75 if (repeatStreamType_ != RepeatStreamType::VIDEO) {
76 SetStreamTransform();
77 } else {
78 #ifdef HOOK_CAMERA_OPERATOR
79 if (!CameraRotatePlugin::GetInstance()->
80 HookCreateVideoOutput(GetBasicInfo(), GetStreamProducer())) {
81 MEDIA_ERR_LOG("HCameraService::CreateVideoOutput HookCreateVideoOutput is failed");
82 }
83 #endif
84 }
85 return CAMERA_OK;
86 }
87
SetVideoStreamInfo(StreamInfo_V1_1 & streamInfo)88 void HStreamRepeat::SetVideoStreamInfo(StreamInfo_V1_1& streamInfo)
89 {
90 streamInfo.v1_0.intent_ = StreamIntent::VIDEO;
91 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_H264;
92 MEDIA_INFO_LOG("HStreamRepeat::SetVideoStreamInfo Enter");
93 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
94 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
95 HDI::Camera::V1_3::ExtendedStreamInfoType::EXTENDED_STREAM_INFO_MAKER_INFO),
96 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
97 };
98 extendedStreamInfo.bufferQueue = metaSurfaceBufferQueue_;
99 MEDIA_INFO_LOG("HStreamRepeat::SetVideoStreamInfo end");
100 streamInfo.extendedStreamInfos = { extendedStreamInfo };
101 }
102
SetSketchStreamInfo(StreamInfo_V1_1 & streamInfo)103 void HStreamRepeat::SetSketchStreamInfo(StreamInfo_V1_1& streamInfo)
104 {
105 MEDIA_DEBUG_LOG("HStreamRepeat::SetSketchStreamInfo enter");
106 streamInfo.v1_0.intent_ = StreamIntent::PREVIEW;
107 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_NULL;
108 // LCOV_EXCL_START
109 CHECK_EXECUTE(CheckVideoModeForSystemApp(currentMode_), {
110 MEDIA_DEBUG_LOG("HStreamRepeat::SetSketchStreamInfo current colorSpace : %{public}d",
111 streamInfo.v1_0.dataspace_);
112 // 系统相机录像相关模式非录像流色域信息LIMIT2FULL
113 if (streamInfo.v1_0.dataspace_ == CM_ColorSpaceType_V2_1::CM_BT2020_HLG_LIMIT) {
114 streamInfo.v1_0.dataspace_ = CM_ColorSpaceType_V2_1::CM_BT2020_HLG_FULL;
115 }
116
117 if (streamInfo.v1_0.dataspace_ == CM_ColorSpaceType_V2_1::CM_BT709_LIMIT) {
118 streamInfo.v1_0.dataspace_ = CM_ColorSpaceType_V2_1::CM_BT709_FULL;
119 }
120 });
121 // LCOV_EXCL_STOP
122 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
123 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
124 HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
125 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
126 };
127 streamInfo.extendedStreamInfos = { extendedStreamInfo };
128 MEDIA_DEBUG_LOG("HStreamRepeat::SetSketchStreamInfo end");
129 }
130
131
SetStreamInfo(StreamInfo_V1_1 & streamInfo)132 void HStreamRepeat::SetStreamInfo(StreamInfo_V1_1& streamInfo)
133 {
134 HStreamCommon::SetStreamInfo(streamInfo);
135 auto metaProducerSequenceable = metaProducer_ == nullptr ? nullptr : new BufferProducerSequenceable(metaProducer_);
136 HDI::Camera::V1_1::ExtendedStreamInfo metaExtendedStreamInfo {
137 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(4), .width = 0, .height = 0, .format = 0,
138 .dataspace = 0, .bufferQueue = metaProducerSequenceable
139 };
140 switch (repeatStreamType_) {
141 case RepeatStreamType::LIVEPHOTO:
142 streamInfo.v1_0.intent_ = StreamIntent::VIDEO;
143 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_H264;
144 streamInfo.extendedStreamInfos = { metaExtendedStreamInfo };
145 break;
146 case RepeatStreamType::VIDEO:
147 SetVideoStreamInfo(streamInfo);
148 break;
149 case RepeatStreamType::PREVIEW:
150 streamInfo.v1_0.intent_ = StreamIntent::PREVIEW;
151 streamInfo.v1_0.encodeType_ = ENCODE_TYPE_NULL;
152 // LCOV_EXCL_START
153 CHECK_EXECUTE(CheckVideoModeForSystemApp(currentMode_), {
154 MEDIA_DEBUG_LOG("HStreamRepeat::SetVideoStreamInfo current colorSpace : %{public}d",
155 streamInfo.v1_0.dataspace_);
156
157 if (streamInfo.v1_0.dataspace_ == CM_ColorSpaceType_V2_1::CM_BT2020_HLG_LIMIT) {
158 streamInfo.v1_0.dataspace_ = CM_ColorSpaceType_V2_1::CM_BT2020_HLG_FULL;
159 }
160 if (streamInfo.v1_0.dataspace_ == CM_ColorSpaceType_V2_1::CM_BT709_LIMIT) {
161 streamInfo.v1_0.dataspace_ = CM_ColorSpaceType_V2_1::CM_BT709_FULL;
162 }
163 });
164 // LCOV_EXCL_STOP
165 if (mEnableSecure) {
166 MEDIA_INFO_LOG("HStreamRepeat::SetStreamInfo Enter");
167 HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
168 .type = static_cast<HDI::Camera::V1_1::ExtendedStreamInfoType>(
169 HDI::Camera::V1_3::ExtendedStreamInfoType::EXTENDED_STREAM_INFO_SECURE),
170 .width = 0, .height = 0, .format = 0, .dataspace = 0, .bufferQueue = nullptr
171 };
172 MEDIA_INFO_LOG("HStreamRepeat::SetStreamInfo end");
173 streamInfo.extendedStreamInfos = { extendedStreamInfo };
174 }
175 break;
176 case RepeatStreamType::SKETCH:
177 SetSketchStreamInfo(streamInfo);
178 break;
179 }
180 }
181
SetCurrentMode(int32_t mode)182 int32_t HStreamRepeat::SetCurrentMode(int32_t mode)
183 {
184 MEDIA_DEBUG_LOG("HStreamRepeat::SetCurentMode current mode:%{public}d", mode);
185 currentMode_ = mode;
186 return 0;
187 }
188
CheckVideoModeForSystemApp(int32_t sceneMode)189 bool HStreamRepeat::CheckVideoModeForSystemApp(int32_t sceneMode)
190 {
191 CHECK_RETURN_RET_ILOG(!CheckSystemApp(), false, "CheckVideoModeForSystemApp is not SystemApp");
192 std::vector<SceneMode> videoModeVec = {
193 SceneMode::VIDEO,
194 SceneMode::SLOW_MOTION,
195 SceneMode::VIDEO_MACRO,
196 SceneMode::PROFESSIONAL_VIDEO,
197 SceneMode::HIGH_FRAME_RATE,
198 SceneMode::TIMELAPSE_PHOTO,
199 SceneMode::APERTURE_VIDEO,
200 };
201 auto iterator = std::find(videoModeVec.begin(), videoModeVec.end(), static_cast<SceneMode>(sceneMode));
202 CHECK_RETURN_RET_ILOG(iterator != videoModeVec.end(), true,
203 "HStreamRepeat::CheckVideoModeForSystemApp current sceneMode: %{public}d", sceneMode);
204 return false;
205 }
206
SetMetaProducer(sptr<OHOS::IBufferProducer> metaProducer)207 void HStreamRepeat::SetMetaProducer(sptr<OHOS::IBufferProducer> metaProducer)
208 {
209 std::lock_guard<std::mutex> lock(producerLock_);
210 metaProducer_ = metaProducer;
211 }
212
SetMovingPhotoStartCallback(std::function<void ()> callback)213 void HStreamRepeat::SetMovingPhotoStartCallback(std::function<void()> callback)
214 {
215 std::lock_guard<std::mutex> lock(movingPhotoCallbackLock_);
216 startMovingPhotoCallback_ = callback;
217 }
218
UpdateSketchStatus(SketchStatus status)219 void HStreamRepeat::UpdateSketchStatus(SketchStatus status)
220 {
221 CHECK_RETURN(repeatStreamType_ != RepeatStreamType::SKETCH);
222 auto parent = parentStreamRepeat_.promote();
223 CHECK_RETURN(parent == nullptr);
224 CHECK_RETURN(sketchStatus_ == status);
225 sketchStatus_ = status;
226 parent->OnSketchStatusChanged(sketchStatus_);
227 }
228
StartSketchStream(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)229 void HStreamRepeat::StartSketchStream(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
230 {
231 CAMERA_SYNC_TRACE;
232 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream Enter");
233 sptr<HStreamRepeat> sketchStreamRepeat;
234 {
235 std::lock_guard<std::mutex> lock(sketchStreamLock_);
236 if (sketchStreamRepeat_ == nullptr || sketchStreamRepeat_->sketchRatio_ <= 0) {
237 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream sketchStreamRepeat_ is null or ratio is illegal");
238 return;
239 }
240 sketchStreamRepeat = sketchStreamRepeat_;
241 }
242 camera_metadata_item_t item;
243 int32_t ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
244 if (ret != CAM_META_SUCCESS || item.count <= 0) {
245 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream get OHOS_CONTROL_ZOOM_RATIO fail");
246 return;
247 }
248 float tagRatio = *item.data.f;
249 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream OHOS_CONTROL_ZOOM_RATIO >>> tagRatio:%{public}f -- "
250 "sketchRatio:%{public}f",
251 tagRatio, sketchStreamRepeat->sketchRatio_);
252 if (sketchStreamRepeat->sketchRatio_ > 0 &&
253 tagRatio - sketchStreamRepeat->sketchRatio_ >= -std::numeric_limits<float>::epsilon()) {
254 sketchStreamRepeat->Start();
255 }
256 MEDIA_DEBUG_LOG("HStreamRepeat::StartSketchStream Exit");
257 }
258
SetUsedAsPosition(camera_position_enum_t cameraPosition)259 void HStreamRepeat::SetUsedAsPosition(camera_position_enum_t cameraPosition)
260 {
261 MEDIA_INFO_LOG("HStreamRepeat::SetUsedAsPosition %{public}d", cameraPosition);
262 cameraUsedAsPosition_ = cameraPosition;
263 SetStreamTransform();
264 }
265
Start(std::shared_ptr<OHOS::Camera::CameraMetadata> settings,bool isUpdateSeetings)266 int32_t HStreamRepeat::Start(std::shared_ptr<OHOS::Camera::CameraMetadata> settings, bool isUpdateSeetings)
267 {
268 CAMERA_SYNC_TRACE;
269 auto streamOperator = GetStreamOperator();
270 CHECK_RETURN_RET(streamOperator == nullptr, CAMERA_INVALID_STATE);
271 auto preparedCaptureId = GetPreparedCaptureId();
272 CHECK_RETURN_RET_ELOG(!isUpdateSeetings && preparedCaptureId != CAPTURE_ID_UNSET, CAMERA_INVALID_STATE,
273 "HStreamRepeat::Start, Already started with captureID: %{public}d", preparedCaptureId);
274 // If current is sketch stream, check parent is start or not.
275 if (repeatStreamType_ == RepeatStreamType::SKETCH) {
276 auto parentRepeat = parentStreamRepeat_.promote();
277 CHECK_RETURN_RET_ELOG(parentRepeat == nullptr || parentRepeat->GetPreparedCaptureId() == CAPTURE_ID_UNSET,
278 CAMERA_INVALID_STATE, "HStreamRepeat::Start sketch parent state is illegal");
279 }
280 if (!isUpdateSeetings) {
281 int32_t ret = PrepareCaptureId();
282 preparedCaptureId = GetPreparedCaptureId();
283 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK || preparedCaptureId == CAPTURE_ID_UNSET, ret,
284 "HStreamRepeat::Start Failed to allocate a captureId");
285 }
286 UpdateSketchStatus(SketchStatus::STARTING);
287
288 std::vector<uint8_t> ability;
289 {
290 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
291 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraAbility_, ability);
292 }
293 std::shared_ptr<OHOS::Camera::CameraMetadata> dynamicSetting = nullptr;
294 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(ability, dynamicSetting);
295 if (dynamicSetting == nullptr) {
296 dynamicSetting = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
297 }
298 // open video dfx switch for hal, no need close
299 if (repeatStreamType_ == RepeatStreamType::PREVIEW) {
300 OpenVideoDfxSwitch(dynamicSetting);
301 }
302 if (repeatStreamType_ == RepeatStreamType::VIDEO || repeatStreamType_ == RepeatStreamType::LIVEPHOTO) {
303 UpdateVideoSettings(dynamicSetting, enableMirror_);
304 }
305 if (repeatStreamType_ == RepeatStreamType::PREVIEW || repeatStreamType_ == RepeatStreamType::VIDEO) {
306 UpdateHalRoateSettings(dynamicSetting);
307 UpdateFrameRateSettings(dynamicSetting);
308 }
309 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
310 #ifdef HOOK_CAMERA_OPERATOR
311 bool mirror = 0;
312 if (CameraRotatePlugin::GetInstance()->
313 HookVideoStreamStart(GetBasicInfo(), GetStreamProducer(), mirror)) {
314 UpdateVideoSettings(dynamicSetting, mirror);
315 }
316 #endif
317 }
318 if (settings != nullptr) {
319 UpdateFrameMuteSettings(settings, dynamicSetting);
320 UpdateFrameMechSettings(settings, dynamicSetting);
321 }
322 #ifdef NOTIFICATION_ENABLE
323 bool isNeedBeautyNotification = IsNeedBeautyNotification();
324 if (isNeedBeautyNotification && CameraBeautyNotification::GetInstance()->GetBeautyStatus() == BEAUTY_STATUS_ON) {
325 UpdateBeautySettings(dynamicSetting);
326 }
327 #endif
328
329 std::vector<uint8_t> captureSetting;
330 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(dynamicSetting, captureSetting);
331
332 CaptureInfo captureInfo;
333 captureInfo.streamIds_ = { GetHdiStreamId() };
334 captureInfo.captureSetting_ = captureSetting;
335 captureInfo.enableShutterCallback_ = false;
336 MEDIA_INFO_LOG("HStreamRepeat::Start streamId:%{public}d hdiStreamId:%{public}d With capture ID: %{public}d, "
337 "repeatStreamType:%{public}d",
338 GetFwkStreamId(), GetHdiStreamId(), preparedCaptureId, repeatStreamType_);
339 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
340 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
341 const std::string permissionName = "ohos.permission.CAMERA";
342 AddCameraPermissionUsedRecord(callingTokenId, permissionName);
343 }
344 int32_t ret = 0;
345 {
346 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
347 HStreamCommon::PrintCaptureDebugLog(dynamicSetting);
348 CamRetCode rc = (CamRetCode)(streamOperator->Capture(preparedCaptureId, captureInfo, true));
349 if (rc != HDI::Camera::V1_0::NO_ERROR) {
350 ResetCaptureId();
351 MEDIA_ERR_LOG("HStreamRepeat::Start Failed with error Code:%{public}d", rc);
352 camera_metadata_item_t item;
353 uint8_t connectionType = 0;
354 if (settings != nullptr) {
355 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
356 if (ret == CAM_META_SUCCESS && item.count > 0) {
357 connectionType = item.data.u8[0];
358 }
359 }
360 MEDIA_ERR_LOG("HStreamRepeat::Start Failed with error Code:%{public}d", rc);
361 CameraReportUtils::ReportCameraErrorForUsb(
362 "HStreamRepeat::Start", rc, true, std::to_string(connectionType), CameraReportUtils::GetCallerInfo());
363 ret = HdiToServiceError(rc);
364 UpdateSketchStatus(SketchStatus::STOPED);
365 } else {
366 repeatStreamStatus_ = RepeatStreamStatus::STARTED;
367 }
368 }
369 CHECK_EXECUTE(settings != nullptr, StartSketchStream(settings));
370 #ifdef NOTIFICATION_ENABLE
371 if (isNeedBeautyNotification) {
372 CameraBeautyNotification::GetInstance()->PublishNotification(true);
373 }
374 #endif
375 return ret;
376 }
377
Start()378 int32_t HStreamRepeat::Start()
379 {
380 return Start(nullptr);
381 }
382
Stop()383 int32_t HStreamRepeat::Stop()
384 {
385 CAMERA_SYNC_TRACE;
386 auto streamOperator = GetStreamOperator();
387 CHECK_RETURN_RET_ELOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
388 "HStreamRepeat::Stop streamOperator is null");
389 auto preparedCaptureId = GetPreparedCaptureId();
390 MEDIA_INFO_LOG("HStreamRepeat::Stop streamId:%{public}d hdiStreamId:%{public}d With capture ID: %{public}d, "
391 "repeatStreamType:%{public}d",
392 GetFwkStreamId(), GetHdiStreamId(), preparedCaptureId, repeatStreamType_);
393 CHECK_RETURN_RET_ELOG(preparedCaptureId == CAPTURE_ID_UNSET, CAMERA_INVALID_STATE,
394 "HStreamRepeat::Stop, Stream not started yet");
395 UpdateSketchStatus(SketchStatus::STOPPING);
396 int32_t ret = CAMERA_OK;
397 {
398 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
399 ret = StopStream();
400 if (ret != CAMERA_OK) {
401 MEDIA_ERR_LOG("HStreamRepeat::Stop Failed with errorCode:%{public}d, curCaptureID_: %{public}d",
402 ret, preparedCaptureId);
403 } else {
404 repeatStreamStatus_ = RepeatStreamStatus::STOPED;
405 }
406 }
407 {
408 std::lock_guard<std::mutex> lock(sketchStreamLock_);
409 CHECK_EXECUTE(sketchStreamRepeat_ != nullptr, sketchStreamRepeat_->Stop());
410 }
411 return ret;
412 }
413
Release()414 int32_t HStreamRepeat::Release()
415 {
416 return ReleaseStream(false);
417 }
418
ReleaseStream(bool isDelay)419 int32_t HStreamRepeat::ReleaseStream(bool isDelay)
420 {
421 {
422 std::lock_guard<std::mutex> lock(callbackLock_);
423 streamRepeatCallback_ = nullptr;
424 }
425
426 {
427 std::lock_guard<std::mutex> lock(sketchStreamLock_);
428 CHECK_EXECUTE(sketchStreamRepeat_ != nullptr, sketchStreamRepeat_->Release());
429 }
430 return HStreamCommon::ReleaseStream(isDelay);
431 }
432
SetCallback(const sptr<IStreamRepeatCallback> & callback)433 int32_t HStreamRepeat::SetCallback(const sptr<IStreamRepeatCallback>& callback)
434 {
435 CHECK_RETURN_RET_ELOG(callback == nullptr, CAMERA_INVALID_ARG, "HStreamRepeat::SetCallback callback is null");
436 std::lock_guard<std::mutex> lock(callbackLock_);
437 streamRepeatCallback_ = callback;
438 return CAMERA_OK;
439 }
440
UnSetCallback()441 int32_t HStreamRepeat::UnSetCallback()
442 {
443 std::lock_guard<std::mutex> lock(callbackLock_);
444 streamRepeatCallback_ = nullptr;
445 return CAMERA_OK;
446 }
447
OnFrameStarted()448 int32_t HStreamRepeat::OnFrameStarted()
449 {
450 CAMERA_SYNC_TRACE;
451 {
452 std::lock_guard<std::mutex> lock(callbackLock_);
453 CHECK_EXECUTE(streamRepeatCallback_ != nullptr, streamRepeatCallback_->OnFrameStarted());
454 }
455 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
456 // report video start dfx
457 DfxCaptureInfo captureInfo;
458 captureInfo.captureId = 1;
459 captureInfo.caller = CameraReportUtils::GetCallerInfo();
460 CameraReportUtils::GetInstance().SetVideoStartInfo(captureInfo);
461 }
462
463 UpdateSketchStatus(SketchStatus::STARTED);
464 return CAMERA_OK;
465 }
466
OnFrameEnded(int32_t frameCount)467 int32_t HStreamRepeat::OnFrameEnded(int32_t frameCount)
468 {
469 CAMERA_SYNC_TRACE;
470 {
471 std::lock_guard<std::mutex> lock(callbackLock_);
472 CHECK_EXECUTE(streamRepeatCallback_ != nullptr, streamRepeatCallback_->OnFrameEnded(frameCount));
473 }
474 // report video end dfx
475 CHECK_EXECUTE(repeatStreamType_ == RepeatStreamType::VIDEO, CameraReportUtils::GetInstance().SetVideoEndInfo(1));
476 UpdateSketchStatus(SketchStatus::STOPED);
477 return CAMERA_OK;
478 }
479
OnDeferredVideoEnhancementInfo(CaptureEndedInfoExt captureEndedInfo)480 int32_t HStreamRepeat::OnDeferredVideoEnhancementInfo(CaptureEndedInfoExt captureEndedInfo)
481 {
482 CAMERA_SYNC_TRACE;
483 MEDIA_INFO_LOG("HStreamRepeat::OnDeferredVideoEnhancementInfo");
484 if (repeatStreamType_ == RepeatStreamType::VIDEO) {
485 // report video end dfx
486 CameraReportUtils::GetInstance().SetVideoEndInfo(1);
487 std::lock_guard<std::mutex> lock(callbackLock_);
488 CHECK_EXECUTE(streamRepeatCallback_ != nullptr,
489 streamRepeatCallback_->OnDeferredVideoEnhancementInfo(captureEndedInfo));
490 }
491 return CAMERA_OK;
492 }
493
OnFrameError(int32_t errorType)494 int32_t HStreamRepeat::OnFrameError(int32_t errorType)
495 {
496 std::lock_guard<std::mutex> lock(callbackLock_);
497 MEDIA_DEBUG_LOG("HStreamRepeat::OnFrameError %{public}d %{public}d", errorType, streamRepeatCallback_ == nullptr);
498 CHECK_EXECUTE(errorType == HDI::Camera::V1_3::HIGH_TEMPERATURE_ERROR, UpdateSketchStatus(SketchStatus::STOPED));
499 if (streamRepeatCallback_ != nullptr) {
500 int32_t repeatErrorCode;
501 if (errorType == BUFFER_LOST) {
502 repeatErrorCode = CAMERA_STREAM_BUFFER_LOST;
503 } else {
504 repeatErrorCode = CAMERA_UNKNOWN_ERROR;
505 }
506 CAMERA_SYSEVENT_FAULT(CreateMsg("Preview OnFrameError! errorCode:%d", repeatErrorCode));
507 streamRepeatCallback_->OnFrameError(repeatErrorCode);
508 }
509 return CAMERA_OK;
510 }
511
OnSketchStatusChanged(SketchStatus status)512 int32_t HStreamRepeat::OnSketchStatusChanged(SketchStatus status)
513 {
514 std::lock_guard<std::mutex> lock(callbackLock_);
515 MEDIA_DEBUG_LOG("HStreamRepeat::OnSketchStatusChanged %{public}d", status);
516 CHECK_EXECUTE(streamRepeatCallback_ != nullptr, streamRepeatCallback_->OnSketchStatusChanged(status));
517 return CAMERA_OK;
518 }
519
AddDeferredSurface(const sptr<OHOS::IBufferProducer> & producer)520 int32_t HStreamRepeat::AddDeferredSurface(const sptr<OHOS::IBufferProducer>& producer)
521 {
522 MEDIA_INFO_LOG("HStreamRepeat::AddDeferredSurface called");
523 {
524 std::lock_guard<std::mutex> lock(producerLock_);
525 CHECK_RETURN_RET_ELOG(producer == nullptr, CAMERA_INVALID_ARG,
526 "HStreamRepeat::AddDeferredSurface producer is null");
527 producer_ = producer;
528 }
529
530 if (repeatStreamType_ == RepeatStreamType::SKETCH) {
531 MEDIA_INFO_LOG("HStreamRepeat::AddDeferredSurface sketch add deferred surface");
532 auto parent = parentStreamRepeat_.promote();
533 if (parent != nullptr) {
534 std::lock_guard<std::mutex> lock(parent->producerLock_);
535 parent->SyncTransformToSketch();
536 } else {
537 MEDIA_ERR_LOG("HStreamRepeat::AddDeferredSurface sketch add deferred surface parent is nullptr");
538 }
539 } else {
540 SetStreamTransform();
541 }
542 auto streamOperator = GetStreamOperator();
543 CHECK_RETURN_RET_ELOG(streamOperator == nullptr, CAMERA_INVALID_STATE,
544 "HStreamRepeat::CreateAndHandleDeferredStreams(), streamOperator_ == null");
545 MEDIA_INFO_LOG("HStreamRepeat::AttachBufferQueue start streamId:%{public}d, hdiStreamId:%{public}d",
546 GetFwkStreamId(), GetHdiStreamId());
547 sptr<BufferProducerSequenceable> bufferProducerSequenceable;
548 CamRetCode rc;
549 {
550 std::lock_guard<std::mutex> lock(producerLock_);
551 bufferProducerSequenceable = new BufferProducerSequenceable(producer_);
552 }
553 rc = (CamRetCode)(streamOperator->AttachBufferQueue(GetHdiStreamId(), bufferProducerSequenceable));
554 CHECK_PRINT_ELOG(rc != HDI::Camera::V1_0::NO_ERROR,
555 "HStreamRepeat::AttachBufferQueue(), Failed to AttachBufferQueue %{public}d", rc);
556 MEDIA_INFO_LOG("HStreamRepeat::AddDeferredSurface end %{public}d", rc);
557 std::lock_guard<std::mutex> lock(movingPhotoCallbackLock_);
558 if (startMovingPhotoCallback_) {
559 startMovingPhotoCallback_();
560 startMovingPhotoCallback_ = nullptr;
561 }
562 return CAMERA_OK;
563 }
564
ForkSketchStreamRepeat(int32_t width,int32_t height,sptr<IRemoteObject> & sketchStream,float sketchRatio)565 int32_t HStreamRepeat::ForkSketchStreamRepeat(
566 int32_t width, int32_t height, sptr<IRemoteObject>& sketchStream, float sketchRatio)
567 {
568 CAMERA_SYNC_TRACE;
569 std::lock_guard<std::mutex> lock(sketchStreamLock_);
570 CHECK_RETURN_RET_ELOG(width <= 0 || height <= 0, CAMERA_INVALID_ARG,
571 "HCameraService::ForkSketchStreamRepeat args is illegal");
572 CHECK_EXECUTE(sketchStreamRepeat_ != nullptr, sketchStreamRepeat_->Release());
573
574 auto streamRepeat = new (std::nothrow) HStreamRepeat(nullptr, format_, width, height, RepeatStreamType::SKETCH);
575 CHECK_RETURN_RET_ELOG(streamRepeat == nullptr, CAMERA_ALLOC_ERROR,
576 "HStreamRepeat::ForkSketchStreamRepeat HStreamRepeat allocation failed");
577 MEDIA_DEBUG_LOG(
578 "HStreamRepeat::ForkSketchStreamRepeat para is:%{public}dx%{public}d,%{public}f", width, height, sketchRatio);
579 sketchStream = streamRepeat->AsObject();
580 sketchStreamRepeat_ = streamRepeat;
581 sketchStreamRepeat_->sketchRatio_ = sketchRatio;
582 sketchStreamRepeat_->parentStreamRepeat_ = this;
583 MEDIA_INFO_LOG("HCameraService::ForkSketchStreamRepeat end");
584 return CAMERA_OK;
585 }
586
RemoveSketchStreamRepeat()587 int32_t HStreamRepeat::RemoveSketchStreamRepeat()
588 {
589 CAMERA_SYNC_TRACE;
590 std::lock_guard<std::mutex> lock(sketchStreamLock_);
591 CHECK_RETURN_RET(sketchStreamRepeat_ == nullptr, CAMERA_OK);
592 sketchStreamRepeat_->Release();
593 sketchStreamRepeat_->parentStreamRepeat_ = nullptr;
594 sketchStreamRepeat_ = nullptr;
595
596 return CAMERA_OK;
597 }
598
SetFrameRate(int32_t minFrameRate,int32_t maxFrameRate)599 int32_t HStreamRepeat::SetFrameRate(int32_t minFrameRate, int32_t maxFrameRate)
600 {
601 streamFrameRateRange_ = {minFrameRate, maxFrameRate};
602 std::vector<uint8_t> ability;
603 std::vector<uint8_t> repeatSettings;
604 CHECK_RETURN_RET_ELOG(cameraAbility_ == nullptr, CAMERA_OK,
605 "HStreamRepeat::SetFrameRate cameraAbility_ is null");
606 {
607 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
608 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraAbility_, ability);
609 std::shared_ptr<OHOS::Camera::CameraMetadata> dynamicSetting = nullptr;
610 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(ability, dynamicSetting);
611 if (dynamicSetting == nullptr) {
612 dynamicSetting = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
613 }
614 CHECK_RETURN_RET_ELOG(dynamicSetting == nullptr, CAMERA_INVALID_ARG,
615 "HStreamRepeat::SetFrameRate dynamicSetting is nullptr.");
616 bool status = AddOrUpdateMetadata(
617 dynamicSetting, OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
618 CHECK_PRINT_ELOG(!status, "HStreamRepeat::SetFrameRate Failed to set frame range");
619 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(dynamicSetting, repeatSettings);
620 }
621 auto streamOperator = GetStreamOperator();
622
623 CamRetCode rc = HDI::Camera::V1_0::NO_ERROR;
624 if (streamOperator != nullptr) {
625 std::lock_guard<std::mutex> startStopLock(streamStartStopLock_);
626 if (repeatStreamStatus_ == RepeatStreamStatus::STARTED) {
627 CaptureInfo captureInfo;
628 captureInfo.streamIds_ = {GetHdiStreamId()};
629 captureInfo.captureSetting_ = repeatSettings;
630 captureInfo.enableShutterCallback_ = false;
631 int32_t currentCaptureId = GetPreparedCaptureId();
632 MEDIA_INFO_LOG("HStreamRepeat::SetFramRate stream:%{public}d, with settingCapture ID:%{public}d",
633 GetFwkStreamId(), currentCaptureId);
634 rc = (CamRetCode)(streamOperator->Capture(currentCaptureId, captureInfo, true));
635 } else {
636 MEDIA_INFO_LOG("HStreamRepeat::SetFramRate stream The stream is not started. Save the parameters.");
637 }
638 CHECK_PRINT_ELOG(rc != HDI::Camera::V1_0::NO_ERROR,
639 "HStreamRepeat::SetFrameRate Failed with error Code:%{public}d", rc);
640 }
641 return rc;
642 }
643
SetMirror(bool isEnable)644 int32_t HStreamRepeat::SetMirror(bool isEnable)
645 {
646 enableMirror_ = isEnable;
647 return CAMERA_OK;
648 }
649
SetMirrorForLivePhoto(bool isEnable,int32_t mode)650 bool HStreamRepeat::SetMirrorForLivePhoto(bool isEnable, int32_t mode)
651 {
652 camera_metadata_item_t item;
653 const int32_t canMirrorVideoAndPhoto = 2;
654 int32_t res;
655 {
656 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
657 CHECK_RETURN_RET(cameraAbility_ == nullptr, false);
658 res = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(),
659 OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &item);
660 }
661
662 bool isMirrorSupported = false;
663 if (res == CAM_META_SUCCESS) {
664 int step = 2;
665 for (int i = 0; i < static_cast<int>(item.count); i += step) {
666 MEDIA_DEBUG_LOG("mode u8[%{public}d]: %{public}d, u8[%{public}d], %{public}d",
667 i, item.data.u8[i], i + 1, item.data.u8[i + 1]);
668 if (mode == static_cast<int>(item.data.u8[i])) {
669 isMirrorSupported = (item.data.u8[i + 1] == canMirrorVideoAndPhoto) ? true : false;
670 }
671 }
672 }
673 if (isMirrorSupported) {
674 enableMirror_ = isEnable;
675 Start(nullptr, true);
676 } else {
677 MEDIA_ERR_LOG("HStreamRepeat::SetMirrorForLivePhoto not supported mirror with mode:%{public}d", mode);
678 }
679 return isMirrorSupported;
680 }
681
SetCameraRotation(bool isEnable,int32_t rotation)682 int32_t HStreamRepeat::SetCameraRotation(bool isEnable, int32_t rotation)
683 {
684 enableCameraRotation_ = isEnable;
685 CHECK_RETURN_RET(rotation > STREAM_ROTATE_360, CAMERA_INVALID_ARG);
686 setCameraRotation_ = STREAM_ROTATE_360 - rotation;
687 SetStreamTransform();
688 return CAMERA_OK;
689 }
690
SetCameraApi(uint32_t apiCompatibleVersion)691 int32_t HStreamRepeat::SetCameraApi(uint32_t apiCompatibleVersion)
692 {
693 apiCompatibleVersion_ = apiCompatibleVersion;
694 return CAMERA_OK;
695 }
696
GetMirror(bool & isEnable)697 int32_t HStreamRepeat::GetMirror(bool& isEnable)
698 {
699 isEnable = enableMirror_;
700 return CAMERA_OK;
701 }
702
SetPreviewRotation(std::string & deviceClass)703 int32_t HStreamRepeat::SetPreviewRotation(std::string &deviceClass)
704 {
705 enableStreamRotate_ = true;
706 deviceClass_ = deviceClass;
707 return CAMERA_OK;
708 }
709
UpdateSketchRatio(float sketchRatio)710 int32_t HStreamRepeat::UpdateSketchRatio(float sketchRatio)
711 {
712 std::lock_guard<std::mutex> lock(sketchStreamLock_);
713 CHECK_RETURN_RET_ELOG(sketchStreamRepeat_ == nullptr, CAMERA_INVALID_STATE,
714 "HCameraService::UpdateSketchRatio sketch stream not create!");
715 sketchStreamRepeat_->sketchRatio_ = sketchRatio;
716 return CAMERA_OK;
717 }
718
GetSketchStream()719 sptr<HStreamRepeat> HStreamRepeat::GetSketchStream()
720 {
721 std::lock_guard<std::mutex> lock(sketchStreamLock_);
722 return sketchStreamRepeat_;
723 }
724
GetRepeatStreamType()725 RepeatStreamType HStreamRepeat::GetRepeatStreamType()
726 {
727 return repeatStreamType_;
728 }
729
DumpStreamInfo(CameraInfoDumper & infoDumper)730 void HStreamRepeat::DumpStreamInfo(CameraInfoDumper& infoDumper)
731 {
732 infoDumper.Title("repeat stream");
733 HStreamCommon::DumpStreamInfo(infoDumper);
734 }
735
SyncTransformToSketch()736 void HStreamRepeat::SyncTransformToSketch()
737 {
738 CHECK_RETURN_ELOG(producer_ == nullptr, "HStreamRepeat::SyncTransformToSketch producer_ is null");
739 GraphicTransformType previewTransform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
740 int ret = producer_->GetTransform(previewTransform);
741 MEDIA_INFO_LOG("HStreamRepeat::SyncTransformToSketch previewTransform is %{public}d", previewTransform);
742 CHECK_RETURN_ELOG(ret != GSERROR_OK, "HStreamRepeat::SyncTransformToSketch GetTransform fail %{public}d", ret);
743 auto sketchStream = GetSketchStream();
744 CHECK_RETURN_ELOG(sketchStream == nullptr, "HStreamRepeat::SyncTransformToSketch sketchStream is null");
745 std::lock_guard<std::mutex> lock(sketchStream->producerLock_);
746 CHECK_RETURN_ELOG(
747 sketchStream->producer_ == nullptr, "HStreamRepeat::SyncTransformToSketch sketchStream->producer_ is null");
748 ret = sketchStream->producer_->SetTransform(previewTransform);
749 CHECK_RETURN_ELOG(ret != GSERROR_OK, "HStreamRepeat::SyncTransformToSketch SetTransform fail %{public}d", ret);
750 }
751
SetStreamTransform(int disPlayRotation)752 void HStreamRepeat::SetStreamTransform(int disPlayRotation)
753 {
754 camera_metadata_item_t item;
755 int32_t sensorOrientation;
756 camera_position_enum_t cameraPosition = OHOS_CAMERA_POSITION_BACK;
757 auto display = OHOS::Rosen::DisplayManager::GetInstance().GetDefaultDisplay();
758 CHECK_RETURN_ELOG(display == nullptr,
759 "HStreamRepeat::SetStreamTransform GetDefaultDisplay failed");
760 {
761 std::lock_guard<std::mutex> lock(cameraAbilityLock_);
762 CHECK_RETURN(cameraAbility_ == nullptr);
763 int ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(), OHOS_SENSOR_ORIENTATION, &item);
764 CHECK_RETURN_ELOG(ret != CAM_META_SUCCESS,
765 "HStreamRepeat::SetStreamTransform get sensor orientation failed");
766 sensorOrientation = item.data.i32[0];
767 MEDIA_DEBUG_LOG("HStreamRepeat::SetStreamTransform sensor orientation %{public}d", sensorOrientation);
768
769 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility_->get(), OHOS_ABILITY_CAMERA_POSITION, &item);
770 CHECK_RETURN_ELOG(ret != CAM_META_SUCCESS,
771 "HStreamRepeat::SetStreamTransform get camera position failed");
772 cameraPosition = static_cast<camera_position_enum_t>(item.data.u8[0]);
773 MEDIA_DEBUG_LOG("HStreamRepeat::SetStreamTransform camera position: %{public}d", cameraPosition);
774 }
775 std::lock_guard<std::mutex> lock(producerLock_);
776 CHECK_RETURN_ELOG(producer_ == nullptr,
777 "HStreamRepeat::SetStreamTransform failed, producer is null or GetDefaultDisplay failed");
778 if (cameraUsedAsPosition_ != OHOS_CAMERA_POSITION_OTHER) {
779 cameraPosition = cameraUsedAsPosition_;
780 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform used camera position: %{public}d", cameraPosition);
781 }
782 if (enableCameraRotation_ && sensorOrientation != 0) {
783 ProcessCameraSetRotation(sensorOrientation, cameraPosition);
784 }
785 if (apiCompatibleVersion_ >= CAMERA_API_VERSION_BASE) {
786 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
787 return;
788 }
789 int mOritation = disPlayRotation;
790 if (enableStreamRotate_) {
791 if (mOritation == -1) {
792 CHECK_RETURN_ELOG(producer_ == nullptr || display == nullptr,
793 "HStreamRepeat::SetStreamTransform failed, producer is null or GetDefaultDisplay failed");
794 mOritation = static_cast<int>(display->GetRotation());
795 }
796 int32_t streamRotation = GetStreamRotation(sensorOrientation, cameraPosition, mOritation, deviceClass_);
797 ProcessCameraPosition(streamRotation, cameraPosition);
798 } else {
799 ProcessFixedTransform(sensorOrientation, cameraPosition);
800 }
801 SyncTransformToSketch();
802 }
803
ProcessFixedTransform(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)804 void HStreamRepeat::ProcessFixedTransform(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
805 {
806 if (enableCameraRotation_) {
807 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
808 return;
809 }
810 bool isTableFlag = system::GetBoolParameter("const.multimedia.enable_camera_rotation_compensation", 0);
811 bool isNeedChangeRotation = system::GetBoolParameter("const.multimedia.enable_camera_rotation_change", 0);
812 if (isTableFlag) { // LCOV_EXCL_LINE
813 ProcessFixedDiffDeviceTransform(sensorOrientation, cameraPosition);
814 return;
815 }
816 if (isNeedChangeRotation) { // LCOV_EXCL_LINE
817 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
818 return;
819 }
820 if (IsVerticalDevice()) { // LCOV_EXCL_LINE
821 ProcessVerticalCameraPosition(sensorOrientation, cameraPosition);
822 } else {
823 ProcessFixedDiffDeviceTransform(sensorOrientation, cameraPosition);
824 }
825 }
826
ProcessFixedDiffDeviceTransform(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)827 void HStreamRepeat::ProcessFixedDiffDeviceTransform(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
828 {
829 MEDIA_INFO_LOG("HStreamRepeat::ProcessFixedDiffDeviceTransform is called");
830 int ret = SurfaceError::SURFACE_ERROR_OK;
831 #ifdef HOOK_CAMERA_OPERATOR
832 int32_t cameraPositionTemp = static_cast<int32_t>(cameraPosition);
833 if (CameraRotatePlugin::GetInstance()->HookPreviewTransform(GetBasicInfo(), producer_,
834 sensorOrientation, cameraPositionTemp)) {
835 int32_t streamRotation = sensorOrientation;
836 if (cameraPositionTemp == OHOS_CAMERA_POSITION_FRONT) {
837 ret = HandleCameraTransform(streamRotation, true);
838 } else {
839 streamRotation = STREAM_ROTATE_360 - sensorOrientation;
840 ret = HandleCameraTransform(streamRotation, false);
841 }
842 return;
843 }
844 MEDIA_ERR_LOG("HStreamRepeat::ProcessFixedDiffDeviceTransform HookPreviewTransform is failed");
845 #endif
846 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
847 ret = producer_->SetTransform(GRAPHIC_FLIP_H);
848 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform filp for wide side devices");
849 } else {
850 ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
851 MEDIA_INFO_LOG("HStreamRepeat::SetStreamTransform none rotate");
852 }
853 CHECK_PRINT_ELOG(ret != SurfaceError::SURFACE_ERROR_OK,
854 "HStreamRepeat::ProcessFixedTransform failed %{public}d", ret);
855 }
856
ProcessCameraSetRotation(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)857 void HStreamRepeat::ProcessCameraSetRotation(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
858 {
859 sensorOrientation = STREAM_ROTATE_360 - setCameraRotation_;
860 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
861 sensorOrientation = (sensorOrientation == STREAM_ROTATE_180) ? STREAM_ROTATE_0 :
862 (sensorOrientation == STREAM_ROTATE_0) ? STREAM_ROTATE_180 : sensorOrientation;
863 }
864 if (sensorOrientation == STREAM_ROTATE_0) {
865 int ret = producer_->SetTransform(GRAPHIC_ROTATE_NONE);
866 MEDIA_ERR_LOG("HStreamRepeat::ProcessCameraSetRotation %{public}d", ret);
867 }
868 }
869
ProcessVerticalCameraPosition(int32_t & sensorOrientation,camera_position_enum_t & cameraPosition)870 void HStreamRepeat::ProcessVerticalCameraPosition(int32_t& sensorOrientation, camera_position_enum_t& cameraPosition)
871 {
872 MEDIA_INFO_LOG("HStreamRepeat::ProcessVerticalCameraPosition is called");
873 int ret = SurfaceError::SURFACE_ERROR_OK;
874 #ifdef HOOK_CAMERA_OPERATOR
875 int32_t cameraPositionTemp = static_cast<int32_t>(cameraPosition);
876 if (!CameraRotatePlugin::GetInstance()->HookPreviewTransform(GetBasicInfo(), producer_,
877 sensorOrientation, cameraPositionTemp)) {
878 MEDIA_ERR_LOG("HStreamRepeat::ProcessVerticalCameraPosition HookPreviewTransform is failed");
879 }
880 cameraPosition = static_cast<camera_position_enum_t>(cameraPositionTemp);
881 #endif
882 int32_t streamRotation = sensorOrientation;
883 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
884 ret = HandleCameraTransform(streamRotation, true);
885 } else {
886 streamRotation = STREAM_ROTATE_360 - sensorOrientation;
887 ret = HandleCameraTransform(streamRotation, false);
888 }
889 CHECK_PRINT_ELOG(ret != SurfaceError::SURFACE_ERROR_OK,
890 "HStreamRepeat::ProcessVerticalCameraPosition failed %{public}d", ret);
891 }
892
ProcessCameraPosition(int32_t & streamRotation,camera_position_enum_t & cameraPosition)893 void HStreamRepeat::ProcessCameraPosition(int32_t& streamRotation, camera_position_enum_t& cameraPosition)
894 {
895 MEDIA_INFO_LOG("HStreamRepeat::ProcessCameraPosition is called");
896 int ret = SurfaceError::SURFACE_ERROR_OK;
897 #ifdef HOOK_CAMERA_OPERATOR
898 int32_t cameraPositionTemp = static_cast<int32_t>(cameraPosition);
899 if (!CameraRotatePlugin::GetInstance()->HookPreviewTransform(GetBasicInfo(), producer_,
900 streamRotation, cameraPositionTemp)) {
901 MEDIA_ERR_LOG("HStreamRepeat::ProcessCameraPosition HookPreviewTransform is failed");
902 }
903 cameraPosition = static_cast<camera_position_enum_t>(cameraPositionTemp);
904 #endif
905 if (cameraPosition == OHOS_CAMERA_POSITION_FRONT) {
906 ret = HandleCameraTransform(streamRotation, true);
907 } else {
908 ret = HandleCameraTransform(streamRotation, false);
909 }
910 CHECK_PRINT_ELOG(ret != SurfaceError::SURFACE_ERROR_OK,
911 "HStreamRepeat::ProcessCameraPosition failed %{public}d", ret);
912 }
913
HandleCameraTransform(int32_t & streamRotation,bool isFrontCamera)914 int32_t HStreamRepeat::HandleCameraTransform(int32_t& streamRotation, bool isFrontCamera)
915 {
916 int32_t ret = SurfaceError::SURFACE_ERROR_OK;
917 switch (streamRotation) {
918 case STREAM_ROTATE_0: {
919 ret = producer_->SetTransform(isFrontCamera ? GRAPHIC_FLIP_H : GRAPHIC_ROTATE_NONE);
920 break;
921 }
922 case STREAM_ROTATE_90: {
923 ret = producer_->SetTransform(isFrontCamera ? GRAPHIC_FLIP_H_ROT90 : GRAPHIC_ROTATE_90);
924 break;
925 }
926 case STREAM_ROTATE_180: {
927 ret = producer_->SetTransform(isFrontCamera ? GRAPHIC_FLIP_H_ROT180 : GRAPHIC_ROTATE_180);
928 break;
929 }
930 case STREAM_ROTATE_270: {
931 ret = producer_->SetTransform(isFrontCamera ? GRAPHIC_FLIP_H_ROT270 : GRAPHIC_ROTATE_270);
932 break;
933 }
934 default: {
935 ret = producer_->SetTransform(isFrontCamera ? GRAPHIC_FLIP_H : GRAPHIC_ROTATE_NONE);
936 break;
937 }
938 }
939 if (isFrontCamera) {
940 MEDIA_INFO_LOG("HStreamRepeat::HandleCameraTransform flip rotate %{public}d", streamRotation);
941 } else {
942 MEDIA_INFO_LOG("HStreamRepeat::HandleCameraTransform not flip rotate %{public}d", streamRotation);
943 }
944
945 return ret;
946 }
OperatePermissionCheck(uint32_t interfaceCode)947 int32_t HStreamRepeat::OperatePermissionCheck(uint32_t interfaceCode)
948 {
949 switch (static_cast<IStreamRepeatIpcCode>(interfaceCode)) {
950 case IStreamRepeatIpcCode::COMMAND_START:
951 case IStreamRepeatIpcCode::COMMAND_FORK_SKETCH_STREAM_REPEAT: {
952 auto callerToken = IPCSkeleton::GetCallingTokenID();
953 CHECK_RETURN_RET_ELOG(callerToken_ != callerToken, CAMERA_OPERATION_NOT_ALLOWED,
954 "HStreamRepeat::OperatePermissionCheck fail, callerToken_ is : %{public}d, now token "
955 "is %{public}d", callerToken_, callerToken);
956 break;
957 }
958 default:
959 break;
960 }
961 return CAMERA_OK;
962 }
963
CallbackEnter(uint32_t code)964 int32_t HStreamRepeat::CallbackEnter([[maybe_unused]] uint32_t code)
965 {
966 MEDIA_DEBUG_LOG("start, code:%{public}u", code);
967 DisableJeMalloc();
968 int32_t errCode = OperatePermissionCheck(code);
969 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode, "HStreamRepeat::OperatePermissionCheck fail");
970 switch (static_cast<IStreamRepeatIpcCode>(code)) {
971 case IStreamRepeatIpcCode::COMMAND_ADD_DEFERRED_SURFACE:
972 case IStreamRepeatIpcCode::COMMAND_FORK_SKETCH_STREAM_REPEAT:
973 case IStreamRepeatIpcCode::COMMAND_UPDATE_SKETCH_RATIO: {
974 CHECK_RETURN_RET_ELOG(!CheckSystemApp(), CAMERA_NO_PERMISSION, "HStreamRepeat::CheckSystemApp fail");
975 break;
976 }
977 default:
978 break;
979 }
980 return CAMERA_OK;
981 }
982
CallbackExit(uint32_t code,int32_t result)983 int32_t HStreamRepeat::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result)
984 {
985 MEDIA_DEBUG_LOG("leave, code:%{public}u, result:%{public}d", code, result);
986 return CAMERA_OK;
987 }
988
OpenVideoDfxSwitch(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)989 void HStreamRepeat::OpenVideoDfxSwitch(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
990 {
991 bool status = false;
992 camera_metadata_item_t item;
993 uint8_t dfxSwitch = true;
994 CHECK_RETURN_ELOG(settings == nullptr, "HStreamRepeat::OpenVideoDfxSwitch fail, setting is null!");
995 int32_t ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_VIDEO_DEBUG_SWITCH, &item);
996 if (ret == CAM_META_ITEM_NOT_FOUND) {
997 status = settings->addEntry(OHOS_CONTROL_VIDEO_DEBUG_SWITCH, &dfxSwitch, 1);
998 MEDIA_INFO_LOG("HStreamRepeat::OpenVideoDfxSwitch success!");
999 } else {
1000 status = true;
1001 }
1002 CHECK_PRINT_ELOG(!status, "HStreamRepeat::OpenVideoDfxSwitch fail!");
1003 }
1004
EnableSecure(bool isEnabled)1005 int32_t HStreamRepeat::EnableSecure(bool isEnabled)
1006 {
1007 mEnableSecure = isEnabled;
1008 return CAMERA_OK;
1009 }
1010
UpdateVideoSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings,uint8_t mirror)1011 void HStreamRepeat::UpdateVideoSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings, uint8_t mirror)
1012 {
1013 CHECK_RETURN_ELOG(settings == nullptr, "HStreamRepeat::UpdateVideoSettings settings is nullptr");
1014 MEDIA_DEBUG_LOG("HStreamRepeat::UpdateVideoSettings set Mirror %{public}d", mirror);
1015 bool status = AddOrUpdateMetadata(settings, OHOS_CONTROL_CAPTURE_MIRROR, &mirror, 1);
1016 CHECK_PRINT_ELOG(!status, "UpdateVideoSettings Failed to set mirroring in VideoSettings");
1017 }
1018
UpdateFrameRateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)1019 void HStreamRepeat::UpdateFrameRateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
1020 {
1021 CHECK_RETURN(settings == nullptr);
1022 CHECK_RETURN(streamFrameRateRange_.size() == 0);
1023 bool status = AddOrUpdateMetadata(
1024 settings, OHOS_CONTROL_FPS_RANGES, streamFrameRateRange_.data(), streamFrameRateRange_.size());
1025 CHECK_PRINT_ELOG(!status, "HStreamRepeat::SetFrameRate Failed to set frame range");
1026 }
1027
UpdateFrameMuteSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,std::shared_ptr<OHOS::Camera::CameraMetadata> & dynamicSetting)1028 void HStreamRepeat::UpdateFrameMuteSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
1029 std::shared_ptr<OHOS::Camera::CameraMetadata> &dynamicSetting)
1030 {
1031 CHECK_RETURN(settings == nullptr);
1032 camera_metadata_item_t item;
1033 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_MUTE_MODE, &item);
1034 CHECK_RETURN(ret == CAM_META_ITEM_NOT_FOUND || item.count == 0);
1035 auto mode = item.data.u8[0];
1036 int32_t count = 1;
1037 CHECK_RETURN_ELOG(dynamicSetting == nullptr, "dynamicSetting is nullptr");
1038 bool status = AddOrUpdateMetadata(dynamicSetting, OHOS_CONTROL_MUTE_MODE, &mode, count);
1039 CHECK_PRINT_ELOG(!status, "HStreamRepeat::UpdateFrameMuteSettings Failed to set frame mute");
1040 }
1041
UpdateFrameMechSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,std::shared_ptr<OHOS::Camera::CameraMetadata> & dynamicSetting)1042 void HStreamRepeat::UpdateFrameMechSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
1043 std::shared_ptr<OHOS::Camera::CameraMetadata> &dynamicSetting)
1044 {
1045 CHECK_RETURN(settings == nullptr);
1046 bool status = false;
1047 camera_metadata_item_t item;
1048 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FOCUS_TRACKING_MECH, &item);
1049 CHECK_RETURN(ret == CAM_META_ITEM_NOT_FOUND || item.count == 0);
1050
1051 auto mode = item.data.u8[0];
1052 int32_t count = 1;
1053 ret = OHOS::Camera::FindCameraMetadataItem(dynamicSetting->get(), OHOS_CONTROL_FOCUS_TRACKING_MECH, &item);
1054 if (ret == CAM_META_SUCCESS) {
1055 status = dynamicSetting->updateEntry(OHOS_CONTROL_FOCUS_TRACKING_MECH, &mode, count);
1056 } else {
1057 status = dynamicSetting->addEntry(OHOS_CONTROL_FOCUS_TRACKING_MECH, &mode, count);
1058 }
1059 CHECK_PRINT_ELOG(!status, "HStreamRepeat::UpdateFrameMechSettings Failed to set frame mech");
1060 }
1061
1062 #ifdef NOTIFICATION_ENABLE
UpdateBeautySettings(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)1063 void HStreamRepeat::UpdateBeautySettings(std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
1064 {
1065 CHECK_RETURN_ELOG(settings == nullptr, "HStreamRepeat::UpdateBeautySettings settings is nullptr");
1066 MEDIA_INFO_LOG("HStreamRepeat::UpdateBeautySettings enter");
1067 bool status = false;
1068 int32_t count = 1;
1069 uint8_t beautyType = OHOS_CAMERA_BEAUTY_TYPE_AUTO;
1070 uint8_t beautyLevel = BEAUTY_LEVEL;
1071
1072 status = AddOrUpdateMetadata(settings, OHOS_CONTROL_BEAUTY_TYPE, &beautyType, count);
1073 CHECK_PRINT_ELOG(!status, "HStreamRepeat::SetFrameRate Failed to set beauty type");
1074
1075 status = AddOrUpdateMetadata(settings, OHOS_CONTROL_BEAUTY_AUTO_VALUE, &beautyLevel, count);
1076 CHECK_PRINT_ELOG(!status, "HStreamRepeat::SetFrameRate Failed to set beauty level");
1077 }
1078
CancelNotification()1079 void HStreamRepeat::CancelNotification()
1080 {
1081 CameraBeautyNotification::GetInstance()->CancelNotification();
1082 }
1083
1084 // LCOV_EXCL_START
IsNeedBeautyNotification()1085 bool HStreamRepeat::IsNeedBeautyNotification()
1086 {
1087 bool ret = false;
1088 int uid = IPCSkeleton::GetCallingUid();
1089 std::string bundleName = GetClientBundle(uid);
1090
1091 if (streamFrameRateRange_.size() == 0) {
1092 return ret;
1093 }
1094 std::string notificationInfo = system::GetParameter("const.camera.notification_info", "");
1095 if (notificationInfo.empty()) {
1096 return ret;
1097 }
1098 const int32_t CONFIG_SIZE = 3;
1099 const int32_t INT32_ZERO = 0;
1100 const int32_t INT32_ONE = 1;
1101 const int32_t INT32_TWO = 2;
1102 std::vector<std::string> configInfos = SplitString(notificationInfo, '#');
1103 for (uint32_t i = 0; i < configInfos.size(); ++i) {
1104 std::vector<std::string> configInfo = SplitString(configInfos[i], '|');
1105 if (configInfo.size() < CONFIG_SIZE) {
1106 continue;
1107 }
1108 if (!isIntegerRegex(configInfo[INT32_ONE]) || !isIntegerRegex(configInfo[INT32_TWO])) {
1109 continue;
1110 }
1111 std::string configBundleName = configInfo[INT32_ZERO];
1112 int32_t configMinFPS = std::atoi(configInfo[INT32_ONE].c_str());
1113 int32_t configMAXFPS = std::atoi(configInfo[INT32_TWO].c_str());
1114 if (configBundleName == bundleName && configMinFPS == streamFrameRateRange_[INT32_ZERO] &&
1115 configMAXFPS == streamFrameRateRange_[INT32_ONE]) {
1116 ret = true;
1117 break;
1118 }
1119 }
1120 return ret;
1121 }
1122 // LCOV_EXCL_STOP
1123 #endif
1124
AttachMetaSurface(const sptr<OHOS::IBufferProducer> & producer,int32_t videoMetaType)1125 int32_t HStreamRepeat::AttachMetaSurface(const sptr<OHOS::IBufferProducer>& producer, int32_t videoMetaType)
1126 {
1127 MEDIA_INFO_LOG("HStreamRepeat::AttachMetaSurface called");
1128 CHECK_RETURN_RET_ELOG(
1129 !CheckSystemApp(), CAMERA_NO_PERMISSION, "HStreamRepeat::AttachMetaSurface:SystemApi is called");
1130 {
1131 CHECK_RETURN_RET_ELOG(producer == nullptr, CAMERA_INVALID_ARG,
1132 "HStreamRepeat::AttachMetaSurface producer is null");
1133 metaSurfaceBufferQueue_ = new BufferProducerSequenceable(producer);
1134 }
1135 return CAMERA_OK;
1136 }
1137
GetFrameRateRange()1138 std::vector<int32_t> HStreamRepeat::GetFrameRateRange()
1139 {
1140 return streamFrameRateRange_;
1141 }
1142
UpdateHalRoateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)1143 void HStreamRepeat::UpdateHalRoateSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
1144 {
1145 #ifdef HOOK_CAMERA_OPERATOR
1146 int32_t rotateAngle = -1;
1147 if (CameraRotatePlugin::GetInstance()->
1148 HookPreviewStreamStart(GetBasicInfo(), GetStreamProducer(), rotateAngle) && rotateAngle >= 0) {
1149 CHECK_PRINT_ELOG(settings == nullptr, "HStreamRepeat::UpdateHalRoateSettings settings is nullptr");
1150 bool status = false;
1151 camera_metadata_item_t item;
1152
1153 MEDIA_DEBUG_LOG("HStreamRepeat::UpdateHalRoateSettings rotateAngle is %{public}d", rotateAngle);
1154 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_ROTATE_ANGLE, &item);
1155 if (ret == CAM_META_ITEM_NOT_FOUND) {
1156 status = settings->addEntry(OHOS_CONTROL_ROTATE_ANGLE, &rotateAngle, 1);
1157 } else if (ret == CAM_META_SUCCESS) {
1158 status = settings->updateEntry(OHOS_CONTROL_ROTATE_ANGLE, &rotateAngle, 1);
1159 }
1160 CHECK_PRINT_ELOG(!status, "UpdateHalRoateSettings Failed");
1161 if (static_cast<uint32_t>(rotateAngle) & 0x1FFF) { // Bit0~12 for angle and mirror
1162 enableCameraRotation_ = true;
1163 }
1164 }
1165 #endif
1166 }
1167 } // namespace CameraStandard
1168 } // namespace OHOS
1169