1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 #include "camera_professional_test_v1_3.h"
16 #include <functional>
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22 using namespace OHOS::HDI::Camera;
23 constexpr uint32_t ITEM_CAPACITY = 100;
24 constexpr uint32_t DATA_CAPACITY = 2000;
25 constexpr uint32_t DATA_COUNT = 1;
26 constexpr uint32_t RESOLUTION_COUNT = 23;
27 constexpr uint32_t RESOLUTION_PARAM = 2;
28 uint32_t g_supportedResolution[RESOLUTION_COUNT][RESOLUTION_PARAM] = {
29 {640, 400}, {640, 480}, {640, 640}, {720, 480}, {720, 540}, {720, 720}, {800, 480}, {800, 600},
30 {864, 480}, {960, 720}, {1024, 768}, {1088, 1080}, {1088, 1088}, {1136, 480}, {1280, 592}, {1280, 720},
31 {1280, 768}, {1280, 960}, {1440, 1080}, {1584, 720}, {1600, 1200}, {1920, 888}, {1920, 1080}
32 };
33 vector<float> supportedPhysicalApertureValues_;
SetUpTestCase(void)34 void CameraProfessionalTestV1_3::SetUpTestCase(void) {}
TearDownTestCase(void)35 void CameraProfessionalTestV1_3::TearDownTestCase(void) {}
SetUp(void)36 void CameraProfessionalTestV1_3::SetUp(void)
37 {
38 cameraTest = std::make_shared<OHOS::Camera::Test>();
39 cameraTest->Init(); // assert inside
40 cameraTest->Open(DEVICE_0); // assert inside
41 }
42
TearDown(void)43 void CameraProfessionalTestV1_3::TearDown(void)
44 {
45 cameraTest->Close();
46 }
47
g_isModeExists(std::shared_ptr<CameraMetadata> ability,uint32_t tag,uint8_t value)48 bool g_isModeExists(std::shared_ptr<CameraMetadata> ability, uint32_t tag, uint8_t value)
49 {
50 common_metadata_header_t* data = ability->get();
51 camera_metadata_item_t entry;
52 int ret = FindCameraMetadataItem(data, tag, &entry);
53 EXPECT_EQ(ret, 0);
54 EXPECT_NE(entry.count, 0);
55 if (entry.data.u8 != nullptr) {
56 for (int i = 0; i < entry.count; i++) {
57 if (entry.data.u8[i] == value) {
58 return true;
59 }
60 }
61 } else {
62 printf("Find CameraMetadata fail!\n");
63 CAMERA_LOGE("Find CameraMetadata fail!");
64 }
65 return false;
66 }
67
GetSupportedPhysicalApertureValues(std::shared_ptr<CameraMetadata> ability)68 void GetSupportedPhysicalApertureValues(std::shared_ptr<CameraMetadata> ability)
69 {
70 supportedPhysicalApertureValues_.clear();
71 EXPECT_NE(ability, nullptr);
72 common_metadata_header_t* data = ability->get();
73 EXPECT_NE(data, nullptr);
74 camera_metadata_item_t entry;
75 int rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry);
76 if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
77 float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10],
78 entry.data.f[14], entry.data.f[18]};
79 for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) {
80 supportedPhysicalApertureValues_.push_back(entryValues[i]);
81 }
82 }
83 }
84
FillCaptureSetting(std::shared_ptr<OHOS::Camera::Test> cameraTest)85 void FillCaptureSetting(std::shared_ptr<OHOS::Camera::Test> cameraTest)
86 {
87 // Fill capture setting
88 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
89 uint8_t muteMode = static_cast<uint8_t>(OHOS_CAMERA_MUTE_MODE_OFF);
90 modeSetting->addEntry(OHOS_CONTROL_MUTE_MODE, &muteMode, DATA_COUNT);
91 uint8_t deferredImage = OHOS::HDI::Camera::V1_2::STILL_IMAGE;
92 modeSetting->addEntry(OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY, &deferredImage, DATA_COUNT);
93 std::vector<uint8_t> controlVec;
94 MetadataUtils::ConvertMetadataToVec(modeSetting, controlVec);
95 cameraTest->abilityVec = controlVec;
96 }
97
98 /**
99 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0200
100 * @tc.desc: OHOS_CONTROL_FLASH_MODE, PROFESSIONAL_PHOTO
101 * @tc.size: MediumTest
102 * @tc.type: Function
103 */
104 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0200, TestSize.Level1)
105 {
106 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
107 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
108 return;
109 }
110
111 cameraTest->Close();
112 //0:close, 1:open, 2:auto, 3:always_open
113 for (uint8_t i = 0;i < 4;i++) {
114 cameraTest->Init();
115 cameraTest->Open(DEVICE_0);
116 FillCaptureSetting(cameraTest);
117
118 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
119 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
120
121 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
122 uint8_t flashMode = i;
123 meta->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, DATA_COUNT);
124 std::vector<uint8_t> setting;
125 MetadataUtils::ConvertMetadataToVec(meta, setting);
126 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
127 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
128
129 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
130 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
131 cameraTest->captureIds = {cameraTest->captureIdPreview};
132 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
133 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
134
135 cameraTest->Close();
136 }
137 sleep(UT_SECOND_TIMES);
138 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
139 EXPECT_NE(callbackData, nullptr);
140 camera_metadata_item_t callbackEntry;
141 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &callbackEntry);
142 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
143 }
144
145 /**
146 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0300
147 * @tc.desc: EXTENDED_STREAM_INFO_RAW, OHOS_CAMERA_FORMAT_DNG, PROFESSIONAL_PHOTO
148 * @tc.size: MediumTest
149 * @tc.type: Function
150 */
151 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0300, TestSize.Level1)
152 {
153 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
154 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
155 return;
156 }
157
158 FillCaptureSetting(cameraTest);
159 // Get stream operator
160 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
161 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
162 cameraTest->streamOperator_V1_3);
163 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
164 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
165
166 // Preview streamInfo
167 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
168 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
169 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
170
171 // Capture extended streamInfo
172 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo;
173 extendedStreamInfo.type =
174 static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(OHOS::HDI::Camera::V1_3::EXTENDED_STREAM_INFO_RAW);
175 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer2 =
176 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anond4b9d56e0102(void *addr, uint32_t size) 177 extendedStreamInfo.bufferQueue = consumer2->CreateProducerSeq([this](void *addr, uint32_t size) {
178 cameraTest->DumpImageFile(105, "dng", addr, size);
179 });
180 EXPECT_NE(extendedStreamInfo.bufferQueue, nullptr);
181 EXPECT_NE(extendedStreamInfo.bufferQueue->producer_, nullptr);
182 extendedStreamInfo.bufferQueue->producer_->SetQueueSize(UT_DATA_SIZE);
183 extendedStreamInfo.width = 4096;
184 extendedStreamInfo.height = 3072;
185 extendedStreamInfo.format = OHOS_CAMERA_FORMAT_DNG;
186 extendedStreamInfo.dataspace = 0;
187
188 // Capture streamInfo
189 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
190 cameraTest->streamInfoCapture->extendedStreamInfos = {extendedStreamInfo};
191 cameraTest->DefaultInfosProfessionalCapture(cameraTest->streamInfoCapture);
192 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
193
194 // Create and commitstreams
195 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
196 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
197 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
198 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO),
199 cameraTest->abilityVec);
200 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
201
202 // Start capture
203 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
204 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
205 cameraTest->captureIds = {cameraTest->captureIdPreview};
206 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
207 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
208 }
209
210 /**
211 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0400
212 * @tc.desc: OHOS_CONTROL_SUPPORTED_COLOR_MODES, PROFESSIONAL_PHOTO
213 * @tc.size: MediumTest
214 * @tc.type: Function
215 */
216 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0400, TestSize.Level1)
217 {
218 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
219 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
220 return;
221 }
222
223 FillCaptureSetting(cameraTest);
224 //0:normal, 1:bright, 2:soft
225 for (uint8_t i = 0;i < 3;i++) {
226 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
227 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
228
229 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
230 uint8_t colorMode = i;
231 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorMode, DATA_COUNT);
232 std::vector<uint8_t> setting;
233 MetadataUtils::ConvertMetadataToVec(meta, setting);
234 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
235 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
236
237 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
238 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
239 cameraTest->captureIds = {cameraTest->captureIdPreview};
240 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
241 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
242 }
243 }
244
245 /**
246 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0500
247 * @tc.desc: FOCUS_ASSIST_FLASH_MODES, PROFESSIONAL_PHOTO
248 * @tc.size: MediumTest
249 * @tc.type: Function
250 */
251 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0500, TestSize.Level1)
252 {
253 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
254 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
255 return;
256 }
257
258 FillCaptureSetting(cameraTest);
259 EXPECT_NE(cameraTest->ability, nullptr);
260 common_metadata_header_t* data = cameraTest->ability->get();
261 EXPECT_NE(data, nullptr);
262 camera_metadata_item_t entry;
263 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_ASSIST_FLASH_SUPPORTED_MODES, &entry);
264 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
265 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
266 for (size_t i = 0;i < entry.count;i++) {
267 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT) {
268 CAMERA_LOGI("OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT mode is supported!");
269 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO) {
270 CAMERA_LOGI("OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO mode is supported!");
271 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON) {
272 CAMERA_LOGI("OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON mode is supported!");
273 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF) {
274 CAMERA_LOGI("OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF mode is supported!");
275 }
276 }
277 }
278
279 for (uint8_t i = 0;i < entry.count;i++) {
280 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
281 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
282
283 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
284 uint8_t focusAssistFlashMode = entry.data.u8[i];
285 meta->addEntry(OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &focusAssistFlashMode, DATA_COUNT);
286 std::vector<uint8_t> setting;
287 MetadataUtils::ConvertMetadataToVec(meta, setting);
288 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
289 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
290
291 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
292 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
293 cameraTest->captureIds = {cameraTest->captureIdPreview};
294 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
295 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
296 }
297 }
298
299 /**
300 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0600
301 * @tc.desc: OHOS_CONTROL_ZOOM_RATIO, PROFESSIONAL_PHOTO
302 * @tc.size: MediumTest
303 * @tc.type: Function
304 */
305 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0600, TestSize.Level1)
306 {
307 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
308 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
309 return;
310 }
311
312 FillCaptureSetting(cameraTest);
313 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
314 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
315
316 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
317 float zoomRatio = 1.0f;
318 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
319 std::vector<uint8_t> setting;
320 MetadataUtils::ConvertMetadataToVec(meta, setting);
321 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
322 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
323
324 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
325 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
326 cameraTest->captureIds = {cameraTest->captureIdPreview};
327 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
328 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
329 }
330
331 /**
332 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0700
333 * @tc.desc: OHOS_ABILITY_METER_MODES, OHOS_CONTROL_METER_MODE, PROFESSIONAL_PHOTO
334 * @tc.size: MediumTest
335 * @tc.type: Function
336 */
337 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0700, TestSize.Level1)
338 {
339 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
340 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
341 return;
342 }
343
344 FillCaptureSetting(cameraTest);
345 EXPECT_NE(cameraTest->ability, nullptr);
346 common_metadata_header_t* data = cameraTest->ability->get();
347 EXPECT_NE(data, nullptr);
348 camera_metadata_item_t entry;
349 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
350 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
351 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
352 for (size_t i = 0;i < entry.count;i++) {
353 if (entry.data.u8[i] == OHOS_CAMERA_SPOT_METERING) {
354 CAMERA_LOGI("OHOS_CAMERA_SPOT_METERING mode is supported!");
355 } else if (entry.data.u8[i] == OHOS_CAMERA_REGION_METERING) {
356 CAMERA_LOGI("OHOS_CAMERA_REGION_METERING mode is supported!");
357 } else if (entry.data.u8[i] == OHOS_CAMERA_OVERALL_METERING) {
358 CAMERA_LOGI("OHOS_CAMERA_OVERALL_METERING mode is supported!");
359 } else if (entry.data.u8[i] == OHOS_CAMERA_CENTER_WEIGHTED_METERING) {
360 CAMERA_LOGI("OHOS_CAMERA_CENTER_WEIGHTED_METERING mode is supported!");
361 }
362 }
363 }
364
365 for (uint8_t i = 0;i < entry.count;i++) {
366 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
367 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
368
369 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
370 uint8_t meteringMode = entry.data.u8[i];
371 meta->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, DATA_COUNT);
372 std::vector<uint8_t> setting;
373 MetadataUtils::ConvertMetadataToVec(meta, setting);
374 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
375 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
376
377 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
378 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
379 cameraTest->captureIds = {cameraTest->captureIdPreview};
380 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
381 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
382 }
383 }
384
385 /**
386 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0800
387 * @tc.desc: OHOS_ABILITY_ISO_VALUES, OHOS_CONTROL_ISO_VALUE, PROFESSIONAL_PHOTO
388 * @tc.size: MediumTest
389 * @tc.type: Function
390 */
391 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0800, TestSize.Level1)
392 {
393 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
394 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
395 return;
396 }
397
398 FillCaptureSetting(cameraTest);
399 EXPECT_NE(cameraTest->ability, nullptr);
400 common_metadata_header_t* data = cameraTest->ability->get();
401 EXPECT_NE(data, nullptr);
402 camera_metadata_item_t entry;
403 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_ISO_VALUES, &entry);
404 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
405
406 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
407 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
408
409 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
410 int32_t isoValue = 50;
411 meta->addEntry(OHOS_CONTROL_ISO_VALUE, &isoValue, DATA_COUNT);
412 std::vector<uint8_t> setting;
413 MetadataUtils::ConvertMetadataToVec(meta, setting);
414 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
415 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
416
417 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
418 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
419 cameraTest->captureIds = {cameraTest->captureIdPreview};
420 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
421 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
422
423 sleep(UT_SECOND_TIMES);
424 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
425 EXPECT_NE(callbackData, nullptr);
426 camera_metadata_item_t callbackEntry;
427 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_ISO_VALUE, &callbackEntry);
428 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
429 }
430
431 /**
432 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_0900
433 * @tc.desc: PHYSICAL_APERTURE, PROFESSIONAL_PHOTO
434 * @tc.size: MediumTest
435 * @tc.type: Function
436 */
437 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_0900, TestSize.Level1)
438 {
439 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
440 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
441 return;
442 }
443
444 FillCaptureSetting(cameraTest);
445 EXPECT_NE(cameraTest->ability, nullptr);
446 GetSupportedPhysicalApertureValues(cameraTest->ability);
447 if (supportedPhysicalApertureValues_.size() == 0)
448 {
449 cout << "OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE is not support" << endl;
450 return;
451 }
452 for (uint8_t i = 0;i < supportedPhysicalApertureValues_.size();i++) {
453 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
454 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
455
456 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
457 float physicalApertureValue = supportedPhysicalApertureValues_[i];
458 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
459 std::vector<uint8_t> setting;
460 MetadataUtils::ConvertMetadataToVec(meta, setting);
461 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
462 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
463
464 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
465 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
466 cameraTest->captureIds = {cameraTest->captureIdPreview};
467 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
468 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
469 }
470
471 sleep(UT_SECOND_TIMES);
472 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
473 EXPECT_NE(callbackData, nullptr);
474 camera_metadata_item_t callbackEntry;
475 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_CAMERA_APERTURE_VALUE, &callbackEntry);
476 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
477 }
478
479 /**
480 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1000
481 * @tc.desc: OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, OHOS_CONTROL_SENSOR_EXPOSURE_TIME, PROFESSIONAL_PHOTO
482 * @tc.size: MediumTest
483 * @tc.type: Function
484 */
485 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1000, TestSize.Level1)
486 {
487 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
488 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
489 return;
490 }
491
492 FillCaptureSetting(cameraTest);
493 EXPECT_NE(cameraTest->ability, nullptr);
494 common_metadata_header_t* data = cameraTest->ability->get();
495 EXPECT_NE(data, nullptr);
496 camera_metadata_item_t entry;
497 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, &entry);
498 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
499
500 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
501 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
502
503 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
504 camera_rational_t sensorExposureTime = {250, 1000000};
505 meta->addEntry(OHOS_CONTROL_SENSOR_EXPOSURE_TIME, &sensorExposureTime, DATA_COUNT);
506 std::vector<uint8_t> setting;
507 MetadataUtils::ConvertMetadataToVec(meta, setting);
508 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
509 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
510
511 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
512 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
513 cameraTest->captureIds = {cameraTest->captureIdPreview};
514 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
515 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
516
517 sleep(UT_SECOND_TIMES);
518 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
519 EXPECT_NE(callbackData, nullptr);
520 camera_metadata_item_t callbackEntry;
521 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_SENSOR_EXPOSURE_TIME, &callbackEntry);
522 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
523 }
524
525 /**
526 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1100
527 * @tc.desc: AE_COMPENSATION, PROFESSIONAL_PHOTO
528 * @tc.size: MediumTest
529 * @tc.type: Function
530 */
531 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1100, TestSize.Level1)
532 {
533 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
534 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
535 return;
536 }
537
538 FillCaptureSetting(cameraTest);
539 EXPECT_NE(cameraTest->ability, nullptr);
540 common_metadata_header_t* data = cameraTest->ability->get();
541 EXPECT_NE(data, nullptr);
542 camera_metadata_item_t entry;
543 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_RANGE, &entry);
544 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
545
546 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_STEP, &entry);
547 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
548
549 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
550 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
551
552 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
553 int32_t aeExposureCompensation = 4;
554 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, DATA_COUNT);
555 std::vector<uint8_t> setting;
556 MetadataUtils::ConvertMetadataToVec(meta, setting);
557 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
558 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
559
560 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
561 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
562 cameraTest->captureIds = {cameraTest->captureIdPreview};
563 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
564 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
565 }
566
567 /**
568 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1200
569 * @tc.desc: OHOS_ABILITY_FOCUS_MODES, OHOS_CONTROL_FOCUS_MODE, PROFESSIONAL_PHOTO
570 * @tc.size: MediumTest
571 * @tc.type: Function
572 */
573 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1200, TestSize.Level1)
574 {
575 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
576 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
577 return;
578 }
579
580 FillCaptureSetting(cameraTest);
581 EXPECT_NE(cameraTest->ability, nullptr);
582 common_metadata_header_t* data = cameraTest->ability->get();
583 EXPECT_NE(data, nullptr);
584 camera_metadata_item_t entry;
585 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
586 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
587 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
588 for (size_t i = 0;i < entry.count;i++) {
589 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) {
590 CAMERA_LOGI("OHOS_CAMERA_FOCUS_MODE_MANUAL mode is supported!");
591 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO) {
592 CAMERA_LOGI("OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO mode is supported!");
593 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_AUTO) {
594 CAMERA_LOGI("OHOS_CAMERA_FOCUS_MODE_AUTO mode is supported!");
595 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_LOCKED) {
596 CAMERA_LOGI("OHOS_CAMERA_FOCUS_MODE_LOCKED mode is supported!");
597 }
598 }
599 }
600
601 for (uint8_t i = 0;i < entry.count;i++) {
602 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
603 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
604
605 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
606 uint8_t focusMode = entry.data.u8[i];
607 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
608 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) {
609 uint8_t focusedPoint[] = {1, 1, 1, 1};
610 meta->addEntry(OHOS_CONTROL_FOCUSED_POINT, &focusedPoint, DATA_COUNT);
611 }
612 std::vector<uint8_t> setting;
613 MetadataUtils::ConvertMetadataToVec(meta, setting);
614 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
615 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
616
617 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
618 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
619 cameraTest->captureIds = {cameraTest->captureIdPreview};
620 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
621 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
622 }
623 }
624
625 /**
626 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1300
627 * @tc.desc: OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, OHOS_CONTROL_LENS_FOCUS_DISTANCE, PROFESSIONAL_PHOTO
628 * @tc.size: MediumTest
629 * @tc.type: Function
630 */
631 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1300, TestSize.Level1)
632 {
633 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
634 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
635 return;
636 }
637
638 FillCaptureSetting(cameraTest);
639 EXPECT_NE(cameraTest->ability, nullptr);
640 common_metadata_header_t* data = cameraTest->ability->get();
641 EXPECT_NE(data, nullptr);
642 camera_metadata_item_t entry;
643 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry);
644 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
645 for (uint8_t i = 0;i < entry.count;i++) {
646 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
647 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
648
649 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
650 float lensFocusDistance = entry.data.f[i];
651 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
652 std::vector<uint8_t> setting;
653 MetadataUtils::ConvertMetadataToVec(meta, setting);
654 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
655 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
656
657 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
658 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
659 cameraTest->captureIds = {cameraTest->captureIdPreview};
660 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
661 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
662 }
663 } else {
664 printf("get tag<OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE> failed.\n");
665 }
666 }
667
668 /**
669 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1400
670 * @tc.desc: OHOS_ABILITY_AWB_MODES, OHOS_CONTROL_AWB_MODE, PROFESSIONAL_PHOTO
671 * @tc.size: MediumTest
672 * @tc.type: Function
673 */
674 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1400, TestSize.Level1)
675 {
676 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
677 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
678 return;
679 }
680
681 FillCaptureSetting(cameraTest);
682 EXPECT_NE(cameraTest->ability, nullptr);
683 common_metadata_header_t* data = cameraTest->ability->get();
684 camera_metadata_item_t entry;
685 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry);
686 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
687 for (size_t i = 0;i < entry.count;i++) {
688 if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_OFF) {
689 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_OFF mode is supported!");
690 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_AUTO) {
691 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_AUTO mode is supported!");
692 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_INCANDESCENT) {
693 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_INCANDESCENT mode is supported!");
694 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_FLUORESCENT) {
695 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_FLUORESCENT mode is supported!");
696 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT) {
697 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT mode is supported!");
698 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_DAYLIGHT) {
699 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_DAYLIGHT mode is supported!");
700 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT) {
701 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT mode is supported!");
702 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_TWILIGHT) {
703 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_TWILIGHT mode is supported!");
704 } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_SHADE) {
705 CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_SHADE mode is supported!");
706 }
707
708 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
709 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
710
711 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
712 uint8_t awbMode = entry.data.u8[i];
713 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT);
714 std::vector<uint8_t> setting;
715 MetadataUtils::ConvertMetadataToVec(meta, setting);
716 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
717 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
718
719 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
720 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
721 cameraTest->captureIds = {cameraTest->captureIdPreview};
722 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
723 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
724 }
725 } else {
726 printf("get tag<OHOS_CONTROL_AWB_AVAILABLE_MODES> failed.\n");
727 }
728 }
729
730 /**
731 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1500
732 * @tc.desc: OHOS_ABILITY_EXPOSURE_HINT_SUPPORTED, OHOS_CONTROL_EXPOSURE_HINT_MODE, PROFESSIONAL_PHOTO
733 * @tc.size: MediumTest
734 * @tc.type: Function
735 */
736 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1500, TestSize.Level1)
737 {
738 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
739 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
740 return;
741 }
742
743 FillCaptureSetting(cameraTest);
744 EXPECT_NE(cameraTest->ability, nullptr);
745 common_metadata_header_t* data = cameraTest->ability->get();
746 EXPECT_NE(data, nullptr);
747 camera_metadata_item_t entry;
748 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_HINT_SUPPORTED, &entry);
749 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
750
751 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
752 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
753
754 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
755 uint8_t exposureHintMode = 1;
756 meta->addEntry(OHOS_CONTROL_EXPOSURE_HINT_MODE, &exposureHintMode, DATA_COUNT);
757 std::vector<uint8_t> setting;
758 MetadataUtils::ConvertMetadataToVec(meta, setting);
759 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
760 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
761
762 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
763 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
764 cameraTest->captureIds = {cameraTest->captureIdPreview};
765 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
766 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
767
768 sleep(UT_SECOND_TIMES);
769 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
770 EXPECT_NE(callbackData, nullptr);
771 camera_metadata_item_t callbackEntry;
772 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_ALGO_MEAN_Y, &callbackEntry);
773 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
774 }
775
776 /**
777 * @tc.name: SUB_Driver_Camera_ProfessionalPhoto_1600
778 * @tc.desc: OHOS_ABILITY_SENSOR_WB_VALUES, OHOS_CONTROL_SENSOR_WB_VALUE, PROFESSIONAL_PHOTO
779 * @tc.size: MediumTest
780 * @tc.type: Function
781 */
782 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1600, TestSize.Level1)
783 {
784 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO)) {
785 cout << "skip this test, because PROFESSIONAL_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
786 return;
787 }
788
789 FillCaptureSetting(cameraTest);
790 EXPECT_NE(cameraTest->ability, nullptr);
791 common_metadata_header_t* data = cameraTest->ability->get();
792 EXPECT_NE(data, nullptr);
793 camera_metadata_item_t entry;
794 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry);
795 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
796 for (uint8_t i = 0;i < entry.count;i++) {
797 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
798 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO);
799
800 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
801 int32_t wbMode = entry.data.i32[i];
802 meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT);
803 std::vector<uint8_t> setting;
804 MetadataUtils::ConvertMetadataToVec(meta, setting);
805 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
806 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
807
808 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
809 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
810 cameraTest->captureIds = {cameraTest->captureIdPreview};
811 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
812 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
813 }
814 } else {
815 printf("get tag<OHOS_ABILITY_SENSOR_WB_VALUES> failed.\n");
816 CAMERA_LOGE("get tag<OHOS_ABILITY_SENSOR_WB_VALUES> failed.");
817 }
818 }
819
820 /**
821 * @tc.name:SUB_Driver_Camera_ProfessionalPhoto_1700
822 * @tc.desc:different resolution
823 * @tc.size:MediumTest
824 * @tc.type:Function
825 */
826 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalPhoto_1700, TestSize.Level1)
827 {
828 // Get stream operator
829 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
830 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
831 cameraTest->streamOperator_V1_3);
832 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
833 FillCaptureSetting(cameraTest);
834 for (uint8_t i = 0; i < RESOLUTION_COUNT; i++) {
835 // Preview streamInfo
836 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
837 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
838 cameraTest->streamInfoPre->v1_0.width_ = g_supportedResolution[i][0];
839 cameraTest->streamInfoPre->v1_0.height_ = g_supportedResolution[i][1];
840 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
841
842 // Capture streamInfo
843 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
844 cameraTest->DefaultInfosProfessionalCapture(cameraTest->streamInfoCapture);
845 cameraTest->streamInfoCapture->v1_0.width_ = g_supportedResolution[i][0];
846 cameraTest->streamInfoCapture->v1_0.height_ = g_supportedResolution[i][1];
847 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
848
849 // Create and commit stream
850 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
851 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
852 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
853 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO),
854 cameraTest->abilityVec);
855 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
856
857 // Start capture
858 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
859 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
860
861 // Stop stream
862 cameraTest->captureIds = {cameraTest->captureIdPreview};
863 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
864 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
865 cameraTest->streamInfosV1_1.clear();
866 }
867 }
868
869 /**
870 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1100
871 * @tc.desc: OHOS_CONTROL_FLASH_MODE, PROFESSIONAL_VIDEO
872 * @tc.size: MediumTest
873 * @tc.type: Function
874 */
875 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1100, TestSize.Level1)
876 {
877 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
878 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
879 return;
880 }
881
882 //0:close, 1:open, 2:auto, 3:always_open
883 for (uint8_t i = 0;i < 4;i++) {
884 cameraTest->intents = {PREVIEW, VIDEO};
885 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
886
887 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
888 uint8_t flashMode = i;
889 meta->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, DATA_COUNT);
890 std::vector<uint8_t> setting;
891 MetadataUtils::ConvertMetadataToVec(meta, setting);
892 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
893 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
894
895 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
896 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
897 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
898 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
899 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
900 }
901
902 sleep(UT_SECOND_TIMES);
903 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
904 EXPECT_NE(callbackData, nullptr);
905 camera_metadata_item_t callbackEntry;
906 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &callbackEntry);
907 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
908 }
909
910 /**
911 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1200
912 * @tc.desc: OHOS_CONTROL_SUPPORTED_COLOR_MODES, PROFESSIONAL_VIDEO
913 * @tc.size: MediumTest
914 * @tc.type: Function
915 */
916 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1200, TestSize.Level1)
917 {
918 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
919 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
920 return;
921 }
922 //0:normal, 1:bright, 2:soft
923 for (uint8_t i = 0;i < 3;i++) {
924 cameraTest->intents = {PREVIEW, VIDEO};
925 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
926
927 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
928 uint8_t colorMode = i;
929 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorMode, DATA_COUNT);
930 std::vector<uint8_t> setting;
931 MetadataUtils::ConvertMetadataToVec(meta, setting);
932 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
933 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
934
935 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
936 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
937 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
938 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
939 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
940 }
941 }
942
943 /**
944 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1300
945 * @tc.desc: OHOS_CONTROL_ZOOM_RATIO, PROFESSIONAL_VIDEO
946 * @tc.size: MediumTest
947 * @tc.type: Function
948 */
949 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1300, TestSize.Level1)
950 {
951 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
952 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
953 return;
954 }
955 cameraTest->intents = {PREVIEW, VIDEO};
956 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
957
958 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
959 float zoomRatio = 1.0f;
960 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
961 std::vector<uint8_t> setting;
962 MetadataUtils::ConvertMetadataToVec(meta, setting);
963 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
964 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
965
966 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
967 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
968 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
969 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
970 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
971 }
972
973 /**
974 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1400
975 * @tc.desc: OHOS_CONTROL_METER_MODE, PROFESSIONAL_VIDEO
976 * @tc.size: MediumTest
977 * @tc.type: Function
978 */
979 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1400, TestSize.Level1)
980 {
981 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
982 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
983 return;
984 }
985 EXPECT_NE(cameraTest->ability, nullptr);
986 common_metadata_header_t* data = cameraTest->ability->get();
987 EXPECT_NE(data, nullptr);
988 camera_metadata_item_t entry;
989 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
990 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
991 for (uint8_t i = 0;i < entry.count;i++) {
992 cameraTest->intents = {PREVIEW, VIDEO};
993 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
994
995 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
996 uint8_t meteringMode = entry.data.u8[i];
997 meta->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, DATA_COUNT);
998 std::vector<uint8_t> setting;
999 MetadataUtils::ConvertMetadataToVec(meta, setting);
1000 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1001 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1002
1003 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1004 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1005 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1006 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1007 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1008 }
1009 } else {
1010 printf("get tag<OHOS_ABILITY_METER_MODES> failed.\n");
1011 }
1012 }
1013
1014 /**
1015 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1500
1016 * @tc.desc: OHOS_CONTROL_ISO_VALUE, OHOS_STATUS_ISO_VALUE, PROFESSIONAL_VIDEO
1017 * @tc.size: MediumTest
1018 * @tc.type: Function
1019 */
1020 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1500, TestSize.Level1)
1021 {
1022 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1023 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1024 return;
1025 }
1026 cameraTest->intents = {PREVIEW, VIDEO};
1027 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1028
1029 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1030 int32_t isoValue = 50;
1031 meta->addEntry(OHOS_CONTROL_ISO_VALUE, &isoValue, DATA_COUNT);
1032 std::vector<uint8_t> setting;
1033 MetadataUtils::ConvertMetadataToVec(meta, setting);
1034 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1035 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1036
1037 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1038 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1039 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1040 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1041 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1042
1043 sleep(UT_SECOND_TIMES);
1044 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
1045 EXPECT_NE(callbackData, nullptr);
1046 camera_metadata_item_t callbackEntry;
1047 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_ISO_VALUE, &callbackEntry);
1048 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1049 }
1050
1051 /**
1052 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1600
1053 * @tc.desc: OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, OHOS_STATUS_CAMERA_APERTURE_VALUE, PROFESSIONAL_VIDEO
1054 * @tc.size: MediumTest
1055 * @tc.type: Function
1056 */
1057 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1600, TestSize.Level1)
1058 {
1059 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1060 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1061 return;
1062 }
1063 EXPECT_NE(cameraTest->ability, nullptr);
1064 GetSupportedPhysicalApertureValues(cameraTest->ability);
1065 if (supportedPhysicalApertureValues_.size() == 0)
1066 {
1067 cout << "OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE is not support" << endl;
1068 return;
1069 }
1070
1071 for (uint8_t i = 0;i < supportedPhysicalApertureValues_.size();i++) {
1072 cameraTest->intents = {PREVIEW, VIDEO};
1073 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1074
1075 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1076 float physicalApertureValue = supportedPhysicalApertureValues_[i];
1077 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
1078 std::vector<uint8_t> setting;
1079 MetadataUtils::ConvertMetadataToVec(meta, setting);
1080 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1081 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1082
1083 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1084 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1085 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1086 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1087 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1088 }
1089 sleep(UT_SECOND_TIMES);
1090 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
1091 EXPECT_NE(callbackData, nullptr);
1092 camera_metadata_item_t callbackEntry;
1093 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_CAMERA_APERTURE_VALUE, &callbackEntry);
1094 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1095 }
1096
1097 /**
1098 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1700
1099 * @tc.desc: OHOS_CONTROL_SENSOR_EXPOSURE_TIME, OHOS_STATUS_SENSOR_EXPOSURE_TIME, PROFESSIONAL_VIDEO
1100 * @tc.size: MediumTest
1101 * @tc.type: Function
1102 */
1103 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1700, TestSize.Level1)
1104 {
1105 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1106 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1107 return;
1108 }
1109 EXPECT_NE(cameraTest->ability, nullptr);
1110 common_metadata_header_t* data = cameraTest->ability->get();
1111 EXPECT_NE(data, nullptr);
1112 camera_metadata_item_t entry;
1113 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, &entry);
1114 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.r != nullptr && entry.count > 0) {
1115 for (uint8_t i = 0;i < entry.count;i++) {
1116 cameraTest->intents = {PREVIEW, VIDEO};
1117 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1118
1119 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1120 camera_rational_t sensorExposureTime = {entry.data.r[i].numerator, entry.data.r[i].denominator};
1121 meta->addEntry(OHOS_CONTROL_SENSOR_EXPOSURE_TIME, &sensorExposureTime, DATA_COUNT);
1122 std::vector<uint8_t> setting;
1123 MetadataUtils::ConvertMetadataToVec(meta, setting);
1124 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1125 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1126
1127 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1128 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1129 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1130 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1131 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1132 }
1133 } else {
1134 printf("get tag<OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE> failed.\n");
1135 }
1136 sleep(UT_SECOND_TIMES);
1137 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
1138 EXPECT_NE(callbackData, nullptr);
1139 camera_metadata_item_t callbackEntry;
1140 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_STATUS_SENSOR_EXPOSURE_TIME, &callbackEntry);
1141 EXPECT_NE(callbackEntry.data.r, nullptr);
1142 CAMERA_LOGI("the value of OHOS_STATUS_SENSOR_EXPOSURE_TIME is %{public}d/%{public}d",
1143 callbackEntry.data.r[0].numerator, callbackEntry.data.r[0].denominator);
1144 }
1145
1146 /**
1147 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1800
1148 * @tc.desc: OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, PROFESSIONAL_VIDEO
1149 * @tc.size: MediumTest
1150 * @tc.type: Function
1151 */
1152 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1800, TestSize.Level1)
1153 {
1154 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1155 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1156 return;
1157 }
1158 cameraTest->intents = {PREVIEW, VIDEO};
1159 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1160
1161 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1162 int32_t aeExposureCompensation = 4;
1163 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, DATA_COUNT);
1164 std::vector<uint8_t> setting;
1165 MetadataUtils::ConvertMetadataToVec(meta, setting);
1166 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1167 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1168
1169 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1170 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1171 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1172 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1173 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1174 }
1175
1176 /**
1177 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_1900
1178 * @tc.desc: OHOS_CONTROL_FOCUS_MODE, PROFESSIONAL_VIDEO
1179 * @tc.size: MediumTest
1180 * @tc.type: Function
1181 */
1182 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_1900, TestSize.Level1)
1183 {
1184 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1185 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1186 return;
1187 }
1188 EXPECT_NE(cameraTest->ability, nullptr);
1189 common_metadata_header_t* data = cameraTest->ability->get();
1190 EXPECT_NE(data, nullptr);
1191 camera_metadata_item_t entry;
1192 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1193
1194 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
1195 for (uint8_t i = 0;i < entry.count;i++) {
1196 cameraTest->intents = {PREVIEW, VIDEO};
1197 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1198 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1199 uint8_t focusMode = entry.data.u8[i];
1200 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
1201 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) {
1202 uint8_t focusedPoint[] = {1, 1, 1, 1};
1203 meta->addEntry(OHOS_CONTROL_FOCUSED_POINT, &focusedPoint, DATA_COUNT);
1204 }
1205 std::vector<uint8_t> setting;
1206 MetadataUtils::ConvertMetadataToVec(meta, setting);
1207 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1208 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1209
1210 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1211 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1212 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1213 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1214 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1215 }
1216 } else {
1217 printf("get tag<OHOS_ABILITY_FOCUS_MODES> failed.\n");
1218 }
1219 }
1220
1221 /**
1222 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_2000
1223 * @tc.desc: OHOS_CONTROL_LENS_FOCUS_DISTANCE, PROFESSIONAL_VIDEO
1224 * @tc.size: MediumTest
1225 * @tc.type: Function
1226 */
1227 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_2000, TestSize.Level1)
1228 {
1229 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1230 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1231 return;
1232 }
1233 EXPECT_NE(cameraTest->ability, nullptr);
1234 common_metadata_header_t* data = cameraTest->ability->get();
1235 EXPECT_NE(data, nullptr);
1236 camera_metadata_item_t entry;
1237 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry);
1238 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
1239 for (uint8_t i = 0;i < entry.count;i++) {
1240 cameraTest->intents = {PREVIEW, VIDEO};
1241 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1242
1243 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1244 float lensFocusDistance = entry.data.f[i];
1245 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
1246 std::vector<uint8_t> setting;
1247 MetadataUtils::ConvertMetadataToVec(meta, setting);
1248 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1249 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1250
1251 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1252 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1253 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1254 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1255 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1256 }
1257 } else {
1258 printf("get tag<OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE> failed.\n");
1259 }
1260 }
1261
1262 /**
1263 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_2100
1264 * @tc.desc: OHOS_CONTROL_AWB_MODE, PROFESSIONAL_VIDEO
1265 * @tc.size: MediumTest
1266 * @tc.type: Function
1267 */
1268 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_2100, TestSize.Level1)
1269 {
1270 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1271 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1272 return;
1273 }
1274 EXPECT_NE(cameraTest->ability, nullptr);
1275 common_metadata_header_t* data = cameraTest->ability->get();
1276 EXPECT_NE(data, nullptr);
1277 camera_metadata_item_t entry;
1278 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry);
1279 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
1280 for (uint8_t i = 0;i < entry.count;i++) {
1281 cameraTest->intents = {PREVIEW, VIDEO};
1282 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1283
1284 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1285 uint8_t awbMode = entry.data.u8[i];
1286 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT);
1287 std::vector<uint8_t> setting;
1288 MetadataUtils::ConvertMetadataToVec(meta, setting);
1289 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1290 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1291
1292 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1293 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1294 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1295 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1296 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1297 }
1298 } else {
1299 printf("get tag<OHOS_CONTROL_AWB_AVAILABLE_MODES> failed.\n");
1300 }
1301 }
1302
1303 /**
1304 * @tc.name: SUB_Driver_Camera_ProfessionalVideo_2200
1305 * @tc.desc: OHOS_CONTROL_SENSOR_WB_VALUE, PROFESSIONAL_VIDEO
1306 * @tc.size: MediumTest
1307 * @tc.type: Function
1308 */
1309 HWTEST_F(CameraProfessionalTestV1_3, SUB_Driver_Camera_ProfessionalVideo_2200, TestSize.Level1)
1310 {
1311 if (!g_isModeExists(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO)) {
1312 cout << "skip this test, because PROFESSIONAL_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1313 return;
1314 }
1315 EXPECT_NE(cameraTest->ability, nullptr);
1316 common_metadata_header_t* data = cameraTest->ability->get();
1317 EXPECT_NE(data, nullptr);
1318 camera_metadata_item_t entry;
1319 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry);
1320 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
1321 for (uint8_t i = 0;i < entry.count;i++) {
1322 cameraTest->intents = {PREVIEW, VIDEO};
1323 cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO);
1324
1325 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1326 int32_t wbMode = entry.data.i32[i];
1327 meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT);
1328 std::vector<uint8_t> setting;
1329 MetadataUtils::ConvertMetadataToVec(meta, setting);
1330 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1331 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1332
1333 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1334 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1335 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1336 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1337 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1338 }
1339 } else {
1340 printf("get tag<OHOS_ABILITY_SENSOR_WB_VALUES> failed.\n");
1341 }
1342 }