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