1 /*
2  * Copyright (c) 2022-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 
16 #include <gtest/gtest.h>
17 
18 #define private public
19 #include "dcamera_stream_data_process.h"
20 #undef private
21 
22 #include "anonymous_string.h"
23 #include "distributed_camera_constants.h"
24 #include "distributed_camera_errno.h"
25 #include "distributed_hardware_log.h"
26 
27 #include "dcamera_pipeline_source.h"
28 #include "dcamera_stream_data_process_pipeline_listener.h"
29 
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace DistributedHardware {
34 class DCameraStreamDataProcessTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40 };
41 
42 namespace {
43 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
44 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
45 const int32_t TEST_WIDTH = 1920;
46 const int32_t TEST_HEIGTH = 1080;
47 const int32_t TEST_FORMAT = 1;
48 const int32_t TEST_DATASPACE = 1;
49 const int32_t SLEEP_TIME = 200000;
50 }
SetUpTestCase(void)51 void DCameraStreamDataProcessTest::SetUpTestCase(void)
52 {
53     DHLOGI("DCameraStreamDataProcessTest::SetUpTestCase");
54 }
55 
TearDownTestCase(void)56 void DCameraStreamDataProcessTest::TearDownTestCase(void)
57 {
58     DHLOGI("DCameraStreamDataProcessTest::TearDownTestCase");
59 }
60 
SetUp(void)61 void DCameraStreamDataProcessTest::SetUp(void)
62 {
63     DHLOGI("DCameraStreamDataProcessTest::SetUp");
64 }
65 
TearDown(void)66 void DCameraStreamDataProcessTest::TearDown(void)
67 {
68     DHLOGI("DCameraStreamDataProcessTest::TearDown");
69 }
70 
71 /**
72  * @tc.name: dcamera_stream_data_process_test_001
73  * @tc.desc: Verify FeedStream func.
74  * @tc.type: FUNC
75  * @tc.require: issue
76  */
77 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_001, TestSize.Level1)
78 {
79     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_001");
80     size_t capacity = 1;
81     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
82     std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
83         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::SNAPSHOT_FRAME);
84 
85     int32_t ret = streamProcess1->GetProducerSize();
86     streamProcess1->FeedStream(buffer);
87     EXPECT_EQ(DCAMERA_OK, ret);
88     std::shared_ptr<DCameraStreamDataProcess> streamProcess2 =
89         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
90 
91     streamProcess2->FeedStream(buffer);
92     EXPECT_EQ(DCAMERA_OK, ret);
93 }
94 
95 /**
96  * @tc.name: dcamera_stream_data_process_test_002
97  * @tc.desc: Verify StartCapture func.
98  * @tc.type: FUNC
99  * @tc.require: issue
100  */
101 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_002, TestSize.Level1)
102 {
103     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_002");
104     std::shared_ptr<DCameraStreamDataProcess> streamProcess =
105         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
106     std::shared_ptr<DCameraStreamConfig> srcConfig =
107         std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
108         DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
109 
110     std::set<int32_t> streamIds;
111     streamIds.insert(1);
112     streamProcess->ConfigStreams(srcConfig, streamIds);
113     streamProcess->StartCapture(srcConfig, streamIds);
114     int32_t ret = streamProcess->GetProducerSize();
115     EXPECT_NE(DCAMERA_OK, ret);
116 }
117 
118 /**
119  * @tc.name: dcamera_stream_data_process_test_003
120  * @tc.desc: Verify FeedStreamToSnapShot func.
121  * @tc.type: FUNC
122  * @tc.require: issue
123  */
124 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_003, TestSize.Level1)
125 {
126     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_003");
127     std::shared_ptr<DCameraStreamDataProcess> streamProcess =
128         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
129     size_t capacity = 1;
130     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
131 
132     streamProcess->FeedStreamToSnapShot(buffer);
133     int32_t ret = streamProcess->GetProducerSize();
134     EXPECT_EQ(DCAMERA_OK, ret);
135 }
136 
137 /**
138  * @tc.name: dcamera_stream_data_process_test_004
139  * @tc.desc: Verify FeedStreamToContinue func.
140  * @tc.type: FUNC
141  * @tc.require: issue
142  */
143 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_004, TestSize.Level1)
144 {
145     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_004");
146     std::shared_ptr<DCameraStreamDataProcess> streamProcess =
147         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
148     size_t capacity = 1;
149     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
150     std::shared_ptr<DCameraStreamConfig> srcConfig =
151         std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
152         DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
153 
154     std::set<int32_t> streamIds;
155     streamIds.insert(1);
156     streamProcess->ConfigStreams(srcConfig, streamIds);
157     streamProcess->StartCapture(srcConfig, streamIds);
158     streamProcess->FeedStreamToContinue(buffer);
159     streamProcess->CreatePipeline();
160     usleep(SLEEP_TIME);
161     streamProcess->FeedStreamToContinue(buffer);
162     int32_t ret = streamProcess->GetProducerSize();
163     EXPECT_NE(DCAMERA_OK, ret);
164 }
165 
166 /**
167  * @tc.name: dcamera_stream_data_process_test_005
168  * @tc.desc: Verify DestroyPipeline func.
169  * @tc.type: FUNC
170  * @tc.require: issue
171  */
172 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_005, TestSize.Level1)
173 {
174     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_005");
175     std::shared_ptr<DCameraStreamDataProcess> streamProcess =
176         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
177     streamProcess->pipeline_ = std::make_shared<DCameraPipelineSource>();
178     std::shared_ptr<DCameraStreamConfig> srcConfig =
179         std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
180         DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
181 
182     std::set<int32_t> streamIds;
183     streamIds.insert(1);
184     streamProcess->ConfigStreams(srcConfig, streamIds);
185     streamProcess->CreatePipeline();
186     streamProcess->DestroyPipeline();
187     streamProcess->pipeline_ = nullptr;
188     streamProcess->DestroyPipeline();
189     int32_t ret = streamProcess->GetProducerSize();
190     EXPECT_EQ(DCAMERA_OK, ret);
191 }
192 
193 /**
194  * @tc.name: dcamera_stream_data_process_test_006
195  * @tc.desc: Verify DestroyPipeline func.
196  * @tc.type: FUNC
197  * @tc.require: issue
198  */
199 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_006, TestSize.Level1)
200 {
201     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_006");
202     std::shared_ptr<DCameraStreamDataProcess> streamProcess =
203         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
204 
205     streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H264);
206     streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H265);
207     streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_NULL);
208     int32_t ret = streamProcess->GetProducerSize();
209     EXPECT_EQ(DCAMERA_OK, ret);
210 }
211 
212 /**
213  * @tc.name: dcamera_stream_data_process_test_007
214  * @tc.desc: Verify DestroyPipeline func.
215  * @tc.type: FUNC
216  * @tc.require: issue
217  */
218 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_007, TestSize.Level1)
219 {
220     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_007");
221     std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
222         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
223     std::shared_ptr<DCameraStreamDataProcessPipelineListener> listener1 =
224         std::make_shared<DCameraStreamDataProcessPipelineListener>(streamProcess1);
225 
226 
227     size_t capacity = 1;
228     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
229     listener1->OnProcessedVideoBuffer(buffer);
230     listener1->OnError(DataProcessErrorType::ERROR_PIPELINE_ENCODER);
231 
232     std::shared_ptr<DCameraStreamDataProcess> streamProcess2 = nullptr;
233     std::shared_ptr<DCameraStreamDataProcessPipelineListener> listener2 =
234         std::make_shared<DCameraStreamDataProcessPipelineListener>(streamProcess2);
235     listener2->OnProcessedVideoBuffer(buffer);
236     listener2->OnError(DataProcessErrorType::ERROR_PIPELINE_ENCODER);
237     int32_t ret = streamProcess1->GetProducerSize();
238     EXPECT_EQ(DCAMERA_OK, ret);
239 }
240 
241 /**
242  * @tc.name: dcamera_stream_data_process_test_008
243  * @tc.desc: Verify GetPipelineFormat func.
244  * @tc.type: FUNC
245  * @tc.require: issue
246  */
247 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_008, TestSize.Level1)
248 {
249     DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_008");
250     int32_t format = OHOS_CAMERA_FORMAT_RGBA_8888;
251     std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
252         std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
253     Videoformat ret = streamProcess1->GetPipelineFormat(format);
254     EXPECT_EQ(Videoformat::RGBA_8888, ret);
255     format = -1;
256     ret = streamProcess1->GetPipelineFormat(format);
257     EXPECT_EQ(Videoformat::NV21, ret);
258 }
259 }
260 }