1/* 2 * Copyright (C) 2009 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 "APM_AudioPolicyManager" 18//#define LOG_NDEBUG 0 19 20//#define VERY_VERBOSE_LOGGING 21#ifdef VERY_VERBOSE_LOGGING 22#define ALOGVV ALOGV 23#else 24#define ALOGVV(a...) do { } while(0) 25#endif 26 27#define AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH 128 28#define AUDIO_POLICY_XML_CONFIG_FILE_NAME "audio_policy_configuration.xml" 29 30#include <inttypes.h> 31#include <math.h> 32 33#include <AudioPolicyManagerInterface.h> 34#include <AudioPolicyEngineInstance.h> 35#include <cutils/atomic.h> 36#include <cutils/properties.h> 37#include <utils/Log.h> 38#include <media/AudioParameter.h> 39#include <media/AudioPolicyHelper.h> 40#include <soundtrigger/SoundTrigger.h> 41#include <system/audio.h> 42#include <audio_policy_conf.h> 43#include "AudioPolicyManager.h" 44#ifndef USE_XML_AUDIO_POLICY_CONF 45#include <ConfigParsingUtils.h> 46#include <StreamDescriptor.h> 47#endif 48#include <Serializer.h> 49#include "TypeConverter.h" 50#include <policy.h> 51 52namespace android { 53 54//FIXME: workaround for truncated touch sounds 55// to be removed when the problem is handled by system UI 56#define TOUCH_SOUND_FIXED_DELAY_MS 100 57// ---------------------------------------------------------------------------- 58// AudioPolicyInterface implementation 59// ---------------------------------------------------------------------------- 60 61status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device, 62 audio_policy_dev_state_t state, 63 const char *device_address, 64 const char *device_name) 65{ 66 return setDeviceConnectionStateInt(device, state, device_address, device_name); 67} 68 69void AudioPolicyManager::broadcastDeviceConnectionState(audio_devices_t device, 70 audio_policy_dev_state_t state, 71 const String8 &device_address) 72{ 73 AudioParameter param(device_address); 74 const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ? 75 AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect); 76 param.addInt(key, device); 77 mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString()); 78} 79 80status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t device, 81 audio_policy_dev_state_t state, 82 const char *device_address, 83 const char *device_name) 84{ 85 ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s", 86- device, state, device_address, device_name); 87 88 // connect/disconnect only 1 device at a time 89 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE; 90 91 sp<DeviceDescriptor> devDesc = 92 mHwModules.getDeviceDescriptor(device, device_address, device_name); 93 94 // handle output devices 95 if (audio_is_output_device(device)) { 96 SortedVector <audio_io_handle_t> outputs; 97 98 ssize_t index = mAvailableOutputDevices.indexOf(devDesc); 99 100 // save a copy of the opened output descriptors before any output is opened or closed 101 // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies() 102 mPreviousOutputs = mOutputs; 103 switch (state) 104 { 105 // handle output device connection 106 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: { 107 if (index >= 0) { 108 ALOGW("setDeviceConnectionState() device already connected: %x", device); 109 return INVALID_OPERATION; 110 } 111 ALOGV("setDeviceConnectionState() connecting device %x", device); 112 113 // register new device as available 114 index = mAvailableOutputDevices.add(devDesc); 115 if (index >= 0) { 116 sp<HwModule> module = mHwModules.getModuleForDevice(device); 117 if (module == 0) { 118 ALOGD("setDeviceConnectionState() could not find HW module for device %08x", 119 device); 120 mAvailableOutputDevices.remove(devDesc); 121 return INVALID_OPERATION; 122 } 123 mAvailableOutputDevices[index]->attach(module); 124 } else { 125 return NO_MEMORY; 126 } 127 128 // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic 129 // parameters on newly connected devices (instead of opening the outputs...) 130 broadcastDeviceConnectionState(device, state, devDesc->mAddress); 131 132 if (checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress) != NO_ERROR) { 133 mAvailableOutputDevices.remove(devDesc); 134 135 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 136 devDesc->mAddress); 137 return INVALID_OPERATION; 138 } 139 // Propagate device availability to Engine 140 mEngine->setDeviceConnectionState(devDesc, state); 141 142 // outputs should never be empty here 143 ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():" 144 "checkOutputsForDevice() returned no outputs but status OK"); 145 ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %zu outputs", 146 outputs.size()); 147 148 } break; 149 // handle output device disconnection 150 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: { 151 if (index < 0) { 152 ALOGW("setDeviceConnectionState() device not connected: %x", device); 153 return INVALID_OPERATION; 154 } 155 156 ALOGV("setDeviceConnectionState() disconnecting output device %x", device); 157 158 // Send Disconnect to HALs 159 broadcastDeviceConnectionState(device, state, devDesc->mAddress); 160 161 // remove device from available output devices 162 mAvailableOutputDevices.remove(devDesc); 163 164 checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress); 165 166 // Propagate device availability to Engine 167 mEngine->setDeviceConnectionState(devDesc, state); 168 } break; 169 170 default: 171 ALOGE("setDeviceConnectionState() invalid state: %x", state); 172 return BAD_VALUE; 173 } 174 175 // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP 176 // output is suspended before any tracks are moved to it 177 checkA2dpSuspend(); 178 checkOutputForAllStrategies(); 179 // outputs must be closed after checkOutputForAllStrategies() is executed 180 if (!outputs.isEmpty()) { 181 for (size_t i = 0; i < outputs.size(); i++) { 182 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]); 183 // close unused outputs after device disconnection or direct outputs that have been 184 // opened by checkOutputsForDevice() to query dynamic parameters 185 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) || 186 (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) && 187 (desc->mDirectOpenCount == 0))) { 188 closeOutput(outputs[i]); 189 } 190 } 191 // check again after closing A2DP output to reset mA2dpSuspended if needed 192 checkA2dpSuspend(); 193 } 194 195 updateDevicesAndOutputs(); 196 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) { 197 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/); 198 updateCallRouting(newDevice); 199 } 200 for (size_t i = 0; i < mOutputs.size(); i++) { 201 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 202 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) { 203 audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/); 204 // do not force device change on duplicated output because if device is 0, it will 205 // also force a device 0 for the two outputs it is duplicated to which may override 206 // a valid device selection on those outputs. 207 bool force = !desc->isDuplicated() 208 && (!device_distinguishes_on_address(device) 209 // always force when disconnecting (a non-duplicated device) 210 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)); 211 setOutputDevice(desc, newDevice, force, 0); 212 } 213 } 214 215 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) { 216 cleanUpForDevice(devDesc); 217 } 218 219 mpClientInterface->onAudioPortListUpdate(); 220 return NO_ERROR; 221 } // end if is output device 222 223 // handle input devices 224 if (audio_is_input_device(device)) { 225 SortedVector <audio_io_handle_t> inputs; 226 227 ssize_t index = mAvailableInputDevices.indexOf(devDesc); 228 switch (state) 229 { 230 // handle input device connection 231 case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: { 232 if (index >= 0) { 233 ALOGW("setDeviceConnectionState() device already connected: %d", device); 234 return INVALID_OPERATION; 235 } 236 sp<HwModule> module = mHwModules.getModuleForDevice(device); 237 if (module == NULL) { 238 ALOGW("setDeviceConnectionState(): could not find HW module for device %08x", 239 device); 240 return INVALID_OPERATION; 241 } 242 243 // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic 244 // parameters on newly connected devices (instead of opening the inputs...) 245 broadcastDeviceConnectionState(device, state, devDesc->mAddress); 246 247 if (checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress) != NO_ERROR) { 248 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 249 devDesc->mAddress); 250 return INVALID_OPERATION; 251 } 252 253 index = mAvailableInputDevices.add(devDesc); 254 if (index >= 0) { 255 mAvailableInputDevices[index]->attach(module); 256 } else { 257 return NO_MEMORY; 258 } 259 260 // Propagate device availability to Engine 261 mEngine->setDeviceConnectionState(devDesc, state); 262 } break; 263 264 // handle input device disconnection 265 case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: { 266 if (index < 0) { 267 ALOGW("setDeviceConnectionState() device not connected: %d", device); 268 return INVALID_OPERATION; 269 } 270 271 ALOGV("setDeviceConnectionState() disconnecting input device %x", device); 272 273 // Set Disconnect to HALs 274 broadcastDeviceConnectionState(device, state, devDesc->mAddress); 275 276 checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress); 277 mAvailableInputDevices.remove(devDesc); 278 279 // Propagate device availability to Engine 280 mEngine->setDeviceConnectionState(devDesc, state); 281 } break; 282 283 default: 284 ALOGE("setDeviceConnectionState() invalid state: %x", state); 285 return BAD_VALUE; 286 } 287 288 closeAllInputs(); 289 // As the input device list can impact the output device selection, update 290 // getDeviceForStrategy() cache 291 updateDevicesAndOutputs(); 292 293 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) { 294 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/); 295 updateCallRouting(newDevice); 296 } 297 298 if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) { 299 cleanUpForDevice(devDesc); 300 } 301 302 mpClientInterface->onAudioPortListUpdate(); 303 return NO_ERROR; 304 } // end if is input device 305 306 ALOGW("setDeviceConnectionState() invalid device: %x", device); 307 return BAD_VALUE; 308} 309 310audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device, 311 const char *device_address) 312{ 313 sp<DeviceDescriptor> devDesc = 314 mHwModules.getDeviceDescriptor(device, device_address, "", 315 (strlen(device_address) != 0)/*matchAddress*/); 316 317 if (devDesc == 0) { 318 ALOGW("getDeviceConnectionState() undeclared device, type %08x, address: %s", 319 device, device_address); 320 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 321 } 322 323 DeviceVector *deviceVector; 324 325 if (audio_is_output_device(device)) { 326 deviceVector = &mAvailableOutputDevices; 327 } else if (audio_is_input_device(device)) { 328 deviceVector = &mAvailableInputDevices; 329 } else { 330 ALOGW("getDeviceConnectionState() invalid device type %08x", device); 331 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 332 } 333 334 return (deviceVector->getDevice(device, String8(device_address)) != 0) ? 335 AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 336} 337 338status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device, 339 const char *device_address, 340 const char *device_name) 341{ 342 status_t status; 343 344 ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s", 345 device, device_address, device_name); 346 347 // connect/disconnect only 1 device at a time 348 if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE; 349 350 // Check if the device is currently connected 351 sp<DeviceDescriptor> devDesc = 352 mHwModules.getDeviceDescriptor(device, device_address, device_name); 353 ssize_t index = mAvailableOutputDevices.indexOf(devDesc); 354 if (index < 0) { 355 // Nothing to do: device is not connected 356 return NO_ERROR; 357 } 358 359 // Toggle the device state: UNAVAILABLE -> AVAILABLE 360 // This will force reading again the device configuration 361 status = setDeviceConnectionState(device, 362 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 363 device_address, device_name); 364 if (status != NO_ERROR) { 365 ALOGW("handleDeviceConfigChange() error disabling connection state: %d", 366 status); 367 return status; 368 } 369 370 status = setDeviceConnectionState(device, 371 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, 372 device_address, device_name); 373 if (status != NO_ERROR) { 374 ALOGW("handleDeviceConfigChange() error enabling connection state: %d", 375 status); 376 return status; 377 } 378 379 return NO_ERROR; 380} 381 382uint32_t AudioPolicyManager::updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs) 383{ 384 bool createTxPatch = false; 385 status_t status; 386 audio_patch_handle_t afPatchHandle; 387 DeviceVector deviceList; 388 uint32_t muteWaitMs = 0; 389 390 if(!hasPrimaryOutput() || mPrimaryOutput->device() == AUDIO_DEVICE_OUT_STUB) { 391 return muteWaitMs; 392 } 393 audio_devices_t txDevice = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION); 394 ALOGV("updateCallRouting device rxDevice %08x txDevice %08x", rxDevice, txDevice); 395 396 // release existing RX patch if any 397 if (mCallRxPatch != 0) { 398 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0); 399 mCallRxPatch.clear(); 400 } 401 // release TX patch if any 402 if (mCallTxPatch != 0) { 403 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0); 404 mCallTxPatch.clear(); 405 } 406 407 // If the RX device is on the primary HW module, then use legacy routing method for voice calls 408 // via setOutputDevice() on primary output. 409 // Otherwise, create two audio patches for TX and RX path. 410 if (availablePrimaryOutputDevices() & rxDevice) { 411 muteWaitMs = setOutputDevice(mPrimaryOutput, rxDevice, true, delayMs); 412 // If the TX device is also on the primary HW module, setOutputDevice() will take care 413 // of it due to legacy implementation. If not, create a patch. 414 if ((availablePrimaryInputDevices() & txDevice & ~AUDIO_DEVICE_BIT_IN) 415 == AUDIO_DEVICE_NONE) { 416 createTxPatch = true; 417 } 418 } else { // create RX path audio patch 419 struct audio_patch patch; 420 421 patch.num_sources = 1; 422 patch.num_sinks = 1; 423 deviceList = mAvailableOutputDevices.getDevicesFromType(rxDevice); 424 ALOG_ASSERT(!deviceList.isEmpty(), 425 "updateCallRouting() selected device not in output device list"); 426 sp<DeviceDescriptor> rxSinkDeviceDesc = deviceList.itemAt(0); 427 deviceList = mAvailableInputDevices.getDevicesFromType(AUDIO_DEVICE_IN_TELEPHONY_RX); 428 ALOG_ASSERT(!deviceList.isEmpty(), 429 "updateCallRouting() no telephony RX device"); 430 sp<DeviceDescriptor> rxSourceDeviceDesc = deviceList.itemAt(0); 431 432 rxSourceDeviceDesc->toAudioPortConfig(&patch.sources[0]); 433 rxSinkDeviceDesc->toAudioPortConfig(&patch.sinks[0]); 434 435 // request to reuse existing output stream if one is already opened to reach the RX device 436 SortedVector<audio_io_handle_t> outputs = 437 getOutputsForDevice(rxDevice, mOutputs); 438 audio_io_handle_t output = selectOutput(outputs, 439 AUDIO_OUTPUT_FLAG_NONE, 440 AUDIO_FORMAT_INVALID); 441 if (output != AUDIO_IO_HANDLE_NONE) { 442 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output); 443 ALOG_ASSERT(!outputDesc->isDuplicated(), 444 "updateCallRouting() RX device output is duplicated"); 445 outputDesc->toAudioPortConfig(&patch.sources[1]); 446 patch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH; 447 patch.num_sources = 2; 448 } 449 450 afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 451 status = mpClientInterface->createAudioPatch(&patch, &afPatchHandle, delayMs); 452 ALOGW_IF(status != NO_ERROR, "updateCallRouting() error %d creating RX audio patch", 453 status); 454 if (status == NO_ERROR) { 455 mCallRxPatch = new AudioPatch(&patch, mUidCached); 456 mCallRxPatch->mAfPatchHandle = afPatchHandle; 457 mCallRxPatch->mUid = mUidCached; 458 } 459 createTxPatch = true; 460 } 461 if (createTxPatch) { // create TX path audio patch 462 struct audio_patch patch; 463 464 patch.num_sources = 1; 465 patch.num_sinks = 1; 466 deviceList = mAvailableInputDevices.getDevicesFromType(txDevice); 467 ALOG_ASSERT(!deviceList.isEmpty(), 468 "updateCallRouting() selected device not in input device list"); 469 sp<DeviceDescriptor> txSourceDeviceDesc = deviceList.itemAt(0); 470 txSourceDeviceDesc->toAudioPortConfig(&patch.sources[0]); 471 deviceList = mAvailableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_TELEPHONY_TX); 472 ALOG_ASSERT(!deviceList.isEmpty(), 473 "updateCallRouting() no telephony TX device"); 474 sp<DeviceDescriptor> txSinkDeviceDesc = deviceList.itemAt(0); 475 txSinkDeviceDesc->toAudioPortConfig(&patch.sinks[0]); 476 477 SortedVector<audio_io_handle_t> outputs = 478 getOutputsForDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX, mOutputs); 479 audio_io_handle_t output = selectOutput(outputs, 480 AUDIO_OUTPUT_FLAG_NONE, 481 AUDIO_FORMAT_INVALID); 482 // request to reuse existing output stream if one is already opened to reach the TX 483 // path output device 484 if (output != AUDIO_IO_HANDLE_NONE) { 485 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output); 486 ALOG_ASSERT(!outputDesc->isDuplicated(), 487 "updateCallRouting() RX device output is duplicated"); 488 outputDesc->toAudioPortConfig(&patch.sources[1]); 489 patch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH; 490 patch.num_sources = 2; 491 } 492 493 // terminate active capture if on the same HW module as the call TX source device 494 // FIXME: would be better to refine to only inputs whose profile connects to the 495 // call TX device but this information is not in the audio patch and logic here must be 496 // symmetric to the one in startInput() 497 Vector<sp <AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs(); 498 for (size_t i = 0; i < activeInputs.size(); i++) { 499 sp<AudioInputDescriptor> activeDesc = activeInputs[i]; 500 if (activeDesc->hasSameHwModuleAs(txSourceDeviceDesc)) { 501 AudioSessionCollection activeSessions = 502 activeDesc->getAudioSessions(true /*activeOnly*/); 503 for (size_t j = 0; j < activeSessions.size(); j++) { 504 audio_session_t activeSession = activeSessions.keyAt(j); 505 stopInput(activeDesc->mIoHandle, activeSession); 506 releaseInput(activeDesc->mIoHandle, activeSession); 507 } 508 } 509 } 510 511 afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 512 status = mpClientInterface->createAudioPatch(&patch, &afPatchHandle, delayMs); 513 ALOGW_IF(status != NO_ERROR, "setPhoneState() error %d creating TX audio patch", 514 status); 515 if (status == NO_ERROR) { 516 mCallTxPatch = new AudioPatch(&patch, mUidCached); 517 mCallTxPatch->mAfPatchHandle = afPatchHandle; 518 mCallTxPatch->mUid = mUidCached; 519 } 520 } 521 522 return muteWaitMs; 523} 524 525void AudioPolicyManager::setPhoneState(audio_mode_t state) 526{ 527 ALOGV("setPhoneState() state %d", state); 528 // store previous phone state for management of sonification strategy below 529 int oldState = mEngine->getPhoneState(); 530 531 if (mEngine->setPhoneState(state) != NO_ERROR) { 532 ALOGW("setPhoneState() invalid or same state %d", state); 533 return; 534 } 535 /// Opens: can these line be executed after the switch of volume curves??? 536 // if leaving call state, handle special case of active streams 537 // pertaining to sonification strategy see handleIncallSonification() 538 if (isStateInCall(oldState)) { 539 ALOGV("setPhoneState() in call state management: new state is %d", state); 540 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) { 541 handleIncallSonification((audio_stream_type_t)stream, false, true); 542 } 543 544 // force reevaluating accessibility routing when call stops 545 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY); 546 } 547 548 /** 549 * Switching to or from incall state or switching between telephony and VoIP lead to force 550 * routing command. 551 */ 552 bool force = ((is_state_in_call(oldState) != is_state_in_call(state)) 553 || (is_state_in_call(state) && (state != oldState))); 554 555 // check for device and output changes triggered by new phone state 556 checkA2dpSuspend(); 557 checkOutputForAllStrategies(); 558 updateDevicesAndOutputs(); 559 560 int delayMs = 0; 561 if (isStateInCall(state)) { 562 nsecs_t sysTime = systemTime(); 563 for (size_t i = 0; i < mOutputs.size(); i++) { 564 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 565 // mute media and sonification strategies and delay device switch by the largest 566 // latency of any output where either strategy is active. 567 // This avoid sending the ring tone or music tail into the earpiece or headset. 568 if ((isStrategyActive(desc, STRATEGY_MEDIA, 569 SONIFICATION_HEADSET_MUSIC_DELAY, 570 sysTime) || 571 isStrategyActive(desc, STRATEGY_SONIFICATION, 572 SONIFICATION_HEADSET_MUSIC_DELAY, 573 sysTime)) && 574 (delayMs < (int)desc->latency()*2)) { 575 delayMs = desc->latency()*2; 576 } 577 setStrategyMute(STRATEGY_MEDIA, true, desc); 578 setStrategyMute(STRATEGY_MEDIA, false, desc, MUTE_TIME_MS, 579 getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/)); 580 setStrategyMute(STRATEGY_SONIFICATION, true, desc); 581 setStrategyMute(STRATEGY_SONIFICATION, false, desc, MUTE_TIME_MS, 582 getDeviceForStrategy(STRATEGY_SONIFICATION, true /*fromCache*/)); 583 } 584 } 585 586 if (hasPrimaryOutput()) { 587 // Note that despite the fact that getNewOutputDevice() is called on the primary output, 588 // the device returned is not necessarily reachable via this output 589 audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/); 590 // force routing command to audio hardware when ending call 591 // even if no device change is needed 592 if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) { 593 rxDevice = mPrimaryOutput->device(); 594 } 595 596 if (state == AUDIO_MODE_IN_CALL) { 597 updateCallRouting(rxDevice, delayMs); 598 } else if (oldState == AUDIO_MODE_IN_CALL) { 599 if (mCallRxPatch != 0) { 600 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0); 601 mCallRxPatch.clear(); 602 } 603 if (mCallTxPatch != 0) { 604 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0); 605 mCallTxPatch.clear(); 606 } 607 setOutputDevice(mPrimaryOutput, rxDevice, force, 0); 608 } else { 609 setOutputDevice(mPrimaryOutput, rxDevice, force, 0); 610 } 611 } 612 // if entering in call state, handle special case of active streams 613 // pertaining to sonification strategy see handleIncallSonification() 614 if (isStateInCall(state)) { 615 ALOGV("setPhoneState() in call state management: new state is %d", state); 616 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) { 617 handleIncallSonification((audio_stream_type_t)stream, true, true); 618 } 619 620 // force reevaluating accessibility routing when call starts 621 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY); 622 } 623 624 // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE 625 if (state == AUDIO_MODE_RINGTONE && 626 isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) { 627 mLimitRingtoneVolume = true; 628 } else { 629 mLimitRingtoneVolume = false; 630 } 631} 632 633audio_mode_t AudioPolicyManager::getPhoneState() { 634 return mEngine->getPhoneState(); 635} 636 637void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage, 638 audio_policy_forced_cfg_t config) 639{ 640 ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState()); 641 if (config == mEngine->getForceUse(usage)) { 642 return; 643 } 644 645 if (mEngine->setForceUse(usage, config) != NO_ERROR) { 646 ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage); 647 return; 648 } 649 bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) || 650 (usage == AUDIO_POLICY_FORCE_FOR_DOCK) || 651 (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM); 652 653 // check for device and output changes triggered by new force usage 654 checkA2dpSuspend(); 655 checkOutputForAllStrategies(); 656 updateDevicesAndOutputs(); 657 658 //FIXME: workaround for truncated touch sounds 659 // to be removed when the problem is handled by system UI 660 uint32_t delayMs = 0; 661 uint32_t waitMs = 0; 662 if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) { 663 delayMs = TOUCH_SOUND_FIXED_DELAY_MS; 664 } 665 if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) { 666 audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, true /*fromCache*/); 667 waitMs = updateCallRouting(newDevice, delayMs); 668 } 669 for (size_t i = 0; i < mOutputs.size(); i++) { 670 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i); 671 audio_devices_t newDevice = getNewOutputDevice(outputDesc, true /*fromCache*/); 672 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) { 673 waitMs = setOutputDevice(outputDesc, newDevice, (newDevice != AUDIO_DEVICE_NONE), 674 delayMs); 675 } 676 if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) { 677 applyStreamVolumes(outputDesc, newDevice, waitMs, true); 678 } 679 } 680 681 Vector<sp <AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs(); 682 for (size_t i = 0; i < activeInputs.size(); i++) { 683 sp<AudioInputDescriptor> activeDesc = activeInputs[i]; 684 audio_devices_t newDevice = getNewInputDevice(activeDesc); 685 // Force new input selection if the new device can not be reached via current input 686 if (activeDesc->mProfile->getSupportedDevices().types() & 687 (newDevice & ~AUDIO_DEVICE_BIT_IN)) { 688 setInputDevice(activeDesc->mIoHandle, newDevice); 689 } else { 690 closeInput(activeDesc->mIoHandle); 691 } 692 } 693} 694 695void AudioPolicyManager::setSystemProperty(const char* property, const char* value) 696{ 697 ALOGV("setSystemProperty() property %s, value %s", property, value); 698} 699 700// Find a direct output profile compatible with the parameters passed, even if the input flags do 701// not explicitly request a direct output 702sp<IOProfile> AudioPolicyManager::getProfileForDirectOutput( 703 audio_devices_t device, 704 uint32_t samplingRate, 705 audio_format_t format, 706 audio_channel_mask_t channelMask, 707 audio_output_flags_t flags) 708{ 709 // only retain flags that will drive the direct output profile selection 710 // if explicitly requested 711 static const uint32_t kRelevantFlags = 712 (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD); 713 flags = 714 (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT); 715 716 sp<IOProfile> profile; 717 718 for (size_t i = 0; i < mHwModules.size(); i++) { 719 if (mHwModules[i]->mHandle == 0) { 720 continue; 721 } 722 for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++) { 723 sp<IOProfile> curProfile = mHwModules[i]->mOutputProfiles[j]; 724 if (!curProfile->isCompatibleProfile(device, String8(""), 725 samplingRate, NULL /*updatedSamplingRate*/, 726 format, NULL /*updatedFormat*/, 727 channelMask, NULL /*updatedChannelMask*/, 728 flags)) { 729 continue; 730 } 731 // reject profiles not corresponding to a device currently available 732 if ((mAvailableOutputDevices.types() & curProfile->getSupportedDevicesType()) == 0) { 733 continue; 734 } 735 // if several profiles are compatible, give priority to one with offload capability 736 if (profile != 0 && ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) { 737 continue; 738 } 739 profile = curProfile; 740 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) { 741 break; 742 } 743 } 744 } 745 return profile; 746} 747 748audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream, 749 uint32_t samplingRate, 750 audio_format_t format, 751 audio_channel_mask_t channelMask, 752 audio_output_flags_t flags, 753 const audio_offload_info_t *offloadInfo) 754{ 755 routing_strategy strategy = getStrategy(stream); 756 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/); 757 ALOGV("getOutput() device %d, stream %d, samplingRate %d, format %x, channelMask %x, flags %x", 758 device, stream, samplingRate, format, channelMask, flags); 759 760 return getOutputForDevice(device, AUDIO_SESSION_ALLOCATE, stream, samplingRate, format, 761 channelMask, flags, offloadInfo); 762} 763 764status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr, 765 audio_io_handle_t *output, 766 audio_session_t session, 767 audio_stream_type_t *stream, 768 uid_t uid, 769 const audio_config_t *config, 770 audio_output_flags_t flags, 771 audio_port_handle_t selectedDeviceId, 772 audio_port_handle_t *portId) 773{ 774 audio_attributes_t attributes; 775 if (attr != NULL) { 776 if (!isValidAttributes(attr)) { 777 ALOGE("getOutputForAttr() invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]", 778 attr->usage, attr->content_type, attr->flags, 779 attr->tags); 780 return BAD_VALUE; 781 } 782 attributes = *attr; 783 } else { 784 if (*stream < AUDIO_STREAM_MIN || *stream >= AUDIO_STREAM_PUBLIC_CNT) { 785 ALOGE("getOutputForAttr(): invalid stream type"); 786 return BAD_VALUE; 787 } 788 stream_type_to_audio_attributes(*stream, &attributes); 789 } 790 791 // TODO: check for existing client for this port ID 792 if (*portId == AUDIO_PORT_HANDLE_NONE) { 793 *portId = AudioPort::getNextUniqueId(); 794 } 795 796 sp<SwAudioOutputDescriptor> desc; 797 if (mPolicyMixes.getOutputForAttr(attributes, uid, desc) == NO_ERROR) { 798 ALOG_ASSERT(desc != 0, "Invalid desc returned by getOutputForAttr"); 799 if (!audio_has_proportional_frames(config->format)) { 800 return BAD_VALUE; 801 } 802 *stream = streamTypefromAttributesInt(&attributes); 803 *output = desc->mIoHandle; 804 ALOGV("getOutputForAttr() returns output %d", *output); 805 return NO_ERROR; 806 } 807 if (attributes.usage == AUDIO_USAGE_VIRTUAL_SOURCE) { 808 ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE"); 809 return BAD_VALUE; 810 } 811 812 ALOGV("getOutputForAttr() usage=%d, content=%d, tag=%s flags=%08x" 813 " session %d selectedDeviceId %d", 814 attributes.usage, attributes.content_type, attributes.tags, attributes.flags, 815 session, selectedDeviceId); 816 817 *stream = streamTypefromAttributesInt(&attributes); 818 819 // Explicit routing? 820 sp<DeviceDescriptor> deviceDesc; 821 for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) { 822 if (mAvailableOutputDevices[i]->getId() == selectedDeviceId) { 823 deviceDesc = mAvailableOutputDevices[i]; 824 break; 825 } 826 } 827 mOutputRoutes.addRoute(session, *stream, SessionRoute::SOURCE_TYPE_NA, deviceDesc, uid); 828 829 routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes); 830 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/); 831 832 if ((attributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) { 833 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC); 834 } 835 836 ALOGV("getOutputForAttr() device 0x%x, samplingRate %d, format %x, channelMask %x, flags %x", 837 device, config->sample_rate, config->format, config->channel_mask, flags); 838 839 *output = getOutputForDevice(device, session, *stream, 840 config->sample_rate, config->format, config->channel_mask, 841 flags, &config->offload_info); 842 if (*output == AUDIO_IO_HANDLE_NONE) { 843 mOutputRoutes.removeRoute(session); 844 return INVALID_OPERATION; 845 } 846 847 return NO_ERROR; 848} 849 850audio_io_handle_t AudioPolicyManager::getOutputForDevice( 851 audio_devices_t device, 852 audio_session_t session, 853 audio_stream_type_t stream, 854 uint32_t samplingRate, 855 audio_format_t format, 856 audio_channel_mask_t channelMask, 857 audio_output_flags_t flags, 858 const audio_offload_info_t *offloadInfo) 859{ 860 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE; 861 status_t status; 862 863#ifdef AUDIO_POLICY_TEST 864 if (mCurOutput != 0) { 865 ALOGV("getOutput() test output mCurOutput %d, samplingRate %d, format %d, channelMask %x, mDirectOutput %d", 866 mCurOutput, mTestSamplingRate, mTestFormat, mTestChannels, mDirectOutput); 867 868 if (mTestOutputs[mCurOutput] == 0) { 869 ALOGV("getOutput() opening test output"); 870 sp<AudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(NULL, 871 mpClientInterface); 872 outputDesc->mDevice = mTestDevice; 873 outputDesc->mLatency = mTestLatencyMs; 874 outputDesc->mFlags = 875 (audio_output_flags_t)(mDirectOutput ? AUDIO_OUTPUT_FLAG_DIRECT : 0); 876 outputDesc->mRefCount[stream] = 0; 877 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 878 config.sample_rate = mTestSamplingRate; 879 config.channel_mask = mTestChannels; 880 config.format = mTestFormat; 881 if (offloadInfo != NULL) { 882 config.offload_info = *offloadInfo; 883 } 884 status = mpClientInterface->openOutput(0, 885 &mTestOutputs[mCurOutput], 886 &config, 887 &outputDesc->mDevice, 888 String8(""), 889 &outputDesc->mLatency, 890 outputDesc->mFlags); 891 if (status == NO_ERROR) { 892 outputDesc->mSamplingRate = config.sample_rate; 893 outputDesc->mFormat = config.format; 894 outputDesc->mChannelMask = config.channel_mask; 895 AudioParameter outputCmd = AudioParameter(); 896 outputCmd.addInt(String8("set_id"),mCurOutput); 897 mpClientInterface->setParameters(mTestOutputs[mCurOutput],outputCmd.toString()); 898 addOutput(mTestOutputs[mCurOutput], outputDesc); 899 } 900 } 901 return mTestOutputs[mCurOutput]; 902 } 903#endif //AUDIO_POLICY_TEST 904 905 // open a direct output if required by specified parameters 906 //force direct flag if offload flag is set: offloading implies a direct output stream 907 // and all common behaviors are driven by checking only the direct flag 908 // this should normally be set appropriately in the policy configuration file 909 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) { 910 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT); 911 } 912 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) { 913 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT); 914 } 915 // only allow deep buffering for music stream type 916 if (stream != AUDIO_STREAM_MUSIC) { 917 flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER); 918 } else if (/* stream == AUDIO_STREAM_MUSIC && */ 919 flags == AUDIO_OUTPUT_FLAG_NONE && 920 property_get_bool("audio.deep_buffer.media", false /* default_value */)) { 921 // use DEEP_BUFFER as default output for music stream type 922 flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER; 923 } 924 if (stream == AUDIO_STREAM_TTS) { 925 flags = AUDIO_OUTPUT_FLAG_TTS; 926 } 927 928 sp<IOProfile> profile; 929 930 // skip direct output selection if the request can obviously be attached to a mixed output 931 // and not explicitly requested 932 if (((flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) && 933 audio_is_linear_pcm(format) && samplingRate <= SAMPLE_RATE_HZ_MAX && 934 audio_channel_count_from_out_mask(channelMask) <= 2) { 935 goto non_direct_output; 936 } 937 938 // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled. 939 // This prevents creating an offloaded track and tearing it down immediately after start 940 // when audioflinger detects there is an active non offloadable effect. 941 // FIXME: We should check the audio session here but we do not have it in this context. 942 // This may prevent offloading in rare situations where effects are left active by apps 943 // in the background. 944 945 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) || 946 !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) { 947 profile = getProfileForDirectOutput(device, 948 samplingRate, 949 format, 950 channelMask, 951 (audio_output_flags_t)flags); 952 } 953 954 if (profile != 0) { 955 sp<SwAudioOutputDescriptor> outputDesc = NULL; 956 957 for (size_t i = 0; i < mOutputs.size(); i++) { 958 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 959 if (!desc->isDuplicated() && (profile == desc->mProfile)) { 960 outputDesc = desc; 961 // reuse direct output if currently open by the same client 962 // and configured with same parameters 963 if ((samplingRate == outputDesc->mSamplingRate) && 964 audio_formats_match(format, outputDesc->mFormat) && 965 (channelMask == outputDesc->mChannelMask)) { 966 if (session == outputDesc->mDirectClientSession) { 967 outputDesc->mDirectOpenCount++; 968 ALOGV("getOutput() reusing direct output %d for session %d", 969 mOutputs.keyAt(i), session); 970 return mOutputs.keyAt(i); 971 } else { 972 ALOGV("getOutput() do not reuse direct output because current client (%d) " 973 "is not the same as requesting client (%d)", 974 outputDesc->mDirectClientSession, session); 975 goto non_direct_output; 976 } 977 } 978 } 979 } 980 // close direct output if currently open and configured with different parameters 981 if (outputDesc != NULL) { 982 closeOutput(outputDesc->mIoHandle); 983 } 984 985 // if the selected profile is offloaded and no offload info was specified, 986 // create a default one 987 audio_offload_info_t defaultOffloadInfo = AUDIO_INFO_INITIALIZER; 988 if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) && !offloadInfo) { 989 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD); 990 defaultOffloadInfo.sample_rate = samplingRate; 991 defaultOffloadInfo.channel_mask = channelMask; 992 defaultOffloadInfo.format = format; 993 defaultOffloadInfo.stream_type = stream; 994 defaultOffloadInfo.bit_rate = 0; 995 defaultOffloadInfo.duration_us = -1; 996 defaultOffloadInfo.has_video = true; // conservative 997 defaultOffloadInfo.is_streaming = true; // likely 998 offloadInfo = &defaultOffloadInfo; 999 } 1000 1001 outputDesc = new SwAudioOutputDescriptor(profile, mpClientInterface); 1002 outputDesc->mDevice = device; 1003 outputDesc->mLatency = 0; 1004 outputDesc->mFlags = (audio_output_flags_t)(outputDesc->mFlags | flags); 1005 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 1006 config.sample_rate = samplingRate; 1007 config.channel_mask = channelMask; 1008 config.format = format; 1009 if (offloadInfo != NULL) { 1010 config.offload_info = *offloadInfo; 1011 } 1012 DeviceVector outputDevices = mAvailableOutputDevices.getDevicesFromType(device); 1013 String8 address = outputDevices.size() > 0 ? outputDevices.itemAt(0)->mAddress 1014 : String8(""); 1015 status = mpClientInterface->openOutput(profile->getModuleHandle(), 1016 &output, 1017 &config, 1018 &outputDesc->mDevice, 1019 address, 1020 &outputDesc->mLatency, 1021 outputDesc->mFlags); 1022 1023 // only accept an output with the requested parameters 1024 if (status != NO_ERROR || 1025 (samplingRate != 0 && samplingRate != config.sample_rate) || 1026 (format != AUDIO_FORMAT_DEFAULT && !audio_formats_match(format, config.format)) || 1027 (channelMask != 0 && channelMask != config.channel_mask)) { 1028 ALOGV("getOutput() failed opening direct output: output %d samplingRate %d %d," 1029 "format %d %d, channelMask %04x %04x", output, samplingRate, 1030 outputDesc->mSamplingRate, format, outputDesc->mFormat, channelMask, 1031 outputDesc->mChannelMask); 1032 if (output != AUDIO_IO_HANDLE_NONE) { 1033 mpClientInterface->closeOutput(output); 1034 } 1035 // fall back to mixer output if possible when the direct output could not be open 1036 if (audio_is_linear_pcm(format) && samplingRate <= SAMPLE_RATE_HZ_MAX) { 1037 goto non_direct_output; 1038 } 1039 return AUDIO_IO_HANDLE_NONE; 1040 } 1041 outputDesc->mSamplingRate = config.sample_rate; 1042 outputDesc->mChannelMask = config.channel_mask; 1043 outputDesc->mFormat = config.format; 1044 outputDesc->mRefCount[stream] = 0; 1045 outputDesc->mStopTime[stream] = 0; 1046 outputDesc->mDirectOpenCount = 1; 1047 outputDesc->mDirectClientSession = session; 1048 1049 addOutput(output, outputDesc); 1050 mPreviousOutputs = mOutputs; 1051 ALOGV("getOutput() returns new direct output %d", output); 1052 mpClientInterface->onAudioPortListUpdate(); 1053 return output; 1054 } 1055 1056non_direct_output: 1057 1058 // A request for HW A/V sync cannot fallback to a mixed output because time 1059 // stamps are embedded in audio data 1060 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) { 1061 return AUDIO_IO_HANDLE_NONE; 1062 } 1063 1064 // ignoring channel mask due to downmix capability in mixer 1065 1066 // open a non direct output 1067 1068 // for non direct outputs, only PCM is supported 1069 if (audio_is_linear_pcm(format)) { 1070 // get which output is suitable for the specified stream. The actual 1071 // routing change will happen when startOutput() will be called 1072 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs); 1073 1074 // at this stage we should ignore the DIRECT flag as no direct output could be found earlier 1075 flags = (audio_output_flags_t)(flags & ~AUDIO_OUTPUT_FLAG_DIRECT); 1076 output = selectOutput(outputs, flags, format); 1077 } 1078 ALOGW_IF((output == 0), "getOutput() could not find output for stream %d, samplingRate %d," 1079 "format %d, channels %x, flags %x", stream, samplingRate, format, channelMask, flags); 1080 1081 ALOGV(" getOutputForDevice() returns output %d", output); 1082 1083 return output; 1084} 1085 1086audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs, 1087 audio_output_flags_t flags, 1088 audio_format_t format) 1089{ 1090 // select one output among several that provide a path to a particular device or set of 1091 // devices (the list was previously build by getOutputsForDevice()). 1092 // The priority is as follows: 1093 // 1: the output with the highest number of requested policy flags 1094 // 2: the output with the bit depth the closest to the requested one 1095 // 3: the primary output 1096 // 4: the first output in the list 1097 1098 if (outputs.size() == 0) { 1099 return 0; 1100 } 1101 if (outputs.size() == 1) { 1102 return outputs[0]; 1103 } 1104 1105 int maxCommonFlags = 0; 1106 audio_io_handle_t outputForFlags = 0; 1107 audio_io_handle_t outputForPrimary = 0; 1108 audio_io_handle_t outputForFormat = 0; 1109 audio_format_t bestFormat = AUDIO_FORMAT_INVALID; 1110 audio_format_t bestFormatForFlags = AUDIO_FORMAT_INVALID; 1111 1112 for (size_t i = 0; i < outputs.size(); i++) { 1113 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(outputs[i]); 1114 if (!outputDesc->isDuplicated()) { 1115 // if a valid format is specified, skip output if not compatible 1116 if (format != AUDIO_FORMAT_INVALID) { 1117 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) { 1118 if (!audio_formats_match(format, outputDesc->mFormat)) { 1119 continue; 1120 } 1121 } else if (!audio_is_linear_pcm(format)) { 1122 continue; 1123 } 1124 if (AudioPort::isBetterFormatMatch( 1125 outputDesc->mFormat, bestFormat, format)) { 1126 outputForFormat = outputs[i]; 1127 bestFormat = outputDesc->mFormat; 1128 } 1129 } 1130 1131 int commonFlags = popcount(outputDesc->mProfile->getFlags() & flags); 1132 if (commonFlags >= maxCommonFlags) { 1133 if (commonFlags == maxCommonFlags) { 1134 if (AudioPort::isBetterFormatMatch( 1135 outputDesc->mFormat, bestFormatForFlags, format)) { 1136 outputForFlags = outputs[i]; 1137 bestFormatForFlags = outputDesc->mFormat; 1138 } 1139 } else { 1140 outputForFlags = outputs[i]; 1141 maxCommonFlags = commonFlags; 1142 bestFormatForFlags = outputDesc->mFormat; 1143 } 1144 ALOGV("selectOutput() commonFlags for output %d, %04x", outputs[i], commonFlags); 1145 } 1146 if (outputDesc->mProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) { 1147 outputForPrimary = outputs[i]; 1148 } 1149 } 1150 } 1151 1152 if (outputForFlags != 0) { 1153 return outputForFlags; 1154 } 1155 if (outputForFormat != 0) { 1156 return outputForFormat; 1157 } 1158 if (outputForPrimary != 0) { 1159 return outputForPrimary; 1160 } 1161 1162 return outputs[0]; 1163} 1164 1165status_t AudioPolicyManager::startOutput(audio_io_handle_t output, 1166 audio_stream_type_t stream, 1167 audio_session_t session) 1168{ 1169 ALOGV("startOutput() output %d, stream %d, session %d", 1170 output, stream, session); 1171 ssize_t index = mOutputs.indexOfKey(output); 1172 if (index < 0) { 1173 ALOGW("startOutput() unknown output %d", output); 1174 return BAD_VALUE; 1175 } 1176 1177 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index); 1178 1179 // Routing? 1180 mOutputRoutes.incRouteActivity(session); 1181 1182 audio_devices_t newDevice; 1183 AudioMix *policyMix = NULL; 1184 const char *address = NULL; 1185 if (outputDesc->mPolicyMix != NULL) { 1186 policyMix = outputDesc->mPolicyMix; 1187 address = policyMix->mDeviceAddress.string(); 1188 if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) { 1189 newDevice = policyMix->mDeviceType; 1190 } else { 1191 newDevice = AUDIO_DEVICE_OUT_REMOTE_SUBMIX; 1192 } 1193 } else if (mOutputRoutes.hasRouteChanged(session)) { 1194 newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/); 1195 checkStrategyRoute(getStrategy(stream), output); 1196 } else { 1197 newDevice = AUDIO_DEVICE_NONE; 1198 } 1199 1200 uint32_t delayMs = 0; 1201 1202 status_t status = startSource(outputDesc, stream, newDevice, address, &delayMs); 1203 1204 if (status != NO_ERROR) { 1205 mOutputRoutes.decRouteActivity(session); 1206 return status; 1207 } 1208 // Automatically enable the remote submix input when output is started on a re routing mix 1209 // of type MIX_TYPE_RECORDERS 1210 if (audio_is_remote_submix_device(newDevice) && policyMix != NULL && 1211 policyMix->mMixType == MIX_TYPE_RECORDERS) { 1212 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX, 1213 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, 1214 address, 1215 "remote-submix"); 1216 } 1217 1218 if (delayMs != 0) { 1219 usleep(delayMs * 1000); 1220 } 1221 1222 return status; 1223} 1224 1225status_t AudioPolicyManager::startSource(const sp<AudioOutputDescriptor>& outputDesc, 1226 audio_stream_type_t stream, 1227 audio_devices_t device, 1228 const char *address, 1229 uint32_t *delayMs) 1230{ 1231 // cannot start playback of STREAM_TTS if any other output is being used 1232 uint32_t beaconMuteLatency = 0; 1233 1234 *delayMs = 0; 1235 if (stream == AUDIO_STREAM_TTS) { 1236 ALOGV("\t found BEACON stream"); 1237 if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(AUDIO_STREAM_TTS /*streamToIgnore*/)) { 1238 return INVALID_OPERATION; 1239 } else { 1240 beaconMuteLatency = handleEventForBeacon(STARTING_BEACON); 1241 } 1242 } else { 1243 // some playback other than beacon starts 1244 beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT); 1245 } 1246 1247 // force device change if the output is inactive and no audio patch is already present. 1248 // check active before incrementing usage count 1249 bool force = !outputDesc->isActive() && 1250 (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE); 1251 1252 // increment usage count for this stream on the requested output: 1253 // NOTE that the usage count is the same for duplicated output and hardware output which is 1254 // necessary for a correct control of hardware output routing by startOutput() and stopOutput() 1255 outputDesc->changeRefCount(stream, 1); 1256 1257 if (stream == AUDIO_STREAM_MUSIC) { 1258 selectOutputForMusicEffects(); 1259 } 1260 1261 if (outputDesc->mRefCount[stream] == 1 || device != AUDIO_DEVICE_NONE) { 1262 // starting an output being rerouted? 1263 if (device == AUDIO_DEVICE_NONE) { 1264 device = getNewOutputDevice(outputDesc, false /*fromCache*/); 1265 } 1266 1267 routing_strategy strategy = getStrategy(stream); 1268 bool shouldWait = (strategy == STRATEGY_SONIFICATION) || 1269 (strategy == STRATEGY_SONIFICATION_RESPECTFUL) || 1270 (beaconMuteLatency > 0); 1271 uint32_t waitMs = beaconMuteLatency; 1272 for (size_t i = 0; i < mOutputs.size(); i++) { 1273 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i); 1274 if (desc != outputDesc) { 1275 // force a device change if any other output is: 1276 // - managed by the same hw module 1277 // - has a current device selection that differs from selected device. 1278 // - supports currently selected device 1279 // - has an active audio patch 1280 // In this case, the audio HAL must receive the new device selection so that it can 1281 // change the device currently selected by the other active output. 1282 if (outputDesc->sharesHwModuleWith(desc) && 1283 desc->device() != device && 1284 desc->supportedDevices() & device && 1285 desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) { 1286 force = true; 1287 } 1288 // wait for audio on other active outputs to be presented when starting 1289 // a notification so that audio focus effect can propagate, or that a mute/unmute 1290 // event occurred for beacon 1291 uint32_t latency = desc->latency(); 1292 if (shouldWait && desc->isActive(latency * 2) && (waitMs < latency)) { 1293 waitMs = latency; 1294 } 1295 } 1296 } 1297 uint32_t muteWaitMs = setOutputDevice(outputDesc, device, force, 0, NULL, address); 1298 1299 // handle special case for sonification while in call 1300 if (isInCall()) { 1301 handleIncallSonification(stream, true, false); 1302 } 1303 1304 // apply volume rules for current stream and device if necessary 1305 checkAndSetVolume(stream, 1306 mVolumeCurves->getVolumeIndex(stream, device), 1307 outputDesc, 1308 device); 1309 1310 // update the outputs if starting an output with a stream that can affect notification 1311 // routing 1312 handleNotificationRoutingForStream(stream); 1313 1314 // force reevaluating accessibility routing when ringtone or alarm starts 1315 if (strategy == STRATEGY_SONIFICATION) { 1316 mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY); 1317 } 1318 1319 if (waitMs > muteWaitMs) { 1320 *delayMs = waitMs - muteWaitMs; 1321 } 1322 } 1323 1324 return NO_ERROR; 1325} 1326 1327 1328status_t AudioPolicyManager::stopOutput(audio_io_handle_t output, 1329 audio_stream_type_t stream, 1330 audio_session_t session) 1331{ 1332 ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session); 1333 ssize_t index = mOutputs.indexOfKey(output); 1334 if (index < 0) { 1335 ALOGW("stopOutput() unknown output %d", output); 1336 return BAD_VALUE; 1337 } 1338 1339 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index); 1340 1341 if (outputDesc->mRefCount[stream] == 1) { 1342 // Automatically disable the remote submix input when output is stopped on a 1343 // re routing mix of type MIX_TYPE_RECORDERS 1344 if (audio_is_remote_submix_device(outputDesc->mDevice) && 1345 outputDesc->mPolicyMix != NULL && 1346 outputDesc->mPolicyMix->mMixType == MIX_TYPE_RECORDERS) { 1347 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX, 1348 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 1349 outputDesc->mPolicyMix->mDeviceAddress, 1350 "remote-submix"); 1351 } 1352 } 1353 1354 // Routing? 1355 bool forceDeviceUpdate = false; 1356 if (outputDesc->mRefCount[stream] > 0) { 1357 int activityCount = mOutputRoutes.decRouteActivity(session); 1358 forceDeviceUpdate = (mOutputRoutes.hasRoute(session) && (activityCount == 0)); 1359 1360 if (forceDeviceUpdate) { 1361 checkStrategyRoute(getStrategy(stream), AUDIO_IO_HANDLE_NONE); 1362 } 1363 } 1364 1365 return stopSource(outputDesc, stream, forceDeviceUpdate); 1366} 1367 1368status_t AudioPolicyManager::stopSource(const sp<AudioOutputDescriptor>& outputDesc, 1369 audio_stream_type_t stream, 1370 bool forceDeviceUpdate) 1371{ 1372 // always handle stream stop, check which stream type is stopping 1373 handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT); 1374 1375 // handle special case for sonification while in call 1376 if (isInCall()) { 1377 handleIncallSonification(stream, false, false); 1378 } 1379 1380 if (outputDesc->mRefCount[stream] > 0) { 1381 // decrement usage count of this stream on the output 1382 outputDesc->changeRefCount(stream, -1); 1383 1384 // store time at which the stream was stopped - see isStreamActive() 1385 if (outputDesc->mRefCount[stream] == 0 || forceDeviceUpdate) { 1386 outputDesc->mStopTime[stream] = systemTime(); 1387 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/); 1388 // delay the device switch by twice the latency because stopOutput() is executed when 1389 // the track stop() command is received and at that time the audio track buffer can 1390 // still contain data that needs to be drained. The latency only covers the audio HAL 1391 // and kernel buffers. Also the latency does not always include additional delay in the 1392 // audio path (audio DSP, CODEC ...) 1393 setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2); 1394 1395 // force restoring the device selection on other active outputs if it differs from the 1396 // one being selected for this output 1397 uint32_t delayMs = outputDesc->latency()*2; 1398 for (size_t i = 0; i < mOutputs.size(); i++) { 1399 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i); 1400 if (desc != outputDesc && 1401 desc->isActive() && 1402 outputDesc->sharesHwModuleWith(desc) && 1403 (newDevice != desc->device())) { 1404 audio_devices_t newDevice2 = getNewOutputDevice(desc, false /*fromCache*/); 1405 bool force = desc->device() != newDevice2; 1406 setOutputDevice(desc, 1407 newDevice2, 1408 force, 1409 delayMs); 1410 // re-apply device specific volume if not done by setOutputDevice() 1411 if (!force) { 1412 applyStreamVolumes(desc, newDevice2, delayMs); 1413 } 1414 } 1415 } 1416 // update the outputs if stopping one with a stream that can affect notification routing 1417 handleNotificationRoutingForStream(stream); 1418 } 1419 if (stream == AUDIO_STREAM_MUSIC) { 1420 selectOutputForMusicEffects(); 1421 } 1422 return NO_ERROR; 1423 } else { 1424 ALOGW("stopOutput() refcount is already 0"); 1425 return INVALID_OPERATION; 1426 } 1427} 1428 1429void AudioPolicyManager::releaseOutput(audio_io_handle_t output, 1430 audio_stream_type_t stream __unused, 1431 audio_session_t session __unused) 1432{ 1433 ALOGV("releaseOutput() %d", output); 1434 ssize_t index = mOutputs.indexOfKey(output); 1435 if (index < 0) { 1436 ALOGW("releaseOutput() releasing unknown output %d", output); 1437 return; 1438 } 1439 1440#ifdef AUDIO_POLICY_TEST 1441 int testIndex = testOutputIndex(output); 1442 if (testIndex != 0) { 1443 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(index); 1444 if (outputDesc->isActive()) { 1445 mpClientInterface->closeOutput(output); 1446 removeOutput(output); 1447 mTestOutputs[testIndex] = 0; 1448 } 1449 return; 1450 } 1451#endif //AUDIO_POLICY_TEST 1452 1453 // Routing 1454 mOutputRoutes.removeRoute(session); 1455 1456 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(index); 1457 if (desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) { 1458 if (desc->mDirectOpenCount <= 0) { 1459 ALOGW("releaseOutput() invalid open count %d for output %d", 1460 desc->mDirectOpenCount, output); 1461 return; 1462 } 1463 if (--desc->mDirectOpenCount == 0) { 1464 closeOutput(output); 1465 mpClientInterface->onAudioPortListUpdate(); 1466 } 1467 } 1468} 1469 1470 1471status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr, 1472 audio_io_handle_t *input, 1473 audio_session_t session, 1474 uid_t uid, 1475 const audio_config_base_t *config, 1476 audio_input_flags_t flags, 1477 audio_port_handle_t selectedDeviceId, 1478 input_type_t *inputType, 1479 audio_port_handle_t *portId) 1480{ 1481 ALOGV("getInputForAttr() source %d, samplingRate %d, format %d, channelMask %x," 1482 "session %d, flags %#x", 1483 attr->source, config->sample_rate, config->format, config->channel_mask, session, flags); 1484 1485 *input = AUDIO_IO_HANDLE_NONE; 1486 *inputType = API_INPUT_INVALID; 1487 1488 audio_devices_t device; 1489 // handle legacy remote submix case where the address was not always specified 1490 String8 address = String8(""); 1491 audio_source_t inputSource = attr->source; 1492 audio_source_t halInputSource; 1493 AudioMix *policyMix = NULL; 1494 1495 if (inputSource == AUDIO_SOURCE_DEFAULT) { 1496 inputSource = AUDIO_SOURCE_MIC; 1497 } 1498 halInputSource = inputSource; 1499 1500 // TODO: check for existing client for this port ID 1501 if (*portId == AUDIO_PORT_HANDLE_NONE) { 1502 *portId = AudioPort::getNextUniqueId(); 1503 } 1504 1505 // Explicit routing? 1506 sp<DeviceDescriptor> deviceDesc; 1507 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) { 1508 if (mAvailableInputDevices[i]->getId() == selectedDeviceId) { 1509 deviceDesc = mAvailableInputDevices[i]; 1510 break; 1511 } 1512 } 1513 mInputRoutes.addRoute(session, SessionRoute::STREAM_TYPE_NA, inputSource, deviceDesc, uid); 1514 1515 if (inputSource == AUDIO_SOURCE_REMOTE_SUBMIX && 1516 strncmp(attr->tags, "addr=", strlen("addr=")) == 0) { 1517 status_t ret = mPolicyMixes.getInputMixForAttr(*attr, &policyMix); 1518 if (ret != NO_ERROR) { 1519 return ret; 1520 } 1521 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE; 1522 device = AUDIO_DEVICE_IN_REMOTE_SUBMIX; 1523 address = String8(attr->tags + strlen("addr=")); 1524 } else { 1525 device = getDeviceAndMixForInputSource(inputSource, &policyMix); 1526 if (device == AUDIO_DEVICE_NONE) { 1527 ALOGW("getInputForAttr() could not find device for source %d", inputSource); 1528 return BAD_VALUE; 1529 } 1530 if (policyMix != NULL) { 1531 address = policyMix->mDeviceAddress; 1532 if (policyMix->mMixType == MIX_TYPE_RECORDERS) { 1533 // there is an external policy, but this input is attached to a mix of recorders, 1534 // meaning it receives audio injected into the framework, so the recorder doesn't 1535 // know about it and is therefore considered "legacy" 1536 *inputType = API_INPUT_LEGACY; 1537 } else { 1538 // recording a mix of players defined by an external policy, we're rerouting for 1539 // an external policy 1540 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE; 1541 } 1542 } else if (audio_is_remote_submix_device(device)) { 1543 address = String8("0"); 1544 *inputType = API_INPUT_MIX_CAPTURE; 1545 } else if (device == AUDIO_DEVICE_IN_TELEPHONY_RX) { 1546 *inputType = API_INPUT_TELEPHONY_RX; 1547 } else { 1548 *inputType = API_INPUT_LEGACY; 1549 } 1550 1551 } 1552 1553 *input = getInputForDevice(device, address, session, uid, inputSource, 1554 config->sample_rate, config->format, config->channel_mask, flags, 1555 policyMix); 1556 if (*input == AUDIO_IO_HANDLE_NONE) { 1557 mInputRoutes.removeRoute(session); 1558 return INVALID_OPERATION; 1559 } 1560 1561 ALOGV("getInputForAttr() returns input type = %d", *inputType); 1562 return NO_ERROR; 1563} 1564 1565 1566audio_io_handle_t AudioPolicyManager::getInputForDevice(audio_devices_t device, 1567 String8 address, 1568 audio_session_t session, 1569 uid_t uid, 1570 audio_source_t inputSource, 1571 uint32_t samplingRate, 1572 audio_format_t format, 1573 audio_channel_mask_t channelMask, 1574 audio_input_flags_t flags, 1575 AudioMix *policyMix) 1576{ 1577 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE; 1578 audio_source_t halInputSource = inputSource; 1579 bool isSoundTrigger = false; 1580 1581 if (inputSource == AUDIO_SOURCE_HOTWORD) { 1582 ssize_t index = mSoundTriggerSessions.indexOfKey(session); 1583 if (index >= 0) { 1584 input = mSoundTriggerSessions.valueFor(session); 1585 isSoundTrigger = true; 1586 flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD); 1587 ALOGV("SoundTrigger capture on session %d input %d", session, input); 1588 } else { 1589 halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION; 1590 } 1591 } 1592 1593 // find a compatible input profile (not necessarily identical in parameters) 1594 sp<IOProfile> profile; 1595 // samplingRate and flags may be updated by getInputProfile 1596 uint32_t profileSamplingRate = (samplingRate == 0) ? SAMPLE_RATE_HZ_DEFAULT : samplingRate; 1597 audio_format_t profileFormat = format; 1598 audio_channel_mask_t profileChannelMask = channelMask; 1599 audio_input_flags_t profileFlags = flags; 1600 for (;;) { 1601 profile = getInputProfile(device, address, 1602 profileSamplingRate, profileFormat, profileChannelMask, 1603 profileFlags); 1604 if (profile != 0) { 1605 break; // success 1606 } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) { 1607 profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry 1608 } else if (profileFlags != AUDIO_INPUT_FLAG_NONE) { 1609 profileFlags = AUDIO_INPUT_FLAG_NONE; // retry 1610 } else { // fail 1611 ALOGW("getInputForDevice() could not find profile for device 0x%X," 1612 "samplingRate %u, format %#x, channelMask 0x%X, flags %#x", 1613 device, samplingRate, format, channelMask, flags); 1614 return input; 1615 } 1616 } 1617 // Pick input sampling rate if not specified by client 1618 if (samplingRate == 0) { 1619 samplingRate = profileSamplingRate; 1620 } 1621 1622 if (profile->getModuleHandle() == 0) { 1623 ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName()); 1624 return input; 1625 } 1626 1627 sp<AudioSession> audioSession = new AudioSession(session, 1628 inputSource, 1629 format, 1630 samplingRate, 1631 channelMask, 1632 flags, 1633 uid, 1634 isSoundTrigger, 1635 policyMix, mpClientInterface); 1636 1637// FIXME: disable concurrent capture until UI is ready 1638#if 0 1639 // reuse an open input if possible 1640 sp<AudioInputDescriptor> reusedInputDesc; 1641 for (size_t i = 0; i < mInputs.size(); i++) { 1642 sp<AudioInputDescriptor> desc = mInputs.valueAt(i); 1643 // reuse input if: 1644 // - it shares the same profile 1645 // AND 1646 // - it is not a reroute submix input 1647 // AND 1648 // - it is: not used for sound trigger 1649 // OR 1650 // used for sound trigger and all clients use the same session ID 1651 // 1652 if ((profile == desc->mProfile) && 1653 (isSoundTrigger == desc->isSoundTrigger()) && 1654 !is_virtual_input_device(device)) { 1655 1656 sp<AudioSession> as = desc->getAudioSession(session); 1657 if (as != 0) { 1658 // do not allow unmatching properties on same session 1659 if (as->matches(audioSession)) { 1660 as->changeOpenCount(1); 1661 } else { 1662 ALOGW("getInputForDevice() record with different attributes" 1663 " exists for session %d", session); 1664 continue; 1665 } 1666 } else if (isSoundTrigger) { 1667 continue; 1668 } 1669 1670 // Reuse the already opened input stream on this profile if: 1671 // - the new capture source is background OR 1672 // - the path requested configurations match OR 1673 // - the new source priority is less than the highest source priority on this input 1674 // If the input stream cannot be reused, close it before opening a new stream 1675 // on the same profile for the new client so that the requested path configuration 1676 // can be selected. 1677 if (!isConcurrentSource(inputSource) && 1678 ((desc->mSamplingRate != samplingRate || 1679 desc->mChannelMask != channelMask || 1680 !audio_formats_match(desc->mFormat, format)) && 1681 (source_priority(desc->getHighestPrioritySource(false /*activeOnly*/)) < 1682 source_priority(inputSource)))) { 1683 reusedInputDesc = desc; 1684 continue; 1685 } else { 1686 desc->addAudioSession(session, audioSession); 1687 ALOGV("%s: reusing input %d", __FUNCTION__, mInputs.keyAt(i)); 1688 return mInputs.keyAt(i); 1689 } 1690 } 1691 } 1692 1693 if (reusedInputDesc != 0) { 1694 AudioSessionCollection sessions = reusedInputDesc->getAudioSessions(false /*activeOnly*/); 1695 for (size_t j = 0; j < sessions.size(); j++) { 1696 audio_session_t currentSession = sessions.keyAt(j); 1697 stopInput(reusedInputDesc->mIoHandle, currentSession); 1698 releaseInput(reusedInputDesc->mIoHandle, currentSession); 1699 } 1700 } 1701#endif 1702 1703 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 1704 config.sample_rate = profileSamplingRate; 1705 config.channel_mask = profileChannelMask; 1706 config.format = profileFormat; 1707 1708 if (address == "") { 1709 DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(device); 1710 // the inputs vector must be of size 1, but we don't want to crash here 1711 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress : String8(""); 1712 } 1713 1714 status_t status = mpClientInterface->openInput(profile->getModuleHandle(), 1715 &input, 1716 &config, 1717 &device, 1718 address, 1719 halInputSource, 1720 profileFlags); 1721 1722 // only accept input with the exact requested set of parameters 1723 if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE || 1724 (profileSamplingRate != config.sample_rate) || 1725 !audio_formats_match(profileFormat, config.format) || 1726 (profileChannelMask != config.channel_mask)) { 1727 ALOGW("getInputForAttr() failed opening input: samplingRate %d" 1728 ", format %d, channelMask %x", 1729 samplingRate, format, channelMask); 1730 if (input != AUDIO_IO_HANDLE_NONE) { 1731 mpClientInterface->closeInput(input); 1732 } 1733 return AUDIO_IO_HANDLE_NONE; 1734 } 1735 1736 sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile); 1737 inputDesc->mSamplingRate = profileSamplingRate; 1738 inputDesc->mFormat = profileFormat; 1739 inputDesc->mChannelMask = profileChannelMask; 1740 inputDesc->mDevice = device; 1741 inputDesc->mPolicyMix = policyMix; 1742 inputDesc->addAudioSession(session, audioSession); 1743 1744 addInput(input, inputDesc); 1745 mpClientInterface->onAudioPortListUpdate(); 1746 1747 return input; 1748} 1749 1750//static 1751bool AudioPolicyManager::isConcurrentSource(audio_source_t source) 1752{ 1753 return (source == AUDIO_SOURCE_HOTWORD) || 1754 (source == AUDIO_SOURCE_VOICE_RECOGNITION) || 1755 (source == AUDIO_SOURCE_FM_TUNER); 1756} 1757 1758bool AudioPolicyManager::isConcurentCaptureAllowed(const sp<AudioInputDescriptor>& inputDesc, 1759 const sp<AudioSession>& audioSession) 1760{ 1761 // Do not allow capture if an active voice call is using a software patch and 1762 // the call TX source device is on the same HW module. 1763 // FIXME: would be better to refine to only inputs whose profile connects to the 1764 // call TX device but this information is not in the audio patch 1765 if (mCallTxPatch != 0 && 1766 inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) { 1767 return false; 1768 } 1769 1770 // starting concurrent capture is enabled if: 1771 // 1) capturing for re-routing 1772 // 2) capturing for HOTWORD source 1773 // 3) capturing for FM TUNER source 1774 // 3) All other active captures are either for re-routing or HOTWORD 1775 1776 if (is_virtual_input_device(inputDesc->mDevice) || 1777 isConcurrentSource(audioSession->inputSource())) { 1778 return true; 1779 } 1780 1781 Vector< sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs(); 1782 for (size_t i = 0; i < activeInputs.size(); i++) { 1783 sp<AudioInputDescriptor> activeInput = activeInputs[i]; 1784 if (!isConcurrentSource(activeInput->inputSource(true)) && 1785 !is_virtual_input_device(activeInput->mDevice)) { 1786 return false; 1787 } 1788 } 1789 1790 return true; 1791} 1792 1793 1794status_t AudioPolicyManager::startInput(audio_io_handle_t input, 1795 audio_session_t session, 1796 concurrency_type__mask_t *concurrency) 1797{ 1798 ALOGV("startInput() input %d", input); 1799 *concurrency = API_INPUT_CONCURRENCY_NONE; 1800 ssize_t index = mInputs.indexOfKey(input); 1801 if (index < 0) { 1802 ALOGW("startInput() unknown input %d", input); 1803 return BAD_VALUE; 1804 } 1805 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index); 1806 1807 sp<AudioSession> audioSession = inputDesc->getAudioSession(session); 1808 if (audioSession == 0) { 1809 ALOGW("startInput() unknown session %d on input %d", session, input); 1810 return BAD_VALUE; 1811 } 1812 1813// FIXME: disable concurrent capture until UI is ready 1814#if 0 1815 if (!isConcurentCaptureAllowed(inputDesc, audioSession)) { 1816 ALOGW("startInput(%d) failed: other input already started", input); 1817 return INVALID_OPERATION; 1818 } 1819 1820 if (isInCall()) { 1821 *concurrency |= API_INPUT_CONCURRENCY_CALL; 1822 } 1823 if (mInputs.activeInputsCountOnDevices() != 0) { 1824 *concurrency |= API_INPUT_CONCURRENCY_CAPTURE; 1825 } 1826#else 1827 if (!is_virtual_input_device(inputDesc->mDevice)) { 1828 if (mCallTxPatch != 0 && 1829 inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) { 1830 ALOGW("startInput(%d) failed: call in progress", input); 1831 return INVALID_OPERATION; 1832 } 1833 1834 Vector< sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs(); 1835 for (size_t i = 0; i < activeInputs.size(); i++) { 1836 sp<AudioInputDescriptor> activeDesc = activeInputs[i]; 1837 1838 if (is_virtual_input_device(activeDesc->mDevice)) { 1839 continue; 1840 } 1841 1842 audio_source_t activeSource = activeDesc->inputSource(true); 1843 if (audioSession->inputSource() == AUDIO_SOURCE_HOTWORD) { 1844 if (activeSource == AUDIO_SOURCE_HOTWORD) { 1845 if (activeDesc->hasPreemptedSession(session)) { 1846 ALOGW("startInput(%d) failed for HOTWORD: " 1847 "other input %d already started for HOTWORD", 1848 input, activeDesc->mIoHandle); 1849 return INVALID_OPERATION; 1850 } 1851 } else { 1852 ALOGV("startInput(%d) failed for HOTWORD: other input %d already started", 1853 input, activeDesc->mIoHandle); 1854 return INVALID_OPERATION; 1855 } 1856 } else { 1857 if (activeSource != AUDIO_SOURCE_HOTWORD) { 1858 ALOGW("startInput(%d) failed: other input %d already started", 1859 input, activeDesc->mIoHandle); 1860 return INVALID_OPERATION; 1861 } 1862 } 1863 } 1864 1865 // if capture is allowed, preempt currently active HOTWORD captures 1866 for (size_t i = 0; i < activeInputs.size(); i++) { 1867 sp<AudioInputDescriptor> activeDesc = activeInputs[i]; 1868 1869 if (is_virtual_input_device(activeDesc->mDevice)) { 1870 continue; 1871 } 1872 1873 audio_source_t activeSource = activeDesc->inputSource(true); 1874 if (activeSource == AUDIO_SOURCE_HOTWORD) { 1875 AudioSessionCollection activeSessions = 1876 activeDesc->getAudioSessions(true /*activeOnly*/); 1877 audio_session_t activeSession = activeSessions.keyAt(0); 1878 audio_io_handle_t activeHandle = activeDesc->mIoHandle; 1879 SortedVector<audio_session_t> sessions = activeDesc->getPreemptedSessions(); 1880 sessions.add(activeSession); 1881 inputDesc->setPreemptedSessions(sessions); 1882 stopInput(activeHandle, activeSession); 1883 releaseInput(activeHandle, activeSession); 1884 ALOGV("startInput(%d) for HOTWORD preempting HOTWORD input %d", 1885 input, activeDesc->mIoHandle); 1886 } 1887 } 1888 } 1889#endif 1890 1891 // increment activity count before calling getNewInputDevice() below as only active sessions 1892 // are considered for device selection 1893 audioSession->changeActiveCount(1); 1894 1895 // Routing? 1896 mInputRoutes.incRouteActivity(session); 1897 1898 if (audioSession->activeCount() == 1 || mInputRoutes.hasRouteChanged(session)) { 1899 // indicate active capture to sound trigger service if starting capture from a mic on 1900 // primary HW module 1901 audio_devices_t device = getNewInputDevice(inputDesc); 1902 setInputDevice(input, device, true /* force */); 1903 1904 if (inputDesc->getAudioSessionCount(true/*activeOnly*/) == 1) { 1905 // if input maps to a dynamic policy with an activity listener, notify of state change 1906 if ((inputDesc->mPolicyMix != NULL) 1907 && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) { 1908 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress, 1909 MIX_STATE_MIXING); 1910 } 1911 1912 audio_devices_t primaryInputDevices = availablePrimaryInputDevices(); 1913 if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) && 1914 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) { 1915 SoundTrigger::setCaptureState(true); 1916 } 1917 1918 // automatically enable the remote submix output when input is started if not 1919 // used by a policy mix of type MIX_TYPE_RECORDERS 1920 // For remote submix (a virtual device), we open only one input per capture request. 1921 if (audio_is_remote_submix_device(inputDesc->mDevice)) { 1922 String8 address = String8(""); 1923 if (inputDesc->mPolicyMix == NULL) { 1924 address = String8("0"); 1925 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) { 1926 address = inputDesc->mPolicyMix->mDeviceAddress; 1927 } 1928 if (address != "") { 1929 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, 1930 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, 1931 address, "remote-submix"); 1932 } 1933 } 1934 } 1935 } 1936 1937 ALOGV("AudioPolicyManager::startInput() input source = %d", audioSession->inputSource()); 1938 1939 return NO_ERROR; 1940} 1941 1942status_t AudioPolicyManager::stopInput(audio_io_handle_t input, 1943 audio_session_t session) 1944{ 1945 ALOGV("stopInput() input %d", input); 1946 ssize_t index = mInputs.indexOfKey(input); 1947 if (index < 0) { 1948 ALOGW("stopInput() unknown input %d", input); 1949 return BAD_VALUE; 1950 } 1951 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index); 1952 1953 sp<AudioSession> audioSession = inputDesc->getAudioSession(session); 1954 if (index < 0) { 1955 ALOGW("stopInput() unknown session %d on input %d", session, input); 1956 return BAD_VALUE; 1957 } 1958 1959 if (audioSession->activeCount() == 0) { 1960 ALOGW("stopInput() input %d already stopped", input); 1961 return INVALID_OPERATION; 1962 } 1963 1964 audioSession->changeActiveCount(-1); 1965 1966 // Routing? 1967 mInputRoutes.decRouteActivity(session); 1968 1969 if (audioSession->activeCount() == 0) { 1970 1971 if (inputDesc->isActive()) { 1972 setInputDevice(input, getNewInputDevice(inputDesc), false /* force */); 1973 } else { 1974 // if input maps to a dynamic policy with an activity listener, notify of state change 1975 if ((inputDesc->mPolicyMix != NULL) 1976 && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) { 1977 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress, 1978 MIX_STATE_IDLE); 1979 } 1980 1981 // automatically disable the remote submix output when input is stopped if not 1982 // used by a policy mix of type MIX_TYPE_RECORDERS 1983 if (audio_is_remote_submix_device(inputDesc->mDevice)) { 1984 String8 address = String8(""); 1985 if (inputDesc->mPolicyMix == NULL) { 1986 address = String8("0"); 1987 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) { 1988 address = inputDesc->mPolicyMix->mDeviceAddress; 1989 } 1990 if (address != "") { 1991 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, 1992 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 1993 address, "remote-submix"); 1994 } 1995 } 1996 1997 audio_devices_t device = inputDesc->mDevice; 1998 resetInputDevice(input); 1999 2000 // indicate inactive capture to sound trigger service if stopping capture from a mic on 2001 // primary HW module 2002 audio_devices_t primaryInputDevices = availablePrimaryInputDevices(); 2003 if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) && 2004 mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) { 2005 SoundTrigger::setCaptureState(false); 2006 } 2007 inputDesc->clearPreemptedSessions(); 2008 } 2009 } 2010 return NO_ERROR; 2011} 2012 2013void AudioPolicyManager::releaseInput(audio_io_handle_t input, 2014 audio_session_t session) 2015{ 2016 2017 ALOGV("releaseInput() %d", input); 2018 ssize_t index = mInputs.indexOfKey(input); 2019 if (index < 0) { 2020 ALOGW("releaseInput() releasing unknown input %d", input); 2021 return; 2022 } 2023 2024 // Routing 2025 mInputRoutes.removeRoute(session); 2026 2027 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index); 2028 ALOG_ASSERT(inputDesc != 0); 2029 2030 sp<AudioSession> audioSession = inputDesc->getAudioSession(session); 2031 if (audioSession == 0) { 2032 ALOGW("releaseInput() unknown session %d on input %d", session, input); 2033 return; 2034 } 2035 2036 if (audioSession->openCount() == 0) { 2037 ALOGW("releaseInput() invalid open count %d on session %d", 2038 audioSession->openCount(), session); 2039 return; 2040 } 2041 2042 if (audioSession->changeOpenCount(-1) == 0) { 2043 inputDesc->removeAudioSession(session); 2044 } 2045 2046 if (inputDesc->getOpenRefCount() > 0) { 2047 ALOGV("releaseInput() exit > 0"); 2048 return; 2049 } 2050 2051 closeInput(input); 2052 mpClientInterface->onAudioPortListUpdate(); 2053 ALOGV("releaseInput() exit"); 2054} 2055 2056void AudioPolicyManager::closeAllInputs() { 2057 bool patchRemoved = false; 2058 2059 for(size_t input_index = 0; input_index < mInputs.size(); input_index++) { 2060 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(input_index); 2061 ssize_t patch_index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle()); 2062 if (patch_index >= 0) { 2063 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(patch_index); 2064 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 2065 mAudioPatches.removeItemsAt(patch_index); 2066 patchRemoved = true; 2067 } 2068 mpClientInterface->closeInput(mInputs.keyAt(input_index)); 2069 } 2070 mInputs.clear(); 2071 SoundTrigger::setCaptureState(false); 2072 nextAudioPortGeneration(); 2073 2074 if (patchRemoved) { 2075 mpClientInterface->onAudioPatchListUpdate(); 2076 } 2077} 2078 2079void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream, 2080 int indexMin, 2081 int indexMax) 2082{ 2083 ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax); 2084 mVolumeCurves->initStreamVolume(stream, indexMin, indexMax); 2085 2086 // initialize other private stream volumes which follow this one 2087 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) { 2088 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) { 2089 continue; 2090 } 2091 mVolumeCurves->initStreamVolume((audio_stream_type_t)curStream, indexMin, indexMax); 2092 } 2093} 2094 2095status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream, 2096 int index, 2097 audio_devices_t device) 2098{ 2099 2100 if ((index < mVolumeCurves->getVolumeIndexMin(stream)) || 2101 (index > mVolumeCurves->getVolumeIndexMax(stream))) { 2102 return BAD_VALUE; 2103 } 2104 if (!audio_is_output_device(device)) { 2105 return BAD_VALUE; 2106 } 2107 2108 // Force max volume if stream cannot be muted 2109 if (!mVolumeCurves->canBeMuted(stream)) index = mVolumeCurves->getVolumeIndexMax(stream); 2110 2111 ALOGV("setStreamVolumeIndex() stream %d, device %08x, index %d", 2112 stream, device, index); 2113 2114 // update other private stream volumes which follow this one 2115 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) { 2116 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) { 2117 continue; 2118 } 2119 mVolumeCurves->addCurrentVolumeIndex((audio_stream_type_t)curStream, device, index); 2120 } 2121 2122 // update volume on all outputs and streams matching the following: 2123 // - The requested stream (or a stream matching for volume control) is active on the output 2124 // - The device (or devices) selected by the strategy corresponding to this stream includes 2125 // the requested device 2126 // - For non default requested device, currently selected device on the output is either the 2127 // requested device or one of the devices selected by the strategy 2128 // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if 2129 // no specific device volume value exists for currently selected device. 2130 status_t status = NO_ERROR; 2131 for (size_t i = 0; i < mOutputs.size(); i++) { 2132 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 2133 audio_devices_t curDevice = Volume::getDeviceForVolume(desc->device()); 2134 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) { 2135 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) { 2136 continue; 2137 } 2138 if (!(desc->isStreamActive((audio_stream_type_t)curStream) || 2139 (isInCall() && (curStream == AUDIO_STREAM_VOICE_CALL)))) { 2140 continue; 2141 } 2142 routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream); 2143 audio_devices_t curStreamDevice = getDeviceForStrategy(curStrategy, false /*fromCache*/); 2144 if ((device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) && 2145 ((curStreamDevice & device) == 0)) { 2146 continue; 2147 } 2148 bool applyVolume; 2149 if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) { 2150 curStreamDevice |= device; 2151 applyVolume = (curDevice & curStreamDevice) != 0; 2152 } else { 2153 applyVolume = !mVolumeCurves->hasVolumeIndexForDevice( 2154 stream, Volume::getDeviceForVolume(curStreamDevice)); 2155 } 2156 2157 if (applyVolume) { 2158 //FIXME: workaround for truncated touch sounds 2159 // delayed volume change for system stream to be removed when the problem is 2160 // handled by system UI 2161 status_t volStatus = 2162 checkAndSetVolume((audio_stream_type_t)curStream, index, desc, curDevice, 2163 (stream == AUDIO_STREAM_SYSTEM) ? TOUCH_SOUND_FIXED_DELAY_MS : 0); 2164 if (volStatus != NO_ERROR) { 2165 status = volStatus; 2166 } 2167 } 2168 } 2169 } 2170 return status; 2171} 2172 2173status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream, 2174 int *index, 2175 audio_devices_t device) 2176{ 2177 if (index == NULL) { 2178 return BAD_VALUE; 2179 } 2180 if (!audio_is_output_device(device)) { 2181 return BAD_VALUE; 2182 } 2183 // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device corresponding to 2184 // the strategy the stream belongs to. 2185 if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) { 2186 device = getDeviceForStrategy(getStrategy(stream), true /*fromCache*/); 2187 } 2188 device = Volume::getDeviceForVolume(device); 2189 2190 *index = mVolumeCurves->getVolumeIndex(stream, device); 2191 ALOGV("getStreamVolumeIndex() stream %d device %08x index %d", stream, device, *index); 2192 return NO_ERROR; 2193} 2194 2195audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects() 2196{ 2197 // select one output among several suitable for global effects. 2198 // The priority is as follows: 2199 // 1: An offloaded output. If the effect ends up not being offloadable, 2200 // AudioFlinger will invalidate the track and the offloaded output 2201 // will be closed causing the effect to be moved to a PCM output. 2202 // 2: A deep buffer output 2203 // 3: The primary output 2204 // 4: the first output in the list 2205 2206 routing_strategy strategy = getStrategy(AUDIO_STREAM_MUSIC); 2207 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/); 2208 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs); 2209 2210 if (outputs.size() == 0) { 2211 return AUDIO_IO_HANDLE_NONE; 2212 } 2213 2214 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE; 2215 bool activeOnly = true; 2216 2217 while (output == AUDIO_IO_HANDLE_NONE) { 2218 audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE; 2219 audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE; 2220 audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE; 2221 2222 for (size_t i = 0; i < outputs.size(); i++) { 2223 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]); 2224 if (activeOnly && !desc->isStreamActive(AUDIO_STREAM_MUSIC)) { 2225 continue; 2226 } 2227 ALOGV("selectOutputForMusicEffects activeOnly %d outputs[%zu] flags 0x%08x", 2228 activeOnly, i, desc->mFlags); 2229 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) { 2230 outputOffloaded = outputs[i]; 2231 } 2232 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) { 2233 outputDeepBuffer = outputs[i]; 2234 } 2235 if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) { 2236 outputPrimary = outputs[i]; 2237 } 2238 } 2239 if (outputOffloaded != AUDIO_IO_HANDLE_NONE) { 2240 output = outputOffloaded; 2241 } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) { 2242 output = outputDeepBuffer; 2243 } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) { 2244 output = outputPrimary; 2245 } else { 2246 output = outputs[0]; 2247 } 2248 activeOnly = false; 2249 } 2250 2251 if (output != mMusicEffectOutput) { 2252 mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output); 2253 mMusicEffectOutput = output; 2254 } 2255 2256 ALOGV("selectOutputForMusicEffects selected output %d", output); 2257 return output; 2258} 2259 2260audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused) 2261{ 2262 return selectOutputForMusicEffects(); 2263} 2264 2265status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc, 2266 audio_io_handle_t io, 2267 uint32_t strategy, 2268 int session, 2269 int id) 2270{ 2271 ssize_t index = mOutputs.indexOfKey(io); 2272 if (index < 0) { 2273 index = mInputs.indexOfKey(io); 2274 if (index < 0) { 2275 ALOGW("registerEffect() unknown io %d", io); 2276 return INVALID_OPERATION; 2277 } 2278 } 2279 return mEffects.registerEffect(desc, io, strategy, session, id); 2280} 2281 2282bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 2283{ 2284 bool active = false; 2285 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT && !active; curStream++) { 2286 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) { 2287 continue; 2288 } 2289 active = mOutputs.isStreamActive((audio_stream_type_t)curStream, inPastMs); 2290 } 2291 return active; 2292} 2293 2294bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 2295{ 2296 return mOutputs.isStreamActiveRemotely(stream, inPastMs); 2297} 2298 2299bool AudioPolicyManager::isSourceActive(audio_source_t source) const 2300{ 2301 for (size_t i = 0; i < mInputs.size(); i++) { 2302 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i); 2303 if (inputDescriptor->isSourceActive(source)) { 2304 return true; 2305 } 2306 } 2307 return false; 2308} 2309 2310// Register a list of custom mixes with their attributes and format. 2311// When a mix is registered, corresponding input and output profiles are 2312// added to the remote submix hw module. The profile contains only the 2313// parameters (sampling rate, format...) specified by the mix. 2314// The corresponding input remote submix device is also connected. 2315// 2316// When a remote submix device is connected, the address is checked to select the 2317// appropriate profile and the corresponding input or output stream is opened. 2318// 2319// When capture starts, getInputForAttr() will: 2320// - 1 look for a mix matching the address passed in attribtutes tags if any 2321// - 2 if none found, getDeviceForInputSource() will: 2322// - 2.1 look for a mix matching the attributes source 2323// - 2.2 if none found, default to device selection by policy rules 2324// At this time, the corresponding output remote submix device is also connected 2325// and active playback use cases can be transferred to this mix if needed when reconnecting 2326// after AudioTracks are invalidated 2327// 2328// When playback starts, getOutputForAttr() will: 2329// - 1 look for a mix matching the address passed in attribtutes tags if any 2330// - 2 if none found, look for a mix matching the attributes usage 2331// - 3 if none found, default to device and output selection by policy rules. 2332 2333status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes) 2334{ 2335 ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size()); 2336 status_t res = NO_ERROR; 2337 2338 sp<HwModule> rSubmixModule; 2339 // examine each mix's route type 2340 for (size_t i = 0; i < mixes.size(); i++) { 2341 // we only support MIX_ROUTE_FLAG_LOOP_BACK or MIX_ROUTE_FLAG_RENDER, not the combination 2342 if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_ALL) == MIX_ROUTE_FLAG_ALL) { 2343 res = INVALID_OPERATION; 2344 break; 2345 } 2346 if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) { 2347 // Loop back through "remote submix" 2348 if (rSubmixModule == 0) { 2349 for (size_t j = 0; i < mHwModules.size(); j++) { 2350 if (strcmp(AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX, mHwModules[j]->mName) == 0 2351 && mHwModules[j]->mHandle != 0) { 2352 rSubmixModule = mHwModules[j]; 2353 break; 2354 } 2355 } 2356 } 2357 2358 ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK", i, mixes.size()); 2359 2360 if (rSubmixModule == 0) { 2361 ALOGE(" Unable to find audio module for submix, aborting mix %zu registration", i); 2362 res = INVALID_OPERATION; 2363 break; 2364 } 2365 2366 String8 address = mixes[i].mDeviceAddress; 2367 2368 if (mPolicyMixes.registerMix(address, mixes[i], 0 /*output desc*/) != NO_ERROR) { 2369 ALOGE(" Error registering mix %zu for address %s", i, address.string()); 2370 res = INVALID_OPERATION; 2371 break; 2372 } 2373 audio_config_t outputConfig = mixes[i].mFormat; 2374 audio_config_t inputConfig = mixes[i].mFormat; 2375 // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL in 2376 // stereo and let audio flinger do the channel conversion if needed. 2377 outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO; 2378 inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO; 2379 rSubmixModule->addOutputProfile(address, &outputConfig, 2380 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address); 2381 rSubmixModule->addInputProfile(address, &inputConfig, 2382 AUDIO_DEVICE_IN_REMOTE_SUBMIX, address); 2383 2384 if (mixes[i].mMixType == MIX_TYPE_PLAYERS) { 2385 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX, 2386 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, 2387 address.string(), "remote-submix"); 2388 } else { 2389 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, 2390 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, 2391 address.string(), "remote-submix"); 2392 } 2393 } else if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) { 2394 String8 address = mixes[i].mDeviceAddress; 2395 audio_devices_t device = mixes[i].mDeviceType; 2396 ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s", 2397 i, mixes.size(), device, address.string()); 2398 2399 bool foundOutput = false; 2400 for (size_t j = 0 ; j < mOutputs.size() ; j++) { 2401 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j); 2402 sp<AudioPatch> patch = mAudioPatches.valueFor(desc->getPatchHandle()); 2403 if ((patch != 0) && (patch->mPatch.num_sinks != 0) 2404 && (patch->mPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE) 2405 && (patch->mPatch.sinks[0].ext.device.type == device) 2406 && (strncmp(patch->mPatch.sinks[0].ext.device.address, address.string(), 2407 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) { 2408 if (mPolicyMixes.registerMix(address, mixes[i], desc) != NO_ERROR) { 2409 res = INVALID_OPERATION; 2410 } else { 2411 foundOutput = true; 2412 } 2413 break; 2414 } 2415 } 2416 2417 if (res != NO_ERROR) { 2418 ALOGE(" Error registering mix %zu for device 0x%X addr %s", 2419 i, device, address.string()); 2420 res = INVALID_OPERATION; 2421 break; 2422 } else if (!foundOutput) { 2423 ALOGE(" Output not found for mix %zu for device 0x%X addr %s", 2424 i, device, address.string()); 2425 res = INVALID_OPERATION; 2426 break; 2427 } 2428 } 2429 } 2430 if (res != NO_ERROR) { 2431 unregisterPolicyMixes(mixes); 2432 } 2433 return res; 2434} 2435 2436status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes) 2437{ 2438 ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size()); 2439 status_t res = NO_ERROR; 2440 sp<HwModule> rSubmixModule; 2441 // examine each mix's route type 2442 for (size_t i = 0; i < mixes.size(); i++) { 2443 if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) { 2444 2445 if (rSubmixModule == 0) { 2446 for (size_t j = 0; i < mHwModules.size(); j++) { 2447 if (strcmp(AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX, mHwModules[j]->mName) == 0 2448 && mHwModules[j]->mHandle != 0) { 2449 rSubmixModule = mHwModules[j]; 2450 break; 2451 } 2452 } 2453 } 2454 if (rSubmixModule == 0) { 2455 res = INVALID_OPERATION; 2456 continue; 2457 } 2458 2459 String8 address = mixes[i].mDeviceAddress; 2460 2461 if (mPolicyMixes.unregisterMix(address) != NO_ERROR) { 2462 res = INVALID_OPERATION; 2463 continue; 2464 } 2465 2466 if (getDeviceConnectionState(AUDIO_DEVICE_IN_REMOTE_SUBMIX, address.string()) == 2467 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) { 2468 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX, 2469 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 2470 address.string(), "remote-submix"); 2471 } 2472 if (getDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address.string()) == 2473 AUDIO_POLICY_DEVICE_STATE_AVAILABLE) { 2474 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, 2475 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, 2476 address.string(), "remote-submix"); 2477 } 2478 rSubmixModule->removeOutputProfile(address); 2479 rSubmixModule->removeInputProfile(address); 2480 2481 } if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) { 2482 if (mPolicyMixes.unregisterMix(mixes[i].mDeviceAddress) != NO_ERROR) { 2483 res = INVALID_OPERATION; 2484 continue; 2485 } 2486 } 2487 } 2488 return res; 2489} 2490 2491 2492status_t AudioPolicyManager::dump(int fd) 2493{ 2494 const size_t SIZE = 256; 2495 char buffer[SIZE]; 2496 String8 result; 2497 2498 snprintf(buffer, SIZE, "\nAudioPolicyManager Dump: %p\n", this); 2499 result.append(buffer); 2500 2501 snprintf(buffer, SIZE, " Primary Output: %d\n", 2502 hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE); 2503 result.append(buffer); 2504 std::string stateLiteral; 2505 AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral); 2506 snprintf(buffer, SIZE, " Phone state: %s\n", stateLiteral.c_str()); 2507 result.append(buffer); 2508 snprintf(buffer, SIZE, " Force use for communications %d\n", 2509 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION)); 2510 result.append(buffer); 2511 snprintf(buffer, SIZE, " Force use for media %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA)); 2512 result.append(buffer); 2513 snprintf(buffer, SIZE, " Force use for record %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD)); 2514 result.append(buffer); 2515 snprintf(buffer, SIZE, " Force use for dock %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_DOCK)); 2516 result.append(buffer); 2517 snprintf(buffer, SIZE, " Force use for system %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM)); 2518 result.append(buffer); 2519 snprintf(buffer, SIZE, " Force use for hdmi system audio %d\n", 2520 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO)); 2521 result.append(buffer); 2522 snprintf(buffer, SIZE, " Force use for encoded surround output %d\n", 2523 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND)); 2524 result.append(buffer); 2525 snprintf(buffer, SIZE, " TTS output %s\n", mTtsOutputAvailable ? "available" : "not available"); 2526 result.append(buffer); 2527 snprintf(buffer, SIZE, " Master mono: %s\n", mMasterMono ? "on" : "off"); 2528 result.append(buffer); 2529 2530 write(fd, result.string(), result.size()); 2531 2532 mAvailableOutputDevices.dump(fd, String8("Available output")); 2533 mAvailableInputDevices.dump(fd, String8("Available input")); 2534 mHwModules.dump(fd); 2535 mOutputs.dump(fd); 2536 mInputs.dump(fd); 2537 mVolumeCurves->dump(fd); 2538 mEffects.dump(fd); 2539 mAudioPatches.dump(fd); 2540 mPolicyMixes.dump(fd); 2541 2542 return NO_ERROR; 2543} 2544 2545// This function checks for the parameters which can be offloaded. 2546// This can be enhanced depending on the capability of the DSP and policy 2547// of the system. 2548bool AudioPolicyManager::isOffloadSupported(const audio_offload_info_t& offloadInfo) 2549{ 2550 ALOGV("isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d," 2551 " BitRate=%u, duration=%" PRId64 " us, has_video=%d", 2552 offloadInfo.sample_rate, offloadInfo.channel_mask, 2553 offloadInfo.format, 2554 offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us, 2555 offloadInfo.has_video); 2556 2557 if (mMasterMono) { 2558 return false; // no offloading if mono is set. 2559 } 2560 2561 // Check if offload has been disabled 2562 char propValue[PROPERTY_VALUE_MAX]; 2563 if (property_get("audio.offload.disable", propValue, "0")) { 2564 if (atoi(propValue) != 0) { 2565 ALOGV("offload disabled by audio.offload.disable=%s", propValue ); 2566 return false; 2567 } 2568 } 2569 2570 // Check if stream type is music, then only allow offload as of now. 2571 if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC) 2572 { 2573 ALOGV("isOffloadSupported: stream_type != MUSIC, returning false"); 2574 return false; 2575 } 2576 2577 //TODO: enable audio offloading with video when ready 2578 const bool allowOffloadWithVideo = 2579 property_get_bool("audio.offload.video", false /* default_value */); 2580 if (offloadInfo.has_video && !allowOffloadWithVideo) { 2581 ALOGV("isOffloadSupported: has_video == true, returning false"); 2582 return false; 2583 } 2584 2585 //If duration is less than minimum value defined in property, return false 2586 if (property_get("audio.offload.min.duration.secs", propValue, NULL)) { 2587 if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) { 2588 ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue); 2589 return false; 2590 } 2591 } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) { 2592 ALOGV("Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS); 2593 return false; 2594 } 2595 2596 // Do not allow offloading if one non offloadable effect is enabled. This prevents from 2597 // creating an offloaded track and tearing it down immediately after start when audioflinger 2598 // detects there is an active non offloadable effect. 2599 // FIXME: We should check the audio session here but we do not have it in this context. 2600 // This may prevent offloading in rare situations where effects are left active by apps 2601 // in the background. 2602 if (mEffects.isNonOffloadableEffectEnabled()) { 2603 return false; 2604 } 2605 2606 // See if there is a profile to support this. 2607 // AUDIO_DEVICE_NONE 2608 sp<IOProfile> profile = getProfileForDirectOutput(AUDIO_DEVICE_NONE /*ignore device */, 2609 offloadInfo.sample_rate, 2610 offloadInfo.format, 2611 offloadInfo.channel_mask, 2612 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD); 2613 ALOGV("isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT "); 2614 return (profile != 0); 2615} 2616 2617status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role, 2618 audio_port_type_t type, 2619 unsigned int *num_ports, 2620 struct audio_port *ports, 2621 unsigned int *generation) 2622{ 2623 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 2624 generation == NULL) { 2625 return BAD_VALUE; 2626 } 2627 ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports); 2628 if (ports == NULL) { 2629 *num_ports = 0; 2630 } 2631 2632 size_t portsWritten = 0; 2633 size_t portsMax = *num_ports; 2634 *num_ports = 0; 2635 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) { 2636 // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB 2637 // as they are used by stub HALs by convention 2638 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) { 2639 for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) { 2640 if (mAvailableOutputDevices[i]->type() == AUDIO_DEVICE_OUT_STUB) { 2641 continue; 2642 } 2643 if (portsWritten < portsMax) { 2644 mAvailableOutputDevices[i]->toAudioPort(&ports[portsWritten++]); 2645 } 2646 (*num_ports)++; 2647 } 2648 } 2649 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) { 2650 for (size_t i = 0; i < mAvailableInputDevices.size(); i++) { 2651 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_STUB) { 2652 continue; 2653 } 2654 if (portsWritten < portsMax) { 2655 mAvailableInputDevices[i]->toAudioPort(&ports[portsWritten++]); 2656 } 2657 (*num_ports)++; 2658 } 2659 } 2660 } 2661 if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) { 2662 if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) { 2663 for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) { 2664 mInputs[i]->toAudioPort(&ports[portsWritten++]); 2665 } 2666 *num_ports += mInputs.size(); 2667 } 2668 if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) { 2669 size_t numOutputs = 0; 2670 for (size_t i = 0; i < mOutputs.size(); i++) { 2671 if (!mOutputs[i]->isDuplicated()) { 2672 numOutputs++; 2673 if (portsWritten < portsMax) { 2674 mOutputs[i]->toAudioPort(&ports[portsWritten++]); 2675 } 2676 } 2677 } 2678 *num_ports += numOutputs; 2679 } 2680 } 2681 *generation = curAudioPortGeneration(); 2682 ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports); 2683 return NO_ERROR; 2684} 2685 2686status_t AudioPolicyManager::getAudioPort(struct audio_port *port __unused) 2687{ 2688 return NO_ERROR; 2689} 2690 2691status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch, 2692 audio_patch_handle_t *handle, 2693 uid_t uid) 2694{ 2695 ALOGV("createAudioPatch()"); 2696 2697 if (handle == NULL || patch == NULL) { 2698 return BAD_VALUE; 2699 } 2700 ALOGV("createAudioPatch() num sources %d num sinks %d", patch->num_sources, patch->num_sinks); 2701 2702 if (patch->num_sources == 0 || patch->num_sources > AUDIO_PATCH_PORTS_MAX || 2703 patch->num_sinks == 0 || patch->num_sinks > AUDIO_PATCH_PORTS_MAX) { 2704 return BAD_VALUE; 2705 } 2706 // only one source per audio patch supported for now 2707 if (patch->num_sources > 1) { 2708 return INVALID_OPERATION; 2709 } 2710 2711 if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) { 2712 return INVALID_OPERATION; 2713 } 2714 for (size_t i = 0; i < patch->num_sinks; i++) { 2715 if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) { 2716 return INVALID_OPERATION; 2717 } 2718 } 2719 2720 sp<AudioPatch> patchDesc; 2721 ssize_t index = mAudioPatches.indexOfKey(*handle); 2722 2723 ALOGV("createAudioPatch source id %d role %d type %d", patch->sources[0].id, 2724 patch->sources[0].role, 2725 patch->sources[0].type); 2726#if LOG_NDEBUG == 0 2727 for (size_t i = 0; i < patch->num_sinks; i++) { 2728 ALOGV("createAudioPatch sink %zu: id %d role %d type %d", i, patch->sinks[i].id, 2729 patch->sinks[i].role, 2730 patch->sinks[i].type); 2731 } 2732#endif 2733 2734 if (index >= 0) { 2735 patchDesc = mAudioPatches.valueAt(index); 2736 ALOGV("createAudioPatch() mUidCached %d patchDesc->mUid %d uid %d", 2737 mUidCached, patchDesc->mUid, uid); 2738 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) { 2739 return INVALID_OPERATION; 2740 } 2741 } else { 2742 *handle = AUDIO_PATCH_HANDLE_NONE; 2743 } 2744 2745 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) { 2746 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id); 2747 if (outputDesc == NULL) { 2748 ALOGV("createAudioPatch() output not found for id %d", patch->sources[0].id); 2749 return BAD_VALUE; 2750 } 2751 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports", 2752 outputDesc->mIoHandle); 2753 if (patchDesc != 0) { 2754 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) { 2755 ALOGV("createAudioPatch() source id differs for patch current id %d new id %d", 2756 patchDesc->mPatch.sources[0].id, patch->sources[0].id); 2757 return BAD_VALUE; 2758 } 2759 } 2760 DeviceVector devices; 2761 for (size_t i = 0; i < patch->num_sinks; i++) { 2762 // Only support mix to devices connection 2763 // TODO add support for mix to mix connection 2764 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) { 2765 ALOGV("createAudioPatch() source mix but sink is not a device"); 2766 return INVALID_OPERATION; 2767 } 2768 sp<DeviceDescriptor> devDesc = 2769 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id); 2770 if (devDesc == 0) { 2771 ALOGV("createAudioPatch() out device not found for id %d", patch->sinks[i].id); 2772 return BAD_VALUE; 2773 } 2774 2775 if (!outputDesc->mProfile->isCompatibleProfile(devDesc->type(), 2776 devDesc->mAddress, 2777 patch->sources[0].sample_rate, 2778 NULL, // updatedSamplingRate 2779 patch->sources[0].format, 2780 NULL, // updatedFormat 2781 patch->sources[0].channel_mask, 2782 NULL, // updatedChannelMask 2783 AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) { 2784 ALOGV("createAudioPatch() profile not supported for device %08x", 2785 devDesc->type()); 2786 return INVALID_OPERATION; 2787 } 2788 devices.add(devDesc); 2789 } 2790 if (devices.size() == 0) { 2791 return INVALID_OPERATION; 2792 } 2793 2794 // TODO: reconfigure output format and channels here 2795 ALOGV("createAudioPatch() setting device %08x on output %d", 2796 devices.types(), outputDesc->mIoHandle); 2797 setOutputDevice(outputDesc, devices.types(), true, 0, handle); 2798 index = mAudioPatches.indexOfKey(*handle); 2799 if (index >= 0) { 2800 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) { 2801 ALOGW("createAudioPatch() setOutputDevice() did not reuse the patch provided"); 2802 } 2803 patchDesc = mAudioPatches.valueAt(index); 2804 patchDesc->mUid = uid; 2805 ALOGV("createAudioPatch() success"); 2806 } else { 2807 ALOGW("createAudioPatch() setOutputDevice() failed to create a patch"); 2808 return INVALID_OPERATION; 2809 } 2810 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) { 2811 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) { 2812 // input device to input mix connection 2813 // only one sink supported when connecting an input device to a mix 2814 if (patch->num_sinks > 1) { 2815 return INVALID_OPERATION; 2816 } 2817 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id); 2818 if (inputDesc == NULL) { 2819 return BAD_VALUE; 2820 } 2821 if (patchDesc != 0) { 2822 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) { 2823 return BAD_VALUE; 2824 } 2825 } 2826 sp<DeviceDescriptor> devDesc = 2827 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id); 2828 if (devDesc == 0) { 2829 return BAD_VALUE; 2830 } 2831 2832 if (!inputDesc->mProfile->isCompatibleProfile(devDesc->type(), 2833 devDesc->mAddress, 2834 patch->sinks[0].sample_rate, 2835 NULL, /*updatedSampleRate*/ 2836 patch->sinks[0].format, 2837 NULL, /*updatedFormat*/ 2838 patch->sinks[0].channel_mask, 2839 NULL, /*updatedChannelMask*/ 2840 // FIXME for the parameter type, 2841 // and the NONE 2842 (audio_output_flags_t) 2843 AUDIO_INPUT_FLAG_NONE)) { 2844 return INVALID_OPERATION; 2845 } 2846 // TODO: reconfigure output format and channels here 2847 ALOGV("createAudioPatch() setting device %08x on output %d", 2848 devDesc->type(), inputDesc->mIoHandle); 2849 setInputDevice(inputDesc->mIoHandle, devDesc->type(), true, handle); 2850 index = mAudioPatches.indexOfKey(*handle); 2851 if (index >= 0) { 2852 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) { 2853 ALOGW("createAudioPatch() setInputDevice() did not reuse the patch provided"); 2854 } 2855 patchDesc = mAudioPatches.valueAt(index); 2856 patchDesc->mUid = uid; 2857 ALOGV("createAudioPatch() success"); 2858 } else { 2859 ALOGW("createAudioPatch() setInputDevice() failed to create a patch"); 2860 return INVALID_OPERATION; 2861 } 2862 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) { 2863 // device to device connection 2864 if (patchDesc != 0) { 2865 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) { 2866 return BAD_VALUE; 2867 } 2868 } 2869 sp<DeviceDescriptor> srcDeviceDesc = 2870 mAvailableInputDevices.getDeviceFromId(patch->sources[0].id); 2871 if (srcDeviceDesc == 0) { 2872 return BAD_VALUE; 2873 } 2874 2875 //update source and sink with our own data as the data passed in the patch may 2876 // be incomplete. 2877 struct audio_patch newPatch = *patch; 2878 srcDeviceDesc->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]); 2879 2880 for (size_t i = 0; i < patch->num_sinks; i++) { 2881 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) { 2882 ALOGV("createAudioPatch() source device but one sink is not a device"); 2883 return INVALID_OPERATION; 2884 } 2885 2886 sp<DeviceDescriptor> sinkDeviceDesc = 2887 mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id); 2888 if (sinkDeviceDesc == 0) { 2889 return BAD_VALUE; 2890 } 2891 sinkDeviceDesc->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]); 2892 2893 // create a software bridge in PatchPanel if: 2894 // - source and sink devices are on differnt HW modules OR 2895 // - audio HAL version is < 3.0 2896 if (!srcDeviceDesc->hasSameHwModuleAs(sinkDeviceDesc) || 2897 (srcDeviceDesc->mModule->getHalVersionMajor() < 3)) { 2898 // support only one sink device for now to simplify output selection logic 2899 if (patch->num_sinks > 1) { 2900 return INVALID_OPERATION; 2901 } 2902 SortedVector<audio_io_handle_t> outputs = 2903 getOutputsForDevice(sinkDeviceDesc->type(), mOutputs); 2904 // if the sink device is reachable via an opened output stream, request to go via 2905 // this output stream by adding a second source to the patch description 2906 audio_io_handle_t output = selectOutput(outputs, 2907 AUDIO_OUTPUT_FLAG_NONE, 2908 AUDIO_FORMAT_INVALID); 2909 if (output != AUDIO_IO_HANDLE_NONE) { 2910 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output); 2911 if (outputDesc->isDuplicated()) { 2912 return INVALID_OPERATION; 2913 } 2914 outputDesc->toAudioPortConfig(&newPatch.sources[1], &patch->sources[0]); 2915 newPatch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH; 2916 newPatch.num_sources = 2; 2917 } 2918 } 2919 } 2920 // TODO: check from routing capabilities in config file and other conflicting patches 2921 2922 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 2923 if (index >= 0) { 2924 afPatchHandle = patchDesc->mAfPatchHandle; 2925 } 2926 2927 status_t status = mpClientInterface->createAudioPatch(&newPatch, 2928 &afPatchHandle, 2929 0); 2930 ALOGV("createAudioPatch() patch panel returned %d patchHandle %d", 2931 status, afPatchHandle); 2932 if (status == NO_ERROR) { 2933 if (index < 0) { 2934 patchDesc = new AudioPatch(&newPatch, uid); 2935 addAudioPatch(patchDesc->mHandle, patchDesc); 2936 } else { 2937 patchDesc->mPatch = newPatch; 2938 } 2939 patchDesc->mAfPatchHandle = afPatchHandle; 2940 *handle = patchDesc->mHandle; 2941 nextAudioPortGeneration(); 2942 mpClientInterface->onAudioPatchListUpdate(); 2943 } else { 2944 ALOGW("createAudioPatch() patch panel could not connect device patch, error %d", 2945 status); 2946 return INVALID_OPERATION; 2947 } 2948 } else { 2949 return BAD_VALUE; 2950 } 2951 } else { 2952 return BAD_VALUE; 2953 } 2954 return NO_ERROR; 2955} 2956 2957status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle, 2958 uid_t uid) 2959{ 2960 ALOGV("releaseAudioPatch() patch %d", handle); 2961 2962 ssize_t index = mAudioPatches.indexOfKey(handle); 2963 2964 if (index < 0) { 2965 return BAD_VALUE; 2966 } 2967 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index); 2968 ALOGV("releaseAudioPatch() mUidCached %d patchDesc->mUid %d uid %d", 2969 mUidCached, patchDesc->mUid, uid); 2970 if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) { 2971 return INVALID_OPERATION; 2972 } 2973 2974 struct audio_patch *patch = &patchDesc->mPatch; 2975 patchDesc->mUid = mUidCached; 2976 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) { 2977 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id); 2978 if (outputDesc == NULL) { 2979 ALOGV("releaseAudioPatch() output not found for id %d", patch->sources[0].id); 2980 return BAD_VALUE; 2981 } 2982 2983 setOutputDevice(outputDesc, 2984 getNewOutputDevice(outputDesc, true /*fromCache*/), 2985 true, 2986 0, 2987 NULL); 2988 } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) { 2989 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) { 2990 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id); 2991 if (inputDesc == NULL) { 2992 ALOGV("releaseAudioPatch() input not found for id %d", patch->sinks[0].id); 2993 return BAD_VALUE; 2994 } 2995 setInputDevice(inputDesc->mIoHandle, 2996 getNewInputDevice(inputDesc), 2997 true, 2998 NULL); 2999 } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) { 3000 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 3001 ALOGV("releaseAudioPatch() patch panel returned %d patchHandle %d", 3002 status, patchDesc->mAfPatchHandle); 3003 removeAudioPatch(patchDesc->mHandle); 3004 nextAudioPortGeneration(); 3005 mpClientInterface->onAudioPatchListUpdate(); 3006 } else { 3007 return BAD_VALUE; 3008 } 3009 } else { 3010 return BAD_VALUE; 3011 } 3012 return NO_ERROR; 3013} 3014 3015status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches, 3016 struct audio_patch *patches, 3017 unsigned int *generation) 3018{ 3019 if (generation == NULL) { 3020 return BAD_VALUE; 3021 } 3022 *generation = curAudioPortGeneration(); 3023 return mAudioPatches.listAudioPatches(num_patches, patches); 3024} 3025 3026status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config) 3027{ 3028 ALOGV("setAudioPortConfig()"); 3029 3030 if (config == NULL) { 3031 return BAD_VALUE; 3032 } 3033 ALOGV("setAudioPortConfig() on port handle %d", config->id); 3034 // Only support gain configuration for now 3035 if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) { 3036 return INVALID_OPERATION; 3037 } 3038 3039 sp<AudioPortConfig> audioPortConfig; 3040 if (config->type == AUDIO_PORT_TYPE_MIX) { 3041 if (config->role == AUDIO_PORT_ROLE_SOURCE) { 3042 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id); 3043 if (outputDesc == NULL) { 3044 return BAD_VALUE; 3045 } 3046 ALOG_ASSERT(!outputDesc->isDuplicated(), 3047 "setAudioPortConfig() called on duplicated output %d", 3048 outputDesc->mIoHandle); 3049 audioPortConfig = outputDesc; 3050 } else if (config->role == AUDIO_PORT_ROLE_SINK) { 3051 sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id); 3052 if (inputDesc == NULL) { 3053 return BAD_VALUE; 3054 } 3055 audioPortConfig = inputDesc; 3056 } else { 3057 return BAD_VALUE; 3058 } 3059 } else if (config->type == AUDIO_PORT_TYPE_DEVICE) { 3060 sp<DeviceDescriptor> deviceDesc; 3061 if (config->role == AUDIO_PORT_ROLE_SOURCE) { 3062 deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id); 3063 } else if (config->role == AUDIO_PORT_ROLE_SINK) { 3064 deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id); 3065 } else { 3066 return BAD_VALUE; 3067 } 3068 if (deviceDesc == NULL) { 3069 return BAD_VALUE; 3070 } 3071 audioPortConfig = deviceDesc; 3072 } else { 3073 return BAD_VALUE; 3074 } 3075 3076 struct audio_port_config backupConfig; 3077 status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig); 3078 if (status == NO_ERROR) { 3079 struct audio_port_config newConfig; 3080 audioPortConfig->toAudioPortConfig(&newConfig, config); 3081 status = mpClientInterface->setAudioPortConfig(&newConfig, 0); 3082 } 3083 if (status != NO_ERROR) { 3084 audioPortConfig->applyAudioPortConfig(&backupConfig); 3085 } 3086 3087 return status; 3088} 3089 3090void AudioPolicyManager::releaseResourcesForUid(uid_t uid) 3091{ 3092 clearAudioSources(uid); 3093 clearAudioPatches(uid); 3094 clearSessionRoutes(uid); 3095} 3096 3097void AudioPolicyManager::clearAudioPatches(uid_t uid) 3098{ 3099 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) { 3100 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i); 3101 if (patchDesc->mUid == uid) { 3102 releaseAudioPatch(mAudioPatches.keyAt(i), uid); 3103 } 3104 } 3105} 3106 3107void AudioPolicyManager::checkStrategyRoute(routing_strategy strategy, 3108 audio_io_handle_t ouptutToSkip) 3109{ 3110 audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/); 3111 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs); 3112 for (size_t j = 0; j < mOutputs.size(); j++) { 3113 if (mOutputs.keyAt(j) == ouptutToSkip) { 3114 continue; 3115 } 3116 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j); 3117 if (!isStrategyActive(outputDesc, (routing_strategy)strategy)) { 3118 continue; 3119 } 3120 // If the default device for this strategy is on another output mix, 3121 // invalidate all tracks in this strategy to force re connection. 3122 // Otherwise select new device on the output mix. 3123 if (outputs.indexOf(mOutputs.keyAt(j)) < 0) { 3124 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) { 3125 if (getStrategy((audio_stream_type_t)stream) == strategy) { 3126 mpClientInterface->invalidateStream((audio_stream_type_t)stream); 3127 } 3128 } 3129 } else { 3130 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/); 3131 setOutputDevice(outputDesc, newDevice, false); 3132 } 3133 } 3134} 3135 3136void AudioPolicyManager::clearSessionRoutes(uid_t uid) 3137{ 3138 // remove output routes associated with this uid 3139 SortedVector<routing_strategy> affectedStrategies; 3140 for (ssize_t i = (ssize_t)mOutputRoutes.size() - 1; i >= 0; i--) { 3141 sp<SessionRoute> route = mOutputRoutes.valueAt(i); 3142 if (route->mUid == uid) { 3143 mOutputRoutes.removeItemsAt(i); 3144 if (route->mDeviceDescriptor != 0) { 3145 affectedStrategies.add(getStrategy(route->mStreamType)); 3146 } 3147 } 3148 } 3149 // reroute outputs if necessary 3150 for (size_t i = 0; i < affectedStrategies.size(); i++) { 3151 checkStrategyRoute(affectedStrategies[i], AUDIO_IO_HANDLE_NONE); 3152 } 3153 3154 // remove input routes associated with this uid 3155 SortedVector<audio_source_t> affectedSources; 3156 for (ssize_t i = (ssize_t)mInputRoutes.size() - 1; i >= 0; i--) { 3157 sp<SessionRoute> route = mInputRoutes.valueAt(i); 3158 if (route->mUid == uid) { 3159 mInputRoutes.removeItemsAt(i); 3160 if (route->mDeviceDescriptor != 0) { 3161 affectedSources.add(route->mSource); 3162 } 3163 } 3164 } 3165 // reroute inputs if necessary 3166 SortedVector<audio_io_handle_t> inputsToClose; 3167 for (size_t i = 0; i < mInputs.size(); i++) { 3168 sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i); 3169 if (affectedSources.indexOf(inputDesc->inputSource()) >= 0) { 3170 inputsToClose.add(inputDesc->mIoHandle); 3171 } 3172 } 3173 for (size_t i = 0; i < inputsToClose.size(); i++) { 3174 closeInput(inputsToClose[i]); 3175 } 3176} 3177 3178void AudioPolicyManager::clearAudioSources(uid_t uid) 3179{ 3180 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) { 3181 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i); 3182 if (sourceDesc->mUid == uid) { 3183 stopAudioSource(mAudioSources.keyAt(i)); 3184 } 3185 } 3186} 3187 3188status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session, 3189 audio_io_handle_t *ioHandle, 3190 audio_devices_t *device) 3191{ 3192 *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION); 3193 *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT); 3194 *device = getDeviceAndMixForInputSource(AUDIO_SOURCE_HOTWORD); 3195 3196 return mSoundTriggerSessions.acquireSession(*session, *ioHandle); 3197} 3198 3199status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source, 3200 const audio_attributes_t *attributes, 3201 audio_patch_handle_t *handle, 3202 uid_t uid) 3203{ 3204 ALOGV("%s source %p attributes %p handle %p", __FUNCTION__, source, attributes, handle); 3205 if (source == NULL || attributes == NULL || handle == NULL) { 3206 return BAD_VALUE; 3207 } 3208 3209 *handle = AUDIO_PATCH_HANDLE_NONE; 3210 3211 if (source->role != AUDIO_PORT_ROLE_SOURCE || 3212 source->type != AUDIO_PORT_TYPE_DEVICE) { 3213 ALOGV("%s INVALID_OPERATION source->role %d source->type %d", __FUNCTION__, source->role, source->type); 3214 return INVALID_OPERATION; 3215 } 3216 3217 sp<DeviceDescriptor> srcDeviceDesc = 3218 mAvailableInputDevices.getDevice(source->ext.device.type, 3219 String8(source->ext.device.address)); 3220 if (srcDeviceDesc == 0) { 3221 ALOGV("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type); 3222 return BAD_VALUE; 3223 } 3224 sp<AudioSourceDescriptor> sourceDesc = 3225 new AudioSourceDescriptor(srcDeviceDesc, attributes, uid); 3226 3227 struct audio_patch dummyPatch; 3228 sp<AudioPatch> patchDesc = new AudioPatch(&dummyPatch, uid); 3229 sourceDesc->mPatchDesc = patchDesc; 3230 3231 status_t status = connectAudioSource(sourceDesc); 3232 if (status == NO_ERROR) { 3233 mAudioSources.add(sourceDesc->getHandle(), sourceDesc); 3234 *handle = sourceDesc->getHandle(); 3235 } 3236 return status; 3237} 3238 3239status_t AudioPolicyManager::connectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc) 3240{ 3241 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle()); 3242 3243 // make sure we only have one patch per source. 3244 disconnectAudioSource(sourceDesc); 3245 3246 routing_strategy strategy = (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes); 3247 audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes); 3248 sp<DeviceDescriptor> srcDeviceDesc = sourceDesc->mDevice; 3249 3250 audio_devices_t sinkDevice = getDeviceForStrategy(strategy, true); 3251 sp<DeviceDescriptor> sinkDeviceDesc = 3252 mAvailableOutputDevices.getDevice(sinkDevice, String8("")); 3253 3254 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 3255 struct audio_patch *patch = &sourceDesc->mPatchDesc->mPatch; 3256 3257 if (srcDeviceDesc->getAudioPort()->mModule->getHandle() == 3258 sinkDeviceDesc->getAudioPort()->mModule->getHandle() && 3259 srcDeviceDesc->getAudioPort()->mModule->getHalVersionMajor() >= 3 && 3260 srcDeviceDesc->getAudioPort()->mGains.size() > 0) { 3261 ALOGV("%s AUDIO_DEVICE_API_VERSION_3_0", __FUNCTION__); 3262 // create patch between src device and output device 3263 // create Hwoutput and add to mHwOutputs 3264 } else { 3265 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(sinkDevice, mOutputs); 3266 audio_io_handle_t output = 3267 selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID); 3268 if (output == AUDIO_IO_HANDLE_NONE) { 3269 ALOGV("%s no output for device %08x", __FUNCTION__, sinkDevice); 3270 return INVALID_OPERATION; 3271 } 3272 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output); 3273 if (outputDesc->isDuplicated()) { 3274 ALOGV("%s output for device %08x is duplicated", __FUNCTION__, sinkDevice); 3275 return INVALID_OPERATION; 3276 } 3277 // create a special patch with no sink and two sources: 3278 // - the second source indicates to PatchPanel through which output mix this patch should 3279 // be connected as well as the stream type for volume control 3280 // - the sink is defined by whatever output device is currently selected for the output 3281 // though which this patch is routed. 3282 patch->num_sinks = 0; 3283 patch->num_sources = 2; 3284 srcDeviceDesc->toAudioPortConfig(&patch->sources[0], NULL); 3285 outputDesc->toAudioPortConfig(&patch->sources[1], NULL); 3286 patch->sources[1].ext.mix.usecase.stream = stream; 3287 status_t status = mpClientInterface->createAudioPatch(patch, 3288 &afPatchHandle, 3289 0); 3290 ALOGV("%s patch panel returned %d patchHandle %d", __FUNCTION__, 3291 status, afPatchHandle); 3292 if (status != NO_ERROR) { 3293 ALOGW("%s patch panel could not connect device patch, error %d", 3294 __FUNCTION__, status); 3295 return INVALID_OPERATION; 3296 } 3297 uint32_t delayMs = 0; 3298 status = startSource(outputDesc, stream, sinkDevice, NULL, &delayMs); 3299 3300 if (status != NO_ERROR) { 3301 mpClientInterface->releaseAudioPatch(sourceDesc->mPatchDesc->mAfPatchHandle, 0); 3302 return status; 3303 } 3304 sourceDesc->mSwOutput = outputDesc; 3305 if (delayMs != 0) { 3306 usleep(delayMs * 1000); 3307 } 3308 } 3309 3310 sourceDesc->mPatchDesc->mAfPatchHandle = afPatchHandle; 3311 addAudioPatch(sourceDesc->mPatchDesc->mHandle, sourceDesc->mPatchDesc); 3312 3313 return NO_ERROR; 3314} 3315 3316status_t AudioPolicyManager::stopAudioSource(audio_patch_handle_t handle __unused) 3317{ 3318 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueFor(handle); 3319 ALOGV("%s handle %d", __FUNCTION__, handle); 3320 if (sourceDesc == 0) { 3321 ALOGW("%s unknown source for handle %d", __FUNCTION__, handle); 3322 return BAD_VALUE; 3323 } 3324 status_t status = disconnectAudioSource(sourceDesc); 3325 3326 mAudioSources.removeItem(handle); 3327 return status; 3328} 3329 3330status_t AudioPolicyManager::setMasterMono(bool mono) 3331{ 3332 if (mMasterMono == mono) { 3333 return NO_ERROR; 3334 } 3335 mMasterMono = mono; 3336 // if enabling mono we close all offloaded devices, which will invalidate the 3337 // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible 3338 // for recreating the new AudioTrack as non-offloaded PCM. 3339 // 3340 // If disabling mono, we leave all tracks as is: we don't know which clients 3341 // and tracks are able to be recreated as offloaded. The next "song" should 3342 // play back offloaded. 3343 if (mMasterMono) { 3344 Vector<audio_io_handle_t> offloaded; 3345 for (size_t i = 0; i < mOutputs.size(); ++i) { 3346 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 3347 if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) { 3348 offloaded.push(desc->mIoHandle); 3349 } 3350 } 3351 for (size_t i = 0; i < offloaded.size(); ++i) { 3352 closeOutput(offloaded[i]); 3353 } 3354 } 3355 // update master mono for all remaining outputs 3356 for (size_t i = 0; i < mOutputs.size(); ++i) { 3357 updateMono(mOutputs.keyAt(i)); 3358 } 3359 return NO_ERROR; 3360} 3361 3362status_t AudioPolicyManager::getMasterMono(bool *mono) 3363{ 3364 *mono = mMasterMono; 3365 return NO_ERROR; 3366} 3367 3368status_t AudioPolicyManager::disconnectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc) 3369{ 3370 ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle()); 3371 3372 sp<AudioPatch> patchDesc = mAudioPatches.valueFor(sourceDesc->mPatchDesc->mHandle); 3373 if (patchDesc == 0) { 3374 ALOGW("%s source has no patch with handle %d", __FUNCTION__, 3375 sourceDesc->mPatchDesc->mHandle); 3376 return BAD_VALUE; 3377 } 3378 removeAudioPatch(sourceDesc->mPatchDesc->mHandle); 3379 3380 audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes); 3381 sp<SwAudioOutputDescriptor> swOutputDesc = sourceDesc->mSwOutput.promote(); 3382 if (swOutputDesc != 0) { 3383 stopSource(swOutputDesc, stream, false); 3384 mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 3385 } else { 3386 sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->mHwOutput.promote(); 3387 if (hwOutputDesc != 0) { 3388 // release patch between src device and output device 3389 // close Hwoutput and remove from mHwOutputs 3390 } else { 3391 ALOGW("%s source has neither SW nor HW output", __FUNCTION__); 3392 } 3393 } 3394 return NO_ERROR; 3395} 3396 3397sp<AudioSourceDescriptor> AudioPolicyManager::getSourceForStrategyOnOutput( 3398 audio_io_handle_t output, routing_strategy strategy) 3399{ 3400 sp<AudioSourceDescriptor> source; 3401 for (size_t i = 0; i < mAudioSources.size(); i++) { 3402 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i); 3403 routing_strategy sourceStrategy = 3404 (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes); 3405 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->mSwOutput.promote(); 3406 if (sourceStrategy == strategy && outputDesc != 0 && outputDesc->mIoHandle == output) { 3407 source = sourceDesc; 3408 break; 3409 } 3410 } 3411 return source; 3412} 3413 3414// ---------------------------------------------------------------------------- 3415// AudioPolicyManager 3416// ---------------------------------------------------------------------------- 3417uint32_t AudioPolicyManager::nextAudioPortGeneration() 3418{ 3419 return android_atomic_inc(&mAudioPortGeneration); 3420} 3421 3422#ifdef USE_XML_AUDIO_POLICY_CONF 3423// Treblized audio policy xml config will be located in /odm/etc or /vendor/etc. 3424static const char *kConfigLocationList[] = 3425 {"/odm/etc", "/vendor/etc", "/system/etc"}; 3426static const int kConfigLocationListSize = 3427 (sizeof(kConfigLocationList) / sizeof(kConfigLocationList[0])); 3428 3429static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) { 3430 char audioPolicyXmlConfigFile[AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH]; 3431 status_t ret; 3432 3433 for (int i = 0; i < kConfigLocationListSize; i++) { 3434 PolicySerializer serializer; 3435 snprintf(audioPolicyXmlConfigFile, 3436 sizeof(audioPolicyXmlConfigFile), 3437 "%s/%s", 3438 kConfigLocationList[i], 3439 AUDIO_POLICY_XML_CONFIG_FILE_NAME); 3440 ret = serializer.deserialize(audioPolicyXmlConfigFile, config); 3441 if (ret == NO_ERROR) { 3442 break; 3443 } 3444 } 3445 return ret; 3446} 3447#endif 3448 3449AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface) 3450 : 3451#ifdef AUDIO_POLICY_TEST 3452 Thread(false), 3453#endif //AUDIO_POLICY_TEST 3454 mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f), 3455 mA2dpSuspended(false), 3456 mAudioPortGeneration(1), 3457 mBeaconMuteRefCount(0), 3458 mBeaconPlayingRefCount(0), 3459 mBeaconMuted(false), 3460 mTtsOutputAvailable(false), 3461 mMasterMono(false), 3462 mMusicEffectOutput(AUDIO_IO_HANDLE_NONE) 3463{ 3464 mUidCached = getuid(); 3465 mpClientInterface = clientInterface; 3466 3467 // TODO: remove when legacy conf file is removed. true on devices that use DRC on the 3468 // DEVICE_CATEGORY_SPEAKER path to boost soft sounds, used to adjust volume curves accordingly. 3469 // Note: remove also speaker_drc_enabled from global configuration of XML config file. 3470 bool speakerDrcEnabled = false; 3471 3472#ifdef USE_XML_AUDIO_POLICY_CONF 3473 mVolumeCurves = new VolumeCurvesCollection(); 3474 AudioPolicyConfig config(mHwModules, mAvailableOutputDevices, mAvailableInputDevices, 3475 mDefaultOutputDevice, speakerDrcEnabled, 3476 static_cast<VolumeCurvesCollection *>(mVolumeCurves)); 3477 if (deserializeAudioPolicyXmlConfig(config) != NO_ERROR) { 3478#else 3479 mVolumeCurves = new StreamDescriptorCollection(); 3480 AudioPolicyConfig config(mHwModules, mAvailableOutputDevices, mAvailableInputDevices, 3481 mDefaultOutputDevice, speakerDrcEnabled); 3482 if ((ConfigParsingUtils::loadConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE, config) != NO_ERROR) && 3483 (ConfigParsingUtils::loadConfig(AUDIO_POLICY_CONFIG_FILE, config) != NO_ERROR)) { 3484#endif 3485 ALOGE("could not load audio policy configuration file, setting defaults"); 3486 config.setDefault(); 3487 } 3488 // must be done after reading the policy (since conditionned by Speaker Drc Enabling) 3489 mVolumeCurves->initializeVolumeCurves(speakerDrcEnabled); 3490 3491 // Once policy config has been parsed, retrieve an instance of the engine and initialize it. 3492 audio_policy::EngineInstance *engineInstance = audio_policy::EngineInstance::getInstance(); 3493 if (!engineInstance) { 3494 ALOGE("%s: Could not get an instance of policy engine", __FUNCTION__); 3495 return; 3496 } 3497 // Retrieve the Policy Manager Interface 3498 mEngine = engineInstance->queryInterface<AudioPolicyManagerInterface>(); 3499 if (mEngine == NULL) { 3500 ALOGE("%s: Failed to get Policy Engine Interface", __FUNCTION__); 3501 return; 3502 } 3503 mEngine->setObserver(this); 3504 status_t status = mEngine->initCheck(); 3505 (void) status; 3506 ALOG_ASSERT(status == NO_ERROR, "Policy engine not initialized(err=%d)", status); 3507 3508 // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices 3509 // open all output streams needed to access attached devices 3510 audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types(); 3511 audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN; 3512 for (size_t i = 0; i < mHwModules.size(); i++) { 3513 mHwModules[i]->mHandle = mpClientInterface->loadHwModule(mHwModules[i]->getName()); 3514 if (mHwModules[i]->mHandle == 0) { 3515 ALOGW("could not open HW module %s", mHwModules[i]->getName()); 3516 continue; 3517 } 3518 // open all output streams needed to access attached devices 3519 // except for direct output streams that are only opened when they are actually 3520 // required by an app. 3521 // This also validates mAvailableOutputDevices list 3522 for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++) 3523 { 3524 const sp<IOProfile> outProfile = mHwModules[i]->mOutputProfiles[j]; 3525 3526 if (!outProfile->hasSupportedDevices()) { 3527 ALOGW("Output profile contains no device on module %s", mHwModules[i]->getName()); 3528 continue; 3529 } 3530 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) { 3531 mTtsOutputAvailable = true; 3532 } 3533 3534 if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) { 3535 continue; 3536 } 3537 audio_devices_t profileType = outProfile->getSupportedDevicesType(); 3538 if ((profileType & mDefaultOutputDevice->type()) != AUDIO_DEVICE_NONE) { 3539 profileType = mDefaultOutputDevice->type(); 3540 } else { 3541 // chose first device present in profile's SupportedDevices also part of 3542 // outputDeviceTypes 3543 profileType = outProfile->getSupportedDeviceForType(outputDeviceTypes); 3544 } 3545 if ((profileType & outputDeviceTypes) == 0) { 3546 continue; 3547 } 3548 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile, 3549 mpClientInterface); 3550 const DeviceVector &supportedDevices = outProfile->getSupportedDevices(); 3551 const DeviceVector &devicesForType = supportedDevices.getDevicesFromType(profileType); 3552 String8 address = devicesForType.size() > 0 ? devicesForType.itemAt(0)->mAddress 3553 : String8(""); 3554 3555 outputDesc->mDevice = profileType; 3556 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 3557 config.sample_rate = outputDesc->mSamplingRate; 3558 config.channel_mask = outputDesc->mChannelMask; 3559 config.format = outputDesc->mFormat; 3560 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE; 3561 status_t status = mpClientInterface->openOutput(outProfile->getModuleHandle(), 3562 &output, 3563 &config, 3564 &outputDesc->mDevice, 3565 address, 3566 &outputDesc->mLatency, 3567 outputDesc->mFlags); 3568 3569 if (status != NO_ERROR) { 3570 ALOGW("Cannot open output stream for device %08x on hw module %s", 3571 outputDesc->mDevice, 3572 mHwModules[i]->getName()); 3573 } else { 3574 outputDesc->mSamplingRate = config.sample_rate; 3575 outputDesc->mChannelMask = config.channel_mask; 3576 outputDesc->mFormat = config.format; 3577 3578 for (size_t k = 0; k < supportedDevices.size(); k++) { 3579 ssize_t index = mAvailableOutputDevices.indexOf(supportedDevices[k]); 3580 // give a valid ID to an attached device once confirmed it is reachable 3581 if (index >= 0 && !mAvailableOutputDevices[index]->isAttached()) { 3582 mAvailableOutputDevices[index]->attach(mHwModules[i]); 3583 } 3584 } 3585 if (mPrimaryOutput == 0 && 3586 outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) { 3587 mPrimaryOutput = outputDesc; 3588 } 3589 addOutput(output, outputDesc); 3590 setOutputDevice(outputDesc, 3591 outputDesc->mDevice, 3592 true, 3593 0, 3594 NULL, 3595 address.string()); 3596 } 3597 } 3598 // open input streams needed to access attached devices to validate 3599 // mAvailableInputDevices list 3600 for (size_t j = 0; j < mHwModules[i]->mInputProfiles.size(); j++) 3601 { 3602 const sp<IOProfile> inProfile = mHwModules[i]->mInputProfiles[j]; 3603 3604 if (!inProfile->hasSupportedDevices()) { 3605 ALOGW("Input profile contains no device on module %s", mHwModules[i]->getName()); 3606 continue; 3607 } 3608 // chose first device present in profile's SupportedDevices also part of 3609 // inputDeviceTypes 3610 audio_devices_t profileType = inProfile->getSupportedDeviceForType(inputDeviceTypes); 3611 3612 if ((profileType & inputDeviceTypes) == 0) { 3613 continue; 3614 } 3615 sp<AudioInputDescriptor> inputDesc = 3616 new AudioInputDescriptor(inProfile); 3617 3618 inputDesc->mDevice = profileType; 3619 3620 // find the address 3621 DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(profileType); 3622 // the inputs vector must be of size 1, but we don't want to crash here 3623 String8 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress 3624 : String8(""); 3625 ALOGV(" for input device 0x%x using address %s", profileType, address.string()); 3626 ALOGE_IF(inputDevices.size() == 0, "Input device list is empty!"); 3627 3628 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 3629 config.sample_rate = inputDesc->mSamplingRate; 3630 config.channel_mask = inputDesc->mChannelMask; 3631 config.format = inputDesc->mFormat; 3632 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE; 3633 status_t status = mpClientInterface->openInput(inProfile->getModuleHandle(), 3634 &input, 3635 &config, 3636 &inputDesc->mDevice, 3637 address, 3638 AUDIO_SOURCE_MIC, 3639 AUDIO_INPUT_FLAG_NONE); 3640 3641 if (status == NO_ERROR) { 3642 const DeviceVector &supportedDevices = inProfile->getSupportedDevices(); 3643 for (size_t k = 0; k < supportedDevices.size(); k++) { 3644 ssize_t index = mAvailableInputDevices.indexOf(supportedDevices[k]); 3645 // give a valid ID to an attached device once confirmed it is reachable 3646 if (index >= 0) { 3647 sp<DeviceDescriptor> devDesc = mAvailableInputDevices[index]; 3648 if (!devDesc->isAttached()) { 3649 devDesc->attach(mHwModules[i]); 3650 devDesc->importAudioPort(inProfile); 3651 } 3652 } 3653 } 3654 mpClientInterface->closeInput(input); 3655 } else { 3656 ALOGW("Cannot open input stream for device %08x on hw module %s", 3657 inputDesc->mDevice, 3658 mHwModules[i]->getName()); 3659 } 3660 } 3661 } 3662 // make sure all attached devices have been allocated a unique ID 3663 for (size_t i = 0; i < mAvailableOutputDevices.size();) { 3664 if (!mAvailableOutputDevices[i]->isAttached()) { 3665 ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type()); 3666 mAvailableOutputDevices.remove(mAvailableOutputDevices[i]); 3667 continue; 3668 } 3669 // The device is now validated and can be appended to the available devices of the engine 3670 mEngine->setDeviceConnectionState(mAvailableOutputDevices[i], 3671 AUDIO_POLICY_DEVICE_STATE_AVAILABLE); 3672 i++; 3673 } 3674 for (size_t i = 0; i < mAvailableInputDevices.size();) { 3675 if (!mAvailableInputDevices[i]->isAttached()) { 3676 ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type()); 3677 mAvailableInputDevices.remove(mAvailableInputDevices[i]); 3678 continue; 3679 } 3680 // The device is now validated and can be appended to the available devices of the engine 3681 mEngine->setDeviceConnectionState(mAvailableInputDevices[i], 3682 AUDIO_POLICY_DEVICE_STATE_AVAILABLE); 3683 i++; 3684 } 3685 // make sure default device is reachable 3686 if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) { 3687 ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type()); 3688 } 3689 3690 ALOGE_IF((mPrimaryOutput == 0), "Failed to open primary output"); 3691 3692 updateDevicesAndOutputs(); 3693 3694#ifdef AUDIO_POLICY_TEST 3695 if (mPrimaryOutput != 0) { 3696 AudioParameter outputCmd = AudioParameter(); 3697 outputCmd.addInt(String8("set_id"), 0); 3698 mpClientInterface->setParameters(mPrimaryOutput->mIoHandle, outputCmd.toString()); 3699 3700 mTestDevice = AUDIO_DEVICE_OUT_SPEAKER; 3701 mTestSamplingRate = 44100; 3702 mTestFormat = AUDIO_FORMAT_PCM_16_BIT; 3703 mTestChannels = AUDIO_CHANNEL_OUT_STEREO; 3704 mTestLatencyMs = 0; 3705 mCurOutput = 0; 3706 mDirectOutput = false; 3707 for (int i = 0; i < NUM_TEST_OUTPUTS; i++) { 3708 mTestOutputs[i] = 0; 3709 } 3710 3711 const size_t SIZE = 256; 3712 char buffer[SIZE]; 3713 snprintf(buffer, SIZE, "AudioPolicyManagerTest"); 3714 run(buffer, ANDROID_PRIORITY_AUDIO); 3715 } 3716#endif //AUDIO_POLICY_TEST 3717} 3718 3719AudioPolicyManager::~AudioPolicyManager() 3720{ 3721#ifdef AUDIO_POLICY_TEST 3722 exit(); 3723#endif //AUDIO_POLICY_TEST 3724 for (size_t i = 0; i < mOutputs.size(); i++) { 3725 mpClientInterface->closeOutput(mOutputs.keyAt(i)); 3726 } 3727 for (size_t i = 0; i < mInputs.size(); i++) { 3728 mpClientInterface->closeInput(mInputs.keyAt(i)); 3729 } 3730 mAvailableOutputDevices.clear(); 3731 mAvailableInputDevices.clear(); 3732 mOutputs.clear(); 3733 mInputs.clear(); 3734 mHwModules.clear(); 3735} 3736 3737status_t AudioPolicyManager::initCheck() 3738{ 3739 return hasPrimaryOutput() ? NO_ERROR : NO_INIT; 3740} 3741 3742#ifdef AUDIO_POLICY_TEST 3743bool AudioPolicyManager::threadLoop() 3744{ 3745 ALOGV("entering threadLoop()"); 3746 while (!exitPending()) 3747 { 3748 String8 command; 3749 int valueInt; 3750 String8 value; 3751 3752 Mutex::Autolock _l(mLock); 3753 mWaitWorkCV.waitRelative(mLock, milliseconds(50)); 3754 3755 command = mpClientInterface->getParameters(0, String8("test_cmd_policy")); 3756 AudioParameter param = AudioParameter(command); 3757 3758 if (param.getInt(String8("test_cmd_policy"), valueInt) == NO_ERROR && 3759 valueInt != 0) { 3760 ALOGV("Test command %s received", command.string()); 3761 String8 target; 3762 if (param.get(String8("target"), target) != NO_ERROR) { 3763 target = "Manager"; 3764 } 3765 if (param.getInt(String8("test_cmd_policy_output"), valueInt) == NO_ERROR) { 3766 param.remove(String8("test_cmd_policy_output")); 3767 mCurOutput = valueInt; 3768 } 3769 if (param.get(String8("test_cmd_policy_direct"), value) == NO_ERROR) { 3770 param.remove(String8("test_cmd_policy_direct")); 3771 if (value == "false") { 3772 mDirectOutput = false; 3773 } else if (value == "true") { 3774 mDirectOutput = true; 3775 } 3776 } 3777 if (param.getInt(String8("test_cmd_policy_input"), valueInt) == NO_ERROR) { 3778 param.remove(String8("test_cmd_policy_input")); 3779 mTestInput = valueInt; 3780 } 3781 3782 if (param.get(String8("test_cmd_policy_format"), value) == NO_ERROR) { 3783 param.remove(String8("test_cmd_policy_format")); 3784 int format = AUDIO_FORMAT_INVALID; 3785 if (value == "PCM 16 bits") { 3786 format = AUDIO_FORMAT_PCM_16_BIT; 3787 } else if (value == "PCM 8 bits") { 3788 format = AUDIO_FORMAT_PCM_8_BIT; 3789 } else if (value == "Compressed MP3") { 3790 format = AUDIO_FORMAT_MP3; 3791 } 3792 if (format != AUDIO_FORMAT_INVALID) { 3793 if (target == "Manager") { 3794 mTestFormat = format; 3795 } else if (mTestOutputs[mCurOutput] != 0) { 3796 AudioParameter outputParam = AudioParameter(); 3797 outputParam.addInt(String8(AudioParameter::keyStreamSupportedFormats), format); 3798 mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 3799 } 3800 } 3801 } 3802 if (param.get(String8("test_cmd_policy_channels"), value) == NO_ERROR) { 3803 param.remove(String8("test_cmd_policy_channels")); 3804 int channels = 0; 3805 3806 if (value == "Channels Stereo") { 3807 channels = AUDIO_CHANNEL_OUT_STEREO; 3808 } else if (value == "Channels Mono") { 3809 channels = AUDIO_CHANNEL_OUT_MONO; 3810 } 3811 if (channels != 0) { 3812 if (target == "Manager") { 3813 mTestChannels = channels; 3814 } else if (mTestOutputs[mCurOutput] != 0) { 3815 AudioParameter outputParam = AudioParameter(); 3816 outputParam.addInt(String8(AudioParameter::keyStreamSupportedChannels), channels); 3817 mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 3818 } 3819 } 3820 } 3821 if (param.getInt(String8("test_cmd_policy_sampleRate"), valueInt) == NO_ERROR) { 3822 param.remove(String8("test_cmd_policy_sampleRate")); 3823 if (valueInt >= 0 && valueInt <= 96000) { 3824 int samplingRate = valueInt; 3825 if (target == "Manager") { 3826 mTestSamplingRate = samplingRate; 3827 } else if (mTestOutputs[mCurOutput] != 0) { 3828 AudioParameter outputParam = AudioParameter(); 3829 outputParam.addInt(String8(AudioParameter::keyStreamSupportedSamplingRates), samplingRate); 3830 mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 3831 } 3832 } 3833 } 3834 3835 if (param.get(String8("test_cmd_policy_reopen"), value) == NO_ERROR) { 3836 param.remove(String8("test_cmd_policy_reopen")); 3837 3838 mpClientInterface->closeOutput(mpClientInterface->closeOutput(mPrimaryOutput);); 3839 3840 audio_module_handle_t moduleHandle = mPrimaryOutput->getModuleHandle(); 3841 3842 removeOutput(mPrimaryOutput->mIoHandle); 3843 sp<SwAudioOutputDescriptor> outputDesc = new AudioOutputDescriptor(NULL, 3844 mpClientInterface); 3845 outputDesc->mDevice = AUDIO_DEVICE_OUT_SPEAKER; 3846 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 3847 config.sample_rate = outputDesc->mSamplingRate; 3848 config.channel_mask = outputDesc->mChannelMask; 3849 config.format = outputDesc->mFormat; 3850 audio_io_handle_t handle; 3851 status_t status = mpClientInterface->openOutput(moduleHandle, 3852 &handle, 3853 &config, 3854 &outputDesc->mDevice, 3855 String8(""), 3856 &outputDesc->mLatency, 3857 outputDesc->mFlags); 3858 if (status != NO_ERROR) { 3859 ALOGE("Failed to reopen hardware output stream, " 3860 "samplingRate: %d, format %d, channels %d", 3861 outputDesc->mSamplingRate, outputDesc->mFormat, outputDesc->mChannelMask); 3862 } else { 3863 outputDesc->mSamplingRate = config.sample_rate; 3864 outputDesc->mChannelMask = config.channel_mask; 3865 outputDesc->mFormat = config.format; 3866 mPrimaryOutput = outputDesc; 3867 AudioParameter outputCmd = AudioParameter(); 3868 outputCmd.addInt(String8("set_id"), 0); 3869 mpClientInterface->setParameters(handle, outputCmd.toString()); 3870 addOutput(handle, outputDesc); 3871 } 3872 } 3873 3874 3875 mpClientInterface->setParameters(0, String8("test_cmd_policy=")); 3876 } 3877 } 3878 return false; 3879} 3880 3881void AudioPolicyManager::exit() 3882{ 3883 { 3884 AutoMutex _l(mLock); 3885 requestExit(); 3886 mWaitWorkCV.signal(); 3887 } 3888 requestExitAndWait(); 3889} 3890 3891int AudioPolicyManager::testOutputIndex(audio_io_handle_t output) 3892{ 3893 for (int i = 0; i < NUM_TEST_OUTPUTS; i++) { 3894 if (output == mTestOutputs[i]) return i; 3895 } 3896 return 0; 3897} 3898#endif //AUDIO_POLICY_TEST 3899 3900// --- 3901 3902void AudioPolicyManager::addOutput(audio_io_handle_t output, const sp<SwAudioOutputDescriptor>& outputDesc) 3903{ 3904 outputDesc->setIoHandle(output); 3905 mOutputs.add(output, outputDesc); 3906 updateMono(output); // update mono status when adding to output list 3907 selectOutputForMusicEffects(); 3908 nextAudioPortGeneration(); 3909} 3910 3911void AudioPolicyManager::removeOutput(audio_io_handle_t output) 3912{ 3913 mOutputs.removeItem(output); 3914 selectOutputForMusicEffects(); 3915} 3916 3917void AudioPolicyManager::addInput(audio_io_handle_t input, const sp<AudioInputDescriptor>& inputDesc) 3918{ 3919 inputDesc->setIoHandle(input); 3920 mInputs.add(input, inputDesc); 3921 nextAudioPortGeneration(); 3922} 3923 3924void AudioPolicyManager::findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/, 3925 const audio_devices_t device /*in*/, 3926 const String8& address /*in*/, 3927 SortedVector<audio_io_handle_t>& outputs /*out*/) { 3928 sp<DeviceDescriptor> devDesc = 3929 desc->mProfile->getSupportedDeviceByAddress(device, address); 3930 if (devDesc != 0) { 3931 ALOGV("findIoHandlesByAddress(): adding opened output %d on same address %s", 3932 desc->mIoHandle, address.string()); 3933 outputs.add(desc->mIoHandle); 3934 } 3935} 3936 3937status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc, 3938 audio_policy_dev_state_t state, 3939 SortedVector<audio_io_handle_t>& outputs, 3940 const String8& address) 3941{ 3942 audio_devices_t device = devDesc->type(); 3943 sp<SwAudioOutputDescriptor> desc; 3944 3945 if (audio_device_is_digital(device)) { 3946 // erase all current sample rates, formats and channel masks 3947 devDesc->clearAudioProfiles(); 3948 } 3949 3950 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) { 3951 // first list already open outputs that can be routed to this device 3952 for (size_t i = 0; i < mOutputs.size(); i++) { 3953 desc = mOutputs.valueAt(i); 3954 if (!desc->isDuplicated() && (desc->supportedDevices() & device)) { 3955 if (!device_distinguishes_on_address(device)) { 3956 ALOGV("checkOutputsForDevice(): adding opened output %d", mOutputs.keyAt(i)); 3957 outputs.add(mOutputs.keyAt(i)); 3958 } else { 3959 ALOGV(" checking address match due to device 0x%x", device); 3960 findIoHandlesByAddress(desc, device, address, outputs); 3961 } 3962 } 3963 } 3964 // then look for output profiles that can be routed to this device 3965 SortedVector< sp<IOProfile> > profiles; 3966 for (size_t i = 0; i < mHwModules.size(); i++) 3967 { 3968 if (mHwModules[i]->mHandle == 0) { 3969 continue; 3970 } 3971 for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++) 3972 { 3973 sp<IOProfile> profile = mHwModules[i]->mOutputProfiles[j]; 3974 if (profile->supportDevice(device)) { 3975 if (!device_distinguishes_on_address(device) || 3976 profile->supportDeviceAddress(address)) { 3977 profiles.add(profile); 3978 ALOGV("checkOutputsForDevice(): adding profile %zu from module %zu", j, i); 3979 } 3980 } 3981 } 3982 } 3983 3984 ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size()); 3985 3986 if (profiles.isEmpty() && outputs.isEmpty()) { 3987 ALOGW("checkOutputsForDevice(): No output available for device %04x", device); 3988 return BAD_VALUE; 3989 } 3990 3991 // open outputs for matching profiles if needed. Direct outputs are also opened to 3992 // query for dynamic parameters and will be closed later by setDeviceConnectionState() 3993 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) { 3994 sp<IOProfile> profile = profiles[profile_index]; 3995 3996 // nothing to do if one output is already opened for this profile 3997 size_t j; 3998 for (j = 0; j < outputs.size(); j++) { 3999 desc = mOutputs.valueFor(outputs.itemAt(j)); 4000 if (!desc->isDuplicated() && desc->mProfile == profile) { 4001 // matching profile: save the sample rates, format and channel masks supported 4002 // by the profile in our device descriptor 4003 if (audio_device_is_digital(device)) { 4004 devDesc->importAudioPort(profile); 4005 } 4006 break; 4007 } 4008 } 4009 if (j != outputs.size()) { 4010 continue; 4011 } 4012 4013 ALOGV("opening output for device %08x with params %s profile %p", 4014 device, address.string(), profile.get()); 4015 desc = new SwAudioOutputDescriptor(profile, mpClientInterface); 4016 desc->mDevice = device; 4017 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 4018 config.sample_rate = desc->mSamplingRate; 4019 config.channel_mask = desc->mChannelMask; 4020 config.format = desc->mFormat; 4021 config.offload_info.sample_rate = desc->mSamplingRate; 4022 config.offload_info.channel_mask = desc->mChannelMask; 4023 config.offload_info.format = desc->mFormat; 4024 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE; 4025 status_t status = mpClientInterface->openOutput(profile->getModuleHandle(), 4026 &output, 4027 &config, 4028 &desc->mDevice, 4029 address, 4030 &desc->mLatency, 4031 desc->mFlags); 4032 if (status == NO_ERROR) { 4033 desc->mSamplingRate = config.sample_rate; 4034 desc->mChannelMask = config.channel_mask; 4035 desc->mFormat = config.format; 4036 4037 // Here is where the out_set_parameters() for card & device gets called 4038 if (!address.isEmpty()) { 4039 char *param = audio_device_address_to_parameter(device, address); 4040 mpClientInterface->setParameters(output, String8(param)); 4041 free(param); 4042 } 4043 updateAudioProfiles(device, output, profile->getAudioProfiles()); 4044 if (!profile->hasValidAudioProfile()) { 4045 ALOGW("checkOutputsForDevice() missing param"); 4046 mpClientInterface->closeOutput(output); 4047 output = AUDIO_IO_HANDLE_NONE; 4048 } else if (profile->hasDynamicAudioProfile()) { 4049 mpClientInterface->closeOutput(output); 4050 output = AUDIO_IO_HANDLE_NONE; 4051 profile->pickAudioProfile(config.sample_rate, config.channel_mask, config.format); 4052 config.offload_info.sample_rate = config.sample_rate; 4053 config.offload_info.channel_mask = config.channel_mask; 4054 config.offload_info.format = config.format; 4055 status = mpClientInterface->openOutput(profile->getModuleHandle(), 4056 &output, 4057 &config, 4058 &desc->mDevice, 4059 address, 4060 &desc->mLatency, 4061 desc->mFlags); 4062 if (status == NO_ERROR) { 4063 desc->mSamplingRate = config.sample_rate; 4064 desc->mChannelMask = config.channel_mask; 4065 desc->mFormat = config.format; 4066 } else { 4067 output = AUDIO_IO_HANDLE_NONE; 4068 } 4069 } 4070 4071 if (output != AUDIO_IO_HANDLE_NONE) { 4072 addOutput(output, desc); 4073 if (device_distinguishes_on_address(device) && address != "0") { 4074 sp<AudioPolicyMix> policyMix; 4075 if (mPolicyMixes.getAudioPolicyMix(address, policyMix) != NO_ERROR) { 4076 ALOGE("checkOutputsForDevice() cannot find policy for address %s", 4077 address.string()); 4078 } 4079 policyMix->setOutput(desc); 4080 desc->mPolicyMix = policyMix->getMix(); 4081 4082 } else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) && 4083 hasPrimaryOutput()) { 4084 // no duplicated output for direct outputs and 4085 // outputs used by dynamic policy mixes 4086 audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE; 4087 4088 // set initial stream volume for device 4089 applyStreamVolumes(desc, device, 0, true); 4090 4091 //TODO: configure audio effect output stage here 4092 4093 // open a duplicating output thread for the new output and the primary output 4094 duplicatedOutput = 4095 mpClientInterface->openDuplicateOutput(output, 4096 mPrimaryOutput->mIoHandle); 4097 if (duplicatedOutput != AUDIO_IO_HANDLE_NONE) { 4098 // add duplicated output descriptor 4099 sp<SwAudioOutputDescriptor> dupOutputDesc = 4100 new SwAudioOutputDescriptor(NULL, mpClientInterface); 4101 dupOutputDesc->mOutput1 = mPrimaryOutput; 4102 dupOutputDesc->mOutput2 = desc; 4103 dupOutputDesc->mSamplingRate = desc->mSamplingRate; 4104 dupOutputDesc->mFormat = desc->mFormat; 4105 dupOutputDesc->mChannelMask = desc->mChannelMask; 4106 dupOutputDesc->mLatency = desc->mLatency; 4107 addOutput(duplicatedOutput, dupOutputDesc); 4108 applyStreamVolumes(dupOutputDesc, device, 0, true); 4109 } else { 4110 ALOGW("checkOutputsForDevice() could not open dup output for %d and %d", 4111 mPrimaryOutput->mIoHandle, output); 4112 mpClientInterface->closeOutput(output); 4113 removeOutput(output); 4114 nextAudioPortGeneration(); 4115 output = AUDIO_IO_HANDLE_NONE; 4116 } 4117 } 4118 } 4119 } else { 4120 output = AUDIO_IO_HANDLE_NONE; 4121 } 4122 if (output == AUDIO_IO_HANDLE_NONE) { 4123 ALOGW("checkOutputsForDevice() could not open output for device %x", device); 4124 profiles.removeAt(profile_index); 4125 profile_index--; 4126 } else { 4127 outputs.add(output); 4128 // Load digital format info only for digital devices 4129 if (audio_device_is_digital(device)) { 4130 devDesc->importAudioPort(profile); 4131 } 4132 4133 if (device_distinguishes_on_address(device)) { 4134 ALOGV("checkOutputsForDevice(): setOutputDevice(dev=0x%x, addr=%s)", 4135 device, address.string()); 4136 setOutputDevice(desc, device, true/*force*/, 0/*delay*/, 4137 NULL/*patch handle*/, address.string()); 4138 } 4139 ALOGV("checkOutputsForDevice(): adding output %d", output); 4140 } 4141 } 4142 4143 if (profiles.isEmpty()) { 4144 ALOGW("checkOutputsForDevice(): No output available for device %04x", device); 4145 return BAD_VALUE; 4146 } 4147 } else { // Disconnect 4148 // check if one opened output is not needed any more after disconnecting one device 4149 for (size_t i = 0; i < mOutputs.size(); i++) { 4150 desc = mOutputs.valueAt(i); 4151 if (!desc->isDuplicated()) { 4152 // exact match on device 4153 if (device_distinguishes_on_address(device) && 4154 (desc->supportedDevices() == device)) { 4155 findIoHandlesByAddress(desc, device, address, outputs); 4156 } else if (!(desc->supportedDevices() & mAvailableOutputDevices.types())) { 4157 ALOGV("checkOutputsForDevice(): disconnecting adding output %d", 4158 mOutputs.keyAt(i)); 4159 outputs.add(mOutputs.keyAt(i)); 4160 } 4161 } 4162 } 4163 // Clear any profiles associated with the disconnected device. 4164 for (size_t i = 0; i < mHwModules.size(); i++) 4165 { 4166 if (mHwModules[i]->mHandle == 0) { 4167 continue; 4168 } 4169 for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++) 4170 { 4171 sp<IOProfile> profile = mHwModules[i]->mOutputProfiles[j]; 4172 if (profile->supportDevice(device)) { 4173 ALOGV("checkOutputsForDevice(): " 4174 "clearing direct output profile %zu on module %zu", j, i); 4175 profile->clearAudioProfiles(); 4176 } 4177 } 4178 } 4179 } 4180 return NO_ERROR; 4181} 4182 4183status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& devDesc, 4184 audio_policy_dev_state_t state, 4185 SortedVector<audio_io_handle_t>& inputs, 4186 const String8& address) 4187{ 4188 audio_devices_t device = devDesc->type(); 4189 sp<AudioInputDescriptor> desc; 4190 4191 if (audio_device_is_digital(device)) { 4192 // erase all current sample rates, formats and channel masks 4193 devDesc->clearAudioProfiles(); 4194 } 4195 4196 if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) { 4197 // first list already open inputs that can be routed to this device 4198 for (size_t input_index = 0; input_index < mInputs.size(); input_index++) { 4199 desc = mInputs.valueAt(input_index); 4200 if (desc->mProfile->supportDevice(device)) { 4201 ALOGV("checkInputsForDevice(): adding opened input %d", mInputs.keyAt(input_index)); 4202 inputs.add(mInputs.keyAt(input_index)); 4203 } 4204 } 4205 4206 // then look for input profiles that can be routed to this device 4207 SortedVector< sp<IOProfile> > profiles; 4208 for (size_t module_idx = 0; module_idx < mHwModules.size(); module_idx++) 4209 { 4210 if (mHwModules[module_idx]->mHandle == 0) { 4211 continue; 4212 } 4213 for (size_t profile_index = 0; 4214 profile_index < mHwModules[module_idx]->mInputProfiles.size(); 4215 profile_index++) 4216 { 4217 sp<IOProfile> profile = mHwModules[module_idx]->mInputProfiles[profile_index]; 4218 4219 if (profile->supportDevice(device)) { 4220 if (!device_distinguishes_on_address(device) || 4221 profile->supportDeviceAddress(address)) { 4222 profiles.add(profile); 4223 ALOGV("checkInputsForDevice(): adding profile %zu from module %zu", 4224 profile_index, module_idx); 4225 } 4226 } 4227 } 4228 } 4229 4230 if (profiles.isEmpty() && inputs.isEmpty()) { 4231 ALOGW("checkInputsForDevice(): No input available for device 0x%X", device); 4232 return BAD_VALUE; 4233 } 4234 4235 // open inputs for matching profiles if needed. Direct inputs are also opened to 4236 // query for dynamic parameters and will be closed later by setDeviceConnectionState() 4237 for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) { 4238 4239 sp<IOProfile> profile = profiles[profile_index]; 4240 // nothing to do if one input is already opened for this profile 4241 size_t input_index; 4242 for (input_index = 0; input_index < mInputs.size(); input_index++) { 4243 desc = mInputs.valueAt(input_index); 4244 if (desc->mProfile == profile) { 4245 if (audio_device_is_digital(device)) { 4246 devDesc->importAudioPort(profile); 4247 } 4248 break; 4249 } 4250 } 4251 if (input_index != mInputs.size()) { 4252 continue; 4253 } 4254 4255 ALOGV("opening input for device 0x%X with params %s", device, address.string()); 4256 desc = new AudioInputDescriptor(profile); 4257 desc->mDevice = device; 4258 audio_config_t config = AUDIO_CONFIG_INITIALIZER; 4259 config.sample_rate = desc->mSamplingRate; 4260 config.channel_mask = desc->mChannelMask; 4261 config.format = desc->mFormat; 4262 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE; 4263 status_t status = mpClientInterface->openInput(profile->getModuleHandle(), 4264 &input, 4265 &config, 4266 &desc->mDevice, 4267 address, 4268 AUDIO_SOURCE_MIC, 4269 AUDIO_INPUT_FLAG_NONE /*FIXME*/); 4270 4271 if (status == NO_ERROR) { 4272 desc->mSamplingRate = config.sample_rate; 4273 desc->mChannelMask = config.channel_mask; 4274 desc->mFormat = config.format; 4275 4276 if (!address.isEmpty()) { 4277 char *param = audio_device_address_to_parameter(device, address); 4278 mpClientInterface->setParameters(input, String8(param)); 4279 free(param); 4280 } 4281 updateAudioProfiles(device, input, profile->getAudioProfiles()); 4282 if (!profile->hasValidAudioProfile()) { 4283 ALOGW("checkInputsForDevice() direct input missing param"); 4284 mpClientInterface->closeInput(input); 4285 input = AUDIO_IO_HANDLE_NONE; 4286 } 4287 4288 if (input != 0) { 4289 addInput(input, desc); 4290 } 4291 } // endif input != 0 4292 4293 if (input == AUDIO_IO_HANDLE_NONE) { 4294 ALOGW("checkInputsForDevice() could not open input for device 0x%X", device); 4295 profiles.removeAt(profile_index); 4296 profile_index--; 4297 } else { 4298 inputs.add(input); 4299 if (audio_device_is_digital(device)) { 4300 devDesc->importAudioPort(profile); 4301 } 4302 ALOGV("checkInputsForDevice(): adding input %d", input); 4303 } 4304 } // end scan profiles 4305 4306 if (profiles.isEmpty()) { 4307 ALOGW("checkInputsForDevice(): No input available for device 0x%X", device); 4308 return BAD_VALUE; 4309 } 4310 } else { 4311 // Disconnect 4312 // check if one opened input is not needed any more after disconnecting one device 4313 for (size_t input_index = 0; input_index < mInputs.size(); input_index++) { 4314 desc = mInputs.valueAt(input_index); 4315 if (!(desc->mProfile->supportDevice(mAvailableInputDevices.types()))) { 4316 ALOGV("checkInputsForDevice(): disconnecting adding input %d", 4317 mInputs.keyAt(input_index)); 4318 inputs.add(mInputs.keyAt(input_index)); 4319 } 4320 } 4321 // Clear any profiles associated with the disconnected device. 4322 for (size_t module_index = 0; module_index < mHwModules.size(); module_index++) { 4323 if (mHwModules[module_index]->mHandle == 0) { 4324 continue; 4325 } 4326 for (size_t profile_index = 0; 4327 profile_index < mHwModules[module_index]->mInputProfiles.size(); 4328 profile_index++) { 4329 sp<IOProfile> profile = mHwModules[module_index]->mInputProfiles[profile_index]; 4330 if (profile->supportDevice(device)) { 4331 ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %zu", 4332 profile_index, module_index); 4333 profile->clearAudioProfiles(); 4334 } 4335 } 4336 } 4337 } // end disconnect 4338 4339 return NO_ERROR; 4340} 4341 4342 4343void AudioPolicyManager::closeOutput(audio_io_handle_t output) 4344{ 4345 ALOGV("closeOutput(%d)", output); 4346 4347 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output); 4348 if (outputDesc == NULL) { 4349 ALOGW("closeOutput() unknown output %d", output); 4350 return; 4351 } 4352 mPolicyMixes.closeOutput(outputDesc); 4353 4354 // look for duplicated outputs connected to the output being removed. 4355 for (size_t i = 0; i < mOutputs.size(); i++) { 4356 sp<SwAudioOutputDescriptor> dupOutputDesc = mOutputs.valueAt(i); 4357 if (dupOutputDesc->isDuplicated() && 4358 (dupOutputDesc->mOutput1 == outputDesc || 4359 dupOutputDesc->mOutput2 == outputDesc)) { 4360 sp<AudioOutputDescriptor> outputDesc2; 4361 if (dupOutputDesc->mOutput1 == outputDesc) { 4362 outputDesc2 = dupOutputDesc->mOutput2; 4363 } else { 4364 outputDesc2 = dupOutputDesc->mOutput1; 4365 } 4366 // As all active tracks on duplicated output will be deleted, 4367 // and as they were also referenced on the other output, the reference 4368 // count for their stream type must be adjusted accordingly on 4369 // the other output. 4370 for (int j = 0; j < AUDIO_STREAM_CNT; j++) { 4371 int refCount = dupOutputDesc->mRefCount[j]; 4372 outputDesc2->changeRefCount((audio_stream_type_t)j,-refCount); 4373 } 4374 audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i); 4375 ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput); 4376 4377 mpClientInterface->closeOutput(duplicatedOutput); 4378 removeOutput(duplicatedOutput); 4379 } 4380 } 4381 4382 nextAudioPortGeneration(); 4383 4384 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle()); 4385 if (index >= 0) { 4386 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index); 4387 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 4388 mAudioPatches.removeItemsAt(index); 4389 mpClientInterface->onAudioPatchListUpdate(); 4390 } 4391 4392 AudioParameter param; 4393 param.add(String8("closing"), String8("true")); 4394 mpClientInterface->setParameters(output, param.toString()); 4395 4396 mpClientInterface->closeOutput(output); 4397 removeOutput(output); 4398 mPreviousOutputs = mOutputs; 4399} 4400 4401void AudioPolicyManager::closeInput(audio_io_handle_t input) 4402{ 4403 ALOGV("closeInput(%d)", input); 4404 4405 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input); 4406 if (inputDesc == NULL) { 4407 ALOGW("closeInput() unknown input %d", input); 4408 return; 4409 } 4410 4411 nextAudioPortGeneration(); 4412 4413 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle()); 4414 if (index >= 0) { 4415 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index); 4416 (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 4417 mAudioPatches.removeItemsAt(index); 4418 mpClientInterface->onAudioPatchListUpdate(); 4419 } 4420 4421 mpClientInterface->closeInput(input); 4422 mInputs.removeItem(input); 4423} 4424 4425SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevice( 4426 audio_devices_t device, 4427 const SwAudioOutputCollection& openOutputs) 4428{ 4429 SortedVector<audio_io_handle_t> outputs; 4430 4431 ALOGVV("getOutputsForDevice() device %04x", device); 4432 for (size_t i = 0; i < openOutputs.size(); i++) { 4433 ALOGVV("output %zu isDuplicated=%d device=%04x", 4434 i, openOutputs.valueAt(i)->isDuplicated(), 4435 openOutputs.valueAt(i)->supportedDevices()); 4436 if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) { 4437 ALOGVV("getOutputsForDevice() found output %d", openOutputs.keyAt(i)); 4438 outputs.add(openOutputs.keyAt(i)); 4439 } 4440 } 4441 return outputs; 4442} 4443 4444bool AudioPolicyManager::vectorsEqual(SortedVector<audio_io_handle_t>& outputs1, 4445 SortedVector<audio_io_handle_t>& outputs2) 4446{ 4447 if (outputs1.size() != outputs2.size()) { 4448 return false; 4449 } 4450 for (size_t i = 0; i < outputs1.size(); i++) { 4451 if (outputs1[i] != outputs2[i]) { 4452 return false; 4453 } 4454 } 4455 return true; 4456} 4457 4458void AudioPolicyManager::checkOutputForStrategy(routing_strategy strategy) 4459{ 4460 audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/); 4461 audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/); 4462 SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs); 4463 SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs); 4464 4465 // also take into account external policy-related changes: add all outputs which are 4466 // associated with policies in the "before" and "after" output vectors 4467 ALOGVV("checkOutputForStrategy(): policy related outputs"); 4468 for (size_t i = 0 ; i < mPreviousOutputs.size() ; i++) { 4469 const sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueAt(i); 4470 if (desc != 0 && desc->mPolicyMix != NULL) { 4471 srcOutputs.add(desc->mIoHandle); 4472 ALOGVV(" previous outputs: adding %d", desc->mIoHandle); 4473 } 4474 } 4475 for (size_t i = 0 ; i < mOutputs.size() ; i++) { 4476 const sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 4477 if (desc != 0 && desc->mPolicyMix != NULL) { 4478 dstOutputs.add(desc->mIoHandle); 4479 ALOGVV(" new outputs: adding %d", desc->mIoHandle); 4480 } 4481 } 4482 4483 if (!vectorsEqual(srcOutputs,dstOutputs)) { 4484 ALOGV("checkOutputForStrategy() strategy %d, moving from output %d to output %d", 4485 strategy, srcOutputs[0], dstOutputs[0]); 4486 // mute strategy while moving tracks from one output to another 4487 for (size_t i = 0; i < srcOutputs.size(); i++) { 4488 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(srcOutputs[i]); 4489 if (isStrategyActive(desc, strategy)) { 4490 setStrategyMute(strategy, true, desc); 4491 setStrategyMute(strategy, false, desc, MUTE_TIME_MS, newDevice); 4492 } 4493 sp<AudioSourceDescriptor> source = 4494 getSourceForStrategyOnOutput(srcOutputs[i], strategy); 4495 if (source != 0){ 4496 connectAudioSource(source); 4497 } 4498 } 4499 4500 // Move effects associated to this strategy from previous output to new output 4501 if (strategy == STRATEGY_MEDIA) { 4502 selectOutputForMusicEffects(); 4503 } 4504 // Move tracks associated to this strategy from previous output to new output 4505 for (int i = 0; i < AUDIO_STREAM_FOR_POLICY_CNT; i++) { 4506 if (getStrategy((audio_stream_type_t)i) == strategy) { 4507 mpClientInterface->invalidateStream((audio_stream_type_t)i); 4508 } 4509 } 4510 } 4511} 4512 4513void AudioPolicyManager::checkOutputForAllStrategies() 4514{ 4515 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) 4516 checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE); 4517 checkOutputForStrategy(STRATEGY_PHONE); 4518 if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) 4519 checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE); 4520 checkOutputForStrategy(STRATEGY_SONIFICATION); 4521 checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL); 4522 checkOutputForStrategy(STRATEGY_ACCESSIBILITY); 4523 checkOutputForStrategy(STRATEGY_MEDIA); 4524 checkOutputForStrategy(STRATEGY_DTMF); 4525 checkOutputForStrategy(STRATEGY_REROUTING); 4526} 4527 4528void AudioPolicyManager::checkA2dpSuspend() 4529{ 4530 audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput(); 4531 if (a2dpOutput == 0) { 4532 mA2dpSuspended = false; 4533 return; 4534 } 4535 4536 bool isScoConnected = 4537 ((mAvailableInputDevices.types() & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET & 4538 ~AUDIO_DEVICE_BIT_IN) != 0) || 4539 ((mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_ALL_SCO) != 0); 4540 4541 // if suspended, restore A2DP output if: 4542 // ((SCO device is NOT connected) || 4543 // ((forced usage communication is NOT SCO) && (forced usage for record is NOT SCO) && 4544 // (phone state is NOT in call) && (phone state is NOT ringing))) 4545 // 4546 // if not suspended, suspend A2DP output if: 4547 // (SCO device is connected) && 4548 // ((forced usage for communication is SCO) || (forced usage for record is SCO) || 4549 // ((phone state is in call) || (phone state is ringing))) 4550 // 4551 if (mA2dpSuspended) { 4552 if (!isScoConnected || 4553 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) != 4554 AUDIO_POLICY_FORCE_BT_SCO) && 4555 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) != 4556 AUDIO_POLICY_FORCE_BT_SCO) && 4557 (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) && 4558 (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) { 4559 4560 mpClientInterface->restoreOutput(a2dpOutput); 4561 mA2dpSuspended = false; 4562 } 4563 } else { 4564 if (isScoConnected && 4565 ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) == 4566 AUDIO_POLICY_FORCE_BT_SCO) || 4567 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) == 4568 AUDIO_POLICY_FORCE_BT_SCO) || 4569 (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) || 4570 (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) { 4571 4572 mpClientInterface->suspendOutput(a2dpOutput); 4573 mA2dpSuspended = true; 4574 } 4575 } 4576} 4577 4578audio_devices_t AudioPolicyManager::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 4579 bool fromCache) 4580{ 4581 audio_devices_t device = AUDIO_DEVICE_NONE; 4582 4583 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle()); 4584 if (index >= 0) { 4585 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index); 4586 if (patchDesc->mUid != mUidCached) { 4587 ALOGV("getNewOutputDevice() device %08x forced by patch %d", 4588 outputDesc->device(), outputDesc->getPatchHandle()); 4589 return outputDesc->device(); 4590 } 4591 } 4592 4593 // check the following by order of priority to request a routing change if necessary: 4594 // 1: the strategy enforced audible is active and enforced on the output: 4595 // use device for strategy enforced audible 4596 // 2: we are in call or the strategy phone is active on the output: 4597 // use device for strategy phone 4598 // 3: the strategy for enforced audible is active but not enforced on the output: 4599 // use the device for strategy enforced audible 4600 // 4: the strategy sonification is active on the output: 4601 // use device for strategy sonification 4602 // 5: the strategy accessibility is active on the output: 4603 // use device for strategy accessibility 4604 // 6: the strategy "respectful" sonification is active on the output: 4605 // use device for strategy "respectful" sonification 4606 // 7: the strategy media is active on the output: 4607 // use device for strategy media 4608 // 8: the strategy DTMF is active on the output: 4609 // use device for strategy DTMF 4610 // 9: the strategy for beacon, a.k.a. "transmitted through speaker" is active on the output: 4611 // use device for strategy t-t-s 4612 if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) && 4613 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) { 4614 device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache); 4615 } else if (isInCall() || 4616 isStrategyActive(outputDesc, STRATEGY_PHONE)) { 4617 device = getDeviceForStrategy(STRATEGY_PHONE, fromCache); 4618 } else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) { 4619 device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache); 4620 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION)) { 4621 device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache); 4622 } else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) { 4623 device = getDeviceForStrategy(STRATEGY_ACCESSIBILITY, fromCache); 4624 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)) { 4625 device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache); 4626 } else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) { 4627 device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache); 4628 } else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) { 4629 device = getDeviceForStrategy(STRATEGY_DTMF, fromCache); 4630 } else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) { 4631 device = getDeviceForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache); 4632 } else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) { 4633 device = getDeviceForStrategy(STRATEGY_REROUTING, fromCache); 4634 } 4635 4636 ALOGV("getNewOutputDevice() selected device %x", device); 4637 return device; 4638} 4639 4640audio_devices_t AudioPolicyManager::getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc) 4641{ 4642 audio_devices_t device = AUDIO_DEVICE_NONE; 4643 4644 ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle()); 4645 if (index >= 0) { 4646 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index); 4647 if (patchDesc->mUid != mUidCached) { 4648 ALOGV("getNewInputDevice() device %08x forced by patch %d", 4649 inputDesc->mDevice, inputDesc->getPatchHandle()); 4650 return inputDesc->mDevice; 4651 } 4652 } 4653 4654 audio_source_t source = inputDesc->getHighestPrioritySource(true /*activeOnly*/); 4655 if (isInCall()) { 4656 device = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION); 4657 } else if (source != AUDIO_SOURCE_DEFAULT) { 4658 device = getDeviceAndMixForInputSource(source); 4659 } 4660 4661 return device; 4662} 4663 4664bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1, 4665 audio_stream_type_t stream2) { 4666 return (stream1 == stream2); 4667} 4668 4669uint32_t AudioPolicyManager::getStrategyForStream(audio_stream_type_t stream) { 4670 return (uint32_t)getStrategy(stream); 4671} 4672 4673audio_devices_t AudioPolicyManager::getDevicesForStream(audio_stream_type_t stream) { 4674 // By checking the range of stream before calling getStrategy, we avoid 4675 // getStrategy's behavior for invalid streams. getStrategy would do a ALOGE 4676 // and then return STRATEGY_MEDIA, but we want to return the empty set. 4677 if (stream < (audio_stream_type_t) 0 || stream >= AUDIO_STREAM_PUBLIC_CNT) { 4678 return AUDIO_DEVICE_NONE; 4679 } 4680 audio_devices_t devices = AUDIO_DEVICE_NONE; 4681 for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) { 4682 if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) { 4683 continue; 4684 } 4685 routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream); 4686 audio_devices_t curDevices = 4687 getDeviceForStrategy((routing_strategy)curStrategy, false /*fromCache*/); 4688 SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(curDevices, mOutputs); 4689 for (size_t i = 0; i < outputs.size(); i++) { 4690 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(outputs[i]); 4691 if (outputDesc->isStreamActive((audio_stream_type_t)curStream)) { 4692 curDevices |= outputDesc->device(); 4693 } 4694 } 4695 devices |= curDevices; 4696 } 4697 4698 /*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it 4699 and doesn't really need to.*/ 4700 if (devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) { 4701 devices |= AUDIO_DEVICE_OUT_SPEAKER; 4702 devices &= ~AUDIO_DEVICE_OUT_SPEAKER_SAFE; 4703 } 4704 return devices; 4705} 4706 4707routing_strategy AudioPolicyManager::getStrategy(audio_stream_type_t stream) const 4708{ 4709 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH,"getStrategy() called for AUDIO_STREAM_PATCH"); 4710 return mEngine->getStrategyForStream(stream); 4711} 4712 4713uint32_t AudioPolicyManager::getStrategyForAttr(const audio_attributes_t *attr) { 4714 // flags to strategy mapping 4715 if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) { 4716 return (uint32_t) STRATEGY_TRANSMITTED_THROUGH_SPEAKER; 4717 } 4718 if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) { 4719 return (uint32_t) STRATEGY_ENFORCED_AUDIBLE; 4720 } 4721 // usage to strategy mapping 4722 return static_cast<uint32_t>(mEngine->getStrategyForUsage(attr->usage)); 4723} 4724 4725void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) { 4726 switch(stream) { 4727 case AUDIO_STREAM_MUSIC: 4728 checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL); 4729 updateDevicesAndOutputs(); 4730 break; 4731 default: 4732 break; 4733 } 4734} 4735 4736uint32_t AudioPolicyManager::handleEventForBeacon(int event) { 4737 4738 // skip beacon mute management if a dedicated TTS output is available 4739 if (mTtsOutputAvailable) { 4740 return 0; 4741 } 4742 4743 switch(event) { 4744 case STARTING_OUTPUT: 4745 mBeaconMuteRefCount++; 4746 break; 4747 case STOPPING_OUTPUT: 4748 if (mBeaconMuteRefCount > 0) { 4749 mBeaconMuteRefCount--; 4750 } 4751 break; 4752 case STARTING_BEACON: 4753 mBeaconPlayingRefCount++; 4754 break; 4755 case STOPPING_BEACON: 4756 if (mBeaconPlayingRefCount > 0) { 4757 mBeaconPlayingRefCount--; 4758 } 4759 break; 4760 } 4761 4762 if (mBeaconMuteRefCount > 0) { 4763 // any playback causes beacon to be muted 4764 return setBeaconMute(true); 4765 } else { 4766 // no other playback: unmute when beacon starts playing, mute when it stops 4767 return setBeaconMute(mBeaconPlayingRefCount == 0); 4768 } 4769} 4770 4771uint32_t AudioPolicyManager::setBeaconMute(bool mute) { 4772 ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d", 4773 mute, mBeaconMuteRefCount, mBeaconPlayingRefCount); 4774 // keep track of muted state to avoid repeating mute/unmute operations 4775 if (mBeaconMuted != mute) { 4776 // mute/unmute AUDIO_STREAM_TTS on all outputs 4777 ALOGV("\t muting %d", mute); 4778 uint32_t maxLatency = 0; 4779 for (size_t i = 0; i < mOutputs.size(); i++) { 4780 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i); 4781 setStreamMute(AUDIO_STREAM_TTS, mute/*on*/, 4782 desc, 4783 0 /*delay*/, AUDIO_DEVICE_NONE); 4784 const uint32_t latency = desc->latency() * 2; 4785 if (latency > maxLatency) { 4786 maxLatency = latency; 4787 } 4788 } 4789 mBeaconMuted = mute; 4790 return maxLatency; 4791 } 4792 return 0; 4793} 4794 4795audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy, 4796 bool fromCache) 4797{ 4798 // Routing 4799 // see if we have an explicit route 4800 // scan the whole RouteMap, for each entry, convert the stream type to a strategy 4801 // (getStrategy(stream)). 4802 // if the strategy from the stream type in the RouteMap is the same as the argument above, 4803 // and activity count is non-zero 4804 // the device = the device from the descriptor in the RouteMap, and exit. 4805 for (size_t routeIndex = 0; routeIndex < mOutputRoutes.size(); routeIndex++) { 4806 sp<SessionRoute> route = mOutputRoutes.valueAt(routeIndex); 4807 routing_strategy routeStrategy = getStrategy(route->mStreamType); 4808 if ((routeStrategy == strategy) && route->isActive()) { 4809 return route->mDeviceDescriptor->type(); 4810 } 4811 } 4812 4813 if (fromCache) { 4814 ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x", 4815 strategy, mDeviceForStrategy[strategy]); 4816 return mDeviceForStrategy[strategy]; 4817 } 4818 return mEngine->getDeviceForStrategy(strategy); 4819} 4820 4821void AudioPolicyManager::updateDevicesAndOutputs() 4822{ 4823 for (int i = 0; i < NUM_STRATEGIES; i++) { 4824 mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/); 4825 } 4826 mPreviousOutputs = mOutputs; 4827} 4828 4829uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc, 4830 audio_devices_t prevDevice, 4831 uint32_t delayMs) 4832{ 4833 // mute/unmute strategies using an incompatible device combination 4834 // if muting, wait for the audio in pcm buffer to be drained before proceeding 4835 // if unmuting, unmute only after the specified delay 4836 if (outputDesc->isDuplicated()) { 4837 return 0; 4838 } 4839 4840 uint32_t muteWaitMs = 0; 4841 audio_devices_t device = outputDesc->device(); 4842 bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2); 4843 4844 for (size_t i = 0; i < NUM_STRATEGIES; i++) { 4845 audio_devices_t curDevice = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/); 4846 curDevice = curDevice & outputDesc->supportedDevices(); 4847 bool mute = shouldMute && (curDevice & device) && (curDevice != device); 4848 bool doMute = false; 4849 4850 if (mute && !outputDesc->mStrategyMutedByDevice[i]) { 4851 doMute = true; 4852 outputDesc->mStrategyMutedByDevice[i] = true; 4853 } else if (!mute && outputDesc->mStrategyMutedByDevice[i]){ 4854 doMute = true; 4855 outputDesc->mStrategyMutedByDevice[i] = false; 4856 } 4857 if (doMute) { 4858 for (size_t j = 0; j < mOutputs.size(); j++) { 4859 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j); 4860 // skip output if it does not share any device with current output 4861 if ((desc->supportedDevices() & outputDesc->supportedDevices()) 4862 == AUDIO_DEVICE_NONE) { 4863 continue; 4864 } 4865 ALOGVV("checkDeviceMuteStrategies() %s strategy %zu (curDevice %04x)", 4866 mute ? "muting" : "unmuting", i, curDevice); 4867 setStrategyMute((routing_strategy)i, mute, desc, mute ? 0 : delayMs); 4868 if (isStrategyActive(desc, (routing_strategy)i)) { 4869 if (mute) { 4870 // FIXME: should not need to double latency if volume could be applied 4871 // immediately by the audioflinger mixer. We must account for the delay 4872 // between now and the next time the audioflinger thread for this output 4873 // will process a buffer (which corresponds to one buffer size, 4874 // usually 1/2 or 1/4 of the latency). 4875 if (muteWaitMs < desc->latency() * 2) { 4876 muteWaitMs = desc->latency() * 2; 4877 } 4878 } 4879 } 4880 } 4881 } 4882 } 4883 4884 // temporary mute output if device selection changes to avoid volume bursts due to 4885 // different per device volumes 4886 if (outputDesc->isActive() && (device != prevDevice)) { 4887 uint32_t tempMuteWaitMs = outputDesc->latency() * 2; 4888 // temporary mute duration is conservatively set to 4 times the reported latency 4889 uint32_t tempMuteDurationMs = outputDesc->latency() * 4; 4890 if (muteWaitMs < tempMuteWaitMs) { 4891 muteWaitMs = tempMuteWaitMs; 4892 } 4893 4894 for (size_t i = 0; i < NUM_STRATEGIES; i++) { 4895 if (isStrategyActive(outputDesc, (routing_strategy)i)) { 4896 // make sure that we do not start the temporary mute period too early in case of 4897 // delayed device change 4898 setStrategyMute((routing_strategy)i, true, outputDesc, delayMs); 4899 setStrategyMute((routing_strategy)i, false, outputDesc, 4900 delayMs + tempMuteDurationMs, device); 4901 } 4902 } 4903 } 4904 4905 // wait for the PCM output buffers to empty before proceeding with the rest of the command 4906 if (muteWaitMs > delayMs) { 4907 muteWaitMs -= delayMs; 4908 usleep(muteWaitMs * 1000); 4909 return muteWaitMs; 4910 } 4911 return 0; 4912} 4913 4914uint32_t AudioPolicyManager::setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 4915 audio_devices_t device, 4916 bool force, 4917 int delayMs, 4918 audio_patch_handle_t *patchHandle, 4919 const char* address) 4920{ 4921 ALOGV("setOutputDevice() device %04x delayMs %d", device, delayMs); 4922 AudioParameter param; 4923 uint32_t muteWaitMs; 4924 4925 if (outputDesc->isDuplicated()) { 4926 muteWaitMs = setOutputDevice(outputDesc->subOutput1(), device, force, delayMs); 4927 muteWaitMs += setOutputDevice(outputDesc->subOutput2(), device, force, delayMs); 4928 return muteWaitMs; 4929 } 4930 // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current 4931 // output profile 4932 if ((device != AUDIO_DEVICE_NONE) && 4933 ((device & outputDesc->supportedDevices()) == 0)) { 4934 return 0; 4935 } 4936 4937 // filter devices according to output selected 4938 device = (audio_devices_t)(device & outputDesc->supportedDevices()); 4939 4940 audio_devices_t prevDevice = outputDesc->mDevice; 4941 4942 ALOGV("setOutputDevice() prevDevice 0x%04x", prevDevice); 4943 4944 if (device != AUDIO_DEVICE_NONE) { 4945 outputDesc->mDevice = device; 4946 } 4947 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs); 4948 4949 // Do not change the routing if: 4950 // the requested device is AUDIO_DEVICE_NONE 4951 // OR the requested device is the same as current device 4952 // AND force is not specified 4953 // AND the output is connected by a valid audio patch. 4954 // Doing this check here allows the caller to call setOutputDevice() without conditions 4955 if ((device == AUDIO_DEVICE_NONE || device == prevDevice) && 4956 !force && 4957 outputDesc->getPatchHandle() != 0) { 4958 ALOGV("setOutputDevice() setting same device 0x%04x or null device", device); 4959 return muteWaitMs; 4960 } 4961 4962 ALOGV("setOutputDevice() changing device"); 4963 4964 // do the routing 4965 if (device == AUDIO_DEVICE_NONE) { 4966 resetOutputDevice(outputDesc, delayMs, NULL); 4967 } else { 4968 DeviceVector deviceList; 4969 if ((address == NULL) || (strlen(address) == 0)) { 4970 deviceList = mAvailableOutputDevices.getDevicesFromType(device); 4971 } else { 4972 deviceList = mAvailableOutputDevices.getDevicesFromTypeAddr(device, String8(address)); 4973 } 4974 4975 if (!deviceList.isEmpty()) { 4976 struct audio_patch patch; 4977 outputDesc->toAudioPortConfig(&patch.sources[0]); 4978 patch.num_sources = 1; 4979 patch.num_sinks = 0; 4980 for (size_t i = 0; i < deviceList.size() && i < AUDIO_PATCH_PORTS_MAX; i++) { 4981 deviceList.itemAt(i)->toAudioPortConfig(&patch.sinks[i]); 4982 patch.num_sinks++; 4983 } 4984 ssize_t index; 4985 if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) { 4986 index = mAudioPatches.indexOfKey(*patchHandle); 4987 } else { 4988 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle()); 4989 } 4990 sp< AudioPatch> patchDesc; 4991 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 4992 if (index >= 0) { 4993 patchDesc = mAudioPatches.valueAt(index); 4994 afPatchHandle = patchDesc->mAfPatchHandle; 4995 } 4996 4997 status_t status = mpClientInterface->createAudioPatch(&patch, 4998 &afPatchHandle, 4999 delayMs); 5000 ALOGV("setOutputDevice() createAudioPatch returned %d patchHandle %d" 5001 "num_sources %d num_sinks %d", 5002 status, afPatchHandle, patch.num_sources, patch.num_sinks); 5003 if (status == NO_ERROR) { 5004 if (index < 0) { 5005 patchDesc = new AudioPatch(&patch, mUidCached); 5006 addAudioPatch(patchDesc->mHandle, patchDesc); 5007 } else { 5008 patchDesc->mPatch = patch; 5009 } 5010 patchDesc->mAfPatchHandle = afPatchHandle; 5011 if (patchHandle) { 5012 *patchHandle = patchDesc->mHandle; 5013 } 5014 outputDesc->setPatchHandle(patchDesc->mHandle); 5015 nextAudioPortGeneration(); 5016 mpClientInterface->onAudioPatchListUpdate(); 5017 } 5018 } 5019 5020 // inform all input as well 5021 for (size_t i = 0; i < mInputs.size(); i++) { 5022 const sp<AudioInputDescriptor> inputDescriptor = mInputs.valueAt(i); 5023 if (!is_virtual_input_device(inputDescriptor->mDevice)) { 5024 AudioParameter inputCmd = AudioParameter(); 5025 ALOGV("%s: inform input %d of device:%d", __func__, 5026 inputDescriptor->mIoHandle, device); 5027 inputCmd.addInt(String8(AudioParameter::keyRouting),device); 5028 mpClientInterface->setParameters(inputDescriptor->mIoHandle, 5029 inputCmd.toString(), 5030 delayMs); 5031 } 5032 } 5033 } 5034 5035 // update stream volumes according to new device 5036 applyStreamVolumes(outputDesc, device, delayMs); 5037 5038 return muteWaitMs; 5039} 5040 5041status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 5042 int delayMs, 5043 audio_patch_handle_t *patchHandle) 5044{ 5045 ssize_t index; 5046 if (patchHandle) { 5047 index = mAudioPatches.indexOfKey(*patchHandle); 5048 } else { 5049 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle()); 5050 } 5051 if (index < 0) { 5052 return INVALID_OPERATION; 5053 } 5054 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index); 5055 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, delayMs); 5056 ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status); 5057 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE); 5058 removeAudioPatch(patchDesc->mHandle); 5059 nextAudioPortGeneration(); 5060 mpClientInterface->onAudioPatchListUpdate(); 5061 return status; 5062} 5063 5064status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input, 5065 audio_devices_t device, 5066 bool force, 5067 audio_patch_handle_t *patchHandle) 5068{ 5069 status_t status = NO_ERROR; 5070 5071 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input); 5072 if ((device != AUDIO_DEVICE_NONE) && ((device != inputDesc->mDevice) || force)) { 5073 inputDesc->mDevice = device; 5074 5075 DeviceVector deviceList = mAvailableInputDevices.getDevicesFromType(device); 5076 if (!deviceList.isEmpty()) { 5077 struct audio_patch patch; 5078 inputDesc->toAudioPortConfig(&patch.sinks[0]); 5079 // AUDIO_SOURCE_HOTWORD is for internal use only: 5080 // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL 5081 if (patch.sinks[0].ext.mix.usecase.source == AUDIO_SOURCE_HOTWORD && 5082 !inputDesc->isSoundTrigger()) { 5083 patch.sinks[0].ext.mix.usecase.source = AUDIO_SOURCE_VOICE_RECOGNITION; 5084 } 5085 patch.num_sinks = 1; 5086 //only one input device for now 5087 deviceList.itemAt(0)->toAudioPortConfig(&patch.sources[0]); 5088 patch.num_sources = 1; 5089 ssize_t index; 5090 if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) { 5091 index = mAudioPatches.indexOfKey(*patchHandle); 5092 } else { 5093 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle()); 5094 } 5095 sp< AudioPatch> patchDesc; 5096 audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE; 5097 if (index >= 0) { 5098 patchDesc = mAudioPatches.valueAt(index); 5099 afPatchHandle = patchDesc->mAfPatchHandle; 5100 } 5101 5102 status_t status = mpClientInterface->createAudioPatch(&patch, 5103 &afPatchHandle, 5104 0); 5105 ALOGV("setInputDevice() createAudioPatch returned %d patchHandle %d", 5106 status, afPatchHandle); 5107 if (status == NO_ERROR) { 5108 if (index < 0) { 5109 patchDesc = new AudioPatch(&patch, mUidCached); 5110 addAudioPatch(patchDesc->mHandle, patchDesc); 5111 } else { 5112 patchDesc->mPatch = patch; 5113 } 5114 patchDesc->mAfPatchHandle = afPatchHandle; 5115 if (patchHandle) { 5116 *patchHandle = patchDesc->mHandle; 5117 } 5118 inputDesc->setPatchHandle(patchDesc->mHandle); 5119 nextAudioPortGeneration(); 5120 mpClientInterface->onAudioPatchListUpdate(); 5121 } 5122 } 5123 } 5124 return status; 5125} 5126 5127status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input, 5128 audio_patch_handle_t *patchHandle) 5129{ 5130 sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input); 5131 ssize_t index; 5132 if (patchHandle) { 5133 index = mAudioPatches.indexOfKey(*patchHandle); 5134 } else { 5135 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle()); 5136 } 5137 if (index < 0) { 5138 return INVALID_OPERATION; 5139 } 5140 sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index); 5141 status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0); 5142 ALOGV("resetInputDevice() releaseAudioPatch returned %d", status); 5143 inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE); 5144 removeAudioPatch(patchDesc->mHandle); 5145 nextAudioPortGeneration(); 5146 mpClientInterface->onAudioPatchListUpdate(); 5147 return status; 5148} 5149 5150sp<IOProfile> AudioPolicyManager::getInputProfile(audio_devices_t device, 5151 const String8& address, 5152 uint32_t& samplingRate, 5153 audio_format_t& format, 5154 audio_channel_mask_t& channelMask, 5155 audio_input_flags_t flags) 5156{ 5157 // Choose an input profile based on the requested capture parameters: select the first available 5158 // profile supporting all requested parameters. 5159 // 5160 // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return 5161 // the best matching profile, not the first one. 5162 5163 for (size_t i = 0; i < mHwModules.size(); i++) 5164 { 5165 if (mHwModules[i]->mHandle == 0) { 5166 continue; 5167 } 5168 for (size_t j = 0; j < mHwModules[i]->mInputProfiles.size(); j++) 5169 { 5170 sp<IOProfile> profile = mHwModules[i]->mInputProfiles[j]; 5171 // profile->log(); 5172 if (profile->isCompatibleProfile(device, address, samplingRate, 5173 &samplingRate /*updatedSamplingRate*/, 5174 format, 5175 &format /*updatedFormat*/, 5176 channelMask, 5177 &channelMask /*updatedChannelMask*/, 5178 (audio_output_flags_t) flags)) { 5179 5180 return profile; 5181 } 5182 } 5183 } 5184 return NULL; 5185} 5186 5187 5188audio_devices_t AudioPolicyManager::getDeviceAndMixForInputSource(audio_source_t inputSource, 5189 AudioMix **policyMix) 5190{ 5191 audio_devices_t availableDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN; 5192 audio_devices_t selectedDeviceFromMix = 5193 mPolicyMixes.getDeviceAndMixForInputSource(inputSource, availableDeviceTypes, policyMix); 5194 5195 if (selectedDeviceFromMix != AUDIO_DEVICE_NONE) { 5196 return selectedDeviceFromMix; 5197 } 5198 return getDeviceForInputSource(inputSource); 5199} 5200 5201audio_devices_t AudioPolicyManager::getDeviceForInputSource(audio_source_t inputSource) 5202{ 5203 for (size_t routeIndex = 0; routeIndex < mInputRoutes.size(); routeIndex++) { 5204 sp<SessionRoute> route = mInputRoutes.valueAt(routeIndex); 5205 if (inputSource == route->mSource && route->isActive()) { 5206 return route->mDeviceDescriptor->type(); 5207 } 5208 } 5209 5210 return mEngine->getDeviceForInputSource(inputSource); 5211} 5212 5213float AudioPolicyManager::computeVolume(audio_stream_type_t stream, 5214 int index, 5215 audio_devices_t device) 5216{ 5217 float volumeDB = mVolumeCurves->volIndexToDb(stream, Volume::getDeviceCategory(device), index); 5218 5219 // handle the case of accessibility active while a ringtone is playing: if the ringtone is much 5220 // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch 5221 // exploration of the dialer UI. In this situation, bring the accessibility volume closer to 5222 // the ringtone volume 5223 if ((stream == AUDIO_STREAM_ACCESSIBILITY) 5224 && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState()) 5225 && isStreamActive(AUDIO_STREAM_RING, 0)) { 5226 const float ringVolumeDB = computeVolume(AUDIO_STREAM_RING, index, device); 5227 return ringVolumeDB - 4 > volumeDB ? ringVolumeDB - 4 : volumeDB; 5228 } 5229 5230 // if a headset is connected, apply the following rules to ring tones and notifications 5231 // to avoid sound level bursts in user's ears: 5232 // - always attenuate notifications volume by 6dB 5233 // - attenuate ring tones volume by 6dB unless music is not playing and 5234 // speaker is part of the select devices 5235 // - if music is playing, always limit the volume to current music volume, 5236 // with a minimum threshold at -36dB so that notification is always perceived. 5237 const routing_strategy stream_strategy = getStrategy(stream); 5238 if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP | 5239 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | 5240 AUDIO_DEVICE_OUT_WIRED_HEADSET | 5241 AUDIO_DEVICE_OUT_WIRED_HEADPHONE | 5242 AUDIO_DEVICE_OUT_USB_HEADSET)) && 5243 ((stream_strategy == STRATEGY_SONIFICATION) 5244 || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL) 5245 || (stream == AUDIO_STREAM_SYSTEM) 5246 || ((stream_strategy == STRATEGY_ENFORCED_AUDIBLE) && 5247 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) && 5248 mVolumeCurves->canBeMuted(stream)) { 5249 // when the phone is ringing we must consider that music could have been paused just before 5250 // by the music application and behave as if music was active if the last music track was 5251 // just stopped 5252 if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) || 5253 mLimitRingtoneVolume) { 5254 volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB; 5255 audio_devices_t musicDevice = getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/); 5256 float musicVolDB = computeVolume(AUDIO_STREAM_MUSIC, 5257 mVolumeCurves->getVolumeIndex(AUDIO_STREAM_MUSIC, 5258 musicDevice), 5259 musicDevice); 5260 float minVolDB = (musicVolDB > SONIFICATION_HEADSET_VOLUME_MIN_DB) ? 5261 musicVolDB : SONIFICATION_HEADSET_VOLUME_MIN_DB; 5262 if (volumeDB > minVolDB) { 5263 volumeDB = minVolDB; 5264 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDB, musicVolDB); 5265 } 5266 if (device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP | 5267 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES)) { 5268 // on A2DP, also ensure notification volume is not too low compared to media when 5269 // intended to be played 5270 if ((volumeDB > -96.0f) && 5271 (musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDB)) { 5272 ALOGV("computeVolume increasing volume for stream=%d device=0x%X from %f to %f", 5273 stream, device, 5274 volumeDB, musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB); 5275 volumeDB = musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB; 5276 } 5277 } 5278 } else if ((Volume::getDeviceForVolume(device) != AUDIO_DEVICE_OUT_SPEAKER) || 5279 stream_strategy != STRATEGY_SONIFICATION) { 5280 volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB; 5281 } 5282 } 5283 5284 return volumeDB; 5285} 5286 5287status_t AudioPolicyManager::checkAndSetVolume(audio_stream_type_t stream, 5288 int index, 5289 const sp<AudioOutputDescriptor>& outputDesc, 5290 audio_devices_t device, 5291 int delayMs, 5292 bool force) 5293{ 5294 // do not change actual stream volume if the stream is muted 5295 if (outputDesc->mMuteCount[stream] != 0) { 5296 ALOGVV("checkAndSetVolume() stream %d muted count %d", 5297 stream, outputDesc->mMuteCount[stream]); 5298 return NO_ERROR; 5299 } 5300 audio_policy_forced_cfg_t forceUseForComm = 5301 mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION); 5302 // do not change in call volume if bluetooth is connected and vice versa 5303 if ((stream == AUDIO_STREAM_VOICE_CALL && forceUseForComm == AUDIO_POLICY_FORCE_BT_SCO) || 5304 (stream == AUDIO_STREAM_BLUETOOTH_SCO && forceUseForComm != AUDIO_POLICY_FORCE_BT_SCO)) { 5305 ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm", 5306 stream, forceUseForComm); 5307 return INVALID_OPERATION; 5308 } 5309 5310 if (device == AUDIO_DEVICE_NONE) { 5311 device = outputDesc->device(); 5312 } 5313 5314 float volumeDb = computeVolume(stream, index, device); 5315 if (outputDesc->isFixedVolume(device)) { 5316 volumeDb = 0.0f; 5317 } 5318 5319 outputDesc->setVolume(volumeDb, stream, device, delayMs, force); 5320 5321 if (stream == AUDIO_STREAM_VOICE_CALL || 5322 stream == AUDIO_STREAM_BLUETOOTH_SCO) { 5323 float voiceVolume; 5324 // Force voice volume to max for bluetooth SCO as volume is managed by the headset 5325 if (stream == AUDIO_STREAM_VOICE_CALL) { 5326 voiceVolume = (float)index/(float)mVolumeCurves->getVolumeIndexMax(stream); 5327 } else { 5328 voiceVolume = 1.0; 5329 } 5330 5331 if (voiceVolume != mLastVoiceVolume) { 5332 mpClientInterface->setVoiceVolume(voiceVolume, delayMs); 5333 mLastVoiceVolume = voiceVolume; 5334 } 5335 } 5336 5337 return NO_ERROR; 5338} 5339 5340void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc, 5341 audio_devices_t device, 5342 int delayMs, 5343 bool force) 5344{ 5345 ALOGVV("applyStreamVolumes() for device %08x", device); 5346 5347 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) { 5348 checkAndSetVolume((audio_stream_type_t)stream, 5349 mVolumeCurves->getVolumeIndex((audio_stream_type_t)stream, device), 5350 outputDesc, 5351 device, 5352 delayMs, 5353 force); 5354 } 5355} 5356 5357void AudioPolicyManager::setStrategyMute(routing_strategy strategy, 5358 bool on, 5359 const sp<AudioOutputDescriptor>& outputDesc, 5360 int delayMs, 5361 audio_devices_t device) 5362{ 5363 ALOGVV("setStrategyMute() strategy %d, mute %d, output ID %d", 5364 strategy, on, outputDesc->getId()); 5365 for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) { 5366 if (getStrategy((audio_stream_type_t)stream) == strategy) { 5367 setStreamMute((audio_stream_type_t)stream, on, outputDesc, delayMs, device); 5368 } 5369 } 5370} 5371 5372void AudioPolicyManager::setStreamMute(audio_stream_type_t stream, 5373 bool on, 5374 const sp<AudioOutputDescriptor>& outputDesc, 5375 int delayMs, 5376 audio_devices_t device) 5377{ 5378 if (device == AUDIO_DEVICE_NONE) { 5379 device = outputDesc->device(); 5380 } 5381 5382 ALOGVV("setStreamMute() stream %d, mute %d, mMuteCount %d device %04x", 5383 stream, on, outputDesc->mMuteCount[stream], device); 5384 5385 if (on) { 5386 if (outputDesc->mMuteCount[stream] == 0) { 5387 if (mVolumeCurves->canBeMuted(stream) && 5388 ((stream != AUDIO_STREAM_ENFORCED_AUDIBLE) || 5389 (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) { 5390 checkAndSetVolume(stream, 0, outputDesc, device, delayMs); 5391 } 5392 } 5393 // increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignored 5394 outputDesc->mMuteCount[stream]++; 5395 } else { 5396 if (outputDesc->mMuteCount[stream] == 0) { 5397 ALOGV("setStreamMute() unmuting non muted stream!"); 5398 return; 5399 } 5400 if (--outputDesc->mMuteCount[stream] == 0) { 5401 checkAndSetVolume(stream, 5402 mVolumeCurves->getVolumeIndex(stream, device), 5403 outputDesc, 5404 device, 5405 delayMs); 5406 } 5407 } 5408} 5409 5410void AudioPolicyManager::handleIncallSonification(audio_stream_type_t stream, 5411 bool starting, bool stateChange) 5412{ 5413 if(!hasPrimaryOutput()) { 5414 return; 5415 } 5416 5417 // if the stream pertains to sonification strategy and we are in call we must 5418 // mute the stream if it is low visibility. If it is high visibility, we must play a tone 5419 // in the device used for phone strategy and play the tone if the selected device does not 5420 // interfere with the device used for phone strategy 5421 // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as 5422 // many times as there are active tracks on the output 5423 const routing_strategy stream_strategy = getStrategy(stream); 5424 if ((stream_strategy == STRATEGY_SONIFICATION) || 5425 ((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) { 5426 sp<SwAudioOutputDescriptor> outputDesc = mPrimaryOutput; 5427 ALOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d", 5428 stream, starting, outputDesc->mDevice, stateChange); 5429 if (outputDesc->mRefCount[stream]) { 5430 int muteCount = 1; 5431 if (stateChange) { 5432 muteCount = outputDesc->mRefCount[stream]; 5433 } 5434 if (audio_is_low_visibility(stream)) { 5435 ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount); 5436 for (int i = 0; i < muteCount; i++) { 5437 setStreamMute(stream, starting, mPrimaryOutput); 5438 } 5439 } else { 5440 ALOGV("handleIncallSonification() high visibility"); 5441 if (outputDesc->device() & 5442 getDeviceForStrategy(STRATEGY_PHONE, true /*fromCache*/)) { 5443 ALOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount); 5444 for (int i = 0; i < muteCount; i++) { 5445 setStreamMute(stream, starting, mPrimaryOutput); 5446 } 5447 } 5448 if (starting) { 5449 mpClientInterface->startTone(AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION, 5450 AUDIO_STREAM_VOICE_CALL); 5451 } else { 5452 mpClientInterface->stopTone(); 5453 } 5454 } 5455 } 5456 } 5457} 5458 5459audio_stream_type_t AudioPolicyManager::streamTypefromAttributesInt(const audio_attributes_t *attr) 5460{ 5461 // flags to stream type mapping 5462 if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) { 5463 return AUDIO_STREAM_ENFORCED_AUDIBLE; 5464 } 5465 if ((attr->flags & AUDIO_FLAG_SCO) == AUDIO_FLAG_SCO) { 5466 return AUDIO_STREAM_BLUETOOTH_SCO; 5467 } 5468 if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) { 5469 return AUDIO_STREAM_TTS; 5470 } 5471 5472 // usage to stream type mapping 5473 switch (attr->usage) { 5474 case AUDIO_USAGE_MEDIA: 5475 case AUDIO_USAGE_GAME: 5476 case AUDIO_USAGE_ASSISTANT: 5477 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: 5478 return AUDIO_STREAM_MUSIC; 5479 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY: 5480 return AUDIO_STREAM_ACCESSIBILITY; 5481 case AUDIO_USAGE_ASSISTANCE_SONIFICATION: 5482 return AUDIO_STREAM_SYSTEM; 5483 case AUDIO_USAGE_VOICE_COMMUNICATION: 5484 return AUDIO_STREAM_VOICE_CALL; 5485 5486 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING: 5487 return AUDIO_STREAM_DTMF; 5488 5489 case AUDIO_USAGE_ALARM: 5490 return AUDIO_STREAM_ALARM; 5491 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE: 5492 return AUDIO_STREAM_RING; 5493 5494 case AUDIO_USAGE_NOTIFICATION: 5495 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST: 5496 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT: 5497 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED: 5498 case AUDIO_USAGE_NOTIFICATION_EVENT: 5499 return AUDIO_STREAM_NOTIFICATION; 5500 5501 case AUDIO_USAGE_UNKNOWN: 5502 default: 5503 return AUDIO_STREAM_MUSIC; 5504 } 5505} 5506 5507bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa) 5508{ 5509 // has flags that map to a strategy? 5510 if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) { 5511 return true; 5512 } 5513 5514 // has known usage? 5515 switch (paa->usage) { 5516 case AUDIO_USAGE_UNKNOWN: 5517 case AUDIO_USAGE_MEDIA: 5518 case AUDIO_USAGE_VOICE_COMMUNICATION: 5519 case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING: 5520 case AUDIO_USAGE_ALARM: 5521 case AUDIO_USAGE_NOTIFICATION: 5522 case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE: 5523 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST: 5524 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT: 5525 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED: 5526 case AUDIO_USAGE_NOTIFICATION_EVENT: 5527 case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY: 5528 case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: 5529 case AUDIO_USAGE_ASSISTANCE_SONIFICATION: 5530 case AUDIO_USAGE_GAME: 5531 case AUDIO_USAGE_VIRTUAL_SOURCE: 5532 case AUDIO_USAGE_ASSISTANT: 5533 break; 5534 default: 5535 return false; 5536 } 5537 return true; 5538} 5539 5540bool AudioPolicyManager::isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc, 5541 routing_strategy strategy, uint32_t inPastMs, 5542 nsecs_t sysTime) const 5543{ 5544 if ((sysTime == 0) && (inPastMs != 0)) { 5545 sysTime = systemTime(); 5546 } 5547 for (int i = 0; i < (int)AUDIO_STREAM_FOR_POLICY_CNT; i++) { 5548 if (((getStrategy((audio_stream_type_t)i) == strategy) || 5549 (NUM_STRATEGIES == strategy)) && 5550 outputDesc->isStreamActive((audio_stream_type_t)i, inPastMs, sysTime)) { 5551 return true; 5552 } 5553 } 5554 return false; 5555} 5556 5557audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage) 5558{ 5559 return mEngine->getForceUse(usage); 5560} 5561 5562bool AudioPolicyManager::isInCall() 5563{ 5564 return isStateInCall(mEngine->getPhoneState()); 5565} 5566 5567bool AudioPolicyManager::isStateInCall(int state) 5568{ 5569 return is_state_in_call(state); 5570} 5571 5572void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc) 5573{ 5574 for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--) { 5575 sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i); 5576 if (sourceDesc->mDevice->equals(deviceDesc)) { 5577 ALOGV("%s releasing audio source %d", __FUNCTION__, sourceDesc->getHandle()); 5578 stopAudioSource(sourceDesc->getHandle()); 5579 } 5580 } 5581 5582 for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--) { 5583 sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i); 5584 bool release = false; 5585 for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++) { 5586 const struct audio_port_config *source = &patchDesc->mPatch.sources[j]; 5587 if (source->type == AUDIO_PORT_TYPE_DEVICE && 5588 source->ext.device.type == deviceDesc->type()) { 5589 release = true; 5590 } 5591 } 5592 for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++) { 5593 const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j]; 5594 if (sink->type == AUDIO_PORT_TYPE_DEVICE && 5595 sink->ext.device.type == deviceDesc->type()) { 5596 release = true; 5597 } 5598 } 5599 if (release) { 5600 ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->mHandle); 5601 releaseAudioPatch(patchDesc->mHandle, patchDesc->mUid); 5602 } 5603 } 5604} 5605 5606// Modify the list of surround sound formats supported. 5607void AudioPolicyManager::filterSurroundFormats(FormatVector *formatsPtr) { 5608 FormatVector &formats = *formatsPtr; 5609 // TODO Set this based on Config properties. 5610 const bool alwaysForceAC3 = true; 5611 5612 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse( 5613 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND); 5614 ALOGD("%s: forced use = %d", __FUNCTION__, forceUse); 5615 5616 // Analyze original support for various formats. 5617 bool supportsAC3 = false; 5618 bool supportsOtherSurround = false; 5619 bool supportsIEC61937 = false; 5620 for (size_t formatIndex = 0; formatIndex < formats.size(); formatIndex++) { 5621 audio_format_t format = formats[formatIndex]; 5622 switch (format) { 5623 case AUDIO_FORMAT_AC3: 5624 supportsAC3 = true; 5625 break; 5626 case AUDIO_FORMAT_E_AC3: 5627 case AUDIO_FORMAT_DTS: 5628 case AUDIO_FORMAT_DTS_HD: 5629 supportsOtherSurround = true; 5630 break; 5631 case AUDIO_FORMAT_IEC61937: 5632 supportsIEC61937 = true; 5633 break; 5634 default: 5635 break; 5636 } 5637 } 5638 5639 // Modify formats based on surround preferences. 5640 // If NEVER, remove support for surround formats. 5641 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { 5642 if (supportsAC3 || supportsOtherSurround || supportsIEC61937) { 5643 // Remove surround sound related formats. 5644 for (size_t formatIndex = 0; formatIndex < formats.size(); ) { 5645 audio_format_t format = formats[formatIndex]; 5646 switch(format) { 5647 case AUDIO_FORMAT_AC3: 5648 case AUDIO_FORMAT_E_AC3: 5649 case AUDIO_FORMAT_DTS: 5650 case AUDIO_FORMAT_DTS_HD: 5651 case AUDIO_FORMAT_IEC61937: 5652 formats.removeAt(formatIndex); 5653 break; 5654 default: 5655 formatIndex++; // keep it 5656 break; 5657 } 5658 } 5659 supportsAC3 = false; 5660 supportsOtherSurround = false; 5661 supportsIEC61937 = false; 5662 } 5663 } else { // AUTO or ALWAYS 5664 // Most TVs support AC3 even if they do not report it in the EDID. 5665 if ((alwaysForceAC3 || (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS)) 5666 && !supportsAC3) { 5667 formats.add(AUDIO_FORMAT_AC3); 5668 supportsAC3 = true; 5669 } 5670 5671 // If ALWAYS, add support for raw surround formats if all are missing. 5672 // This assumes that if any of these formats are reported by the HAL 5673 // then the report is valid and should not be modified. 5674 if ((forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) 5675 && !supportsOtherSurround) { 5676 formats.add(AUDIO_FORMAT_E_AC3); 5677 formats.add(AUDIO_FORMAT_DTS); 5678 formats.add(AUDIO_FORMAT_DTS_HD); 5679 supportsOtherSurround = true; 5680 } 5681 5682 // Add support for IEC61937 if any raw surround supported. 5683 // The HAL could do this but add it here, just in case. 5684 if ((supportsAC3 || supportsOtherSurround) && !supportsIEC61937) { 5685 formats.add(AUDIO_FORMAT_IEC61937); 5686 supportsIEC61937 = true; 5687 } 5688 } 5689} 5690 5691// Modify the list of channel masks supported. 5692void AudioPolicyManager::filterSurroundChannelMasks(ChannelsVector *channelMasksPtr) { 5693 ChannelsVector &channelMasks = *channelMasksPtr; 5694 audio_policy_forced_cfg_t forceUse = mEngine->getForceUse( 5695 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND); 5696 5697 // If NEVER, then remove support for channelMasks > stereo. 5698 if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { 5699 for (size_t maskIndex = 0; maskIndex < channelMasks.size(); ) { 5700 audio_channel_mask_t channelMask = channelMasks[maskIndex]; 5701 if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) { 5702 ALOGI("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask); 5703 channelMasks.removeAt(maskIndex); 5704 } else { 5705 maskIndex++; 5706 } 5707 } 5708 // If ALWAYS, then make sure we at least support 5.1 5709 } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) { 5710 bool supports5dot1 = false; 5711 // Are there any channel masks that can be considered "surround"? 5712 for (size_t maskIndex = 0; maskIndex < channelMasks.size(); maskIndex++) { 5713 audio_channel_mask_t channelMask = channelMasks[maskIndex]; 5714 if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) { 5715 supports5dot1 = true; 5716 break; 5717 } 5718 } 5719 // If not then add 5.1 support. 5720 if (!supports5dot1) { 5721 channelMasks.add(AUDIO_CHANNEL_OUT_5POINT1); 5722 ALOGI("%s: force ALWAYS, so adding channelMask for 5.1 surround", __FUNCTION__); 5723 } 5724 } 5725} 5726 5727void AudioPolicyManager::updateAudioProfiles(audio_devices_t device, 5728 audio_io_handle_t ioHandle, 5729 AudioProfileVector &profiles) 5730{ 5731 String8 reply; 5732 5733 // Format MUST be checked first to update the list of AudioProfile 5734 if (profiles.hasDynamicFormat()) { 5735 reply = mpClientInterface->getParameters( 5736 ioHandle, String8(AudioParameter::keyStreamSupportedFormats)); 5737 ALOGV("%s: supported formats %s", __FUNCTION__, reply.string()); 5738 AudioParameter repliedParameters(reply); 5739 if (repliedParameters.get( 5740 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) { 5741 ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__); 5742 return; 5743 } 5744 FormatVector formats = formatsFromString(reply.string()); 5745 if (device == AUDIO_DEVICE_OUT_HDMI) { 5746 filterSurroundFormats(&formats); 5747 } 5748 profiles.setFormats(formats); 5749 } 5750 const FormatVector &supportedFormats = profiles.getSupportedFormats(); 5751 5752 for (size_t formatIndex = 0; formatIndex < supportedFormats.size(); formatIndex++) { 5753 audio_format_t format = supportedFormats[formatIndex]; 5754 ChannelsVector channelMasks; 5755 SampleRateVector samplingRates; 5756 AudioParameter requestedParameters; 5757 requestedParameters.addInt(String8(AudioParameter::keyFormat), format); 5758 5759 if (profiles.hasDynamicRateFor(format)) { 5760 reply = mpClientInterface->getParameters( 5761 ioHandle, 5762 requestedParameters.toString() + ";" + 5763 AudioParameter::keyStreamSupportedSamplingRates); 5764 ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string()); 5765 AudioParameter repliedParameters(reply); 5766 if (repliedParameters.get( 5767 String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) { 5768 samplingRates = samplingRatesFromString(reply.string()); 5769 } 5770 } 5771 if (profiles.hasDynamicChannelsFor(format)) { 5772 reply = mpClientInterface->getParameters(ioHandle, 5773 requestedParameters.toString() + ";" + 5774 AudioParameter::keyStreamSupportedChannels); 5775 ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string()); 5776 AudioParameter repliedParameters(reply); 5777 if (repliedParameters.get( 5778 String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) { 5779 channelMasks = channelMasksFromString(reply.string()); 5780 if (device == AUDIO_DEVICE_OUT_HDMI) { 5781 filterSurroundChannelMasks(&channelMasks); 5782 } 5783 } 5784 } 5785 profiles.addProfileFromHal(new AudioProfile(format, channelMasks, samplingRates)); 5786 } 5787} 5788 5789}; // namespace android 5790