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 "audio_sink.h"
18 #include "audio_effect.h"
19 #include "filter/filter.h"
20 #include "common/log.h"
21 #include "sink/media_synchronous_sink.h"
22 
23 namespace {
24 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_ONLY_PRERELEASE, LOG_DOMAIN_SYSTEM_PLAYER, "AudioSinkTest" };
25 }
26 
27 using namespace testing::ext;
28 
29 namespace OHOS {
30 namespace Media {
31 namespace Test {
32 
33 class TestEventReceiver : public Pipeline::EventReceiver {
34 public:
TestEventReceiver()35     explicit TestEventReceiver()
36     {
37         MEDIA_LOG_I("TestEventReceiver ctor ");
38     }
39 
OnEvent(const Event & event)40     void OnEvent(const Event &event)
41     {
42         MEDIA_LOG_I("TestEventReceiver OnEvent " PUBLIC_LOG_S, event.srcFilter.c_str());
43     }
44 
45 private:
46 };
47 
AudioSinkCreate()48 std::shared_ptr<AudioSink> AudioSinkCreate()
49 {
50     auto audioSink = std::make_shared<AudioSink>();
51     std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
52     auto meta = std::make_shared<Meta>();
53     auto initStatus = audioSink->Init(meta, testEventReceiver);
54     if (initStatus == Status::OK) {
55         return audioSink;
56     } else {
57         return nullptr;
58     }
59 }
60 
61 HWTEST(TestAudioSink, find_audio_sink_process, TestSize.Level1)
62 {
63     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
64     ASSERT_TRUE(audioSink != nullptr);
65     auto preStatus = audioSink->Prepare();
66     ASSERT_TRUE(preStatus == Status::OK);
67     auto startStatus = audioSink->Start();
68     ASSERT_TRUE(startStatus == Status::OK);
69     auto pauseStatus = audioSink->Pause();
70     ASSERT_TRUE(pauseStatus == Status::OK);
71     auto stopStatus = audioSink->Stop();
72     ASSERT_TRUE(stopStatus == Status::OK);
73     auto flushStatus = audioSink->Flush();
74     ASSERT_TRUE(flushStatus == Status::OK);
75     auto resumeStatus = audioSink->Resume();
76     ASSERT_TRUE(resumeStatus == Status::OK);
77     auto freeStatus = audioSink->Release();
78     ASSERT_TRUE(freeStatus == Status::OK);
79 }
80 
81 HWTEST(TestAudioSink, find_audio_sink_set_volume, TestSize.Level1)
82 {
83     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
84     ASSERT_TRUE(audioSink != nullptr);
85     float volume = 0.5f;
86     auto setVolumeStatus =  audioSink->SetVolume(volume);
87     ASSERT_TRUE(setVolumeStatus == Status::OK);
88 
89     // SetVolumeWithRamp
90     float targetVolume = 0;
91     int32_t duration = 0;
92     auto setVolumeWithRampStatus = audioSink->SetVolumeWithRamp(targetVolume, duration);
93     ASSERT_TRUE(setVolumeWithRampStatus == 0);
94 }
95 
96 HWTEST(TestAudioSink, find_audio_sink_set_sync_center, TestSize.Level1)
97 {
98     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
99     ASSERT_TRUE(audioSink != nullptr);
100     float volume = 0.5f;
101     auto setVolumeStatus =  audioSink->SetVolume(volume);
102     ASSERT_TRUE(setVolumeStatus == Status::OK);
103 
104     // SetVolumeWithRamp
105     float targetVolume = 0;
106     int32_t duration = 0;
107     auto setVolumeWithRampStatus = audioSink->SetVolumeWithRamp(targetVolume, duration);
108     ASSERT_TRUE(setVolumeWithRampStatus == 0);
109 
110     // SetSyncCenter
111     auto syncCenter = std::make_shared<Pipeline::MediaSyncManager>();
112     audioSink->SetSyncCenter(syncCenter);
113 }
114 
115 HWTEST(TestAudioSink, find_audio_sink_set_speed, TestSize.Level1)
116 {
117     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
118     ASSERT_TRUE(audioSink != nullptr);
119     float speed = 1.0f;
120     auto setVolumeStatus =  audioSink->SetSpeed(speed);
121     ASSERT_TRUE(setVolumeStatus == Status::OK);
122 }
123 
124 HWTEST(TestAudioSink, find_audio_sink_audio_effect, TestSize.Level1)
125 {
126     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
127     ASSERT_TRUE(audioSink != nullptr);
128     auto setEffectStatus =  audioSink->SetAudioEffectMode(AudioStandard::EFFECT_NONE);
129     ASSERT_TRUE(setEffectStatus == Status::OK);
130     int32_t audioEffectMode;
131     auto getEffectStatus =  audioSink->GetAudioEffectMode(audioEffectMode);
132     ASSERT_TRUE(getEffectStatus == Status::OK);
133 }
134 
135 HWTEST(TestAudioSink, find_audio_sink_audio_reset_sync_info, TestSize.Level1)
136 {
137     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
138     ASSERT_TRUE(audioSink != nullptr);
139     audioSink->ResetSyncInfo();
140     SUCCEED();
141 }
142 
143 HWTEST(TestAudioSink, audio_sink_set_get_parameter, TestSize.Level1)
144 {
145     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
146     ASSERT_TRUE(audioSink != nullptr);
147 
148     // SetParameter before ChangeTrack
149     std::shared_ptr<Meta> meta = std::make_shared<Meta>();
150     auto setParameterStatus = audioSink->SetParameter(meta);
151     ASSERT_EQ(setParameterStatus, Status::OK);
152 
153     // GetParameter
154     std::shared_ptr<Meta> newMeta = std::make_shared<Meta>();
155     audioSink->GetParameter(newMeta);
156     int32_t appUid = 0;
157     (void)newMeta->Get<Tag::APP_UID>(appUid);
158     ASSERT_FALSE(appUid == 9999);
159 }
160 
161 HWTEST(TestAudioSink, audio_sink_write, TestSize.Level1)
162 {
163     std::shared_ptr<AudioSink> audioSink = AudioSinkCreate();
164     ASSERT_TRUE(audioSink != nullptr);
165 
166     // SetSyncCenter
167     auto syncCenter = std::make_shared<Pipeline::MediaSyncManager>();
168     audioSink->SetSyncCenter(syncCenter);
169 
170     // DoSyncWrite
171     AVBufferConfig config;
172     config.size = 4;
173     config.memoryType = MemoryType::SHARED_MEMORY;
174     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
175     buffer->flag_ = 0; // not eos
176     buffer->pts_ = -1;
177     auto doSyncWriteRes = audioSink->DoSyncWrite(buffer);
178     ASSERT_TRUE(doSyncWriteRes == 0);
179     buffer->pts_ = 1;
180     doSyncWriteRes = audioSink->DoSyncWrite(buffer);
181     ASSERT_TRUE(doSyncWriteRes == 0);
182 }
183 
184 HWTEST(TestAudioSink, audio_sink_CalcMaxAmplitude_001, TestSize.Level1)
185 {
186     auto audioSink = std::make_shared<AudioSink>();
187     ASSERT_TRUE(audioSink != nullptr);
188     AVBufferConfig config;
189     config.size = 1;
190     config.capacity = 1;
191     config.memoryType = MemoryType::VIRTUAL_MEMORY;
192     std::shared_ptr<OHOS::Media::AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
193     audioSink->CalcMaxAmplitude(buffer);
194     ASSERT_EQ(0, audioSink->DoSyncWrite(buffer));
195 }
196 
197 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_001, TestSize.Level1)
198 {
199     auto audioSink = std::make_shared<AudioSink>();
200     ASSERT_TRUE(audioSink != nullptr);
201     int8_t frame[] = {0, 127};
202     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 0);
203     float amplitude = 0.0f;
204     amplitude = audioSink->GetMaxAmplitude();
205     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
206 }
207 
208 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_002, TestSize.Level1)
209 {
210     auto audioSink = std::make_shared<AudioSink>();
211     ASSERT_TRUE(audioSink != nullptr);
212     int8_t frame[] = {0, -127};
213     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 0);
214     float amplitude = 0.0f;
215     amplitude = audioSink->GetMaxAmplitude();
216     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
217 }
218 
219 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_003, TestSize.Level1)
220 {
221     auto audioSink = std::make_shared<AudioSink>();
222     ASSERT_TRUE(audioSink != nullptr);
223     int16_t frame[] = {0, -32767};
224     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 1);
225     float amplitude = 0.0f;
226     amplitude = audioSink->GetMaxAmplitude();
227     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
228 }
229 
230 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_004, TestSize.Level1)
231 {
232     auto audioSink = std::make_shared<AudioSink>();
233     ASSERT_TRUE(audioSink != nullptr);
234     int16_t frame[] = {0, 32767};
235     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 1);
236     float amplitude = 0.0f;
237     amplitude = audioSink->GetMaxAmplitude();
238     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
239 }
240 
241 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_005, TestSize.Level1)
242 {
243     auto audioSink = std::make_shared<AudioSink>();
244     ASSERT_TRUE(audioSink != nullptr);
245     int8_t frame[] = {0, 0, 0, 1, 0, 0x80};
246     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 2);
247     float amplitude = 0.0f;
248     amplitude = audioSink->GetMaxAmplitude();
249     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
250 }
251 
252 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_006, TestSize.Level1)
253 {
254     auto audioSink = std::make_shared<AudioSink>();
255     ASSERT_TRUE(audioSink != nullptr);
256     int8_t frame[] = {0, 0, 0, 0xff, 0xff, 0x7f};
257     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 2);
258     float amplitude = 0.0f;
259     amplitude = audioSink->GetMaxAmplitude();
260     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
261 }
262 
263 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_007, TestSize.Level1)
264 {
265     auto audioSink = std::make_shared<AudioSink>();
266     ASSERT_TRUE(audioSink != nullptr);
267     int32_t frame[] = {0, -2147483647};
268     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 3);
269     float amplitude = 0.0f;
270     amplitude = audioSink->GetMaxAmplitude();
271     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
272 }
273 
274 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_008, TestSize.Level1)
275 {
276     auto audioSink = std::make_shared<AudioSink>();
277     ASSERT_TRUE(audioSink != nullptr);
278     int32_t frame[] = {0, 2147483647};
279     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), 3);
280     float amplitude = 0.0f;
281     amplitude = audioSink->GetMaxAmplitude();
282     ASSERT_EQ(true, fabs(amplitude - 1.0) <= 1e-6);
283 }
284 
285 HWTEST(TestAudioSink, audio_sink_CheckUpdateState_009, TestSize.Level1)
286 {
287     auto audioSink = std::make_shared<AudioSink>();
288     ASSERT_TRUE(audioSink != nullptr);
289     int32_t frame[] = {0, 2147483647};
290     audioSink->CheckUpdateState(reinterpret_cast<char*>(frame), sizeof(frame), -1);
291     float amplitude = 0.0f;
292     amplitude = audioSink->GetMaxAmplitude();
293     ASSERT_EQ(true, fabs(amplitude) <= 1e-6);
294 }
295 } // namespace Test
296 } // namespace Media
297 } // namespace OHOS