1 /*
2 * Copyright (C) 2006-2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "AudioSystem"
18 //#define LOG_NDEBUG 0
19
20 #include <utils/Log.h>
21 #include <binder/IServiceManager.h>
22 #include <media/AudioSystem.h>
23 #include <media/IAudioFlinger.h>
24 #include <media/IAudioPolicyService.h>
25 #include <math.h>
26
27 #include <system/audio.h>
28
29 // ----------------------------------------------------------------------------
30
31 namespace android {
32
33 // client singleton for AudioFlinger binder interface
34 Mutex AudioSystem::gLock;
35 sp<IAudioFlinger> AudioSystem::gAudioFlinger;
36 sp<AudioSystem::AudioFlingerClient> AudioSystem::gAudioFlingerClient;
37 audio_error_callback AudioSystem::gAudioErrorCallback = NULL;
38 // Cached values
39
40 DefaultKeyedVector<audio_io_handle_t, AudioSystem::OutputDescriptor *> AudioSystem::gOutputs(0);
41
42 // Cached values for recording queries, all protected by gLock
43 uint32_t AudioSystem::gPrevInSamplingRate = 16000;
44 audio_format_t AudioSystem::gPrevInFormat = AUDIO_FORMAT_PCM_16_BIT;
45 audio_channel_mask_t AudioSystem::gPrevInChannelMask = AUDIO_CHANNEL_IN_MONO;
46 size_t AudioSystem::gInBuffSize = 0;
47
48
49 // establish binder interface to AudioFlinger service
get_audio_flinger()50 const sp<IAudioFlinger>& AudioSystem::get_audio_flinger()
51 {
52 Mutex::Autolock _l(gLock);
53 if (gAudioFlinger == 0) {
54 sp<IServiceManager> sm = defaultServiceManager();
55 sp<IBinder> binder;
56 do {
57 binder = sm->getService(String16("media.audio_flinger"));
58 if (binder != 0)
59 break;
60 ALOGW("AudioFlinger not published, waiting...");
61 usleep(500000); // 0.5 s
62 } while (true);
63 if (gAudioFlingerClient == NULL) {
64 gAudioFlingerClient = new AudioFlingerClient();
65 } else {
66 if (gAudioErrorCallback) {
67 gAudioErrorCallback(NO_ERROR);
68 }
69 }
70 binder->linkToDeath(gAudioFlingerClient);
71 gAudioFlinger = interface_cast<IAudioFlinger>(binder);
72 gAudioFlinger->registerClient(gAudioFlingerClient);
73 }
74 ALOGE_IF(gAudioFlinger==0, "no AudioFlinger!?");
75
76 return gAudioFlinger;
77 }
78
checkAudioFlinger()79 /* static */ status_t AudioSystem::checkAudioFlinger()
80 {
81 if (defaultServiceManager()->checkService(String16("media.audio_flinger")) != 0) {
82 return NO_ERROR;
83 }
84 return DEAD_OBJECT;
85 }
86
muteMicrophone(bool state)87 status_t AudioSystem::muteMicrophone(bool state) {
88 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
89 if (af == 0) return PERMISSION_DENIED;
90 return af->setMicMute(state);
91 }
92
isMicrophoneMuted(bool * state)93 status_t AudioSystem::isMicrophoneMuted(bool* state) {
94 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
95 if (af == 0) return PERMISSION_DENIED;
96 *state = af->getMicMute();
97 return NO_ERROR;
98 }
99
setMasterVolume(float value)100 status_t AudioSystem::setMasterVolume(float value)
101 {
102 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
103 if (af == 0) return PERMISSION_DENIED;
104 af->setMasterVolume(value);
105 return NO_ERROR;
106 }
107
setMasterMute(bool mute)108 status_t AudioSystem::setMasterMute(bool mute)
109 {
110 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
111 if (af == 0) return PERMISSION_DENIED;
112 af->setMasterMute(mute);
113 return NO_ERROR;
114 }
115
getMasterVolume(float * volume)116 status_t AudioSystem::getMasterVolume(float* volume)
117 {
118 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
119 if (af == 0) return PERMISSION_DENIED;
120 *volume = af->masterVolume();
121 return NO_ERROR;
122 }
123
getMasterMute(bool * mute)124 status_t AudioSystem::getMasterMute(bool* mute)
125 {
126 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
127 if (af == 0) return PERMISSION_DENIED;
128 *mute = af->masterMute();
129 return NO_ERROR;
130 }
131
setStreamVolume(audio_stream_type_t stream,float value,audio_io_handle_t output)132 status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
133 audio_io_handle_t output)
134 {
135 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
136 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
137 if (af == 0) return PERMISSION_DENIED;
138 af->setStreamVolume(stream, value, output);
139 return NO_ERROR;
140 }
141
setStreamMute(audio_stream_type_t stream,bool mute)142 status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute)
143 {
144 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
145 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
146 if (af == 0) return PERMISSION_DENIED;
147 af->setStreamMute(stream, mute);
148 return NO_ERROR;
149 }
150
getStreamVolume(audio_stream_type_t stream,float * volume,audio_io_handle_t output)151 status_t AudioSystem::getStreamVolume(audio_stream_type_t stream, float* volume,
152 audio_io_handle_t output)
153 {
154 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
155 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
156 if (af == 0) return PERMISSION_DENIED;
157 *volume = af->streamVolume(stream, output);
158 return NO_ERROR;
159 }
160
getStreamMute(audio_stream_type_t stream,bool * mute)161 status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute)
162 {
163 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
164 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
165 if (af == 0) return PERMISSION_DENIED;
166 *mute = af->streamMute(stream);
167 return NO_ERROR;
168 }
169
setMode(audio_mode_t mode)170 status_t AudioSystem::setMode(audio_mode_t mode)
171 {
172 if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE;
173 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
174 if (af == 0) return PERMISSION_DENIED;
175 return af->setMode(mode);
176 }
177
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)178 status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) {
179 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
180 if (af == 0) return PERMISSION_DENIED;
181 return af->setParameters(ioHandle, keyValuePairs);
182 }
183
getParameters(audio_io_handle_t ioHandle,const String8 & keys)184 String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys) {
185 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
186 String8 result = String8("");
187 if (af == 0) return result;
188
189 result = af->getParameters(ioHandle, keys);
190 return result;
191 }
192
193 // convert volume steps to natural log scale
194
195 // change this value to change volume scaling
196 static const float dBPerStep = 0.5f;
197 // shouldn't need to touch these
198 static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
199 static const float dBConvertInverse = 1.0f / dBConvert;
200
linearToLog(int volume)201 float AudioSystem::linearToLog(int volume)
202 {
203 // float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
204 // ALOGD("linearToLog(%d)=%f", volume, v);
205 // return v;
206 return volume ? exp(float(100 - volume) * dBConvert) : 0;
207 }
208
logToLinear(float volume)209 int AudioSystem::logToLinear(float volume)
210 {
211 // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
212 // ALOGD("logTolinear(%d)=%f", v, volume);
213 // return v;
214 return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
215 }
216
getOutputSamplingRate(uint32_t * samplingRate,audio_stream_type_t streamType)217 status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType)
218 {
219 audio_io_handle_t output;
220
221 if (streamType == AUDIO_STREAM_DEFAULT) {
222 streamType = AUDIO_STREAM_MUSIC;
223 }
224
225 output = getOutput(streamType);
226 if (output == 0) {
227 return PERMISSION_DENIED;
228 }
229
230 return getSamplingRate(output, streamType, samplingRate);
231 }
232
getSamplingRate(audio_io_handle_t output,audio_stream_type_t streamType,uint32_t * samplingRate)233 status_t AudioSystem::getSamplingRate(audio_io_handle_t output,
234 audio_stream_type_t streamType,
235 uint32_t* samplingRate)
236 {
237 OutputDescriptor *outputDesc;
238
239 gLock.lock();
240 outputDesc = AudioSystem::gOutputs.valueFor(output);
241 if (outputDesc == NULL) {
242 ALOGV("getOutputSamplingRate() no output descriptor for output %d in gOutputs", output);
243 gLock.unlock();
244 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
245 if (af == 0) return PERMISSION_DENIED;
246 *samplingRate = af->sampleRate(output);
247 } else {
248 ALOGV("getOutputSamplingRate() reading from output desc");
249 *samplingRate = outputDesc->samplingRate;
250 gLock.unlock();
251 }
252
253 ALOGV("getSamplingRate() streamType %d, output %d, sampling rate %u", streamType, output,
254 *samplingRate);
255
256 return NO_ERROR;
257 }
258
getOutputFrameCount(size_t * frameCount,audio_stream_type_t streamType)259 status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType)
260 {
261 audio_io_handle_t output;
262
263 if (streamType == AUDIO_STREAM_DEFAULT) {
264 streamType = AUDIO_STREAM_MUSIC;
265 }
266
267 output = getOutput(streamType);
268 if (output == 0) {
269 return PERMISSION_DENIED;
270 }
271
272 return getFrameCount(output, streamType, frameCount);
273 }
274
getFrameCount(audio_io_handle_t output,audio_stream_type_t streamType,size_t * frameCount)275 status_t AudioSystem::getFrameCount(audio_io_handle_t output,
276 audio_stream_type_t streamType,
277 size_t* frameCount)
278 {
279 OutputDescriptor *outputDesc;
280
281 gLock.lock();
282 outputDesc = AudioSystem::gOutputs.valueFor(output);
283 if (outputDesc == NULL) {
284 gLock.unlock();
285 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
286 if (af == 0) return PERMISSION_DENIED;
287 *frameCount = af->frameCount(output);
288 } else {
289 *frameCount = outputDesc->frameCount;
290 gLock.unlock();
291 }
292
293 ALOGV("getFrameCount() streamType %d, output %d, frameCount %d", streamType, output,
294 *frameCount);
295
296 return NO_ERROR;
297 }
298
getOutputLatency(uint32_t * latency,audio_stream_type_t streamType)299 status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
300 {
301 audio_io_handle_t output;
302
303 if (streamType == AUDIO_STREAM_DEFAULT) {
304 streamType = AUDIO_STREAM_MUSIC;
305 }
306
307 output = getOutput(streamType);
308 if (output == 0) {
309 return PERMISSION_DENIED;
310 }
311
312 return getLatency(output, streamType, latency);
313 }
314
getLatency(audio_io_handle_t output,audio_stream_type_t streamType,uint32_t * latency)315 status_t AudioSystem::getLatency(audio_io_handle_t output,
316 audio_stream_type_t streamType,
317 uint32_t* latency)
318 {
319 OutputDescriptor *outputDesc;
320
321 gLock.lock();
322 outputDesc = AudioSystem::gOutputs.valueFor(output);
323 if (outputDesc == NULL) {
324 gLock.unlock();
325 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
326 if (af == 0) return PERMISSION_DENIED;
327 *latency = af->latency(output);
328 } else {
329 *latency = outputDesc->latency;
330 gLock.unlock();
331 }
332
333 ALOGV("getLatency() streamType %d, output %d, latency %d", streamType, output, *latency);
334
335 return NO_ERROR;
336 }
337
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t * buffSize)338 status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
339 audio_channel_mask_t channelMask, size_t* buffSize)
340 {
341 gLock.lock();
342 // Do we have a stale gInBufferSize or are we requesting the input buffer size for new values
343 size_t inBuffSize = gInBuffSize;
344 if ((inBuffSize == 0) || (sampleRate != gPrevInSamplingRate) || (format != gPrevInFormat)
345 || (channelMask != gPrevInChannelMask)) {
346 gLock.unlock();
347 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
348 if (af == 0) {
349 return PERMISSION_DENIED;
350 }
351 inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask);
352 gLock.lock();
353 // save the request params
354 gPrevInSamplingRate = sampleRate;
355 gPrevInFormat = format;
356 gPrevInChannelMask = channelMask;
357
358 gInBuffSize = inBuffSize;
359 }
360 gLock.unlock();
361 *buffSize = inBuffSize;
362
363 return NO_ERROR;
364 }
365
setVoiceVolume(float value)366 status_t AudioSystem::setVoiceVolume(float value)
367 {
368 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
369 if (af == 0) return PERMISSION_DENIED;
370 return af->setVoiceVolume(value);
371 }
372
getRenderPosition(audio_io_handle_t output,size_t * halFrames,size_t * dspFrames,audio_stream_type_t stream)373 status_t AudioSystem::getRenderPosition(audio_io_handle_t output, size_t *halFrames,
374 size_t *dspFrames, audio_stream_type_t stream)
375 {
376 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
377 if (af == 0) return PERMISSION_DENIED;
378
379 if (stream == AUDIO_STREAM_DEFAULT) {
380 stream = AUDIO_STREAM_MUSIC;
381 }
382
383 if (output == 0) {
384 output = getOutput(stream);
385 }
386
387 return af->getRenderPosition(halFrames, dspFrames, output);
388 }
389
getInputFramesLost(audio_io_handle_t ioHandle)390 size_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) {
391 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
392 unsigned int result = 0;
393 if (af == 0) return result;
394 if (ioHandle == 0) return result;
395
396 result = af->getInputFramesLost(ioHandle);
397 return result;
398 }
399
newAudioSessionId()400 int AudioSystem::newAudioSessionId() {
401 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
402 if (af == 0) return 0;
403 return af->newAudioSessionId();
404 }
405
acquireAudioSessionId(int audioSession)406 void AudioSystem::acquireAudioSessionId(int audioSession) {
407 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
408 if (af != 0) {
409 af->acquireAudioSessionId(audioSession);
410 }
411 }
412
releaseAudioSessionId(int audioSession)413 void AudioSystem::releaseAudioSessionId(int audioSession) {
414 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
415 if (af != 0) {
416 af->releaseAudioSessionId(audioSession);
417 }
418 }
419
420 // ---------------------------------------------------------------------------
421
binderDied(const wp<IBinder> & who)422 void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who) {
423 Mutex::Autolock _l(AudioSystem::gLock);
424
425 AudioSystem::gAudioFlinger.clear();
426 // clear output handles and stream to output map caches
427 AudioSystem::gOutputs.clear();
428
429 if (gAudioErrorCallback) {
430 gAudioErrorCallback(DEAD_OBJECT);
431 }
432 ALOGW("AudioFlinger server died!");
433 }
434
ioConfigChanged(int event,audio_io_handle_t ioHandle,const void * param2)435 void AudioSystem::AudioFlingerClient::ioConfigChanged(int event, audio_io_handle_t ioHandle,
436 const void *param2) {
437 ALOGV("ioConfigChanged() event %d", event);
438 const OutputDescriptor *desc;
439 audio_stream_type_t stream;
440
441 if (ioHandle == 0) return;
442
443 Mutex::Autolock _l(AudioSystem::gLock);
444
445 switch (event) {
446 case STREAM_CONFIG_CHANGED:
447 break;
448 case OUTPUT_OPENED: {
449 if (gOutputs.indexOfKey(ioHandle) >= 0) {
450 ALOGV("ioConfigChanged() opening already existing output! %d", ioHandle);
451 break;
452 }
453 if (param2 == NULL) break;
454 desc = (const OutputDescriptor *)param2;
455
456 OutputDescriptor *outputDesc = new OutputDescriptor(*desc);
457 gOutputs.add(ioHandle, outputDesc);
458 ALOGV("ioConfigChanged() new output samplingRate %u, format %d channel mask %#x frameCount %u "
459 "latency %d",
460 outputDesc->samplingRate, outputDesc->format, outputDesc->channelMask,
461 outputDesc->frameCount, outputDesc->latency);
462 } break;
463 case OUTPUT_CLOSED: {
464 if (gOutputs.indexOfKey(ioHandle) < 0) {
465 ALOGW("ioConfigChanged() closing unknown output! %d", ioHandle);
466 break;
467 }
468 ALOGV("ioConfigChanged() output %d closed", ioHandle);
469
470 gOutputs.removeItem(ioHandle);
471 } break;
472
473 case OUTPUT_CONFIG_CHANGED: {
474 int index = gOutputs.indexOfKey(ioHandle);
475 if (index < 0) {
476 ALOGW("ioConfigChanged() modifying unknown output! %d", ioHandle);
477 break;
478 }
479 if (param2 == NULL) break;
480 desc = (const OutputDescriptor *)param2;
481
482 ALOGV("ioConfigChanged() new config for output %d samplingRate %u, format %d channel mask %#x "
483 "frameCount %d latency %d",
484 ioHandle, desc->samplingRate, desc->format,
485 desc->channelMask, desc->frameCount, desc->latency);
486 OutputDescriptor *outputDesc = gOutputs.valueAt(index);
487 delete outputDesc;
488 outputDesc = new OutputDescriptor(*desc);
489 gOutputs.replaceValueFor(ioHandle, outputDesc);
490 } break;
491 case INPUT_OPENED:
492 case INPUT_CLOSED:
493 case INPUT_CONFIG_CHANGED:
494 break;
495
496 }
497 }
498
setErrorCallback(audio_error_callback cb)499 void AudioSystem::setErrorCallback(audio_error_callback cb) {
500 Mutex::Autolock _l(gLock);
501 gAudioErrorCallback = cb;
502 }
503
routedToA2dpOutput(audio_stream_type_t streamType)504 bool AudioSystem::routedToA2dpOutput(audio_stream_type_t streamType) {
505 switch (streamType) {
506 case AUDIO_STREAM_MUSIC:
507 case AUDIO_STREAM_VOICE_CALL:
508 case AUDIO_STREAM_BLUETOOTH_SCO:
509 case AUDIO_STREAM_SYSTEM:
510 return true;
511 default:
512 return false;
513 }
514 }
515
516
517 // client singleton for AudioPolicyService binder interface
518 sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
519 sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;
520
521
522 // establish binder interface to AudioPolicy service
get_audio_policy_service()523 const sp<IAudioPolicyService>& AudioSystem::get_audio_policy_service()
524 {
525 gLock.lock();
526 if (gAudioPolicyService == 0) {
527 sp<IServiceManager> sm = defaultServiceManager();
528 sp<IBinder> binder;
529 do {
530 binder = sm->getService(String16("media.audio_policy"));
531 if (binder != 0)
532 break;
533 ALOGW("AudioPolicyService not published, waiting...");
534 usleep(500000); // 0.5 s
535 } while (true);
536 if (gAudioPolicyServiceClient == NULL) {
537 gAudioPolicyServiceClient = new AudioPolicyServiceClient();
538 }
539 binder->linkToDeath(gAudioPolicyServiceClient);
540 gAudioPolicyService = interface_cast<IAudioPolicyService>(binder);
541 gLock.unlock();
542 } else {
543 gLock.unlock();
544 }
545 return gAudioPolicyService;
546 }
547
548 // ---------------------------------------------------------------------------
549
setDeviceConnectionState(audio_devices_t device,audio_policy_dev_state_t state,const char * device_address)550 status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,
551 audio_policy_dev_state_t state,
552 const char *device_address)
553 {
554 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
555 const char *address = "";
556
557 if (aps == 0) return PERMISSION_DENIED;
558
559 if (device_address != NULL) {
560 address = device_address;
561 }
562
563 return aps->setDeviceConnectionState(device, state, address);
564 }
565
getDeviceConnectionState(audio_devices_t device,const char * device_address)566 audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device,
567 const char *device_address)
568 {
569 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
570 if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
571
572 return aps->getDeviceConnectionState(device, device_address);
573 }
574
setPhoneState(audio_mode_t state)575 status_t AudioSystem::setPhoneState(audio_mode_t state)
576 {
577 if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE;
578 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
579 if (aps == 0) return PERMISSION_DENIED;
580
581 return aps->setPhoneState(state);
582 }
583
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)584 status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
585 {
586 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
587 if (aps == 0) return PERMISSION_DENIED;
588 return aps->setForceUse(usage, config);
589 }
590
getForceUse(audio_policy_force_use_t usage)591 audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage)
592 {
593 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
594 if (aps == 0) return AUDIO_POLICY_FORCE_NONE;
595 return aps->getForceUse(usage);
596 }
597
598
getOutput(audio_stream_type_t stream,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,audio_output_flags_t flags,const audio_offload_info_t * offloadInfo)599 audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream,
600 uint32_t samplingRate,
601 audio_format_t format,
602 audio_channel_mask_t channelMask,
603 audio_output_flags_t flags,
604 const audio_offload_info_t *offloadInfo)
605 {
606 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
607 if (aps == 0) return 0;
608 return aps->getOutput(stream, samplingRate, format, channelMask, flags, offloadInfo);
609 }
610
startOutput(audio_io_handle_t output,audio_stream_type_t stream,int session)611 status_t AudioSystem::startOutput(audio_io_handle_t output,
612 audio_stream_type_t stream,
613 int session)
614 {
615 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
616 if (aps == 0) return PERMISSION_DENIED;
617 return aps->startOutput(output, stream, session);
618 }
619
stopOutput(audio_io_handle_t output,audio_stream_type_t stream,int session)620 status_t AudioSystem::stopOutput(audio_io_handle_t output,
621 audio_stream_type_t stream,
622 int session)
623 {
624 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
625 if (aps == 0) return PERMISSION_DENIED;
626 return aps->stopOutput(output, stream, session);
627 }
628
releaseOutput(audio_io_handle_t output)629 void AudioSystem::releaseOutput(audio_io_handle_t output)
630 {
631 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
632 if (aps == 0) return;
633 aps->releaseOutput(output);
634 }
635
getInput(audio_source_t inputSource,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,int sessionId)636 audio_io_handle_t AudioSystem::getInput(audio_source_t inputSource,
637 uint32_t samplingRate,
638 audio_format_t format,
639 audio_channel_mask_t channelMask,
640 int sessionId)
641 {
642 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
643 if (aps == 0) return 0;
644 return aps->getInput(inputSource, samplingRate, format, channelMask, sessionId);
645 }
646
startInput(audio_io_handle_t input)647 status_t AudioSystem::startInput(audio_io_handle_t input)
648 {
649 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
650 if (aps == 0) return PERMISSION_DENIED;
651 return aps->startInput(input);
652 }
653
stopInput(audio_io_handle_t input)654 status_t AudioSystem::stopInput(audio_io_handle_t input)
655 {
656 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
657 if (aps == 0) return PERMISSION_DENIED;
658 return aps->stopInput(input);
659 }
660
releaseInput(audio_io_handle_t input)661 void AudioSystem::releaseInput(audio_io_handle_t input)
662 {
663 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
664 if (aps == 0) return;
665 aps->releaseInput(input);
666 }
667
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)668 status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,
669 int indexMin,
670 int indexMax)
671 {
672 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
673 if (aps == 0) return PERMISSION_DENIED;
674 return aps->initStreamVolume(stream, indexMin, indexMax);
675 }
676
setStreamVolumeIndex(audio_stream_type_t stream,int index,audio_devices_t device)677 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
678 int index,
679 audio_devices_t device)
680 {
681 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
682 if (aps == 0) return PERMISSION_DENIED;
683 return aps->setStreamVolumeIndex(stream, index, device);
684 }
685
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)686 status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
687 int *index,
688 audio_devices_t device)
689 {
690 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
691 if (aps == 0) return PERMISSION_DENIED;
692 return aps->getStreamVolumeIndex(stream, index, device);
693 }
694
getStrategyForStream(audio_stream_type_t stream)695 uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream)
696 {
697 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
698 if (aps == 0) return 0;
699 return aps->getStrategyForStream(stream);
700 }
701
getDevicesForStream(audio_stream_type_t stream)702 audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream)
703 {
704 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
705 if (aps == 0) return (audio_devices_t)0;
706 return aps->getDevicesForStream(stream);
707 }
708
getOutputForEffect(const effect_descriptor_t * desc)709 audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc)
710 {
711 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
712 if (aps == 0) return PERMISSION_DENIED;
713 return aps->getOutputForEffect(desc);
714 }
715
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,uint32_t strategy,int session,int id)716 status_t AudioSystem::registerEffect(const effect_descriptor_t *desc,
717 audio_io_handle_t io,
718 uint32_t strategy,
719 int session,
720 int id)
721 {
722 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
723 if (aps == 0) return PERMISSION_DENIED;
724 return aps->registerEffect(desc, io, strategy, session, id);
725 }
726
unregisterEffect(int id)727 status_t AudioSystem::unregisterEffect(int id)
728 {
729 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
730 if (aps == 0) return PERMISSION_DENIED;
731 return aps->unregisterEffect(id);
732 }
733
setEffectEnabled(int id,bool enabled)734 status_t AudioSystem::setEffectEnabled(int id, bool enabled)
735 {
736 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
737 if (aps == 0) return PERMISSION_DENIED;
738 return aps->setEffectEnabled(id, enabled);
739 }
740
isStreamActive(audio_stream_type_t stream,bool * state,uint32_t inPastMs)741 status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs)
742 {
743 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
744 if (aps == 0) return PERMISSION_DENIED;
745 if (state == NULL) return BAD_VALUE;
746 *state = aps->isStreamActive(stream, inPastMs);
747 return NO_ERROR;
748 }
749
isStreamActiveRemotely(audio_stream_type_t stream,bool * state,uint32_t inPastMs)750 status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state,
751 uint32_t inPastMs)
752 {
753 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
754 if (aps == 0) return PERMISSION_DENIED;
755 if (state == NULL) return BAD_VALUE;
756 *state = aps->isStreamActiveRemotely(stream, inPastMs);
757 return NO_ERROR;
758 }
759
isSourceActive(audio_source_t stream,bool * state)760 status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state)
761 {
762 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
763 if (aps == 0) return PERMISSION_DENIED;
764 if (state == NULL) return BAD_VALUE;
765 *state = aps->isSourceActive(stream);
766 return NO_ERROR;
767 }
768
getPrimaryOutputSamplingRate()769 uint32_t AudioSystem::getPrimaryOutputSamplingRate()
770 {
771 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
772 if (af == 0) return 0;
773 return af->getPrimaryOutputSamplingRate();
774 }
775
getPrimaryOutputFrameCount()776 size_t AudioSystem::getPrimaryOutputFrameCount()
777 {
778 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
779 if (af == 0) return 0;
780 return af->getPrimaryOutputFrameCount();
781 }
782
setLowRamDevice(bool isLowRamDevice)783 status_t AudioSystem::setLowRamDevice(bool isLowRamDevice)
784 {
785 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
786 if (af == 0) return PERMISSION_DENIED;
787 return af->setLowRamDevice(isLowRamDevice);
788 }
789
clearAudioConfigCache()790 void AudioSystem::clearAudioConfigCache()
791 {
792 Mutex::Autolock _l(gLock);
793 ALOGV("clearAudioConfigCache()");
794 gOutputs.clear();
795 }
796
isOffloadSupported(const audio_offload_info_t & info)797 bool AudioSystem::isOffloadSupported(const audio_offload_info_t& info)
798 {
799 ALOGV("isOffloadSupported()");
800 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
801 if (aps == 0) return false;
802 return aps->isOffloadSupported(info);
803 }
804
805 // ---------------------------------------------------------------------------
806
binderDied(const wp<IBinder> & who)807 void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who) {
808 Mutex::Autolock _l(AudioSystem::gLock);
809 AudioSystem::gAudioPolicyService.clear();
810
811 ALOGW("AudioPolicyService server died!");
812 }
813
814 }; // namespace android
815