1 /*
2 * Copyright (c) 2022-2025 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_source_encoder_test.h"
17 #include "buffer/avsharedmemorybase.h"
18 #include "iconsumer_surface.h"
19 #include "screen_source_trans.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedHardware {
SetUpTestCase(void)25 void ImageSourceEncoderTest::SetUpTestCase(void) {}
26
TearDownTestCase(void)27 void ImageSourceEncoderTest::TearDownTestCase(void) {}
28
SetUp(void)29 void ImageSourceEncoderTest::SetUp(void)
30 {
31 std::shared_ptr<IImageSourceProcessorListener> imageListener = nullptr;
32 encoder = std::make_shared<ImageSourceEncoder>(imageListener);
33 }
34
TearDown(void)35 void ImageSourceEncoderTest::TearDown(void)
36 {
37 if (encoder != nullptr) {
38 encoder->StopEncoder();
39 encoder->ReleaseEncoder();
40 }
41 }
42
43 /**
44 * @tc.name: InitDscreenDBG_001
45 * @tc.desc: Verify InitDscreenDBG when dlopen fails.
46 * @tc.type: FUNC
47 * @tc.require: Issue Number
48 */
49 HWTEST_F(ImageSourceEncoderTest, InitDscreenDBG_001, TestSize.Level1)
50 {
51 encoder->InitDscreenDBG();
52 EXPECT_EQ(encoder->pHandler_, nullptr);
53 }
54
55 /**
56 * @tc.name: ConfigureEncoder_001
57 * @tc.desc: Verify the ConfigureEncoder function.
58 * @tc.type: FUNC
59 * @tc.require: Issue Number
60 */
61 HWTEST_F(ImageSourceEncoderTest, ConfigureEncoder_001, TestSize.Level1)
62 {
63 VideoParam configParam;
64 configParam.SetCodecType(2);
65 int32_t actual = encoder->ConfigureEncoder(configParam);
66 EXPECT_EQ(ERR_DH_SCREEN_TRANS_CREATE_CODEC_FAILED, actual);
67 }
68
69 /**
70 * @tc.name: ConfigureEncoder_002
71 * @tc.desc: Verify the ConfigureEncoder function.
72 * @tc.type: FUNC
73 * @tc.require: Issue Number
74 */
75 HWTEST_F(ImageSourceEncoderTest, ConfigureEncoder_002, TestSize.Level1)
76 {
77 VideoParam configParam;
78 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
79 int32_t actual = encoder->ConfigureEncoder(configParam);
80 EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, actual);
81 }
82
83 /**
84 * @tc.name: ConfigureEncoder_003
85 * @tc.desc: Verify the ConfigureEncoder function.
86 * @tc.type: FUNC
87 * @tc.require: Issue Number
88 */
89
90 HWTEST_F(ImageSourceEncoderTest, ConfigureEncoder_004, TestSize.Level1)
91 {
92 VideoParam configParam;
93 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
94 configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
95 configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
96
97 int32_t actual = encoder->ConfigureEncoder(configParam);
98 EXPECT_EQ(DH_SUCCESS, actual);
99 }
100
101 /**
102 * @tc.name: ReleaseEncoder_001
103 * @tc.desc: Verify the ReleaseEncoder function.
104 * @tc.type: FUNC
105 * @tc.require: Issue Number
106 */
107 HWTEST_F(ImageSourceEncoderTest, ReleaseEncoder_001, TestSize.Level1)
108 {
109 int32_t actual = encoder->ReleaseEncoder();
110 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
111 }
112
113 /**
114 * @tc.name: ReleaseEncoder_002
115 * @tc.desc: Verify the ReleaseEncoder function.
116 * @tc.type: FUNC
117 * @tc.require: Issue Number
118 */
119 HWTEST_F(ImageSourceEncoderTest, ReleaseEncoder_002, TestSize.Level1)
120 {
121 encoder->videoEncoder_ = MediaAVCodec::VideoEncoderFactory::CreateByMime(
122 std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC));
123
124 int32_t actual = encoder->ReleaseEncoder();
125 EXPECT_EQ(DH_SUCCESS, actual);
126 }
127
128 /**
129 * @tc.name: StartEncoder_001
130 * @tc.desc: Verify the StartEncoder function.
131 * @tc.type: FUNC
132 * @tc.require: Issue Number
133 */
134 HWTEST_F(ImageSourceEncoderTest, StartEncoder_001, TestSize.Level1)
135 {
136 int32_t actual = encoder->StartEncoder();
137 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
138 }
139
140 /**
141 * @tc.name: StartEncoder_002
142 * @tc.desc: Verify the StartEncoder function.
143 * @tc.type: FUNC
144 * @tc.require: Issue Number
145 */
146 HWTEST_F(ImageSourceEncoderTest, StartEncoder_002, TestSize.Level1)
147 {
148 encoder->videoEncoder_ = MediaAVCodec::VideoEncoderFactory::CreateByMime(
149 std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC));
150 int32_t actual = encoder->StartEncoder();
151 EXPECT_EQ(ERR_DH_SCREEN_CODEC_START_FAILED, actual);
152 }
153
154 /**
155 * @tc.name: StopEncoder_001
156 * @tc.desc: Verify the StopEncoder function.
157 * @tc.type: FUNC
158 * @tc.require: Issue Number
159 */
160 HWTEST_F(ImageSourceEncoderTest, StopEncoder_001, TestSize.Level1)
161 {
162 int32_t actual = encoder->StopEncoder();
163 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
164 }
165
166 /**
167 * @tc.name: StopEncoder_002
168 * @tc.desc: Verify the StartEncoder function.
169 * @tc.type: FUNC
170 * @tc.require: Issue Number
171 */
172 HWTEST_F(ImageSourceEncoderTest, StopEncoder_002, TestSize.Level1)
173 {
174 encoder->videoEncoder_ = MediaAVCodec::VideoEncoderFactory::CreateByMime(
175 std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC));
176
177 int32_t actual = encoder->StopEncoder();
178 EXPECT_EQ(ERR_DH_SCREEN_CODEC_STOP_FAILED, actual);
179 }
180
181 /**
182 * @tc.name: InitVideoEncoder_001
183 * @tc.desc: Verify the InitVideoEncoder function.
184 * @tc.type: FUNC
185 * @tc.require: Issue Number
186 */
187 HWTEST_F(ImageSourceEncoderTest, InitVideoEncoder_001, TestSize.Level1)
188 {
189 VideoParam configParam;
190 configParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
191
192 int32_t actual = encoder->InitVideoEncoder(configParam);
193 EXPECT_EQ(DH_SUCCESS, actual);
194 }
195
196 /**
197 * @tc.name: InitVideoEncoder_002
198 * @tc.desc: Verify the InitVideoEncoder function.
199 * @tc.type: FUNC
200 * @tc.require: Issue Number
201 */
202 HWTEST_F(ImageSourceEncoderTest, InitVideoEncoder_002, TestSize.Level1)
203 {
204 VideoParam configParam;
205 configParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4;
206
207 int32_t actual = encoder->InitVideoEncoder(configParam);
208 EXPECT_EQ(ERR_DH_SCREEN_TRANS_CREATE_CODEC_FAILED, actual);
209 }
210
211 /**
212 * @tc.name: InitVideoEncoder_003
213 * @tc.desc: Verify the InitVideoEncoder function.
214 * @tc.type: FUNC
215 * @tc.require: Issue Number
216 */
217 HWTEST_F(ImageSourceEncoderTest, InitVideoEncoder_003, TestSize.Level1)
218 {
219 VideoParam configParam;
220 configParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265;
221
222 int32_t actual = encoder->InitVideoEncoder(configParam);
223 EXPECT_EQ(DH_SUCCESS, actual);
224 }
225
226 /**
227 * @tc.name: InitVideoEncoder_004
228 * @tc.desc: Verify the InitVideoEncoder function.
229 * @tc.type: FUNC
230 * @tc.require: Issue Number
231 */
232 HWTEST_F(ImageSourceEncoderTest, InitVideoEncoder_004, TestSize.Level1)
233 {
234 VideoParam configParam;
235 configParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
236
237 int32_t actual = encoder->InitVideoEncoder(configParam);
238 EXPECT_EQ(DH_SUCCESS, actual);
239 }
240
241 /**
242 * @tc.name: SetEncoderFormat_001
243 * @tc.desc: Verify the SetEncoderFormat function.
244 * @tc.type: FUNC
245 * @tc.require: Issue Number
246 */
247 HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_001, TestSize.Level1)
248 {
249 VideoParam configParam;
250 int32_t actual = encoder->SetEncoderFormat(configParam);
251 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
252 }
253
254 /**
255 * @tc.name: SetEncoderFormat_002
256 * @tc.desc: Verify the SetEncoderFormat function.
257 * @tc.type: FUNC
258 * @tc.require: Issue Number
259 */
260 HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_002, TestSize.Level1)
261 {
262 VideoParam configParam;
263 configParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264;
264 int32_t actual = encoder->InitVideoEncoder(configParam);
265 configParam.codecType_ = -1;
266 actual = encoder->SetEncoderFormat(configParam);
267 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
268 }
269
270 /**
271 * @tc.name: SetEncoderFormat_003
272 * @tc.desc: Verify the SetEncoderFormat function.
273 * @tc.type: FUNC
274 * @tc.require: Issue Number
275 */
276 HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_003, TestSize.Level1)
277 {
278 VideoParam configParam;
279 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
280 configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
281 configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
282 int32_t actual = encoder->InitVideoEncoder(configParam);
283 actual = encoder->SetEncoderFormat(configParam);
284
285 EXPECT_EQ(DH_SUCCESS, actual);
286 }
287
288 /**
289 * @tc.name: SetEncoderFormat_004
290 * @tc.desc: Verify the SetEncoderFormat function.
291 * @tc.type: FUNC
292 * @tc.require: Issue Number
293 */
294 HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_004, TestSize.Level1)
295 {
296 VideoParam configParam;
297 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H265);
298 configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
299 configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
300 int32_t actual = encoder->InitVideoEncoder(configParam);
301 actual = encoder->SetEncoderFormat(configParam);
302
303 EXPECT_EQ(DH_SUCCESS, actual);
304 }
305
306 /**
307 * @tc.name: SetEncoderFormat_007
308 * @tc.desc: Verify the SetEncoderFormat function.
309 * @tc.type: FUNC
310 * @tc.require: Issue Number
311 */
312 HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_007, TestSize.Level1)
313 {
314 VideoParam configParam;
315 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H265);
316 configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
317 configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
318 int32_t actual = encoder->InitVideoEncoder(configParam);
319 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_MPEG4);
320 actual = encoder->SetEncoderFormat(configParam);
321 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual);
322 }
323
324 /**
325 * @tc.name: GetInputSurface_001
326 * @tc.desc: Verify the GetInputSurface function.
327 * @tc.type: FUNC
328 * @tc.require: Issue Number
329 */
330 HWTEST_F(ImageSourceEncoderTest, GetInputSurface_001, TestSize.Level1)
331 {
332 encoder->configParam_.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H265);
333 encoder->configParam_.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
334 encoder->configParam_.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
335 encoder->configParam_.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_MPEG4);
336 encoder->configParam_.SetPartialRefreshFlag(true);
337 encoder->producerSurface_ = IConsumerSurface::Create();
338 EXPECT_EQ(encoder->GetInputSurface(), encoder->producerSurface_);
339 }
340
341 /**
342 * @tc.name: FeedEncoderData_001
343 * @tc.desc: Verify the FeedEncoderData function.
344 * @tc.type: FUNC
345 * @tc.require: Issue Number
346 */
347 HWTEST_F(ImageSourceEncoderTest, FeedEncoderData_001, TestSize.Level1)
348 {
349 VideoParam configParam;
350 configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
351 configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH);
352 configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT);
353 int32_t ret = encoder->ConfigureEncoder(configParam);
354 ASSERT_EQ(DH_SUCCESS, ret);
355
356 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
357 ret = encoder->FeedEncoderData(buffer);
358 EXPECT_NE(DH_SUCCESS, ret);
359 }
360
361 /**
362 * @tc.name: OnOutputBufferAvailable_001
363 * @tc.desc: Verify the OnOutputBufferAvailable function with various scenarios to cover all branches.
364 * @tc.type: FUNC
365 * @tc.require: Issue Number
366 */
367 HWTEST_F(ImageSourceEncoderTest, OnOutputBufferAvailable_001, TestSize.Level1)
368 {
369 encoder->videoEncoder_ = nullptr;
370 std::shared_ptr<IImageSourceProcessorListener> listener = nullptr;
371 encoder->imageProcessorListener_ = listener;
372 MediaAVCodec::AVCodecBufferInfo info;
373 MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE;
374 std::shared_ptr<Media::AVSharedMemory> buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
375 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
376 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
377 encoder->OnError(MediaAVCodec::AVCODEC_ERROR_EXTEND_START, 0);
378
379 std::shared_ptr<ScreenSourceTrans> trans = std::make_shared<ScreenSourceTrans>();
380 encoder->imageProcessorListener_ = trans;
381 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
382 EXPECT_EQ(trans->dataQueue_.size(), 0);
383
384 encoder->videoEncoder_ = MediaAVCodec::VideoEncoderFactory::CreateByMime(
385 std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC));
386 buffer = nullptr;
387 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
388 EXPECT_EQ(trans->dataQueue_.size(), 0);
389
390 info.size = 0;
391 buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
392 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
393 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
394 EXPECT_EQ(trans->dataQueue_.size(), 0);
395
396 info.size = DATA_BUFFER_MAX_SIZE + 1;
397 buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
398 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
399 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
400 EXPECT_EQ(trans->dataQueue_.size(), 0);
401
402 info.size = 100;
403 buffer = Media::AVSharedMemoryBase::CreateFromLocal(0,
404 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
405 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
406 EXPECT_EQ(trans->dataQueue_.size(), 0);
407
408 info.size = 100;
409 buffer = Media::AVSharedMemoryBase::CreateFromLocal(100,
410 Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
411 encoder->videoEncoder_ = nullptr;
412 encoder->OnOutputBufferAvailable(0, info, flag, buffer);
413 EXPECT_EQ(trans->dataQueue_.size(), 0);
414 }
415 } // DistributedHardware
416 } // OHOS