1 /*
2 * Copyright (c) 2022-2024 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 std::shared_ptr<DCameraStreamDataProcess> streamProcess3 =
95 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, static_cast<DCStreamType>(-1));
96
97 streamProcess3->FeedStream(buffer);
98 EXPECT_EQ(DCAMERA_OK, ret);
99 }
100
101 /**
102 * @tc.name: dcamera_stream_data_process_test_002
103 * @tc.desc: Verify StartCapture func.
104 * @tc.type: FUNC
105 * @tc.require: issue
106 */
107 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_002, TestSize.Level1)
108 {
109 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_002");
110 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
111 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
112 std::shared_ptr<DCameraStreamConfig> srcConfig =
113 std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
114 DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
115
116 std::set<int32_t> streamIds;
117 streamIds.insert(1);
118 streamProcess->ConfigStreams(srcConfig, streamIds);
119 streamProcess->StartCapture(srcConfig, streamIds);
120 streamProcess->StopCapture(streamIds);
121
122 std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
123 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::SNAPSHOT_FRAME);
124 streamIds.clear();
125 streamProcess->ConfigStreams(srcConfig, streamIds);
126 streamProcess->StartCapture(srcConfig, streamIds);
127 streamProcess->StopCapture(streamIds);
128 int32_t ret = streamProcess->GetProducerSize();
129 EXPECT_EQ(DCAMERA_OK, ret);
130 }
131
132 /**
133 * @tc.name: dcamera_stream_data_process_test_003
134 * @tc.desc: Verify FeedStreamToSnapShot func.
135 * @tc.type: FUNC
136 * @tc.require: issue
137 */
138 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_003, TestSize.Level1)
139 {
140 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_003");
141 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
142 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
143 size_t capacity = 1;
144 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
145
146 streamProcess->FeedStreamToSnapShot(buffer);
147 int32_t ret = streamProcess->GetProducerSize();
148 EXPECT_EQ(DCAMERA_OK, ret);
149 }
150
151 /**
152 * @tc.name: dcamera_stream_data_process_test_004
153 * @tc.desc: Verify FeedStreamToContinue func.
154 * @tc.type: FUNC
155 * @tc.require: issue
156 */
157 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_004, TestSize.Level1)
158 {
159 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_004");
160 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
161 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
162 size_t capacity = 1;
163 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
164 std::shared_ptr<DCameraStreamConfig> srcConfig =
165 std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
166 DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
167
168 std::set<int32_t> streamIds;
169 streamIds.insert(1);
170 streamProcess->ConfigStreams(srcConfig, streamIds);
171 streamProcess->StartCapture(srcConfig, streamIds);
172 streamProcess->FeedStreamToContinue(buffer);
173 streamProcess->CreatePipeline();
174 usleep(SLEEP_TIME);
175 streamProcess->FeedStreamToContinue(buffer);
176 int32_t ret = streamProcess->GetProducerSize();
177 EXPECT_NE(DCAMERA_OK, ret);
178 }
179
180 /**
181 * @tc.name: dcamera_stream_data_process_test_005
182 * @tc.desc: Verify DestroyPipeline func.
183 * @tc.type: FUNC
184 * @tc.require: issue
185 */
186 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_005, TestSize.Level1)
187 {
188 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_005");
189 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
190 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
191 streamProcess->pipeline_ = std::make_shared<DCameraPipelineSource>();
192 std::shared_ptr<DCameraStreamConfig> srcConfig =
193 std::make_shared<DCameraStreamConfig>(TEST_WIDTH, TEST_HEIGTH, TEST_FORMAT, TEST_DATASPACE,
194 DCEncodeType::ENCODE_TYPE_H264, DCStreamType::SNAPSHOT_FRAME);
195
196 std::set<int32_t> streamIds;
197 streamIds.insert(1);
198 streamProcess->ConfigStreams(srcConfig, streamIds);
199 streamProcess->CreatePipeline();
200 streamProcess->DestroyPipeline();
201 streamProcess->pipeline_ = nullptr;
202 streamProcess->DestroyPipeline();
203 int32_t ret = streamProcess->GetProducerSize();
204 EXPECT_EQ(DCAMERA_OK, ret);
205 }
206
207 /**
208 * @tc.name: dcamera_stream_data_process_test_006
209 * @tc.desc: Verify DestroyPipeline func.
210 * @tc.type: FUNC
211 * @tc.require: issue
212 */
213 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_006, TestSize.Level1)
214 {
215 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_006");
216 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
217 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
218
219 streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H264);
220 streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H265);
221 streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_NULL);
222 streamProcess->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_MPEG4_ES);
223 int32_t ret = streamProcess->GetProducerSize();
224 EXPECT_EQ(DCAMERA_OK, ret);
225 }
226
227 /**
228 * @tc.name: dcamera_stream_data_process_test_007
229 * @tc.desc: Verify DestroyPipeline func.
230 * @tc.type: FUNC
231 * @tc.require: issue
232 */
233 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_007, TestSize.Level1)
234 {
235 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_007");
236 std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
237 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
238 std::shared_ptr<DCameraStreamDataProcessPipelineListener> listener1 =
239 std::make_shared<DCameraStreamDataProcessPipelineListener>(streamProcess1);
240
241
242 size_t capacity = 1;
243 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
244 listener1->OnProcessedVideoBuffer(buffer);
245 listener1->OnError(DataProcessErrorType::ERROR_PIPELINE_ENCODER);
246
247 std::shared_ptr<DCameraStreamDataProcess> streamProcess2 = nullptr;
248 std::shared_ptr<DCameraStreamDataProcessPipelineListener> listener2 =
249 std::make_shared<DCameraStreamDataProcessPipelineListener>(streamProcess2);
250 listener2->OnProcessedVideoBuffer(buffer);
251 listener2->OnError(DataProcessErrorType::ERROR_PIPELINE_ENCODER);
252 int32_t ret = streamProcess1->GetProducerSize();
253 EXPECT_EQ(DCAMERA_OK, ret);
254 }
255
256 /**
257 * @tc.name: dcamera_stream_data_process_test_008
258 * @tc.desc: Verify GetPipelineFormat func.
259 * @tc.type: FUNC
260 * @tc.require: issue
261 */
262 HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_008, TestSize.Level1)
263 {
264 DHLOGI("DCameraStreamDataProcessTest::dcamera_stream_data_process_test_008");
265 int32_t format = OHOS_CAMERA_FORMAT_RGBA_8888;
266 std::shared_ptr<DCameraStreamDataProcess> streamProcess1 =
267 std::make_shared<DCameraStreamDataProcess>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, DCStreamType::CONTINUOUS_FRAME);
268 Videoformat ret = streamProcess1->GetPipelineFormat(format);
269 EXPECT_EQ(Videoformat::RGBA_8888, ret);
270 format = -1;
271 ret = streamProcess1->GetPipelineFormat(format);
272 EXPECT_EQ(Videoformat::NV21, ret);
273 }
274 }
275 }