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