1/* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15#include "usb_camera_test.h" 16 17bool g_usbCameraExit = false; 18 19void UtestUSBCameraTest::SetUpTestCase(void) 20{} 21void UtestUSBCameraTest::TearDownTestCase(void) 22{} 23void UtestUSBCameraTest::SetUp(void) 24{ 25 if (cameraBase_ == nullptr) 26 cameraBase_ = std::make_shared<TestCameraBase>(); 27 cameraBase_->UsbInit(); 28} 29void UtestUSBCameraTest::TearDown(void) 30{ 31 cameraBase_->Close(); 32} 33 34/** 35 * @tc.name: USB Camera 36 * @tc.desc: USB Camera, getCameraID success. 37 * @tc.level: Level0 38 * @tc.size: MediumTest 39 * @tc.type: Function 40 */ 41TEST_F(UtestUSBCameraTest, camera_usb_0001) 42{ 43 uint32_t rc = 0; 44 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl; 45 std::vector<std::string> cameraIds; 46 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl; 47 cameraBase_->cameraHost->GetCameraIds(cameraIds); 48 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl; 49 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl; 50 for (const auto &cameraId : cameraIds) { 51 std::cout << "==========[test log] cameraId = " << cameraId << std::endl; 52 } 53 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 10s..."<< std::endl; 54 sleep(3); // judging add or delete the usb camera, wait for 3s. 55 std::cout << "==========[test log] r u ready? wait for 10s..."<< std::endl; 56 sleep(3); // judging r u ready, wait for 3s. 57 std::cout << "==========[test log] 3. check the cameraID again... wait for 10s..."<< std::endl; 58 sleep(3); // checking the cameraID again, wait for 3s. 59 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl; 60 if (cameraIds.size() == 1) { 61 cameraIds.clear(); 62 } 63 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds); 64 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR); 65 for (const auto &cameraId : cameraIds) { 66 std::cout << "cameraId = " << cameraId << std::endl; 67 } 68 // 1:number of connected cameras 69 g_usbCameraExit = cameraIds.size() > 1; 70} 71 72/** 73 * @tc.name: USB Camera 74 * @tc.desc: get value of OHOS_ABILITY_ZOOM_RATIO_RANGE 75 * @tc.level: Level0 76 * @tc.size: MediumTest 77 * @tc.type: Function 78 */ 79TEST_F(UtestUSBCameraTest, camera_usb_0002) 80{ 81 if (!g_usbCameraExit) { 82 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 83 } 84 ability_ = cameraBase_->GetCameraAbility(); 85 EXPECT_NE(ability_, nullptr); 86 common_metadata_header_t *data = ability_->get(); 87 camera_metadata_item_t entry; 88 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry); 89 if (ret == CAM_META_SUCCESS) { 90 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE: count is " << (int)entry.count << std::endl; 91 std::cout << "Zoom ratio range: [" << entry.data.f[0]; 92 std::cout << "," << entry.data.f[1] << "]" << std::endl; 93 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 94 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE is not support" << std::endl; 95 } 96} 97 98/** 99 * @tc.name: USB Camera 100 * @tc.desc: get value of OHOS_ABILITY_CAMERA_CONNECTION_TYPE 101 * @tc.level: Level0 102 * @tc.size: MediumTest 103 * @tc.type: Function 104 */ 105TEST_F(UtestUSBCameraTest, camera_usb_0003) 106{ 107 if (!g_usbCameraExit) { 108 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 109 } 110 ability_ = cameraBase_->GetCameraAbility(); 111 EXPECT_NE(ability_, nullptr); 112 common_metadata_header_t *data = ability_->get(); 113 camera_metadata_item_t entry; 114 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry); 115 EXPECT_EQ(ret, CAM_META_SUCCESS); 116 std::cout << "OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is " 117 << static_cast<int>(entry.data.u8[0]) << std::endl; 118 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN); 119} 120 121/** 122 * @tc.name: USB Camera 123 * @tc.desc: get value of OHOS_ABILITY_CAMERA_POSITION 124 * @tc.level: Level0 125 * @tc.size: MediumTest 126 * @tc.type: Function 127 */ 128TEST_F(UtestUSBCameraTest, camera_usb_0004) 129{ 130 if (!g_usbCameraExit) { 131 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 132 } 133 ability_ = cameraBase_->GetCameraAbility(); 134 EXPECT_NE(ability_, nullptr); 135 common_metadata_header_t *data = ability_->get(); 136 camera_metadata_item_t entry; 137 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry); 138 EXPECT_EQ(ret, CAM_META_SUCCESS); 139 std::cout << "OHOS_ABILITY_CAMERA_POSITION value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 140 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_FRONT); 141} 142 143/** 144 * @tc.name: USB Camera 145 * @tc.desc: get value of OHOS_ABILITY_FLASH_AVAILABLE 146 * @tc.level: Level0 147 * @tc.size: MediumTest 148 * @tc.type: Function 149 */ 150TEST_F(UtestUSBCameraTest, camera_usb_0005) 151{ 152 if (!g_usbCameraExit) { 153 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 154 } 155 ability_ = cameraBase_->GetCameraAbility(); 156 EXPECT_NE(ability_, nullptr); 157 common_metadata_header_t *data = ability_->get(); 158 camera_metadata_item_t entry; 159 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry); 160 EXPECT_EQ(ret, CAM_META_SUCCESS); 161 std::cout << "OHOS_ABILITY_FLASH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 162} 163 164/** 165 * @tc.name: USB Camera 166 * @tc.desc: get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES 167 * @tc.level: Level0 168 * @tc.size: MediumTest 169 * @tc.type: Function 170 */ 171TEST_F(UtestUSBCameraTest, camera_usb_0006) 172{ 173 if (!g_usbCameraExit) { 174 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 175 } 176 ability_ = cameraBase_->GetCameraAbility(); 177 EXPECT_NE(ability_, nullptr); 178 common_metadata_header_t *data = ability_->get(); 179 camera_metadata_item_t entry; 180 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); 181 if (ret == CAM_META_SUCCESS) { 182 for (int i = 0; i < entry.count; i++) { 183 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is " 184 << static_cast<int>(entry.data.u8[i]) << std::endl; 185 } 186 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 187 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support" << std::endl; 188 } 189} 190 191/** 192 * @tc.name: USB Camera 193 * @tc.desc: get value of OHOS_ABILITY_FLASH_MODES 194 * @tc.level: Level0 195 * @tc.size: MediumTest 196 * @tc.type: Function 197 */ 198TEST_F(UtestUSBCameraTest, camera_usb_007) 199{ 200 if (!g_usbCameraExit) { 201 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 202 } 203 ability_ = cameraBase_->GetCameraAbility(); 204 common_metadata_header_t *data = ability_->get(); 205 camera_metadata_item_t entry; 206 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry); 207 if (ret == CAM_META_SUCCESS) { 208 std::cout << "supported flash mode list:"; 209 for (int i = 0; i < entry.count; i++) { 210 std::cout << " " << static_cast<int>(entry.data.u8[i]); 211 } 212 std::cout << std::endl; 213 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 214 std::cout << "OHOS_ABILITY_FLASH_MODES is not support" << std::endl; 215 } 216} 217 218/** 219 * @tc.name: USB Camera 220 * @tc.desc: get value of OHOS_ABILITY_FOCUS_MODES 221 * @tc.level: Level0 222 * @tc.size: MediumTest 223 * @tc.type: Function 224 */ 225TEST_F(UtestUSBCameraTest, camera_usb_008) 226{ 227 if (!g_usbCameraExit) { 228 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 229 } 230 ability_ = cameraBase_->GetCameraAbility(); 231 EXPECT_NE(ability_, nullptr); 232 common_metadata_header_t *data = ability_->get(); 233 camera_metadata_item_t entry; 234 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); 235 if (ret == CAM_META_SUCCESS) { 236 std::cout << "supported focus mode list:"; 237 for (int i = 0; i < entry.count; i++) { 238 std::cout << " " << static_cast<int>(entry.data.u8[i]); 239 } 240 std::cout << std::endl; 241 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 242 std::cout << "OHOS_ABILITY_FOCUS_MODES is not support" << std::endl; 243 } 244} 245 246/** 247 * @tc.name: USB Camera 248 * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_MODES 249 * @tc.level: Level0 250 * @tc.size: MediumTest 251 * @tc.type: Function 252 */ 253TEST_F(UtestUSBCameraTest, camera_usb_009) 254{ 255 if (!g_usbCameraExit) { 256 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 257 } 258 ability_ = cameraBase_->GetCameraAbility(); 259 EXPECT_NE(ability_, nullptr); 260 common_metadata_header_t *data = ability_->get(); 261 camera_metadata_item_t entry; 262 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry); 263 if (ret == CAM_META_SUCCESS) { 264 std::cout << "supported exposure mode list:"; 265 for (int i = 0; i < entry.count; i++) { 266 std::cout << " " << static_cast<int>(entry.data.u8[i]); 267 } 268 std::cout << std::endl; 269 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 270 std::cout << "OHOS_ABILITY_EXPOSURE_MODES is not support" << std::endl; 271 } 272} 273 274/** 275 * @tc.name: USB Camera 276 * @tc.desc: get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED 277 * @tc.level: Level0 278 * @tc.size: MediumTest 279 * @tc.type: Function 280 */ 281TEST_F(UtestUSBCameraTest, camera_usb_0010) 282{ 283 if (!g_usbCameraExit) { 284 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 285 } 286 ability_ = cameraBase_->GetCameraAbility(); 287 EXPECT_NE(ability_, nullptr); 288 common_metadata_header_t *data = ability_->get(); 289 camera_metadata_item_t entry; 290 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); 291 EXPECT_EQ(ret, CAM_META_SUCCESS); 292 std::cout << "capture mirror supported is :"; 293 for (int i = 0; i < entry.count; i++) { 294 std::cout << " " << static_cast<int>(entry.data.u8[i]); 295 } 296 std::cout << std::endl; 297} 298 299/** 300 * @tc.name: USB Camera 301 * @tc.desc: get value of OHOS_ABILITY_MUTE_MODES 302 * @tc.level: Level0 303 * @tc.size: MediumTest 304 * @tc.type: Function 305 */ 306TEST_F(UtestUSBCameraTest, camera_usb_0011) 307{ 308 if (!g_usbCameraExit) { 309 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 310 } 311 ability_ = cameraBase_->GetCameraAbility(); 312 EXPECT_NE(ability_, nullptr); 313 common_metadata_header_t *data = ability_->get(); 314 camera_metadata_item_t entry; 315 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry); 316 if (ret == CAM_META_SUCCESS) { 317 std::cout << "supported mute mode is:"; 318 for (int i = 0; i < entry.count; i++) { 319 std::cout << " " << static_cast<int>(entry.data.u8[i]); 320 } 321 std::cout << std::endl; 322 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 323 std::cout << "OHOS_ABILITY_MUTE_MODES is not support" << std::endl; 324 } 325} 326 327/** 328 * @tc.name: USB Camera 329 * @tc.desc: get value of OHOS_ABILITY_FPS_RANGES 330 * @tc.level: Level0 331 * @tc.size: MediumTest 332 * @tc.type: Function 333 */ 334TEST_F(UtestUSBCameraTest, camera_usb_0012) 335{ 336 if (!g_usbCameraExit) { 337 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 338 } 339 ability_ = cameraBase_->GetCameraAbility(); 340 EXPECT_NE(ability_, nullptr); 341 common_metadata_header_t *data = ability_->get(); 342 camera_metadata_item_t entry; 343 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); 344 EXPECT_EQ(ret, CAM_META_SUCCESS); 345 std::cout << "supported fps ranges list: ["; 346 std::cout << static_cast<int>(entry.data.i32[0]) << "," << static_cast<int>(entry.data.i32[1]) << "]"; 347 std::cout << std::endl; 348} 349 350/** 351 * @tc.name: USB Camera 352 * @tc.desc: get value of OHOS_ABILITY_CAMERA_TYPE 353 * @tc.level: Level0 354 * @tc.size: MediumTest 355 * @tc.type: Function 356 */ 357TEST_F(UtestUSBCameraTest, camera_usb_0013) 358{ 359 if (!g_usbCameraExit) { 360 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 361 } 362 ability_ = cameraBase_->GetCameraAbility(); 363 EXPECT_NE(ability_, nullptr); 364 common_metadata_header_t *data = ability_->get(); 365 camera_metadata_item_t entry; 366 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry); 367 EXPECT_EQ(ret, CAM_META_SUCCESS); 368 std::cout << "OHOS_ABILITY_CAMERA_TYPE value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 369 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED); 370} 371 372/** 373 * @tc.name: USB Camera 374 * @tc.desc: get value of OHOS_JPEG_ORIENTATION 375 * @tc.level: Level0 376 * @tc.size: MediumTest 377 * @tc.type: Function 378 */ 379TEST_F(UtestUSBCameraTest, camera_usb_0014) 380{ 381 if (!g_usbCameraExit) { 382 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 383 } 384 ability_ = cameraBase_->GetCameraAbility(); 385 EXPECT_NE(ability_, nullptr); 386 common_metadata_header_t *data = ability_->get(); 387 camera_metadata_item_t entry; 388 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry); 389 EXPECT_EQ(ret, CAM_META_SUCCESS); 390 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.i32[0]) << std::endl; 391} 392 393/** 394 * @tc.name: USB Camera 395 * @tc.desc: get value of OHOS_JPEG_QUALITY 396 * @tc.level: Level0 397 * @tc.size: MediumTest 398 * @tc.type: Function 399 */ 400TEST_F(UtestUSBCameraTest, camera_usb_0015) 401{ 402 if (!g_usbCameraExit) { 403 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 404 } 405 ability_ = cameraBase_->GetCameraAbility(); 406 EXPECT_NE(ability_, nullptr); 407 common_metadata_header_t *data = ability_->get(); 408 camera_metadata_item_t entry; 409 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry); 410 EXPECT_EQ(ret, CAM_META_SUCCESS); 411 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 412} 413 414/** 415 * @tc.name: USB Camera 416 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS 417 * @tc.level: Level0 418 * @tc.size: MediumTest 419 * @tc.type: Function 420 */ 421TEST_F(UtestUSBCameraTest, camera_usb_0016) 422{ 423 if (!g_usbCameraExit) { 424 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 425 } 426 ability_ = cameraBase_->GetCameraAbility(); 427 EXPECT_NE(ability_, nullptr); 428 common_metadata_header_t *data = ability_->get(); 429 camera_metadata_item_t entry; 430 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry); 431 EXPECT_EQ(ret, CAM_META_SUCCESS); 432 std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is " 433 << static_cast<int>(entry.data.u8[0]) << std::endl; 434 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888); 435} 436 437/** 438 * @tc.name: USB Camera 439 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS 440 * @tc.level: Level0 441 * @tc.size: MediumTest 442 * @tc.type: Function 443 */ 444TEST_F(UtestUSBCameraTest, camera_usb_0017) 445{ 446 if (!g_usbCameraExit) { 447 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 448 } 449 ability_ = cameraBase_->GetCameraAbility(); 450 EXPECT_NE(ability_, nullptr); 451 common_metadata_header_t *data = ability_->get(); 452 EXPECT_NE(data, nullptr); 453 camera_metadata_item_t entry; 454 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry); 455 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) { 456 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start." << std::endl; 457 const size_t STEP = 10; // print step 458 std::cout << "count" << entry.count << std::endl; 459 for (size_t i = 0; i < entry.count; i++) { 460 std::cout << entry.data.i32[i] << " "; 461 if ((i != 0) && (i % STEP == 0 || i == entry.count - 1)) { 462 std::cout << std::endl; 463 } 464 } 465 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end." << std::endl; 466 } 467} 468 469/** 470 * @tc.name: USB Camera 471 * @tc.desc: Preview stream, expected success. 472 * @tc.level: Level0 473 * @tc.size: MediumTest 474 * @tc.type: Function 475 */ 476TEST_F(UtestUSBCameraTest, camera_usb_0018) 477{ 478 if (!g_usbCameraExit) { 479 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 480 } 481 // Get the device manager 482 cameraBase_->OpenUsbCamera(); 483 // Get the stream manager 484 cameraBase_->AchieveStreamOperator(); 485 // start stream 486 cameraBase_->intents = {PREVIEW}; 487 cameraBase_->StartStream(cameraBase_->intents); 488 // Get preview 489 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 490 // release stream 491 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 492 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 493 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 494} 495 496/** 497 * @tc.name: USB Camera 498 * @tc.desc: Preview stream, width = 1280, height = 720, expected success. 499 * @tc.level: Level0 500 * @tc.size: MediumTest 501 * @tc.type: Function 502 */ 503TEST_F(UtestUSBCameraTest, camera_usb_0019) 504{ 505 if (!g_usbCameraExit) { 506 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 507 } 508 // Get the device manager 509 cameraBase_->OpenUsbCamera(); 510 // Create and get streamOperator information 511 cameraBase_->AchieveStreamOperator(); 512 // Create data stream 513 if (cameraBase_->streamCustomerPreview_ == nullptr) { 514 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 515 } 516 OHOS::sptr<OHOS::IBufferProducer> producer = cameraBase_->streamCustomerPreview_->CreateProducer(); 517 producer->SetQueueSize(8); // 8:set bufferQueue size 518 519 std::vector<StreamInfo> streamInfos; 520 StreamInfo streamInfo = {}; 521 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 522 streamInfo.width_ = 1280; // 1280:picture width 523 streamInfo.height_ = 720; // 720:picture height 524 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 525 streamInfo.dataspace_ = 8; // 8:picture dataspace 526 streamInfo.intent_ = PREVIEW; 527 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 528 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer); 529 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 530 std::vector<StreamInfo>().swap(streamInfos); 531 streamInfos.push_back(streamInfo); 532 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 533 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 534 // Submit stream information 535 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 536 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 537 // capture 538 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 539 // release stream 540 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 541 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 542 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 543} 544 545/** 546 * @tc.name: USB Camera 547 * @tc.desc: UpdateSettings, fps. 548 * @tc.level: Level0 549 * @tc.size: MediumTest 550 * @tc.type: Function 551 */ 552TEST_F(UtestUSBCameraTest, camera_usb_0020) 553{ 554 if (!g_usbCameraExit) { 555 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 556 } 557 // Get the device manager 558 cameraBase_->OpenUsbCamera(); 559 // get the stream manager 560 cameraBase_->AchieveStreamOperator(); 561 562 // start stream 563 cameraBase_->intents = {PREVIEW}; 564 cameraBase_->StartStream(cameraBase_->intents); 565 566 // updateSettings 567 const uint32_t ITEM_CAPACITY = 100; 568 const uint32_t DATA_CAPACITY = 2000; 569 const int32_t FPS_VALUE = 10; 570 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>( 571 ITEM_CAPACITY, DATA_CAPACITY); 572 std::vector<int32_t> fpsRange; 573 fpsRange.push_back(FPS_VALUE); 574 fpsRange.push_back(FPS_VALUE); 575 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size()); 576 const int32_t DEVICE_STREAM_ID = 0; 577 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1); 578 std::vector<uint8_t> setting; 579 MetadataUtils::ConvertMetadataToVec(meta, setting); 580 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting); 581 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 582 583 // get preview 584 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 585 586 // release stream 587 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 588 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 589 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 590} 591 592/** 593 * @tc.name: USB Camera 594 * @tc.desc: USB Camera, OnCameraStatus and OnCameraEvent. 595 * @tc.level: Level0 596 * @tc.size: MediumTest 597 * @tc.type: Function 598 */ 599TEST_F(UtestUSBCameraTest, camera_usb_0021) 600{ 601 uint32_t rc = 0; 602 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl; 603 std::vector<std::string> cameraIds; 604 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl; 605 cameraBase_->cameraHost->GetCameraIds(cameraIds); 606 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl; 607 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl; 608 for (const auto &cameraId : cameraIds) { 609 std::cout << "==========[test log] cameraId = " << cameraId << std::endl; 610 } 611 const int count = 4; 612 for (int i = 0; i < count; i++) { 613 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 3s..."<< std::endl; 614 sleep(3); // judging add or delete the usb camera, wait for 3s. 615 } 616 std::cout << "==========[test log] 3. check the cameraID again... wait for 3s..."<< std::endl; 617 sleep(3); // checking the cameraID again, wait for 3s. 618 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl; 619 if (cameraIds.size() == 1) { 620 cameraIds.clear(); 621 } 622 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds); 623 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR); 624 for (const auto &cameraId : cameraIds) { 625 std::cout << "cameraId = " << cameraId << std::endl; 626 } 627 // 1:number of connected cameras 628 g_usbCameraExit = cameraIds.size() > 1; 629} 630 631/** 632 * @tc.name: USB Camera 633 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true. 634 * @tc.level: Level0 635 * @tc.size: MediumTest 636 * @tc.type: Function 637 */ 638TEST_F(UtestUSBCameraTest, camera_usb_0022) 639{ 640 // Get the device manager 641 cameraBase_->OpenUsbCamera(); 642 if (!g_usbCameraExit) { 643 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 644 } 645 // Get the stream manager 646 cameraBase_->AchieveStreamOperator(); 647 // start stream 648 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 649 cameraBase_->StartStream(cameraBase_->intents); 650 // Get preview 651 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 652 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 653 // release stream 654 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 655 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 656 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 657} 658 659/** 660 * @tc.name: USB Camera 661 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success. 662 * @tc.level: Level0 663 * @tc.size: MediumTest 664 * @tc.type: Function 665 */ 666TEST_F(UtestUSBCameraTest, camera_usb_0023) 667{ 668 cameraBase_->OpenUsbCamera(); 669 if (!g_usbCameraExit) { 670 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 671 } 672 cameraBase_->AchieveStreamOperator(); 673 if (cameraBase_->streamCustomerPreview_ == nullptr) { 674 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 675 } 676 std::vector<StreamInfo> streamInfos; 677 StreamInfo streamInfo = {}; 678 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 679 streamInfo.width_ = 1280; // 1280:picture width 680 streamInfo.height_ = 720; // 720:picture height 681 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 682 streamInfo.dataspace_ = 8; // 8:picture dataspace 683 streamInfo.intent_ = PREVIEW; 684 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 685 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 686 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 687 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 688 streamInfos.push_back(streamInfo); 689 if (cameraBase_->streamCustomerCapture_ == nullptr) { 690 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>(); 691 } 692 StreamInfo streamInfoCapture = {}; 693 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE; 694 streamInfoCapture.width_ = 1280; // 1280:picture width 695 streamInfoCapture.height_ = 720; // 720:picture height 696 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888; 697 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace 698 streamInfoCapture.intent_ = STILL_CAPTURE; 699 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG; 700 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode 701 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable( 702 cameraBase_->streamCustomerCapture_->CreateProducer()); 703 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr); 704 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 705 streamInfos.push_back(streamInfoCapture); 706 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 707 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 708 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 709 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 710 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 711 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 712 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 713 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 714 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 715} 716 717/** 718 * @tc.name: preview and capture 719 * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true. 720 * @tc.level: Level0 721 * @tc.size: MediumTest 722 * @tc.type: Function 723 */ 724TEST_F(UtestUSBCameraTest, camera_usb_0024) 725{ 726 // Get the device manager 727 cameraBase_->OpenUsbCamera(); 728 if (!g_usbCameraExit) { 729 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 730 } 731 // Get the stream manager 732 cameraBase_->AchieveStreamOperator(); 733 std::vector<int32_t> jpegOrientationVector; 734 jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270); 735 cameraBase_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(), 736 jpegOrientationVector.size()); 737 cameraBase_->ability_.clear(); 738 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_); 739 // start stream 740 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 741 cameraBase_->StartStream(cameraBase_->intents); 742 743 // Get preview 744 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 745 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 746 // release stream 747 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 748 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 749 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 750} 751 752/** 753 * @tc.name: preview and capture 754 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true. 755 * @tc.level: Level0 756 * @tc.size: MediumTest 757 * @tc.type: Function 758 */ 759TEST_F(UtestUSBCameraTest, camera_usb_0025) 760{ 761 // Get the device manager 762 cameraBase_->OpenUsbCamera(); 763 if (!g_usbCameraExit) { 764 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 765 } 766 // Get the stream manager 767 cameraBase_->AchieveStreamOperator(); 768 std::vector<int32_t> jpegQualityVector; 769 jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW); 770 cameraBase_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size()); 771 cameraBase_->ability_.clear(); 772 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_); 773 // start stream 774 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 775 cameraBase_->StartStream(cameraBase_->intents); 776 777 // Get preview 778 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 779 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 780 // release stream 781 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 782 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 783 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 784} 785 786/** 787 * @tc.name: Video 788 * @tc.desc: Preview + video, commit together, success. 789 * @tc.level: Level0 790 * @tc.size: MediumTest 791 * @tc.type: Function 792 */ 793TEST_F(UtestUSBCameraTest, camera_usb_0026) 794{ 795 // Get the device manager 796 cameraBase_->OpenUsbCamera(); 797 if (!g_usbCameraExit) { 798 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 799 } 800 // Create and get streamOperator information 801 cameraBase_->AchieveStreamOperator(); 802 // start stream 803 cameraBase_->intents = {PREVIEW, VIDEO}; 804 cameraBase_->StartStream(cameraBase_->intents); 805 // Get preview 806 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 807 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 808 809 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 810 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 811 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 812} 813 814/** 815 * @tc.name: USB Camera 816 * @tc.desc: Preview stream, width = 1280, height = 720, expected success. 817 * @tc.level: Level0 818 * @tc.size: MediumTest 819 * @tc.type: Function 820 */ 821TEST_F(UtestUSBCameraTest, camera_usb_0027) 822{ 823 cameraBase_->OpenUsbCamera(); 824 if (!g_usbCameraExit) { 825 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 826 } 827 cameraBase_->AchieveStreamOperator(); 828 if (cameraBase_->streamCustomerPreview_ == nullptr) { 829 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 830 } 831 std::vector<StreamInfo> streamInfos; 832 StreamInfo streamInfo = {}; 833 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 834 streamInfo.width_ = 1280; // 1280:picture width 835 streamInfo.height_ = 720; // 720:picture height 836 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 837 streamInfo.dataspace_ = 8; // 8:picture dataspace 838 streamInfo.intent_ = PREVIEW; 839 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 840 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 841 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 842 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 843 streamInfos.push_back(streamInfo); 844 if (cameraBase_->streamCustomerVideo_ == nullptr) { 845 cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>(); 846 } 847 StreamInfo streamInfoVideo = {}; 848 streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO; 849 streamInfoVideo.width_ = 1280; // 1280:picture width 850 streamInfoVideo.height_ = 720; // 720:picture height 851 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888; 852 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace 853 streamInfoVideo.intent_ = VIDEO; 854 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264; 855 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode 856 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer()); 857 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr); 858 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 859 streamInfos.push_back(streamInfoVideo); 860 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 861 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 862 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 863 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 864 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 865 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 866 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 867 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 868 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 869} 870 871/** 872 * @tc.name: USB Camera 873 * @tc.desc: UpdateSettings, fps. 874 * @tc.level: Level0 875 * @tc.size: MediumTest 876 * @tc.type: Function 877 */ 878TEST_F(UtestUSBCameraTest, camera_usb_0028) 879{ 880 // Get the device manager 881 cameraBase_->OpenUsbCamera(); 882 if (!g_usbCameraExit) { 883 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 884 } 885 // get the stream manager 886 cameraBase_->AchieveStreamOperator(); 887 888 // start stream 889 cameraBase_->intents = {PREVIEW, VIDEO}; 890 cameraBase_->StartStream(cameraBase_->intents); 891 892 // updateSettings 893 const uint32_t ITEM_CAPACITY = 100; 894 const uint32_t DATA_CAPACITY = 2000; 895 const int32_t FPS_VALUE = 10; 896 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>( 897 ITEM_CAPACITY, DATA_CAPACITY); 898 std::vector<int32_t> fpsRange; 899 fpsRange.push_back(FPS_VALUE); 900 fpsRange.push_back(FPS_VALUE); 901 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size()); 902 const int32_t DEVICE_STREAM_ID = 0; 903 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1); 904 std::vector<uint8_t> setting; 905 MetadataUtils::ConvertMetadataToVec(meta, setting); 906 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting); 907 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 908 909 // get preview 910 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 911 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 912 913 // release stream 914 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 915 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 916 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 917} 918 919/** 920 * @tc.name: USB Camera 921 * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true. 922 * @tc.level: Level0 923 * @tc.size: MediumTest 924 * @tc.type: Function 925 */ 926TEST_F(UtestUSBCameraTest, camera_usb_0029) 927{ 928 // Get the device manager 929 cameraBase_->OpenUsbCamera(); 930 if (!g_usbCameraExit) { 931 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 932 } 933 // Get the stream manager 934 cameraBase_->AchieveStreamOperator(); 935 // start stream 936 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO}; 937 cameraBase_->StartStream(cameraBase_->intents); 938 // Get preview 939 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 940 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 941 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 942 // release stream 943 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE, 944 cameraBase_->CAPTURE_ID_VIDEO}; 945 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE, 946 cameraBase_->STREAM_ID_VIDEO}; 947 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 948} 949 950/** 951 * @tc.name: USB Camera 952 * @tc.desc: get value of OHOS_SENSOR_ORIENTATION 953 * @tc.level: Level0 954 * @tc.size: MediumTest 955 * @tc.type: Function 956 */ 957TEST_F(UtestUSBCameraTest, camera_usb_0030) 958{ 959 if (!g_usbCameraExit) { 960 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 961 } 962 ability_ = cameraBase_->GetCameraAbility(); 963 EXPECT_NE(ability_, nullptr); 964 common_metadata_header_t *data = ability_->get(); 965 camera_metadata_item_t entry; 966 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry); 967 EXPECT_EQ(ret, CAM_META_SUCCESS); 968 std::cout << "OHOS_SENSOR_ORIENTATION value is " << entry.data.i32[0] << std::endl; 969 EXPECT_TRUE(entry.data.i32[0] == 0); 970} 971 972/** 973 * @tc.name: USB Camera 974 * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH 975 * @tc.level: Level0 976 * @tc.size: MediumTest 977 * @tc.type: Function 978 */ 979TEST_F(UtestUSBCameraTest, camera_usb_0031) 980{ 981 if (!g_usbCameraExit) { 982 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 983 } 984 ability_ = cameraBase_->GetCameraAbility(); 985 EXPECT_NE(ability_, nullptr); 986 common_metadata_header_t *data = ability_->get(); 987 camera_metadata_item_t entry; 988 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry); 989 if (ret == CAM_META_SUCCESS) { 990 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl; 991 std::cout << "log focal length value: " << entry.data.f[0] << std::endl; 992 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 993 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl; 994 } 995} 996 997/** 998 * @tc.name: USB Camera 999 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true. 1000 * @tc.level: Level0 1001 * @tc.size: MediumTest 1002 * @tc.type: Function 1003 */ 1004TEST_F(UtestUSBCameraTest, camera_usb_0032) 1005{ 1006 // Get the device manager 1007 std::vector<std::string> usbCameraIds; 1008 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1009 // 1:number of connected cameras 1010 g_usbCameraExit = usbCameraIds.size() > 1; 1011 for (int i = 0; i < usbCameraIds.size(); i++) { 1012 if (!g_usbCameraExit) { 1013 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1014 } 1015 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]); 1016 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR); 1017 // Get the stream manager 1018 cameraBase_->AchieveStreamOperator(); 1019 // start stream 1020 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 1021 cameraBase_->StartStream(cameraBase_->intents); 1022 // Get preview 1023 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1024 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1025 // release stream 1026 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 1027 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 1028 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1029 } 1030} 1031 1032/** 1033 * @tc.name: USB Camera 1034 * @tc.desc: Open the capture stream for both cameras at the same time. 1035 * @tc.level: Level0 1036 * @tc.size: MediumTest 1037 * @tc.type: Function 1038 */ 1039TEST_F(UtestUSBCameraTest, camera_usb_0033) 1040{ 1041 // Get the device manager 1042 std::vector<std::string> usbCameraIds; 1043 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1044 // 1:number of connected cameras 1045 g_usbCameraExit = usbCameraIds.size() > 1; 1046 for (int i = 0; i < usbCameraIds.size(); i++) { 1047 if (!g_usbCameraExit) { 1048 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1049 } 1050 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]); 1051 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR); 1052 // Get the stream manager 1053 cameraBase_->AchieveStreamOperator(); 1054 // start stream 1055 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO}; 1056 cameraBase_->StartStream(cameraBase_->intents); 1057 // Get preview 1058 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1059 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1060 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 1061 // release stream 1062 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE, 1063 cameraBase_->CAPTURE_ID_VIDEO}; 1064 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE, 1065 cameraBase_->STREAM_ID_VIDEO}; 1066 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1067 } 1068} 1069 1070/** 1071 * @tc.name: USB Camera 1072 * @tc.desc: One camera starts capturing and the other camera starts recording. 1073 * @tc.level: Level0 1074 * @tc.size: MediumTest 1075 * @tc.type: Function 1076 */ 1077TEST_F(UtestUSBCameraTest, camera_usb_0034) 1078{ 1079 // Get the device manager 1080 std::vector<std::string> usbCameraIds; 1081 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1082 // 1:number of connected cameras 1083 g_usbCameraExit = usbCameraIds.size() > 1; 1084 if (!g_usbCameraExit) { 1085 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1086 } 1087 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); 1088 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR); 1089 // Get the stream manager 1090 cameraBase_->AchieveStreamOperator(); 1091 // start stream 1092 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 1093 cameraBase_->StartStream(cameraBase_->intents); 1094 // Get preview 1095 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1096 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1097 // release stream 1098 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 1099 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 1100 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1101 1102 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[1]); 1103 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR); 1104 // Get the stream manager 1105 cameraBase_->AchieveStreamOperator(); 1106 // start stream 1107 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO}; 1108 cameraBase_->StartStream(cameraBase_->intents); 1109 // Get preview 1110 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1111 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1112 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 1113 // release stream 1114 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE, 1115 cameraBase_->CAPTURE_ID_VIDEO}; 1116 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE, 1117 cameraBase_->STREAM_ID_VIDEO}; 1118 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1119} 1120 1121/** 1122 * @tc.name: USB Camera 1123 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_ZOOM_RATIO_RANGE 1124 * @tc.level: Level0 1125 * @tc.size: MediumTest 1126 * @tc.type: Function 1127 */ 1128TEST_F(UtestUSBCameraTest, camera_usb_0035) 1129{ 1130 // Get the device manager 1131 std::vector<std::string> usbCameraIds; 1132 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1133 // 1:number of connected cameras 1134 g_usbCameraExit = usbCameraIds.size() > 1; 1135 for (int i = 0; i < usbCameraIds.size(); i++) { 1136 if (!g_usbCameraExit) { 1137 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1138 } 1139 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1140 EXPECT_NE(ability_, nullptr); 1141 common_metadata_header_t *data = ability_->get(); 1142 camera_metadata_item_t entry; 1143 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry); 1144 if (ret == CAM_META_SUCCESS) { 1145 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE: count is %{public}d ", entry.count); 1146 CAMERA_LOGD("Zoom ratio range: [%{public}d,[%{public}d]", entry.data.f[0], entry.data.f[1]); 1147 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1148 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE is not support"); 1149 } 1150 } 1151} 1152 1153/** 1154 * @tc.name: USB Camera 1155 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_AVAILABLE 1156 * @tc.level: Level0 1157 * @tc.size: MediumTest 1158 * @tc.type: Function 1159 */ 1160TEST_F(UtestUSBCameraTest, camera_usb_0036) 1161{ 1162 // Get the device manager 1163 std::vector<std::string> usbCameraIds; 1164 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1165 // 1:number of connected cameras 1166 g_usbCameraExit = usbCameraIds.size() > 1; 1167 for (int i = 0; i < usbCameraIds.size(); i++) { 1168 if (!g_usbCameraExit) { 1169 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1170 } 1171 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1172 EXPECT_NE(ability_, nullptr); 1173 common_metadata_header_t *data = ability_->get(); 1174 camera_metadata_item_t entry; 1175 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry); 1176 EXPECT_EQ(ret, CAM_META_SUCCESS); 1177 CAMERA_LOGD("OHOS_ABILITY_FLASH_AVAILABLE value is %{public}d", entry.data.u8[0]); 1178 } 1179} 1180 1181/** 1182 * @tc.name: USB Camera 1183 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES 1184 * @tc.level: Level0 1185 * @tc.size: MediumTest 1186 * @tc.type: Function 1187 */ 1188TEST_F(UtestUSBCameraTest, camera_usb_0037) 1189{ 1190 // Get the device manager 1191 std::vector<std::string> usbCameraIds; 1192 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1193 // 1:number of connected cameras 1194 g_usbCameraExit = usbCameraIds.size() > 1; 1195 for (int i = 0; i < usbCameraIds.size(); i++) { 1196 if (!g_usbCameraExit) { 1197 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1198 } 1199 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1200 EXPECT_NE(ability_, nullptr); 1201 common_metadata_header_t *data = ability_->get(); 1202 camera_metadata_item_t entry; 1203 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); 1204 if (ret == CAM_META_SUCCESS) { 1205 for (int i = 0; i < entry.count; i++) { 1206 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is %{public}d", entry.data.u8[i]); 1207 } 1208 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1209 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support"); 1210 } 1211 } 1212} 1213 1214/** 1215 * @tc.name: USB Camera 1216 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_MODES 1217 * @tc.level: Level0 1218 * @tc.size: MediumTest 1219 * @tc.type: Function 1220 */ 1221TEST_F(UtestUSBCameraTest, camera_usb_0038) 1222{ 1223 // Get the device manager 1224 std::vector<std::string> usbCameraIds; 1225 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1226 // 1:number of connected cameras 1227 g_usbCameraExit = usbCameraIds.size() > 1; 1228 for (int i = 0; i < usbCameraIds.size(); i++) { 1229 if (!g_usbCameraExit) { 1230 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1231 } 1232 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1233 common_metadata_header_t *data = ability_->get(); 1234 camera_metadata_item_t entry; 1235 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry); 1236 if (ret == CAM_META_SUCCESS) { 1237 CAMERA_LOGD("supported flash mode list:"); 1238 for (int i = 0; i < entry.count; i++) { 1239 CAMERA_LOGD("%{public}d", entry.data.u8[i]); 1240 } 1241 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1242 CAMERA_LOGD("OHOS_ABILITY_FLASH_MODES is not support"); 1243 } 1244 } 1245} 1246 1247/** 1248 * @tc.name: USB Camera 1249 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCUS_MODES 1250 * @tc.level: Level0 1251 * @tc.size: MediumTest 1252 * @tc.type: Function 1253 */ 1254TEST_F(UtestUSBCameraTest, camera_usb_0039) 1255{ 1256 // Get the device manager 1257 std::vector<std::string> usbCameraIds; 1258 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1259 // 1:number of connected cameras 1260 g_usbCameraExit = usbCameraIds.size() > 1; 1261 for (int i = 0; i < usbCameraIds.size(); i++) { 1262 if (!g_usbCameraExit) { 1263 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1264 } 1265 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1266 EXPECT_NE(ability_, nullptr); 1267 common_metadata_header_t *data = ability_->get(); 1268 camera_metadata_item_t entry; 1269 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); 1270 if (ret == CAM_META_SUCCESS) { 1271 CAMERA_LOGD("supported flash mode list:"); 1272 for (int i = 0; i < entry.count; i++) { 1273 CAMERA_LOGD("%{public}d", entry.data.u8[i]); 1274 } 1275 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1276 CAMERA_LOGD("OHOS_ABILITY_FOCUS_MODES is not support"); 1277 } 1278 } 1279} 1280 1281/** 1282 * @tc.name: USB Camera 1283 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_EXPOSURE_MODES 1284 * @tc.level: Level0 1285 * @tc.size: MediumTest 1286 * @tc.type: Function 1287 */ 1288TEST_F(UtestUSBCameraTest, camera_usb_0040) 1289{ 1290 // Get the device manager 1291 std::vector<std::string> usbCameraIds; 1292 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1293 // 1:number of connected cameras 1294 g_usbCameraExit = usbCameraIds.size() > 1; 1295 for (int i = 0; i < usbCameraIds.size(); i++) { 1296 if (!g_usbCameraExit) { 1297 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1298 } 1299 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1300 EXPECT_NE(ability_, nullptr); 1301 common_metadata_header_t *data = ability_->get(); 1302 camera_metadata_item_t entry; 1303 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry); 1304 if (ret == CAM_META_SUCCESS) { 1305 CAMERA_LOGD("supported flash mode list:"); 1306 for (int i = 0; i < entry.count; i++) { 1307 CAMERA_LOGD("%{public}d ", entry.data.u8[i]); 1308 } 1309 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1310 CAMERA_LOGD("OHOS_ABILITY_EXPOSURE_MODES is not support"); 1311 } 1312 } 1313} 1314 1315/** 1316 * @tc.name: USB Camera 1317 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED 1318 * @tc.level: Level0 1319 * @tc.size: MediumTest 1320 * @tc.type: Function 1321 */ 1322TEST_F(UtestUSBCameraTest, camera_usb_0041) 1323{ 1324 // Get the device manager 1325 std::vector<std::string> usbCameraIds; 1326 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1327 // 1:number of connected cameras 1328 g_usbCameraExit = usbCameraIds.size() > 1; 1329 for (int i = 0; i < usbCameraIds.size(); i++) { 1330 if (!g_usbCameraExit) { 1331 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1332 } 1333 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1334 EXPECT_NE(ability_, nullptr); 1335 common_metadata_header_t *data = ability_->get(); 1336 camera_metadata_item_t entry; 1337 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); 1338 EXPECT_EQ(ret, CAM_META_SUCCESS); 1339 CAMERA_LOGD("capture mirror supported is :"); 1340 for (int i = 0; i < entry.count; i++) { 1341 CAMERA_LOGD("%{public}d", entry.data.u8[i]); 1342 } 1343 } 1344} 1345 1346/** 1347 * @tc.name: USB Camera 1348 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_MUTE_MODES 1349 * @tc.level: Level0 1350 * @tc.size: MediumTest 1351 * @tc.type: Function 1352 */ 1353TEST_F(UtestUSBCameraTest, camera_usb_0042) 1354{ 1355 // Get the device manager 1356 std::vector<std::string> usbCameraIds; 1357 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1358 // 1:number of connected cameras 1359 g_usbCameraExit = usbCameraIds.size() > 1; 1360 for (int i = 0; i < usbCameraIds.size(); i++) { 1361 if (!g_usbCameraExit) { 1362 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1363 } 1364 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1365 EXPECT_NE(ability_, nullptr); 1366 common_metadata_header_t *data = ability_->get(); 1367 camera_metadata_item_t entry; 1368 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry); 1369 if (ret == CAM_META_SUCCESS) { 1370 CAMERA_LOGD("supported flash mode list:"); 1371 for (int i = 0; i < entry.count; i++) { 1372 CAMERA_LOGD("%{public}d", entry.data.u8[i]); 1373 } 1374 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1375 CAMERA_LOGD("OHOS_ABILITY_MUTE_MODES is not support"); 1376 } 1377 } 1378} 1379 1380/** 1381 * @tc.name: USB Camera 1382 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FPS_RANGES 1383 * @tc.level: Level0 1384 * @tc.size: MediumTest 1385 * @tc.type: Function 1386 */ 1387TEST_F(UtestUSBCameraTest, camera_usb_0043) 1388{ 1389 // Get the device manager 1390 std::vector<std::string> usbCameraIds; 1391 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1392 // 1:number of connected cameras 1393 g_usbCameraExit = usbCameraIds.size() > 1; 1394 for (int i = 0; i < usbCameraIds.size(); i++) { 1395 if (!g_usbCameraExit) { 1396 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1397 } 1398 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1399 EXPECT_NE(ability_, nullptr); 1400 common_metadata_header_t *data = ability_->get(); 1401 camera_metadata_item_t entry; 1402 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); 1403 EXPECT_EQ(ret, CAM_META_SUCCESS); 1404 CAMERA_LOGD("supported fps ranges list: [ %{public}d, %{public}d ]", entry.data.i32[0], entry.data.i32[1]); 1405 } 1406} 1407 1408/** 1409 * @tc.name: USB Camera 1410 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_ORIENTATION 1411 * @tc.level: Level0 1412 * @tc.size: MediumTest 1413 * @tc.type: Function 1414 */ 1415TEST_F(UtestUSBCameraTest, camera_usb_0044) 1416{ 1417 // Get the device manager 1418 std::vector<std::string> usbCameraIds; 1419 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1420 // 1:number of connected cameras 1421 g_usbCameraExit = usbCameraIds.size() > 1; 1422 for (int i = 0; i < usbCameraIds.size(); i++) { 1423 if (!g_usbCameraExit) { 1424 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1425 } 1426 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1427 EXPECT_NE(ability_, nullptr); 1428 common_metadata_header_t *data = ability_->get(); 1429 camera_metadata_item_t entry; 1430 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry); 1431 EXPECT_EQ(ret, CAM_META_SUCCESS); 1432 CAMERA_LOGD("OHOS_JPEG_ORIENTATION value is %{public}d", entry.data.i32[0]); 1433 } 1434} 1435 1436/** 1437 * @tc.name: USB Camera 1438 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_QUALITY 1439 * @tc.level: Level0 1440 * @tc.size: MediumTest 1441 * @tc.type: Function 1442 */ 1443TEST_F(UtestUSBCameraTest, camera_usb_0045) 1444{ 1445 // Get the device manager 1446 std::vector<std::string> usbCameraIds; 1447 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1448 // 1:number of connected cameras 1449 g_usbCameraExit = usbCameraIds.size() > 1; 1450 for (int i = 0; i < usbCameraIds.size(); i++) { 1451 if (!g_usbCameraExit) { 1452 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1453 } 1454 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1455 EXPECT_NE(ability_, nullptr); 1456 common_metadata_header_t *data = ability_->get(); 1457 camera_metadata_item_t entry; 1458 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry); 1459 EXPECT_EQ(ret, CAM_META_SUCCESS); 1460 CAMERA_LOGD("OHOS_JPEG_QUALITY value is %{public}d", entry.data.i32[0]); 1461 } 1462} 1463 1464/** 1465 * @tc.name: USB Camera 1466 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS 1467 * @tc.level: Level0 1468 * @tc.size: MediumTest 1469 * @tc.type: Function 1470 */ 1471TEST_F(UtestUSBCameraTest, camera_usb_0046) 1472{ 1473 // Get the device manager 1474 std::vector<std::string> usbCameraIds; 1475 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1476 // 1:number of connected cameras 1477 g_usbCameraExit = usbCameraIds.size() > 1; 1478 for (int i = 0; i < usbCameraIds.size(); i++) { 1479 if (!g_usbCameraExit) { 1480 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1481 } 1482 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1483 EXPECT_NE(ability_, nullptr); 1484 common_metadata_header_t *data = ability_->get(); 1485 camera_metadata_item_t entry; 1486 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry); 1487 EXPECT_EQ(ret, CAM_META_SUCCESS); 1488 CAMERA_LOGD("OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is %{public}d", entry.data.u8[0]); 1489 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888); 1490 } 1491} 1492 1493/** 1494 * @tc.name: USB Camera 1495 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS 1496 * @tc.level: Level0 1497 * @tc.size: MediumTest 1498 * @tc.type: Function 1499 */ 1500TEST_F(UtestUSBCameraTest, camera_usb_0047) 1501{ 1502 // Get the device manager 1503 std::vector<std::string> usbCameraIds; 1504 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1505 // 1:number of connected cameras 1506 g_usbCameraExit = usbCameraIds.size() > 1; 1507 for (int i = 0; i < usbCameraIds.size(); i++) { 1508 if (!g_usbCameraExit) { 1509 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1510 } 1511 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1512 EXPECT_NE(ability_, nullptr); 1513 common_metadata_header_t *data = ability_->get(); 1514 EXPECT_NE(data, nullptr); 1515 camera_metadata_item_t entry; 1516 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry); 1517 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) { 1518 CAMERA_LOGD("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start."); 1519 const size_t STEP = 10; // print step 1520 CAMERA_LOGD("count: %{public}s", entry.count); 1521 for (size_t a = 0; a < entry.count; a++) { 1522 CAMERA_LOGD("%{public}d", entry.data.i32[a]); 1523 } 1524 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end."); 1525 } 1526 } 1527} 1528 1529/** 1530 * @tc.name: USB Camera 1531 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCAL_LENGTH 1532 * @tc.level: Level0 1533 * @tc.size: MediumTest 1534 * @tc.type: Function 1535 */ 1536TEST_F(UtestUSBCameraTest, camera_usb_0048) 1537{ 1538 // Get the device manager 1539 std::vector<std::string> usbCameraIds; 1540 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1541 // 1:number of connected cameras 1542 g_usbCameraExit = usbCameraIds.size() > 1; 1543 for (int i = 0; i < usbCameraIds.size(); i++) { 1544 if (!g_usbCameraExit) { 1545 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1546 } 1547 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1548 EXPECT_NE(ability_, nullptr); 1549 common_metadata_header_t *data = ability_->get(); 1550 camera_metadata_item_t entry; 1551 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry); 1552 if (ret == CAM_META_SUCCESS) { 1553 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH: count is %{public}s", entry.count); 1554 CAMERA_LOGD("log focal length value: %{pubilc}d", entry.data.f[0]); 1555 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1556 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH is not support"); 1557 } 1558 } 1559} 1560 1561/** 1562 * @tc.name: USB Camera 1563 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_SENSOR_ORIENTATION 1564 * @tc.level: Level0 1565 * @tc.size: MediumTest 1566 * @tc.type: Function 1567 */ 1568TEST_F(UtestUSBCameraTest, camera_usb_0049) 1569{ 1570 // Get the device manager 1571 std::vector<std::string> usbCameraIds; 1572 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1573 // 1:number of connected cameras 1574 g_usbCameraExit = usbCameraIds.size() > 1; 1575 for (int i = 0; i < usbCameraIds.size(); i++) { 1576 if (!g_usbCameraExit) { 1577 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1578 } 1579 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1580 EXPECT_NE(ability_, nullptr); 1581 common_metadata_header_t *data = ability_->get(); 1582 camera_metadata_item_t entry; 1583 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry); 1584 EXPECT_EQ(ret, CAM_META_SUCCESS); 1585 CAMERA_LOGD("OHOS_SENSOR_ORIENTATION value is %{pubilc}d", entry.data.i32[0]); 1586 EXPECT_TRUE(entry.data.i32[0] == 0); 1587 } 1588} 1589 1590/** 1591 * @tc.name: USB Camera 1592 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_TYPE_UNSPECIFIED 1593 * @tc.level: Level0 1594 * @tc.size: MediumTest 1595 * @tc.type: Function 1596 */ 1597TEST_F(UtestUSBCameraTest, camera_usb_0050) 1598{ 1599 // Get the device manager 1600 std::vector<std::string> usbCameraIds; 1601 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1602 // 1:number of connected cameras 1603 g_usbCameraExit = usbCameraIds.size() > 1; 1604 for (int i = 0; i < usbCameraIds.size(); i++) { 1605 if (!g_usbCameraExit) { 1606 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1607 } 1608 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1609 EXPECT_NE(ability_, nullptr); 1610 common_metadata_header_t *data = ability_->get(); 1611 camera_metadata_item_t entry; 1612 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry); 1613 EXPECT_EQ(ret, CAM_META_SUCCESS); 1614 CAMERA_LOGD("OHOS_ABILITY_CAMERA_TYPE value is %{pubilc}d", entry.data.u8[0]); 1615 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED); 1616 } 1617} 1618 1619/** 1620 * @tc.name: USB Camera 1621 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN 1622 * @tc.level: Level0 1623 * @tc.size: MediumTest 1624 * @tc.type: Function 1625 */ 1626TEST_F(UtestUSBCameraTest, camera_usb_0051) 1627{ 1628 // Get the device manager 1629 std::vector<std::string> usbCameraIds; 1630 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1631 // 1:number of connected cameras 1632 g_usbCameraExit = usbCameraIds.size() > 1; 1633 for (int i = 0; i < usbCameraIds.size(); i++) { 1634 if (!g_usbCameraExit) { 1635 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1636 } 1637 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1638 EXPECT_NE(ability_, nullptr); 1639 common_metadata_header_t *data = ability_->get(); 1640 camera_metadata_item_t entry; 1641 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry); 1642 EXPECT_EQ(ret, CAM_META_SUCCESS); 1643 CAMERA_LOGD("OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is %{pubilc}d", entry.data.u8[0]); 1644 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN); 1645 } 1646} 1647 1648/** 1649 * @tc.name: USB Camera 1650 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_CAMERA_POSITION 1651 * @tc.level: Level0 1652 * @tc.size: MediumTest 1653 * @tc.type: Function 1654 */ 1655TEST_F(UtestUSBCameraTest, camera_usb_0052) 1656{ 1657 // Get the device manager 1658 std::vector<std::string> usbCameraIds; 1659 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1660 // 1:number of connected cameras 1661 g_usbCameraExit = usbCameraIds.size() > 1; 1662 for (int i = 0; i < usbCameraIds.size(); i++) { 1663 if (!g_usbCameraExit) { 1664 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1665 } 1666 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]); 1667 EXPECT_NE(ability_, nullptr); 1668 common_metadata_header_t *data = ability_->get(); 1669 camera_metadata_item_t entry; 1670 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry); 1671 CAMERA_LOGD("OHOS_ABILITY_CAMERA_POSITION value is %{pubilc}d", entry.data.u8[0]); 1672 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_FRONT); 1673 } 1674} 1675 1676/** 1677 * @tc.name: USB Camera 1678 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success. 1679 * @tc.level: Level0 1680 * @tc.size: MediumTest 1681 * @tc.type: Function 1682 */ 1683TEST_F(UtestUSBCameraTest, camera_usb_0053) 1684{ 1685 cameraBase_->OpenUsbCamera(); 1686 if (!g_usbCameraExit) { 1687 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1688 } 1689 cameraBase_->AchieveStreamOperator(); 1690 if (cameraBase_->streamCustomerPreview_ == nullptr) { 1691 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 1692 } 1693 std::vector<StreamInfo> streamInfos; 1694 StreamInfo streamInfo = {}; 1695 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 1696 streamInfo.width_ = 1280; // 1280:picture width 1697 streamInfo.height_ = 720; // 720:picture height 1698 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 1699 streamInfo.dataspace_ = 8; // 8:picture dataspace 1700 streamInfo.intent_ = PREVIEW; 1701 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 1702 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 1703 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 1704 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1705 streamInfos.push_back(streamInfo); 1706 if (cameraBase_->streamCustomerCapture_ == nullptr) { 1707 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>(); 1708 } 1709 StreamInfo streamInfoCapture = {}; 1710 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE; 1711 streamInfoCapture.width_ = 1280; // 1280:picture width 1712 streamInfoCapture.height_ = 720; // 720:picture height 1713 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888; 1714 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace 1715 streamInfoCapture.intent_ = STILL_CAPTURE; 1716 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG; 1717 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode 1718 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable( 1719 cameraBase_->streamCustomerCapture_->CreateProducer()); 1720 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr); 1721 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1722 streamInfos.push_back(streamInfoCapture); 1723 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 1724 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1725 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 1726 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1727 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1728 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1729 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 1730 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 1731 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1732} 1733 1734void StoreFile(const unsigned char *bufStart, const uint32_t size, const char* suffix) 1735{ 1736 static int count = 0; 1737 constexpr uint32_t pathLen = 128; 1738 char path[pathLen] = {0}; 1739 char prefix[] = "/data/"; 1740 struct timeval start = {}; 1741 gettimeofday(&start, nullptr); 1742 std::cout << "suffix = " << suffix << std::endl; 1743 if (sprintf_s(path, sizeof(path), "%sfile_%d_%lld_%s", prefix, count++, start.tv_usec, suffix) < 0) { 1744 CAMERA_LOGE("%{public}s:StoreFile sprintf failed", __func__); 1745 return; 1746 } 1747 int fd = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission 1748 if (fd < 0) { 1749 CAMERA_LOGE("demo test:StoreFile open %s %{public}s failed", path, strerror(errno)); 1750 return; 1751 } 1752 int ret = write(fd, bufStart, size); 1753 if (ret == -1) { 1754 CAMERA_LOGE("demo test:StoreFile write video file error %{public}s.....\n", strerror(errno)); 1755 } 1756 CAMERA_LOGD("demo test:StoreFile size == %{public}d\n", size); 1757 std::cout << "Strore File , Path = " << path << ", size = " << size << std::endl; 1758 close(fd); 1759} 1760 1761/** 1762 * @tc.name: USB Camera 1763 * @tc.desc: single video stream, output nv21, expected success. 1764 * @tc.level: Level0 1765 * @tc.size: MediumTest 1766 * @tc.type: Function 1767 */ 1768TEST_F(UtestUSBCameraTest, camera_usb_0054) 1769{ 1770 cameraBase_->OpenUsbCamera(); 1771 cameraBase_->AchieveStreamOperator(); 1772 auto streamCustomerVideo = std::make_shared<StreamCustomer>(); 1773 1774 uint32_t captureIdVideo = 1; 1775 uint32_t streamIdVideo = 1; 1776 std::vector<StreamInfo> streamInfos; 1777 StreamInfo streamInfo = {}; 1778 streamInfo.streamId_ = streamIdVideo; 1779 streamInfo.width_ = 1280; // 1280:picture width 1780 streamInfo.height_ = 720; // 720:picture height 1781 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; 1782 streamInfo.encodeType_ = ENCODE_TYPE_NULL; 1783 streamInfo.dataspace_ = 8; // 8:picture dataspace 1784 streamInfo.intent_ = VIDEO; 1785 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 1786 streamInfo.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo->CreateProducer()); 1787 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 1788 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1789 streamInfos.push_back(streamInfo); 1790 1791 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 1792 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1793 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 1794 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1795 1796 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1797 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) { 1798 StoreFile(addr, size, "_single_video.yuv"); 1799 }); 1800 1801 CaptureInfo captureInfoVideo = { 1802 .streamIds_ = {streamIdVideo}, 1803 .captureSetting_ = cameraBase_->ability_, 1804 .enableShutterCallback_ = false, 1805 }; 1806 std::cout << "start capture video" << std::endl; 1807 CAMERA_LOGE("start capture video"); 1808 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true); 1809 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1810 sleep(1); 1811 1812 std::cout << "cancel capture video" << std::endl; 1813 CAMERA_LOGE("cancel capture video"); 1814 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo); 1815 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1816 sleep(1); 1817 1818 std::cout << "start capture video" << std::endl; 1819 CAMERA_LOGE("start capture video"); 1820 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true); 1821 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1822 sleep(1); 1823 1824 streamCustomerVideo->ReceiveFrameOff(); 1825 1826 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo}); 1827 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1828 sleep(1); 1829 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo}); 1830 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1831} 1832 1833/** 1834 * @tc.name: USB Camera 1835 * @tc.desc: single video stream, output jpeg, expected success. 1836 * @tc.level: Level0 1837 * @tc.size: MediumTest 1838 * @tc.type: Function 1839 */ 1840TEST_F(UtestUSBCameraTest, camera_usb_0055) 1841{ 1842 cameraBase_->OpenUsbCamera(); 1843 cameraBase_->AchieveStreamOperator(); 1844 auto streamCustomerVideo = std::make_shared<StreamCustomer>(); 1845 1846 uint32_t captureIdVideo = 1; 1847 uint32_t streamIdVideo = 1; 1848 std::vector<StreamInfo> streamInfos; 1849 StreamInfo streamInfo = {}; 1850 streamInfo.streamId_ = streamIdVideo; 1851 streamInfo.width_ = 1280; // 1280:picture width 1852 streamInfo.height_ = 720; // 720:picture height 1853 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; 1854 streamInfo.encodeType_ = ENCODE_TYPE_JPEG; 1855 streamInfo.dataspace_ = 8; // 8:picture dataspace 1856 streamInfo.intent_ = VIDEO; 1857 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 1858 streamInfo.bufferQueue_ = new (std::nothrow) BufferProducerSequenceable(streamCustomerVideo->CreateProducer()); 1859 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 1860 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1861 streamInfos.push_back(streamInfo); 1862 1863 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 1864 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1865 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 1866 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1867 1868 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1869 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) { 1870 StoreFile(addr, size, "_single_video.jpeg"); 1871 }); 1872 1873 CaptureInfo captureInfoVideo = { 1874 .streamIds_ = {streamIdVideo}, 1875 .captureSetting_ = cameraBase_->ability_, 1876 .enableShutterCallback_ = false, 1877 }; 1878 std::cout << "start capture video" << std::endl; 1879 CAMERA_LOGE("start capture video"); 1880 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true); 1881 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1882 sleep(1); 1883 1884 std::cout << "cancel capture video" << std::endl; 1885 CAMERA_LOGE("cancel capture video"); 1886 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo); 1887 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1888 sleep(1); 1889 1890 std::cout << "start capture video" << std::endl; 1891 CAMERA_LOGE("start capture video"); 1892 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true); 1893 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1894 sleep(1); 1895 1896 streamCustomerVideo->ReceiveFrameOff(); 1897 1898 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo}); 1899 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1900 sleep(1); 1901 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo}); 1902 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1903}