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