1 /*
2 * Copyright (c) 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 "cachebuffer_unit_test.h"
17 #include "media_errors.h"
18
19 using namespace OHOS;
20 using namespace OHOS::Media;
21 using namespace testing::ext;
22 using namespace std;
23
24 static const std::string g_fileName[6] = {
25 {"/data/test/test_06.ogg"},
26 {"/data/test/test_02.mp3"},
27 {"/data/test/test_01.mp3"},
28 {"/data/test/test_05.ogg"},
29 {"/data/test/test_03.mp3"},
30 {"/data/test/test_04.mp3"},
31 };
32
33 namespace OHOS {
34 namespace Media {
35 static const std::string THREAD_POOL_NAME_CACHE_BUFFER = "OS_UnitCacheBuf";
36
SetUpTestCase(void)37 void CacheBufferUnitTest::SetUpTestCase(void) {}
38
TearDownTestCase(void)39 void CacheBufferUnitTest::TearDownTestCase(void) {}
40
SetUp(void)41 void CacheBufferUnitTest::SetUp(void)
42 {
43 cacheBuffer_ = std::make_shared<CacheBufferMock>();
44 ASSERT_NE(nullptr, cacheBuffer_);
45 }
46
TearDown(void)47 void CacheBufferUnitTest::TearDown(void)
48 {
49 if (isCacheBufferStopThreadPoolStarted_.load()) {
50 if (cacheBufferStopThreadPool_ != nullptr) {
51 cacheBufferStopThreadPool_->Stop();
52 }
53 isCacheBufferStopThreadPoolStarted_.store(false);
54 }
55 if (cacheBuffer_ != nullptr) {
56 cacheBuffer_.reset();
57 }
58 sleep(waitTime1);
59 }
60
CreateCacheBuffer(const Format & trackFormat,const int32_t & soundID,const int32_t & streamID)61 void CacheBufferUnitTest::CreateCacheBuffer(const Format &trackFormat,
62 const int32_t &soundID, const int32_t &streamID)
63 {
64 if (cacheBuffer_ != nullptr) {
65 cacheBufferStopThreadPool_ = std::make_shared<ThreadPool>(THREAD_POOL_NAME_CACHE_BUFFER);
66 cacheBufferStopThreadPool_->Start(waitTime1);
67 cacheBufferStopThreadPool_->SetMaxTaskNum(waitTime1);
68 isCacheBufferStopThreadPoolStarted_.store(true);
69 cacheBuffer_->CreateCacheBuffer(trackFormat, soundID, streamID, cacheBufferStopThreadPool_);
70 } else {
71 cout << "create cacheBuffer failed" << endl;
72 }
73 }
74
GetFdByFileName(std::string fileName)75 int32_t CacheBufferUnitTest::GetFdByFileName(std::string fileName)
76 {
77 int32_t loadFd = open(fileName.c_str(), O_RDWR);
78 if (loadFd <= 0) {
79 cout << "Url open failed, g_fileName " << fileName.c_str() << ", fd: " << loadFd << endl;
80 }
81 return loadFd;
82 }
83
84 /**
85 * @tc.name: soundpool_cacheBuffer_001
86 * @tc.desc: function test soundpool singleton
87 * @tc.type: FUNC
88 * @tc.require:
89 */
90 HWTEST_F(CacheBufferUnitTest, soundpool_cacheBuffer_001, TestSize.Level0)
91 {
92 MEDIA_LOGI("CacheBufferUnitTest soundpool_cacheBuffer_001 before");
93 std::shared_ptr<SoundPool> impl;
94 EXPECT_EQ(MSERR_OK, SoundPoolManager::GetInstance().GetSoundPool(getpid(), impl));
95 EXPECT_EQ(MSERR_OK, SoundPoolManager::GetInstance().GetSoundPool(getpid(), impl));
96 sleep(waitTime1);
97 EXPECT_EQ(MSERR_OK, SoundPoolManager::GetInstance().Release(getpid()));
98 EXPECT_EQ(MSERR_OK, SoundPoolManager::GetInstance().Release(123));
99 MEDIA_LOGI("CacheBufferUnitTest soundpool_cacheBuffer_001 after");
100 }
101
102 /**
103 * @tc.name: soundpool_rendererInfo_001
104 * @tc.desc: function test renderInfo result
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(CacheBufferUnitTest, soundpool_rendererInfo_001, TestSize.Level2)
109 {
110 MEDIA_LOGI("CacheBufferUnitTest soundpool_rendererInfo_001 before");
111 int32_t soundID = 1;
112 int32_t streamID = 1;
113 Format format;
114 CreateCacheBuffer(format, soundID, streamID);
115 AudioStandard::AudioRendererInfo audioRenderInfo1;
116 audioRenderInfo1.contentType = CONTENT_TYPE_UNKNOWN;
117 audioRenderInfo1.streamUsage = STREAM_USAGE_MOVIE;
118 EXPECT_EQ(true, cacheBuffer_->IsAudioRendererCanMix(audioRenderInfo1));
119 sleep(waitTime1);
120 AudioStandard::AudioRendererInfo audioRenderInfo2;
121 audioRenderInfo2.contentType = CONTENT_TYPE_UNKNOWN;
122 audioRenderInfo2.streamUsage = STREAM_USAGE_AUDIOBOOK;
123 EXPECT_EQ(true, cacheBuffer_->IsAudioRendererCanMix(audioRenderInfo2));
124 sleep(waitTime1);
125 AudioStandard::AudioRendererInfo audioRenderInfo3;
126 audioRenderInfo3.contentType = CONTENT_TYPE_UNKNOWN;
127 audioRenderInfo3.streamUsage = STREAM_USAGE_SYSTEM;
128 EXPECT_EQ(false, cacheBuffer_->IsAudioRendererCanMix(audioRenderInfo3));
129 MEDIA_LOGI("CacheBufferUnitTest soundpool_rendererInfo_001 after");
130 }
131
132 /**
133 * @tc.name: soundpool_createAudioRenderer_001
134 * @tc.desc: function test createAudioRenderer result
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(CacheBufferUnitTest, soundpool_createAudioRenderer_001, TestSize.Level2)
139 {
140 MEDIA_LOGI("CacheBufferUnitTest soundpool_createAudioRenderer_001 before");
141 int32_t soundID = 1;
142 int32_t streamID = 1;
143 Format format;
144 CreateCacheBuffer(format, soundID, streamID);
145 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
146 AudioStandard::AudioRendererInfo audioRenderInfo;
147 audioRenderInfo.contentType = CONTENT_TYPE_UNKNOWN;
148 audioRenderInfo.streamUsage = STREAM_USAGE_MOVIE;
149 std::string cacheDir = "/data/storage/el2/base/temp";
150 struct PlayParams playParameters;
151 playParameters.loop = -1;
152 playParameters.rate = 1;
153 playParameters.leftVolume = 0.5;
154 playParameters.rightVolume = 0.3;
155 playParameters.priority = 1;
156 playParameters.parallelPlayFlag = true;
157 playParameters.cacheDir = cacheDir;
158 cacheBuffer_->CreateAudioRenderer(streamID, audioRenderInfo, playParameters);
159 EXPECT_EQ(streamID, cacheBuffer_->cacheBuffer_->streamID_);
160 MEDIA_LOGI("CacheBufferUnitTest soundpool_createAudioRenderer_001 after");
161 }
162
163 /**
164 * @tc.name: soundpool_CheckAndAlignRendererRate_001
165 * @tc.desc: function test CheckAndAlignRendererRate result
166 * @tc.type: FUNC
167 * @tc.require:
168 */
169 HWTEST_F(CacheBufferUnitTest, soundpool_CheckAndAlignRendererRate_001, TestSize.Level2)
170 {
171 MEDIA_LOGI("CacheBufferUnitTest soundpool_CheckAndAlignRendererRate_001 before");
172 int32_t soundID = 1;
173 int32_t streamID = 1;
174 Format format;
175 CreateCacheBuffer(format, soundID, streamID);
176 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
177 EXPECT_EQ(AudioRendererRate::RENDER_RATE_NORMAL, cacheBuffer_->cacheBuffer_->CheckAndAlignRendererRate(-1));
178 MEDIA_LOGI("CacheBufferUnitTest soundpool_CheckAndAlignRendererRate_001 after");
179 }
180
181 /**
182 * @tc.name: soundpool_OnWriteData_001
183 * @tc.desc: function test OnWriteData result
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(CacheBufferUnitTest, soundpool_OnWriteData_001, TestSize.Level2)
188 {
189 MEDIA_LOGI("CacheBufferUnitTest soundpool_OnWriteData_001 before");
190 int32_t soundID = 1;
191 int32_t streamID = 1;
192 Format format;
193 CreateCacheBuffer(format, soundID, streamID);
194 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
195 cacheBuffer_->cacheBuffer_->audioRenderer_ = nullptr;
196 size_t length = 10;
197 cacheBuffer_->cacheBuffer_->OnWriteData(length);
198 EXPECT_EQ(streamID, cacheBuffer_->cacheBuffer_->streamID_);
199 MEDIA_LOGI("CacheBufferUnitTest soundpool_OnWriteData_001 after");
200 }
201
202 /**
203 * @tc.name: soundpool_OnInterrupt_001
204 * @tc.desc: function test OnInterrupt result
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(CacheBufferUnitTest, soundpool_OnInterrupt_001, TestSize.Level2)
209 {
210 MEDIA_LOGI("CacheBufferUnitTest soundpool_OnInterrupt_001 before");
211 int32_t soundID = 1;
212 int32_t streamID = 1;
213 Format format;
214 CreateCacheBuffer(format, soundID, streamID);
215 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
216 struct InterruptEvent interruptEvent;
217 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_PAUSE;
218 cacheBuffer_->cacheBuffer_->OnInterrupt(interruptEvent);
219 struct InterruptEvent interruptEvent2;
220 interruptEvent2.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_STOP;
221 cacheBuffer_->cacheBuffer_->OnInterrupt(interruptEvent2);
222 EXPECT_EQ(streamID, cacheBuffer_->cacheBuffer_->streamID_);
223 MEDIA_LOGI("CacheBufferUnitTest soundpool_OnInterrupt_001 after");
224 }
225
226 /**
227 * @tc.name: soundpool_SetParallelPlayFlag_001
228 * @tc.desc: function test SetParallelPlayFlag result
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(CacheBufferUnitTest, soundpool_SetParallelPlayFlag_001, TestSize.Level2)
233 {
234 MEDIA_LOGI("CacheBufferUnitTest soundpool_SetParallelPlayFlag_001 before");
235 int32_t soundID = 1;
236 int32_t streamID = 1;
237 Format format;
238 CreateCacheBuffer(format, soundID, streamID);
239 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
240 EXPECT_EQ(MSERR_OK, cacheBuffer_->cacheBuffer_->SetParallelPlayFlag(streamID, true));
241 MEDIA_LOGI("CacheBufferUnitTest soundpool_SetParallelPlayFlag_001 after");
242 }
243
244 /**
245 * @tc.name: soundpool_SoundParseOnError_001
246 * @tc.desc: function test SoundParse OnError result
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(CacheBufferUnitTest, soundpool_SoundParseOnError_001, TestSize.Level2)
251 {
252 MEDIA_LOGI("CacheBufferUnitTest soundpool_SoundParseOnError_001 before");
253 int32_t soundID = 1;
254 int32_t streamID = 1;
255 bool isRawFile = true;
256 Format format;
257 CreateCacheBuffer(format, soundID, streamID);
258 cacheBuffer_->cacheBuffer_->streamID_ = streamID;
259 int32_t fd = GetFdByFileName(g_fileName[soundID]);
260 EXPECT_GT(fd, 0);
261 size_t filesize = cacheBuffer_->GetFileSize(g_fileName[soundID]);
262 int64_t length = static_cast<int64_t>(filesize);
263 std::shared_ptr<MediaAVCodec::AVSource> source =
264 MediaAVCodec::AVSourceFactory::CreateWithFD(fd, 0, length);
265 ASSERT_NE(nullptr, source);
266 std::shared_ptr<MediaAVCodec::AVDemuxer> demuxer = MediaAVCodec::AVDemuxerFactory::CreateWithSource(source);
267 ASSERT_NE(nullptr, demuxer);
268 std::shared_ptr<MediaAVCodec::AVCodecAudioDecoder> audioDec =
269 MediaAVCodec::AudioDecoderFactory::CreateByMime("audio/mpeg");
270 std::shared_ptr<SoundDecoderCallback> audioDecCb_ =
271 std::make_shared<SoundDecoderCallback>(soundID, audioDec, demuxer, isRawFile);
272 audioDecCb_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, MSERR_INVALID_OPERATION);
273 audioDecCb_->OnOutputFormatChanged(format);
274 audioDecCb_->demuxer_ = nullptr;
275 audioDecCb_->OnInputBufferAvailable(0, nullptr);
276 audioDecCb_->demuxer_ = demuxer;
277 std::shared_ptr<AVSharedMemory> buffer = std::make_shared<AVSharedMemoryBase>(1,
278 AVSharedMemory::Flags::FLAGS_READ_WRITE, "testBufferMemory");
279 audioDecCb_->decodeShouldCompleted_ = false;
280 audioDecCb_->OnInputBufferAvailable(0, buffer);
281 audioDecCb_->isRawFile_ = false;
282 audioDecCb_->eosFlag_ = false;
283 audioDecCb_->OnInputBufferAvailable(0, buffer);
284 if (fd > 0) {
285 (void)::close(fd);
286 }
287 EXPECT_EQ(streamID, cacheBuffer_->cacheBuffer_->streamID_);
288 MEDIA_LOGI("CacheBufferUnitTest soundpool_SoundParseOnError_001 after");
289 }
290 } // namespace Media
291 } // namespace OHOS