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