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 "session/profession_session.h"
17 #include "camera_log.h"
18 #include "camera_metadata_operator.h"
19 #include "camera_util.h"
20 #include "hcapture_session_callback_stub.h"
21 #include "metadata_common_utils.h"
22 #include "input/camera_input.h"
23 #include "output/photo_output.h"
24 #include "output/preview_output.h"
25 #include "output/video_output.h"
26 #include <algorithm>
27 #include <cstdint>
28
29 namespace OHOS {
30 namespace CameraStandard {
~ProfessionSession()31 ProfessionSession::~ProfessionSession()
32 {
33 exposureInfoCallback_ = nullptr;
34 isoInfoCallback_ = nullptr;
35 apertureInfoCallback_ = nullptr;
36 luminationInfoCallback_ = nullptr;
37 }
38 // metering mode
39 const std::unordered_map<camera_meter_mode_t, MeteringMode> ProfessionSession::metaMeteringModeMap_ = {
40 {OHOS_CAMERA_SPOT_METERING, METERING_MODE_SPOT},
41 {OHOS_CAMERA_REGION_METERING, METERING_MODE_REGION},
42 {OHOS_CAMERA_OVERALL_METERING, METERING_MODE_OVERALL},
43 {OHOS_CAMERA_CENTER_WEIGHTED_METERING, METERING_MODE_CENTER_WEIGHTED}
44 };
45
46 const std::unordered_map<MeteringMode, camera_meter_mode_t> ProfessionSession::fwkMeteringModeMap_ = {
47 {METERING_MODE_SPOT, OHOS_CAMERA_SPOT_METERING},
48 {METERING_MODE_REGION, OHOS_CAMERA_REGION_METERING},
49 {METERING_MODE_OVERALL, OHOS_CAMERA_OVERALL_METERING},
50 {METERING_MODE_CENTER_WEIGHTED, OHOS_CAMERA_CENTER_WEIGHTED_METERING}
51 };
52
53 // FocusAssistFlash mode
54 const std::unordered_map<camera_focus_assist_flash_mode_enum_t, FocusAssistFlashMode>
55 ProfessionSession::metaFocusAssistFlashModeMap_ = {
56 { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT, FOCUS_ASSIST_FLASH_MODE_DEFAULT },
57 { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO, FOCUS_ASSIST_FLASH_MODE_AUTO },
58 { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON, FOCUS_ASSIST_FLASH_MODE_ON },
59 { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF, FOCUS_ASSIST_FLASH_MODE_OFF },
60 };
61 const std::unordered_map<FocusAssistFlashMode, camera_focus_assist_flash_mode_enum_t>
62 ProfessionSession::fwkFocusAssistFlashModeMap_ = {
63 { FOCUS_ASSIST_FLASH_MODE_DEFAULT, OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT },
64 { FOCUS_ASSIST_FLASH_MODE_AUTO, OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO },
65 { FOCUS_ASSIST_FLASH_MODE_ON, OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON },
66 { FOCUS_ASSIST_FLASH_MODE_OFF, OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF },
67 };
68 // ExposureHintMode
69 const std::unordered_map<camera_exposure_hint_mode_enum_t, ExposureHintMode>
70 ProfessionSession::metaExposureHintModeMap_ = {
71 { OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED, EXPOSURE_HINT_UNSUPPORTED },
72 { OHOS_CAMERA_EXPOSURE_HINT_MODE_ON, EXPOSURE_HINT_MODE_ON },
73 { OHOS_CAMERA_EXPOSURE_HINT_MODE_OFF, EXPOSURE_HINT_MODE_OFF },
74 };
75 const std::unordered_map<ExposureHintMode, camera_exposure_hint_mode_enum_t>
76 ProfessionSession::fwkExposureHintModeMap_ = {
77 { EXPOSURE_HINT_UNSUPPORTED, OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED },
78 { EXPOSURE_HINT_MODE_ON, OHOS_CAMERA_EXPOSURE_HINT_MODE_ON },
79 { EXPOSURE_HINT_MODE_OFF, OHOS_CAMERA_EXPOSURE_HINT_MODE_OFF },
80 };
81 // metering mode
GetSupportedMeteringModes(std::vector<MeteringMode> & supportedMeteringModes)82 int32_t ProfessionSession::GetSupportedMeteringModes(std::vector<MeteringMode> &supportedMeteringModes)
83 {
84 supportedMeteringModes.clear();
85 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
86 "ProfessionSession::GetSupportedMeteringModes Session is not Commited");
87 auto inputDevice = GetInputDevice();
88 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
89 "ProfessionSession::GetSupportedMeteringModes camera device is null");
90 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
91 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, PortraitEffect::OFF_EFFECT,
92 "ProfessionSession::GetSupportedMeteringModes camera deviceInfo is null");
93 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
94 camera_metadata_item_t item;
95 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_METER_MODES, &item);
96 if (ret != CAM_META_SUCCESS) {
97 MEDIA_ERR_LOG("ProfessionSession::GetSupportedMeteringModes Failed with return code %{public}d", ret);
98 return CameraErrorCode::SUCCESS;
99 }
100 for (uint32_t i = 0; i < item.count; i++) {
101 auto itr = metaMeteringModeMap_.find(static_cast<camera_meter_mode_t>(item.data.u8[i]));
102 if (itr != metaMeteringModeMap_.end()) {
103 supportedMeteringModes.emplace_back(itr->second);
104 }
105 }
106 return CameraErrorCode::SUCCESS;
107 }
108
IsMeteringModeSupported(MeteringMode meteringMode,bool & isSupported)109 int32_t ProfessionSession::IsMeteringModeSupported(MeteringMode meteringMode, bool &isSupported)
110 {
111 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
112 "ProfessionSession::IsMeteringModeSupported Session is not Commited");
113 std::vector<MeteringMode> vecSupportedMeteringModeList;
114 (void)this->GetSupportedMeteringModes(vecSupportedMeteringModeList);
115 if (find(vecSupportedMeteringModeList.begin(), vecSupportedMeteringModeList.end(),
116 meteringMode) != vecSupportedMeteringModeList.end()) {
117 isSupported = true;
118 return CameraErrorCode::SUCCESS;
119 }
120 isSupported = false;
121 return CameraErrorCode::SUCCESS;
122 }
123
SetMeteringMode(MeteringMode mode)124 int32_t ProfessionSession::SetMeteringMode(MeteringMode mode)
125 {
126 CAMERA_SYNC_TRACE;
127 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
128 "ProfessionSession::SetMeteringMode Session is not Commited");
129 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
130 "ProfessionSession::SetMeteringMode Need to call LockForControl() before setting camera properties");
131 camera_meter_mode_t meteringMode = OHOS_CAMERA_SPOT_METERING;
132 auto itr = fwkMeteringModeMap_.find(mode);
133 if (itr == fwkMeteringModeMap_.end()) {
134 MEDIA_ERR_LOG("ProfessionSession::SetMeteringMode Unknown exposure mode");
135 } else {
136 meteringMode = itr->second;
137 }
138 bool status = false;
139 int32_t ret;
140 uint32_t count = 1;
141 camera_metadata_item_t item;
142
143 MEDIA_DEBUG_LOG("ProfessionSession::SetMeteringMode metering mode: %{public}d", meteringMode);
144
145 ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_METER_MODE, &item);
146 if (ret == CAM_META_ITEM_NOT_FOUND) {
147 status = changedMetadata_->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, count);
148 } else if (ret == CAM_META_SUCCESS) {
149 status = changedMetadata_->updateEntry(OHOS_CONTROL_METER_MODE, &meteringMode, count);
150 }
151 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetMeteringMode Failed to set focus mode");
152 return CameraErrorCode::SUCCESS;
153 }
154
GetMeteringMode(MeteringMode & meteringMode)155 int32_t ProfessionSession::GetMeteringMode(MeteringMode &meteringMode)
156 {
157 meteringMode = METERING_MODE_SPOT;
158 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
159 "ProfessionSession::GetMeteringMode Session is not Commited");
160 auto inputDevice = GetInputDevice();
161 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
162 "ProfessionSession::GetMeteringMode camera device is null");
163 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
164 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
165 "ProfessionSession::GetMeteringMode camera deviceInfo is null");
166 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
167 camera_metadata_item_t item;
168 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_METER_MODE, &item);
169 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
170 "ProfessionSession::GetMeteringMode Failed with return code %{public}d", ret);
171 auto itr = metaMeteringModeMap_.find(static_cast<camera_meter_mode_t>(item.data.u8[0]));
172 if (itr != metaMeteringModeMap_.end()) {
173 meteringMode = itr->second;
174 return CameraErrorCode::SUCCESS;
175 }
176 return CameraErrorCode::SUCCESS;
177 }
178 // ISO
GetIsoRange(std::vector<int32_t> & isoRange)179 int32_t ProfessionSession::GetIsoRange(std::vector<int32_t> &isoRange)
180 {
181 isoRange.clear();
182 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
183 "ProfessionSession::GetIsoRange Session is not Commited");
184 auto inputDevice = GetInputDevice();
185 CHECK_ERROR_RETURN_RET_LOG(!inputDevice || !inputDevice->GetCameraDeviceInfo(),
186 CameraErrorCode::SUCCESS, "ProfessionSession::GetIsoRange camera device is null");
187
188 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = GetMetadata();
189 CHECK_ERROR_RETURN_RET_LOG(metadata == nullptr, CameraErrorCode::INVALID_ARGUMENT, "GetIsoRange metadata is null");
190
191 camera_metadata_item_t item;
192 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_ISO_VALUES, &item);
193 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, CameraErrorCode::INVALID_ARGUMENT,
194 "ProfessionSession::GetIsoRange Failed with return code %{public}d", ret);
195 std::vector<std::vector<int32_t> > modeIsoRanges = {};
196 std::vector<int32_t> modeRange = {};
197 for (uint32_t i = 0; i < item.count; i++) {
198 if (item.data.i32[i] != -1) {
199 modeRange.emplace_back(item.data.i32[i]);
200 continue;
201 }
202 MEDIA_DEBUG_LOG("ProfessionSession::GetIsoRange mode %{public}d, range=%{public}s",
203 GetMode(), Container2String(modeRange.begin(), modeRange.end()).c_str());
204 modeIsoRanges.emplace_back(std::move(modeRange));
205 modeRange.clear();
206 }
207
208 for (auto it : modeIsoRanges) {
209 MEDIA_DEBUG_LOG("ProfessionSession::GetIsoRange ranges=%{public}s",
210 Container2String(it.begin(), it.end()).c_str());
211 if (GetMode() == it.at(0)) {
212 isoRange.resize(it.size() - 1);
213 std::copy(it.begin() + 1, it.end(), isoRange.begin());
214 }
215 }
216 MEDIA_INFO_LOG("ProfessionSessionNapi::GetIsoRange isoRange=%{public}s, len = %{public}zu",
217 Container2String(isoRange.begin(), isoRange.end()).c_str(), isoRange.size());
218 return CameraErrorCode::SUCCESS;
219 }
220
SetISO(int32_t iso)221 int32_t ProfessionSession::SetISO(int32_t iso)
222 {
223 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
224 "ProfessionSession::SetISO Session is not Commited");
225 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
226 "ProfessionSession::SetISO Need to call LockForControl() before setting camera properties");
227
228 bool status = false;
229 int32_t count = 1;
230 camera_metadata_item_t item;
231 MEDIA_DEBUG_LOG("ProfessionSession::SetISO iso value: %{public}d", iso);
232 auto inputDevice = GetInputDevice();
233 CHECK_ERROR_RETURN_RET_LOG(!inputDevice || !inputDevice->GetCameraDeviceInfo(),
234 CameraErrorCode::SUCCESS, "ProfessionSession::SetISO camera device is null");
235
236 std::vector<int32_t> isoRange;
237 CHECK_ERROR_RETURN_RET_LOG((GetIsoRange(isoRange) != CameraErrorCode::SUCCESS) && isoRange.empty(),
238 CameraErrorCode::OPERATION_NOT_ALLOWED, "ProfessionSession::SetISO range is empty");
239
240 const int32_t autoIsoValue = 0;
241 if (iso != autoIsoValue && std::find(isoRange.begin(), isoRange.end(), iso) == isoRange.end()) {
242 return CameraErrorCode::INVALID_ARGUMENT;
243 }
244 int ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_ISO_VALUE, &item);
245 if (ret == CAM_META_ITEM_NOT_FOUND) {
246 status = changedMetadata_->addEntry(OHOS_CONTROL_ISO_VALUE, &iso, count);
247 } else if (ret == CAM_META_SUCCESS) {
248 status = changedMetadata_->updateEntry(OHOS_CONTROL_ISO_VALUE, &iso, count);
249 }
250 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetISO Failed to set exposure compensation");
251 isoValue_ = static_cast<uint32_t>(iso);
252 return CameraErrorCode::SUCCESS;
253 }
254
GetISO(int32_t & iso)255 int32_t ProfessionSession::GetISO(int32_t &iso)
256 {
257 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
258 "ProfessionSession::GetISO Session is not Commited");
259 auto inputDevice = GetInputDevice();
260 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::INVALID_ARGUMENT,
261 "ProfessionSession::GetISO camera device is null");
262 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
263 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
264 "ProfessionSession::GetISO camera deviceInfo is null");
265 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
266 camera_metadata_item_t item;
267 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_ISO_VALUE, &item);
268 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::INVALID_ARGUMENT,
269 "ProfessionSession::GetISO Failed with return code %{public}d", ret);
270 iso = item.data.i32[0];
271 MEDIA_DEBUG_LOG("iso: %{public}d", iso);
272 return CameraErrorCode::SUCCESS;
273 }
274
IsManualIsoSupported()275 bool ProfessionSession::IsManualIsoSupported()
276 {
277 CAMERA_SYNC_TRACE;
278 MEDIA_DEBUG_LOG("Enter IsManualIsoSupported");
279
280 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), false,
281 "ProfessionSession::IsManualIsoSupported Session is not Commited");
282
283 auto inputDevice = GetInputDevice();
284 CHECK_ERROR_RETURN_RET_LOG(inputDevice == nullptr, false,
285 "ProfessionSession::IsManualIsoSupported camera device is null");
286
287 auto deviceInfo = inputDevice->GetCameraDeviceInfo();
288 CHECK_ERROR_RETURN_RET_LOG(deviceInfo == nullptr, false,
289 "ProfessionSession::IsManualIsoSupported camera deviceInfo is null");
290 std::shared_ptr<Camera::CameraMetadata> metadata = deviceInfo->GetMetadata();
291 camera_metadata_item_t item;
292 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_ISO_VALUES, &item);
293 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, false,
294 "ProfessionSession::IsMacroSupported Failed with return code %{public}d", ret);
295 return true;
296 }
297
298 // focus mode
GetSupportedFocusModes(std::vector<FocusMode> & supportedFocusModes)299 int32_t ProfessionSession::GetSupportedFocusModes(std::vector<FocusMode> &supportedFocusModes)
300 {
301 supportedFocusModes.clear();
302 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
303 "ProfessionSession::GetSupportedFocusModes Session is not Commited");
304
305 auto inputDevice = GetInputDevice();
306 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
307 "ProfessionSession::GetSupportedFocusModes camera device is null");
308 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
309 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
310 "ProfessionSession::GetSupportedFocusModes camera deviceInfo is null");
311 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
312 camera_metadata_item_t item;
313 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FOCUS_MODES, &item);
314 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
315 "ProfessionSession::GetSupportedFocusModes Failed with return code %{public}d", ret);
316 for (uint32_t i = 0; i < item.count; i++) {
317 auto itr = g_metaFocusModeMap_.find(static_cast<camera_focus_mode_enum_t>(item.data.u8[i]));
318 if (itr != g_metaFocusModeMap_.end()) {
319 supportedFocusModes.emplace_back(itr->second);
320 }
321 }
322 return CameraErrorCode::SUCCESS;
323 }
324
IsFocusModeSupported(FocusMode focusMode,bool & isSupported)325 int32_t ProfessionSession::IsFocusModeSupported(FocusMode focusMode, bool &isSupported)
326 {
327 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
328 "ProfessionSession::IsFocusModeSupported Session is not Commited");
329 std::vector<FocusMode> vecSupportedMeteringModeList;
330 (void)(this->GetSupportedFocusModes(vecSupportedMeteringModeList));
331 if (find(vecSupportedMeteringModeList.begin(), vecSupportedMeteringModeList.end(),
332 focusMode) != vecSupportedMeteringModeList.end()) {
333 isSupported = true;
334 return CameraErrorCode::SUCCESS;
335 }
336 isSupported = false;
337 return CameraErrorCode::SUCCESS;
338 }
339
SetFocusMode(FocusMode focusMode)340 int32_t ProfessionSession::SetFocusMode(FocusMode focusMode)
341 {
342 CAMERA_SYNC_TRACE;
343 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
344 "ProfessionSession::SetFocusMode Session is not Commited");
345 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
346 "ProfessionSession::SetFocusMode Need to call LockForControl() before setting camera properties");
347 uint8_t focus = FOCUS_MODE_LOCKED;
348 auto itr = g_fwkFocusModeMap_.find(focusMode);
349 if (itr == g_fwkFocusModeMap_.end()) {
350 MEDIA_ERR_LOG("ProfessionSession::SetFocusMode Unknown exposure mode");
351 } else {
352 focus = itr->second;
353 }
354 bool status = false;
355 int32_t ret;
356 uint32_t count = 1;
357 camera_metadata_item_t item;
358
359 MEDIA_DEBUG_LOG("ProfessionSession::SetFocusMode Focus mode: %{public}d", focusMode);
360
361 ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_FOCUS_MODE, &item);
362 if (ret == CAM_META_ITEM_NOT_FOUND) {
363 status = changedMetadata_->addEntry(OHOS_CONTROL_FOCUS_MODE, &focus, count);
364 } else if (ret == CAM_META_SUCCESS) {
365 status = changedMetadata_->updateEntry(OHOS_CONTROL_FOCUS_MODE, &focus, count);
366 }
367 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFocusMode Failed to set focus mode");
368 return CameraErrorCode::SUCCESS;
369 }
370
GetFocusMode(FocusMode & focusMode)371 int32_t ProfessionSession::GetFocusMode(FocusMode &focusMode)
372 {
373 focusMode = FOCUS_MODE_MANUAL;
374 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
375 "ProfessionSession::GetFocusMode Session is not Commited");
376 auto inputDevice = GetInputDevice();
377 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
378 "ProfessionSession::GetFocusMode camera device is null");
379 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
380 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
381 "ProfessionSession::GetFocusMode camera deviceInfo is null");
382 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
383 camera_metadata_item_t item;
384 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FOCUS_MODE, &item);
385 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
386 "ProfessionSession::GetFocusMode Failed with return code %{public}d", ret);
387 auto itr = g_metaFocusModeMap_.find(static_cast<camera_focus_mode_enum_t>(item.data.u8[0]));
388 if (itr != g_metaFocusModeMap_.end()) {
389 focusMode = itr->second;
390 return CameraErrorCode::SUCCESS;
391 }
392 return CameraErrorCode::SUCCESS;
393 }
394
395 // Exposure Hint
GetSupportedExposureHintModes(std::vector<ExposureHintMode> & supportedExposureHintModes)396 int32_t ProfessionSession::GetSupportedExposureHintModes(std::vector<ExposureHintMode> &supportedExposureHintModes)
397 {
398 supportedExposureHintModes.clear();
399 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
400 "ProfessionSession::GetSupportedExposureHintModes Session is not Commited");
401 auto inputDevice = GetInputDevice();
402 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
403 "ProfessionSession::GetSupportedExposureHintModes camera device is null");
404 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
405 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
406 "ProfessionSession::GetSupportedExposureHintModes camera deviceInfo is null");
407 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
408 camera_metadata_item_t item;
409 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_EXPOSURE_HINT_SUPPORTED, &item);
410 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
411 "ProfessionSession::GetSupportedExposureHintModes Failed with return code %{public}d", ret);
412 for (uint32_t i = 0; i < item.count; i++) {
413 auto itr = metaExposureHintModeMap_.find(static_cast<camera_exposure_hint_mode_enum_t>(item.data.u8[i]));
414 if (itr != metaExposureHintModeMap_.end()) {
415 supportedExposureHintModes.emplace_back(itr->second);
416 }
417 }
418 return CameraErrorCode::SUCCESS;
419 }
420
SetExposureHintMode(ExposureHintMode mode)421 int32_t ProfessionSession::SetExposureHintMode(ExposureHintMode mode)
422 {
423 CAMERA_SYNC_TRACE;
424 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
425 "ProfessionSession::SetExposureHintMode Session is not Commited");
426 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
427 "ProfessionSession::SetExposureHintMode Need to call LockForControl() before setting camera properties");
428 uint8_t exposureHintMode = OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED;
429 auto itr = fwkExposureHintModeMap_.find(mode);
430 if (itr == fwkExposureHintModeMap_.end()) {
431 MEDIA_ERR_LOG("ProfessionSession::SetExposureHintMode Unknown mode");
432 } else {
433 exposureHintMode = itr->second;
434 }
435 bool status = false;
436 int32_t ret;
437 uint32_t count = 1;
438 camera_metadata_item_t item;
439 MEDIA_DEBUG_LOG("ProfessionSession::SetExposureHintMode ExposureHint mode: %{public}d", exposureHintMode);
440
441 ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_EXPOSURE_HINT_MODE, &item);
442 if (ret == CAM_META_ITEM_NOT_FOUND) {
443 status = changedMetadata_->addEntry(OHOS_CONTROL_EXPOSURE_HINT_MODE, &exposureHintMode, count);
444 } else if (ret == CAM_META_SUCCESS) {
445 status = changedMetadata_->updateEntry(OHOS_CONTROL_EXPOSURE_HINT_MODE, &exposureHintMode, count);
446 }
447 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetExposureHintMode Failed to set ExposureHint mode");
448 return CameraErrorCode::SUCCESS;
449 }
450
GetExposureHintMode(ExposureHintMode & mode)451 int32_t ProfessionSession::GetExposureHintMode(ExposureHintMode &mode)
452 {
453 mode = EXPOSURE_HINT_UNSUPPORTED;
454 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
455 "ProfessionSession::GetExposureHintMode Session is not Commited");
456 auto inputDevice = GetInputDevice();
457 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
458 "ProfessionSession::GetExposureHintMode camera device is null");
459 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
460 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
461 "ProfessionSession::GetExposureHintMode camera deviceInfo is null");
462 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
463 camera_metadata_item_t item;
464 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_EXPOSURE_HINT_MODE, &item);
465 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
466 "ProfessionSession::GetExposureHintMode Failed with return code %{public}d", ret);
467 auto itr = metaExposureHintModeMap_.find(static_cast<camera_exposure_hint_mode_enum_t>(item.data.u8[0]));
468 if (itr != metaExposureHintModeMap_.end()) {
469 mode = itr->second;
470 return CameraErrorCode::SUCCESS;
471 }
472 return CameraErrorCode::SUCCESS;
473 }
474 // Focus Flash Assist
GetSupportedFocusAssistFlashModes(std::vector<FocusAssistFlashMode> & supportedFocusAssistFlashModes)475 int32_t ProfessionSession::GetSupportedFocusAssistFlashModes(
476 std::vector<FocusAssistFlashMode> &supportedFocusAssistFlashModes)
477 {
478 supportedFocusAssistFlashModes.clear();
479 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
480 "ProfessionSession::GetSupportedFocusAssistFlashModes Session is not Commited");
481 auto inputDevice = GetInputDevice();
482 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
483 "ProfessionSession::GetSupportedFocusAssistFlashModes camera device is null");
484 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
485 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
486 "ProfessionSession::GetSupportedFocusAssistFlashModes camera deviceInfo is null");
487 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
488 camera_metadata_item_t item;
489 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FOCUS_ASSIST_FLASH_SUPPORTED_MODES, &item);
490 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
491 "ProfessionSession::GetSupportedFocusAssistFlashModes Failed with return code %{public}d", ret);
492 for (uint32_t i = 0; i < item.count; i++) {
493 auto itr = metaFocusAssistFlashModeMap_.find(
494 static_cast<camera_focus_assist_flash_mode_enum_t>(item.data.u8[i]));
495 if (itr != metaFocusAssistFlashModeMap_.end()) {
496 supportedFocusAssistFlashModes.emplace_back(itr->second);
497 }
498 }
499 return CameraErrorCode::SUCCESS;
500 }
501
IsFocusAssistFlashModeSupported(FocusAssistFlashMode mode,bool & isSupported)502 int32_t ProfessionSession::IsFocusAssistFlashModeSupported(FocusAssistFlashMode mode, bool &isSupported)
503 {
504 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
505 "ProfessionSession::IsFocusAssistFlashModeSupported Session is not Commited");
506 std::vector<FocusAssistFlashMode> vecSupportedFocusAssistFlashModeList;
507 (void)this->GetSupportedFocusAssistFlashModes(vecSupportedFocusAssistFlashModeList);
508 if (find(vecSupportedFocusAssistFlashModeList.begin(), vecSupportedFocusAssistFlashModeList.end(),
509 mode) != vecSupportedFocusAssistFlashModeList.end()) {
510 isSupported = true;
511 return CameraErrorCode::SUCCESS;
512 }
513 isSupported = false;
514 return CameraErrorCode::SUCCESS;
515 }
516
SetFocusAssistFlashMode(FocusAssistFlashMode mode)517 int32_t ProfessionSession::SetFocusAssistFlashMode(FocusAssistFlashMode mode)
518 {
519 CAMERA_SYNC_TRACE;
520 MEDIA_DEBUG_LOG("ProfessionSession::SetFocusAssistFlashMode app mode: %{public}d", static_cast<int32_t>(mode));
521 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
522 "ProfessionSession::IsFocusAssistFlashModeSupported Session is not Commited");
523 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
524 "ProfessionSession::IsFocusAssistFlashModeSupported Need to call LockForControl "
525 "before setting camera properties");
526 uint8_t value = OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT;
527 auto itr = fwkFocusAssistFlashModeMap_.find(mode);
528 if (itr == fwkFocusAssistFlashModeMap_.end()) {
529 MEDIA_ERR_LOG("ProfessionSession::SetFocusAssistFlashMode Unknown exposure mode");
530 } else {
531 value = itr->second;
532 }
533 bool status = false;
534 int32_t ret;
535 uint32_t count = 1;
536 camera_metadata_item_t item;
537 MEDIA_DEBUG_LOG("ProfessionSession::SetFocusAssistFlashMode FocusAssistFlash mode: %{public}d", value);
538 ret = Camera::FindCameraMetadataItem(
539 changedMetadata_->get(), OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &item);
540 if (ret == CAM_META_ITEM_NOT_FOUND) {
541 status = changedMetadata_->addEntry(OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &value, count);
542 } else if (ret == CAM_META_SUCCESS) {
543 status = changedMetadata_->updateEntry(OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &value, count);
544 }
545 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFocusAssistFlashMode Failed to set FocusAssistFlash mode");
546 return CameraErrorCode::SUCCESS;
547 }
548
GetFocusAssistFlashMode(FocusAssistFlashMode & mode)549 int32_t ProfessionSession::GetFocusAssistFlashMode(FocusAssistFlashMode &mode)
550 {
551 mode = FOCUS_ASSIST_FLASH_MODE_DEFAULT;
552 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
553 "ProfessionSession::GetFocusAssistFlashMode Session is not Commited");
554 auto inputDevice = GetInputDevice();
555 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
556 "ProfessionSession::GetFocusAssistFlashMode camera device is null");
557 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
558 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
559 "ProfessionSession::GetFocusAssistFlashMode camera deviceInfo is null");
560 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
561 camera_metadata_item_t item;
562 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &item);
563 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
564 "ProfessionSession::GetFocusAssistFlashMode Failed with return code %{public}d", ret);
565 auto itr = metaFocusAssistFlashModeMap_.find(static_cast<camera_focus_assist_flash_mode_enum_t>(item.data.u8[0]));
566 if (itr != metaFocusAssistFlashModeMap_.end()) {
567 mode = itr->second;
568 return CameraErrorCode::SUCCESS;
569 }
570 return CameraErrorCode::SUCCESS;
571 }
572
573 // flash mode
GetSupportedFlashModes(std::vector<FlashMode> & supportedFlashModes)574 int32_t ProfessionSession::GetSupportedFlashModes(std::vector<FlashMode> &supportedFlashModes)
575 {
576 supportedFlashModes.clear();
577 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
578 "ProfessionSession::GetSupportedFlashModes Session is not Commited");
579 auto inputDevice = GetInputDevice();
580 CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
581 CameraErrorCode::SUCCESS, "ProfessionSession::GetSupportedFlashModes camera device is null");
582 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
583 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
584 "ProfessionSession::GetSupportedFlashModes camera deviceInfo is null");
585 auto metadata = isRawImageDelivery_ ? GetMetadata() : inputDeviceInfo->GetMetadata();
586 camera_metadata_item_t item;
587 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FLASH_MODES, &item);
588 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
589 "ProfessionSession::GetSupportedFlashModes Failed with return code %{public}d", ret);
590 g_transformValidData(item, g_metaFlashModeMap_, supportedFlashModes);
591 return CameraErrorCode::SUCCESS;
592 }
593
GetFlashMode(FlashMode & flashMode)594 int32_t ProfessionSession::GetFlashMode(FlashMode &flashMode)
595 {
596 flashMode = FLASH_MODE_CLOSE;
597 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
598 "ProfessionSession::GetFlashMode Session is not Commited");
599 auto inputDevice = GetInputDevice();
600 CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
601 CameraErrorCode::SUCCESS, "ProfessionSession::GetFlashMode camera device is null");
602 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
603 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
604 "ProfessionSession::GetFlashMode camera deviceInfo is null");
605 auto metadata = isRawImageDelivery_ ? GetMetadata() : inputDeviceInfo->GetMetadata();
606 camera_metadata_item_t item;
607 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FLASH_MODE, &item);
608 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
609 "ProfessionSession::GetFlashMode Failed with return code %{public}d", ret);
610 auto itr = g_metaFlashModeMap_.find(static_cast<camera_flash_mode_enum_t>(item.data.u8[0]));
611 if (itr != g_metaFlashModeMap_.end()) {
612 flashMode = itr->second;
613 return CameraErrorCode::SUCCESS;
614 }
615
616 return CameraErrorCode::SUCCESS;
617 }
618
SetFlashMode(FlashMode flashMode)619 int32_t ProfessionSession::SetFlashMode(FlashMode flashMode)
620 {
621 CAMERA_SYNC_TRACE;
622 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
623 "ProfessionSession::SetFlashMode Session is not Commited");
624 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
625 "ProfessionSession::SetFlashMode Need to call LockForControl() before setting camera properties");
626 MEDIA_INFO_LOG("ProfessionSession::SetFlashMode flashMode:%{public}d", flashMode);
627 uint8_t flash = g_fwkFlashModeMap_.at(FLASH_MODE_CLOSE);
628 auto itr = g_fwkFlashModeMap_.find(flashMode);
629 if (itr == g_fwkFlashModeMap_.end()) {
630 MEDIA_ERR_LOG("ProfessionSession::SetFlashMode Unknown exposure mode");
631 } else {
632 flash = itr->second;
633 }
634 bool status = AddOrUpdateMetadata(changedMetadata_, OHOS_CONTROL_FLASH_MODE, &flash, 1);
635 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFlashMode Failed to set flash mode");
636 return CameraErrorCode::SUCCESS;
637 }
638
IsFlashModeSupported(FlashMode flashMode,bool & isSupported)639 int32_t ProfessionSession::IsFlashModeSupported(FlashMode flashMode, bool &isSupported)
640 {
641 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
642 "ProfessionSession::IsFlashModeSupported Session is not Commited");
643 std::vector<FlashMode> vecSupportedFlashModeList;
644 (void)this->GetSupportedFlashModes(vecSupportedFlashModeList);
645 if (find(vecSupportedFlashModeList.begin(), vecSupportedFlashModeList.end(), flashMode) !=
646 vecSupportedFlashModeList.end()) {
647 isSupported = true;
648 return CameraErrorCode::SUCCESS;
649 }
650 isSupported = false;
651 return CameraErrorCode::SUCCESS;
652 }
653
HasFlash(bool & hasFlash)654 int32_t ProfessionSession::HasFlash(bool &hasFlash)
655 {
656 hasFlash = false;
657 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
658 "ProfessionSession::HasFlash Session is not Commited");
659 std::vector<FlashMode> supportedFlashModeList;
660 GetSupportedFlashModes(supportedFlashModeList);
661 bool onlyHasCloseMode = supportedFlashModeList.size() == 1 && supportedFlashModeList[0] == FLASH_MODE_CLOSE;
662 if (!supportedFlashModeList.empty() && !onlyHasCloseMode) {
663 hasFlash = true;
664 }
665 return CameraErrorCode::SUCCESS;
666 }
667 // XMAGE
668
GetSupportedColorEffects(std::vector<ColorEffect> & supportedColorEffects)669 int32_t ProfessionSession::GetSupportedColorEffects(std::vector<ColorEffect>& supportedColorEffects)
670 {
671 supportedColorEffects.clear();
672 CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
673 "ProfessionSession::GetSupportedColorEffects Session is not Commited");
674 auto inputDevice = GetInputDevice();
675 CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
676 CameraErrorCode::SUCCESS, "ProfessionSession::GetSupportedColorEffects camera device is null");
677 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
678 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
679 "ProfessionSession::GetSupportedColorEffects camera deviceInfo is null");
680 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
681 camera_metadata_item_t item;
682 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_SUPPORTED_COLOR_MODES, &item);
683 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
684 "ProfessionSession::GetSupportedColorEffects Failed with return code %{public}d", ret);
685 for (uint32_t i = 0; i < item.count; i++) {
686 auto itr = g_metaColorEffectMap_.find(static_cast<camera_xmage_color_type_t>(item.data.u8[i]));
687 if (itr != g_metaColorEffectMap_.end()) {
688 supportedColorEffects.emplace_back(itr->second);
689 }
690 }
691 return CameraErrorCode::SUCCESS;
692 }
693
GetColorEffect(ColorEffect & colorEffect)694 int32_t ProfessionSession::GetColorEffect(ColorEffect& colorEffect)
695 {
696 colorEffect = ColorEffect::COLOR_EFFECT_NORMAL;
697 CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
698 "ProfessionSession::GetColorEffect Session is not Commited");
699 auto inputDevice = GetInputDevice();
700 CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
701 CameraErrorCode::SUCCESS, "ProfessionSession::GetColorEffect camera device is null");
702 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
703 CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
704 "ProfessionSession::GetColorEffect camera deviceInfo is null");
705 std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
706 camera_metadata_item_t item;
707 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_SUPPORTED_COLOR_MODES, &item);
708 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, CameraErrorCode::SUCCESS,
709 "ProfessionSession::GetColorEffect Failed with return code %{public}d", ret);
710 auto itr = g_metaColorEffectMap_.find(static_cast<camera_xmage_color_type_t>(item.data.u8[0]));
711 if (itr != g_metaColorEffectMap_.end()) {
712 colorEffect = itr->second;
713 }
714 return CameraErrorCode::SUCCESS;
715 }
716
SetColorEffect(ColorEffect colorEffect)717 int32_t ProfessionSession::SetColorEffect(ColorEffect colorEffect)
718 {
719 CAMERA_SYNC_TRACE;
720 CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
721 "ProfessionSession::GetColorEffect Session is not Commited");
722 CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
723 "ProfessionSession::SetFlashMode Need to call LockForControl() before setting camera properties");
724 uint8_t colorEffectTemp = ColorEffect::COLOR_EFFECT_NORMAL;
725 auto itr = g_fwkColorEffectMap_.find(colorEffect);
726 if (itr == g_fwkColorEffectMap_.end()) {
727 MEDIA_ERR_LOG("ProfessionSession::SetColorEffect unknown is color effect");
728 } else {
729 colorEffectTemp = itr->second;
730 }
731 MEDIA_DEBUG_LOG("ProfessionSession::SetColorEffect: %{public}d", colorEffect);
732
733 bool status = false;
734 int32_t ret;
735 uint32_t count = 1;
736 camera_metadata_item_t item;
737 ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_SUPPORTED_COLOR_MODES, &item);
738 if (ret == CAM_META_ITEM_NOT_FOUND) {
739 status = changedMetadata_->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorEffectTemp, count);
740 } else if (ret == CAM_META_SUCCESS) {
741 status = changedMetadata_->updateEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorEffectTemp, count);
742 }
743 CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetColorEffect Failed to set color effect");
744 return CameraErrorCode::SUCCESS;
745 }
746
CanAddOutput(sptr<CaptureOutput> & output)747 bool ProfessionSession::CanAddOutput(sptr<CaptureOutput> &output)
748 {
749 CAMERA_SYNC_TRACE;
750 MEDIA_DEBUG_LOG("Enter Into ProfessionSession::CanAddOutput");
751 CHECK_ERROR_RETURN_RET_LOG(!IsSessionConfiged() || output == nullptr, false,
752 "ProfessionSession::CanAddOutput operation is Not allowed!");
753 return CaptureSession::CanAddOutput(output);
754 }
755
756 //callbacks
SetExposureInfoCallback(std::shared_ptr<ExposureInfoCallback> callback)757 void ProfessionSession::SetExposureInfoCallback(std::shared_ptr<ExposureInfoCallback> callback)
758 {
759 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
760 exposureInfoCallback_ = callback;
761 }
762
SetIsoInfoCallback(std::shared_ptr<IsoInfoCallback> callback)763 void ProfessionSession::SetIsoInfoCallback(std::shared_ptr<IsoInfoCallback> callback)
764 {
765 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
766 isoInfoCallback_ = callback;
767 }
768
SetApertureInfoCallback(std::shared_ptr<ApertureInfoCallback> callback)769 void ProfessionSession::SetApertureInfoCallback(std::shared_ptr<ApertureInfoCallback> callback)
770 {
771 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
772 apertureInfoCallback_ = callback;
773 }
774
SetLuminationInfoCallback(std::shared_ptr<LuminationInfoCallback> callback)775 void ProfessionSession::SetLuminationInfoCallback(std::shared_ptr<LuminationInfoCallback> callback)
776 {
777 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
778 luminationInfoCallback_ = callback;
779 }
780
ProcessSensorExposureTimeChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)781 void ProfessionSession::ProcessSensorExposureTimeChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
782 {
783 camera_metadata_item_t item;
784 common_metadata_header_t* metadata = result->get();
785 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_SENSOR_EXPOSURE_TIME, &item);
786 if (ret == CAM_META_SUCCESS) {
787 int32_t numerator = item.data.r->numerator;
788 int32_t denominator = item.data.r->denominator;
789 MEDIA_DEBUG_LOG("SensorExposureTime: %{public}d/%{public}d", numerator, denominator);
790 CHECK_ERROR_RETURN_LOG(denominator == 0, "ProcessSensorExposureTimeChange error! divide by zero");
791 constexpr int32_t timeUnit = 1000000;
792 uint32_t value = static_cast<uint32_t>(numerator / (denominator / timeUnit));
793 MEDIA_DEBUG_LOG("SensorExposureTime: %{public}d", value);
794 ExposureInfo info = {
795 .exposureDurationValue = value,
796 };
797 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
798 if (exposureInfoCallback_ != nullptr && (value != exposureDurationValue_)) {
799 if (exposureDurationValue_ != 0) {
800 exposureInfoCallback_->OnExposureInfoChanged(info);
801 }
802 exposureDurationValue_ = value;
803 }
804 }
805 }
806
ProcessIsoChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)807 void ProfessionSession::ProcessIsoChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
808 {
809 camera_metadata_item_t item;
810 common_metadata_header_t* metadata = result->get();
811 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_ISO_VALUE, &item);
812 if (ret == CAM_META_SUCCESS) {
813 MEDIA_DEBUG_LOG("Iso Value: %{public}d", item.data.ui32[0]);
814 IsoInfo info = {
815 .isoValue = item.data.ui32[0],
816 };
817 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
818 if (isoInfoCallback_ != nullptr && item.data.ui32[0] != isoValue_) {
819 if (isoValue_ != 0) {
820 isoInfoCallback_->OnIsoInfoChanged(info);
821 }
822 isoValue_ = item.data.ui32[0];
823 }
824 }
825 }
826
ProcessApertureChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)827 void ProfessionSession::ProcessApertureChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
828 {
829 camera_metadata_item_t item;
830 common_metadata_header_t* metadata = result->get();
831 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_CAMERA_APERTURE_VALUE, &item);
832 if (ret == CAM_META_SUCCESS) {
833 MEDIA_DEBUG_LOG("aperture Value: %{public}f", ConfusingNumber(item.data.f[0]));
834 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
835 ApertureInfo info = {
836 .apertureValue = item.data.f[0],
837 };
838 if (apertureInfoCallback_ != nullptr && (item.data.f[0] != apertureValue_ || apertureValue_ == 0)) {
839 apertureInfoCallback_->OnApertureInfoChanged(info);
840 apertureValue_ = item.data.f[0];
841 }
842 }
843 }
844
ProcessLuminationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)845 void ProfessionSession::ProcessLuminationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
846 {
847 constexpr float normalizedMeanValue = 255.0;
848 camera_metadata_item_t item;
849 common_metadata_header_t* metadata = result->get();
850 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_ALGO_MEAN_Y, &item);
851 float value = item.data.ui32[0] / normalizedMeanValue;
852 if (ret == CAM_META_SUCCESS) {
853 MEDIA_DEBUG_LOG("Lumination Value: %{public}f", value);
854 LuminationInfo info = {
855 .luminationValue = value,
856 };
857 std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
858 if (luminationInfoCallback_ != nullptr && value != luminationValue_) {
859 luminationInfoCallback_->OnLuminationInfoChanged(info);
860 luminationValue_ = value;
861 }
862 }
863 }
864
ProcessPhysicalCameraSwitch(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)865 void ProfessionSession::ProcessPhysicalCameraSwitch(const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
866 {
867 camera_metadata_item_t item;
868 common_metadata_header_t* metadata = result->get();
869 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &item);
870 CHECK_ERROR_RETURN(ret != CAM_META_SUCCESS);
871 if (physicalCameraId_ != item.data.u8[0]) {
872 MEDIA_DEBUG_LOG("physicalCameraId: %{public}d", item.data.u8[0]);
873 physicalCameraId_ = item.data.u8[0];
874 ExecuteAbilityChangeCallback();
875 }
876 }
877
GetMetadata()878 std::shared_ptr<OHOS::Camera::CameraMetadata> ProfessionSession::GetMetadata()
879 {
880 std::string phyCameraId = std::to_string(physicalCameraId_.load());
881 auto physicalCameraDevice =
882 std::find_if(supportedDevices_.begin(), supportedDevices_.end(), [phyCameraId](const auto& device) -> bool {
883 std::string cameraId = device->GetID();
884 size_t delimPos = cameraId.find("/");
885 CHECK_ERROR_RETURN_RET(delimPos == std::string::npos, false);
886 string id = cameraId.substr(delimPos + 1);
887 return id.compare(phyCameraId) == 0;
888 });
889 // DELIVERY_PHOTO for default when commit
890 if (physicalCameraDevice != supportedDevices_.end()) {
891 MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata physicalCameraId: device/%{public}s", phyCameraId.c_str());
892 if ((*physicalCameraDevice)->GetCameraType() == CAMERA_TYPE_WIDE_ANGLE && !isRawImageDelivery_) {
893 auto inputDevice = GetInputDevice();
894 CHECK_ERROR_RETURN_RET(inputDevice == nullptr, nullptr);
895 auto info = inputDevice->GetCameraDeviceInfo();
896 CHECK_ERROR_RETURN_RET(info == nullptr, nullptr);
897 MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata using main sensor: %{public}s", info->GetID().c_str());
898 return info->GetMetadata();
899 }
900 return (*physicalCameraDevice)->GetMetadata();
901 }
902 auto inputDevice = GetInputDevice();
903 CHECK_ERROR_RETURN_RET(inputDevice == nullptr, nullptr);
904 MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata no physicalCamera, using current camera device:%{public}s",
905 inputDevice->GetCameraDeviceInfo()->GetID().c_str());
906 return inputDevice->GetCameraDeviceInfo()->GetMetadata();
907 }
908
ProcessCallbacks(const uint64_t timestamp,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)909 void ProfessionSession::ProfessionSessionMetadataResultProcessor::ProcessCallbacks(
910 const uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
911 {
912 auto session = session_.promote();
913 CHECK_ERROR_RETURN_LOG(session == nullptr,
914 "CaptureSession::ProfessionSessionMetadataResultProcessor ProcessCallbacks but session is null");
915
916 session->ProcessAutoFocusUpdates(result);
917 session->ProcessSensorExposureTimeChange(result);
918 session->ProcessIsoChange(result);
919 session->ProcessApertureChange(result);
920 session->ProcessLuminationChange(result);
921 session->ProcessPhysicalCameraSwitch(result);
922 }
923 } // CameraStandard
924 } // OHOS
925