1 /*
2  * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "gtest/gtest.h"
17 #include <chrono>
18 #include <fcntl.h>
19 #include <cmath>
20 #include <thread>
21 #include "foundation/log.h"
22 #include "scenetest/helper/test_player.hpp"
23 
24 #ifndef WIN32
25 #define RESOURCE_DIR "/data/test/media/"
26 using namespace testing::ext;
27 #endif
28 
29 using namespace OHOS::Media::Plugin;
30 using namespace OHOS::Media::Test;
31 
32 namespace OHOS {
33 namespace Media {
34 namespace Test {
35     class UtTestFastPlayer : public ::testing::Test {
36     public:
SetUp()37         void SetUp() override
38         {
39         }
TearDown()40         void TearDown() override
41         {
42         }
43     };
44 
CheckTimeEquality(int32_t expectValue,int32_t currentValue)45     bool CheckTimeEquality(int32_t expectValue, int32_t currentValue)
46     {
47         MEDIA_LOG_I("expectValue : %d, currentValue : %d", expectValue, currentValue);
48         return fabs(expectValue - currentValue) < 1000; // if open debug log, should use value >= 1000
49     }
50 
TestSinglePlayerFinishedAutomatically(std::string url)51     void TestSinglePlayerFinishedAutomatically(std::string url)
52     {
53         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
54         ASSERT_EQ(0, player->SetSource(TestSource(url)));
55         ASSERT_EQ(0, player->Prepare());
56         ASSERT_EQ(0, player->Play());
57         while (player->IsPlaying()) {
58             std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
59         }
60     }
61 
TestSinglePlayerFinishedManually(std::string url)62     void TestSinglePlayerFinishedManually(std::string url)
63     {
64         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
65         ASSERT_EQ(0, player->SetSource(TestSource(url)));
66         ASSERT_EQ(0, player->Prepare());
67         ASSERT_EQ(0, player->Play());
68         std::vector<OHOS::Media::Format> audioTrack;
69         ASSERT_EQ(0, player->GetAudioTrackInfo(audioTrack));
70         ASSERT_TRUE(player->IsPlaying());
71         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
72         ASSERT_EQ(0, player->Pause());
73         ASSERT_EQ(0, player->Stop());
74         ASSERT_EQ(0, player->Reset());
75         ASSERT_EQ(0, player->Release());
76     }
77 
TestSinglePlayerGetDuration(std::string url,int32_t expectDuration)78     void TestSinglePlayerGetDuration(std::string url, int32_t expectDuration)
79     {
80         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
81         ASSERT_EQ(0, player->SetSource(TestSource(url)));
82         ASSERT_EQ(0, player->Prepare());
83         ASSERT_EQ(0, player->Play());
84         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
85         int64_t duration;
86         ASSERT_EQ(0, player->GetDuration(duration));
87         ASSERT_TRUE(CheckTimeEquality(expectDuration, duration));
88         ASSERT_EQ(0, player->Stop());
89     }
90 
TestSinglePlayerGetCurrentTime(std::string url)91     void TestSinglePlayerGetCurrentTime(std::string url)
92     {
93         int64_t currentMS {0};
94         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
95         ASSERT_EQ(0, player->SetSource(TestSource(url)));
96         ASSERT_EQ(0, player->Prepare());
97         ASSERT_EQ(0, player->Play());
98         ASSERT_TRUE(player->IsPlaying());
99         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
100         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
101         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
102         ASSERT_TRUE(CheckTimeEquality(1000, currentMS)); // 1000 MS
103         ASSERT_EQ(0, player->Stop());
104     }
105 
TestSinglePlayerSeek(std::string url)106     void TestSinglePlayerSeek(std::string url)
107     {
108         int64_t seekPos {5000};
109         int64_t currentMS {0};
110         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
111         ASSERT_EQ(0, player->SetSource(TestSource(url)));
112         ASSERT_EQ(0, player->Prepare());
113         ASSERT_EQ(0, player->Play());
114         ASSERT_TRUE(player->IsPlaying());
115         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
116         ASSERT_EQ(0, player->Seek(seekPos));
117         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
118         EXPECT_TRUE(CheckTimeEquality(seekPos, currentMS));
119         std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 2000 MS
120         ASSERT_EQ(0, player->Stop());
121     }
122 
TestSinglePlayerSeekPause(std::string url)123     void TestSinglePlayerSeekPause(std::string url)
124     {
125         int64_t seekPos {5000}; // 5000 MS
126         int64_t currentMS {0};
127         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
128         ASSERT_EQ(0, player->SetSource(TestSource(url)));
129         ASSERT_EQ(0, player->Prepare());
130         ASSERT_EQ(0, player->Play());
131         ASSERT_TRUE(player->IsPlaying());
132         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
133         ASSERT_EQ(0, player->Pause());
134         ASSERT_EQ(0, player->Seek(seekPos));
135         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
136         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
137         ASSERT_TRUE(CheckTimeEquality(seekPos, currentMS)); // pause + seek still pause
138         ASSERT_EQ(0, player->Stop());
139     }
140 
TestSinglePlayerPauseSeek(std::string url)141     void TestSinglePlayerPauseSeek(std::string url)
142     {
143         int64_t seekPos {5000}; // 5000 MS
144         int64_t currentMS {0};
145         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
146         ASSERT_EQ(0, player->SetSource(TestSource(url)));
147         ASSERT_EQ(0, player->Prepare());
148         ASSERT_EQ(0, player->Play());
149         ASSERT_TRUE(player->IsPlaying());
150         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
151         ASSERT_EQ(0, player->Pause());
152         ASSERT_EQ(0, player->Seek(seekPos));
153         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
154         ASSERT_EQ(0, player->GetCurrentTime(currentMS));
155         ASSERT_TRUE(CheckTimeEquality(seekPos, currentMS)); // pause + seek still pause
156         ASSERT_EQ(0, player->Stop());
157     }
158 
TestSinglePlayerSingleLoop(std::string url)159     void TestSinglePlayerSingleLoop(std::string url)
160     {
161         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
162         ASSERT_EQ(0, player->SetSource(TestSource(url)));
163         ASSERT_EQ(0, player->SetSingleLoop(true));
164         ASSERT_EQ(0, player->Prepare());
165         ASSERT_EQ(0, player->Play());
166         std::this_thread::sleep_for(std::chrono::seconds(20)); // 20 second
167         ASSERT_EQ(0, player->Stop());
168     }
169 
TestSinglePlayerHttp(std::string url)170     void TestSinglePlayerHttp(std::string url)
171     {
172         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
173         ASSERT_EQ(0, player->SetSource(TestSource(url)));
174         ASSERT_EQ(0, player->Prepare());
175         ASSERT_EQ(0, player->Play());
176         std::this_thread::sleep_for(std::chrono::seconds(20)); // 20 second
177         ASSERT_EQ(0, player->Seek(10000)); // 10000 ms
178         std::this_thread::sleep_for(std::chrono::seconds(10)); // 10 second
179         ASSERT_EQ(0, player->Stop());
180     }
181 
TestSinglePlayerHls(std::string url)182     void TestSinglePlayerHls(std::string url)
183     {
184         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
185         ASSERT_EQ(0, player->SetSource(TestSource(url)));
186         ASSERT_EQ(0, player->Prepare());
187         ASSERT_EQ(0, player->Play());
188         std::this_thread::sleep_for(std::chrono::seconds(5)); // 5 second
189         ASSERT_EQ(0, player->Stop());
190     }
191 
TestSinglePlayerSeekNearEnd(std::string url,int32_t expectDuration)192     void TestSinglePlayerSeekNearEnd(std::string url, int32_t expectDuration)
193     {
194         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
195         ASSERT_EQ(0, player->SetSource(TestSource(url)));
196         ASSERT_EQ(0, player->Prepare());
197         ASSERT_EQ(0, player->Play());
198         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
199         int64_t duration;
200         ASSERT_EQ(0, player->GetDuration(duration));
201         ASSERT_TRUE(CheckTimeEquality(expectDuration, duration));
202         int32_t count = 5;
203         while (count > 0) {
204             NZERO_LOG(player->Seek(duration - 100)); // 100 MS
205             NZERO_LOG(player->Seek(0));
206             count--;
207         }
208         ASSERT_EQ(0, player->Reset());
209         ASSERT_EQ(0, player->Release());
210     }
211 
TestSinglePlayerFinishPlayAgain(std::string url)212     void TestSinglePlayerFinishPlayAgain(std::string url)
213     {
214         std::unique_ptr<TestPlayer> player = TestPlayer::Create();
215         ASSERT_EQ(0, player->SetSource(TestSource(url)));
216         ASSERT_EQ(0, player->Prepare());
217         ASSERT_EQ(0, player->Play());
218         while (player->IsPlaying()) {
219             std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
220         }
221         ASSERT_EQ(0, player->Play());
222         while (player->IsPlaying()) {
223             std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000 MS
224         }
225     }
226 
227     HST_TEST(UtTestFastPlayer, TestSinglePlayerFinishedAutomatically, TestSize.Level1)
228     {
229         std::vector<std::string> vecSource;
230         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
231         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_48000_32_SHORT.mp3"));
232         vecSource.push_back(std::string(RESOURCE_DIR "/AAC/AAC_48000_32_SHORT.aac"));
233         vecSource.push_back(std::string(RESOURCE_DIR "/FLAC/vorbis_48000_32_SHORT.flac"));
234         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_SHORT.m4a"));
235         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
236         for (auto url : vecSource)
237         {
238             TestSinglePlayerFinishedAutomatically(url);
239         }
240     }
241 
242     HST_TEST(UtTestFastPlayer, TestSinglePlayerFinishedManually, TestSize.Level1)
243     {
244         std::vector<std::string> vecSource;
245         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_SHORT.m4a"));
246         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
247         vecSource.push_back(std::string(RESOURCE_DIR "/AAC/AAC_48000_32_SHORT.aac"));
248         vecSource.push_back(std::string(RESOURCE_DIR "/FLAC/vorbis_48000_32_SHORT.flac"));
249         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
250         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
251         for (auto url : vecSource)
252         {
253             TestSinglePlayerFinishedManually(url);
254         }
255     }
256 
257     HST_TEST(UtTestFastPlayer, TestSinglePlayerGetDuration, TestSize.Level1)
258     {
259         std::vector<std::string> vecSource;
260         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
261         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
262         for (auto url : vecSource)
263         {
264             TestSinglePlayerGetDuration(url, 30000); // 30000 MS
265         }
266         TestSinglePlayerGetDuration(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"),
267                                         5000); // 5000 MS
268     }
269 
270     HST_TEST(UtTestFastPlayer, TestSinglePlayerGetCurrentTime, TestSize.Level1)
271     {
272         std::vector<std::string> vecSource;
273         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
274         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
275         vecSource.push_back(std::string("http://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
276         for (auto url : vecSource)
277         {
278             TestSinglePlayerGetCurrentTime(url);
279         }
280     }
281 
282     HST_TEST(UtTestFastPlayer, TestSinglePlayerSeek, TestSize.Level1)
283     {
284         std::vector<std::string> vecSource;
285         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
286         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
287         vecSource.push_back(std::string("http://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
288         for (auto url : vecSource)
289         {
290             TestSinglePlayerSeek(url);
291         }
292     }
293 
294     HST_TEST(UtTestFastPlayer, TestSinglePlayerSeekPause, TestSize.Level1)
295     {
296         std::vector<std::string> vecSource;
297         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
298         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
299         vecSource.push_back(std::string("http://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
300         for (auto url : vecSource)
301         {
302             TestSinglePlayerSeekPause(url);
303         }
304     }
305 
306     HST_TEST(UtTestFastPlayer, TestSinglePlayerPauseSeek, TestSize.Level1)
307     {
308         std::vector<std::string> vecSource;
309         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
310         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
311         vecSource.push_back(std::string("http://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
312         for (auto url : vecSource)
313         {
314             TestSinglePlayerPauseSeek(url);
315         }
316     }
317 
318     HST_TEST(UtTestFastPlayer, TestSinglePlayerSingleLoop, TestSize.Level1)
319     {
320         std::vector<std::string> vecSource;
321         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_SHORT.m4a"));
322         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
323         vecSource.push_back(std::string(RESOURCE_DIR "/AAC/AAC_48000_32_SHORT.aac"));
324         vecSource.push_back(std::string(RESOURCE_DIR "/FLAC/vorbis_48000_32_SHORT.flac"));
325         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
326         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
327         for (auto url : vecSource)
328         {
329             TestSinglePlayerSingleLoop(url);
330         }
331     }
332 
333     HST_TEST(UtTestFastPlayer, TestSinglePlayerHttp, TestSize.Level1)
334     {
335         std::vector<std::string> vecSource;
336         vecSource.push_back(std::string("http://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
337         vecSource.push_back(std::string("https://img.51miz.com/preview/sound/00/26/73/51miz-S267356-423D33372.mp3"));
338         for (auto url : vecSource)
339         {
340             TestSinglePlayerHttp(url);
341         }
342     }
343 
344     HST_TEST(UtTestFastPlayer, TestSinglePlayerHls, TestSize.Level1)
345     {
346         std::vector<std::string> vecSource;
347         vecSource.push_back(std::string("http://220.161.87.62:8800/hls/2/index.m3u8"));
348         for (auto url : vecSource)
349         {
350             TestSinglePlayerHls(url);
351         }
352     }
353 
354     HST_TEST(UtTestFastPlayer, TestSinglePlayerSeekNearEnd, TestSize.Level1)
355     {
356         std::vector<std::string> vecSource;
357         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
358         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_LONG.m4a"));
359         for (auto url : vecSource)
360         {
361             TestSinglePlayerSeekNearEnd(url, 30000); // 30000 MS
362         }
363     }
364 
365     HST_TEST(UtTestFastPlayer, TestSinglePlayerFinishPlayAgain, TestSize.Level1)
366     {
367         std::vector<std::string> vecSource;
368         vecSource.push_back(std::string(RESOURCE_DIR "/M4A/MPEG-4_48000_32_SHORT.m4a"));
369         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
370         vecSource.push_back(std::string(RESOURCE_DIR "/AAC/AAC_48000_32_SHORT.aac"));
371         vecSource.push_back(std::string(RESOURCE_DIR "/FLAC/vorbis_48000_32_SHORT.flac"));
372         vecSource.push_back(std::string(RESOURCE_DIR "/MP3/MP3_LONG_48000_32.mp3"));
373         vecSource.push_back(std::string(RESOURCE_DIR "/WAV/vorbis_48000_32_SHORT.wav"));
374         for (auto url : vecSource)
375         {
376             TestSinglePlayerFinishPlayAgain(url);
377         }
378     }
379 
380     } // namespace Test
381 } // namespace Media
382 } // namespace OHOS
383