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