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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioPlayerAdapter"
17 #endif
18
19 #include <common.h>
20
21 using namespace std;
22 using namespace OHOS;
23 using namespace OHOS::AudioStandard;
24
25 namespace OHOS {
26 namespace AudioStandard {
AudioPlayerAdapter()27 AudioPlayerAdapter::AudioPlayerAdapter() { }
28
~AudioPlayerAdapter()29 AudioPlayerAdapter::~AudioPlayerAdapter() { }
30
GetInstance()31 AudioPlayerAdapter* AudioPlayerAdapter::GetInstance()
32 {
33 static AudioPlayerAdapter audioPlayerAdapter_;
34 return &audioPlayerAdapter_;
35 }
36
GetAudioRenderById(SLuint32 id)37 AudioRenderer* AudioPlayerAdapter::GetAudioRenderById(SLuint32 id)
38 {
39 auto it = renderMap_.find(id);
40 if (it == renderMap_.end()) {
41 return nullptr;
42 }
43 return it->second;
44 }
45
EraseAudioRenderById(SLuint32 id)46 void AudioPlayerAdapter::EraseAudioRenderById(SLuint32 id)
47 {
48 AUDIO_INFO_LOG("AudioPlayerAdapter::EraseAudioRenderById: %{public}lu", id);
49 AudioRenderer* pRender = GetAudioRenderById(id);
50 renderMap_.erase(id);
51 callbackMap_.erase(id);
52 if (pRender) {
53 delete pRender;
54 pRender = nullptr;
55 }
56 return;
57 }
58
CreateAudioPlayerAdapter(SLuint32 id,SLDataSource * dataSource,SLDataSink * dataSink,AudioStreamType streamType)59 SLresult AudioPlayerAdapter::CreateAudioPlayerAdapter
60 (SLuint32 id, SLDataSource *dataSource, SLDataSink *dataSink, AudioStreamType streamType)
61 {
62 SLDataFormat_PCM *pcmFormat = (SLDataFormat_PCM *)dataSource->pFormat;
63 AudioRendererParams rendererParams;
64 ConvertPcmFormat(pcmFormat, &rendererParams);
65 streamType = AudioStreamType::STREAM_MUSIC;
66 AudioRendererOptions rendererOptions;
67 rendererOptions.streamInfo.samplingRate = rendererParams.sampleRate;
68 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
69 rendererOptions.streamInfo.format = rendererParams.sampleFormat;
70 rendererOptions.streamInfo.channels = rendererParams.channelCount;
71 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
72 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
73 rendererOptions.rendererInfo.rendererFlags = RENDERER_NEW;
74 string cachePath = "/data/storage/el2/base/cache";
75 unique_ptr<AudioRenderer> rendererHolder = AudioRenderer::Create(cachePath.c_str(), rendererOptions);
76 if (!rendererHolder) {
77 AUDIO_ERR_LOG("AudioPlayerAdapter::CreateAudioPlayer fail, ID: %{public}lu", id);
78 return SL_RESULT_RESOURCE_ERROR;
79 }
80 // use release to get raw pointer, so need to delete explicitly when destory object
81 AudioRenderer *renderer = rendererHolder.release();
82 AUDIO_INFO_LOG("AudioPlayerAdapter::CreateAudioPlayer ID: %{public}lu", id);
83 renderer->SetRenderMode(RENDER_MODE_CALLBACK);
84 renderer->SetOffloadAllowed(false);
85 renderMap_.insert(make_pair(id, renderer));
86 return SL_RESULT_SUCCESS;
87 }
88
SetPlayStateAdapter(SLuint32 id,SLuint32 state)89 SLresult AudioPlayerAdapter::SetPlayStateAdapter(SLuint32 id, SLuint32 state)
90 {
91 AudioRenderer* pRender = GetAudioRenderById(id);
92 if (pRender == nullptr) {
93 AUDIO_ERR_LOG("AudioPlayerAdapter::SetPlayStateAdapter invalid id.");
94 return SL_RESULT_RESOURCE_ERROR;
95 }
96
97 SLresult slResult = SL_RESULT_SUCCESS;
98 bool result = false;
99 bool rtStop = false;
100 bool rtRelease = false;
101 int32_t rtClear = -1;
102 switch (state) {
103 case SL_PLAYSTATE_PLAYING:
104 result = pRender->Start();
105 break;
106 case SL_PLAYSTATE_PAUSED:
107 result = pRender->Pause();
108 break;
109 case SL_PLAYSTATE_STOPPED: {
110 rtStop = pRender->Stop();
111 rtClear = pRender->Clear();
112 rtRelease = pRender->Release();
113 result = rtStop && !rtClear && rtRelease;
114 break;
115 }
116 default:
117 AUDIO_ERR_LOG("AudioPlayerAdapter::play state not supported ");
118 break;
119 }
120 slResult = result ? SL_RESULT_SUCCESS : SL_RESULT_RESOURCE_ERROR;
121 return slResult;
122 }
123
GetPlayStateAdapter(SLuint32 id,SLuint32 * state)124 SLresult AudioPlayerAdapter::GetPlayStateAdapter(SLuint32 id, SLuint32 *state)
125 {
126 AudioRenderer* pRender = GetAudioRenderById(id);
127 if (pRender == nullptr) {
128 AUDIO_ERR_LOG("AudioPlayerAdapter::GetPlayStateAdapter invalid id.");
129 return SL_RESULT_RESOURCE_ERROR;
130 }
131
132 RendererState rendererState = pRender->GetStatus();
133 switch (rendererState) {
134 case RENDERER_RUNNING:
135 *state = SL_PLAYSTATE_PLAYING;
136 break;
137 case RENDERER_PAUSED:
138 *state = SL_PLAYSTATE_PAUSED;
139 break;
140 case RENDERER_STOPPED:
141 *state = SL_PLAYSTATE_STOPPED;
142 break;
143 default:
144 *state = -1;
145 break;
146 }
147 return SL_RESULT_SUCCESS;
148 }
149
SetVolumeLevelAdapter(SLuint32 id,SLmillibel level)150 SLresult AudioPlayerAdapter::SetVolumeLevelAdapter(SLuint32 id, SLmillibel level)
151 {
152 AudioRenderer *audioRenderer = GetAudioRenderById(id);
153 if (audioRenderer == nullptr) {
154 AUDIO_ERR_LOG("AudioPlayerAdapter::SetVolumeLevelAdapter invalid id.");
155 return SL_RESULT_RESOURCE_ERROR;
156 }
157
158 int base = 10;
159 float volume = pow(base, level / MAGNIFICATION);
160 float volumeMaxLevel = 15;
161 audioRenderer->SetVolume(volume / volumeMaxLevel);
162 return SL_RESULT_SUCCESS;
163 }
164
GetVolumeLevelAdapter(SLuint32 id,SLmillibel * level)165 SLresult AudioPlayerAdapter::GetVolumeLevelAdapter(SLuint32 id, SLmillibel *level)
166 {
167 AudioRenderer *audioRenderer = GetAudioRenderById(id);
168 if (audioRenderer == nullptr) {
169 AUDIO_ERR_LOG("AudioPlayerAdapter::GetVolumeLevelAdapter invalid id.");
170 return SL_RESULT_RESOURCE_ERROR;
171 }
172
173 float volume = audioRenderer->GetVolume();
174 *level = (SLmillibel) (MAGNIFICATION * log10(volume));
175 return SL_RESULT_SUCCESS;
176 }
177
GetMaxVolumeLevelAdapter(SLuint32 id,SLmillibel * level)178 SLresult AudioPlayerAdapter::GetMaxVolumeLevelAdapter(SLuint32 id, SLmillibel *level)
179 {
180 float volume = AudioSystemManager::GetInstance()->GetMaxVolume(STREAM_MUSIC);
181 *level = (SLmillibel) (MAGNIFICATION * log10(volume));
182 return SL_RESULT_SUCCESS;
183 }
184
EnqueueAdapter(SLuint32 id,const void * buffer,SLuint32 size)185 SLresult AudioPlayerAdapter::EnqueueAdapter(SLuint32 id, const void *buffer, SLuint32 size)
186 {
187 AudioRenderer *audioRenderer = GetAudioRenderById(id);
188 if (audioRenderer == nullptr) {
189 AUDIO_ERR_LOG("AudioPlayerAdapter::EnqueueAdapter invalid id.");
190 return SL_RESULT_RESOURCE_ERROR;
191 }
192
193 BufferDesc bufDesc = {};
194 bufDesc.buffer = (uint8_t*) buffer;
195 bufDesc.bufLength = size;
196 bufDesc.dataLength = size;
197 audioRenderer->Enqueue(bufDesc);
198 return SL_RESULT_SUCCESS;
199 }
200
ClearAdapter(SLuint32 id)201 SLresult AudioPlayerAdapter::ClearAdapter(SLuint32 id)
202 {
203 AudioRenderer *audioRenderer = GetAudioRenderById(id);
204 if (audioRenderer == nullptr) {
205 AUDIO_ERR_LOG("AudioPlayerAdapter::ClearAdapter invalid id.");
206 return SL_RESULT_RESOURCE_ERROR;
207 }
208
209 audioRenderer->Clear();
210 return SL_RESULT_SUCCESS;
211 }
212
GetStateAdapter(SLuint32 id,SLOHBufferQueueState * state)213 SLresult AudioPlayerAdapter::GetStateAdapter(SLuint32 id, SLOHBufferQueueState *state)
214 {
215 AudioRenderer *audioRenderer = GetAudioRenderById(id);
216 if (audioRenderer == nullptr) {
217 AUDIO_ERR_LOG("AudioPlayerAdapter::GetStateAdapter invalid id.");
218 return SL_RESULT_RESOURCE_ERROR;
219 }
220
221 BufferQueueState queueState = {0, 0};
222 audioRenderer->GetBufQueueState(queueState);
223 state->count = queueState.numBuffers;
224 state->index = queueState.currentIndex;
225 return SL_RESULT_SUCCESS;
226 }
227
GetBufferAdapter(SLuint32 id,SLuint8 ** buffer,SLuint32 * size)228 SLresult AudioPlayerAdapter::GetBufferAdapter(SLuint32 id, SLuint8 **buffer, SLuint32 *size)
229 {
230 AudioRenderer *audioRenderer = GetAudioRenderById(id);
231 if (audioRenderer == nullptr) {
232 AUDIO_ERR_LOG("AudioPlayerAdapter::GetBufferAdapter invalid id.");
233 return SL_RESULT_RESOURCE_ERROR;
234 }
235
236 BufferDesc bufferDesc = {};
237 audioRenderer->GetBufferDesc(bufferDesc);
238 *buffer = bufferDesc.buffer;
239 *size = bufferDesc.bufLength;
240 return SL_RESULT_SUCCESS;
241 }
242
RegisterCallbackAdapter(SLOHBufferQueueItf itf,SlOHBufferQueueCallback callback,void * pContext)243 SLresult AudioPlayerAdapter::RegisterCallbackAdapter
244 (SLOHBufferQueueItf itf, SlOHBufferQueueCallback callback, void *pContext)
245 {
246 IOHBufferQueue *thiz = (IOHBufferQueue *)itf;
247 AudioRenderer *audioRenderer = GetAudioRenderById(thiz->mId);
248 if (audioRenderer == nullptr) {
249 AUDIO_ERR_LOG("AudioPlayerAdapter::RegisterCallbackAdapter invalid id.");
250 return SL_RESULT_RESOURCE_ERROR;
251 }
252
253 callbackPtr_ = make_shared<ReadOrWriteCallbackAdapter>(callback, itf, pContext);
254 audioRenderer->SetRendererWriteCallback(static_pointer_cast<AudioRendererWriteCallback>(callbackPtr_));
255 callbackMap_.insert(make_pair(thiz->mId, callbackPtr_));
256 return SL_RESULT_SUCCESS;
257 }
258
ConvertPcmFormat(SLDataFormat_PCM * slFormat,AudioRendererParams * rendererParams)259 void AudioPlayerAdapter::ConvertPcmFormat(SLDataFormat_PCM *slFormat, AudioRendererParams *rendererParams)
260 {
261 AudioSampleFormat sampleFormat = SlToOhosSampelFormat(slFormat);
262 AudioSamplingRate sampleRate = SlToOhosSamplingRate(slFormat);
263 AudioChannel channelCount = SlToOhosChannel(slFormat);
264 rendererParams->sampleFormat = sampleFormat;
265 rendererParams->sampleRate = sampleRate;
266 rendererParams->channelCount = channelCount;
267 rendererParams->encodingType = ENCODING_PCM;
268 }
269
SlToOhosSampelFormat(SLDataFormat_PCM * pcmFormat)270 AudioSampleFormat AudioPlayerAdapter::SlToOhosSampelFormat(SLDataFormat_PCM *pcmFormat)
271 {
272 AudioSampleFormat sampleFormat;
273 switch (pcmFormat->bitsPerSample) {
274 case SL_PCMSAMPLEFORMAT_FIXED_8:
275 sampleFormat = SAMPLE_U8;
276 break;
277 case SL_PCMSAMPLEFORMAT_FIXED_16:
278 sampleFormat = SAMPLE_S16LE;
279 break;
280 case SL_PCMSAMPLEFORMAT_FIXED_20:
281 sampleFormat = INVALID_WIDTH;
282 break;
283 case SL_PCMSAMPLEFORMAT_FIXED_24:
284 sampleFormat = SAMPLE_S24LE;
285 break;
286 case SL_PCMSAMPLEFORMAT_FIXED_28:
287 sampleFormat = INVALID_WIDTH;
288 break;
289 case SL_PCMSAMPLEFORMAT_FIXED_32:
290 sampleFormat = SAMPLE_S32LE;
291 break;
292 default:
293 sampleFormat = INVALID_WIDTH;
294 }
295 return sampleFormat;
296 }
297
SlToOhosSamplingRate(SLDataFormat_PCM * pcmFormat)298 AudioSamplingRate AudioPlayerAdapter::SlToOhosSamplingRate(SLDataFormat_PCM *pcmFormat)
299 {
300 AudioSamplingRate sampleRate;
301 switch (pcmFormat->samplesPerSec) {
302 case SL_SAMPLINGRATE_8:
303 sampleRate = SAMPLE_RATE_8000;
304 break;
305 case SL_SAMPLINGRATE_11_025:
306 sampleRate = SAMPLE_RATE_11025;
307 break;
308 case SL_SAMPLINGRATE_12:
309 sampleRate = SAMPLE_RATE_12000;
310 break;
311 case SL_SAMPLINGRATE_16:
312 sampleRate = SAMPLE_RATE_16000;
313 break;
314 case SL_SAMPLINGRATE_22_05:
315 sampleRate = SAMPLE_RATE_22050;
316 break;
317 case SL_SAMPLINGRATE_24:
318 sampleRate = SAMPLE_RATE_24000;
319 break;
320 case SL_SAMPLINGRATE_32:
321 sampleRate = SAMPLE_RATE_32000;
322 break;
323 case SL_SAMPLINGRATE_44_1:
324 sampleRate = SAMPLE_RATE_44100;
325 break;
326 case SL_SAMPLINGRATE_48:
327 sampleRate = SAMPLE_RATE_48000;
328 break;
329 case SL_SAMPLINGRATE_64:
330 sampleRate = SAMPLE_RATE_64000;
331 break;
332 case SL_SAMPLINGRATE_88_2:
333 sampleRate = SAMPLE_RATE_44100;
334 break;
335 case SL_SAMPLINGRATE_96:
336 sampleRate = SAMPLE_RATE_96000;
337 break;
338 case SL_SAMPLINGRATE_192:
339 sampleRate = SAMPLE_RATE_44100;
340 break;
341 default:
342 sampleRate = SAMPLE_RATE_44100;
343 }
344 return sampleRate;
345 }
346
SlToOhosChannel(SLDataFormat_PCM * pcmFormat)347 AudioChannel AudioPlayerAdapter::SlToOhosChannel(SLDataFormat_PCM *pcmFormat)
348 {
349 AudioChannel channelCount;
350 switch (pcmFormat->numChannels) {
351 case MONO:
352 channelCount = MONO;
353 break;
354 case STEREO:
355 channelCount = STEREO;
356 break;
357 default:
358 channelCount = MONO;
359 AUDIO_ERR_LOG("AudioPlayerAdapter::channel count not supported ");
360 }
361 return channelCount;
362 }
363 } // namespace AudioStandard
364 } // namespace OHOS
365