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 shared_ptr<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 renderMap_.erase(id);
50 callbackMap_.erase(id);
51 return;
52 }
53
CreateAudioPlayerAdapter(SLuint32 id,SLDataSource * dataSource,SLDataSink * dataSink,AudioStreamType streamType)54 SLresult AudioPlayerAdapter::CreateAudioPlayerAdapter
55 (SLuint32 id, SLDataSource *dataSource, SLDataSink *dataSink, AudioStreamType streamType)
56 {
57 SLDataFormat_PCM *pcmFormat = (SLDataFormat_PCM *)dataSource->pFormat;
58 AudioRendererParams rendererParams;
59 ConvertPcmFormat(pcmFormat, &rendererParams);
60 streamType = AudioStreamType::STREAM_MUSIC;
61 AudioRendererOptions rendererOptions;
62 rendererOptions.streamInfo.samplingRate = rendererParams.sampleRate;
63 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
64 rendererOptions.streamInfo.format = rendererParams.sampleFormat;
65 rendererOptions.streamInfo.channels = rendererParams.channelCount;
66 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
67 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
68 rendererOptions.rendererInfo.rendererFlags = RENDERER_NEW;
69 rendererOptions.rendererInfo.playerType = PLAYER_TYPE_OPENSL_ES;
70 shared_ptr<AudioRenderer> rendererHolder = AudioRenderer::CreateRenderer(rendererOptions);
71 if (!rendererHolder) {
72 AUDIO_ERR_LOG("AudioPlayerAdapter::CreateAudioPlayer fail, ID: %{public}lu", id);
73 return SL_RESULT_RESOURCE_ERROR;
74 }
75 AUDIO_INFO_LOG("AudioPlayerAdapter::CreateAudioPlayer ID: %{public}lu", id);
76 rendererHolder->SetRenderMode(RENDER_MODE_CALLBACK);
77 rendererHolder->SetOffloadAllowed(false);
78 renderMap_.insert(make_pair(id, rendererHolder));
79 return SL_RESULT_SUCCESS;
80 }
81
SetPlayStateAdapter(SLuint32 id,SLuint32 state)82 SLresult AudioPlayerAdapter::SetPlayStateAdapter(SLuint32 id, SLuint32 state)
83 {
84 shared_ptr<AudioRenderer> pRender = GetAudioRenderById(id);
85 if (pRender == nullptr) {
86 AUDIO_ERR_LOG("AudioPlayerAdapter::SetPlayStateAdapter invalid id.");
87 return SL_RESULT_RESOURCE_ERROR;
88 }
89
90 SLresult slResult = SL_RESULT_SUCCESS;
91 bool result = false;
92 bool rtStop = 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 result = rtStop && !rtClear;
105 break;
106 }
107 default:
108 AUDIO_ERR_LOG("AudioPlayerAdapter::play state not supported ");
109 break;
110 }
111 slResult = result ? SL_RESULT_SUCCESS : SL_RESULT_RESOURCE_ERROR;
112 return slResult;
113 }
114
GetPlayStateAdapter(SLuint32 id,SLuint32 * state)115 SLresult AudioPlayerAdapter::GetPlayStateAdapter(SLuint32 id, SLuint32 *state)
116 {
117 shared_ptr<AudioRenderer> pRender = GetAudioRenderById(id);
118 if (pRender == nullptr) {
119 AUDIO_ERR_LOG("AudioPlayerAdapter::GetPlayStateAdapter invalid id.");
120 return SL_RESULT_RESOURCE_ERROR;
121 }
122
123 RendererState rendererState = pRender->GetStatus();
124 switch (rendererState) {
125 case RENDERER_RUNNING:
126 *state = SL_PLAYSTATE_PLAYING;
127 break;
128 case RENDERER_PAUSED:
129 *state = SL_PLAYSTATE_PAUSED;
130 break;
131 case RENDERER_STOPPED:
132 *state = SL_PLAYSTATE_STOPPED;
133 break;
134 default:
135 *state = -1;
136 break;
137 }
138 return SL_RESULT_SUCCESS;
139 }
140
SetVolumeLevelAdapter(SLuint32 id,SLmillibel level)141 SLresult AudioPlayerAdapter::SetVolumeLevelAdapter(SLuint32 id, SLmillibel level)
142 {
143 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
144 if (audioRenderer == nullptr) {
145 AUDIO_ERR_LOG("AudioPlayerAdapter::SetVolumeLevelAdapter invalid id.");
146 return SL_RESULT_RESOURCE_ERROR;
147 }
148
149 int base = 10;
150 float volume = pow(base, level / MAGNIFICATION);
151 float volumeMaxLevel = 15;
152 audioRenderer->SetVolume(volume / volumeMaxLevel);
153 return SL_RESULT_SUCCESS;
154 }
155
GetVolumeLevelAdapter(SLuint32 id,SLmillibel * level)156 SLresult AudioPlayerAdapter::GetVolumeLevelAdapter(SLuint32 id, SLmillibel *level)
157 {
158 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
159 if (audioRenderer == nullptr) {
160 AUDIO_ERR_LOG("AudioPlayerAdapter::GetVolumeLevelAdapter invalid id.");
161 return SL_RESULT_RESOURCE_ERROR;
162 }
163
164 float volume = audioRenderer->GetVolume();
165 *level = (SLmillibel) (MAGNIFICATION * log10(volume));
166 return SL_RESULT_SUCCESS;
167 }
168
GetMaxVolumeLevelAdapter(SLuint32 id,SLmillibel * level)169 SLresult AudioPlayerAdapter::GetMaxVolumeLevelAdapter(SLuint32 id, SLmillibel *level)
170 {
171 float volume = AudioSystemManager::GetInstance()->GetMaxVolume(STREAM_MUSIC);
172 *level = (SLmillibel) (MAGNIFICATION * log10(volume));
173 return SL_RESULT_SUCCESS;
174 }
175
EnqueueAdapter(SLuint32 id,const void * buffer,SLuint32 size)176 SLresult AudioPlayerAdapter::EnqueueAdapter(SLuint32 id, const void *buffer, SLuint32 size)
177 {
178 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
179 if (audioRenderer == nullptr) {
180 AUDIO_ERR_LOG("AudioPlayerAdapter::EnqueueAdapter invalid id.");
181 return SL_RESULT_RESOURCE_ERROR;
182 }
183
184 BufferDesc bufDesc = {};
185 bufDesc.buffer = (uint8_t*) buffer;
186 bufDesc.bufLength = size;
187 bufDesc.dataLength = size;
188 audioRenderer->Enqueue(bufDesc);
189 return SL_RESULT_SUCCESS;
190 }
191
ClearAdapter(SLuint32 id)192 SLresult AudioPlayerAdapter::ClearAdapter(SLuint32 id)
193 {
194 shared_ptr<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 shared_ptr<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 shared_ptr<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 shared_ptr<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