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("id: %{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 /*Set isOffloadAllowed before renderer creation when setOffloadAllowed is disabled. */
70 rendererOptions.rendererInfo.isOffloadAllowed = false;
71 rendererOptions.rendererInfo.playerType = PLAYER_TYPE_OPENSL_ES;
72 shared_ptr<AudioRenderer> rendererHolder = AudioRenderer::CreateRenderer(rendererOptions);
73 if (!rendererHolder) {
74 AUDIO_ERR_LOG("fail, ID: %{public}lu", id);
75 return SL_RESULT_RESOURCE_ERROR;
76 }
77 AUDIO_INFO_LOG("ID: %{public}lu", id);
78 rendererHolder->SetRenderMode(RENDER_MODE_CALLBACK);
79 renderMap_.insert(make_pair(id, rendererHolder));
80 return SL_RESULT_SUCCESS;
81 }
82
SetPlayStateAdapter(SLuint32 id,SLuint32 state)83 SLresult AudioPlayerAdapter::SetPlayStateAdapter(SLuint32 id, SLuint32 state)
84 {
85 shared_ptr<AudioRenderer> pRender = GetAudioRenderById(id);
86 if (pRender == nullptr) {
87 AUDIO_ERR_LOG("invalid id.");
88 return SL_RESULT_RESOURCE_ERROR;
89 }
90
91 SLresult slResult = SL_RESULT_SUCCESS;
92 bool result = false;
93 bool rtStop = false;
94 int32_t rtClear = -1;
95 switch (state) {
96 case SL_PLAYSTATE_PLAYING:
97 result = pRender->Start();
98 break;
99 case SL_PLAYSTATE_PAUSED:
100 result = pRender->Pause();
101 break;
102 case SL_PLAYSTATE_STOPPED: {
103 rtStop = pRender->Stop();
104 rtClear = pRender->Clear();
105 result = rtStop && !rtClear;
106 break;
107 }
108 default:
109 AUDIO_ERR_LOG(" 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 shared_ptr<AudioRenderer> pRender = GetAudioRenderById(id);
119 if (pRender == nullptr) {
120 AUDIO_ERR_LOG("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 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
145 if (audioRenderer == nullptr) {
146 AUDIO_ERR_LOG("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 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
160 if (audioRenderer == nullptr) {
161 AUDIO_ERR_LOG("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 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
180 if (audioRenderer == nullptr) {
181 AUDIO_ERR_LOG("invalid id.");
182 return SL_RESULT_RESOURCE_ERROR;
183 }
184
185 BufferDesc bufDesc = {};
186 bufDesc.buffer = (uint8_t*) buffer;
187 bufDesc.bufLength = size;
188 bufDesc.dataLength = size;
189 audioRenderer->Enqueue(bufDesc);
190 return SL_RESULT_SUCCESS;
191 }
192
ClearAdapter(SLuint32 id)193 SLresult AudioPlayerAdapter::ClearAdapter(SLuint32 id)
194 {
195 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
196 if (audioRenderer == nullptr) {
197 AUDIO_ERR_LOG("invalid id.");
198 return SL_RESULT_RESOURCE_ERROR;
199 }
200
201 audioRenderer->Clear();
202 return SL_RESULT_SUCCESS;
203 }
204
GetStateAdapter(SLuint32 id,SLOHBufferQueueState * state)205 SLresult AudioPlayerAdapter::GetStateAdapter(SLuint32 id, SLOHBufferQueueState *state)
206 {
207 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
208 if (audioRenderer == nullptr) {
209 AUDIO_ERR_LOG("invalid id.");
210 return SL_RESULT_RESOURCE_ERROR;
211 }
212
213 BufferQueueState queueState = {0, 0};
214 audioRenderer->GetBufQueueState(queueState);
215 state->count = queueState.numBuffers;
216 state->index = queueState.currentIndex;
217 return SL_RESULT_SUCCESS;
218 }
219
GetBufferAdapter(SLuint32 id,SLuint8 ** buffer,SLuint32 * size)220 SLresult AudioPlayerAdapter::GetBufferAdapter(SLuint32 id, SLuint8 **buffer, SLuint32 *size)
221 {
222 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(id);
223 if (audioRenderer == nullptr) {
224 AUDIO_ERR_LOG("invalid id.");
225 return SL_RESULT_RESOURCE_ERROR;
226 }
227
228 BufferDesc bufferDesc = {};
229 audioRenderer->GetBufferDesc(bufferDesc);
230 *buffer = bufferDesc.buffer;
231 *size = bufferDesc.bufLength;
232 return SL_RESULT_SUCCESS;
233 }
234
RegisterCallbackAdapter(SLOHBufferQueueItf itf,SlOHBufferQueueCallback callback,void * pContext)235 SLresult AudioPlayerAdapter::RegisterCallbackAdapter
236 (SLOHBufferQueueItf itf, SlOHBufferQueueCallback callback, void *pContext)
237 {
238 IOHBufferQueue *thiz = (IOHBufferQueue *)itf;
239 shared_ptr<AudioRenderer> audioRenderer = GetAudioRenderById(thiz->mId);
240 if (audioRenderer == nullptr) {
241 AUDIO_ERR_LOG("invalid id.");
242 return SL_RESULT_RESOURCE_ERROR;
243 }
244
245 callbackPtr_ = make_shared<ReadOrWriteCallbackAdapter>(callback, itf, pContext);
246 audioRenderer->SetRendererWriteCallback(static_pointer_cast<AudioRendererWriteCallback>(callbackPtr_));
247 callbackMap_.insert(make_pair(thiz->mId, callbackPtr_));
248 return SL_RESULT_SUCCESS;
249 }
250
ConvertPcmFormat(SLDataFormat_PCM * slFormat,AudioRendererParams * rendererParams)251 void AudioPlayerAdapter::ConvertPcmFormat(SLDataFormat_PCM *slFormat, AudioRendererParams *rendererParams)
252 {
253 AudioSampleFormat sampleFormat = SlToOhosSampelFormat(slFormat);
254 AudioSamplingRate sampleRate = SlToOhosSamplingRate(slFormat);
255 AudioChannel channelCount = SlToOhosChannel(slFormat);
256 rendererParams->sampleFormat = sampleFormat;
257 rendererParams->sampleRate = sampleRate;
258 rendererParams->channelCount = channelCount;
259 rendererParams->encodingType = ENCODING_PCM;
260 }
261
SlToOhosSampelFormat(SLDataFormat_PCM * pcmFormat)262 AudioSampleFormat AudioPlayerAdapter::SlToOhosSampelFormat(SLDataFormat_PCM *pcmFormat)
263 {
264 AudioSampleFormat sampleFormat;
265 switch (pcmFormat->bitsPerSample) {
266 case SL_PCMSAMPLEFORMAT_FIXED_8:
267 sampleFormat = SAMPLE_U8;
268 break;
269 case SL_PCMSAMPLEFORMAT_FIXED_16:
270 sampleFormat = SAMPLE_S16LE;
271 break;
272 case SL_PCMSAMPLEFORMAT_FIXED_20:
273 sampleFormat = INVALID_WIDTH;
274 break;
275 case SL_PCMSAMPLEFORMAT_FIXED_24:
276 sampleFormat = SAMPLE_S24LE;
277 break;
278 case SL_PCMSAMPLEFORMAT_FIXED_28:
279 sampleFormat = INVALID_WIDTH;
280 break;
281 case SL_PCMSAMPLEFORMAT_FIXED_32:
282 sampleFormat = SAMPLE_S32LE;
283 break;
284 default:
285 sampleFormat = INVALID_WIDTH;
286 }
287 return sampleFormat;
288 }
289
SlToOhosSamplingRate(SLDataFormat_PCM * pcmFormat)290 AudioSamplingRate AudioPlayerAdapter::SlToOhosSamplingRate(SLDataFormat_PCM *pcmFormat)
291 {
292 AudioSamplingRate sampleRate;
293 switch (pcmFormat->samplesPerSec) {
294 case SL_SAMPLINGRATE_8:
295 sampleRate = SAMPLE_RATE_8000;
296 break;
297 case SL_SAMPLINGRATE_11_025:
298 sampleRate = SAMPLE_RATE_11025;
299 break;
300 case SL_SAMPLINGRATE_12:
301 sampleRate = SAMPLE_RATE_12000;
302 break;
303 case SL_SAMPLINGRATE_16:
304 sampleRate = SAMPLE_RATE_16000;
305 break;
306 case SL_SAMPLINGRATE_22_05:
307 sampleRate = SAMPLE_RATE_22050;
308 break;
309 case SL_SAMPLINGRATE_24:
310 sampleRate = SAMPLE_RATE_24000;
311 break;
312 case SL_SAMPLINGRATE_32:
313 sampleRate = SAMPLE_RATE_32000;
314 break;
315 case SL_SAMPLINGRATE_44_1:
316 sampleRate = SAMPLE_RATE_44100;
317 break;
318 case SL_SAMPLINGRATE_48:
319 sampleRate = SAMPLE_RATE_48000;
320 break;
321 case SL_SAMPLINGRATE_64:
322 sampleRate = SAMPLE_RATE_64000;
323 break;
324 case SL_SAMPLINGRATE_88_2:
325 sampleRate = SAMPLE_RATE_44100;
326 break;
327 case SL_SAMPLINGRATE_96:
328 sampleRate = SAMPLE_RATE_96000;
329 break;
330 case SL_SAMPLINGRATE_192:
331 sampleRate = SAMPLE_RATE_44100;
332 break;
333 default:
334 sampleRate = SAMPLE_RATE_44100;
335 }
336 return sampleRate;
337 }
338
SlToOhosChannel(SLDataFormat_PCM * pcmFormat)339 AudioChannel AudioPlayerAdapter::SlToOhosChannel(SLDataFormat_PCM *pcmFormat)
340 {
341 AudioChannel channelCount;
342 switch (pcmFormat->numChannels) {
343 case MONO:
344 channelCount = MONO;
345 break;
346 case STEREO:
347 channelCount = STEREO;
348 break;
349 default:
350 channelCount = MONO;
351 AUDIO_ERR_LOG("AudioPlayerAdapter::channel count not supported ");
352 }
353 return channelCount;
354 }
355 } // namespace AudioStandard
356 } // namespace OHOS
357