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