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
16 #include "image_sink_decoder_test.h"
17
18 #include <chrono>
19 #include <securec.h>
20
21 #include "dscreen_constants.h"
22 #include "dscreen_errcode.h"
23 #include "dscreen_log.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedHardware {
SetUpTestCase(void)29 void ImageSinkDecoderTest::SetUpTestCase(void) {}
30
TearDownTestCase(void)31 void ImageSinkDecoderTest::TearDownTestCase(void) {}
32
SetUp(void)33 void ImageSinkDecoderTest::SetUp(void)
34 {
35 param_.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH;
36 param_.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
37 param_.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH;
38 param_.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT;
39 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
40 param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420;
41 param_.fps_ = FPS;
42
43 imageListener_ = std::make_shared<MockIImageSinkProcessorListener>();
44 imageDecoder_ = std::make_shared<ImageSinkDecoder>(imageListener_);
45 imageDecoder_->videoDecoder_ = Media::VideoDecoderFactory::CreateByMime("video/avc");
46 }
47
TearDown(void)48 void ImageSinkDecoderTest::TearDown(void) {}
49
50 /**
51 * @tc.name: configure_decoder_test_001
52 * @tc.desc: Verify the ConfigureDecoder function.
53 * @tc.type: FUNC
54 * @tc.require: Issue Number
55 */
56 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_001, TestSize.Level1)
57 {
58 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ConfigureDecoder(param_));
59 }
60
61 /**
62 * @tc.name: configure_decoder_test_002
63 * @tc.desc: Verify the ConfigureDecoder function.
64 * @tc.type: FUNC
65 * @tc.require: Issue Number
66 */
67 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_002, TestSize.Level1)
68 {
69 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
70 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ConfigureDecoder(param_));
71 }
72
73 /**
74 * @tc.name: configure_decoder_test_003
75 * @tc.desc: Verify the ConfigureDecoder function.
76 * @tc.type: FUNC
77 * @tc.require: Issue Number
78 */
79 HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_003, TestSize.Level1)
80 {
81 param_.videoFormat_ = VIDEO_CODEC_TYPE_INVALID;
82 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->ConfigureDecoder(param_));
83 }
84
85 /**
86 * @tc.name: release_decoder_test_001
87 * @tc.desc: Verify the ReleaseDecoder function.
88 * @tc.type: FUNC
89 * @tc.require: Issue Number
90 */
91 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_001, TestSize.Level1)
92 {
93 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ReleaseDecoder());
94 }
95
96 /**
97 * @tc.name: release_decoder_test_002
98 * @tc.desc: Verify the ReleaseDecoder function.
99 * @tc.type: FUNC
100 * @tc.require: Issue Number
101 */
102 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_002, TestSize.Level1)
103 {
104 imageDecoder_->videoDecoder_ = nullptr;
105 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ReleaseDecoder());
106 }
107
108 /**
109 * @tc.name: start_decoder_test_001
110 * @tc.desc: Verify the StartDecoder function.
111 * @tc.type: FUNC
112 * @tc.require: Issue Number
113 */
114 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_001, TestSize.Level1)
115 {
116 EXPECT_EQ(ERR_DH_SCREEN_CODEC_PREPARE_FAILED, imageDecoder_->StartDecoder());
117 }
118
119 /**
120 * @tc.name: start_decoder_test_002
121 * @tc.desc: Verify the StartDecoder function.
122 * @tc.type: FUNC
123 * @tc.require: Issue Number
124 */
125 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_002, TestSize.Level1)
126 {
127 imageDecoder_->videoDecoder_ = nullptr;
128 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StartDecoder());
129 }
130
131 /**
132 * @tc.name: stop_decoder_test_001
133 * @tc.desc: Verify the StopDecoder function.
134 * @tc.type: FUNC
135 * @tc.require: Issue Number
136 */
137 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_001, TestSize.Level1)
138 {
139 imageDecoder_->videoDecoder_ = nullptr;
140 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StopDecoder());
141 }
142
143 /**
144 * @tc.name: init_video_decoder_test_001
145 * @tc.desc: Verify the InitVideoDecoder function.
146 * @tc.type: FUNC
147 * @tc.require: Issue Number
148 */
149 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_001, TestSize.Level1)
150 {
151 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
152 }
153
154 /**
155 * @tc.name: init_video_decoder_test_002
156 * @tc.desc: Verify the InitVideoDecoder function.
157 * @tc.type: FUNC
158 * @tc.require: Issue Number
159 */
160 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_002, TestSize.Level1)
161 {
162 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
163 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
164 }
165
166 /**
167 * @tc.name: init_video_decoder_test_003
168 * @tc.desc: Verify the InitVideoDecoder function.
169 * @tc.type: FUNC
170 * @tc.require: Issue Number
171 */
172 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_003, TestSize.Level1)
173 {
174 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
175 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InitVideoDecoder(param_));
176 }
177
178 /**
179 * @tc.name: init_video_decoder_test_004
180 * @tc.desc: Verify the InitVideoDecoder function.
181 * @tc.type: FUNC
182 * @tc.require: Issue Number
183 */
184 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_004, TestSize.Level1)
185 {
186 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4;
187 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
188 }
189
190 /**
191 * @tc.name: set_decoder_format_test_001
192 * @tc.desc: Verify the SetDecoderFormat function.
193 * @tc.type: FUNC
194 * @tc.require: Issue Number
195 */
196 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_001, TestSize.Level1)
197 {
198 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
199 }
200
201 /**
202 * @tc.name: set_decoder_format_test_002
203 * @tc.desc: Verify the SetDecoderFormat function.
204 * @tc.type: FUNC
205 * @tc.require: Issue Number
206 */
207 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_002, TestSize.Level1)
208 {
209 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
210 param_.videoFormat_ = VIDEO_DATA_FORMAT_NV12;
211 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
212 }
213
214 /**
215 * @tc.name: set_decoder_format_test_003
216 * @tc.desc: Verify the SetDecoderFormat function.
217 * @tc.type: FUNC
218 * @tc.require: Issue Number
219 */
220 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_003, TestSize.Level1)
221 {
222 imageDecoder_->videoDecoder_ = nullptr;
223 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetDecoderFormat(param_));
224 }
225
226 /**
227 * @tc.name: set_decoder_format_test_004
228 * @tc.desc: Verify the SetDecoderFormat function.
229 * @tc.type: FUNC
230 * @tc.require: Issue Number
231 */
232 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_004, TestSize.Level1)
233 {
234 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
235 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->SetDecoderFormat(param_));
236 }
237
238 /**
239 * @tc.name: set_decoder_format_test_005
240 * @tc.desc: Verify the SetDecoderFormat function.
241 * @tc.type: FUNC
242 * @tc.require: Issue Number
243 */
244 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_005, TestSize.Level1)
245 {
246 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
247 param_.videoFormat_ = VIDEO_CODEC_TYPE_INVALID;
248 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->SetDecoderFormat(param_));
249 }
250
251 /**
252 * @tc.name: set_decoder_format_test_006
253 * @tc.desc: Verify the SetDecoderFormat function.
254 * @tc.type: FUNC
255 * @tc.require: Issue Number
256 */
257 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_006, TestSize.Level1)
258 {
259 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4;
260 param_.videoFormat_ = VIDEO_DATA_FORMAT_NV21;
261 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
262 }
263
264 /**
265 * @tc.name: set_decoder_format_test_007
266 * @tc.desc: Verify the SetDecoderFormat function.
267 * @tc.type: FUNC
268 * @tc.require: Issue Number
269 */
270 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_007, TestSize.Level1)
271 {
272 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4;
273 param_.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888;
274 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
275 }
276
277 /**
278 * @tc.name: set_output_surface_test_001
279 * @tc.desc: Verify the SetOutputSurface function.
280 * @tc.type: FUNC
281 * @tc.require: Issue Number
282 */
283 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_001, TestSize.Level1)
284 {
285 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer("test");
286 imageDecoder_->videoDecoder_ = nullptr;
287 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(surface));
288 }
289
290 /**
291 * @tc.name: on_error_test_001
292 * @tc.desc: Verify the OnError function.
293 * @tc.type: FUNC
294 * @tc.require: Issue Number
295 */
296 HWTEST_F(ImageSinkDecoderTest, on_error_test_001, TestSize.Level1)
297 {
298 Media::AVCodecErrorType errorType = Media::AVCODEC_ERROR_EXTEND_START;
299 int32_t errorCode = DH_SUCCESS;
300 imageDecoder_->OnError(errorType, errorCode);
301 }
302
303 /**
304 * @tc.name: on_error_test_002
305 * @tc.desc: Verify the OnError function.
306 * @tc.type: FUNC
307 * @tc.require: Issue Number
308 */
309 HWTEST_F(ImageSinkDecoderTest, on_error_test_002, TestSize.Level1)
310 {
311 Media::AVCodecErrorType errorType = Media::AVCODEC_ERROR_EXTEND_START;
312 int32_t errorCode = DH_SUCCESS;
313 std::shared_ptr<IImageSinkProcessorListener> listener= nullptr;
314 imageDecoder_->imageProcessorListener_ = listener;
315 imageDecoder_->OnError(errorType, errorCode);
316 }
317
318 /**
319 * @tc.name: on_input_buffer_available_test_001
320 * @tc.desc: Verify the OnInputBufferAvailable function.
321 * @tc.type: FUNC
322 * @tc.require: Issue Number
323 */
324 HWTEST_F(ImageSinkDecoderTest, on_input_buffer_available_test_001, TestSize.Level1)
325 {
326 uint32_t index = 0;
327 unsigned int len = 1;
328 imageDecoder_->OnInputBufferAvailable(index);
329 EXPECT_EQ(len, imageDecoder_->bufferIndexQueue_.size());
330 }
331
332 /**
333 * @tc.name: on_output_buffer_available_test_001
334 * @tc.desc: Verify the OnInputBufferAvailable function.
335 * @tc.type: FUNC
336 * @tc.require: Issue Number
337 */
338 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_001, TestSize.Level1)
339 {
340 uint32_t index = 0;
341 Media::AVCodecBufferFlag flag = Media::AVCODEC_BUFFER_FLAG_CODEC_DATA;
342 Media::AVCodecBufferInfo info;
343 info.presentationTimeUs = 1;
344
345 imageDecoder_->OnOutputBufferAvailable(index, info, flag);
346 EXPECT_EQ(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
347 }
348
349 /**
350 * @tc.name: on_output_buffer_available_test_002
351 * @tc.desc: Verify the OnInputBufferAvailable function.
352 * @tc.type: FUNC
353 * @tc.require: Issue Number
354 */
355 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_002, TestSize.Level1)
356 {
357 uint32_t index = 0;
358 Media::AVCodecBufferFlag flag = Media::AVCODEC_BUFFER_FLAG_CODEC_DATA;
359 Media::AVCodecBufferInfo info;
360 info.presentationTimeUs = 1;
361 imageDecoder_->decoderBufferInfo_.presentationTimeUs = 0;
362
363 imageDecoder_->videoDecoder_ = nullptr;
364 imageDecoder_->OnOutputBufferAvailable(index, info, flag);
365 EXPECT_NE(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
366 }
367
368 /**
369 * @tc.name: on_output_format_changed_test_001
370 * @tc.desc: Verify the OnOutputFormatChanged function.
371 * @tc.type: FUNC
372 * @tc.require: Issue Number
373 */
374 HWTEST_F(ImageSinkDecoderTest, on_output_format_changed_test_001, TestSize.Level1)
375 {
376 Media::Format format;
377 imageDecoder_->OnOutputFormatChanged(format);
378
379 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
380 }
381
382 /**
383 * @tc.name: ProcessData_001
384 * @tc.desc: Verify the DecodeScreenData function.
385 * @tc.type: FUNC
386 * @tc.require: Issue Number
387 */
388 HWTEST_F(ImageSinkDecoderTest, ProcessData_001, TestSize.Level1)
389 {
390 std::shared_ptr<DataBuffer> screenData = std::make_shared<DataBuffer>(100);
391 int32_t ret = imageDecoder_->ProcessData(screenData, 0);
392 EXPECT_EQ(ERR_DH_SCREEN_CODEC_SURFACE_ERROR, ret);
393 }
394
395 /**
396 * @tc.name: start_input_thread_test_001
397 * @tc.desc: Verify the StartInputThread StopInputThread function.
398 * @tc.type: FUNC
399 * @tc.require: Issue Number
400 */
401 HWTEST_F(ImageSinkDecoderTest, start_input_thread_test_001, TestSize.Level1)
402 {
403 imageDecoder_->videoDecoder_ = nullptr;
404
405 imageDecoder_->StartInputThread();
406 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
407
408 imageDecoder_->StopInputThread();
409 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
410 }
411
412 /**
413 * @tc.name: process_data_test_001
414 * @tc.desc: Verify the StartInputThread StopInputThread function.
415 * @tc.type: FUNC
416 * @tc.require: Issue Number
417 */
418 HWTEST_F(ImageSinkDecoderTest, process_data_test_001, TestSize.Level1)
419 {
420 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(DATA_LEN);
421 imageDecoder_->videoDataQueue_.push(data);
422
423 uint32_t index = 0;
424 imageDecoder_->bufferIndexQueue_.push(index);
425
426 imageDecoder_->StartInputThread();
427 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
428
429 imageDecoder_->StopInputThread();
430 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
431 }
432 }
433 }