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