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
17using namespace testing::ext;
18
19void CameraVideoTest::SetUpTestCase(void)
20{}
21void CameraVideoTest::TearDownTestCase(void)
22{}
23void CameraVideoTest::SetUp(void)
24{
25    if (cameraBase_ == nullptr)
26    cameraBase_ = std::make_shared<TestCameraBase>();
27    cameraBase_->Init();
28}
29void CameraVideoTest::TearDown(void)
30{
31    cameraBase_->Close();
32}
33
34void 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    ASSERT_NE(streamInfo.bufferQueue_, nullptr);
63    streamInfo.bufferQueue_->producer_->SetQueueSize(BUFFER_QUEUE_SIZE);
64}
65
66void 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
98void 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}
108void 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
145void CameraVideoTest::StopStream(std::vector<int> &captureIds, std::vector<int> &streamIds)
146{
147    constexpr uint32_t TIME_FOR_RECEIVE_FRAME_OFF = 1;
148    constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 2;
149    sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
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(TIME_FOR_RECEIVE_FRAME_OFF);
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(TIME_FOR_WAIT_IMAGE_PREVIEW);
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(TIME_FOR_RECEIVE_FRAME_OFF);
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  */
185HWTEST_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  */
209HWTEST_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  */
255HWTEST_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  */
298HWTEST_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  */
341HWTEST_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  */
365HWTEST_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  */
391HWTEST_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  */
420HWTEST_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  */
474HWTEST_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  */
519HWTEST_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 */
568HWTEST_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 TIME_FOR_WAIT_INIT_CAPTUREIDS = 5;
604    sleep(TIME_FOR_WAIT_INIT_CAPTUREIDS);
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}