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