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: release_decoder_test_001
75 * @tc.desc: Verify the ReleaseDecoder function.
76 * @tc.type: FUNC
77 * @tc.require: Issue Number
78 */
79 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_001, TestSize.Level1)
80 {
81 EXPECT_EQ(DH_SUCCESS, imageDecoder_->ReleaseDecoder());
82 }
83
84 /**
85 * @tc.name: release_decoder_test_002
86 * @tc.desc: Verify the ReleaseDecoder function.
87 * @tc.type: FUNC
88 * @tc.require: Issue Number
89 */
90 HWTEST_F(ImageSinkDecoderTest, release_decoder_test_002, TestSize.Level1)
91 {
92 imageDecoder_->videoDecoder_ = nullptr;
93 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->ReleaseDecoder());
94 }
95
96 /**
97 * @tc.name: start_decoder_test_001
98 * @tc.desc: Verify the StartDecoder function.
99 * @tc.type: FUNC
100 * @tc.require: Issue Number
101 */
102 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_001, TestSize.Level1)
103 {
104 EXPECT_EQ(ERR_DH_SCREEN_CODEC_PREPARE_FAILED, imageDecoder_->StartDecoder());
105 }
106
107 /**
108 * @tc.name: start_decoder_test_002
109 * @tc.desc: Verify the StartDecoder function.
110 * @tc.type: FUNC
111 * @tc.require: Issue Number
112 */
113 HWTEST_F(ImageSinkDecoderTest, start_decoder_test_002, TestSize.Level1)
114 {
115 imageDecoder_->videoDecoder_ = nullptr;
116 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StartDecoder());
117 }
118
119 /**
120 * @tc.name: stop_decoder_test_001
121 * @tc.desc: Verify the StopDecoder function.
122 * @tc.type: FUNC
123 * @tc.require: Issue Number
124 */
125 HWTEST_F(ImageSinkDecoderTest, stop_decoder_test_001, TestSize.Level1)
126 {
127 imageDecoder_->videoDecoder_ = nullptr;
128 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->StopDecoder());
129 }
130
131 /**
132 * @tc.name: init_video_decoder_test_001
133 * @tc.desc: Verify the InitVideoDecoder function.
134 * @tc.type: FUNC
135 * @tc.require: Issue Number
136 */
137 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_001, TestSize.Level1)
138 {
139 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
140 }
141
142 /**
143 * @tc.name: init_video_decoder_test_002
144 * @tc.desc: Verify the InitVideoDecoder function.
145 * @tc.type: FUNC
146 * @tc.require: Issue Number
147 */
148 HWTEST_F(ImageSinkDecoderTest, init_video_decoder_test_002, TestSize.Level1)
149 {
150 param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
151 EXPECT_EQ(DH_SUCCESS, imageDecoder_->InitVideoDecoder(param_));
152 }
153
154 /**
155 * @tc.name: init_video_decoder_test_003
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_003, TestSize.Level1)
161 {
162 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
163 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->InitVideoDecoder(param_));
164 }
165
166 /**
167 * @tc.name: set_decoder_format_test_001
168 * @tc.desc: Verify the SetDecoderFormat function.
169 * @tc.type: FUNC
170 * @tc.require: Issue Number
171 */
172 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_001, TestSize.Level1)
173 {
174 EXPECT_EQ(DH_SUCCESS, imageDecoder_->SetDecoderFormat(param_));
175 }
176
177 /**
178 * @tc.name: set_decoder_format_test_002
179 * @tc.desc: Verify the SetDecoderFormat function.
180 * @tc.type: FUNC
181 * @tc.require: Issue Number
182 */
183 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_002, TestSize.Level1)
184 {
185 imageDecoder_->videoDecoder_ = nullptr;
186 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetDecoderFormat(param_));
187 }
188
189 /**
190 * @tc.name: set_decoder_format_test_003
191 * @tc.desc: Verify the SetDecoderFormat function.
192 * @tc.type: FUNC
193 * @tc.require: Issue Number
194 */
195 HWTEST_F(ImageSinkDecoderTest, set_decoder_format_test_003, TestSize.Level1)
196 {
197 param_.codecType_ = VIDEO_CODEC_TYPE_INVALID;
198 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_OPERATION, imageDecoder_->SetDecoderFormat(param_));
199 }
200
201 /**
202 * @tc.name: set_output_surface_test_001
203 * @tc.desc: Verify the SetOutputSurface function.
204 * @tc.type: FUNC
205 * @tc.require: Issue Number
206 */
207 HWTEST_F(ImageSinkDecoderTest, set_output_surface_test_001, TestSize.Level1)
208 {
209 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer("test");
210 imageDecoder_->videoDecoder_ = nullptr;
211 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, imageDecoder_->SetOutputSurface(surface));
212 }
213
214 /**
215 * @tc.name: on_error_test_001
216 * @tc.desc: Verify the OnError function.
217 * @tc.type: FUNC
218 * @tc.require: Issue Number
219 */
220 HWTEST_F(ImageSinkDecoderTest, on_error_test_001, TestSize.Level1)
221 {
222 Media::AVCodecErrorType errorType = Media::AVCODEC_ERROR_EXTEND_START;
223 int32_t errorCode = DH_SUCCESS;
224 imageDecoder_->OnError(errorType, errorCode);
225 }
226
227 /**
228 * @tc.name: on_error_test_002
229 * @tc.desc: Verify the OnError function.
230 * @tc.type: FUNC
231 * @tc.require: Issue Number
232 */
233 HWTEST_F(ImageSinkDecoderTest, on_error_test_002, TestSize.Level1)
234 {
235 Media::AVCodecErrorType errorType = Media::AVCODEC_ERROR_EXTEND_START;
236 int32_t errorCode = DH_SUCCESS;
237 std::shared_ptr<IImageSinkProcessorListener> listener= nullptr;
238 imageDecoder_->imageProcessorListener_ = listener;
239 imageDecoder_->OnError(errorType, errorCode);
240 }
241
242 /**
243 * @tc.name: on_input_buffer_available_test_001
244 * @tc.desc: Verify the OnInputBufferAvailable function.
245 * @tc.type: FUNC
246 * @tc.require: Issue Number
247 */
248 HWTEST_F(ImageSinkDecoderTest, on_input_buffer_available_test_001, TestSize.Level1)
249 {
250 uint32_t index = 0;
251 unsigned int len = 1;
252 imageDecoder_->OnInputBufferAvailable(index);
253 EXPECT_EQ(len, imageDecoder_->bufferIndexQueue_.size());
254 }
255
256 /**
257 * @tc.name: on_output_buffer_available_test_001
258 * @tc.desc: Verify the OnInputBufferAvailable function.
259 * @tc.type: FUNC
260 * @tc.require: Issue Number
261 */
262 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_001, TestSize.Level1)
263 {
264 uint32_t index = 0;
265 Media::AVCodecBufferFlag flag = Media::AVCODEC_BUFFER_FLAG_CODEC_DATA;
266 Media::AVCodecBufferInfo info;
267 info.presentationTimeUs = 1;
268
269 imageDecoder_->OnOutputBufferAvailable(index, info, flag);
270 EXPECT_EQ(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
271 }
272
273 /**
274 * @tc.name: on_output_buffer_available_test_002
275 * @tc.desc: Verify the OnInputBufferAvailable function.
276 * @tc.type: FUNC
277 * @tc.require: Issue Number
278 */
279 HWTEST_F(ImageSinkDecoderTest, on_output_buffer_available_test_002, TestSize.Level1)
280 {
281 uint32_t index = 0;
282 Media::AVCodecBufferFlag flag = Media::AVCODEC_BUFFER_FLAG_CODEC_DATA;
283 Media::AVCodecBufferInfo info;
284 info.presentationTimeUs = 1;
285 imageDecoder_->decoderBufferInfo_.presentationTimeUs = 0;
286
287 imageDecoder_->videoDecoder_ = nullptr;
288 imageDecoder_->OnOutputBufferAvailable(index, info, flag);
289 EXPECT_NE(info.presentationTimeUs, imageDecoder_->decoderBufferInfo_.presentationTimeUs);
290 }
291
292 /**
293 * @tc.name: on_output_format_changed_test_001
294 * @tc.desc: Verify the OnOutputFormatChanged function.
295 * @tc.type: FUNC
296 * @tc.require: Issue Number
297 */
298 HWTEST_F(ImageSinkDecoderTest, on_output_format_changed_test_001, TestSize.Level1)
299 {
300 Media::Format format;
301 imageDecoder_->OnOutputFormatChanged(format);
302
303 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
304 }
305
306 /**
307 * @tc.name: start_input_thread_test_001
308 * @tc.desc: Verify the StartInputThread StopInputThread function.
309 * @tc.type: FUNC
310 * @tc.require: Issue Number
311 */
312 HWTEST_F(ImageSinkDecoderTest, start_input_thread_test_001, TestSize.Level1)
313 {
314 imageDecoder_->videoDecoder_ = nullptr;
315
316 imageDecoder_->StartInputThread();
317 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
318
319 imageDecoder_->StopInputThread();
320 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
321 }
322
323 /**
324 * @tc.name: process_data_test_001
325 * @tc.desc: Verify the StartInputThread StopInputThread function.
326 * @tc.type: FUNC
327 * @tc.require: Issue Number
328 */
329 HWTEST_F(ImageSinkDecoderTest, process_data_test_001, TestSize.Level1)
330 {
331 std::shared_ptr<DataBuffer> data = std::make_shared<DataBuffer>(DATA_LEN);
332 imageDecoder_->videoDataQueue_.push(data);
333
334 uint32_t index = 0;
335 imageDecoder_->bufferIndexQueue_.push(index);
336
337 imageDecoder_->StartInputThread();
338 EXPECT_EQ(true, imageDecoder_->isDecoderReady_);
339
340 imageDecoder_->StopInputThread();
341 EXPECT_EQ(false, imageDecoder_->isDecoderReady_);
342 }
343 }
344 }