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