1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "camera_video_test.h"
16
17 using namespace testing::ext;
18
SetUpTestCase(void)19 void CameraVideoTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void CameraVideoTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void CameraVideoTest::SetUp(void)
24 {
25 if (display_ == nullptr)
26 display_ = std::make_shared<TestDisplay>();
27 display_->Init();
28 }
TearDown(void)29 void CameraVideoTest::TearDown(void)
30 {
31 display_->Close();
32 }
33
SetStreamInfo(StreamInfo & streamInfo,const std::shared_ptr<StreamCustomer> & streamCustomer,const int streamId,const StreamIntent intent)34 void CameraVideoTest::SetStreamInfo(StreamInfo &streamInfo, const std::shared_ptr<StreamCustomer> &streamCustomer,
35 const int streamId, const StreamIntent intent)
36 {
37 sptr<OHOS::IBufferProducer> producer;
38 constexpr uint32_t DATA_SPACE = 8;
39 constexpr uint32_t TUNNEL_MODE = 5;
40 constexpr uint32_t BUFFER_QUEUE_SIZE = 8;
41 constexpr uint32_t WIDTH = 1280;
42 constexpr uint32_t HEIGHT = 960;
43 if (intent == PREVIEW) {
44 streamInfo.width_ = PREVIEW_WIDTH;
45 streamInfo.height_ = PREVIEW_HEIGHT;
46 } else if (intent == STILL_CAPTURE) {
47 streamInfo.width_ = WIDTH;
48 streamInfo.height_ = HEIGHT;
49 streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
50 } else if (intent == VIDEO) {
51 streamInfo.width_ = WIDTH;
52 streamInfo.height_ = HEIGHT;
53 streamInfo.encodeType_ = ENCODE_TYPE_H264;
54 }
55 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
56 streamInfo.streamId_ = streamId;
57 streamInfo.dataspace_ = DATA_SPACE;
58 streamInfo.intent_ = intent;
59 streamInfo.tunneledMode_ = TUNNEL_MODE;
60 producer = streamCustomer->CreateProducer();
61 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
62 streamInfo.bufferQueue_->producer_->SetQueueSize(BUFFER_QUEUE_SIZE);
63 }
64
CreateStream(int streamId,StreamIntent intent)65 void CameraVideoTest::CreateStream(int streamId, StreamIntent intent)
66 {
67 StreamInfo streamInfo = {};
68 if (intent == PREVIEW) {
69 if (streamId == display_->STREAM_ID_PREVIEW) {
70 if (streamCustomerPreview_ == nullptr) {
71 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
72 SetStreamInfo(streamInfo, streamCustomerPreview_, streamId, intent);
73 }
74 }
75 } else if (intent == STILL_CAPTURE) {
76 if (streamCustomerSnapshot_ == nullptr) {
77 streamCustomerSnapshot_ = std::make_shared<StreamCustomer>();
78 SetStreamInfo(streamInfo, streamCustomerSnapshot_, streamId, intent);
79 }
80 } else if (intent == VIDEO) {
81 if (streamCustomerVideo_ == nullptr) {
82 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
83 SetStreamInfo(streamInfo, streamCustomerVideo_, streamId, intent);
84 }
85 }
86 std::vector<StreamInfo>().swap(streamInfos_);
87 streamInfos_.push_back(streamInfo);
88 CamRetCode result = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos_);
89 EXPECT_EQ(false, result != HDI::Camera::V1_0::NO_ERROR);
90 if (result == HDI::Camera::V1_0::NO_ERROR) {
91 std::cout << "==========[test log]CreateStreams success." << std::endl;
92 } else {
93 std::cout << "==========[test log]CreateStreams fail, result = " << result << std::endl;
94 }
95 }
96
CommitStream()97 void CameraVideoTest::CommitStream()
98 {
99 CamRetCode result = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
100 EXPECT_EQ(false, result != HDI::Camera::V1_0::NO_ERROR);
101 if (result == HDI::Camera::V1_0::NO_ERROR) {
102 std::cout << "==========[test log]CommitStreams success." << std::endl;
103 } else {
104 std::cout << "==========[test log]CommitStreams fail, result = " << result << std::endl;
105 }
106 }
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming,const CaptureInfo captureInfo)107 void CameraVideoTest::StartCapture(
108 int streamId, int captureId, bool shutterCallback, bool isStreaming, const CaptureInfo captureInfo)
109 {
110 captureInfo_.streamIds_ = {streamId};
111 captureInfo_.captureSetting_ = display_->ability_;
112 captureInfo_.enableShutterCallback_ = shutterCallback;
113 CamRetCode result;
114 if (captureInfo.captureSetting_.size() != 0) {
115 result = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
116 } else {
117 result = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo_, isStreaming);
118 }
119
120 EXPECT_EQ(true, result == HDI::Camera::V1_0::NO_ERROR);
121 if (result == HDI::Camera::V1_0::NO_ERROR) {
122 std::cout << "==========[test log]check Capture: Capture success, " << captureId << std::endl;
123 } else {
124 std::cout << "==========[test log]check Capture: Capture fail, result = " << result << captureId << std::endl;
125 }
126
127 if (captureId == display_->CAPTURE_ID_PREVIEW) {
128 streamCustomerPreview_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
129 std::cout << "==========[test log]preview size= " << size << std::endl;
130 });
131 } else if (captureId == display_->CAPTURE_ID_CAPTURE) {
132 streamCustomerSnapshot_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
133 std::cout << "==========[test log]snapshot size= " << size << std::endl;
134 });
135 } else if (captureId == display_->CAPTURE_ID_VIDEO) {
136 streamCustomerVideo_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
137 std::cout << "==========[test log]videosize= " << size << std::endl;
138 });
139 } else {
140 std::cout << "==========[test log]StartCapture ignore command " << std::endl;
141 }
142 }
143
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)144 void CameraVideoTest::StopStream(std::vector<int> &captureIds, std::vector<int> &streamIds)
145 {
146 constexpr uint32_t TIME_FOR_RECEIVE_FRAME_OFF = 1;
147 constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 2;
148 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
149 if (sizeof(captureIds) > 0) {
150 for (const auto &captureId : captureIds) {
151 if (captureId == display_->CAPTURE_ID_PREVIEW) {
152 streamCustomerPreview_->ReceiveFrameOff();
153 } else if (captureId == display_->CAPTURE_ID_CAPTURE) {
154 streamCustomerSnapshot_->ReceiveFrameOff();
155 } else if (captureId == display_->CAPTURE_ID_VIDEO) {
156 streamCustomerVideo_->ReceiveFrameOff();
157 sleep(TIME_FOR_RECEIVE_FRAME_OFF);
158 } else {
159 std::cout << "==========[test log]StopStream ignore command. " << std::endl;
160 }
161 }
162
163 for (auto &captureId : captureIds) {
164 CamRetCode result = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
165 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
166 EXPECT_EQ(true, result == HDI::Camera::V1_0::NO_ERROR);
167 if (result == HDI::Camera::V1_0::NO_ERROR) {
168 std::cout << "==========[test log]check Capture: CancelCapture success," << captureId << std::endl;
169 } else {
170 std::cout << "==========[test log]check Capture: CancelCapture fail, result = " << result;
171 std::cout << "captureId = " << captureId << std::endl;
172 }
173 }
174 }
175 sleep(TIME_FOR_RECEIVE_FRAME_OFF);
176 }
177 /**
178 * @tc.name: Video
179 * @tc.desc: Preview + video, commit together, success.
180 * @tc.level: Level1
181 * @tc.size: MediumTest
182 * @tc.type: Function
183 */
184 HWTEST_F(CameraVideoTest, camera_video_001, TestSize.Level1)
185 {
186 std::cout << "==========[test log] 1 Preview + video, commit together, success." << std::endl;
187 // Create and get streamOperator information
188 display_->AchieveStreamOperator();
189 // start stream
190 display_->intents = {PREVIEW, VIDEO};
191 display_->StartStream(display_->intents);
192 // Get preview
193 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
194 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
195
196 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
197 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
198 display_->StopStream(display_->captureIds, display_->streamIds);
199 }
200
201 /**
202 * @tc.name: Video
203 * @tc.desc: Preview + video, commit together, set 3A, success.
204 * @tc.level: Level1
205 * @tc.size: MediumTest
206 * @tc.type: Function
207 */
208 HWTEST_F(CameraVideoTest, camera_video_002, TestSize.Level1)
209 {
210 std::cout << "==========[test log] Preview + video, commit together, set 3A, success." << std::endl;
211 // Create and get streamOperator information
212 display_->AchieveStreamOperator();
213
214 // start stream
215 display_->intents = {PREVIEW, VIDEO};
216 display_->StartStream(display_->intents);
217 // Get preview
218 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
219 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
220 // Issue 3A parameters to increase exposure
221 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 2000);
222 int32_t expo = 0xa0;
223 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
224 std::vector<uint8_t> setting;
225 MetadataUtils::ConvertMetadataToVec(meta, setting);
226 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
227 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
228 std::cout << "==========[test log] UpdateSettings success, for 5s." << std::endl;
229 } else {
230 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
231 }
232 sleep(3);
233
234 // release stream
235 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
236 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
237 display_->StopStream(display_->captureIds, display_->streamIds);
238 }
239
240 /**
241 * @tc.name: Video
242 * @tc.desc: Preview + video, commit together, then close device, and preview + video again.
243 * @tc.level: Level1
244 * @tc.size: MediumTest
245 * @tc.type: Function
246 */
247 HWTEST_F(CameraVideoTest, camera_video_003, TestSize.Level1)
248 {
249 std::cout << "==========[test log] Preview + video, commit together, then close device,";
250 std::cout << "and preview + video again." << std::endl;
251 // Create and get streamOperator information
252 display_->AchieveStreamOperator();
253 // start stream
254 display_->intents = {PREVIEW, VIDEO};
255 display_->StartStream(display_->intents);
256 // Get preview
257 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
258 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
259 // release stream
260 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
261 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
262 display_->StopStream(display_->captureIds, display_->streamIds);
263
264 // Turn off the device
265 display_->Close();
266 // Turn on the device
267 display_->Init();
268 std::cout << "==========[test log] The 2nd time." << std::endl;
269
270 // Create and get streamOperator information
271 display_->AchieveStreamOperator();
272 // start stream
273 display_->intents = {PREVIEW, VIDEO};
274 display_->StartStream(display_->intents);
275 // Get preview
276 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
277 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
278 // release stream
279 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
280 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
281 display_->StopStream(display_->captureIds, display_->streamIds);
282 }
283
284 /**
285 * @tc.name: Video
286 * @tc.desc: Preview + video, commit together, then close device, and preview + capture.
287 * @tc.level: Level1
288 * @tc.size: MediumTest
289 * @tc.type: Function
290 */
291 HWTEST_F(CameraVideoTest, camera_video_004, TestSize.Level1)
292 {
293 std::cout << "==========[test log] Preview + video, commit together, then close device,";
294 std::cout << "and preview + capture." << std::endl;
295 // Create and get streamOperator information
296 display_->AchieveStreamOperator();
297 // start stream
298 display_->intents = {PREVIEW, VIDEO};
299 display_->StartStream(display_->intents);
300 // Get preview
301 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
302 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
303 // release stream
304 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
305 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
306 display_->StopStream(display_->captureIds, display_->streamIds);
307
308 // Turn off the device
309 display_->Close();
310 std::cout << "==========[test log] cameraDevice->Close" << std::endl;
311 // Turn on the device
312 display_->Init();
313
314 // Create and get streamOperator information
315 display_->AchieveStreamOperator();
316 // start stream
317 display_->intents = {PREVIEW, STILL_CAPTURE};
318 display_->StartStream(display_->intents);
319 // Get preview
320 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
321 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
322 // release stream
323 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
324 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
325 display_->StopStream(display_->captureIds, display_->streamIds);
326 }
327
328 /**
329 * @tc.name: Video
330 * @tc.desc: Preview + video, commit together, success.
331 * @tc.level: Level1
332 * @tc.size: MediumTest
333 * @tc.type: Function
334 */
335 HWTEST_F(CameraVideoTest, camera_video_005, TestSize.Level1)
336 {
337 std::cout << "==========[test log] 1 Preview + video, commit together, success." << std::endl;
338 // Create and get streamOperator information
339 display_->AchieveStreamOperator();
340 // start stream
341 display_->intents = {PREVIEW, VIDEO};
342 display_->StartStream(display_->intents);
343 // Get preview
344 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
345 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
346 // release stream
347 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
348 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
349 display_->StopStream(display_->captureIds, display_->streamIds);
350 }
351
352 /**
353 * @tc.name: Video
354 * @tc.desc: Video start&stop, for 5 times, success.
355 * @tc.level: Level2
356 * @tc.size: MediumTest
357 * @tc.type: Function
358 */
359 HWTEST_F(CameraVideoTest, camera_video_010, TestSize.Level2)
360 {
361 std::cout << "==========[test log] Video start&stop, for 5 times, success." << std::endl;
362 // Create and get streamOperator information
363 display_->AchieveStreamOperator();
364 for (int i = 0; i < 5; i++) {
365 // start stream
366 display_->intents = {PREVIEW, VIDEO};
367 display_->StartStream(display_->intents);
368 // Get preview
369 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
370 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
371 // release stream
372 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
373 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
374 display_->StopStream(display_->captureIds, display_->streamIds);
375 }
376 }
377
378 /**
379 * @tc.name: Video
380 * @tc.desc: Video start&stop, for 5 times, success.
381 * @tc.level: Level2
382 * @tc.size: MediumTest
383 * @tc.type: Function
384 */
385 HWTEST_F(CameraVideoTest, camera_video_011, TestSize.Level2)
386 {
387 std::cout << "==========[test log] Video start&stop, for 5 times, success." << std::endl;
388 // Create and get streamOperator information
389 display_->AchieveStreamOperator();
390 for (int i = 0; i < 5; i++) {
391 // start stream
392 display_->intents = {PREVIEW, VIDEO};
393 display_->StartStream(display_->intents);
394
395 // Start capture preview
396 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
397 // Start capture recording
398 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
399
400 // post-processing
401 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
402 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
403 display_->StopStream(display_->captureIds, display_->streamIds);
404 }
405 }
406
407 /**
408 * @tc.name: Video
409 * @tc.desc: Dynamic Video mode, preview, success.
410 * @tc.level: Level2
411 * @tc.size: MediumTest
412 * @tc.type: Function
413 */
414 HWTEST_F(CameraVideoTest, camera_video_020, TestSize.Level2)
415 {
416 std::cout << "==========[test log] Video mode, preview, success." << std::endl;
417 // Create and get streamOperator information
418 display_->AchieveStreamOperator();
419 // Create data stream
420 display_->intents = {PREVIEW};
421 display_->StartStream(display_->intents);
422 // capture
423 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
424 // Create video stream
425 display_->intents = {VIDEO};
426 display_->StartStream(display_->intents);
427 // Start capture preview
428 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
429 // Start capture recording
430 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
431
432 // post-processing
433 display_->streamCustomerPreview_->ReceiveFrameOff();
434 display_->streamCustomerVideo_->ReceiveFrameOff();
435 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_VIDEO);
436 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
437 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
438 std::cout << "==========[test log] CancelCapture success, captureId = ";
439 std::cout << display_->CAPTURE_ID_VIDEO << std::endl;
440 } else {
441 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
442 }
443 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_PREVIEW);
444 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
445 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
446 std::cout << "==========[test log] CancelCapture success, captureId = ";
447 std::cout << display_->CAPTURE_ID_PREVIEW << std::endl;
448 } else {
449 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
450 }
451 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
452 {display_->STREAM_ID_VIDEO});
453 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
454 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
455 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
456 } else {
457 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
458 }
459 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
460 {display_->STREAM_ID_PREVIEW});
461 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
462 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
463 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
464 } else {
465 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
466 }
467 }
468
469 /**
470 * @tc.name: Video
471 * @tc.desc: Video mode, preview, set 3A, success.
472 * @tc.level: Level1
473 * @tc.size: MediumTest
474 * @tc.type: Function
475 */
476 HWTEST_F(CameraVideoTest, camera_video_021, TestSize.Level1)
477 {
478 std::cout << "==========[test log] Video mode, preview, set 3A, success." << std::endl;
479 EXPECT_EQ(true, display_->cameraDevice != nullptr);
480 display_->AchieveStreamOperator();
481 // start stream
482 display_->intents = {PREVIEW, VIDEO};
483 display_->StartStream(display_->intents);
484 // capture
485 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
486 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
487 // Issue 3A parameters to increase exposure
488 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 2000);
489 int32_t expo = 0xa0;
490 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
491 std::vector<uint8_t> setting;
492 MetadataUtils::ConvertMetadataToVec(meta, setting);
493 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
494 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
495 std::cout << "==========[test log] UpdateSettings success, for 5s." << std::endl;
496 } else {
497 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
498 }
499 sleep(3);
500
501 // post-processing
502 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
503 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
504 display_->StopStream(display_->captureIds, display_->streamIds);
505 }
506
507 /**
508 * @tc.name: Video
509 * @tc.desc: Video mode without preview, system not support, expected return fail.
510 * @tc.level: Level2
511 * @tc.size: MediumTest
512 * @tc.type: Function
513 */
514 HWTEST_F(CameraVideoTest, camera_video_030, TestSize.Level2)
515 {
516 std::cout << "==========[test log] Video mode without preview, system not support,";
517 std::cout << "expected return fail." << std::endl;
518
519 EXPECT_EQ(true, display_->cameraDevice != nullptr);
520 display_->AchieveStreamOperator();
521 // Create video stream
522 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
523 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
524 producer->SetQueueSize(8); // 8:set bufferQueue size
525 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
526 std::cout << "~~~~~~~" << std::endl;
527 }
528
529 std::vector<StreamInfo> streamInfos;
530 display_->streamInfo.streamId_ = display_->STREAM_ID_VIDEO;
531 display_->streamInfo.width_ = 1280; // 1280:picture width
532 display_->streamInfo.height_ = 960; // 960:picture height
533 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
534 display_->streamInfo.dataspace_ = 10;
535 display_->streamInfo.intent_ = VIDEO;
536 display_->streamInfo.tunneledMode_ = 5; // 5:tunnel mode
537 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
538 streamInfos.push_back(display_->streamInfo);
539 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
540 EXPECT_EQ(false, display_->rc == OHOS::Camera::METHOD_NOT_SUPPORTED);
541 if (display_->rc == OHOS::Camera::METHOD_NOT_SUPPORTED) {
542 std::cout << "==========[test log] CreateStreams METHOD_NOT_SUPPORTED, streamId = ";
543 std::cout << display_->STREAM_ID_VIDEO <<", intent = VIDEO" << std::endl;
544 } else {
545 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
546 }
547 std::vector<uint8_t> modeSetting = {};
548 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, modeSetting);
549 EXPECT_EQ(false, display_->rc == HDI::Camera::V1_0::NO_ERROR);
550 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
551 std::cout << "==========[test log] CommitStreams success." << std::endl;
552 } else {
553 std::cout << "==========[test log] CommitStreams fail, rc = ." << display_->rc << std::endl;
554 }
555 }
556
557 /**
558 * @tc.name: preview, still_capture and video
559 * @tc.desc: Commit 3 streams in order, Preview, still_capture and video streams.
560 * @tc.level: Level1
561 * @tc.size: MediumTest
562 * @tc.type: Function
563 */
564 HWTEST_F(CameraVideoTest, camera_video_031, TestSize.Level1)
565 {
566 display_->AchieveStreamOperator();
567
568 CreateStream(display_->STREAM_ID_PREVIEW, PREVIEW);
569 CreateStream(display_->STREAM_ID_CAPTURE, STILL_CAPTURE);
570 CreateStream(display_->STREAM_ID_VIDEO, VIDEO);
571
572 CommitStream();
573
574 CaptureInfo captureInfo = {};
575 StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true, captureInfo);
576 StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true, captureInfo);
577
578 constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde
579 constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude
580 constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude
581
582 constexpr size_t entryCapacity = 100;
583 constexpr size_t dataCapacity = 2000;
584 std::shared_ptr<CameraSetting> captureSetting =
585 std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
586 std::vector<double> gps;
587 gps.push_back(latitude);
588 gps.push_back(longitude);
589 gps.push_back(altitude);
590 captureSetting->addEntry(OHOS_JPEG_GPS_COORDINATES, gps.data(), gps.size());
591
592 captureInfo.streamIds_ = {display_->STREAM_ID_CAPTURE};
593 std::vector<uint8_t> setting;
594 MetadataUtils::ConvertMetadataToVec(captureSetting, setting);
595 captureInfo.captureSetting_ = setting;
596 captureInfo.enableShutterCallback_ = false;
597 StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true, captureInfo);
598
599 constexpr uint32_t TIME_FOR_WAIT_INIT_CAPTUREIDS = 5;
600 sleep(TIME_FOR_WAIT_INIT_CAPTUREIDS);
601 std::vector<int> captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO,
602 display_->CAPTURE_ID_CAPTURE};
603 std::vector<int> streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO, display_->STREAM_ID_CAPTURE};
604 StopStream(captureIds, streamIds);
605 }