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 audio_channel_mask_t AudioSystem::gPrevInChannelMask = AUDIO_CHANNEL_IN_MONO; 45 size_t AudioSystem::gInBuffSize = 0; 46 47 48 // establish binder interface to AudioFlinger service 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType) 209 { 210 audio_io_handle_t output; 211 212 if (streamType == AUDIO_STREAM_DEFAULT) { 213 streamType = AUDIO_STREAM_MUSIC; 214 } 215 216 output = getOutput(streamType); 217 if (output == 0) { 218 return PERMISSION_DENIED; 219 } 220 221 return getSamplingRate(output, streamType, samplingRate); 222 } 223 224 status_t AudioSystem::getSamplingRate(audio_io_handle_t output, 225 audio_stream_type_t streamType, 226 uint32_t* samplingRate) 227 { 228 OutputDescriptor *outputDesc; 229 230 gLock.lock(); 231 outputDesc = AudioSystem::gOutputs.valueFor(output); 232 if (outputDesc == NULL) { 233 ALOGV("getOutputSamplingRate() no output descriptor for output %d in gOutputs", output); 234 gLock.unlock(); 235 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 236 if (af == 0) return PERMISSION_DENIED; 237 *samplingRate = af->sampleRate(output); 238 } else { 239 ALOGV("getOutputSamplingRate() reading from output desc"); 240 *samplingRate = outputDesc->samplingRate; 241 gLock.unlock(); 242 } 243 244 ALOGV("getSamplingRate() streamType %d, output %d, sampling rate %u", streamType, output, 245 *samplingRate); 246 247 return NO_ERROR; 248 } 249 250 status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType) 251 { 252 audio_io_handle_t output; 253 254 if (streamType == AUDIO_STREAM_DEFAULT) { 255 streamType = AUDIO_STREAM_MUSIC; 256 } 257 258 output = getOutput(streamType); 259 if (output == 0) { 260 return PERMISSION_DENIED; 261 } 262 263 return getFrameCount(output, streamType, frameCount); 264 } 265 266 status_t AudioSystem::getFrameCount(audio_io_handle_t output, 267 audio_stream_type_t streamType, 268 size_t* frameCount) 269 { 270 OutputDescriptor *outputDesc; 271 272 gLock.lock(); 273 outputDesc = AudioSystem::gOutputs.valueFor(output); 274 if (outputDesc == NULL) { 275 gLock.unlock(); 276 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 277 if (af == 0) return PERMISSION_DENIED; 278 *frameCount = af->frameCount(output); 279 } else { 280 *frameCount = outputDesc->frameCount; 281 gLock.unlock(); 282 } 283 284 ALOGV("getFrameCount() streamType %d, output %d, frameCount %d", streamType, output, 285 *frameCount); 286 287 return NO_ERROR; 288 } 289 290 status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType) 291 { 292 audio_io_handle_t output; 293 294 if (streamType == AUDIO_STREAM_DEFAULT) { 295 streamType = AUDIO_STREAM_MUSIC; 296 } 297 298 output = getOutput(streamType); 299 if (output == 0) { 300 return PERMISSION_DENIED; 301 } 302 303 return getLatency(output, streamType, latency); 304 } 305 306 status_t AudioSystem::getLatency(audio_io_handle_t output, 307 audio_stream_type_t streamType, 308 uint32_t* latency) 309 { 310 OutputDescriptor *outputDesc; 311 312 gLock.lock(); 313 outputDesc = AudioSystem::gOutputs.valueFor(output); 314 if (outputDesc == NULL) { 315 gLock.unlock(); 316 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 317 if (af == 0) return PERMISSION_DENIED; 318 *latency = af->latency(output); 319 } else { 320 *latency = outputDesc->latency; 321 gLock.unlock(); 322 } 323 324 ALOGV("getLatency() streamType %d, output %d, latency %d", streamType, output, *latency); 325 326 return NO_ERROR; 327 } 328 329 status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format, 330 audio_channel_mask_t channelMask, size_t* buffSize) 331 { 332 gLock.lock(); 333 // Do we have a stale gInBufferSize or are we requesting the input buffer size for new values 334 size_t inBuffSize = gInBuffSize; 335 if ((inBuffSize == 0) || (sampleRate != gPrevInSamplingRate) || (format != gPrevInFormat) 336 || (channelMask != gPrevInChannelMask)) { 337 gLock.unlock(); 338 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 339 if (af == 0) { 340 return PERMISSION_DENIED; 341 } 342 inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask); 343 gLock.lock(); 344 // save the request params 345 gPrevInSamplingRate = sampleRate; 346 gPrevInFormat = format; 347 gPrevInChannelMask = channelMask; 348 349 gInBuffSize = inBuffSize; 350 } 351 gLock.unlock(); 352 *buffSize = inBuffSize; 353 354 return NO_ERROR; 355 } 356 357 status_t AudioSystem::setVoiceVolume(float value) 358 { 359 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 360 if (af == 0) return PERMISSION_DENIED; 361 return af->setVoiceVolume(value); 362 } 363 364 status_t AudioSystem::getRenderPosition(size_t *halFrames, size_t *dspFrames, 365 audio_stream_type_t stream) 366 { 367 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 368 if (af == 0) return PERMISSION_DENIED; 369 370 if (stream == AUDIO_STREAM_DEFAULT) { 371 stream = AUDIO_STREAM_MUSIC; 372 } 373 374 return af->getRenderPosition(halFrames, dspFrames, getOutput(stream)); 375 } 376 377 size_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) { 378 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 379 unsigned int result = 0; 380 if (af == 0) return result; 381 if (ioHandle == 0) return result; 382 383 result = af->getInputFramesLost(ioHandle); 384 return result; 385 } 386 387 int AudioSystem::newAudioSessionId() { 388 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 389 if (af == 0) return 0; 390 return af->newAudioSessionId(); 391 } 392 393 void AudioSystem::acquireAudioSessionId(int audioSession) { 394 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 395 if (af != 0) { 396 af->acquireAudioSessionId(audioSession); 397 } 398 } 399 400 void AudioSystem::releaseAudioSessionId(int audioSession) { 401 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 402 if (af != 0) { 403 af->releaseAudioSessionId(audioSession); 404 } 405 } 406 407 // --------------------------------------------------------------------------- 408 409 void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who) { 410 Mutex::Autolock _l(AudioSystem::gLock); 411 412 AudioSystem::gAudioFlinger.clear(); 413 // clear output handles and stream to output map caches 414 AudioSystem::gOutputs.clear(); 415 416 if (gAudioErrorCallback) { 417 gAudioErrorCallback(DEAD_OBJECT); 418 } 419 ALOGW("AudioFlinger server died!"); 420 } 421 422 void AudioSystem::AudioFlingerClient::ioConfigChanged(int event, audio_io_handle_t ioHandle, 423 const void *param2) { 424 ALOGV("ioConfigChanged() event %d", event); 425 const OutputDescriptor *desc; 426 audio_stream_type_t stream; 427 428 if (ioHandle == 0) return; 429 430 Mutex::Autolock _l(AudioSystem::gLock); 431 432 switch (event) { 433 case STREAM_CONFIG_CHANGED: 434 break; 435 case OUTPUT_OPENED: { 436 if (gOutputs.indexOfKey(ioHandle) >= 0) { 437 ALOGV("ioConfigChanged() opening already existing output! %d", ioHandle); 438 break; 439 } 440 if (param2 == NULL) break; 441 desc = (const OutputDescriptor *)param2; 442 443 OutputDescriptor *outputDesc = new OutputDescriptor(*desc); 444 gOutputs.add(ioHandle, outputDesc); 445 ALOGV("ioConfigChanged() new output samplingRate %u, format %d channels %#x frameCount %u " 446 "latency %d", 447 outputDesc->samplingRate, outputDesc->format, outputDesc->channels, 448 outputDesc->frameCount, outputDesc->latency); 449 } break; 450 case OUTPUT_CLOSED: { 451 if (gOutputs.indexOfKey(ioHandle) < 0) { 452 ALOGW("ioConfigChanged() closing unknow output! %d", ioHandle); 453 break; 454 } 455 ALOGV("ioConfigChanged() output %d closed", ioHandle); 456 457 gOutputs.removeItem(ioHandle); 458 } break; 459 460 case OUTPUT_CONFIG_CHANGED: { 461 int index = gOutputs.indexOfKey(ioHandle); 462 if (index < 0) { 463 ALOGW("ioConfigChanged() modifying unknow output! %d", ioHandle); 464 break; 465 } 466 if (param2 == NULL) break; 467 desc = (const OutputDescriptor *)param2; 468 469 ALOGV("ioConfigChanged() new config for output %d samplingRate %u, format %d channels %#x " 470 "frameCount %d latency %d", 471 ioHandle, desc->samplingRate, desc->format, 472 desc->channels, desc->frameCount, desc->latency); 473 OutputDescriptor *outputDesc = gOutputs.valueAt(index); 474 delete outputDesc; 475 outputDesc = new OutputDescriptor(*desc); 476 gOutputs.replaceValueFor(ioHandle, outputDesc); 477 } break; 478 case INPUT_OPENED: 479 case INPUT_CLOSED: 480 case INPUT_CONFIG_CHANGED: 481 break; 482 483 } 484 } 485 486 void AudioSystem::setErrorCallback(audio_error_callback cb) { 487 Mutex::Autolock _l(gLock); 488 gAudioErrorCallback = cb; 489 } 490 491 bool AudioSystem::routedToA2dpOutput(audio_stream_type_t streamType) { 492 switch (streamType) { 493 case AUDIO_STREAM_MUSIC: 494 case AUDIO_STREAM_VOICE_CALL: 495 case AUDIO_STREAM_BLUETOOTH_SCO: 496 case AUDIO_STREAM_SYSTEM: 497 return true; 498 default: 499 return false; 500 } 501 } 502 503 504 // client singleton for AudioPolicyService binder interface 505 sp<IAudioPolicyService> AudioSystem::gAudioPolicyService; 506 sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient; 507 508 509 // establish binder interface to AudioPolicy service 510 const sp<IAudioPolicyService>& AudioSystem::get_audio_policy_service() 511 { 512 gLock.lock(); 513 if (gAudioPolicyService == 0) { 514 sp<IServiceManager> sm = defaultServiceManager(); 515 sp<IBinder> binder; 516 do { 517 binder = sm->getService(String16("media.audio_policy")); 518 if (binder != 0) 519 break; 520 ALOGW("AudioPolicyService not published, waiting..."); 521 usleep(500000); // 0.5 s 522 } while (true); 523 if (gAudioPolicyServiceClient == NULL) { 524 gAudioPolicyServiceClient = new AudioPolicyServiceClient(); 525 } 526 binder->linkToDeath(gAudioPolicyServiceClient); 527 gAudioPolicyService = interface_cast<IAudioPolicyService>(binder); 528 gLock.unlock(); 529 } else { 530 gLock.unlock(); 531 } 532 return gAudioPolicyService; 533 } 534 535 status_t AudioSystem::setDeviceConnectionState(audio_devices_t device, 536 audio_policy_dev_state_t state, 537 const char *device_address) 538 { 539 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 540 const char *address = ""; 541 542 if (aps == 0) return PERMISSION_DENIED; 543 544 if (device_address != NULL) { 545 address = device_address; 546 } 547 548 return aps->setDeviceConnectionState(device, state, address); 549 } 550 551 audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device, 552 const char *device_address) 553 { 554 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 555 if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 556 557 return aps->getDeviceConnectionState(device, device_address); 558 } 559 560 status_t AudioSystem::setPhoneState(audio_mode_t state) 561 { 562 if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE; 563 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 564 if (aps == 0) return PERMISSION_DENIED; 565 566 return aps->setPhoneState(state); 567 } 568 569 status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 570 { 571 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 572 if (aps == 0) return PERMISSION_DENIED; 573 return aps->setForceUse(usage, config); 574 } 575 576 audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) 577 { 578 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 579 if (aps == 0) return AUDIO_POLICY_FORCE_NONE; 580 return aps->getForceUse(usage); 581 } 582 583 584 audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream, 585 uint32_t samplingRate, 586 audio_format_t format, 587 audio_channel_mask_t channelMask, 588 audio_output_flags_t flags) 589 { 590 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 591 if (aps == 0) return 0; 592 return aps->getOutput(stream, samplingRate, format, channelMask, flags); 593 } 594 595 status_t AudioSystem::startOutput(audio_io_handle_t output, 596 audio_stream_type_t stream, 597 int session) 598 { 599 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 600 if (aps == 0) return PERMISSION_DENIED; 601 return aps->startOutput(output, stream, session); 602 } 603 604 status_t AudioSystem::stopOutput(audio_io_handle_t output, 605 audio_stream_type_t stream, 606 int session) 607 { 608 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 609 if (aps == 0) return PERMISSION_DENIED; 610 return aps->stopOutput(output, stream, session); 611 } 612 613 void AudioSystem::releaseOutput(audio_io_handle_t output) 614 { 615 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 616 if (aps == 0) return; 617 aps->releaseOutput(output); 618 } 619 620 audio_io_handle_t AudioSystem::getInput(audio_source_t inputSource, 621 uint32_t samplingRate, 622 audio_format_t format, 623 audio_channel_mask_t channelMask, 624 int sessionId) 625 { 626 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 627 if (aps == 0) return 0; 628 return aps->getInput(inputSource, samplingRate, format, channelMask, sessionId); 629 } 630 631 status_t AudioSystem::startInput(audio_io_handle_t input) 632 { 633 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 634 if (aps == 0) return PERMISSION_DENIED; 635 return aps->startInput(input); 636 } 637 638 status_t AudioSystem::stopInput(audio_io_handle_t input) 639 { 640 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 641 if (aps == 0) return PERMISSION_DENIED; 642 return aps->stopInput(input); 643 } 644 645 void AudioSystem::releaseInput(audio_io_handle_t input) 646 { 647 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 648 if (aps == 0) return; 649 aps->releaseInput(input); 650 } 651 652 status_t AudioSystem::initStreamVolume(audio_stream_type_t stream, 653 int indexMin, 654 int indexMax) 655 { 656 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 657 if (aps == 0) return PERMISSION_DENIED; 658 return aps->initStreamVolume(stream, indexMin, indexMax); 659 } 660 661 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream, 662 int index, 663 audio_devices_t device) 664 { 665 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 666 if (aps == 0) return PERMISSION_DENIED; 667 return aps->setStreamVolumeIndex(stream, index, device); 668 } 669 670 status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream, 671 int *index, 672 audio_devices_t device) 673 { 674 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 675 if (aps == 0) return PERMISSION_DENIED; 676 return aps->getStreamVolumeIndex(stream, index, device); 677 } 678 679 uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) 680 { 681 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 682 if (aps == 0) return 0; 683 return aps->getStrategyForStream(stream); 684 } 685 686 audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream) 687 { 688 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 689 if (aps == 0) return (audio_devices_t)0; 690 return aps->getDevicesForStream(stream); 691 } 692 693 audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc) 694 { 695 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 696 if (aps == 0) return PERMISSION_DENIED; 697 return aps->getOutputForEffect(desc); 698 } 699 700 status_t AudioSystem::registerEffect(const effect_descriptor_t *desc, 701 audio_io_handle_t io, 702 uint32_t strategy, 703 int session, 704 int id) 705 { 706 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 707 if (aps == 0) return PERMISSION_DENIED; 708 return aps->registerEffect(desc, io, strategy, session, id); 709 } 710 711 status_t AudioSystem::unregisterEffect(int id) 712 { 713 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 714 if (aps == 0) return PERMISSION_DENIED; 715 return aps->unregisterEffect(id); 716 } 717 718 status_t AudioSystem::setEffectEnabled(int id, bool enabled) 719 { 720 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 721 if (aps == 0) return PERMISSION_DENIED; 722 return aps->setEffectEnabled(id, enabled); 723 } 724 725 status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs) 726 { 727 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 728 if (aps == 0) return PERMISSION_DENIED; 729 if (state == NULL) return BAD_VALUE; 730 *state = aps->isStreamActive(stream, inPastMs); 731 return NO_ERROR; 732 } 733 734 status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state, 735 uint32_t inPastMs) 736 { 737 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 738 if (aps == 0) return PERMISSION_DENIED; 739 if (state == NULL) return BAD_VALUE; 740 *state = aps->isStreamActiveRemotely(stream, inPastMs); 741 return NO_ERROR; 742 } 743 744 status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state) 745 { 746 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 747 if (aps == 0) return PERMISSION_DENIED; 748 if (state == NULL) return BAD_VALUE; 749 *state = aps->isSourceActive(stream); 750 return NO_ERROR; 751 } 752 753 uint32_t AudioSystem::getPrimaryOutputSamplingRate() 754 { 755 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 756 if (af == 0) return 0; 757 return af->getPrimaryOutputSamplingRate(); 758 } 759 760 size_t AudioSystem::getPrimaryOutputFrameCount() 761 { 762 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 763 if (af == 0) return 0; 764 return af->getPrimaryOutputFrameCount(); 765 } 766 767 void AudioSystem::clearAudioConfigCache() 768 { 769 Mutex::Autolock _l(gLock); 770 ALOGV("clearAudioConfigCache()"); 771 gOutputs.clear(); 772 } 773 774 // --------------------------------------------------------------------------- 775 776 void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who) { 777 Mutex::Autolock _l(AudioSystem::gLock); 778 AudioSystem::gAudioPolicyService.clear(); 779 780 ALOGW("AudioPolicyService server died!"); 781 } 782 783 }; // namespace android 784