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