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 "player_unit_test.h"
17 #include "media_errors.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Media::PlayerTestParam;
22
23 namespace OHOS {
24 namespace Media {
SetUpTestCase(void)25 void PlayerUnitTest::SetUpTestCase(void)
26 {
27 system("param set debug.media_service.histreamer 0");
28 }
29
TearDownTestCase(void)30 void PlayerUnitTest::TearDownTestCase(void)
31 {
32 system("param set debug.media_service.histreamer 0");
33 }
34
SetUp(void)35 void PlayerUnitTest::SetUp(void)
36 {
37 callback_ = std::make_shared<PlayerCallbackTest>();
38 ASSERT_NE(nullptr, callback_);
39 player_ = std::make_shared<PlayerMock>(callback_);
40 ASSERT_NE(nullptr, player_);
41 EXPECT_TRUE(player_->CreatePlayer());
42 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
43 }
44
TearDown(void)45 void PlayerUnitTest::TearDown(void)
46 {
47 if (player_ != nullptr) {
48 player_->Release();
49 }
50 }
51
PlayFunTest(const std::string & protocol)52 void PlayerUnitTest::PlayFunTest(const std::string &protocol)
53 {
54 int32_t duration = 0;
55 if (player_ != nullptr) {
56 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
57 EXPECT_EQ(MSERR_OK, player_->Play());
58 EXPECT_TRUE(player_->IsPlaying());
59 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
60 EXPECT_EQ(MSERR_OK, player_->Pause());
61 int32_t time;
62 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
63 std::vector<Format> videoTrack;
64 std::vector<Format> audioTrack;
65 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
66 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
67 PlaybackRateMode mode;
68 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
69 player_->GetPlaybackSpeed(mode);
70 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
71 EXPECT_EQ(true, player_->IsLooping());
72 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_NEXT_SYNC));
73 EXPECT_EQ(MSERR_OK, player_->Play());
74 sleep(PLAYING_TIME);
75 if (protocol == PlayerTestParam::HLS_PLAY) {
76 EXPECT_EQ(MSERR_OK, player_->SelectBitRate(200000)); // 200000:bitrate
77 sleep(PLAYING_TIME);
78 }
79 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
80 EXPECT_EQ(false, player_->IsLooping());
81 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
82 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
83 EXPECT_EQ(MSERR_OK, player_->Stop());
84 EXPECT_EQ(MSERR_OK, player_->Reset());
85 }
86 }
87
GetSetParaFunTest()88 void PlayerUnitTest::GetSetParaFunTest()
89 {
90 if (player_ != nullptr) {
91 int32_t duration = 0;
92 int32_t time = 0;
93 PlaybackRateMode mode;
94 std::vector<Format> videoTrack;
95 std::vector<Format> audioTrack;
96 player_->GetVideoTrackInfo(videoTrack);
97 player_->GetAudioTrackInfo(audioTrack);
98 player_->GetCurrentTime(time);
99 player_->GetDuration(duration);
100 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
101 player_->GetPlaybackSpeed(mode);
102 player_->SetLooping(true);
103 player_->IsLooping();
104 player_->SetVolume(1, 1);
105 }
106 }
107
108 /**
109 * @tc.name : Test Player SetSource API
110 * @tc.number: Player_SetSource_001
111 * @tc.desc : Test Player SetSource interface
112 */
113 HWTEST_F(PlayerUnitTest, Player_SetSource_001, TestSize.Level0)
114 {
115 int32_t ret = player_->SetSource(VIDEO_FILE1);
116 EXPECT_EQ(MSERR_OK, ret);
117 }
118
119 /**
120 * @tc.name : Test Player SetSource API
121 * @tc.number: Player_SetSource_002
122 * @tc.desc : Test Player SetSource interface with invalid path
123 */
124 HWTEST_F(PlayerUnitTest, Player_SetSource_002, TestSize.Level1)
125 {
126 int32_t ret = player_->SetSource(MEDIA_ROOT + "kong.mp4");
127 EXPECT_NE(MSERR_OK, ret);
128 }
129
130 /**
131 * @tc.name : Test Player SetSource API
132 * @tc.number: Player_SetSource_003
133 * @tc.desc : Test Player SetSource interface with wrong mp3
134 */
135 HWTEST_F(PlayerUnitTest, Player_SetSource_003, TestSize.Level2)
136 {
137 PlaybackRateMode mode;
138 int32_t time = 0;
139 int32_t duration = 0;
140 std::vector<Format> videoTrack;
141 std::vector<Format> audioTrack;
142 int32_t ret = player_->SetSource(MEDIA_ROOT + "1kb.mp3");
143 EXPECT_EQ(MSERR_OK, ret);
144 sptr<Surface> videoSurface = player_->GetVideoSurface();
145 ASSERT_NE(nullptr, videoSurface);
146 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
147 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
148 EXPECT_NE(MSERR_OK, player_->Prepare());
149 Format format;
150 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT);
151 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
152 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
153 EXPECT_NE(MSERR_OK, player_->Play());
154 EXPECT_EQ(false, player_->IsPlaying());
155 EXPECT_NE(MSERR_OK, player_->Pause());
156 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
157 EXPECT_NE(MSERR_OK, player_->SetLooping(true));
158 EXPECT_EQ(false, player_->IsLooping());
159 EXPECT_NE(MSERR_OK, player_->SetVolume(1, 1));
160 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
161 EXPECT_NE(MSERR_OK, player_->GetPlaybackSpeed(mode));
162 EXPECT_NE(MSERR_OK, player_->GetCurrentTime(time));
163 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
164 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
165 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
166 EXPECT_NE(480, player_->GetVideoHeight());
167 EXPECT_NE(720, player_->GetVideoWidth());
168 EXPECT_NE(MSERR_OK, player_->Stop());
169 EXPECT_EQ(MSERR_OK, player_->Reset());
170 }
171
172 /**
173 * @tc.name : Test Player SetSource API
174 * @tc.number: Player_SetSource_004
175 * @tc.desc : Test Player SetSource interface with txt
176 */
177 HWTEST_F(PlayerUnitTest, Player_SetSource_004, TestSize.Level2)
178 {
179 int32_t ret = player_->SetSource(MEDIA_ROOT + "error.mp4");
180 EXPECT_EQ(MSERR_OK, ret);
181 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
182 }
183
184 /**
185 * @tc.name : Test Player SetSource
186 * @tc.number: Player_SetSource_005
187 * @tc.desc : Test Player SetSource interface
188 */
189 HWTEST_F(PlayerUnitTest, Player_SetSource_005, TestSize.Level3)
190 {
191 PlaybackRateMode mode;
192 int32_t duration = 0;
193 std::vector<Format> videoTrack;
194 std::vector<Format> audioTrack;
195 Format format;
196 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT);
197 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
198 sptr<Surface> videoSurface = player_->GetVideoSurface();
199 ASSERT_NE(nullptr, videoSurface);
200 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
201 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
202 EXPECT_NE(MSERR_OK, player_->Prepare());
203 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
204 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
205 EXPECT_NE(MSERR_OK, player_->Play());
206 EXPECT_NE(MSERR_OK, player_->Pause());
207 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
208 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
209 EXPECT_EQ(true, player_->IsLooping());
210 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
211 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
212 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
213 EXPECT_EQ(SPEED_FORWARD_1_00_X, mode);
214 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
215 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
216 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
217 EXPECT_NE(480, player_->GetVideoHeight());
218 EXPECT_NE(720, player_->GetVideoWidth());
219 EXPECT_NE(MSERR_OK, player_->Stop());
220 EXPECT_NE(MSERR_OK, player_->Reset());
221 }
222
223 /**
224 * @tc.name : Test Player SetSource API
225 * @tc.number: Player_SetSource_001
226 * @tc.desc : Test Player SetSource interface
227 */
228 HWTEST_F(PlayerUnitTest, Player_SetSource_006, TestSize.Level2)
229 {
230 int32_t ret = player_->SetSource(VIDEO_FILE1);
231 EXPECT_EQ(MSERR_OK, ret);
232 EXPECT_EQ(MSERR_OK, player_->Reset());
233 EXPECT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
234 }
235
236 /**
237 * @tc.name : Test Player Local
238 * @tc.number: Player_Local_001
239 * @tc.desc : Test Player Local source
240 */
241 HWTEST_F(PlayerUnitTest, Player_Local_001, TestSize.Level2)
242 {
243 int32_t ret = player_->SetSource(MEDIA_ROOT + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4");
244 EXPECT_EQ(MSERR_OK, ret);
245 sptr<Surface> videoSurface = player_->GetVideoSurface();
246 ASSERT_NE(nullptr, videoSurface);
247 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
248 ret = player_->PrepareAsync();
249 if (ret == MSERR_OK) {
250 PlayFunTest(LOCAL_PLAY);
251 }
252 }
253
254 /**
255 * @tc.name : Test Player Local
256 * @tc.number: Player_Local_002
257 * @tc.desc : Test Player Local source
258 */
259 HWTEST_F(PlayerUnitTest, Player_Local_002, TestSize.Level2)
260 {
261 int32_t ret = player_->SetSource(MEDIA_ROOT + "ChineseColor_H264_AAC_480p_15fps.mp4");
262 EXPECT_EQ(MSERR_OK, ret);
263 sptr<Surface> videoSurface = player_->GetVideoSurface();
264 ASSERT_NE(nullptr, videoSurface);
265 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
266 ret = player_->PrepareAsync();
267 if (ret == MSERR_OK) {
268 PlayFunTest(LOCAL_PLAY);
269 }
270 }
271
272 /**
273 * @tc.name : Test Player Local
274 * @tc.number: Player_Local_003
275 * @tc.desc : Test Player Local source
276 */
277 HWTEST_F(PlayerUnitTest, Player_Local_003, TestSize.Level2)
278 {
279 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_MP3.mp4");
280 EXPECT_EQ(MSERR_OK, ret);
281 sptr<Surface> videoSurface = player_->GetVideoSurface();
282 ASSERT_NE(nullptr, videoSurface);
283 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
284 ret = player_->PrepareAsync();
285 if (ret == MSERR_OK) {
286 PlayFunTest(LOCAL_PLAY);
287 }
288 }
289
290 /**
291 * @tc.name : Test Player Local
292 * @tc.number: Player_Local_004
293 * @tc.desc : Test Player Local source
294 */
295 HWTEST_F(PlayerUnitTest, Player_Local_004, TestSize.Level2)
296 {
297 int32_t ret = player_->SetSource(MEDIA_ROOT + "MPEG2_AAC.mp4");
298 EXPECT_EQ(MSERR_OK, ret);
299 sptr<Surface> videoSurface = player_->GetVideoSurface();
300 ASSERT_NE(nullptr, videoSurface);
301 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
302 ret = player_->PrepareAsync();
303 if (ret == MSERR_OK) {
304 PlayFunTest(LOCAL_PLAY);
305 }
306 }
307
308 /**
309 * @tc.name : Test Player Local
310 * @tc.number: Player_Local_005
311 * @tc.desc : Test Player Local source
312 */
313 HWTEST_F(PlayerUnitTest, Player_Local_005, TestSize.Level2)
314 {
315 int32_t ret = player_->SetSource(MEDIA_ROOT + "MPEG2_MP3.mp4");
316 EXPECT_EQ(MSERR_OK, ret);
317 sptr<Surface> videoSurface = player_->GetVideoSurface();
318 ASSERT_NE(nullptr, videoSurface);
319 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
320 ret = player_->PrepareAsync();
321 if (ret == MSERR_OK) {
322 PlayFunTest(LOCAL_PLAY);
323 }
324 }
325
326 /**
327 * @tc.name : Test Player Local
328 * @tc.number: Player_Local_006
329 * @tc.desc : Test Player Local source
330 */
331 HWTEST_F(PlayerUnitTest, Player_Local_006, TestSize.Level2)
332 {
333 int32_t ret = player_->SetSource(MEDIA_ROOT + "MPEG4_AAC.mp4");
334 EXPECT_EQ(MSERR_OK, ret);
335 sptr<Surface> videoSurface = player_->GetVideoSurface();
336 ASSERT_NE(nullptr, videoSurface);
337 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
338 ret = player_->PrepareAsync();
339 if (ret == MSERR_OK) {
340 PlayFunTest(LOCAL_PLAY);
341 }
342 }
343
344 /**
345 * @tc.name : Test Player Local
346 * @tc.number: Player_Local_007
347 * @tc.desc : Test Player Local source
348 */
349 HWTEST_F(PlayerUnitTest, Player_Local_007, TestSize.Level2)
350 {
351 int32_t ret = player_->SetSource(MEDIA_ROOT + "MPEG4_MP3.mp4");
352 EXPECT_EQ(MSERR_OK, ret);
353 sptr<Surface> videoSurface = player_->GetVideoSurface();
354 ASSERT_NE(nullptr, videoSurface);
355 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
356 ret = player_->PrepareAsync();
357 if (ret == MSERR_OK) {
358 PlayFunTest(LOCAL_PLAY);
359 }
360 }
361
362 /**
363 * @tc.name : Test Player Local
364 * @tc.number: Player_Local_008
365 * @tc.desc : Test Player Local source
366 */
367 HWTEST_F(PlayerUnitTest, Player_Local_008, TestSize.Level2)
368 {
369 int32_t ret = player_->SetSource(MEDIA_ROOT + "out_170_170.mp4");
370 EXPECT_EQ(MSERR_OK, ret);
371 sptr<Surface> videoSurface = player_->GetVideoSurface();
372 ASSERT_NE(nullptr, videoSurface);
373 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
374 ret = player_->PrepareAsync();
375 if (ret == MSERR_OK) {
376 PlayFunTest(LOCAL_PLAY);
377 }
378 }
379
380 /**
381 * @tc.name : Test Player Local
382 * @tc.number: Player_Local_009
383 * @tc.desc : Test Player Local source
384 */
385 HWTEST_F(PlayerUnitTest, Player_Local_009, TestSize.Level2)
386 {
387 int32_t ret = player_->SetSource(MEDIA_ROOT + "H264_AAC_320x240.mp4");
388 EXPECT_EQ(MSERR_OK, ret);
389 sptr<Surface> videoSurface = player_->GetVideoSurface();
390 ASSERT_NE(nullptr, videoSurface);
391 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
392 ret = player_->PrepareAsync();
393 if (ret == MSERR_OK) {
394 PlayFunTest(LOCAL_PLAY);
395 }
396 }
397
398 /**
399 * @tc.name : Test Player Local
400 * @tc.number: Player_Local_010
401 * @tc.desc : Test Player Local source
402 */
403 HWTEST_F(PlayerUnitTest, Player_Local_010, TestSize.Level2)
404 {
405 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_44100Hz_143kbs_stereo.aac");
406 EXPECT_EQ(MSERR_OK, ret);
407 sptr<Surface> videoSurface = player_->GetVideoSurface();
408 ASSERT_NE(nullptr, videoSurface);
409 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
410 ret = player_->PrepareAsync();
411 if (ret == MSERR_OK) {
412 PlayFunTest(LOCAL_PLAY);
413 }
414 }
415
416 /**
417 * @tc.name : Test Player Local
418 * @tc.number: Player_Local_011
419 * @tc.desc : Test Player Local source
420 */
421 HWTEST_F(PlayerUnitTest, Player_Local_011, TestSize.Level2)
422 {
423 int32_t ret = player_->SetSource(MEDIA_ROOT + "mp3_48000Hz_64kbs_mono.mp3");
424 EXPECT_EQ(MSERR_OK, ret);
425 sptr<Surface> videoSurface = player_->GetVideoSurface();
426 ASSERT_NE(nullptr, videoSurface);
427 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
428 ret = player_->PrepareAsync();
429 if (ret == MSERR_OK) {
430 PlayFunTest(LOCAL_PLAY);
431 }
432 }
433
434 /**
435 * @tc.name : Test Player Local
436 * @tc.number: Player_Local_013
437 * @tc.desc : Test Player Local source
438 */
439 HWTEST_F(PlayerUnitTest, Player_Local_013, TestSize.Level2)
440 {
441 int32_t ret = player_->SetSource(MEDIA_ROOT + "pcm_s16le_48000Hz_768kbs_mono.wav");
442 EXPECT_EQ(MSERR_OK, ret);
443 sptr<Surface> videoSurface = player_->GetVideoSurface();
444 ASSERT_NE(nullptr, videoSurface);
445 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
446 ret = player_->PrepareAsync();
447 if (ret == MSERR_OK) {
448 PlayFunTest(LOCAL_PLAY);
449 }
450 }
451
452 /**
453 * @tc.name : Test Player Local
454 * @tc.number: Player_Local_014
455 * @tc.desc : Test Player Local source
456 */
457 HWTEST_F(PlayerUnitTest, Player_Local_014, TestSize.Level2)
458 {
459 int32_t ret = player_->SetSource(MEDIA_ROOT + "vorbis_48000Hz_80kbs_mono.ogg");
460 EXPECT_EQ(MSERR_OK, ret);
461 sptr<Surface> videoSurface = player_->GetVideoSurface();
462 ASSERT_NE(nullptr, videoSurface);
463 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
464 ret = player_->PrepareAsync();
465 if (ret == MSERR_OK) {
466 PlayFunTest(LOCAL_PLAY);
467 }
468 }
469
470 /**
471 * @tc.name : Test Player Local
472 * @tc.number: Player_Local_015
473 * @tc.desc : Test Player Local source
474 */
475 HWTEST_F(PlayerUnitTest, Player_Local_015, TestSize.Level2)
476 {
477 int32_t ret = player_->SetSource(MEDIA_ROOT + "aac_48000Hz_70kbs_mono.m4a");
478 EXPECT_EQ(MSERR_OK, ret);
479 sptr<Surface> videoSurface = player_->GetVideoSurface();
480 ASSERT_NE(nullptr, videoSurface);
481 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
482 ret = player_->PrepareAsync();
483 if (ret == MSERR_OK) {
484 PlayFunTest(LOCAL_PLAY);
485 }
486 }
487
488 /**
489 * @tc.name : Test Player SetPlayerCallback API
490 * @tc.number: Player_SetPlayerCallback_001
491 * @tc.desc : Test Player SetPlayerCallback interface
492 */
493 HWTEST_F(PlayerUnitTest, Player_SetPlayerCallback_001, TestSize.Level0)
494 {
495 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
496 sptr<Surface> videoSurface = player_->GetVideoSurface();
497 ASSERT_NE(nullptr, videoSurface);
498 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
499 EXPECT_EQ(MSERR_OK, player_->Prepare());
500 std::shared_ptr<PlayerCallbackTest> callback = std::make_shared<PlayerCallbackTest>();
501 ASSERT_NE(nullptr, callback);
502 EXPECT_NE(MSERR_OK, player_->SetPlayerCallback(callback));
503 player_->Reset();
504 player_->SetPlayerCallback(callback);
505 }
506
507 /**
508 * @tc.name : Test Player Prepare API
509 * @tc.number: Player_Prepare_001
510 * @tc.desc : Test Player Prepare interface
511 */
512 HWTEST_F(PlayerUnitTest, Player_Prepare_001, TestSize.Level0)
513 {
514 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
515 sptr<Surface> videoSurface = player_->GetVideoSurface();
516 ASSERT_NE(nullptr, videoSurface);
517 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
518 EXPECT_EQ(MSERR_OK, player_->Prepare());
519 }
520
521 /**
522 * @tc.name : Test Player Prepare API
523 * @tc.number: Player_Prepare_002
524 * @tc.desc : Test Player Prepare->Prepare
525 */
526 HWTEST_F(PlayerUnitTest, Player_Prepare_002, TestSize.Level2)
527 {
528 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
529 sptr<Surface> videoSurface = player_->GetVideoSurface();
530 ASSERT_NE(nullptr, videoSurface);
531 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
532 EXPECT_EQ(MSERR_OK, player_->Prepare());
533 EXPECT_NE(MSERR_OK, player_->Prepare());
534 }
535
536 /**
537 * @tc.name : Test Player Prepare API
538 * @tc.number: Player_Prepare_003
539 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->Prepare
540 */
541 HWTEST_F(PlayerUnitTest, Player_Prepare_003, TestSize.Level2)
542 {
543 PlaybackRateMode mode;
544 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
545 sptr<Surface> videoSurface = player_->GetVideoSurface();
546 ASSERT_NE(nullptr, videoSurface);
547 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
548 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
549 EXPECT_EQ(true, player_->IsLooping());
550 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
551 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
552 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
553 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
554 EXPECT_EQ(MSERR_OK, player_->Prepare());
555 EXPECT_EQ(true, player_->IsLooping());
556 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
557 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
558 }
559
560 /**
561 * @tc.name : Test Player Prepare API
562 * @tc.number: Player_Prepare_004
563 * @tc.desc : Test Player Stop->Prepare
564 */
565 HWTEST_F(PlayerUnitTest, Player_Prepare_004, TestSize.Level2)
566 {
567 PlaybackRateMode mode;
568 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
569 sptr<Surface> videoSurface = player_->GetVideoSurface();
570 ASSERT_NE(nullptr, videoSurface);
571 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
572 EXPECT_EQ(MSERR_OK, player_->Prepare());
573 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
574 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
575 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
576 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
577 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
578 EXPECT_EQ(MSERR_OK, player_->Stop());
579 EXPECT_EQ(MSERR_OK, player_->Prepare());
580 EXPECT_EQ(true, player_->IsLooping());
581 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
582 EXPECT_EQ(mode, SPEED_FORWARD_2_00_X);
583 }
584
585 /**
586 * @tc.name : Test Player PrepareAsync API
587 * @tc.number: Player_PrepareAsync_001
588 * @tc.desc : Test Player PrepareAsync interface
589 */
590 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_001, TestSize.Level0)
591 {
592 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
593 sptr<Surface> videoSurface = player_->GetVideoSurface();
594 ASSERT_NE(nullptr, videoSurface);
595 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
596 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
597 }
598
599 /**
600 * @tc.name : Test Player PrepareAsync API
601 * @tc.number: Player_PrepareAsync_002
602 * @tc.desc : Test Player PrepareAsync->PrepareAsync
603 */
604 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_002, TestSize.Level2)
605 {
606 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
607 sptr<Surface> videoSurface = player_->GetVideoSurface();
608 ASSERT_NE(nullptr, videoSurface);
609 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
610 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
611 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
612 }
613
614 /**
615 * @tc.name : Test Player PrepareAsync API
616 * @tc.number: Player_PrepareAsync_003
617 * @tc.desc : Test Player SetVolume/SetLooping/SetPlaybackSpeed->PrepareAsync
618 */
619 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_003, TestSize.Level2)
620 {
621 PlaybackRateMode mode;
622 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
623 sptr<Surface> videoSurface = player_->GetVideoSurface();
624 ASSERT_NE(nullptr, videoSurface);
625 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
626 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
627 EXPECT_EQ(true, player_->IsLooping());
628 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
629 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
630 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
631 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
632 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
633 EXPECT_EQ(true, player_->IsLooping());
634 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
635 EXPECT_NE(SPEED_FORWARD_2_00_X, mode);
636 }
637
638 /**
639 * @tc.name : Test Player PrepareAsync API
640 * @tc.number: Player_PrepareAsync_004
641 * @tc.desc : Test Player Stop->PrepareAsync
642 */
643 HWTEST_F(PlayerUnitTest, Player_PrepareAsync_004, TestSize.Level2)
644 {
645 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
646 sptr<Surface> videoSurface = player_->GetVideoSurface();
647 ASSERT_NE(nullptr, videoSurface);
648 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
649 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
650 EXPECT_EQ(MSERR_OK, player_->Stop());
651 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
652 }
653
654 /**
655 * @tc.name : Test Player SetVideoSurface API
656 * @tc.number: Player_SetVideoSurface_001
657 * @tc.desc : Test Player SetVideoSurface interface
658 */
659 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_001, TestSize.Level0)
660 {
661 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
662 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(player_->GetVideoSurface()));
663 }
664
665 /**
666 * @tc.name : Test Player SetVideoSurface API
667 * @tc.number: Player_SetVideoSurface_002
668 * @tc.desc : Test Player PrepareAsync->SetVideoSurface
669 */
670 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_002, TestSize.Level2)
671 {
672 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
673 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
674 sptr<Surface> videoSurface = player_->GetVideoSurface();
675 ASSERT_NE(nullptr, videoSurface);
676 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
677 }
678
679 /**
680 * @tc.name : Test Player SetVideoSurface API
681 * @tc.number: Player_SetVideoSurface_003
682 * @tc.desc : Test Player SetVideoSurface interface
683 */
684 HWTEST_F(PlayerUnitTest, Player_SetVideoSurface_003, TestSize.Level0)
685 {
686 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
687 EXPECT_EQ(MSERR_OK, player_->Prepare());
688 sptr<Surface> videoSurface = player_->GetVideoSurface();
689 ASSERT_NE(nullptr, videoSurface);
690 EXPECT_NE(MSERR_OK, player_->SetVideoSurface(videoSurface));
691 }
692
693 /**
694 * @tc.name : Test Player Play API
695 * @tc.number: Player_Play_001
696 * @tc.desc : Test Player Play interface
697 */
698 HWTEST_F(PlayerUnitTest, Player_Play_001, TestSize.Level0)
699 {
700 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
701 sptr<Surface> videoSurface = player_->GetVideoSurface();
702 ASSERT_NE(nullptr, videoSurface);
703 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
704 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
705 EXPECT_EQ(MSERR_OK, player_->Play());
706 EXPECT_TRUE(player_->IsPlaying());
707 EXPECT_EQ(MSERR_OK, player_->Pause());
708 EXPECT_EQ(MSERR_OK, player_->Play());
709 }
710
711 /**
712 * @tc.name : Test Player Play API
713 * @tc.number: Player_Play_002
714 * @tc.desc : Test Player Reset->Play
715 */
716 HWTEST_F(PlayerUnitTest, Player_Play_002, TestSize.Level2)
717 {
718 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
719 sptr<Surface> videoSurface = player_->GetVideoSurface();
720 ASSERT_NE(nullptr, videoSurface);
721 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
722 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
723 EXPECT_EQ(MSERR_OK, player_->Play());
724 EXPECT_TRUE(player_->IsPlaying());
725 EXPECT_EQ(MSERR_OK, player_->Reset());
726 EXPECT_NE(MSERR_OK, player_->Play());
727 }
728
729 /**
730 * @tc.name : Test Player Play API
731 * @tc.number: Player_Play_003
732 * @tc.desc : Test Player complete->Play
733 */
734 HWTEST_F(PlayerUnitTest, Player_Play_003, TestSize.Level2)
735 {
736 int32_t duration = 0;
737 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
738 sptr<Surface> videoSurface = player_->GetVideoSurface();
739 ASSERT_NE(nullptr, videoSurface);
740 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
741 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
742 EXPECT_EQ(MSERR_OK, player_->Play());
743 EXPECT_TRUE(player_->IsPlaying());
744 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
745 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
746 sleep(PLAYING_TIME);
747 EXPECT_EQ(MSERR_OK, player_->Play());
748 }
749
750 /**
751 * @tc.name : Test Player Play API
752 * @tc.number: Player_Play_004
753 * @tc.desc : Test Player Play->Play
754 */
755 HWTEST_F(PlayerUnitTest, Player_Play_004, TestSize.Level2)
756 {
757 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
758 sptr<Surface> videoSurface = player_->GetVideoSurface();
759 ASSERT_NE(nullptr, videoSurface);
760 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
761 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
762 EXPECT_EQ(MSERR_OK, player_->Play());
763 EXPECT_TRUE(player_->IsPlaying());
764 EXPECT_NE(MSERR_OK, player_->Play());
765 }
766
767 /**
768 * @tc.name : Test Player Stop API
769 * @tc.number: Player_Stop_001
770 * @tc.desc : Test Player Stop Play->Stop
771 */
772 HWTEST_F(PlayerUnitTest, Player_Stop_001, TestSize.Level0)
773 {
774 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
775 sptr<Surface> videoSurface = player_->GetVideoSurface();
776 ASSERT_NE(nullptr, videoSurface);
777 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
778 EXPECT_EQ(MSERR_OK, player_->Prepare());
779 EXPECT_EQ(MSERR_OK, player_->Play());
780 EXPECT_TRUE(player_->IsPlaying());
781 EXPECT_EQ(MSERR_OK, player_->Stop());
782 }
783
784 /**
785 * @tc.name : Test Player Stop API
786 * @tc.number: Player_Stop_002
787 * @tc.desc : Test Player Stop Prepare->Stop
788 */
789 HWTEST_F(PlayerUnitTest, Player_Stop_002, TestSize.Level2)
790 {
791 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
792 sptr<Surface> videoSurface = player_->GetVideoSurface();
793 ASSERT_NE(nullptr, videoSurface);
794 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
795 EXPECT_EQ(MSERR_OK, player_->Prepare());
796 EXPECT_EQ(MSERR_OK, player_->Stop());
797 }
798
799 /**
800 * @tc.name : Test Player Stop API
801 * @tc.number: Player_Stop_003
802 * @tc.desc : Test Player Stop complete/stop->Stop
803 */
804 HWTEST_F(PlayerUnitTest, Player_Stop_003, TestSize.Level2)
805 {
806 int32_t duration = 0;
807 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
808 sptr<Surface> videoSurface = player_->GetVideoSurface();
809 ASSERT_NE(nullptr, videoSurface);
810 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
811 EXPECT_EQ(MSERR_OK, player_->Prepare());
812 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
813 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
814 sleep(PLAYING_TIME);
815 EXPECT_EQ(MSERR_OK, player_->Stop());
816 EXPECT_NE(MSERR_OK, player_->Stop());
817 }
818
819 /**
820 * @tc.name : Test Player Stop API
821 * @tc.number: Player_Stop_004
822 * @tc.desc : Test Player Stop Reset->Stop
823 */
824 HWTEST_F(PlayerUnitTest, Player_Stop_004, TestSize.Level2)
825 {
826 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
827 sptr<Surface> videoSurface = player_->GetVideoSurface();
828 ASSERT_NE(nullptr, videoSurface);
829 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
830 EXPECT_EQ(MSERR_OK, player_->Prepare());
831 EXPECT_EQ(MSERR_OK, player_->Play());
832 EXPECT_EQ(MSERR_OK, player_->Reset());
833 EXPECT_NE(MSERR_OK, player_->Stop());
834 }
835
836 /**
837 * @tc.name : Test Player Stop API
838 * @tc.number: Player_Stop_005
839 * @tc.desc : Test Player Reset->Stop
840 */
841 HWTEST_F(PlayerUnitTest, Player_Stop_005, TestSize.Level2)
842 {
843 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1, 0, 0));
844 sptr<Surface> videoSurface = player_->GetVideoSurface();
845 ASSERT_NE(nullptr, videoSurface);
846 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
847 EXPECT_EQ(MSERR_OK, player_->Prepare());
848 EXPECT_EQ(MSERR_OK, player_->Play());
849 EXPECT_TRUE(player_->IsPlaying());
850 EXPECT_EQ(MSERR_OK, player_->Reset());
851 EXPECT_NE(MSERR_OK, player_->Stop());
852 }
853
854 /**
855 * @tc.name : Test Player Pause API
856 * @tc.number: Player_Pause_001
857 * @tc.desc : Test Player Pause interface
858 */
859 HWTEST_F(PlayerUnitTest, Player_Pause_001, TestSize.Level0)
860 {
861 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
862 sptr<Surface> videoSurface = player_->GetVideoSurface();
863 ASSERT_NE(nullptr, videoSurface);
864 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
865 EXPECT_EQ(MSERR_OK, player_->Prepare());
866 EXPECT_EQ(MSERR_OK, player_->Play());
867 EXPECT_TRUE(player_->IsPlaying());
868 EXPECT_EQ(MSERR_OK, player_->Pause());
869 EXPECT_FALSE(player_->IsPlaying());
870 EXPECT_NE(MSERR_OK, player_->Pause());
871 }
872
873 /**
874 * @tc.name : Test Player Pause API
875 * @tc.number: Player_Pause_002
876 * @tc.desc : Test Player Pause interface
877 */
878 HWTEST_F(PlayerUnitTest, Player_Pause_002, TestSize.Level2)
879 {
880 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
881 sptr<Surface> videoSurface = player_->GetVideoSurface();
882 ASSERT_NE(nullptr, videoSurface);
883 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
884 EXPECT_EQ(MSERR_OK, player_->Prepare());
885 EXPECT_NE(MSERR_OK, player_->Pause());
886 }
887
888 /**
889 * @tc.name : Test Player Reset API
890 * @tc.number: Player_Reset_001
891 * @tc.desc : Test Player Reset interface
892 */
893 HWTEST_F(PlayerUnitTest, Player_Reset_001, TestSize.Level0)
894 {
895 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
896 sptr<Surface> videoSurface = player_->GetVideoSurface();
897 ASSERT_NE(nullptr, videoSurface);
898 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
899 EXPECT_EQ(MSERR_OK, player_->Prepare());
900 EXPECT_EQ(MSERR_OK, player_->Reset());
901 EXPECT_NE(MSERR_OK, player_->Reset());
902 }
903
904 /**
905 * @tc.name : Test Player Seek API
906 * @tc.number: Player_Seek_001
907 * @tc.desc : Test Player Seek interface with valid parameters
908 */
909 HWTEST_F(PlayerUnitTest, Player_Seek_001, TestSize.Level0)
910 {
911 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
912 sptr<Surface> videoSurface = player_->GetVideoSurface();
913 ASSERT_NE(nullptr, videoSurface);
914 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
915 EXPECT_EQ(MSERR_OK, player_->Prepare());
916 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
917 EXPECT_EQ(MSERR_OK, player_->Play());
918 EXPECT_TRUE(player_->IsPlaying());
919 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST));
920 int32_t time = 0;
921 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
922 EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME);
923 EXPECT_EQ(MSERR_OK, player_->Pause());
924 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
925 }
926
927 /**
928 * @tc.name : Test Player Seek API
929 * @tc.number: Player_Seek_002
930 * @tc.desc : Test Player Seek interface with seek mode
931 */
932 HWTEST_F(PlayerUnitTest, Player_Seek_002, TestSize.Level1)
933 {
934 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
935 sptr<Surface> videoSurface = player_->GetVideoSurface();
936 ASSERT_NE(nullptr, videoSurface);
937 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
938 EXPECT_EQ(MSERR_OK, player_->Prepare());
939 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_NEXT_SYNC));
940 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_PREVIOUS_SYNC));
941 EXPECT_EQ(MSERR_OK, player_->Seek(0, SEEK_CLOSEST_SYNC));
942 EXPECT_EQ(MSERR_OK, player_->Play());
943 EXPECT_TRUE(player_->IsPlaying());
944 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
945 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC));
946 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST_SYNC));
947 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, (PlayerSeekMode)5));
948 }
949
950 /**
951 * @tc.name : Test Player Seek API
952 * @tc.number: Player_Seek_002
953 * @tc.desc : Test Player Seek out of duration
954 */
955 HWTEST_F(PlayerUnitTest, Player_Seek_003, TestSize.Level2)
956 {
957 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
958 sptr<Surface> videoSurface = player_->GetVideoSurface();
959 ASSERT_NE(nullptr, videoSurface);
960 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
961 EXPECT_EQ(MSERR_OK, player_->Prepare());
962 EXPECT_EQ(MSERR_OK, player_->Play());
963 EXPECT_TRUE(player_->IsPlaying());
964 EXPECT_EQ(MSERR_OK, player_->Seek(1000000, SEEK_NEXT_SYNC));
965 }
966
967 /**
968 * @tc.name : Test Seek API
969 * @tc.number: Player_Seek_004
970 * @tc.desc : Test Player Seek
971 */
972 HWTEST_F(PlayerUnitTest, Player_Seek_004, TestSize.Level2)
973 {
974 int32_t duration = 0;
975 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
976 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
977 sptr<Surface> videoSurface = player_->GetVideoSurface();
978 ASSERT_NE(nullptr, videoSurface);
979 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
980 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
981 EXPECT_EQ(MSERR_OK, player_->Prepare());
982 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
983 EXPECT_EQ(MSERR_OK, player_->Play());
984 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
985 EXPECT_EQ(MSERR_OK, player_->Pause());
986 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
987 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
988 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
989 EXPECT_EQ(MSERR_OK, player_->Play());
990 sleep(PLAYING_TIME);
991 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
992 EXPECT_EQ(MSERR_OK, player_->Stop());
993 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
994 EXPECT_EQ(MSERR_OK, player_->Reset());
995 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
996 }
997
998 /**
999 * @tc.name : Test GetVideoTrackInfo API
1000 * @tc.number: Player_GetVideoTrackInfo_001
1001 * @tc.desc : Test Player GetVideoTrackInfo
1002 */
1003 HWTEST_F(PlayerUnitTest, Player_GetVideoTrackInfo_001, TestSize.Level0)
1004 {
1005 std::vector<Format> videoTrack;
1006 std::vector<Format> audioTrack;
1007 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1008 sptr<Surface> videoSurface = player_->GetVideoSurface();
1009 ASSERT_NE(nullptr, videoSurface);
1010 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1011 EXPECT_EQ(MSERR_OK, player_->Prepare());
1012 EXPECT_EQ(MSERR_OK, player_->Play());
1013 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1014 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1015 }
1016
1017 /**
1018 * @tc.name : Test GetVideoTrackInfo API
1019 * @tc.number: Player_GetVideoTrackInfo_002
1020 * @tc.desc : Test Player GetVideoTrackInfo
1021 */
1022 HWTEST_F(PlayerUnitTest, Player_GetVideoTrackInfo_002, TestSize.Level2)
1023 {
1024 std::vector<Format> videoTrack;
1025 std::vector<Format> audioTrack;
1026 int32_t duration = 0;
1027 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1028 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1029 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1030 sptr<Surface> videoSurface = player_->GetVideoSurface();
1031 ASSERT_NE(nullptr, videoSurface);
1032 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1033 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1034 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1035 EXPECT_EQ(MSERR_OK, player_->Prepare());
1036 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1037 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1038 EXPECT_EQ(MSERR_OK, player_->Play());
1039 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1040 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1041 EXPECT_EQ(MSERR_OK, player_->Pause());
1042 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1043 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1044 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1045 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1046 EXPECT_EQ(MSERR_OK, player_->Play());
1047 sleep(PLAYING_TIME);
1048 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1049 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1050 EXPECT_EQ(MSERR_OK, player_->Stop());
1051 EXPECT_EQ(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1052 EXPECT_EQ(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1053 EXPECT_EQ(MSERR_OK, player_->Reset());
1054 EXPECT_NE(MSERR_OK, player_->GetVideoTrackInfo(videoTrack));
1055 EXPECT_NE(MSERR_OK, player_->GetAudioTrackInfo(audioTrack));
1056 }
1057
1058 /**
1059 * @tc.name : Test GetVideoHeight API
1060 * @tc.number: Player_GetVideoHeight_001
1061 * @tc.desc : Test Player GetVideoHeight
1062 */
1063 HWTEST_F(PlayerUnitTest, Player_GetVideoHeight_001, TestSize.Level0)
1064 {
1065 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1066 sptr<Surface> videoSurface = player_->GetVideoSurface();
1067 ASSERT_NE(nullptr, videoSurface);
1068 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1069 EXPECT_EQ(MSERR_OK, player_->Prepare());
1070 EXPECT_EQ(MSERR_OK, player_->Play());
1071 EXPECT_EQ(480, player_->GetVideoHeight());
1072 EXPECT_EQ(720, player_->GetVideoWidth());
1073 }
1074
1075 /**
1076 * @tc.name : Test GetVideoHeight API
1077 * @tc.number: Player_GetVideoHeight_002
1078 * @tc.desc : Test Player GetVideoHeight
1079 */
1080 HWTEST_F(PlayerUnitTest, Player_GetVideoHeight_002, TestSize.Level2)
1081 {
1082 int32_t duration = 0;
1083 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1084 EXPECT_NE(480, player_->GetVideoHeight());
1085 EXPECT_NE(720, player_->GetVideoWidth());
1086 sptr<Surface> videoSurface = player_->GetVideoSurface();
1087 ASSERT_NE(nullptr, videoSurface);
1088 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1089 EXPECT_NE(480, player_->GetVideoHeight());
1090 EXPECT_NE(720, player_->GetVideoWidth());
1091 EXPECT_EQ(MSERR_OK, player_->Prepare());
1092 EXPECT_EQ(480, player_->GetVideoHeight());
1093 EXPECT_EQ(720, player_->GetVideoWidth());
1094 EXPECT_EQ(MSERR_OK, player_->Play());
1095 EXPECT_EQ(480, player_->GetVideoHeight());
1096 EXPECT_EQ(720, player_->GetVideoWidth());
1097 EXPECT_EQ(MSERR_OK, player_->Pause());
1098 EXPECT_EQ(480, player_->GetVideoHeight());
1099 EXPECT_EQ(720, player_->GetVideoWidth());
1100 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1101 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1102 EXPECT_EQ(MSERR_OK, player_->Play());
1103 sleep(PLAYING_TIME);
1104 EXPECT_EQ(480, player_->GetVideoHeight());
1105 EXPECT_EQ(720, player_->GetVideoWidth());
1106 EXPECT_EQ(MSERR_OK, player_->Stop());
1107 EXPECT_EQ(480, player_->GetVideoHeight());
1108 EXPECT_EQ(720, player_->GetVideoWidth());
1109 EXPECT_EQ(MSERR_OK, player_->Reset());
1110 EXPECT_NE(480, player_->GetVideoHeight());
1111 EXPECT_NE(720, player_->GetVideoWidth());
1112 }
1113
1114 /**
1115 * @tc.name : Test GetDuration API
1116 * @tc.number: Player_GetDuration_001
1117 * @tc.desc : Test Player GetDuration
1118 */
1119 HWTEST_F(PlayerUnitTest, Player_GetDuration_001, TestSize.Level0)
1120 {
1121 int32_t duration = 0;
1122 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1123 sptr<Surface> videoSurface = player_->GetVideoSurface();
1124 ASSERT_NE(nullptr, videoSurface);
1125 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1126 EXPECT_EQ(MSERR_OK, player_->Prepare());
1127 EXPECT_EQ(MSERR_OK, player_->Play());
1128 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1129 EXPECT_NEAR(10000, duration, DELTA_TIME); // duration 10000ms
1130 }
1131
1132 /**
1133 * @tc.name : Test GetDuration API
1134 * @tc.number: Player_GetDuration_002
1135 * @tc.desc : Test Player GetDuration
1136 */
1137 HWTEST_F(PlayerUnitTest, Player_GetDuration_002, TestSize.Level2)
1138 {
1139 int32_t duration = 0;
1140 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1141 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1142 sptr<Surface> videoSurface = player_->GetVideoSurface();
1143 ASSERT_NE(nullptr, videoSurface);
1144 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1145 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1146 EXPECT_EQ(MSERR_OK, player_->Prepare());
1147 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1148 EXPECT_EQ(MSERR_OK, player_->Play());
1149 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1150 EXPECT_EQ(MSERR_OK, player_->Pause());
1151 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1152 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1153 EXPECT_EQ(MSERR_OK, player_->Play());
1154 sleep(PLAYING_TIME);
1155 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1156 EXPECT_EQ(MSERR_OK, player_->Stop());
1157 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1158 EXPECT_EQ(MSERR_OK, player_->Reset());
1159 EXPECT_NE(MSERR_OK, player_->GetDuration(duration));
1160 }
1161
1162 /**
1163 * @tc.name : Test SetPlaybackSpeed API
1164 * @tc.number: Player_SetPlaybackSpeed_001
1165 * @tc.desc : Test Player SetPlaybackSpeed
1166 */
1167 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_001, TestSize.Level0)
1168 {
1169 PlaybackRateMode mode;
1170 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1171 sptr<Surface> videoSurface = player_->GetVideoSurface();
1172 ASSERT_NE(nullptr, videoSurface);
1173 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1174 EXPECT_EQ(MSERR_OK, player_->Prepare());
1175 EXPECT_EQ(MSERR_OK, player_->Play());
1176 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1177 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1178 EXPECT_EQ(SPEED_FORWARD_2_00_X, mode);
1179 }
1180
1181 /**
1182 * @tc.name : Test SetPlaybackSpeed API
1183 * @tc.number: Player_SetPlaybackSpeed_002
1184 * @tc.desc : Test Player SetPlaybackSpeed
1185 */
1186 HWTEST_F(PlayerUnitTest, Player_SetPlaybackSpeed_002, TestSize.Level2)
1187 {
1188 int32_t duration = 0;
1189 PlaybackRateMode mode;
1190 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1191 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1192 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1193 sptr<Surface> videoSurface = player_->GetVideoSurface();
1194 ASSERT_NE(nullptr, videoSurface);
1195 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1196 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1197 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1198 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1199 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1200 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1201 EXPECT_EQ(MSERR_OK, player_->Play());
1202 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1203 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1204 EXPECT_EQ(MSERR_OK, player_->Pause());
1205 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_75_X));
1206 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1207 EXPECT_EQ(MSERR_OK, player_->GetDuration(duration));
1208 EXPECT_EQ(MSERR_OK, player_->Seek(duration, SEEK_CLOSEST));
1209 EXPECT_EQ(MSERR_OK, player_->Play());
1210 sleep(PLAYING_TIME);
1211 EXPECT_EQ(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_0_75_X));
1212 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1213 EXPECT_EQ(MSERR_OK, player_->Stop());
1214 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_1_25_X));
1215 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1216 EXPECT_EQ(MSERR_OK, player_->Reset());
1217 EXPECT_NE(MSERR_OK, player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X));
1218 EXPECT_EQ(MSERR_OK, player_->GetPlaybackSpeed(mode));
1219 }
1220
1221 /**
1222 * @tc.name : Test SetLooping API
1223 * @tc.number: Player_SetLooping_001
1224 * @tc.desc : Test Player SetLooping
1225 */
1226 HWTEST_F(PlayerUnitTest, Player_SetLooping_001, TestSize.Level0)
1227 {
1228 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1229 sptr<Surface> videoSurface = player_->GetVideoSurface();
1230 ASSERT_NE(nullptr, videoSurface);
1231 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1232 EXPECT_EQ(MSERR_OK, player_->Prepare());
1233 EXPECT_EQ(MSERR_OK, player_->Play());
1234 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1235 EXPECT_EQ(true, player_->IsLooping());
1236 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
1237 EXPECT_EQ(false, player_->IsLooping());
1238 }
1239
1240 /**
1241 * @tc.name : Test SetVolume API
1242 * @tc.number: Player_SetVolume_001
1243 * @tc.desc : Test Player SetVolume
1244 */
1245 HWTEST_F(PlayerUnitTest, Player_SetVolume_001, TestSize.Level0)
1246 {
1247 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1248 sptr<Surface> videoSurface = player_->GetVideoSurface();
1249 ASSERT_NE(nullptr, videoSurface);
1250 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1251 EXPECT_EQ(MSERR_OK, player_->Prepare());
1252 EXPECT_EQ(MSERR_OK, player_->Play());
1253 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1254 }
1255
1256 /**
1257 * @tc.name : Test SetVolume API
1258 * @tc.number: Player_SetVolume_002
1259 * @tc.desc : Test Player SetVolume
1260 */
1261 HWTEST_F(PlayerUnitTest, Player_SetVolume_002, TestSize.Level0)
1262 {
1263 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1264 sptr<Surface> videoSurface = player_->GetVideoSurface();
1265 ASSERT_NE(nullptr, videoSurface);
1266 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1267 EXPECT_EQ(MSERR_OK, player_->Prepare());
1268 EXPECT_EQ(MSERR_OK, player_->Play());
1269 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 0.1));
1270 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, 1.1));
1271 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, 0.1));
1272 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, -0.1));
1273 }
1274
1275 /**
1276 * @tc.name : Test SetVolume API
1277 * @tc.number: Player_SetVolume_003
1278 * @tc.desc : Test Player SetVolume
1279 */
1280 HWTEST_F(PlayerUnitTest, Player_SetVolume_003, TestSize.Level2)
1281 {
1282 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1283 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1284 sptr<Surface> videoSurface = player_->GetVideoSurface();
1285 ASSERT_NE(nullptr, videoSurface);
1286 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1287 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1288 EXPECT_EQ(MSERR_OK, player_->Prepare());
1289 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1290 EXPECT_EQ(MSERR_OK, player_->Play());
1291 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1292 EXPECT_EQ(MSERR_OK, player_->Pause());
1293 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1294 EXPECT_EQ(MSERR_OK, player_->Stop());
1295 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1296 EXPECT_EQ(MSERR_OK, player_->Reset());
1297 EXPECT_EQ(MSERR_OK, player_->SetVolume(1, 1));
1298 }
1299
1300 /**
1301 * @tc.name : Test SetVideoScaleType API
1302 * @tc.number: Player_SetVideoScaleType_001
1303 * @tc.desc : Test Player SetVideoScaleType
1304 */
1305 HWTEST_F(PlayerUnitTest, Player_SetVideoScaleType_001, TestSize.Level0)
1306 {
1307 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1308 sptr<Surface> videoSurface = player_->GetVideoSurface();
1309 ASSERT_NE(nullptr, videoSurface);
1310 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1311 EXPECT_EQ(MSERR_OK, player_->Prepare());
1312 EXPECT_EQ(MSERR_OK, player_->Play());
1313 Format format;
1314 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT);
1315 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1316 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT_CROP);
1317 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1318 }
1319
1320 /**
1321 * @tc.name : Test SetRendererInfo API
1322 * @tc.number: Player_SetRendererInfo_001
1323 * @tc.desc : Test Player SetRendererInfo
1324 */
1325 HWTEST_F(PlayerUnitTest, Player_SetRendererInfo_001, TestSize.Level0)
1326 {
1327 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1328 Format format;
1329 sptr<Surface> videoSurface = player_->GetVideoSurface();
1330 ASSERT_NE(nullptr, videoSurface);
1331 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1332 int32_t contentType = 1;
1333 int32_t streamUsage = 1;
1334 int32_t rendererFlags = 1;
1335 (void)format.PutIntValue(PlayerKeys::CONTENT_TYPE, contentType);
1336 (void)format.PutIntValue(PlayerKeys::STREAM_USAGE, streamUsage);
1337 (void)format.PutIntValue(PlayerKeys::RENDERER_FLAG, rendererFlags);
1338 EXPECT_EQ(MSERR_OK, player_->SetParameter(format));
1339 EXPECT_EQ(MSERR_OK, player_->Prepare());
1340 EXPECT_EQ(MSERR_OK, player_->Play());
1341 }
1342
1343 /**
1344 * @tc.name : Test SetInterrupt API
1345 * @tc.number: Player_SetInterrupt_001
1346 * @tc.desc : Test Player SetInterrupt
1347 */
1348 HWTEST_F(PlayerUnitTest, Player_SetInterrupt_001, TestSize.Level0)
1349 {
1350 Format format;
1351 int32_t mode = 1;
1352 int32_t type = 1;
1353 std::shared_ptr<PlayerMock> player = nullptr;
1354 std::shared_ptr<PlayerCallbackTest> callback = nullptr;
1355 callback = std::make_shared<PlayerCallbackTest>();
1356 ASSERT_NE(nullptr, callback);
1357 player = std::make_shared<PlayerMock>(callback);
1358 ASSERT_NE(nullptr, player);
1359 EXPECT_TRUE(player->CreatePlayer());
1360 EXPECT_EQ(MSERR_OK, player->SetPlayerCallback(callback));
1361 ASSERT_EQ(MSERR_OK, player->SetSource(MEDIA_ROOT + "01.mp3"));
1362 EXPECT_EQ(MSERR_OK, player->Prepare());
1363
1364 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1365 EXPECT_EQ(MSERR_OK, player_->Prepare());
1366 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_MODE, mode);
1367 (void)format.PutIntValue(PlayerKeys::AUDIO_INTERRUPT_TYPE, type);
1368 EXPECT_EQ(MSERR_OK, player->SetParameter(format));
1369 EXPECT_EQ(MSERR_OK, player->Play());
1370 sleep(PLAYING_TIME);
1371 EXPECT_EQ(MSERR_OK, player_->Play());
1372 sleep(PLAYING_TIME);
1373 EXPECT_EQ(MSERR_OK, player->ReleaseSync());
1374 }
1375
1376 /**
1377 * @tc.name : Test SetDataSource API
1378 * @tc.number: Player_SetDataSource_001
1379 * @tc.desc : Test Player SetDataSource
1380 */
1381 HWTEST_F(PlayerUnitTest, Player_SetDataSource_001, TestSize.Level0)
1382 {
1383 ASSERT_EQ(MSERR_OK, player_->SetDataSrc("/data/test/H264_AAC.mp4", -1, true));
1384 sptr<Surface> videoSurface = player_->GetVideoSurface();
1385 ASSERT_NE(nullptr, videoSurface);
1386 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1387 EXPECT_EQ(MSERR_OK, player_->Prepare());
1388 EXPECT_EQ(MSERR_OK, player_->Play());
1389 EXPECT_EQ(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1390 }
1391
1392 /**
1393 * @tc.name : Test SetDataSource API
1394 * @tc.number: Player_SetDataSource_002
1395 * @tc.desc : Test Player SetDataSource
1396 */
1397 HWTEST_F(PlayerUnitTest, Player_SetDataSource_002, TestSize.Level0)
1398 {
1399 ASSERT_EQ(MSERR_OK, player_->SetDataSrc("/data/test/H264_AAC.mp4", -1, false));
1400 sptr<Surface> videoSurface = player_->GetVideoSurface();
1401 ASSERT_NE(nullptr, videoSurface);
1402 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1403 EXPECT_EQ(MSERR_OK, player_->Prepare());
1404 EXPECT_EQ(MSERR_OK, player_->Play());
1405 EXPECT_NE(MSERR_OK, player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC));
1406 }
1407
1408 /**
1409 * @tc.name : Test Player SelectBitRate API
1410 * @tc.number: Player_SelectBitRate_001
1411 * @tc.desc : Test Player SelectBitRate interface
1412 */
1413 HWTEST_F(PlayerUnitTest, Player_SelectBitRate_001, TestSize.Level0)
1414 {
1415 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1416 sptr<Surface> videoSurface = player_->GetVideoSurface();
1417 ASSERT_NE(nullptr, videoSurface);
1418 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1419 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1420 EXPECT_EQ(MSERR_OK, player_->Play());
1421 EXPECT_NE(MSERR_OK, player_->SelectBitRate(0));
1422 }
1423
1424 /**
1425 * @tc.name: Player_Performance_Prepared_001
1426 * @tc.desc: test player start
1427 * @tc.type: PERFORMANCE
1428 * @tc.require: issueI5NYBJ
1429 */
1430 HWTEST_F(PlayerUnitTest, Player_Performance_Prepared_001, TestSize.Level0)
1431 {
1432 struct timeval startTime = {};
1433 struct timeval finishTime = {};
1434 int32_t runTimes = 10;
1435 float timeConv = 1000;
1436 float deltaTime = 0;
1437 sptr<Surface> videoSurface = player_->GetVideoSurface();
1438 ASSERT_NE(nullptr, videoSurface);
1439 for (int32_t i = 0; i < runTimes; i++) {
1440 EXPECT_EQ(MSERR_OK, gettimeofday(&startTime, nullptr));
1441 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1442 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1443 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1444 EXPECT_EQ(MSERR_OK, gettimeofday(&finishTime, nullptr));
1445 EXPECT_EQ(MSERR_OK, player_->Play());
1446 deltaTime += (finishTime.tv_sec - startTime.tv_sec) * timeConv +
1447 (finishTime.tv_usec - startTime.tv_usec) / timeConv;
1448 EXPECT_EQ(MSERR_OK, player_->Reset());
1449 }
1450 EXPECT_LE(deltaTime / runTimes, 1000); // less than 1000 ms
1451 }
1452
1453 /**
1454 * @tc.name : Test Player Play mp4 with rotation
1455 * @tc.number: Player_Rotate_001
1456 * @tc.desc : Test Player Play interface
1457 */
1458 HWTEST_F(PlayerUnitTest, Player_Rotate_001, TestSize.Level0)
1459 {
1460 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1461 sptr<Surface> videoSurface = player_->GetVideoSurface();
1462 ASSERT_NE(nullptr, videoSurface);
1463 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1464 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1465 EXPECT_EQ(MSERR_OK, player_->Play());
1466 EXPECT_TRUE(player_->IsPlaying());
1467 }
1468
1469 /**
1470 * @tc.name : Test Player Dump Dot
1471 * @tc.number: Player_Dump_Dot_001
1472 * @tc.desc : Test Player Dump Dot
1473 */
1474 HWTEST_F(PlayerUnitTest, Player_Dump_Dot_001, TestSize.Level0)
1475 {
1476 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1477 sptr<Surface> videoSurface = player_->GetVideoSurface();
1478 ASSERT_NE(nullptr, videoSurface);
1479 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1480 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1481 EXPECT_EQ(MSERR_OK, player_->Play());
1482 system("param set sys.media.dump.dot.path /data/test");
1483 EXPECT_TRUE(player_->IsPlaying());
1484 EXPECT_EQ(MSERR_OK, player_->Pause());
1485 system("param set sys.media.dump.dot.path /xx");
1486 EXPECT_EQ(MSERR_OK, player_->Play());
1487 }
1488
1489 /**
1490 * @tc.name : Test Player Dump GlibMem
1491 * @tc.number: Player_Dump_GlibMem_001
1492 * @tc.desc : Test Player Dump GlibMem
1493 */
1494 HWTEST_F(PlayerUnitTest, Player_Dump_GlibMem_001, TestSize.Level0)
1495 {
1496 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1497 sptr<Surface> videoSurface = player_->GetVideoSurface();
1498 ASSERT_NE(nullptr, videoSurface);
1499 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1500 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1501 EXPECT_EQ(MSERR_OK, player_->Play());
1502 system("hidumper -s 3002 -a glibmem");
1503 system("param set sys.media.dump.codec.vdec ALL");
1504 EXPECT_TRUE(player_->IsPlaying());
1505 EXPECT_EQ(MSERR_OK, player_->Pause());
1506 }
1507
1508 /**
1509 * @tc.name : Test Player Dump
1510 * @tc.number: Player_HiDump_001
1511 * @tc.desc : Test Player Dump
1512 */
1513 HWTEST_F(PlayerUnitTest, Player_HiDump_001, TestSize.Level0)
1514 {
1515 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1516 sptr<Surface> videoSurface = player_->GetVideoSurface();
1517 ASSERT_NE(nullptr, videoSurface);
1518 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1519 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1520 EXPECT_EQ(MSERR_OK, player_->Play());
1521 system("hidumper -s 3002");
1522 system("hidumper -s 3002 -a player");
1523 system("param set sys.media.dump.codec.vdec INPUT");
1524 EXPECT_TRUE(player_->IsPlaying());
1525 EXPECT_EQ(MSERR_OK, player_->Pause());
1526 }
1527
1528 /**
1529 * @tc.name : Test Player Dump GlibPool
1530 * @tc.number: Player_Dump_GlibPool_001
1531 * @tc.desc : Test Player Dump GlibPool
1532 */
1533 HWTEST_F(PlayerUnitTest, Player_Dump_GlibPool_001, TestSize.Level0)
1534 {
1535 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "MP4_ROTATE_90.mp4"));
1536 sptr<Surface> videoSurface = player_->GetVideoSurface();
1537 ASSERT_NE(nullptr, videoSurface);
1538 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1539 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1540 system("param set sys.media.dump.frame.enable true");
1541 system("param set sys.media.set.mute TRUE");
1542 system("param set sys.media.kpi.avsync.log.enable true");
1543 system("param set sys.media.kpi.opt.renderdelay.enable true");
1544 EXPECT_EQ(MSERR_OK, player_->Play());
1545 system("hidumper -s 3002 -a glibpool");
1546 system("param set sys.media.dump.codec.vdec OUTPUT");
1547 EXPECT_TRUE(player_->IsPlaying());
1548 EXPECT_EQ(MSERR_OK, player_->Pause());
1549 }
1550
1551 /**
1552 * @tc.name : Test Player Dump Log
1553 * @tc.number: Player_Dump_Log_001
1554 * @tc.desc : Test Player Dump Log
1555 */
1556 HWTEST_F(PlayerUnitTest, Player_Dump_Log_001, TestSize.Level0)
1557 {
1558 system("mkdir /data/media/log");
1559 system("chmod 777 -R /data/media");
1560 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1561 sptr<Surface> videoSurface = player_->GetVideoSurface();
1562 ASSERT_NE(nullptr, videoSurface);
1563 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1564 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1565 system("param set sys.media.log.level *:l,multiqueue,decodecbin:,tsdemux:D,multiqueue:D,hlsdemux:D,souphttpsrc:W");
1566 system("param set sys.media.log.level *:l,basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm" \
1567 "basesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmmbasesrcmmm:D");
1568 system("param set sys.media.dump.frame.enable false");
1569 system("param set sys.media.set.mute FALSE");
1570 system("param set sys.media.kpi.avsync.log.enable false");
1571 system("param set sys.media.kpi.opt.renderdelay.enable false");
1572 EXPECT_EQ(MSERR_OK, player_->Play());
1573 system("param set sys.media.dump.codec.vdec NULL");
1574 EXPECT_TRUE(player_->IsPlaying());
1575 EXPECT_EQ(MSERR_OK, player_->Pause());
1576 system("rm -rf /data/media/log");
1577 }
1578
1579 /**
1580 * @tc.name : Test Player Dump gstbuffer
1581 * @tc.number: Player_Dump_GstBuffer_001
1582 * @tc.desc : Test Player Dump gstbuffer
1583 */
1584 HWTEST_F(PlayerUnitTest, Player_Dump_GstBuffer_001, TestSize.Level0)
1585 {
1586 ASSERT_EQ(MSERR_OK, player_->SetSource(VIDEO_FILE1));
1587 sptr<Surface> videoSurface = player_->GetVideoSurface();
1588 ASSERT_NE(nullptr, videoSurface);
1589 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1590 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1591 system("param set sys.media.dump.gstbuffer 1");
1592 system("param set sys.media.set.mute null");
1593 EXPECT_EQ(MSERR_OK, player_->Play());
1594 EXPECT_TRUE(player_->IsPlaying());
1595 EXPECT_EQ(MSERR_OK, player_->Pause());
1596 system("param set sys.media.dump.gstbuffer 0");
1597 }
1598
1599 /**
1600 * @tc.name : Test Player Histreamer
1601 * @tc.number: Player_Histreamer_001
1602 * @tc.desc : Test Player function with Histreamer
1603 */
1604 HWTEST_F(PlayerUnitTest, Player_Histreamer_001, TestSize.Level0)
1605 {
1606 EXPECT_EQ(MSERR_OK, player_->Release());
1607 system("param set debug.media_service.histreamer 1");
1608 callback_ = std::make_shared<PlayerCallbackTest>();
1609 ASSERT_NE(nullptr, callback_);
1610 player_ = std::make_shared<PlayerMock>(callback_);
1611 ASSERT_NE(nullptr, player_);
1612 EXPECT_TRUE(player_->CreatePlayer());
1613 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
1614
1615 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3"));
1616 sptr<Surface> videoSurface = player_->GetVideoSurface();
1617 ASSERT_NE(nullptr, videoSurface);
1618 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1619 EXPECT_EQ(MSERR_OK, player_->PrepareAsync());
1620 EXPECT_EQ(MSERR_OK, player_->Play());
1621 EXPECT_TRUE(player_->IsPlaying());
1622 EXPECT_EQ(MSERR_OK, player_->Pause());
1623 int32_t time;
1624 EXPECT_EQ(MSERR_OK, player_->GetCurrentTime(time));
1625 std::vector<Format> videoTrack;
1626 std::vector<Format> audioTrack;
1627 player_->GetVideoTrackInfo(videoTrack);
1628 player_->GetAudioTrackInfo(audioTrack);
1629 int32_t duration = 0;
1630 player_->GetDuration(duration);
1631 PlaybackRateMode mode;
1632 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
1633 player_->GetPlaybackSpeed(mode);
1634 EXPECT_EQ(MSERR_OK, player_->SetLooping(true));
1635 EXPECT_EQ(true, player_->IsLooping());
1636 EXPECT_EQ(MSERR_OK, player_->SetLooping(false));
1637 EXPECT_EQ(false, player_->IsLooping());
1638 player_->SetVolume(1, 1);
1639 Format format;
1640 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT);
1641 player_->SetParameter(format);
1642 player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC);
1643 player_->Stop();
1644 EXPECT_EQ(MSERR_OK, player_->Reset());
1645 EXPECT_EQ(MSERR_OK, player_->Release());
1646 player_ = nullptr;
1647 system("param set debug.media_service.histreamer 0");
1648 }
1649
1650 /**
1651 * @tc.name : Test Player Histreamer
1652 * @tc.number: Player_Histreamer_002
1653 * @tc.desc : Test Player function with Histreamer
1654 */
1655 HWTEST_F(PlayerUnitTest, Player_Histreamer_002, TestSize.Level0)
1656 {
1657 EXPECT_EQ(MSERR_OK, player_->Release());
1658 system("param set debug.media_service.histreamer 1");
1659 callback_ = std::make_shared<PlayerCallbackTest>();
1660 ASSERT_NE(nullptr, callback_);
1661 player_ = std::make_shared<PlayerMock>(callback_);
1662 ASSERT_NE(nullptr, player_);
1663 EXPECT_TRUE(player_->CreatePlayer());
1664 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
1665
1666 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3", 0, 0));
1667 sptr<Surface> videoSurface = player_->GetVideoSurface();
1668 ASSERT_NE(nullptr, videoSurface);
1669 EXPECT_EQ(MSERR_OK, player_->SetVideoSurface(videoSurface));
1670 GetSetParaFunTest();
1671 player_->PrepareAsync();
1672 player_->PrepareAsync();
1673 GetSetParaFunTest();
1674 player_->Play();
1675 player_->Play();
1676 GetSetParaFunTest();
1677 player_->Pause();
1678 player_->Pause();
1679 GetSetParaFunTest();
1680 player_->Play();
1681 player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC);
1682 player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC);
1683 player_->Pause();
1684 player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC);
1685 player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST_SYNC);
1686 player_->Stop();
1687 player_->Stop();
1688 player_->Pause();
1689 player_->Play();
1690 GetSetParaFunTest();
1691 EXPECT_EQ(MSERR_OK, player_->Reset());
1692 player_->Pause();
1693 player_->Play();
1694 GetSetParaFunTest();
1695 EXPECT_EQ(MSERR_OK, player_->Release());
1696 player_ = nullptr;
1697 system("param set debug.media_service.histreamer 0");
1698 }
1699
1700 /**
1701 * @tc.name : Test Histreamer
1702 * @tc.number: Player_Histreamer_003
1703 * @tc.desc : Test Player Histreamer
1704 */
1705 HWTEST_F(PlayerUnitTest, Player_Histreamer_003, TestSize.Level0)
1706 {
1707 EXPECT_EQ(MSERR_OK, player_->Release());
1708 system("param set debug.media_service.histreamer 1");
1709 callback_ = std::make_shared<PlayerCallbackTest>();
1710 ASSERT_NE(nullptr, callback_);
1711 player_ = std::make_shared<PlayerMock>(callback_);
1712 ASSERT_NE(nullptr, player_);
1713 EXPECT_TRUE(player_->CreatePlayer());
1714 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
1715 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "01.mp3", 0, 0));
1716 EXPECT_EQ(MSERR_OK, player_->Prepare());
1717 EXPECT_EQ(MSERR_OK, player_->Play());
1718 EXPECT_NE(MSERR_OK, player_->SetVolume(1.1, 0.1));
1719 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, 1.1));
1720 EXPECT_NE(MSERR_OK, player_->SetVolume(-0.1, 0.1));
1721 EXPECT_NE(MSERR_OK, player_->SetVolume(0.1, -0.1));
1722 player_->Seek(0, SEEK_NEXT_SYNC);
1723 player_->Seek(0, SEEK_PREVIOUS_SYNC);
1724 player_->Seek(0, SEEK_CLOSEST_SYNC);
1725 player_->IsPlaying();
1726 player_->Seek(SEEK_TIME_2_SEC, SEEK_NEXT_SYNC);
1727 player_->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC);
1728 player_->Seek(SEEK_TIME_2_SEC, SEEK_CLOSEST_SYNC);
1729 player_->Seek(SEEK_TIME_2_SEC, (PlayerSeekMode)5);
1730 EXPECT_EQ(MSERR_OK, player_->Release());
1731 player_ = nullptr;
1732 system("param set debug.media_service.histreamer 0");
1733 }
1734
1735 /**
1736 * @tc.name : Test Histreamer
1737 * @tc.number: Player_Histreamer_004
1738 * @tc.desc : Test Player Histreamer
1739 */
1740 HWTEST_F(PlayerUnitTest, Player_Histreamer_004, TestSize.Level0)
1741 {
1742 PlaybackRateMode mode;
1743 int32_t time = 0;
1744 int32_t duration = 0;
1745 std::vector<Format> videoTrack;
1746 std::vector<Format> audioTrack;
1747 EXPECT_EQ(MSERR_OK, player_->Release());
1748 system("param set debug.media_service.histreamer 1");
1749 callback_ = std::make_shared<PlayerCallbackTest>();
1750 ASSERT_NE(nullptr, callback_);
1751 player_ = std::make_shared<PlayerMock>(callback_);
1752 ASSERT_NE(nullptr, player_);
1753 EXPECT_TRUE(player_->CreatePlayer());
1754 EXPECT_EQ(MSERR_OK, player_->SetPlayerCallback(callback_));
1755 ASSERT_EQ(MSERR_OK, player_->SetSource(MEDIA_ROOT + "1kb.mp3", 0, 0));
1756 EXPECT_NE(MSERR_OK, player_->PrepareAsync());
1757 EXPECT_NE(MSERR_OK, player_->Prepare());
1758 Format format;
1759 format.PutIntValue(PlayerKeys::VIDEO_SCALE_TYPE, VideoScaleType::VIDEO_SCALE_TYPE_FIT);
1760 EXPECT_NE(MSERR_OK, player_->SetParameter(format));
1761 player_->SetVolume(1, 1);
1762 EXPECT_NE(MSERR_OK, player_->Play());
1763 EXPECT_EQ(false, player_->IsPlaying());
1764 EXPECT_NE(MSERR_OK, player_->Pause());
1765 EXPECT_NE(MSERR_OK, player_->Seek(0, SEEK_CLOSEST));
1766 player_->SetLooping(true);
1767 player_->IsLooping();
1768 player_->SetVolume(1, 1);
1769 player_->SetPlaybackSpeed(SPEED_FORWARD_2_00_X);
1770 player_->GetPlaybackSpeed(mode);
1771 player_->GetCurrentTime(time);
1772 player_->GetDuration(duration);
1773 player_->GetVideoTrackInfo(videoTrack);
1774 player_->GetAudioTrackInfo(audioTrack);
1775 player_->GetVideoHeight();
1776 player_->GetVideoWidth();
1777 EXPECT_NE(MSERR_OK, player_->Stop());
1778 EXPECT_EQ(MSERR_OK, player_->Reset());
1779 EXPECT_EQ(MSERR_OK, player_->Release());
1780 player_ = nullptr;
1781 system("param set debug.media_service.histreamer 0");
1782 }
1783 } // namespace Media
1784 } // namespace OHOS
1785