audio/AudioPolicyManagerBase.cpp

   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 "AudioPolicyManagerBase"
  18 //#define LOG_NDEBUG 0
  19 #include <utils/Log.h>
  20 #include <hardware_legacy/AudioPolicyManagerBase.h>
  21 #include <hardware/audio_effect.h>
  22 #include <math.h>
  23
  24 namespace android_audio_legacy {
  25
  26 // ----------------------------------------------------------------------------
  27 // AudioPolicyInterface implementation
  28 // ----------------------------------------------------------------------------
  29
  30
  31 status_t AudioPolicyManagerBase::setDeviceConnectionState(AudioSystem::audio_devices device,
  32                                                   AudioSystem::device_connection_state state,
  33                                                   const char *device_address)
  34 {
  35
  36     LOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address);
  37
  38     // connect/disconnect only 1 device at a time
  39     if (AudioSystem::popCount(device) != 1) return BAD_VALUE;
  40
  41     if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) {
  42         LOGE("setDeviceConnectionState() invalid address: %s", device_address);
  43         return BAD_VALUE;
  44     }
  45
  46     // handle output devices
  47     if (AudioSystem::isOutputDevice(device)) {
  48
  49 #ifndef WITH_A2DP
  50         if (AudioSystem::isA2dpDevice(device)) {
  51             LOGE("setDeviceConnectionState() invalid device: %x", device);
  52             return BAD_VALUE;
  53         }
  54 #endif
  55
  56         switch (state)
  57         {
  58         // handle output device connection
  59         case AudioSystem::DEVICE_STATE_AVAILABLE:
  60             if (mAvailableOutputDevices & device) {
  61                 LOGW("setDeviceConnectionState() device already connected: %x", device);
  62                 return INVALID_OPERATION;
  63             }
  64             LOGV("setDeviceConnectionState() connecting device %x", device);
  65
  66             // register new device as available
  67             mAvailableOutputDevices |= device;
  68
  69 #ifdef WITH_A2DP
  70             // handle A2DP device connection
  71             if (AudioSystem::isA2dpDevice(device)) {
  72                 status_t status = handleA2dpConnection(device, device_address);
  73                 if (status != NO_ERROR) {
  74                     mAvailableOutputDevices &= ~device;
  75                     return status;
  76                 }
  77             } else
  78 #endif
  79             {
  80                 if (AudioSystem::isBluetoothScoDevice(device)) {
  81                     LOGV("setDeviceConnectionState() BT SCO  device, address %s", device_address);
  82                     // keep track of SCO device address
  83                     mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
  84                 }
  85             }
  86             break;
  87         // handle output device disconnection
  88         case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
  89             if (!(mAvailableOutputDevices & device)) {
  90                 LOGW("setDeviceConnectionState() device not connected: %x", device);
  91                 return INVALID_OPERATION;
  92             }
  93
  94
  95             LOGV("setDeviceConnectionState() disconnecting device %x", device);
  96             // remove device from available output devices
  97             mAvailableOutputDevices &= ~device;
  98
  99 #ifdef WITH_A2DP
 100             // handle A2DP device disconnection
 101             if (AudioSystem::isA2dpDevice(device)) {
 102                 status_t status = handleA2dpDisconnection(device, device_address);
 103                 if (status != NO_ERROR) {
 104                     mAvailableOutputDevices |= device;
 105                     return status;
 106                 }
 107             } else
 108 #endif
 109             {
 110                 if (AudioSystem::isBluetoothScoDevice(device)) {
 111                     mScoDeviceAddress = "";
 112                 }
 113             }
 114             } break;
 115
 116         default:
 117             LOGE("setDeviceConnectionState() invalid state: %x", state);
 118             return BAD_VALUE;
 119         }
 120
 121         // request routing change if necessary
 122         uint32_t newDevice = getNewDevice(mHardwareOutput, false);
 123 #ifdef WITH_A2DP
 124         checkA2dpSuspend();
 125         checkOutputForAllStrategies();
 126         // A2DP outputs must be closed after checkOutputForAllStrategies() is executed
 127         if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && AudioSystem::isA2dpDevice(device)) {
 128             closeA2dpOutputs();
 129         }
 130 #endif
 131         updateDeviceForStrategy();
 132         setOutputDevice(mHardwareOutput, newDevice);
 133
 134         if (device == AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
 135             device = AudioSystem::DEVICE_IN_WIRED_HEADSET;
 136         } else if (device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO ||
 137                    device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET ||
 138                    device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
 139             device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
 140         } else {
 141             return NO_ERROR;
 142         }
 143     }
 144     // handle input devices
 145     if (AudioSystem::isInputDevice(device)) {
 146
 147         switch (state)
 148         {
 149         // handle input device connection
 150         case AudioSystem::DEVICE_STATE_AVAILABLE: {
 151             if (mAvailableInputDevices & device) {
 152                 LOGW("setDeviceConnectionState() device already connected: %d", device);
 153                 return INVALID_OPERATION;
 154             }
 155             mAvailableInputDevices |= device;
 156             }
 157             break;
 158
 159         // handle input device disconnection
 160         case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
 161             if (!(mAvailableInputDevices & device)) {
 162                 LOGW("setDeviceConnectionState() device not connected: %d", device);
 163                 return INVALID_OPERATION;
 164             }
 165             mAvailableInputDevices &= ~device;
 166             } break;
 167
 168         default:
 169             LOGE("setDeviceConnectionState() invalid state: %x", state);
 170             return BAD_VALUE;
 171         }
 172
 173         audio_io_handle_t activeInput = getActiveInput();
 174         if (activeInput != 0) {
 175             AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
 176             uint32_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
 177             if (newDevice != inputDesc->mDevice) {
 178                 LOGV("setDeviceConnectionState() changing device from %x to %x for input %d",
 179                         inputDesc->mDevice, newDevice, activeInput);
 180                 inputDesc->mDevice = newDevice;
 181                 AudioParameter param = AudioParameter();
 182                 param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
 183                 mpClientInterface->setParameters(activeInput, param.toString());
 184             }
 185         }
 186
 187         return NO_ERROR;
 188     }
 189
 190     LOGW("setDeviceConnectionState() invalid device: %x", device);
 191     return BAD_VALUE;
 192 }
 193
 194 AudioSystem::device_connection_state AudioPolicyManagerBase::getDeviceConnectionState(AudioSystem::audio_devices device,
 195                                                   const char *device_address)
 196 {
 197     AudioSystem::device_connection_state state = AudioSystem::DEVICE_STATE_UNAVAILABLE;
 198     String8 address = String8(device_address);
 199     if (AudioSystem::isOutputDevice(device)) {
 200         if (device & mAvailableOutputDevices) {
 201 #ifdef WITH_A2DP
 202             if (AudioSystem::isA2dpDevice(device) &&
 203                 address != "" && mA2dpDeviceAddress != address) {
 204                 return state;
 205             }
 206 #endif
 207             if (AudioSystem::isBluetoothScoDevice(device) &&
 208                 address != "" && mScoDeviceAddress != address) {
 209                 return state;
 210             }
 211             state = AudioSystem::DEVICE_STATE_AVAILABLE;
 212         }
 213     } else if (AudioSystem::isInputDevice(device)) {
 214         if (device & mAvailableInputDevices) {
 215             state = AudioSystem::DEVICE_STATE_AVAILABLE;
 216         }
 217     }
 218
 219     return state;
 220 }
 221
 222 void AudioPolicyManagerBase::setPhoneState(int state)
 223 {
 224     LOGV("setPhoneState() state %d", state);
 225     uint32_t newDevice = 0;
 226     if (state < 0 || state >= AudioSystem::NUM_MODES) {
 227         LOGW("setPhoneState() invalid state %d", state);
 228         return;
 229     }
 230
 231     if (state == mPhoneState ) {
 232         LOGW("setPhoneState() setting same state %d", state);
 233         return;
 234     }
 235
 236     // if leaving call state, handle special case of active streams
 237     // pertaining to sonification strategy see handleIncallSonification()
 238     if (isInCall()) {
 239         LOGV("setPhoneState() in call state management: new state is %d", state);
 240         for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
 241             handleIncallSonification(stream, false, true);
 242         }
 243     }
 244
 245     // store previous phone state for management of sonification strategy below
 246     int oldState = mPhoneState;
 247     mPhoneState = state;
 248     bool force = false;
 249
 250     // are we entering or starting a call
 251     if (!isStateInCall(oldState) && isStateInCall(state)) {
 252         LOGV("  Entering call in setPhoneState()");
 253         // force routing command to audio hardware when starting a call
 254         // even if no device change is needed
 255         force = true;
 256     } else if (isStateInCall(oldState) && !isStateInCall(state)) {
 257         LOGV("  Exiting call in setPhoneState()");
 258         // force routing command to audio hardware when exiting a call
 259         // even if no device change is needed
 260         force = true;
 261     } else if (isStateInCall(state) && (state != oldState)) {
 262         LOGV("  Switching between telephony and VoIP in setPhoneState()");
 263         // force routing command to audio hardware when switching between telephony and VoIP
 264         // even if no device change is needed
 265         force = true;
 266     }
 267
 268     // check for device and output changes triggered by new phone state
 269     newDevice = getNewDevice(mHardwareOutput, false);
 270 #ifdef WITH_A2DP
 271     checkA2dpSuspend();
 272     checkOutputForAllStrategies();
 273 #endif
 274     updateDeviceForStrategy();
 275
 276     AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mHardwareOutput);
 277
 278     // force routing command to audio hardware when ending call
 279     // even if no device change is needed
 280     if (isStateInCall(oldState) && newDevice == 0) {
 281         newDevice = hwOutputDesc->device();
 282     }
 283
 284     // when changing from ring tone to in call mode, mute the ringing tone
 285     // immediately and delay the route change to avoid sending the ring tone
 286     // tail into the earpiece or headset.
 287     int delayMs = 0;
 288     if (isStateInCall(state) && oldState == AudioSystem::MODE_RINGTONE) {
 289         // delay the device change command by twice the output latency to have some margin
 290         // and be sure that audio buffers not yet affected by the mute are out when
 291         // we actually apply the route change
 292         delayMs = hwOutputDesc->mLatency*2;
 293         setStreamMute(AudioSystem::RING, true, mHardwareOutput);
 294     }
 295
 296     // change routing is necessary
 297     setOutputDevice(mHardwareOutput, newDevice, force, delayMs);
 298
 299     // if entering in call state, handle special case of active streams
 300     // pertaining to sonification strategy see handleIncallSonification()
 301     if (isStateInCall(state)) {
 302         LOGV("setPhoneState() in call state management: new state is %d", state);
 303         // unmute the ringing tone after a sufficient delay if it was muted before
 304         // setting output device above
 305         if (oldState == AudioSystem::MODE_RINGTONE) {
 306             setStreamMute(AudioSystem::RING, false, mHardwareOutput, MUTE_TIME_MS);
 307         }
 308         for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
 309             handleIncallSonification(stream, true, true);
 310         }
 311     }
 312
 313     // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
 314     if (state == AudioSystem::MODE_RINGTONE &&
 315         isStreamActive(AudioSystem::MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
 316         mLimitRingtoneVolume = true;
 317     } else {
 318         mLimitRingtoneVolume = false;
 319     }
 320 }
 321
 322 void AudioPolicyManagerBase::setRingerMode(uint32_t mode, uint32_t mask)
 323 {
 324     LOGV("setRingerMode() mode %x, mask %x", mode, mask);
 325
 326     mRingerMode = mode;
 327 }
 328
 329 void AudioPolicyManagerBase::setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config)
 330 {
 331     LOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mPhoneState);
 332
 333     bool forceVolumeReeval = false;
 334     switch(usage) {
 335     case AudioSystem::FOR_COMMUNICATION:
 336         if (config != AudioSystem::FORCE_SPEAKER && config != AudioSystem::FORCE_BT_SCO &&
 337             config != AudioSystem::FORCE_NONE) {
 338             LOGW("setForceUse() invalid config %d for FOR_COMMUNICATION", config);
 339             return;
 340         }
 341         forceVolumeReeval = true;
 342         mForceUse[usage] = config;
 343         break;
 344     case AudioSystem::FOR_MEDIA:
 345         if (config != AudioSystem::FORCE_HEADPHONES && config != AudioSystem::FORCE_BT_A2DP &&
 346             config != AudioSystem::FORCE_WIRED_ACCESSORY &&
 347             config != AudioSystem::FORCE_ANALOG_DOCK &&
 348             config != AudioSystem::FORCE_DIGITAL_DOCK && config != AudioSystem::FORCE_NONE) {
 349             LOGW("setForceUse() invalid config %d for FOR_MEDIA", config);
 350             return;
 351         }
 352         mForceUse[usage] = config;
 353         break;
 354     case AudioSystem::FOR_RECORD:
 355         if (config != AudioSystem::FORCE_BT_SCO && config != AudioSystem::FORCE_WIRED_ACCESSORY &&
 356             config != AudioSystem::FORCE_NONE) {
 357             LOGW("setForceUse() invalid config %d for FOR_RECORD", config);
 358             return;
 359         }
 360         mForceUse[usage] = config;
 361         break;
 362     case AudioSystem::FOR_DOCK:
 363         if (config != AudioSystem::FORCE_NONE && config != AudioSystem::FORCE_BT_CAR_DOCK &&
 364             config != AudioSystem::FORCE_BT_DESK_DOCK &&
 365             config != AudioSystem::FORCE_WIRED_ACCESSORY &&
 366             config != AudioSystem::FORCE_ANALOG_DOCK &&
 367             config != AudioSystem::FORCE_DIGITAL_DOCK) {
 368             LOGW("setForceUse() invalid config %d for FOR_DOCK", config);
 369         }
 370         forceVolumeReeval = true;
 371         mForceUse[usage] = config;
 372         break;
 373     default:
 374         LOGW("setForceUse() invalid usage %d", usage);
 375         break;
 376     }
 377
 378     // check for device and output changes triggered by new phone state
 379     uint32_t newDevice = getNewDevice(mHardwareOutput, false);
 380 #ifdef WITH_A2DP
 381     checkA2dpSuspend();
 382     checkOutputForAllStrategies();
 383 #endif
 384     updateDeviceForStrategy();
 385     setOutputDevice(mHardwareOutput, newDevice);
 386     if (forceVolumeReeval) {
 387         applyStreamVolumes(mHardwareOutput, newDevice, 0, true);
 388     }
 389
 390     audio_io_handle_t activeInput = getActiveInput();
 391     if (activeInput != 0) {
 392         AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
 393         newDevice = getDeviceForInputSource(inputDesc->mInputSource);
 394         if (newDevice != inputDesc->mDevice) {
 395             LOGV("setForceUse() changing device from %x to %x for input %d",
 396                     inputDesc->mDevice, newDevice, activeInput);
 397             inputDesc->mDevice = newDevice;
 398             AudioParameter param = AudioParameter();
 399             param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
 400             mpClientInterface->setParameters(activeInput, param.toString());
 401         }
 402     }
 403
 404 }
 405
 406 AudioSystem::forced_config AudioPolicyManagerBase::getForceUse(AudioSystem::force_use usage)
 407 {
 408     return mForceUse[usage];
 409 }
 410
 411 void AudioPolicyManagerBase::setSystemProperty(const char* property, const char* value)
 412 {
 413     LOGV("setSystemProperty() property %s, value %s", property, value);
 414     if (strcmp(property, "ro.camera.sound.forced") == 0) {
 415         if (atoi(value)) {
 416             LOGV("ENFORCED_AUDIBLE cannot be muted");
 417             mStreams[AudioSystem::ENFORCED_AUDIBLE].mCanBeMuted = false;
 418         } else {
 419             LOGV("ENFORCED_AUDIBLE can be muted");
 420             mStreams[AudioSystem::ENFORCED_AUDIBLE].mCanBeMuted = true;
 421         }
 422     }
 423 }
 424
 425 audio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type stream,
 426                                     uint32_t samplingRate,
 427                                     uint32_t format,
 428                                     uint32_t channels,
 429                                     AudioSystem::output_flags flags)
 430 {
 431     audio_io_handle_t output = 0;
 432     uint32_t latency = 0;
 433     routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
 434     uint32_t device = getDeviceForStrategy(strategy);
 435     LOGV("getOutput() stream %d, samplingRate %d, format %d, channels %x, flags %x", stream, samplingRate, format, channels, flags);
 436
 437 #ifdef AUDIO_POLICY_TEST
 438     if (mCurOutput != 0) {
 439         LOGV("getOutput() test output mCurOutput %d, samplingRate %d, format %d, channels %x, mDirectOutput %d",
 440                 mCurOutput, mTestSamplingRate, mTestFormat, mTestChannels, mDirectOutput);
 441
 442         if (mTestOutputs[mCurOutput] == 0) {
 443             LOGV("getOutput() opening test output");
 444             AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
 445             outputDesc->mDevice = mTestDevice;
 446             outputDesc->mSamplingRate = mTestSamplingRate;
 447             outputDesc->mFormat = mTestFormat;
 448             outputDesc->mChannels = mTestChannels;
 449             outputDesc->mLatency = mTestLatencyMs;
 450             outputDesc->mFlags = (AudioSystem::output_flags)(mDirectOutput ? AudioSystem::OUTPUT_FLAG_DIRECT : 0);
 451             outputDesc->mRefCount[stream] = 0;
 452             mTestOutputs[mCurOutput] = mpClientInterface->openOutput(&outputDesc->mDevice,
 453                                             &outputDesc->mSamplingRate,
 454                                             &outputDesc->mFormat,
 455                                             &outputDesc->mChannels,
 456                                             &outputDesc->mLatency,
 457                                             outputDesc->mFlags);
 458             if (mTestOutputs[mCurOutput]) {
 459                 AudioParameter outputCmd = AudioParameter();
 460                 outputCmd.addInt(String8("set_id"),mCurOutput);
 461                 mpClientInterface->setParameters(mTestOutputs[mCurOutput],outputCmd.toString());
 462                 addOutput(mTestOutputs[mCurOutput], outputDesc);
 463             }
 464         }
 465         return mTestOutputs[mCurOutput];
 466     }
 467 #endif //AUDIO_POLICY_TEST
 468
 469     // open a direct output if required by specified parameters
 470     if (needsDirectOuput(stream, samplingRate, format, channels, flags, device)) {
 471
 472         LOGV("getOutput() opening direct output device %x", device);
 473         AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
 474         outputDesc->mDevice = device;
 475         outputDesc->mSamplingRate = samplingRate;
 476         outputDesc->mFormat = format;
 477         outputDesc->mChannels = channels;
 478         outputDesc->mLatency = 0;
 479         outputDesc->mFlags = (AudioSystem::output_flags)(flags | AudioSystem::OUTPUT_FLAG_DIRECT);
 480         outputDesc->mRefCount[stream] = 0;
 481         outputDesc->mStopTime[stream] = 0;
 482         output = mpClientInterface->openOutput(&outputDesc->mDevice,
 483                                         &outputDesc->mSamplingRate,
 484                                         &outputDesc->mFormat,
 485                                         &outputDesc->mChannels,
 486                                         &outputDesc->mLatency,
 487                                         outputDesc->mFlags);
 488
 489         // only accept an output with the requeted parameters
 490         if (output == 0 ||
 491             (samplingRate != 0 && samplingRate != outputDesc->mSamplingRate) ||
 492             (format != 0 && format != outputDesc->mFormat) ||
 493             (channels != 0 && channels != outputDesc->mChannels)) {
 494             LOGV("getOutput() failed opening direct output: samplingRate %d, format %d, channels %d",
 495                     samplingRate, format, channels);
 496             if (output != 0) {
 497                 mpClientInterface->closeOutput(output);
 498             }
 499             delete outputDesc;
 500             return 0;
 501         }
 502         addOutput(output, outputDesc);
 503         return output;
 504     }
 505
 506     if (channels != 0 && channels != AudioSystem::CHANNEL_OUT_MONO &&
 507         channels != AudioSystem::CHANNEL_OUT_STEREO) {
 508         return 0;
 509     }
 510     // open a non direct output
 511
 512     // get which output is suitable for the specified stream. The actual routing change will happen
 513     // when startOutput() will be called
 514     uint32_t a2dpDevice = device & AudioSystem::DEVICE_OUT_ALL_A2DP;
 515     if (AudioSystem::popCount((AudioSystem::audio_devices)device) == 2) {
 516 #ifdef WITH_A2DP
 517         if (a2dpUsedForSonification() && a2dpDevice != 0) {
 518             // if playing on 2 devices among which one is A2DP, use duplicated output
 519             LOGV("getOutput() using duplicated output");
 520             LOGW_IF((mA2dpOutput == 0), "getOutput() A2DP device in multiple %x selected but A2DP output not opened", device);
 521             output = mDuplicatedOutput;
 522         } else
 523 #endif
 524         {
 525             // if playing on 2 devices among which none is A2DP, use hardware output
 526             output = mHardwareOutput;
 527         }
 528         LOGV("getOutput() using output %d for 2 devices %x", output, device);
 529     } else {
 530 #ifdef WITH_A2DP
 531         if (a2dpDevice != 0) {
 532             // if playing on A2DP device, use a2dp output
 533             LOGW_IF((mA2dpOutput == 0), "getOutput() A2DP device %x selected but A2DP output not opened", device);
 534             output = mA2dpOutput;
 535         } else
 536 #endif
 537         {
 538             // if playing on not A2DP device, use hardware output
 539             output = mHardwareOutput;
 540         }
 541     }
 542
 543
 544     LOGW_IF((output ==0), "getOutput() could not find output for stream %d, samplingRate %d, format %d, channels %x, flags %x",
 545                 stream, samplingRate, format, channels, flags);
 546
 547     return output;
 548 }
 549
 550 status_t AudioPolicyManagerBase::startOutput(audio_io_handle_t output,
 551                                              AudioSystem::stream_type stream,
 552                                              int session)
 553 {
 554     LOGV("startOutput() output %d, stream %d, session %d", output, stream, session);
 555     ssize_t index = mOutputs.indexOfKey(output);
 556     if (index < 0) {
 557         LOGW("startOutput() unknow output %d", output);
 558         return BAD_VALUE;
 559     }
 560
 561     AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index);
 562     routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
 563
 564 #ifdef WITH_A2DP
 565     if (mA2dpOutput != 0  && !a2dpUsedForSonification() && strategy == STRATEGY_SONIFICATION) {
 566         setStrategyMute(STRATEGY_MEDIA, true, mA2dpOutput);
 567     }
 568 #endif
 569
 570     // incremenent usage count for this stream on the requested output:
 571     // NOTE that the usage count is the same for duplicated output and hardware output which is
 572     // necassary for a correct control of hardware output routing by startOutput() and stopOutput()
 573     outputDesc->changeRefCount(stream, 1);
 574
 575     setOutputDevice(output, getNewDevice(output));
 576
 577     // handle special case for sonification while in call
 578     if (isInCall()) {
 579         handleIncallSonification(stream, true, false);
 580     }
 581
 582     // apply volume rules for current stream and device if necessary
 583     checkAndSetVolume(stream, mStreams[stream].mIndexCur, output, outputDesc->device());
 584
 585     return NO_ERROR;
 586 }
 587
 588 status_t AudioPolicyManagerBase::stopOutput(audio_io_handle_t output,
 589                                             AudioSystem::stream_type stream,
 590                                             int session)
 591 {
 592     LOGV("stopOutput() output %d, stream %d, session %d", output, stream, session);
 593     ssize_t index = mOutputs.indexOfKey(output);
 594     if (index < 0) {
 595         LOGW("stopOutput() unknow output %d", output);
 596         return BAD_VALUE;
 597     }
 598
 599     AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index);
 600     routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
 601
 602     // handle special case for sonification while in call
 603     if (isInCall()) {
 604         handleIncallSonification(stream, false, false);
 605     }
 606
 607     if (outputDesc->mRefCount[stream] > 0) {
 608         // decrement usage count of this stream on the output
 609         outputDesc->changeRefCount(stream, -1);
 610         // store time at which the stream was stopped - see isStreamActive()
 611         outputDesc->mStopTime[stream] = systemTime();
 612
 613         setOutputDevice(output, getNewDevice(output), false, outputDesc->mLatency*2);
 614
 615 #ifdef WITH_A2DP
 616         if (mA2dpOutput != 0 && !a2dpUsedForSonification() &&
 617                 strategy == STRATEGY_SONIFICATION) {
 618             setStrategyMute(STRATEGY_MEDIA,
 619                             false,
 620                             mA2dpOutput,
 621                             mOutputs.valueFor(mHardwareOutput)->mLatency*2);
 622         }
 623 #endif
 624         if (output != mHardwareOutput) {
 625             setOutputDevice(mHardwareOutput, getNewDevice(mHardwareOutput), true);
 626         }
 627         return NO_ERROR;
 628     } else {
 629         LOGW("stopOutput() refcount is already 0 for output %d", output);
 630         return INVALID_OPERATION;
 631     }
 632 }
 633
 634 void AudioPolicyManagerBase::releaseOutput(audio_io_handle_t output)
 635 {
 636     LOGV("releaseOutput() %d", output);
 637     ssize_t index = mOutputs.indexOfKey(output);
 638     if (index < 0) {
 639         LOGW("releaseOutput() releasing unknown output %d", output);
 640         return;
 641     }
 642
 643 #ifdef AUDIO_POLICY_TEST
 644     int testIndex = testOutputIndex(output);
 645     if (testIndex != 0) {
 646         AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index);
 647         if (outputDesc->refCount() == 0) {
 648             mpClientInterface->closeOutput(output);
 649             delete mOutputs.valueAt(index);
 650             mOutputs.removeItem(output);
 651             mTestOutputs[testIndex] = 0;
 652         }
 653         return;
 654     }
 655 #endif //AUDIO_POLICY_TEST
 656
 657     if (mOutputs.valueAt(index)->mFlags & AudioSystem::OUTPUT_FLAG_DIRECT) {
 658         mpClientInterface->closeOutput(output);
 659         delete mOutputs.valueAt(index);
 660         mOutputs.removeItem(output);
 661     }
 662 }
 663
 664 audio_io_handle_t AudioPolicyManagerBase::getInput(int inputSource,
 665                                     uint32_t samplingRate,
 666                                     uint32_t format,
 667                                     uint32_t channels,
 668                                     AudioSystem::audio_in_acoustics acoustics)
 669 {
 670     audio_io_handle_t input = 0;
 671     uint32_t device = getDeviceForInputSource(inputSource);
 672
 673     LOGV("getInput() inputSource %d, samplingRate %d, format %d, channels %x, acoustics %x", inputSource, samplingRate, format, channels, acoustics);
 674
 675     if (device == 0) {
 676         return 0;
 677     }
 678
 679     // adapt channel selection to input source
 680     switch(inputSource) {
 681     case AUDIO_SOURCE_VOICE_UPLINK:
 682         channels = AudioSystem::CHANNEL_IN_VOICE_UPLINK;
 683         break;
 684     case AUDIO_SOURCE_VOICE_DOWNLINK:
 685         channels = AudioSystem::CHANNEL_IN_VOICE_DNLINK;
 686         break;
 687     case AUDIO_SOURCE_VOICE_CALL:
 688         channels = (AudioSystem::CHANNEL_IN_VOICE_UPLINK | AudioSystem::CHANNEL_IN_VOICE_DNLINK);
 689         break;
 690     default:
 691         break;
 692     }
 693
 694     AudioInputDescriptor *inputDesc = new AudioInputDescriptor();
 695
 696     inputDesc->mInputSource = inputSource;
 697     inputDesc->mDevice = device;
 698     inputDesc->mSamplingRate = samplingRate;
 699     inputDesc->mFormat = format;
 700     inputDesc->mChannels = channels;
 701     inputDesc->mAcoustics = acoustics;
 702     inputDesc->mRefCount = 0;
 703     input = mpClientInterface->openInput(&inputDesc->mDevice,
 704                                     &inputDesc->mSamplingRate,
 705                                     &inputDesc->mFormat,
 706                                     &inputDesc->mChannels,
 707                                     inputDesc->mAcoustics);
 708
 709     // only accept input with the exact requested set of parameters
 710     if (input == 0 ||
 711         (samplingRate != inputDesc->mSamplingRate) ||
 712         (format != inputDesc->mFormat) ||
 713         (channels != inputDesc->mChannels)) {
 714         LOGV("getInput() failed opening input: samplingRate %d, format %d, channels %d",
 715                 samplingRate, format, channels);
 716         if (input != 0) {
 717             mpClientInterface->closeInput(input);
 718         }
 719         delete inputDesc;
 720         return 0;
 721     }
 722     mInputs.add(input, inputDesc);
 723     return input;
 724 }
 725
 726 status_t AudioPolicyManagerBase::startInput(audio_io_handle_t input)
 727 {
 728     LOGV("startInput() input %d", input);
 729     ssize_t index = mInputs.indexOfKey(input);
 730     if (index < 0) {
 731         LOGW("startInput() unknow input %d", input);
 732         return BAD_VALUE;
 733     }
 734     AudioInputDescriptor *inputDesc = mInputs.valueAt(index);
 735
 736 #ifdef AUDIO_POLICY_TEST
 737     if (mTestInput == 0)
 738 #endif //AUDIO_POLICY_TEST
 739     {
 740         // refuse 2 active AudioRecord clients at the same time
 741         if (getActiveInput() != 0) {
 742             LOGW("startInput() input %d failed: other input already started", input);
 743             return INVALID_OPERATION;
 744         }
 745     }
 746
 747     AudioParameter param = AudioParameter();
 748     param.addInt(String8(AudioParameter::keyRouting), (int)inputDesc->mDevice);
 749
 750     param.addInt(String8(AudioParameter::keyInputSource), (int)inputDesc->mInputSource);
 751     LOGV("AudioPolicyManager::startInput() input source = %d", inputDesc->mInputSource);
 752
 753     mpClientInterface->setParameters(input, param.toString());
 754
 755     inputDesc->mRefCount = 1;
 756     return NO_ERROR;
 757 }
 758
 759 status_t AudioPolicyManagerBase::stopInput(audio_io_handle_t input)
 760 {
 761     LOGV("stopInput() input %d", input);
 762     ssize_t index = mInputs.indexOfKey(input);
 763     if (index < 0) {
 764         LOGW("stopInput() unknow input %d", input);
 765         return BAD_VALUE;
 766     }
 767     AudioInputDescriptor *inputDesc = mInputs.valueAt(index);
 768
 769     if (inputDesc->mRefCount == 0) {
 770         LOGW("stopInput() input %d already stopped", input);
 771         return INVALID_OPERATION;
 772     } else {
 773         AudioParameter param = AudioParameter();
 774         param.addInt(String8(AudioParameter::keyRouting), 0);
 775         mpClientInterface->setParameters(input, param.toString());
 776         inputDesc->mRefCount = 0;
 777         return NO_ERROR;
 778     }
 779 }
 780
 781 void AudioPolicyManagerBase::releaseInput(audio_io_handle_t input)
 782 {
 783     LOGV("releaseInput() %d", input);
 784     ssize_t index = mInputs.indexOfKey(input);
 785     if (index < 0) {
 786         LOGW("releaseInput() releasing unknown input %d", input);
 787         return;
 788     }
 789     mpClientInterface->closeInput(input);
 790     delete mInputs.valueAt(index);
 791     mInputs.removeItem(input);
 792     LOGV("releaseInput() exit");
 793 }
 794
 795 void AudioPolicyManagerBase::initStreamVolume(AudioSystem::stream_type stream,
 796                                             int indexMin,
 797                                             int indexMax)
 798 {
 799     LOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
 800     if (indexMin < 0 || indexMin >= indexMax) {
 801         LOGW("initStreamVolume() invalid index limits for stream %d, min %d, max %d", stream , indexMin, indexMax);
 802         return;
 803     }
 804     mStreams[stream].mIndexMin = indexMin;
 805     mStreams[stream].mIndexMax = indexMax;
 806 }
 807
 808 status_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type stream, int index)
 809 {
 810
 811     if ((index < mStreams[stream].mIndexMin) || (index > mStreams[stream].mIndexMax)) {
 812         return BAD_VALUE;
 813     }
 814
 815     // Force max volume if stream cannot be muted
 816     if (!mStreams[stream].mCanBeMuted) index = mStreams[stream].mIndexMax;
 817
 818     LOGV("setStreamVolumeIndex() stream %d, index %d", stream, index);
 819     mStreams[stream].mIndexCur = index;
 820
 821     // compute and apply stream volume on all outputs according to connected device
 822     status_t status = NO_ERROR;
 823     for (size_t i = 0; i < mOutputs.size(); i++) {
 824         status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), mOutputs.valueAt(i)->device());
 825         if (volStatus != NO_ERROR) {
 826             status = volStatus;
 827         }
 828     }
 829     return status;
 830 }
 831
 832 status_t AudioPolicyManagerBase::getStreamVolumeIndex(AudioSystem::stream_type stream, int *index)
 833 {
 834     if (index == 0) {
 835         return BAD_VALUE;
 836     }
 837     LOGV("getStreamVolumeIndex() stream %d", stream);
 838     *index =  mStreams[stream].mIndexCur;
 839     return NO_ERROR;
 840 }
 841
 842 audio_io_handle_t AudioPolicyManagerBase::getOutputForEffect(effect_descriptor_t *desc)
 843 {
 844     LOGV("getOutputForEffect()");
 845     // apply simple rule where global effects are attached to the same output as MUSIC streams
 846     return getOutput(AudioSystem::MUSIC);
 847 }
 848
 849 status_t AudioPolicyManagerBase::registerEffect(effect_descriptor_t *desc,
 850                                 audio_io_handle_t io,
 851                                 uint32_t strategy,
 852                                 int session,
 853                                 int id)
 854 {
 855     ssize_t index = mOutputs.indexOfKey(io);
 856     if (index < 0) {
 857         index = mInputs.indexOfKey(io);
 858         if (index < 0) {
 859             LOGW("registerEffect() unknown io %d", io);
 860             return INVALID_OPERATION;
 861         }
 862     }
 863
 864     if (mTotalEffectsCpuLoad + desc->cpuLoad > getMaxEffectsCpuLoad()) {
 865         LOGW("registerEffect() CPU Load limit exceeded for Fx %s, CPU %f MIPS",
 866                 desc->name, (float)desc->cpuLoad/10);
 867         return INVALID_OPERATION;
 868     }
 869     if (mTotalEffectsMemory + desc->memoryUsage > getMaxEffectsMemory()) {
 870         LOGW("registerEffect() memory limit exceeded for Fx %s, Memory %d KB",
 871                 desc->name, desc->memoryUsage);
 872         return INVALID_OPERATION;
 873     }
 874     mTotalEffectsCpuLoad += desc->cpuLoad;
 875     mTotalEffectsMemory += desc->memoryUsage;
 876     LOGV("registerEffect() effect %s, io %d, strategy %d session %d id %d",
 877             desc->name, io, strategy, session, id);
 878
 879     LOGV("registerEffect() CPU %d, memory %d", desc->cpuLoad, desc->memoryUsage);
 880     LOGV("  total CPU %d, total memory %d", mTotalEffectsCpuLoad, mTotalEffectsMemory);
 881
 882     EffectDescriptor *pDesc = new EffectDescriptor();
 883     memcpy (&pDesc->mDesc, desc, sizeof(effect_descriptor_t));
 884     pDesc->mIo = io;
 885     pDesc->mStrategy = (routing_strategy)strategy;
 886     pDesc->mSession = session;
 887     mEffects.add(id, pDesc);
 888
 889     return NO_ERROR;
 890 }
 891
 892 status_t AudioPolicyManagerBase::unregisterEffect(int id)
 893 {
 894     ssize_t index = mEffects.indexOfKey(id);
 895     if (index < 0) {
 896         LOGW("unregisterEffect() unknown effect ID %d", id);
 897         return INVALID_OPERATION;
 898     }
 899
 900     EffectDescriptor *pDesc = mEffects.valueAt(index);
 901
 902     if (mTotalEffectsCpuLoad < pDesc->mDesc.cpuLoad) {
 903         LOGW("unregisterEffect() CPU load %d too high for total %d",
 904                 pDesc->mDesc.cpuLoad, mTotalEffectsCpuLoad);
 905         pDesc->mDesc.cpuLoad = mTotalEffectsCpuLoad;
 906     }
 907     mTotalEffectsCpuLoad -= pDesc->mDesc.cpuLoad;
 908     if (mTotalEffectsMemory < pDesc->mDesc.memoryUsage) {
 909         LOGW("unregisterEffect() memory %d too big for total %d",
 910                 pDesc->mDesc.memoryUsage, mTotalEffectsMemory);
 911         pDesc->mDesc.memoryUsage = mTotalEffectsMemory;
 912     }
 913     mTotalEffectsMemory -= pDesc->mDesc.memoryUsage;
 914     LOGV("unregisterEffect() effect %s, ID %d, CPU %d, memory %d",
 915             pDesc->mDesc.name, id, pDesc->mDesc.cpuLoad, pDesc->mDesc.memoryUsage);
 916     LOGV("  total CPU %d, total memory %d", mTotalEffectsCpuLoad, mTotalEffectsMemory);
 917
 918     mEffects.removeItem(id);
 919     delete pDesc;
 920
 921     return NO_ERROR;
 922 }
 923
 924 bool AudioPolicyManagerBase::isStreamActive(int stream, uint32_t inPastMs) const
 925 {
 926     nsecs_t sysTime = systemTime();
 927     for (size_t i = 0; i < mOutputs.size(); i++) {
 928         if (mOutputs.valueAt(i)->mRefCount[stream] != 0 ||
 929             ns2ms(sysTime - mOutputs.valueAt(i)->mStopTime[stream]) < inPastMs) {
 930             return true;
 931         }
 932     }
 933     return false;
 934 }
 935
 936
 937 status_t AudioPolicyManagerBase::dump(int fd)
 938 {
 939     const size_t SIZE = 256;
 940     char buffer[SIZE];
 941     String8 result;
 942
 943     snprintf(buffer, SIZE, "\nAudioPolicyManager Dump: %p\n", this);
 944     result.append(buffer);
 945     snprintf(buffer, SIZE, " Hardware Output: %d\n", mHardwareOutput);
 946     result.append(buffer);
 947 #ifdef WITH_A2DP
 948     snprintf(buffer, SIZE, " A2DP Output: %d\n", mA2dpOutput);
 949     result.append(buffer);
 950     snprintf(buffer, SIZE, " Duplicated Output: %d\n", mDuplicatedOutput);
 951     result.append(buffer);
 952     snprintf(buffer, SIZE, " A2DP device address: %s\n", mA2dpDeviceAddress.string());
 953     result.append(buffer);
 954 #endif
 955     snprintf(buffer, SIZE, " SCO device address: %s\n", mScoDeviceAddress.string());
 956     result.append(buffer);
 957     snprintf(buffer, SIZE, " Output devices: %08x\n", mAvailableOutputDevices);
 958     result.append(buffer);
 959     snprintf(buffer, SIZE, " Input devices: %08x\n", mAvailableInputDevices);
 960     result.append(buffer);
 961     snprintf(buffer, SIZE, " Phone state: %d\n", mPhoneState);
 962     result.append(buffer);
 963     snprintf(buffer, SIZE, " Ringer mode: %d\n", mRingerMode);
 964     result.append(buffer);
 965     snprintf(buffer, SIZE, " Force use for communications %d\n", mForceUse[AudioSystem::FOR_COMMUNICATION]);
 966     result.append(buffer);
 967     snprintf(buffer, SIZE, " Force use for media %d\n", mForceUse[AudioSystem::FOR_MEDIA]);
 968     result.append(buffer);
 969     snprintf(buffer, SIZE, " Force use for record %d\n", mForceUse[AudioSystem::FOR_RECORD]);
 970     result.append(buffer);
 971     snprintf(buffer, SIZE, " Force use for dock %d\n", mForceUse[AudioSystem::FOR_DOCK]);
 972     result.append(buffer);
 973     write(fd, result.string(), result.size());
 974
 975     snprintf(buffer, SIZE, "\nOutputs dump:\n");
 976     write(fd, buffer, strlen(buffer));
 977     for (size_t i = 0; i < mOutputs.size(); i++) {
 978         snprintf(buffer, SIZE, "- Output %d dump:\n", mOutputs.keyAt(i));
 979         write(fd, buffer, strlen(buffer));
 980         mOutputs.valueAt(i)->dump(fd);
 981     }
 982
 983     snprintf(buffer, SIZE, "\nInputs dump:\n");
 984     write(fd, buffer, strlen(buffer));
 985     for (size_t i = 0; i < mInputs.size(); i++) {
 986         snprintf(buffer, SIZE, "- Input %d dump:\n", mInputs.keyAt(i));
 987         write(fd, buffer, strlen(buffer));
 988         mInputs.valueAt(i)->dump(fd);
 989     }
 990
 991     snprintf(buffer, SIZE, "\nStreams dump:\n");
 992     write(fd, buffer, strlen(buffer));
 993     snprintf(buffer, SIZE, " Stream  Index Min  Index Max  Index Cur  Can be muted\n");
 994     write(fd, buffer, strlen(buffer));
 995     for (size_t i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
 996         snprintf(buffer, SIZE, " %02d", i);
 997         mStreams[i].dump(buffer + 3, SIZE);
 998         write(fd, buffer, strlen(buffer));
 999     }
1000
1001     snprintf(buffer, SIZE, "\nTotal Effects CPU: %f MIPS, Total Effects memory: %d KB\n",
1002             (float)mTotalEffectsCpuLoad/10, mTotalEffectsMemory);
1003     write(fd, buffer, strlen(buffer));
1004
1005     snprintf(buffer, SIZE, "Registered effects:\n");
1006     write(fd, buffer, strlen(buffer));
1007     for (size_t i = 0; i < mEffects.size(); i++) {
1008         snprintf(buffer, SIZE, "- Effect %d dump:\n", mEffects.keyAt(i));
1009         write(fd, buffer, strlen(buffer));
1010         mEffects.valueAt(i)->dump(fd);
1011     }
1012
1013
1014     return NO_ERROR;
1015 }
1016
1017 // ----------------------------------------------------------------------------
1018 // AudioPolicyManagerBase
1019 // ----------------------------------------------------------------------------
1020
1021 AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clientInterface)
1022     :
1023 #ifdef AUDIO_POLICY_TEST
1024     Thread(false),
1025 #endif //AUDIO_POLICY_TEST
1026     mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),
1027     mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
1028     mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0),
1029     mA2dpSuspended(false)
1030 {
1031     mpClientInterface = clientInterface;
1032
1033     for (int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {
1034         mForceUse[i] = AudioSystem::FORCE_NONE;
1035     }
1036
1037     initializeVolumeCurves();
1038
1039     // devices available by default are speaker, ear piece and microphone
1040     mAvailableOutputDevices = AudioSystem::DEVICE_OUT_EARPIECE |
1041                         AudioSystem::DEVICE_OUT_SPEAKER;
1042     mAvailableInputDevices = AudioSystem::DEVICE_IN_BUILTIN_MIC;
1043
1044 #ifdef WITH_A2DP
1045     mA2dpOutput = 0;
1046     mDuplicatedOutput = 0;
1047     mA2dpDeviceAddress = String8("");
1048 #endif
1049     mScoDeviceAddress = String8("");
1050
1051     // open hardware output
1052     AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
1053     outputDesc->mDevice = (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;
1054     mHardwareOutput = mpClientInterface->openOutput(&outputDesc->mDevice,
1055                                     &outputDesc->mSamplingRate,
1056                                     &outputDesc->mFormat,
1057                                     &outputDesc->mChannels,
1058                                     &outputDesc->mLatency,
1059                                     outputDesc->mFlags);
1060
1061     if (mHardwareOutput == 0) {
1062         LOGE("Failed to initialize hardware output stream, samplingRate: %d, format %d, channels %d",
1063                 outputDesc->mSamplingRate, outputDesc->mFormat, outputDesc->mChannels);
1064     } else {
1065         addOutput(mHardwareOutput, outputDesc);
1066         setOutputDevice(mHardwareOutput, (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER, true);
1067         //TODO: configure audio effect output stage here
1068     }
1069
1070     updateDeviceForStrategy();
1071 #ifdef AUDIO_POLICY_TEST
1072     if (mHardwareOutput != 0) {
1073         AudioParameter outputCmd = AudioParameter();
1074         outputCmd.addInt(String8("set_id"), 0);
1075         mpClientInterface->setParameters(mHardwareOutput, outputCmd.toString());
1076
1077         mTestDevice = AudioSystem::DEVICE_OUT_SPEAKER;
1078         mTestSamplingRate = 44100;
1079         mTestFormat = AudioSystem::PCM_16_BIT;
1080         mTestChannels =  AudioSystem::CHANNEL_OUT_STEREO;
1081         mTestLatencyMs = 0;
1082         mCurOutput = 0;
1083         mDirectOutput = false;
1084         for (int i = 0; i < NUM_TEST_OUTPUTS; i++) {
1085             mTestOutputs[i] = 0;
1086         }
1087
1088         const size_t SIZE = 256;
1089         char buffer[SIZE];
1090         snprintf(buffer, SIZE, "AudioPolicyManagerTest");
1091         run(buffer, ANDROID_PRIORITY_AUDIO);
1092     }
1093 #endif //AUDIO_POLICY_TEST
1094 }
1095
1096 AudioPolicyManagerBase::~AudioPolicyManagerBase()
1097 {
1098 #ifdef AUDIO_POLICY_TEST
1099     exit();
1100 #endif //AUDIO_POLICY_TEST
1101    for (size_t i = 0; i < mOutputs.size(); i++) {
1102         mpClientInterface->closeOutput(mOutputs.keyAt(i));
1103         delete mOutputs.valueAt(i);
1104    }
1105    mOutputs.clear();
1106    for (size_t i = 0; i < mInputs.size(); i++) {
1107         mpClientInterface->closeInput(mInputs.keyAt(i));
1108         delete mInputs.valueAt(i);
1109    }
1110    mInputs.clear();
1111 }
1112
1113 status_t AudioPolicyManagerBase::initCheck()
1114 {
1115     return (mHardwareOutput == 0) ? NO_INIT : NO_ERROR;
1116 }
1117
1118 #ifdef AUDIO_POLICY_TEST
1119 bool AudioPolicyManagerBase::threadLoop()
1120 {
1121     LOGV("entering threadLoop()");
1122     while (!exitPending())
1123     {
1124         String8 command;
1125         int valueInt;
1126         String8 value;
1127
1128         Mutex::Autolock _l(mLock);
1129         mWaitWorkCV.waitRelative(mLock, milliseconds(50));
1130
1131         command = mpClientInterface->getParameters(0, String8("test_cmd_policy"));
1132         AudioParameter param = AudioParameter(command);
1133
1134         if (param.getInt(String8("test_cmd_policy"), valueInt) == NO_ERROR &&
1135             valueInt != 0) {
1136             LOGV("Test command %s received", command.string());
1137             String8 target;
1138             if (param.get(String8("target"), target) != NO_ERROR) {
1139                 target = "Manager";
1140             }
1141             if (param.getInt(String8("test_cmd_policy_output"), valueInt) == NO_ERROR) {
1142                 param.remove(String8("test_cmd_policy_output"));
1143                 mCurOutput = valueInt;
1144             }
1145             if (param.get(String8("test_cmd_policy_direct"), value) == NO_ERROR) {
1146                 param.remove(String8("test_cmd_policy_direct"));
1147                 if (value == "false") {
1148                     mDirectOutput = false;
1149                 } else if (value == "true") {
1150                     mDirectOutput = true;
1151                 }
1152             }
1153             if (param.getInt(String8("test_cmd_policy_input"), valueInt) == NO_ERROR) {
1154                 param.remove(String8("test_cmd_policy_input"));
1155                 mTestInput = valueInt;
1156             }
1157
1158             if (param.get(String8("test_cmd_policy_format"), value) == NO_ERROR) {
1159                 param.remove(String8("test_cmd_policy_format"));
1160                 int format = AudioSystem::INVALID_FORMAT;
1161                 if (value == "PCM 16 bits") {
1162                     format = AudioSystem::PCM_16_BIT;
1163                 } else if (value == "PCM 8 bits") {
1164                     format = AudioSystem::PCM_8_BIT;
1165                 } else if (value == "Compressed MP3") {
1166                     format = AudioSystem::MP3;
1167                 }
1168                 if (format != AudioSystem::INVALID_FORMAT) {
1169                     if (target == "Manager") {
1170                         mTestFormat = format;
1171                     } else if (mTestOutputs[mCurOutput] != 0) {
1172                         AudioParameter outputParam = AudioParameter();
1173                         outputParam.addInt(String8("format"), format);
1174                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
1175                     }
1176                 }
1177             }
1178             if (param.get(String8("test_cmd_policy_channels"), value) == NO_ERROR) {
1179                 param.remove(String8("test_cmd_policy_channels"));
1180                 int channels = 0;
1181
1182                 if (value == "Channels Stereo") {
1183                     channels =  AudioSystem::CHANNEL_OUT_STEREO;
1184                 } else if (value == "Channels Mono") {
1185                     channels =  AudioSystem::CHANNEL_OUT_MONO;
1186                 }
1187                 if (channels != 0) {
1188                     if (target == "Manager") {
1189                         mTestChannels = channels;
1190                     } else if (mTestOutputs[mCurOutput] != 0) {
1191                         AudioParameter outputParam = AudioParameter();
1192                         outputParam.addInt(String8("channels"), channels);
1193                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
1194                     }
1195                 }
1196             }
1197             if (param.getInt(String8("test_cmd_policy_sampleRate"), valueInt) == NO_ERROR) {
1198                 param.remove(String8("test_cmd_policy_sampleRate"));
1199                 if (valueInt >= 0 && valueInt <= 96000) {
1200                     int samplingRate = valueInt;
1201                     if (target == "Manager") {
1202                         mTestSamplingRate = samplingRate;
1203                     } else if (mTestOutputs[mCurOutput] != 0) {
1204                         AudioParameter outputParam = AudioParameter();
1205                         outputParam.addInt(String8("sampling_rate"), samplingRate);
1206                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
1207                     }
1208                 }
1209             }
1210
1211             if (param.get(String8("test_cmd_policy_reopen"), value) == NO_ERROR) {
1212                 param.remove(String8("test_cmd_policy_reopen"));
1213
1214                 mpClientInterface->closeOutput(mHardwareOutput);
1215                 delete mOutputs.valueFor(mHardwareOutput);
1216                 mOutputs.removeItem(mHardwareOutput);
1217
1218                 AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
1219                 outputDesc->mDevice = (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;
1220                 mHardwareOutput = mpClientInterface->openOutput(&outputDesc->mDevice,
1221                                                 &outputDesc->mSamplingRate,
1222                                                 &outputDesc->mFormat,
1223                                                 &outputDesc->mChannels,
1224                                                 &outputDesc->mLatency,
1225                                                 outputDesc->mFlags);
1226                 if (mHardwareOutput == 0) {
1227                     LOGE("Failed to reopen hardware output stream, samplingRate: %d, format %d, channels %d",
1228                             outputDesc->mSamplingRate, outputDesc->mFormat, outputDesc->mChannels);
1229                 } else {
1230                     AudioParameter outputCmd = AudioParameter();
1231                     outputCmd.addInt(String8("set_id"), 0);
1232                     mpClientInterface->setParameters(mHardwareOutput, outputCmd.toString());
1233                     addOutput(mHardwareOutput, outputDesc);
1234                 }
1235             }
1236
1237
1238             mpClientInterface->setParameters(0, String8("test_cmd_policy="));
1239         }
1240     }
1241     return false;
1242 }
1243
1244 void AudioPolicyManagerBase::exit()
1245 {
1246     {
1247         AutoMutex _l(mLock);
1248         requestExit();
1249         mWaitWorkCV.signal();
1250     }
1251     requestExitAndWait();
1252 }
1253
1254 int AudioPolicyManagerBase::testOutputIndex(audio_io_handle_t output)
1255 {
1256     for (int i = 0; i < NUM_TEST_OUTPUTS; i++) {
1257         if (output == mTestOutputs[i]) return i;
1258     }
1259     return 0;
1260 }
1261 #endif //AUDIO_POLICY_TEST
1262
1263 // ---
1264
1265 void AudioPolicyManagerBase::addOutput(audio_io_handle_t id, AudioOutputDescriptor *outputDesc)
1266 {
1267     outputDesc->mId = id;
1268     mOutputs.add(id, outputDesc);
1269 }
1270
1271
1272 #ifdef WITH_A2DP
1273 status_t AudioPolicyManagerBase::handleA2dpConnection(AudioSystem::audio_devices device,
1274                                                  const char *device_address)
1275 {
1276     // when an A2DP device is connected, open an A2DP and a duplicated output
1277     LOGV("opening A2DP output for device %s", device_address);
1278     AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
1279     outputDesc->mDevice = device;
1280     mA2dpOutput = mpClientInterface->openOutput(&outputDesc->mDevice,
1281                                             &outputDesc->mSamplingRate,
1282                                             &outputDesc->mFormat,
1283                                             &outputDesc->mChannels,
1284                                             &outputDesc->mLatency,
1285                                             outputDesc->mFlags);
1286     if (mA2dpOutput) {
1287         // add A2DP output descriptor
1288         addOutput(mA2dpOutput, outputDesc);
1289
1290         //TODO: configure audio effect output stage here
1291
1292         // set initial stream volume for A2DP device
1293         applyStreamVolumes(mA2dpOutput, device);
1294         if (a2dpUsedForSonification()) {
1295             mDuplicatedOutput = mpClientInterface->openDuplicateOutput(mA2dpOutput, mHardwareOutput);
1296         }
1297         if (mDuplicatedOutput != 0 ||
1298             !a2dpUsedForSonification()) {
1299             // If both A2DP and duplicated outputs are open, send device address to A2DP hardware
1300             // interface
1301             AudioParameter param;
1302             param.add(String8("a2dp_sink_address"), String8(device_address));
1303             mpClientInterface->setParameters(mA2dpOutput, param.toString());
1304             mA2dpDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
1305
1306             if (a2dpUsedForSonification()) {
1307                 // add duplicated output descriptor
1308                 AudioOutputDescriptor *dupOutputDesc = new AudioOutputDescriptor();
1309                 dupOutputDesc->mOutput1 = mOutputs.valueFor(mHardwareOutput);
1310                 dupOutputDesc->mOutput2 = mOutputs.valueFor(mA2dpOutput);
1311                 dupOutputDesc->mSamplingRate = outputDesc->mSamplingRate;
1312                 dupOutputDesc->mFormat = outputDesc->mFormat;
1313                 dupOutputDesc->mChannels = outputDesc->mChannels;
1314                 dupOutputDesc->mLatency = outputDesc->mLatency;
1315                 addOutput(mDuplicatedOutput, dupOutputDesc);
1316                 applyStreamVolumes(mDuplicatedOutput, device);
1317             }
1318         } else {
1319             LOGW("getOutput() could not open duplicated output for %d and %d",
1320                     mHardwareOutput, mA2dpOutput);
1321             mpClientInterface->closeOutput(mA2dpOutput);
1322             mOutputs.removeItem(mA2dpOutput);
1323             mA2dpOutput = 0;
1324             delete outputDesc;
1325             return NO_INIT;
1326         }
1327     } else {
1328         LOGW("setDeviceConnectionState() could not open A2DP output for device %x", device);
1329         delete outputDesc;
1330         return NO_INIT;
1331     }
1332     AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mHardwareOutput);
1333
1334     if (!a2dpUsedForSonification()) {
1335         // mute music on A2DP output if a notification or ringtone is playing
1336         uint32_t refCount = hwOutputDesc->strategyRefCount(STRATEGY_SONIFICATION);
1337         for (uint32_t i = 0; i < refCount; i++) {
1338             setStrategyMute(STRATEGY_MEDIA, true, mA2dpOutput);
1339         }
1340     }
1341
1342     mA2dpSuspended = false;
1343
1344     return NO_ERROR;
1345 }
1346
1347 status_t AudioPolicyManagerBase::handleA2dpDisconnection(AudioSystem::audio_devices device,
1348                                                     const char *device_address)
1349 {
1350     if (mA2dpOutput == 0) {
1351         LOGW("setDeviceConnectionState() disconnecting A2DP and no A2DP output!");
1352         return INVALID_OPERATION;
1353     }
1354
1355     if (mA2dpDeviceAddress != device_address) {
1356         LOGW("setDeviceConnectionState() disconnecting unknow A2DP sink address %s", device_address);
1357         return INVALID_OPERATION;
1358     }
1359
1360     // mute media strategy to avoid outputting sound on hardware output while music stream
1361     // is switched from A2DP output and before music is paused by music application
1362     setStrategyMute(STRATEGY_MEDIA, true, mHardwareOutput);
1363     setStrategyMute(STRATEGY_MEDIA, false, mHardwareOutput, MUTE_TIME_MS);
1364
1365     if (!a2dpUsedForSonification()) {
1366         // unmute music on A2DP output if a notification or ringtone is playing
1367         uint32_t refCount = mOutputs.valueFor(mHardwareOutput)->strategyRefCount(STRATEGY_SONIFICATION);
1368         for (uint32_t i = 0; i < refCount; i++) {
1369             setStrategyMute(STRATEGY_MEDIA, false, mA2dpOutput);
1370         }
1371     }
1372     mA2dpDeviceAddress = "";
1373     mA2dpSuspended = false;
1374     return NO_ERROR;
1375 }
1376
1377 void AudioPolicyManagerBase::closeA2dpOutputs()
1378 {
1379
1380     LOGV("setDeviceConnectionState() closing A2DP and duplicated output!");
1381
1382     if (mDuplicatedOutput != 0) {
1383         AudioOutputDescriptor *dupOutputDesc = mOutputs.valueFor(mDuplicatedOutput);
1384         AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mHardwareOutput);
1385         // As all active tracks on duplicated output will be deleted,
1386         // and as they were also referenced on hardware output, the reference
1387         // count for their stream type must be adjusted accordingly on
1388         // hardware output.
1389         for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {
1390             int refCount = dupOutputDesc->mRefCount[i];
1391             hwOutputDesc->changeRefCount((AudioSystem::stream_type)i,-refCount);
1392         }
1393
1394         mpClientInterface->closeOutput(mDuplicatedOutput);
1395         delete mOutputs.valueFor(mDuplicatedOutput);
1396         mOutputs.removeItem(mDuplicatedOutput);
1397         mDuplicatedOutput = 0;
1398     }
1399     if (mA2dpOutput != 0) {
1400         AudioParameter param;
1401         param.add(String8("closing"), String8("true"));
1402         mpClientInterface->setParameters(mA2dpOutput, param.toString());
1403
1404         mpClientInterface->closeOutput(mA2dpOutput);
1405         delete mOutputs.valueFor(mA2dpOutput);
1406         mOutputs.removeItem(mA2dpOutput);
1407         mA2dpOutput = 0;
1408     }
1409 }
1410
1411 void AudioPolicyManagerBase::checkOutputForStrategy(routing_strategy strategy)
1412 {
1413     uint32_t prevDevice = getDeviceForStrategy(strategy);
1414     uint32_t curDevice = getDeviceForStrategy(strategy, false);
1415     bool a2dpWasUsed = AudioSystem::isA2dpDevice((AudioSystem::audio_devices)(prevDevice & ~AudioSystem::DEVICE_OUT_SPEAKER));
1416     bool a2dpIsUsed = AudioSystem::isA2dpDevice((AudioSystem::audio_devices)(curDevice & ~AudioSystem::DEVICE_OUT_SPEAKER));
1417     audio_io_handle_t srcOutput = 0;
1418     audio_io_handle_t dstOutput = 0;
1419
1420     if (a2dpWasUsed && !a2dpIsUsed) {
1421         bool dupUsed = a2dpUsedForSonification() && a2dpWasUsed && (AudioSystem::popCount(prevDevice) == 2);
1422         dstOutput = mHardwareOutput;
1423         if (dupUsed) {
1424             LOGV("checkOutputForStrategy() moving strategy %d from duplicated", strategy);
1425             srcOutput = mDuplicatedOutput;
1426         } else {
1427             LOGV("checkOutputForStrategy() moving strategy %d from a2dp", strategy);
1428             srcOutput = mA2dpOutput;
1429         }
1430     }
1431     if (a2dpIsUsed && !a2dpWasUsed) {
1432         bool dupUsed = a2dpUsedForSonification() && a2dpIsUsed && (AudioSystem::popCount(curDevice) == 2);
1433         srcOutput = mHardwareOutput;
1434         if (dupUsed) {
1435             LOGV("checkOutputForStrategy() moving strategy %d to duplicated", strategy);
1436             dstOutput = mDuplicatedOutput;
1437         } else {
1438             LOGV("checkOutputForStrategy() moving strategy %d to a2dp", strategy);
1439             dstOutput = mA2dpOutput;
1440         }
1441     }
1442
1443     if (srcOutput != 0 && dstOutput != 0) {
1444         // Move effects associated to this strategy from previous output to new output
1445         for (size_t i = 0; i < mEffects.size(); i++) {
1446             EffectDescriptor *desc = mEffects.valueAt(i);
1447             if (desc->mSession != AudioSystem::SESSION_OUTPUT_STAGE &&
1448                     desc->mStrategy == strategy &&
1449                     desc->mIo == srcOutput) {
1450                 LOGV("checkOutputForStrategy() moving effect %d to output %d", mEffects.keyAt(i), dstOutput);
1451                 mpClientInterface->moveEffects(desc->mSession, srcOutput, dstOutput);
1452                 desc->mIo = dstOutput;
1453             }
1454         }
1455         // Move tracks associated to this strategy from previous output to new output
1456         for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {
1457             if (getStrategy((AudioSystem::stream_type)i) == strategy) {
1458                 mpClientInterface->setStreamOutput((AudioSystem::stream_type)i, dstOutput);
1459             }
1460         }
1461     }
1462 }
1463
1464 void AudioPolicyManagerBase::checkOutputForAllStrategies()
1465 {
1466     checkOutputForStrategy(STRATEGY_PHONE);
1467     checkOutputForStrategy(STRATEGY_SONIFICATION);
1468     checkOutputForStrategy(STRATEGY_MEDIA);
1469     checkOutputForStrategy(STRATEGY_DTMF);
1470 }
1471
1472 void AudioPolicyManagerBase::checkA2dpSuspend()
1473 {
1474     // suspend A2DP output if:
1475     //      (NOT already suspended) &&
1476     //      ((SCO device is connected &&
1477     //       (forced usage for communication || for record is SCO))) ||
1478     //      (phone state is ringing || in call)
1479     //
1480     // restore A2DP output if:
1481     //      (Already suspended) &&
1482     //      ((SCO device is NOT connected ||
1483     //       (forced usage NOT for communication && NOT for record is SCO))) &&
1484     //      (phone state is NOT ringing && NOT in call)
1485     //
1486     if (mA2dpOutput == 0) {
1487         return;
1488     }
1489
1490     if (mA2dpSuspended) {
1491         if (((mScoDeviceAddress == "") ||
1492              ((mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO) &&
1493               (mForceUse[AudioSystem::FOR_RECORD] != AudioSystem::FORCE_BT_SCO))) &&
1494              ((mPhoneState != AudioSystem::MODE_IN_CALL) &&
1495               (mPhoneState != AudioSystem::MODE_RINGTONE))) {
1496
1497             mpClientInterface->restoreOutput(mA2dpOutput);
1498             mA2dpSuspended = false;
1499         }
1500     } else {
1501         if (((mScoDeviceAddress != "") &&
1502              ((mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
1503               (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO))) ||
1504              ((mPhoneState == AudioSystem::MODE_IN_CALL) ||
1505               (mPhoneState == AudioSystem::MODE_RINGTONE))) {
1506
1507             mpClientInterface->suspendOutput(mA2dpOutput);
1508             mA2dpSuspended = true;
1509         }
1510     }
1511 }
1512
1513
1514 #endif
1515
1516 uint32_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output, bool fromCache)
1517 {
1518     uint32_t device = 0;
1519
1520     AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
1521     // check the following by order of priority to request a routing change if necessary:
1522     // 1: we are in call or the strategy phone is active on the hardware output:
1523     //      use device for strategy phone
1524     // 2: the strategy sonification is active on the hardware output:
1525     //      use device for strategy sonification
1526     // 3: the strategy media is active on the hardware output:
1527     //      use device for strategy media
1528     // 4: the strategy DTMF is active on the hardware output:
1529     //      use device for strategy DTMF
1530     if (isInCall() ||
1531         outputDesc->isUsedByStrategy(STRATEGY_PHONE)) {
1532         device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
1533     } else if (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) {
1534         device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
1535     } else if (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) {
1536         device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
1537     } else if (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) {
1538         device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
1539     }
1540
1541     LOGV("getNewDevice() selected device %x", device);
1542     return device;
1543 }
1544
1545 uint32_t AudioPolicyManagerBase::getStrategyForStream(AudioSystem::stream_type stream) {
1546     return (uint32_t)getStrategy(stream);
1547 }
1548
1549 uint32_t AudioPolicyManagerBase::getDevicesForStream(AudioSystem::stream_type stream) {
1550     uint32_t devices;
1551     // By checking the range of stream before calling getStrategy, we avoid
1552     // getStrategy's behavior for invalid streams.  getStrategy would do a LOGE
1553     // and then return STRATEGY_MEDIA, but we want to return the empty set.
1554     if (stream < (AudioSystem::stream_type) 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
1555         devices = 0;
1556     } else {
1557         AudioPolicyManagerBase::routing_strategy strategy = getStrategy(stream);
1558         devices = getDeviceForStrategy(strategy, true);
1559     }
1560     return devices;
1561 }
1562
1563 AudioPolicyManagerBase::routing_strategy AudioPolicyManagerBase::getStrategy(
1564         AudioSystem::stream_type stream) {
1565     // stream to strategy mapping
1566     switch (stream) {
1567     case AudioSystem::VOICE_CALL:
1568     case AudioSystem::BLUETOOTH_SCO:
1569         return STRATEGY_PHONE;
1570     case AudioSystem::RING:
1571     case AudioSystem::NOTIFICATION:
1572     case AudioSystem::ALARM:
1573     case AudioSystem::ENFORCED_AUDIBLE:
1574         return STRATEGY_SONIFICATION;
1575     case AudioSystem::DTMF:
1576         return STRATEGY_DTMF;
1577     default:
1578         LOGE("unknown stream type");
1579     case AudioSystem::SYSTEM:
1580         // NOTE: SYSTEM stream uses MEDIA strategy because muting music and switching outputs
1581         // while key clicks are played produces a poor result
1582     case AudioSystem::TTS:
1583     case AudioSystem::MUSIC:
1584         return STRATEGY_MEDIA;
1585     }
1586 }
1587
1588 uint32_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy strategy, bool fromCache)
1589 {
1590     uint32_t device = 0;
1591
1592     if (fromCache) {
1593         LOGV("getDeviceForStrategy() from cache strategy %d, device %x", strategy, mDeviceForStrategy[strategy]);
1594         return mDeviceForStrategy[strategy];
1595     }
1596
1597     switch (strategy) {
1598     case STRATEGY_DTMF:
1599         if (!isInCall()) {
1600             // when off call, DTMF strategy follows the same rules as MEDIA strategy
1601             device = getDeviceForStrategy(STRATEGY_MEDIA, false);
1602             break;
1603         }
1604         // when in call, DTMF and PHONE strategies follow the same rules
1605         // FALL THROUGH
1606
1607     case STRATEGY_PHONE:
1608         // for phone strategy, we first consider the forced use and then the available devices by order
1609         // of priority
1610         switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) {
1611         case AudioSystem::FORCE_BT_SCO:
1612             if (!isInCall() || strategy != STRATEGY_DTMF) {
1613                 device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT;
1614                 if (device) break;
1615             }
1616             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET;
1617             if (device) break;
1618             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO;
1619             if (device) break;
1620             // if SCO device is requested but no SCO device is available, fall back to default case
1621             // FALL THROUGH
1622
1623         default:    // FORCE_NONE
1624             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE;
1625             if (device) break;
1626             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET;
1627             if (device) break;
1628 #ifdef WITH_A2DP
1629             // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to A2DP
1630             if (!isInCall() && !mA2dpSuspended) {
1631                 device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP;
1632                 if (device) break;
1633                 device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
1634                 if (device) break;
1635             }
1636 #endif
1637             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL;
1638             if (device) break;
1639             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET;
1640             if (device) break;
1641             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET;
1642             if (device) break;
1643             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_EARPIECE;
1644             if (device == 0) {
1645                 LOGE("getDeviceForStrategy() earpiece device not found");
1646             }
1647             break;
1648
1649         case AudioSystem::FORCE_SPEAKER:
1650 #ifdef WITH_A2DP
1651             // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to
1652             // A2DP speaker when forcing to speaker output
1653             if (!isInCall() && !mA2dpSuspended) {
1654                 device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
1655                 if (device) break;
1656             }
1657 #endif
1658             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL;
1659             if (device) break;
1660             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET;
1661             if (device) break;
1662             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET;
1663             if (device) break;
1664             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;
1665             if (device == 0) {
1666                 LOGE("getDeviceForStrategy() speaker device not found");
1667             }
1668             break;
1669         }
1670     break;
1671
1672     case STRATEGY_SONIFICATION:
1673
1674         // If incall, just select the STRATEGY_PHONE device: The rest of the behavior is handled by
1675         // handleIncallSonification().
1676         if (isInCall()) {
1677             device = getDeviceForStrategy(STRATEGY_PHONE, false);
1678             break;
1679         }
1680         device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;
1681         if (device == 0) {
1682             LOGE("getDeviceForStrategy() speaker device not found");
1683         }
1684         // The second device used for sonification is the same as the device used by media strategy
1685         // FALL THROUGH
1686
1687     case STRATEGY_MEDIA: {
1688         uint32_t device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE;
1689         if (device2 == 0) {
1690             device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET;
1691         }
1692 #ifdef WITH_A2DP
1693         if ((mA2dpOutput != 0) && !mA2dpSuspended &&
1694                 (strategy != STRATEGY_SONIFICATION || a2dpUsedForSonification())) {
1695             if (device2 == 0) {
1696                 device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP;
1697             }
1698             if (device2 == 0) {
1699                 device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
1700             }
1701             if (device2 == 0) {
1702                 device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
1703             }
1704         }
1705 #endif
1706         if (device2 == 0) {
1707             device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL;
1708         }
1709         if (device2 == 0) {
1710             device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET;
1711         }
1712         if (device2 == 0) {
1713             device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET;
1714         }
1715         if (device2 == 0) {
1716             device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;
1717         }
1718
1719         // device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION, 0 otherwise
1720         device |= device2;
1721         if (device == 0) {
1722             LOGE("getDeviceForStrategy() speaker device not found");
1723         }
1724         } break;
1725
1726     default:
1727         LOGW("getDeviceForStrategy() unknown strategy: %d", strategy);
1728         break;
1729     }
1730
1731     LOGV("getDeviceForStrategy() strategy %d, device %x", strategy, device);
1732     return device;
1733 }
1734
1735 void AudioPolicyManagerBase::updateDeviceForStrategy()
1736 {
1737     for (int i = 0; i < NUM_STRATEGIES; i++) {
1738         mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false);
1739     }
1740 }
1741
1742 void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_t output, uint32_t device, bool force, int delayMs)
1743 {
1744     LOGV("setOutputDevice() output %d device %x delayMs %d", output, device, delayMs);
1745     AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
1746
1747
1748     if (outputDesc->isDuplicated()) {
1749         setOutputDevice(outputDesc->mOutput1->mId, device, force, delayMs);
1750         setOutputDevice(outputDesc->mOutput2->mId, device, force, delayMs);
1751         return;
1752     }
1753 #ifdef WITH_A2DP
1754     // filter devices according to output selected
1755     if (output == mA2dpOutput) {
1756         device &= AudioSystem::DEVICE_OUT_ALL_A2DP;
1757     } else {
1758         device &= ~AudioSystem::DEVICE_OUT_ALL_A2DP;
1759     }
1760 #endif
1761
1762     uint32_t prevDevice = (uint32_t)outputDesc->device();
1763     // Do not change the routing if:
1764     //  - the requestede device is 0
1765     //  - the requested device is the same as current device and force is not specified.
1766     // Doing this check here allows the caller to call setOutputDevice() without conditions
1767     if ((device == 0 || device == prevDevice) && !force) {
1768         LOGV("setOutputDevice() setting same device %x or null device for output %d", device, output);
1769         return;
1770     }
1771
1772     outputDesc->mDevice = device;
1773     // mute media streams if both speaker and headset are selected
1774     if (output == mHardwareOutput && AudioSystem::popCount(device) == 2) {
1775         setStrategyMute(STRATEGY_MEDIA, true, output);
1776         // wait for the PCM output buffers to empty before proceeding with the rest of the command
1777         usleep(outputDesc->mLatency*2*1000);
1778     }
1779
1780     // do the routing
1781     AudioParameter param = AudioParameter();
1782     param.addInt(String8(AudioParameter::keyRouting), (int)device);
1783     mpClientInterface->setParameters(mHardwareOutput, param.toString(), delayMs);
1784     // update stream volumes according to new device
1785     applyStreamVolumes(output, device, delayMs);
1786
1787     // if changing from a combined headset + speaker route, unmute media streams
1788     if (output == mHardwareOutput && AudioSystem::popCount(prevDevice) == 2) {
1789         setStrategyMute(STRATEGY_MEDIA, false, output, delayMs);
1790     }
1791 }
1792
1793 uint32_t AudioPolicyManagerBase::getDeviceForInputSource(int inputSource)
1794 {
1795     uint32_t device;
1796
1797     switch(inputSource) {
1798     case AUDIO_SOURCE_DEFAULT:
1799     case AUDIO_SOURCE_MIC:
1800     case AUDIO_SOURCE_VOICE_RECOGNITION:
1801     case AUDIO_SOURCE_VOICE_COMMUNICATION:
1802         if (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO &&
1803             mAvailableInputDevices & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
1804             device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
1805         } else if (mAvailableInputDevices & AudioSystem::DEVICE_IN_WIRED_HEADSET) {
1806             device = AudioSystem::DEVICE_IN_WIRED_HEADSET;
1807         } else {
1808             device = AudioSystem::DEVICE_IN_BUILTIN_MIC;
1809         }
1810         break;
1811     case AUDIO_SOURCE_CAMCORDER:
1812         if (hasBackMicrophone()) {
1813             device = AudioSystem::DEVICE_IN_BACK_MIC;
1814         } else {
1815             device = AudioSystem::DEVICE_IN_BUILTIN_MIC;
1816         }
1817         break;
1818     case AUDIO_SOURCE_VOICE_UPLINK:
1819     case AUDIO_SOURCE_VOICE_DOWNLINK:
1820     case AUDIO_SOURCE_VOICE_CALL:
1821         device = AudioSystem::DEVICE_IN_VOICE_CALL;
1822         break;
1823     default:
1824         LOGW("getDeviceForInputSource() invalid input source %d", inputSource);
1825         device = 0;
1826         break;
1827     }
1828     LOGV("getDeviceForInputSource()input source %d, device %08x", inputSource, device);
1829     return device;
1830 }
1831
1832 audio_io_handle_t AudioPolicyManagerBase::getActiveInput()
1833 {
1834     for (size_t i = 0; i < mInputs.size(); i++) {
1835         if (mInputs.valueAt(i)->mRefCount > 0) {
1836             return mInputs.keyAt(i);
1837         }
1838     }
1839     return 0;
1840 }
1841
1842 float AudioPolicyManagerBase::volIndexToAmpl(uint32_t device, const StreamDescriptor& streamDesc,
1843         int indexInUi) {
1844     // the volume index in the UI is relative to the min and max volume indices for this stream type
1845     int nbSteps = 1 + streamDesc.mVolIndex[StreamDescriptor::VOLMAX] -
1846             streamDesc.mVolIndex[StreamDescriptor::VOLMIN];
1847     int volIdx = (nbSteps * (indexInUi - streamDesc.mIndexMin)) /
1848             (streamDesc.mIndexMax - streamDesc.mIndexMin);
1849
1850     // find what part of the curve this index volume belongs to, or if it's out of bounds
1851     int segment = 0;
1852     if (volIdx < streamDesc.mVolIndex[StreamDescriptor::VOLMIN]) {         // out of bounds
1853         return 0.0f;
1854     } else if (volIdx < streamDesc.mVolIndex[StreamDescriptor::VOLKNEE1]) {
1855         segment = 0;
1856     } else if (volIdx < streamDesc.mVolIndex[StreamDescriptor::VOLKNEE2]) {
1857         segment = 1;
1858     } else if (volIdx <= streamDesc.mVolIndex[StreamDescriptor::VOLMAX]) {
1859         segment = 2;
1860     } else {                                                               // out of bounds
1861         return 1.0f;
1862     }
1863
1864     // linear interpolation in the attenuation table in dB
1865     float decibels = streamDesc.mVolDbAtt[segment] +
1866             ((float)(volIdx - streamDesc.mVolIndex[segment])) *
1867                 ( (streamDesc.mVolDbAtt[segment+1] - streamDesc.mVolDbAtt[segment]) /
1868                     ((float)(streamDesc.mVolIndex[segment+1] - streamDesc.mVolIndex[segment])) );
1869
1870     float amplification = exp( decibels * 0.115129f); // exp( dB * ln(10) / 20 )
1871
1872     LOGV("VOLUME vol index=[%d %d %d], dB=[%.1f %.1f %.1f] ampl=%.5f",
1873             streamDesc.mVolIndex[segment], volIdx, streamDesc.mVolIndex[segment+1],
1874             streamDesc.mVolDbAtt[segment], decibels, streamDesc.mVolDbAtt[segment+1],
1875             amplification);
1876
1877     return amplification;
1878 }
1879
1880 void AudioPolicyManagerBase::initializeVolumeCurves() {
1881     // initialize the volume curves to a (-49.5 - 0 dB) attenuation in 0.5dB steps
1882     for (int i=0 ; i< AudioSystem::NUM_STREAM_TYPES ; i++) {
1883         mStreams[i].mVolIndex[StreamDescriptor::VOLMIN] = 1;
1884         mStreams[i].mVolDbAtt[StreamDescriptor::VOLMIN] = -49.5f;
1885         mStreams[i].mVolIndex[StreamDescriptor::VOLKNEE1] = 33;
1886         mStreams[i].mVolDbAtt[StreamDescriptor::VOLKNEE1] = -33.5f;
1887         mStreams[i].mVolIndex[StreamDescriptor::VOLKNEE2] = 66;
1888         mStreams[i].mVolDbAtt[StreamDescriptor::VOLKNEE2] = -17.0f;
1889         // here we use 100 steps to avoid rounding errors
1890         // when computing the volume in volIndexToAmpl()
1891         mStreams[i].mVolIndex[StreamDescriptor::VOLMAX] = 100;
1892         mStreams[i].mVolDbAtt[StreamDescriptor::VOLMAX] = 0.0f;
1893     }
1894
1895     // Modification for music: more attenuation for lower volumes, finer steps at high volumes
1896     mStreams[AudioSystem::MUSIC].mVolIndex[StreamDescriptor::VOLMIN] = 1;
1897     mStreams[AudioSystem::MUSIC].mVolDbAtt[StreamDescriptor::VOLMIN] = -58.0f;
1898     mStreams[AudioSystem::MUSIC].mVolIndex[StreamDescriptor::VOLKNEE1] = 20;
1899     mStreams[AudioSystem::MUSIC].mVolDbAtt[StreamDescriptor::VOLKNEE1] = -40.0f;
1900     mStreams[AudioSystem::MUSIC].mVolIndex[StreamDescriptor::VOLKNEE2] = 60;
1901     mStreams[AudioSystem::MUSIC].mVolDbAtt[StreamDescriptor::VOLKNEE2] = -17.0f;
1902     mStreams[AudioSystem::MUSIC].mVolIndex[StreamDescriptor::VOLMAX] = 100;
1903     mStreams[AudioSystem::MUSIC].mVolDbAtt[StreamDescriptor::VOLMAX] = 0.0f;
1904 }
1905
1906 float AudioPolicyManagerBase::computeVolume(int stream, int index, audio_io_handle_t output, uint32_t device)
1907 {
1908     float volume = 1.0;
1909     AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
1910     StreamDescriptor &streamDesc = mStreams[stream];
1911
1912     if (device == 0) {
1913         device = outputDesc->device();
1914     }
1915
1916     // if volume is not 0 (not muted), force media volume to max on digital output
1917     if (stream == AudioSystem::MUSIC &&
1918         index != mStreams[stream].mIndexMin &&
1919         device == AudioSystem::DEVICE_OUT_AUX_DIGITAL) {
1920         return 1.0;
1921     }
1922
1923     volume = volIndexToAmpl(device, streamDesc, index);
1924
1925     // if a headset is connected, apply the following rules to ring tones and notifications
1926     // to avoid sound level bursts in user's ears:
1927     // - always attenuate ring tones and notifications volume by 6dB
1928     // - if music is playing, always limit the volume to current music volume,
1929     // with a minimum threshold at -36dB so that notification is always perceived.
1930     if ((device &
1931         (AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP |
1932         AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
1933         AudioSystem::DEVICE_OUT_WIRED_HEADSET |
1934         AudioSystem::DEVICE_OUT_WIRED_HEADPHONE)) &&
1935         ((getStrategy((AudioSystem::stream_type)stream) == STRATEGY_SONIFICATION) ||
1936          (stream == AudioSystem::SYSTEM)) &&
1937         streamDesc.mCanBeMuted) {
1938         volume *= SONIFICATION_HEADSET_VOLUME_FACTOR;
1939         // when the phone is ringing we must consider that music could have been paused just before
1940         // by the music application and behave as if music was active if the last music track was
1941         // just stopped
1942         if (outputDesc->mRefCount[AudioSystem::MUSIC] || mLimitRingtoneVolume) {
1943             float musicVol = computeVolume(AudioSystem::MUSIC, mStreams[AudioSystem::MUSIC].mIndexCur, output, device);
1944             float minVol = (musicVol > SONIFICATION_HEADSET_VOLUME_MIN) ? musicVol : SONIFICATION_HEADSET_VOLUME_MIN;
1945             if (volume > minVol) {
1946                 volume = minVol;
1947                 LOGV("computeVolume limiting volume to %f musicVol %f", minVol, musicVol);
1948             }
1949         }
1950     }
1951
1952     return volume;
1953 }
1954
1955 status_t AudioPolicyManagerBase::checkAndSetVolume(int stream, int index, audio_io_handle_t output, uint32_t device, int delayMs, bool force)
1956 {
1957
1958     // do not change actual stream volume if the stream is muted
1959     if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) {
1960         LOGV("checkAndSetVolume() stream %d muted count %d", stream, mOutputs.valueFor(output)->mMuteCount[stream]);
1961         return NO_ERROR;
1962     }
1963
1964     // do not change in call volume if bluetooth is connected and vice versa
1965     if ((stream == AudioSystem::VOICE_CALL && mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
1966         (stream == AudioSystem::BLUETOOTH_SCO && mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO)) {
1967         LOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
1968              stream, mForceUse[AudioSystem::FOR_COMMUNICATION]);
1969         return INVALID_OPERATION;
1970     }
1971
1972     float volume = computeVolume(stream, index, output, device);
1973     // We actually change the volume if:
1974     // - the float value returned by computeVolume() changed
1975     // - the force flag is set
1976     if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||
1977             force) {
1978         mOutputs.valueFor(output)->mCurVolume[stream] = volume;
1979         LOGV("setStreamVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs);
1980         if (stream == AudioSystem::VOICE_CALL ||
1981             stream == AudioSystem::DTMF ||
1982             stream == AudioSystem::BLUETOOTH_SCO) {
1983             // offset value to reflect actual hardware volume that never reaches 0
1984             // 1% corresponds roughly to first step in VOICE_CALL stream volume setting (see AudioService.java)
1985             volume = 0.01 + 0.99 * volume;
1986             // Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is
1987             // enabled
1988             if (stream == AudioSystem::BLUETOOTH_SCO) {
1989                 mpClientInterface->setStreamVolume(AudioSystem::VOICE_CALL, volume, output, delayMs);
1990             }
1991         }
1992
1993         mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);
1994     }
1995
1996     if (stream == AudioSystem::VOICE_CALL ||
1997         stream == AudioSystem::BLUETOOTH_SCO) {
1998         float voiceVolume;
1999         // Force voice volume to max for bluetooth SCO as volume is managed by the headset
2000         if (stream == AudioSystem::VOICE_CALL) {
2001             voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
2002         } else {
2003             voiceVolume = 1.0;
2004         }
2005
2006         if (voiceVolume != mLastVoiceVolume && output == mHardwareOutput) {
2007             mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
2008             mLastVoiceVolume = voiceVolume;
2009         }
2010     }
2011
2012     return NO_ERROR;
2013 }
2014
2015 void AudioPolicyManagerBase::applyStreamVolumes(audio_io_handle_t output, uint32_t device, int delayMs, bool force)
2016 {
2017     LOGV("applyStreamVolumes() for output %d and device %x", output, device);
2018
2019     for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
2020         checkAndSetVolume(stream, mStreams[stream].mIndexCur, output, device, delayMs, force);
2021     }
2022 }
2023
2024 void AudioPolicyManagerBase::setStrategyMute(routing_strategy strategy, bool on, audio_io_handle_t output, int delayMs)
2025 {
2026     LOGV("setStrategyMute() strategy %d, mute %d, output %d", strategy, on, output);
2027     for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
2028         if (getStrategy((AudioSystem::stream_type)stream) == strategy) {
2029             setStreamMute(stream, on, output, delayMs);
2030         }
2031     }
2032 }
2033
2034 void AudioPolicyManagerBase::setStreamMute(int stream, bool on, audio_io_handle_t output, int delayMs)
2035 {
2036     StreamDescriptor &streamDesc = mStreams[stream];
2037     AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
2038
2039     LOGV("setStreamMute() stream %d, mute %d, output %d, mMuteCount %d", stream, on, output, outputDesc->mMuteCount[stream]);
2040
2041     if (on) {
2042         if (outputDesc->mMuteCount[stream] == 0) {
2043             if (streamDesc.mCanBeMuted) {
2044                 checkAndSetVolume(stream, 0, output, outputDesc->device(), delayMs);
2045             }
2046         }
2047         // increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignored
2048         outputDesc->mMuteCount[stream]++;
2049     } else {
2050         if (outputDesc->mMuteCount[stream] == 0) {
2051             LOGW("setStreamMute() unmuting non muted stream!");
2052             return;
2053         }
2054         if (--outputDesc->mMuteCount[stream] == 0) {
2055             checkAndSetVolume(stream, streamDesc.mIndexCur, output, outputDesc->device(), delayMs);
2056         }
2057     }
2058 }
2059
2060 void AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting, bool stateChange)
2061 {
2062     // if the stream pertains to sonification strategy and we are in call we must
2063     // mute the stream if it is low visibility. If it is high visibility, we must play a tone
2064     // in the device used for phone strategy and play the tone if the selected device does not
2065     // interfere with the device used for phone strategy
2066     // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as
2067     // many times as there are active tracks on the output
2068
2069     if (getStrategy((AudioSystem::stream_type)stream) == STRATEGY_SONIFICATION) {
2070         AudioOutputDescriptor *outputDesc = mOutputs.valueFor(mHardwareOutput);
2071         LOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d",
2072                 stream, starting, outputDesc->mDevice, stateChange);
2073         if (outputDesc->mRefCount[stream]) {
2074             int muteCount = 1;
2075             if (stateChange) {
2076                 muteCount = outputDesc->mRefCount[stream];
2077             }
2078             if (AudioSystem::isLowVisibility((AudioSystem::stream_type)stream)) {
2079                 LOGV("handleIncallSonification() low visibility, muteCount %d", muteCount);
2080                 for (int i = 0; i < muteCount; i++) {
2081                     setStreamMute(stream, starting, mHardwareOutput);
2082                 }
2083             } else {
2084                 LOGV("handleIncallSonification() high visibility");
2085                 if (outputDesc->device() & getDeviceForStrategy(STRATEGY_PHONE)) {
2086                     LOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount);
2087                     for (int i = 0; i < muteCount; i++) {
2088                         setStreamMute(stream, starting, mHardwareOutput);
2089                     }
2090                 }
2091                 if (starting) {
2092                     mpClientInterface->startTone(ToneGenerator::TONE_SUP_CALL_WAITING, AudioSystem::VOICE_CALL);
2093                 } else {
2094                     mpClientInterface->stopTone();
2095                 }
2096             }
2097         }
2098     }
2099 }
2100
2101 bool AudioPolicyManagerBase::isInCall()
2102 {
2103     return isStateInCall(mPhoneState);
2104 }
2105
2106 bool AudioPolicyManagerBase::isStateInCall(int state) {
2107     return ((state == AudioSystem::MODE_IN_CALL) ||
2108             (state == AudioSystem::MODE_IN_COMMUNICATION));
2109 }
2110
2111 bool AudioPolicyManagerBase::needsDirectOuput(AudioSystem::stream_type stream,
2112                                     uint32_t samplingRate,
2113                                     uint32_t format,
2114                                     uint32_t channels,
2115                                     AudioSystem::output_flags flags,
2116                                     uint32_t device)
2117 {
2118    return ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||
2119           (format !=0 && !AudioSystem::isLinearPCM(format)));
2120 }
2121
2122 uint32_t AudioPolicyManagerBase::getMaxEffectsCpuLoad()
2123 {
2124     return MAX_EFFECTS_CPU_LOAD;
2125 }
2126
2127 uint32_t AudioPolicyManagerBase::getMaxEffectsMemory()
2128 {
2129     return MAX_EFFECTS_MEMORY;
2130 }
2131
2132 // --- AudioOutputDescriptor class implementation
2133
2134 AudioPolicyManagerBase::AudioOutputDescriptor::AudioOutputDescriptor()
2135     : mId(0), mSamplingRate(0), mFormat(0), mChannels(0), mLatency(0),
2136     mFlags((AudioSystem::output_flags)0), mDevice(0), mOutput1(0), mOutput2(0)
2137 {
2138     // clear usage count for all stream types
2139     for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
2140         mRefCount[i] = 0;
2141         mCurVolume[i] = -1.0;
2142         mMuteCount[i] = 0;
2143         mStopTime[i] = 0;
2144     }
2145 }
2146
2147 uint32_t AudioPolicyManagerBase::AudioOutputDescriptor::device()
2148 {
2149     uint32_t device = 0;
2150     if (isDuplicated()) {
2151         device = mOutput1->mDevice | mOutput2->mDevice;
2152     } else {
2153         device = mDevice;
2154     }
2155     return device;
2156 }
2157
2158 void AudioPolicyManagerBase::AudioOutputDescriptor::changeRefCount(AudioSystem::stream_type stream, int delta)
2159 {
2160     // forward usage count change to attached outputs
2161     if (isDuplicated()) {
2162         mOutput1->changeRefCount(stream, delta);
2163         mOutput2->changeRefCount(stream, delta);
2164     }
2165     if ((delta + (int)mRefCount[stream]) < 0) {
2166         LOGW("changeRefCount() invalid delta %d for stream %d, refCount %d", delta, stream, mRefCount[stream]);
2167         mRefCount[stream] = 0;
2168         return;
2169     }
2170     mRefCount[stream] += delta;
2171     LOGV("changeRefCount() stream %d, count %d", stream, mRefCount[stream]);
2172 }
2173
2174 uint32_t AudioPolicyManagerBase::AudioOutputDescriptor::refCount()
2175 {
2176     uint32_t refcount = 0;
2177     for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {
2178         refcount += mRefCount[i];
2179     }
2180     return refcount;
2181 }
2182
2183 uint32_t AudioPolicyManagerBase::AudioOutputDescriptor::strategyRefCount(routing_strategy strategy)
2184 {
2185     uint32_t refCount = 0;
2186     for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {
2187         if (getStrategy((AudioSystem::stream_type)i) == strategy) {
2188             refCount += mRefCount[i];
2189         }
2190     }
2191     return refCount;
2192 }
2193
2194 status_t AudioPolicyManagerBase::AudioOutputDescriptor::dump(int fd)
2195 {
2196     const size_t SIZE = 256;
2197     char buffer[SIZE];
2198     String8 result;
2199
2200     snprintf(buffer, SIZE, " Sampling rate: %d\n", mSamplingRate);
2201     result.append(buffer);
2202     snprintf(buffer, SIZE, " Format: %d\n", mFormat);
2203     result.append(buffer);
2204     snprintf(buffer, SIZE, " Channels: %08x\n", mChannels);
2205     result.append(buffer);
2206     snprintf(buffer, SIZE, " Latency: %d\n", mLatency);
2207     result.append(buffer);
2208     snprintf(buffer, SIZE, " Flags %08x\n", mFlags);
2209     result.append(buffer);
2210     snprintf(buffer, SIZE, " Devices %08x\n", device());
2211     result.append(buffer);
2212     snprintf(buffer, SIZE, " Stream volume refCount muteCount\n");
2213     result.append(buffer);
2214     for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
2215         snprintf(buffer, SIZE, " %02d     %.03f     %02d       %02d\n", i, mCurVolume[i], mRefCount[i], mMuteCount[i]);
2216         result.append(buffer);
2217     }
2218     write(fd, result.string(), result.size());
2219
2220     return NO_ERROR;
2221 }
2222
2223 // --- AudioInputDescriptor class implementation
2224
2225 AudioPolicyManagerBase::AudioInputDescriptor::AudioInputDescriptor()
2226     : mSamplingRate(0), mFormat(0), mChannels(0),
2227       mAcoustics((AudioSystem::audio_in_acoustics)0), mDevice(0), mRefCount(0),
2228       mInputSource(0)
2229 {
2230 }
2231
2232 status_t AudioPolicyManagerBase::AudioInputDescriptor::dump(int fd)
2233 {
2234     const size_t SIZE = 256;
2235     char buffer[SIZE];
2236     String8 result;
2237
2238     snprintf(buffer, SIZE, " Sampling rate: %d\n", mSamplingRate);
2239     result.append(buffer);
2240     snprintf(buffer, SIZE, " Format: %d\n", mFormat);
2241     result.append(buffer);
2242     snprintf(buffer, SIZE, " Channels: %08x\n", mChannels);
2243     result.append(buffer);
2244     snprintf(buffer, SIZE, " Acoustics %08x\n", mAcoustics);
2245     result.append(buffer);
2246     snprintf(buffer, SIZE, " Devices %08x\n", mDevice);
2247     result.append(buffer);
2248     snprintf(buffer, SIZE, " Ref Count %d\n", mRefCount);
2249     result.append(buffer);
2250     write(fd, result.string(), result.size());
2251
2252     return NO_ERROR;
2253 }
2254
2255 // --- StreamDescriptor class implementation
2256
2257 void AudioPolicyManagerBase::StreamDescriptor::dump(char* buffer, size_t size)
2258 {
2259     snprintf(buffer, size, "      %02d         %02d         %02d         %d\n",
2260             mIndexMin,
2261             mIndexMax,
2262             mIndexCur,
2263             mCanBeMuted);
2264 }
2265
2266 // --- EffectDescriptor class implementation
2267
2268 status_t AudioPolicyManagerBase::EffectDescriptor::dump(int fd)
2269 {
2270     const size_t SIZE = 256;
2271     char buffer[SIZE];
2272     String8 result;
2273
2274     snprintf(buffer, SIZE, " I/O: %d\n", mIo);
2275     result.append(buffer);
2276     snprintf(buffer, SIZE, " Strategy: %d\n", mStrategy);
2277     result.append(buffer);
2278     snprintf(buffer, SIZE, " Session: %d\n", mSession);
2279     result.append(buffer);
2280     snprintf(buffer, SIZE, " Name: %s\n",  mDesc.name);
2281     result.append(buffer);
2282     write(fd, result.string(), result.size());
2283
2284     return NO_ERROR;
2285 }
2286
2287
2288
2289 }; // namespace android