AudioPolicyManagerBase.cpp revision 5ccdf14a85ed66ac54036fb393acc06ea7acfed6
1f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin/* 2f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * Copyright (C) 2009 The Android Open Source Project 3f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * 4f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * Licensed under the Apache License, Version 2.0 (the "License"); 5f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * you may not use this file except in compliance with the License. 6f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * You may obtain a copy of the License at 7f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * 8f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * http://www.apache.org/licenses/LICENSE-2.0 9f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * 10f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * Unless required by applicable law or agreed to in writing, software 11f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * distributed under the License is distributed on an "AS IS" BASIS, 12f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * See the License for the specific language governing permissions and 14f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin * limitations under the License. 15f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin */ 16f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 17f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#define LOG_TAG "AudioPolicyManagerBase" 18f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin//#define LOG_NDEBUG 0 19f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#include <utils/Log.h> 20f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#include <hardware_legacy/AudioPolicyManagerBase.h> 211c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent#include <hardware/audio_effect.h> 2208b014d9e509c9163db6b33a63852e73db4d07ccEric Laurent#include <hardware/audio.h> 23f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#include <math.h> 245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent#include <hardware_legacy/audio_policy_conf.h> 25f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 26e81531e91ecae92aff471dbff9cbeb0f95ff4a80Dima Zavinnamespace android_audio_legacy { 27f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 28f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// ---------------------------------------------------------------------------- 29f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// AudioPolicyInterface implementation 30f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// ---------------------------------------------------------------------------- 31f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 32f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 33f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::setDeviceConnectionState(AudioSystem::audio_devices device, 34f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::device_connection_state state, 35f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const char *device_address) 36f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 37b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent audio_io_handle_t output = 0; 38f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 396a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address); 40f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 41f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // connect/disconnect only 1 device at a time 42f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::popCount(device) != 1) return BAD_VALUE; 43f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 44f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) { 455efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("setDeviceConnectionState() invalid address: %s", device_address); 46f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 47f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 48f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 49f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle output devices 50f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isOutputDevice(device)) { 51f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (!mHasA2dp && AudioSystem::isA2dpDevice(device)) { 535efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("setDeviceConnectionState() invalid device: %x", device); 54f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 55f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 56f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 57f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch (state) 58f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin { 59f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle output device connection 60f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::DEVICE_STATE_AVAILABLE: 61f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mAvailableOutputDevices & device) { 6264cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setDeviceConnectionState() device already connected: %x", device); 63f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 64f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 656a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setDeviceConnectionState() connecting device %x", device); 66f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 67f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // register new device as available 68f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices | device); 69f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 70f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent output = checkOutputForDevice((audio_devices_t)device, state); 71b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (output == 0) { 72f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices & ~device); 73b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return INVALID_OPERATION; 74b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 75f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle A2DP device connection 765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mHasA2dp && AudioSystem::isA2dpDevice(device)) { 77b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioParameter param; 7808b014d9e509c9163db6b33a63852e73db4d07ccEric Laurent param.add(String8(AUDIO_PARAMETER_A2DP_SINK_ADDRESS), String8(device_address)); 79b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->setParameters(output, param.toString()); 80b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mA2dpDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN); 81b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mA2dpSuspended = false; 82b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else if (AudioSystem::isBluetoothScoDevice(device)) { 83b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("setDeviceConnectionState() BT SCO device, address %s", device_address); 84b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // keep track of SCO device address 85b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN); 86f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 87f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 88f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle output device disconnection 89f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::DEVICE_STATE_UNAVAILABLE: { 90f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!(mAvailableOutputDevices & device)) { 9164cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setDeviceConnectionState() device not connected: %x", device); 92f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 93f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 94f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 95f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 966a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setDeviceConnectionState() disconnecting device %x", device); 97f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // remove device from available output devices 98f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices & ~device); 99f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 100f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent output = checkOutputForDevice((audio_devices_t)device, state); 101f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle A2DP device disconnection 1025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mHasA2dp && AudioSystem::isA2dpDevice(device)) { 103b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mA2dpDeviceAddress = ""; 104b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mA2dpSuspended = false; 105b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else if (AudioSystem::isBluetoothScoDevice(device)) { 106b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mScoDeviceAddress = ""; 107f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 108f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } break; 109f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 110f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 1115efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("setDeviceConnectionState() invalid state: %x", state); 112f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 113f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 114f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 115f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkA2dpSuspend(); 116f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForAllStrategies(); 117b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // outputs must be closed after checkOutputForAllStrategies() is executed 118b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && output != 0) { 119b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent closeOutput(output); 120f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 122f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin updateDeviceForStrategy(); 1235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 1245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setOutputDevice(mOutputs.keyAt(i), getNewDevice(mOutputs.keyAt(i), true /*fromCache*/)); 1255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 126f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 127f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == AudioSystem::DEVICE_OUT_WIRED_HEADSET) { 128f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_WIRED_HEADSET; 129f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO || 130f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET || 131f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) { 132f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET; 133f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 134f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 135f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 136f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 137f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle input devices 138f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isInputDevice(device)) { 139f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 140f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch (state) 141f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin { 142f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle input device connection 143f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::DEVICE_STATE_AVAILABLE: { 144f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mAvailableInputDevices & device) { 14564cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setDeviceConnectionState() device already connected: %d", device); 146f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 147f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mAvailableInputDevices = (audio_devices_t)(mAvailableInputDevices | device); 149f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 150f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 151f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 152f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle input device disconnection 153f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::DEVICE_STATE_UNAVAILABLE: { 154f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!(mAvailableInputDevices & device)) { 15564cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setDeviceConnectionState() device not connected: %d", device); 156f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 157f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mAvailableInputDevices = (audio_devices_t) (mAvailableInputDevices & ~device); 159f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } break; 160f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 161f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 1625efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("setDeviceConnectionState() invalid state: %x", state); 163f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 164f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 165f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 166f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin audio_io_handle_t activeInput = getActiveInput(); 167f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (activeInput != 0) { 168f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput); 169f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t newDevice = getDeviceForInputSource(inputDesc->mInputSource); 1705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((newDevice != 0) && (newDevice != inputDesc->mDevice)) { 1716a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setDeviceConnectionState() changing device from %x to %x for input %d", 172f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mDevice, newDevice, activeInput); 173f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mDevice = newDevice; 174f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter param = AudioParameter(); 175f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyRouting), (int)newDevice); 176f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(activeInput, param.toString()); 177f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 178f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 179f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 180f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 181f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 182f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 18364cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setDeviceConnectionState() invalid device: %x", device); 184f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 185f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 186f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 187f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima ZavinAudioSystem::device_connection_state AudioPolicyManagerBase::getDeviceConnectionState(AudioSystem::audio_devices device, 188f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const char *device_address) 189f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 190f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::device_connection_state state = AudioSystem::DEVICE_STATE_UNAVAILABLE; 191f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 address = String8(device_address); 192f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isOutputDevice(device)) { 193f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device & mAvailableOutputDevices) { 194f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isA2dpDevice(device) && 1955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (!mHasA2dp || (address != "" && mA2dpDeviceAddress != address))) { 196f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return state; 197f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 198f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isBluetoothScoDevice(device) && 199f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin address != "" && mScoDeviceAddress != address) { 200f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return state; 201f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 202f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin state = AudioSystem::DEVICE_STATE_AVAILABLE; 203f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 204f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (AudioSystem::isInputDevice(device)) { 205f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device & mAvailableInputDevices) { 206f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin state = AudioSystem::DEVICE_STATE_AVAILABLE; 207f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 208f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 209f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 210f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return state; 211f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 212f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 213f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::setPhoneState(int state) 214f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2156a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setPhoneState() state %d", state); 216f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t newDevice = (audio_devices_t)0; 217f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (state < 0 || state >= AudioSystem::NUM_MODES) { 21864cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setPhoneState() invalid state %d", state); 219f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 220f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 221f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 222f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (state == mPhoneState ) { 22364cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setPhoneState() setting same state %d", state); 224f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 225f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 226f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 227f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if leaving call state, handle special case of active streams 228f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // pertaining to sonification strategy see handleIncallSonification() 229f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isInCall()) { 2306a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setPhoneState() in call state management: new state is %d", state); 231f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { 232f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin handleIncallSonification(stream, false, true); 233f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 234f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 235f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 236f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // store previous phone state for management of sonification strategy below 237f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int oldState = mPhoneState; 238f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mPhoneState = state; 239f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin bool force = false; 240f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 241f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // are we entering or starting a call 242f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!isStateInCall(oldState) && isStateInCall(state)) { 2436a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV(" Entering call in setPhoneState()"); 244f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // force routing command to audio hardware when starting a call 245f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // even if no device change is needed 246f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin force = true; 247f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (isStateInCall(oldState) && !isStateInCall(state)) { 2486a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV(" Exiting call in setPhoneState()"); 249f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // force routing command to audio hardware when exiting a call 250f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // even if no device change is needed 251f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin force = true; 252f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (isStateInCall(state) && (state != oldState)) { 2536a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV(" Switching between telephony and VoIP in setPhoneState()"); 254f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // force routing command to audio hardware when switching between telephony and VoIP 255f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // even if no device change is needed 256f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin force = true; 257f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 258f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 259f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // check for device and output changes triggered by new phone state 2605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent newDevice = getNewDevice(mPrimaryOutput, false /*fromCache*/); 261f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkA2dpSuspend(); 262f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForAllStrategies(); 263f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin updateDeviceForStrategy(); 264f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 265b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mPrimaryOutput); 266f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 267f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // force routing command to audio hardware when ending call 268f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // even if no device change is needed 269f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isStateInCall(oldState) && newDevice == 0) { 270f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin newDevice = hwOutputDesc->device(); 271f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 272f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 273f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when changing from ring tone to in call mode, mute the ringing tone 274f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // immediately and delay the route change to avoid sending the ring tone 275f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // tail into the earpiece or headset. 276f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int delayMs = 0; 277f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isStateInCall(state) && oldState == AudioSystem::MODE_RINGTONE) { 278f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // delay the device change command by twice the output latency to have some margin 279f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // and be sure that audio buffers not yet affected by the mute are out when 280f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // we actually apply the route change 281f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delayMs = hwOutputDesc->mLatency*2; 282b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setStreamMute(AudioSystem::RING, true, mPrimaryOutput); 283f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 284f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 285f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // change routing is necessary 286b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setOutputDevice(mPrimaryOutput, newDevice, force, delayMs); 287f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 288f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if entering in call state, handle special case of active streams 289f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // pertaining to sonification strategy see handleIncallSonification() 290f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isStateInCall(state)) { 2916a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setPhoneState() in call state management: new state is %d", state); 292f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // unmute the ringing tone after a sufficient delay if it was muted before 293f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // setting output device above 294f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (oldState == AudioSystem::MODE_RINGTONE) { 295b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setStreamMute(AudioSystem::RING, false, mPrimaryOutput, MUTE_TIME_MS); 296f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 297f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { 298f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin handleIncallSonification(stream, true, true); 299f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 300f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 301f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 302f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE 303f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (state == AudioSystem::MODE_RINGTONE && 304f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin isStreamActive(AudioSystem::MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) { 305f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mLimitRingtoneVolume = true; 306f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 307f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mLimitRingtoneVolume = false; 308f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 309f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 310f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 311f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) 312f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 3136a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mPhoneState); 314f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 315f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin bool forceVolumeReeval = false; 316f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch(usage) { 317f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FOR_COMMUNICATION: 318f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (config != AudioSystem::FORCE_SPEAKER && config != AudioSystem::FORCE_BT_SCO && 319f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_NONE) { 32064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setForceUse() invalid config %d for FOR_COMMUNICATION", config); 321f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 322f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 323f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin forceVolumeReeval = true; 324f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mForceUse[usage] = config; 325f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 326f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FOR_MEDIA: 327f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (config != AudioSystem::FORCE_HEADPHONES && config != AudioSystem::FORCE_BT_A2DP && 328f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_WIRED_ACCESSORY && 329f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_ANALOG_DOCK && 330f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_DIGITAL_DOCK && config != AudioSystem::FORCE_NONE) { 33164cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setForceUse() invalid config %d for FOR_MEDIA", config); 332f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 333f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 334f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mForceUse[usage] = config; 335f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 336f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FOR_RECORD: 337f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (config != AudioSystem::FORCE_BT_SCO && config != AudioSystem::FORCE_WIRED_ACCESSORY && 338f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_NONE) { 33964cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setForceUse() invalid config %d for FOR_RECORD", config); 340f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 341f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 342f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mForceUse[usage] = config; 343f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 344f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FOR_DOCK: 345f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (config != AudioSystem::FORCE_NONE && config != AudioSystem::FORCE_BT_CAR_DOCK && 346f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_BT_DESK_DOCK && 347f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_WIRED_ACCESSORY && 348f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_ANALOG_DOCK && 349f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin config != AudioSystem::FORCE_DIGITAL_DOCK) { 35064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setForceUse() invalid config %d for FOR_DOCK", config); 351f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 352f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin forceVolumeReeval = true; 353f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mForceUse[usage] = config; 354f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 355f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 35664cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setForceUse() invalid usage %d", usage); 357f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 358f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 359f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 3605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // check for device and output changes triggered by new force usage 361f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkA2dpSuspend(); 362f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForAllStrategies(); 363f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin updateDeviceForStrategy(); 3645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 3655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t output = mOutputs.keyAt(i); 3665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t newDevice = getNewDevice(output, true /*fromCache*/); 3675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setOutputDevice(output, newDevice, true); 3685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (forceVolumeReeval) { 3695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent applyStreamVolumes(output, newDevice, 0, true); 3705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 371f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 372f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 373f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin audio_io_handle_t activeInput = getActiveInput(); 374f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (activeInput != 0) { 375f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput); 3765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t newDevice = getDeviceForInputSource(inputDesc->mInputSource); 3775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((newDevice != 0) && (newDevice != inputDesc->mDevice)) { 3786a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setForceUse() changing device from %x to %x for input %d", 379f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mDevice, newDevice, activeInput); 380f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mDevice = newDevice; 381f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter param = AudioParameter(); 382f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyRouting), (int)newDevice); 383f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(activeInput, param.toString()); 384f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 385f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 386f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 387f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 388f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 389f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima ZavinAudioSystem::forced_config AudioPolicyManagerBase::getForceUse(AudioSystem::force_use usage) 390f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 391f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return mForceUse[usage]; 392f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 393f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 394f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::setSystemProperty(const char* property, const char* value) 395f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 3966a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setSystemProperty() property %s, value %s", property, value); 397f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (strcmp(property, "ro.camera.sound.forced") == 0) { 398f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (atoi(value)) { 3996a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("ENFORCED_AUDIBLE cannot be muted"); 400f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mStreams[AudioSystem::ENFORCED_AUDIBLE].mCanBeMuted = false; 401f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 4026a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("ENFORCED_AUDIBLE can be muted"); 403f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mStreams[AudioSystem::ENFORCED_AUDIBLE].mCanBeMuted = true; 404f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 405f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 406f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 407f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 408f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinaudio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type stream, 409f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t samplingRate, 410f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t format, 411f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t channels, 412f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::output_flags flags) 413f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 414f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin audio_io_handle_t output = 0; 415f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t latency = 0; 416f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream); 4175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/); 4186a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutput() stream %d, samplingRate %d, format %d, channels %x, flags %x", stream, samplingRate, format, channels, flags); 419f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 420f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 421f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mCurOutput != 0) { 4226a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutput() test output mCurOutput %d, samplingRate %d, format %d, channels %x, mDirectOutput %d", 423f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mCurOutput, mTestSamplingRate, mTestFormat, mTestChannels, mDirectOutput); 424f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 425f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mTestOutputs[mCurOutput] == 0) { 4266a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutput() opening test output"); 427f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor(); 428f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mDevice = mTestDevice; 429f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mSamplingRate = mTestSamplingRate; 430f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFormat = mTestFormat; 431f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mChannels = mTestChannels; 432f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mLatency = mTestLatencyMs; 433f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFlags = (AudioSystem::output_flags)(mDirectOutput ? AudioSystem::OUTPUT_FLAG_DIRECT : 0); 434f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mRefCount[stream] = 0; 435f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestOutputs[mCurOutput] = mpClientInterface->openOutput(&outputDesc->mDevice, 436f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mSamplingRate, 437f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mFormat, 438f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mChannels, 439f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mLatency, 440f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFlags); 441f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mTestOutputs[mCurOutput]) { 442f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputCmd = AudioParameter(); 443f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputCmd.addInt(String8("set_id"),mCurOutput); 444f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(mTestOutputs[mCurOutput],outputCmd.toString()); 445f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin addOutput(mTestOutputs[mCurOutput], outputDesc); 446f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 447f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 448f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return mTestOutputs[mCurOutput]; 449f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 450f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 451f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 452f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // open a direct output if required by specified parameters 453f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (needsDirectOuput(stream, samplingRate, format, channels, flags, device)) { 454f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 4556a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutput() opening direct output device %x", device); 456b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor(NULL); 457f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mDevice = device; 458f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mSamplingRate = samplingRate; 459f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFormat = format; 460f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mChannels = channels; 461f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mLatency = 0; 462f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFlags = (AudioSystem::output_flags)(flags | AudioSystem::OUTPUT_FLAG_DIRECT); 463f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mRefCount[stream] = 0; 464f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mStopTime[stream] = 0; 465f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent output = mpClientInterface->openOutput((uint32_t *)&outputDesc->mDevice, 466f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mSamplingRate, 467f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mFormat, 468f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mChannels, 469f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mLatency, 470f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFlags); 471f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 472f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // only accept an output with the requeted parameters 473f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (output == 0 || 474f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (samplingRate != 0 && samplingRate != outputDesc->mSamplingRate) || 475f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (format != 0 && format != outputDesc->mFormat) || 476f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (channels != 0 && channels != outputDesc->mChannels)) { 4776a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutput() failed opening direct output: samplingRate %d, format %d, channels %d", 478f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin samplingRate, format, channels); 479f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (output != 0) { 480f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeOutput(output); 481f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 482f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete outputDesc; 483f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 484f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 485f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin addOutput(output, outputDesc); 486f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return output; 487f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 488f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 489f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (channels != 0 && channels != AudioSystem::CHANNEL_OUT_MONO && 490f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels != AudioSystem::CHANNEL_OUT_STEREO) { 491f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 492f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 493f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // open a non direct output 494f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 495f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // get which output is suitable for the specified stream. The actual routing change will happen 496f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when startOutput() will be called 497b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device); 498f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 4995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent output = selectOutput(outputs, flags); 500f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 50164cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW_IF((output ==0), "getOutput() could not find output for stream %d, samplingRate %d, format %d, channels %x, flags %x", 502f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream, samplingRate, format, channels, flags); 503f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("getOutput() returns output %d", output); 5055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 506f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return output; 507f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 508f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentaudio_io_handle_t AudioPolicyManagerBase::selectOutput(const SortedVector<audio_io_handle_t>& outputs, 5105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioSystem::output_flags flags) 5115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 5125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // select one output among several that provide a path to a particular device or set of 5135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // devices (the list was previously build by getOutputsForDevice()). 5145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // The priority is as follows: 5155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // 1: the output with the highest number of requested policy flags 5165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // 2: the primary output 5175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // 3: the first output in the list 5185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 5195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputs.size() == 0) { 5205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return 0; 5215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputs.size() == 1) { 5235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return outputs[0]; 5245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 5265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent int maxCommonFlags = 0; 5275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t outputFlags = 0; 5285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t outputPrimary = 0; 5295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 5305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < outputs.size(); i++) { 5315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioOutputDescriptor *outputDesc = mOutputs.valueFor(outputs[i]); 5325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (!outputDesc->isDuplicated()) { 5335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent int commonFlags = (int)AudioSystem::popCount(outputDesc->mProfile->mFlags & flags); 5345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (commonFlags > maxCommonFlags) { 5355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputFlags = outputs[i]; 5365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent maxCommonFlags = commonFlags; 5375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("selectOutput() commonFlags for output %d, %04x", outputs[i], commonFlags); 5385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputDesc->mProfile->mFlags & AUDIO_POLICY_OUTPUT_FLAG_PRIMARY) { 5405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputPrimary = outputs[i]; 5415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 5455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputFlags != 0) { 5465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return outputFlags; 5475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputPrimary != 0) { 5495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return outputPrimary; 5505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 5525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return outputs[0]; 5535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 5545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 555f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::startOutput(audio_io_handle_t output, 556f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::stream_type stream, 557f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int session) 558f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 5596a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("startOutput() output %d, stream %d, session %d", output, stream, session); 560f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mOutputs.indexOfKey(output); 561f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 56264cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("startOutput() unknow output %d", output); 563f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 564f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 565f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 566f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); 567f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // increment usage count for this stream on the requested output: 569f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // NOTE that the usage count is the same for duplicated output and hardware output which is 5705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // necessary for a correct control of hardware output routing by startOutput() and stopOutput() 571f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->changeRefCount(stream, 1); 572f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputDesc->mRefCount[stream] == 1) { 5745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t prevDevice = outputDesc->device(); 5755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t newDevice = getNewDevice(output, false /*fromCache*/); 576f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // force a device change if any other output is active, is managed by the same and hw 5785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // module and has a current device selection that differs from newly selected device. 5795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // In this case, the audio HAL must receive the new device selection so that it can 5805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // change the device currently selected by the other active output. 5815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent bool force = false; 5825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 5835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioOutputDescriptor *desc = mOutputs.valueAt(i); 5845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (output != mOutputs.keyAt(i) && 5855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent desc->refCount() != 0 && 5865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->sharesHwModuleWith(desc) && 5875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent desc->device() != newDevice) { 5885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent force = true; 5895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent break; 5905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 5925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setOutputDevice(output, newDevice, force); 593f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 5945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // handle special case for sonification while in call 5955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (isInCall()) { 5965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent handleIncallSonification(stream, true, false); 5975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 598c16ac09f510437e8340be691720177a490ae78f0Eric Laurent 5995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // apply volume rules for current stream and device if necessary 6005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent checkAndSetVolume(stream, 6015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mStreams[stream].getVolumeIndex((audio_devices_t)newDevice), 6025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent output, 6035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent newDevice); 60412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 6055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // update the outputs if starting an output with a stream that can affect notification 6065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // routing 6075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent handleNotificationRoutingForStream(stream); 6085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 609f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 610f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 611f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 6125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 613f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::stopOutput(audio_io_handle_t output, 614f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::stream_type stream, 615f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int session) 616f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 6176a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session); 618f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mOutputs.indexOfKey(output); 619f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 62064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("stopOutput() unknow output %d", output); 621f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 622f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 623f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 624f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); 625f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 626f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handle special case for sonification while in call 627f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isInCall()) { 628f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin handleIncallSonification(stream, false, false); 629f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 630f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 631f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->mRefCount[stream] > 0) { 632f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // decrement usage count of this stream on the output 633f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->changeRefCount(stream, -1); 634f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // store time at which the stream was stopped - see isStreamActive() 6355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputDesc->mRefCount[stream] == 0) { 6365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mStopTime[stream] = systemTime(); 6375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t newDevice = getNewDevice(output, false /*fromCache*/); 6385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // delay the device switch by twice the latency because stopOutput() is executed when 6395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // the track stop() command is received and at that time the audio track buffer can 6405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // still contain data that needs to be drained. The latency only covers the audio HAL 6415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // and kernel buffers. Also the latency does not always include additional delay in the 6425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // audio path (audio DSP, CODEC ...) 6435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setOutputDevice(output, newDevice, false, outputDesc->mLatency*2); 6445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 6455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // force restoring the device selection on other active outputs if it differs from the 6465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // one being selected for this output 6475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 6485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t curOutput = mOutputs.keyAt(i); 6495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioOutputDescriptor *desc = mOutputs.valueAt(i); 6505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (curOutput != output && 6515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent desc->refCount() != 0 && 6525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->sharesHwModuleWith(desc) && 6535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent newDevice != desc->device()) { 6545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setOutputDevice(curOutput, 6555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent getNewDevice(curOutput, false /*fromCache*/), 6565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent true, 6575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mLatency*2); 6585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 6595ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 6605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // update the outputs if stopping one with a stream that can affect notification routing 6615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent handleNotificationRoutingForStream(stream); 662f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 663f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 664f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 66564cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("stopOutput() refcount is already 0 for output %d", output); 666f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 667f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 668f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 669f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 670f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::releaseOutput(audio_io_handle_t output) 671f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 6726a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("releaseOutput() %d", output); 673f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mOutputs.indexOfKey(output); 674f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 67564cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("releaseOutput() releasing unknown output %d", output); 676f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 677f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 678f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 679f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 680f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int testIndex = testOutputIndex(output); 681f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (testIndex != 0) { 682f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); 683f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->refCount() == 0) { 684f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeOutput(output); 685f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete mOutputs.valueAt(index); 686f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.removeItem(output); 687f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestOutputs[testIndex] = 0; 688f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 689f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 690f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 691f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 692f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 693f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mOutputs.valueAt(index)->mFlags & AudioSystem::OUTPUT_FLAG_DIRECT) { 694f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeOutput(output); 695f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete mOutputs.valueAt(index); 696f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.removeItem(output); 697f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 69812bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 699f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 700f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 701f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinaudio_io_handle_t AudioPolicyManagerBase::getInput(int inputSource, 702f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t samplingRate, 703f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t format, 704f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t channels, 705f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::audio_in_acoustics acoustics) 706f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 707f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin audio_io_handle_t input = 0; 708f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device = getDeviceForInputSource(inputSource); 709f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 7105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("getInput() inputSource %d, samplingRate %d, format %d, channels %x, acoustics %x", 7115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent inputSource, samplingRate, format, channels, acoustics); 712f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 713f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 7145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW("getInput() could not find device for inputSource %d", inputSource); 715f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 716f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 717f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 718f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // adapt channel selection to input source 719f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch(inputSource) { 720f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_UPLINK: 721f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels = AudioSystem::CHANNEL_IN_VOICE_UPLINK; 722f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 723f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_DOWNLINK: 724f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels = AudioSystem::CHANNEL_IN_VOICE_DNLINK; 725f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 726f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_CALL: 727f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels = (AudioSystem::CHANNEL_IN_VOICE_UPLINK | AudioSystem::CHANNEL_IN_VOICE_DNLINK); 728f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 729f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 730f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 731f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 732f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 7335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent IOProfile *profile = getInputProfile(device, 7345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent samplingRate, 7355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent format, 7365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent channels); 7375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (profile == NULL) { 7385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW("getInput() could not find profile for device %04x, samplingRate %d, format %d," 7395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "channels %04x", 7405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device, samplingRate, format, channels); 7415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return 0; 7425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 7435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 7445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioInputDescriptor *inputDesc = new AudioInputDescriptor(profile); 745f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 746f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mInputSource = inputSource; 747f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mDevice = device; 748f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mSamplingRate = samplingRate; 749f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mFormat = format; 750f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mChannels = channels; 751f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mAcoustics = acoustics; 752f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mRefCount = 0; 753f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent input = mpClientInterface->openInput((uint32_t *)&inputDesc->mDevice, 754f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &inputDesc->mSamplingRate, 755f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &inputDesc->mFormat, 756f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &inputDesc->mChannels, 75770eb9dec508c3269a0792e362ab34ffb3b29976cGlenn Kasten (audio_in_acoustics_t) inputDesc->mAcoustics); 758f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 759f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // only accept input with the exact requested set of parameters 760f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (input == 0 || 761f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (samplingRate != inputDesc->mSamplingRate) || 762f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (format != inputDesc->mFormat) || 763f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (channels != inputDesc->mChannels)) { 7646a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getInput() failed opening input: samplingRate %d, format %d, channels %d", 765f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin samplingRate, format, channels); 766f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (input != 0) { 767f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeInput(input); 768f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 769f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete inputDesc; 770f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 771f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 772f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mInputs.add(input, inputDesc); 773f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return input; 774f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 775f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 776f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::startInput(audio_io_handle_t input) 777f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 7786a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("startInput() input %d", input); 779f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mInputs.indexOfKey(input); 780f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 78164cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("startInput() unknow input %d", input); 782f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 783f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 784f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioInputDescriptor *inputDesc = mInputs.valueAt(index); 785f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 786f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 787f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mTestInput == 0) 788f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 789f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin { 790f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // refuse 2 active AudioRecord clients at the same time 791f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (getActiveInput() != 0) { 79264cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("startInput() input %d failed: other input already started", input); 793f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 794f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 795f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 796f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 797f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter param = AudioParameter(); 798f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyRouting), (int)inputDesc->mDevice); 799f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 800f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyInputSource), (int)inputDesc->mInputSource); 8016a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("AudioPolicyManager::startInput() input source = %d", inputDesc->mInputSource); 802f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 803f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(input, param.toString()); 804f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 805f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mRefCount = 1; 806f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 807f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 808f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 809f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::stopInput(audio_io_handle_t input) 810f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 8116a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("stopInput() input %d", input); 812f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mInputs.indexOfKey(input); 813f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 81464cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("stopInput() unknow input %d", input); 815f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 816f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 817f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioInputDescriptor *inputDesc = mInputs.valueAt(index); 818f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 819f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (inputDesc->mRefCount == 0) { 82064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("stopInput() input %d already stopped", input); 821f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 822f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 823f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter param = AudioParameter(); 824f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyRouting), 0); 825f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(input, param.toString()); 826f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin inputDesc->mRefCount = 0; 827f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 828f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 829f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 830f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 831f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::releaseInput(audio_io_handle_t input) 832f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 8336a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("releaseInput() %d", input); 834f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mInputs.indexOfKey(input); 835f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 83664cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("releaseInput() releasing unknown input %d", input); 837f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 838f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 839f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeInput(input); 840f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete mInputs.valueAt(index); 841f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mInputs.removeItem(input); 8426a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("releaseInput() exit"); 843f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 844f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 845f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::initStreamVolume(AudioSystem::stream_type stream, 846f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int indexMin, 847f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int indexMax) 848f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 8496a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax); 850f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (indexMin < 0 || indexMin >= indexMax) { 85164cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("initStreamVolume() invalid index limits for stream %d, min %d, max %d", stream , indexMin, indexMax); 852f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 853f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 854f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mStreams[stream].mIndexMin = indexMin; 855f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mStreams[stream].mIndexMax = indexMax; 856f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 857f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 858c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentstatus_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type stream, 859c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int index, 860c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent audio_devices_t device) 861f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 862f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 863f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if ((index < mStreams[stream].mIndexMin) || (index > mStreams[stream].mIndexMax)) { 864f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 865f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 866c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (!audio_is_output_device(device)) { 867c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent return BAD_VALUE; 868c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 869f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 870f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Force max volume if stream cannot be muted 871f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!mStreams[stream].mCanBeMuted) index = mStreams[stream].mIndexMax; 872f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 873b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("setStreamVolumeIndex() stream %d, device %04x, index %d", 874c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent stream, device, index); 875c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 876c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent // if device is AUDIO_DEVICE_OUT_DEFAULT set default value and 877c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent // clear all device specific values 878c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (device == AUDIO_DEVICE_OUT_DEFAULT) { 879c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mStreams[stream].mIndexCur.clear(); 880c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 881c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mStreams[stream].mIndexCur.add(device, index); 882f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 883f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // compute and apply stream volume on all outputs according to connected device 884f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin status_t status = NO_ERROR; 885f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mOutputs.size(); i++) { 886c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent audio_devices_t curDevice = 887c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent getDeviceForVolume((audio_devices_t)mOutputs.valueAt(i)->device()); 888c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent if (device == curDevice) { 889c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice); 890c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent if (volStatus != NO_ERROR) { 891c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent status = volStatus; 892c5eb8b4a5d4395ce335bc7c3e6df2678fa47e2ddEric Laurent } 893f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 894f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 895f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return status; 896f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 897f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 898c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentstatus_t AudioPolicyManagerBase::getStreamVolumeIndex(AudioSystem::stream_type stream, 899c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int *index, 900c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent audio_devices_t device) 901f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 902c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (index == NULL) { 903f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return BAD_VALUE; 904f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 905c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (!audio_is_output_device(device)) { 906c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent return BAD_VALUE; 907c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 908c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent // if device is AUDIO_DEVICE_OUT_DEFAULT, return volume for device corresponding to 909c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent // the strategy the stream belongs to. 910c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (device == AUDIO_DEVICE_OUT_DEFAULT) { 9115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = (audio_devices_t)getDeviceForStrategy(getStrategy(stream), true /*fromCache*/); 912c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 913c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = getDeviceForVolume(device); 914c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 915c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent *index = mStreams[stream].getVolumeIndex(device); 916c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent ALOGV("getStreamVolumeIndex() stream %d device %08x index %d", stream, device, *index); 917f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 918f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 919f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 920f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinaudio_io_handle_t AudioPolicyManagerBase::getOutputForEffect(effect_descriptor_t *desc) 921f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 9226a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getOutputForEffect()"); 923f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // apply simple rule where global effects are attached to the same output as MUSIC streams 924f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return getOutput(AudioSystem::MUSIC); 925f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 926f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 927f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::registerEffect(effect_descriptor_t *desc, 9281c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent audio_io_handle_t io, 929f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t strategy, 930f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int session, 931f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int id) 932f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 9331c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent ssize_t index = mOutputs.indexOfKey(io); 934f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 9351c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent index = mInputs.indexOfKey(io); 9361c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent if (index < 0) { 93764cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("registerEffect() unknown io %d", io); 9381c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent return INVALID_OPERATION; 9391c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent } 940f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 941f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 942f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mTotalEffectsMemory + desc->memoryUsage > getMaxEffectsMemory()) { 94364cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("registerEffect() memory limit exceeded for Fx %s, Memory %d KB", 944f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin desc->name, desc->memoryUsage); 945f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 946f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 947f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTotalEffectsMemory += desc->memoryUsage; 9486a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("registerEffect() effect %s, io %d, strategy %d session %d id %d", 9491c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent desc->name, io, strategy, session, id); 9506a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("registerEffect() memory %d, total memory %d", desc->memoryUsage, mTotalEffectsMemory); 951f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 952f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin EffectDescriptor *pDesc = new EffectDescriptor(); 953f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin memcpy (&pDesc->mDesc, desc, sizeof(effect_descriptor_t)); 9541c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent pDesc->mIo = io; 955f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin pDesc->mStrategy = (routing_strategy)strategy; 956f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin pDesc->mSession = session; 957582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mEnabled = false; 958582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 959f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mEffects.add(id, pDesc); 960f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 961f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 962f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 963f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 964f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::unregisterEffect(int id) 965f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 966f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ssize_t index = mEffects.indexOfKey(id); 967f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (index < 0) { 96864cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("unregisterEffect() unknown effect ID %d", id); 969f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 970f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 971f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 972f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin EffectDescriptor *pDesc = mEffects.valueAt(index); 973f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 974582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent setEffectEnabled(pDesc, false); 975582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 976f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mTotalEffectsMemory < pDesc->mDesc.memoryUsage) { 97764cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("unregisterEffect() memory %d too big for total %d", 978f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin pDesc->mDesc.memoryUsage, mTotalEffectsMemory); 979f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin pDesc->mDesc.memoryUsage = mTotalEffectsMemory; 980f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 981f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTotalEffectsMemory -= pDesc->mDesc.memoryUsage; 9826a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("unregisterEffect() effect %s, ID %d, memory %d total memory %d", 983582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mDesc.name, id, pDesc->mDesc.memoryUsage, mTotalEffectsMemory); 984f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 985f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mEffects.removeItem(id); 986f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete pDesc; 987f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 988f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 989f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 990f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 991582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurentstatus_t AudioPolicyManagerBase::setEffectEnabled(int id, bool enabled) 992582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent{ 993582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent ssize_t index = mEffects.indexOfKey(id); 994582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent if (index < 0) { 99564cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("unregisterEffect() unknown effect ID %d", id); 996582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent return INVALID_OPERATION; 997582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } 998582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 999582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent return setEffectEnabled(mEffects.valueAt(index), enabled); 1000582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent} 1001582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 1002582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurentstatus_t AudioPolicyManagerBase::setEffectEnabled(EffectDescriptor *pDesc, bool enabled) 1003582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent{ 1004582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent if (enabled == pDesc->mEnabled) { 10056a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setEffectEnabled(%s) effect already %s", 1006582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent enabled?"true":"false", enabled?"enabled":"disabled"); 1007582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent return INVALID_OPERATION; 1008582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } 1009582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 1010582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent if (enabled) { 1011582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent if (mTotalEffectsCpuLoad + pDesc->mDesc.cpuLoad > getMaxEffectsCpuLoad()) { 101264cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setEffectEnabled(true) CPU Load limit exceeded for Fx %s, CPU %f MIPS", 1013582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mDesc.name, (float)pDesc->mDesc.cpuLoad/10); 1014582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent return INVALID_OPERATION; 1015582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } 1016582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent mTotalEffectsCpuLoad += pDesc->mDesc.cpuLoad; 10176a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setEffectEnabled(true) total CPU %d", mTotalEffectsCpuLoad); 1018582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } else { 1019582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent if (mTotalEffectsCpuLoad < pDesc->mDesc.cpuLoad) { 102064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setEffectEnabled(false) CPU load %d too high for total %d", 1021582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mDesc.cpuLoad, mTotalEffectsCpuLoad); 1022582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mDesc.cpuLoad = mTotalEffectsCpuLoad; 1023582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } 1024582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent mTotalEffectsCpuLoad -= pDesc->mDesc.cpuLoad; 10256a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setEffectEnabled(false) total CPU %d", mTotalEffectsCpuLoad); 1026582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent } 1027582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent pDesc->mEnabled = enabled; 1028582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent return NO_ERROR; 1029582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent} 1030582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent 1031f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinbool AudioPolicyManagerBase::isStreamActive(int stream, uint32_t inPastMs) const 1032f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1033f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin nsecs_t sysTime = systemTime(); 1034f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mOutputs.size(); i++) { 1035f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mOutputs.valueAt(i)->mRefCount[stream] != 0 || 1036f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ns2ms(sysTime - mOutputs.valueAt(i)->mStopTime[stream]) < inPastMs) { 1037f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return true; 1038f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1039f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1040f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return false; 1041f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1042f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1043f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1044f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::dump(int fd) 1045f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1046f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const size_t SIZE = 256; 1047f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin char buffer[SIZE]; 1048f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 result; 1049f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1050f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "\nAudioPolicyManager Dump: %p\n", this); 1051f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1052b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1053b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent snprintf(buffer, SIZE, " Hardware Output: %d\n", mPrimaryOutput); 1054f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1055f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " A2DP device address: %s\n", mA2dpDeviceAddress.string()); 1056f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1057f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " SCO device address: %s\n", mScoDeviceAddress.string()); 1058f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1059f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Output devices: %08x\n", mAvailableOutputDevices); 1060f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1061f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Input devices: %08x\n", mAvailableInputDevices); 1062f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1063f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Phone state: %d\n", mPhoneState); 1064f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1065f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Force use for communications %d\n", mForceUse[AudioSystem::FOR_COMMUNICATION]); 1066f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1067f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Force use for media %d\n", mForceUse[AudioSystem::FOR_MEDIA]); 1068f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1069f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Force use for record %d\n", mForceUse[AudioSystem::FOR_RECORD]); 1070f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1071f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Force use for dock %d\n", mForceUse[AudioSystem::FOR_DOCK]); 1072f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 1073f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, result.string(), result.size()); 1074f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 10755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "\nOutput Profiles dump:\n"); 10765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent write(fd, buffer, strlen(buffer)); 10775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputProfiles.size(); i++) { 10785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "- Output Profile %d:\n", i + 1); 10795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent write(fd, buffer, strlen(buffer)); 10805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mOutputProfiles[i]->dump(fd); 10815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 10825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 10835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "\nInput Profiles dump:\n"); 10845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent write(fd, buffer, strlen(buffer)); 10855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mInputProfiles.size(); i++) { 10865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "- Input Profile %d:\n", i + 1); 10875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent write(fd, buffer, strlen(buffer)); 10885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mInputProfiles[i]->dump(fd); 10895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 10905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 1091f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "\nOutputs dump:\n"); 1092f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1093f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mOutputs.size(); i++) { 1094f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "- Output %d dump:\n", mOutputs.keyAt(i)); 1095f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1096f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.valueAt(i)->dump(fd); 1097f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1098f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1099f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "\nInputs dump:\n"); 1100f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1101f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mInputs.size(); i++) { 1102f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "- Input %d dump:\n", mInputs.keyAt(i)); 1103f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1104f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mInputs.valueAt(i)->dump(fd); 1105f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1106f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1107f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "\nStreams dump:\n"); 1108f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1109c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent snprintf(buffer, SIZE, 1110c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent " Stream Can be muted Index Min Index Max Index Cur [device : index]...\n"); 1111f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1112f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) { 1113c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent snprintf(buffer, SIZE, " %02d ", i); 1114f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1115c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mStreams[i].dump(fd); 1116f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1117f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1118f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "\nTotal Effects CPU: %f MIPS, Total Effects memory: %d KB\n", 1119f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (float)mTotalEffectsCpuLoad/10, mTotalEffectsMemory); 1120f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1121f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1122f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "Registered effects:\n"); 1123f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1124f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mEffects.size(); i++) { 1125f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "- Effect %d dump:\n", mEffects.keyAt(i)); 1126f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, buffer, strlen(buffer)); 1127f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mEffects.valueAt(i)->dump(fd); 1128f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1129f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1130f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1131f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 1132f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1133f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1134f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// ---------------------------------------------------------------------------- 1135f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// AudioPolicyManagerBase 1136f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// ---------------------------------------------------------------------------- 1137f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1138f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima ZavinAudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clientInterface) 1139f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin : 1140f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 1141f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin Thread(false), 1142f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 1143f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mAvailableOutputDevices((audio_devices_t)0), 1144ca0657a1ca087a6d474a75fcfedd6aac3901d587Glenn Kasten mPhoneState(AudioSystem::MODE_NORMAL), 1145f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f), 1146f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0), 11475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mA2dpSuspended(false), mHasA2dp(false) 1148f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1149f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface = clientInterface; 1150f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1151f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) { 1152f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mForceUse[i] = AudioSystem::FORCE_NONE; 1153f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1154f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1155f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin initializeVolumeCurves(); 1156f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1157f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mA2dpDeviceAddress = String8(""); 1158f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mScoDeviceAddress = String8(""); 1159f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 11605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (loadAudioPolicyConfig(AUDIO_POLICY_CONFIG_FILE) != NO_ERROR) { 11615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE("could not load audio policy configuration file"); 11625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 11635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 1164b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // open all output streams needed to access attached devices 11655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputProfiles.size(); i++) 1166b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent { 11675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const IOProfile *outProfile = mOutputProfiles[i]; 11685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 11695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outProfile->mSupportedDevices & mAttachedOutputDevices) { 11705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor(outProfile); 11715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 11725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mDevice = (audio_devices_t)(mDefaultOutputDevice & 11735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outProfile->mSupportedDevices); 11745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mSamplingRate = outProfile->mSamplingRates[0]; 11755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mFormat = outProfile->mFormats[0]; 11765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mChannels = outProfile->mChannelMasks[0]; 11775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mFlags = (AudioSystem::output_flags)outProfile->mFlags; 11785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t output = mpClientInterface->openOutput( 11795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (uint32_t *)&outputDesc->mDevice, 1180b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mSamplingRate, 1181b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mFormat, 1182b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mChannels, 1183b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mLatency, 1184b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc->mFlags); 1185b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (output == 0) { 1186b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent delete outputDesc; 1187b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else { 11885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices | 11895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (outProfile->mSupportedDevices & mAttachedOutputDevices)); 11905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outProfile->mFlags & AUDIO_POLICY_OUTPUT_FLAG_PRIMARY) { 1191b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mPrimaryOutput = output; 1192b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1193b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent addOutput(output, outputDesc); 1194b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setOutputDevice(output, 11955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (audio_devices_t)(mDefaultOutputDevice & 11965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outProfile->mSupportedDevices), 1197b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent true); 1198b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1199b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1200f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1201f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 12025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE_IF((mAttachedOutputDevices & ~mAvailableOutputDevices), 1203b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent "Not output found for attached devices %08x", 12045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (mAttachedOutputDevices & ~mAvailableOutputDevices)); 1205b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1206b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGE_IF((mPrimaryOutput == 0), "Failed to open primary output"); 1207b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1208f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin updateDeviceForStrategy(); 1209f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 1210b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (mPrimaryOutput != 0) { 1211f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputCmd = AudioParameter(); 1212f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputCmd.addInt(String8("set_id"), 0); 1213b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->setParameters(mPrimaryOutput, outputCmd.toString()); 1214f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1215f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestDevice = AudioSystem::DEVICE_OUT_SPEAKER; 1216f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestSamplingRate = 44100; 1217f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestFormat = AudioSystem::PCM_16_BIT; 1218f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestChannels = AudioSystem::CHANNEL_OUT_STEREO; 1219f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestLatencyMs = 0; 1220f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mCurOutput = 0; 1221f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mDirectOutput = false; 1222f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < NUM_TEST_OUTPUTS; i++) { 1223f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestOutputs[i] = 0; 1224f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1225f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1226f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const size_t SIZE = 256; 1227f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin char buffer[SIZE]; 1228f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, "AudioPolicyManagerTest"); 1229f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin run(buffer, ANDROID_PRIORITY_AUDIO); 1230f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1231f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 1232f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1233f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1234f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima ZavinAudioPolicyManagerBase::~AudioPolicyManagerBase() 1235f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1236f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 1237f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin exit(); 1238f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 1239f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mOutputs.size(); i++) { 1240f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeOutput(mOutputs.keyAt(i)); 1241f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete mOutputs.valueAt(i); 1242f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1243f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.clear(); 1244f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mInputs.size(); i++) { 1245f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->closeInput(mInputs.keyAt(i)); 1246f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete mInputs.valueAt(i); 1247f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1248f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mInputs.clear(); 12495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputProfiles.size(); i++) { 12505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent delete mOutputProfiles[i]; 12515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 12525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mInputProfiles.size(); i++) { 12535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent delete mInputProfiles[i]; 12545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 1255f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1256f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1257f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::initCheck() 1258f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1259b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return (mPrimaryOutput == 0) ? NO_INIT : NO_ERROR; 1260f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1261f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1262f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#ifdef AUDIO_POLICY_TEST 1263f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinbool AudioPolicyManagerBase::threadLoop() 1264f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 12656a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("entering threadLoop()"); 1266f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin while (!exitPending()) 1267f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin { 1268f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 command; 1269f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int valueInt; 1270f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 value; 1271f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1272f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin Mutex::Autolock _l(mLock); 1273f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mWaitWorkCV.waitRelative(mLock, milliseconds(50)); 1274f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1275f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin command = mpClientInterface->getParameters(0, String8("test_cmd_policy")); 1276f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter param = AudioParameter(command); 1277f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1278f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.getInt(String8("test_cmd_policy"), valueInt) == NO_ERROR && 1279f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin valueInt != 0) { 12806a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("Test command %s received", command.string()); 1281f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 target; 1282f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.get(String8("target"), target) != NO_ERROR) { 1283f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin target = "Manager"; 1284f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1285f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.getInt(String8("test_cmd_policy_output"), valueInt) == NO_ERROR) { 1286f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_output")); 1287f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mCurOutput = valueInt; 1288f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1289f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.get(String8("test_cmd_policy_direct"), value) == NO_ERROR) { 1290f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_direct")); 1291f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (value == "false") { 1292f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mDirectOutput = false; 1293f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (value == "true") { 1294f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mDirectOutput = true; 1295f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1296f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1297f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.getInt(String8("test_cmd_policy_input"), valueInt) == NO_ERROR) { 1298f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_input")); 1299f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestInput = valueInt; 1300f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1301f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1302f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.get(String8("test_cmd_policy_format"), value) == NO_ERROR) { 1303f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_format")); 1304f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int format = AudioSystem::INVALID_FORMAT; 1305f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (value == "PCM 16 bits") { 1306f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin format = AudioSystem::PCM_16_BIT; 1307f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (value == "PCM 8 bits") { 1308f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin format = AudioSystem::PCM_8_BIT; 1309f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (value == "Compressed MP3") { 1310f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin format = AudioSystem::MP3; 1311f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1312f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (format != AudioSystem::INVALID_FORMAT) { 1313f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (target == "Manager") { 1314f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestFormat = format; 1315f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (mTestOutputs[mCurOutput] != 0) { 1316f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputParam = AudioParameter(); 1317f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputParam.addInt(String8("format"), format); 1318f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 1319f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1320f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1321f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1322f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.get(String8("test_cmd_policy_channels"), value) == NO_ERROR) { 1323f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_channels")); 1324f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int channels = 0; 1325f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1326f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (value == "Channels Stereo") { 1327f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels = AudioSystem::CHANNEL_OUT_STEREO; 1328f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (value == "Channels Mono") { 1329f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin channels = AudioSystem::CHANNEL_OUT_MONO; 1330f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1331f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (channels != 0) { 1332f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (target == "Manager") { 1333f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestChannels = channels; 1334f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (mTestOutputs[mCurOutput] != 0) { 1335f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputParam = AudioParameter(); 1336f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputParam.addInt(String8("channels"), channels); 1337f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 1338f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1339f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1340f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1341f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.getInt(String8("test_cmd_policy_sampleRate"), valueInt) == NO_ERROR) { 1342f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_sampleRate")); 1343f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (valueInt >= 0 && valueInt <= 96000) { 1344f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int samplingRate = valueInt; 1345f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (target == "Manager") { 1346f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mTestSamplingRate = samplingRate; 1347f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (mTestOutputs[mCurOutput] != 0) { 1348f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputParam = AudioParameter(); 1349f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputParam.addInt(String8("sampling_rate"), samplingRate); 1350f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString()); 1351f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1352f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1353f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1354f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1355f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (param.get(String8("test_cmd_policy_reopen"), value) == NO_ERROR) { 1356f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.remove(String8("test_cmd_policy_reopen")); 1357f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1358b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->closeOutput(mPrimaryOutput); 1359b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent delete mOutputs.valueFor(mPrimaryOutput); 1360b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mOutputs.removeItem(mPrimaryOutput); 1361f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1362b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor(NULL); 1363f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mDevice = (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER; 1364b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mPrimaryOutput = mpClientInterface->openOutput(&outputDesc->mDevice, 1365f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mSamplingRate, 1366f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mFormat, 1367f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mChannels, 1368f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin &outputDesc->mLatency, 1369f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mFlags); 1370b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (mPrimaryOutput == 0) { 13715efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("Failed to reopen hardware output stream, samplingRate: %d, format %d, channels %d", 1372f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mSamplingRate, outputDesc->mFormat, outputDesc->mChannels); 1373f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 1374f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioParameter outputCmd = AudioParameter(); 1375f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputCmd.addInt(String8("set_id"), 0); 1376b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->setParameters(mPrimaryOutput, outputCmd.toString()); 1377b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent addOutput(mPrimaryOutput, outputDesc); 1378f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1379f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1380f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1381f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1382f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setParameters(0, String8("test_cmd_policy=")); 1383f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1384f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1385f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return false; 1386f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1387f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1388f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::exit() 1389f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1390f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin { 1391f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AutoMutex _l(mLock); 1392f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin requestExit(); 1393f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mWaitWorkCV.signal(); 1394f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1395f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin requestExitAndWait(); 1396f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1397f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1398f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinint AudioPolicyManagerBase::testOutputIndex(audio_io_handle_t output) 1399f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1400f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < NUM_TEST_OUTPUTS; i++) { 1401f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (output == mTestOutputs[i]) return i; 1402f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1403f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 1404f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1405f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin#endif //AUDIO_POLICY_TEST 1406f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1407f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// --- 1408f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1409f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::addOutput(audio_io_handle_t id, AudioOutputDescriptor *outputDesc) 1410f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1411f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mId = id; 1412f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.add(id, outputDesc); 1413f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1414f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1415f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1416b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurentaudio_io_handle_t AudioPolicyManagerBase::checkOutputForDevice( 1417f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device, 1418b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioSystem::device_connection_state state) 1419f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1420b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent audio_io_handle_t output = 0; 1421b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc; 1422b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1423b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // TODO handle multiple outputs supporting overlapping sets of devices. 1424b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1425b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (state == AudioSystem::DEVICE_STATE_AVAILABLE) { 1426b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // first check if one output already open can be routed to this device 1427b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 1428b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = mOutputs.valueAt(i); 1429b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (outputDesc->mProfile && outputDesc->mProfile->mSupportedDevices & device) { 1430b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return mOutputs.keyAt(i); 1431b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1432b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1433b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // then look for one available output that can be routed to this device 14345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const IOProfile *outProfile = NULL; 14355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mOutputProfiles.size(); i++) 1436b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent { 14375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mOutputProfiles[i]->mSupportedDevices & device) { 14385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outProfile = mOutputProfiles[i]; 1439b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent break; 1440b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1441b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 14425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outProfile == NULL) { 1443b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGW("No output available for device %04x", device); 1444b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return output; 1445b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1446b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1447b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("opening output for device %08x", device); 14485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc = new AudioOutputDescriptor(outProfile); 1449b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc->mDevice = device; 1450f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent output = mpClientInterface->openOutput((uint32_t *)&outputDesc->mDevice, 1451b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mSamplingRate, 1452b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mFormat, 1453b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mChannels, 1454b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent &outputDesc->mLatency, 1455b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc->mFlags); 1456b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1457b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (output != 0) { 1458b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent audio_io_handle_t duplicatedOutput = 0; 1459b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // add output descriptor 1460b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent addOutput(output, outputDesc); 1461b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // set initial stream volume for device 1462b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent applyStreamVolumes(output, device); 1463b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1464b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent //TODO: configure audio effect output stage here 1465b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1466b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // open a duplicating output thread for the new output and the primary output 1467b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent duplicatedOutput = mpClientInterface->openDuplicateOutput(output, mPrimaryOutput); 1468b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (duplicatedOutput != 0) { 1469f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // add duplicated output descriptor 1470b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *dupOutputDesc = new AudioOutputDescriptor(NULL); 1471b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent dupOutputDesc->mOutput1 = mOutputs.valueFor(mPrimaryOutput); 1472b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent dupOutputDesc->mOutput2 = mOutputs.valueFor(output); 1473f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin dupOutputDesc->mSamplingRate = outputDesc->mSamplingRate; 1474f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin dupOutputDesc->mFormat = outputDesc->mFormat; 1475f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin dupOutputDesc->mChannels = outputDesc->mChannels; 1476f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin dupOutputDesc->mLatency = outputDesc->mLatency; 1477b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent addOutput(duplicatedOutput, dupOutputDesc); 1478b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent applyStreamVolumes(duplicatedOutput, device); 1479b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else { 1480b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGW("getOutput() could not open duplicated output for %d and %d", 1481b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mPrimaryOutput, output); 1482b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->closeOutput(output); 1483b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mOutputs.removeItem(output); 1484b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent delete outputDesc; 1485b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return 0; 1486f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1487f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 14885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW("checkOutputForDevice() could not open output for device %x", device); 1489f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin delete outputDesc; 1490b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return 0; 1491f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1492f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 1493b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // we assume that one given device is supported by zero or one output 1494b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // check if one opened output is not needed any more after disconnecting one device 1495b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 1496b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc = mOutputs.valueAt(i); 1497b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (outputDesc->mProfile && 1498b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent !(outputDesc->mProfile->mSupportedDevices & mAvailableOutputDevices)) { 1499b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent output = mOutputs.keyAt(i); 1500b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent break; 1501b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1502f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1503f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1504f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1505b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return output; 1506f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1507f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1508b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurentvoid AudioPolicyManagerBase::closeOutput(audio_io_handle_t output) 1509f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1510b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("closeOutput(%d)", output); 1511f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1512b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 1513b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (outputDesc == NULL) { 1514b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGW("closeOutput() unknown output %d", output); 1515b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return; 1516f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1517f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1518b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // look for duplicated outputs connected to the output being removed. 1519b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 1520b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *dupOutputDesc = mOutputs.valueAt(i); 1521b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (dupOutputDesc->isDuplicated() && 1522b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent (dupOutputDesc->mOutput1 == outputDesc || 1523b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent dupOutputDesc->mOutput2 == outputDesc)) { 1524b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc2; 1525b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (dupOutputDesc->mOutput1 == outputDesc) { 1526b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc2 = dupOutputDesc->mOutput2; 1527b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else { 1528b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc2 = dupOutputDesc->mOutput1; 1529b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1530b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // As all active tracks on duplicated output will be deleted, 1531b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // and as they were also referenced on the other output, the reference 1532b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // count for their stream type must be adjusted accordingly on 1533b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent // the other output. 1534b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (int j = 0; j < (int)AudioSystem::NUM_STREAM_TYPES; j++) { 1535b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent int refCount = dupOutputDesc->mRefCount[j]; 1536b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputDesc2->changeRefCount((AudioSystem::stream_type)j,-refCount); 1537b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1538b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i); 1539b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput); 1540f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1541b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->closeOutput(duplicatedOutput); 1542b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent delete mOutputs.valueFor(duplicatedOutput); 1543b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mOutputs.removeItem(duplicatedOutput); 1544f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1545f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1546b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1547b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioParameter param; 1548b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent param.add(String8("closing"), String8("true")); 1549b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->setParameters(output, param.toString()); 1550b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1551b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->closeOutput(output); 1552b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent delete mOutputs.valueFor(output); 1553b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mOutputs.removeItem(output); 1554f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1555f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1556f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric LaurentSortedVector<audio_io_handle_t> AudioPolicyManagerBase::getOutputsForDevice(audio_devices_t device) 1557f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1558b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent SortedVector<audio_io_handle_t> outputs; 1559f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1560b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("getOutputsForDevice() device %04x", device); 1561b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 156212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi ALOGV("output %d isDuplicated=%d device=%04x", 156312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi i, mOutputs.valueAt(i)->isDuplicated(), mOutputs.valueAt(i)->supportedDevices()); 1564b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if ((device & mOutputs.valueAt(i)->supportedDevices()) == device) { 1565b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("getOutputsForDevice() found output %d", mOutputs.keyAt(i)); 1566b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent outputs.add(mOutputs.keyAt(i)); 1567f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1568f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1569b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return outputs; 1570f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1571f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1572b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurentbool AudioPolicyManagerBase::vectorsEqual(SortedVector<audio_io_handle_t>& outputs1, 1573b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent SortedVector<audio_io_handle_t>& outputs2) 1574f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1575b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (outputs1.size() != outputs2.size()) { 1576b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return false; 1577f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1578b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < outputs1.size(); i++) { 1579b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (outputs1[i] != outputs2[i]) { 1580b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return false; 1581f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1582f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1583b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return true; 1584b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent} 1585b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1586b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurentvoid AudioPolicyManagerBase::checkOutputForStrategy(routing_strategy strategy) 1587b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent{ 1588b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent SortedVector<audio_io_handle_t> srcOutputs = 15895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent getOutputsForDevice(getDeviceForStrategy(strategy, true /*fromCache*/)); 1590b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent SortedVector<audio_io_handle_t> dstOutputs = 15915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent getOutputsForDevice(getDeviceForStrategy(strategy, false /*fromCache*/)); 1592b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1593b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (!vectorsEqual(srcOutputs,dstOutputs)) { 159412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // FIXME dstOutputs[0] happens to be the output to use, what guarantees it is always true? 1595b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent ALOGV("checkOutputForStrategy() strategy %d, moving from output %d to output %d", 1596b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent strategy, srcOutputs[0], dstOutputs[0]); 15975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // mute strategy while moving tracks from one output to another 15985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < srcOutputs.size(); i++) { 15995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setStrategyMute(strategy, true, srcOutputs[i]); 16005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setStrategyMute(strategy, false, srcOutputs[i], MUTE_TIME_MS); 16015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 1602f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1603f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Move effects associated to this strategy from previous output to new output 16045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent//FIXME: removing this code works for effects applied to a particular session as they will be 16055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// re-connected when the tracks are re-created after being invalidated. 16065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// However we need to define a policy for global effects when more than one output is possible 16075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// for (size_t i = 0; i < mEffects.size(); i++) { 16085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// EffectDescriptor *desc = mEffects.valueAt(i); 16095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// if (desc->mSession != AudioSystem::SESSION_OUTPUT_STAGE && 16105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// desc->mStrategy == strategy && 16115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// desc->mIo == srcOutputs[0]) { 16125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// ALOGV("checkOutputForStrategy() moving effect %d to output %d", 16135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// mEffects.keyAt(i), dstOutputs[0]); 16145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// mpClientInterface->moveEffects(desc->mSession, srcOutputs[0], dstOutputs[0]); 16155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// desc->mIo = dstOutputs[0]; 16165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// } 16175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// } 16185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // Move tracks associated to this strategy from previous output to new output 1619f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) { 1620f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (getStrategy((AudioSystem::stream_type)i) == strategy) { 162112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi //FIXME see fixme on name change 1622b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->setStreamOutput((AudioSystem::stream_type)i, dstOutputs[0]); 1623f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1624f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1625f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1626f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1627f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1628f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::checkOutputForAllStrategies() 1629f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1630c16ac09f510437e8340be691720177a490ae78f0Eric Laurent checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE); 1631f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForStrategy(STRATEGY_PHONE); 1632f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForStrategy(STRATEGY_SONIFICATION); 163312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL); 1634f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForStrategy(STRATEGY_MEDIA); 1635f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin checkOutputForStrategy(STRATEGY_DTMF); 1636f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1637f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1638b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurentaudio_io_handle_t AudioPolicyManagerBase::getA2dpOutput() 1639b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent{ 16405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (!mHasA2dp) { 1641b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return 0; 1642b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1643b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1644b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent for (size_t i = 0; i < mOutputs.size(); i++) { 1645b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = mOutputs.valueAt(i); 1646b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (!outputDesc->isDuplicated() && outputDesc->device() & AUDIO_DEVICE_OUT_ALL_A2DP) { 1647b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return mOutputs.keyAt(i); 1648b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1649b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1650b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1651b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return 0; 1652b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent} 1653b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1654f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::checkA2dpSuspend() 1655f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 16565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (!mHasA2dp) { 1657b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return; 1658b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1659b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent audio_io_handle_t a2dpOutput = getA2dpOutput(); 1660b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (a2dpOutput == 0) { 1661b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return; 1662b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 1663b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 1664f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // suspend A2DP output if: 1665f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (NOT already suspended) && 1666f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // ((SCO device is connected && 1667f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (forced usage for communication || for record is SCO))) || 1668f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (phone state is ringing || in call) 1669f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // 1670f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // restore A2DP output if: 1671f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (Already suspended) && 1672f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // ((SCO device is NOT connected || 1673f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (forced usage NOT for communication && NOT for record is SCO))) && 1674f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // (phone state is NOT ringing && NOT in call) 1675f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // 1676f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mA2dpSuspended) { 1677f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (((mScoDeviceAddress == "") || 1678f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ((mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO) && 1679f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (mForceUse[AudioSystem::FOR_RECORD] != AudioSystem::FORCE_BT_SCO))) && 1680f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ((mPhoneState != AudioSystem::MODE_IN_CALL) && 1681f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (mPhoneState != AudioSystem::MODE_RINGTONE))) { 1682f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1683b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->restoreOutput(a2dpOutput); 1684f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mA2dpSuspended = false; 1685f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1686f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 1687f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (((mScoDeviceAddress != "") && 1688f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ((mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) || 1689f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO))) || 1690f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin ((mPhoneState == AudioSystem::MODE_IN_CALL) || 1691f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (mPhoneState == AudioSystem::MODE_RINGTONE))) { 1692f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1693b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent mpClientInterface->suspendOutput(a2dpOutput); 1694f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mA2dpSuspended = true; 1695f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1696f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1697f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1698f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1699f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentaudio_devices_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output, bool fromCache) 1700f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1701f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device = (audio_devices_t)0; 1702f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1703f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 1704f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // check the following by order of priority to request a routing change if necessary: 1705c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // 1: the strategy enforced audible is active on the output: 1706c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // use device for strategy enforced audible 1707c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // 2: we are in call or the strategy phone is active on the output: 1708f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // use device for strategy phone 1709c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // 3: the strategy sonification is active on the output: 1710f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // use device for strategy sonification 171112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // 4: the strategy "respectful" sonification is active on the output: 171212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // use device for strategy "respectful" sonification 171312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // 5: the strategy media is active on the output: 1714f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // use device for strategy media 171512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // 6: the strategy DTMF is active on the output: 1716f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // use device for strategy DTMF 1717c16ac09f510437e8340be691720177a490ae78f0Eric Laurent if (outputDesc->isUsedByStrategy(STRATEGY_ENFORCED_AUDIBLE)) { 1718c16ac09f510437e8340be691720177a490ae78f0Eric Laurent device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache); 1719c16ac09f510437e8340be691720177a490ae78f0Eric Laurent } else if (isInCall() || 1720c16ac09f510437e8340be691720177a490ae78f0Eric Laurent outputDesc->isUsedByStrategy(STRATEGY_PHONE)) { 1721f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = getDeviceForStrategy(STRATEGY_PHONE, fromCache); 1722f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) { 1723f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache); 172412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi } else if (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION_RESPECTFUL)) { 17255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache); 1726f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) { 1727f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache); 1728f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) { 1729f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = getDeviceForStrategy(STRATEGY_DTMF, fromCache); 1730f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1731f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 17326a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getNewDevice() selected device %x", device); 1733f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return device; 1734f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1735f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1736f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinuint32_t AudioPolicyManagerBase::getStrategyForStream(AudioSystem::stream_type stream) { 1737f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return (uint32_t)getStrategy(stream); 1738f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1739f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1740f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentaudio_devices_t AudioPolicyManagerBase::getDevicesForStream(AudioSystem::stream_type stream) { 1741f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t devices; 1742f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // By checking the range of stream before calling getStrategy, we avoid 17435efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block // getStrategy's behavior for invalid streams. getStrategy would do a ALOGE 1744f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // and then return STRATEGY_MEDIA, but we want to return the empty set. 1745f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream < (AudioSystem::stream_type) 0 || stream >= AudioSystem::NUM_STREAM_TYPES) { 1746f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent devices = (audio_devices_t)0; 1747f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 1748f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioPolicyManagerBase::routing_strategy strategy = getStrategy(stream); 17495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent devices = getDeviceForStrategy(strategy, true /*fromCache*/); 1750f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1751f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return devices; 1752f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1753f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1754f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima ZavinAudioPolicyManagerBase::routing_strategy AudioPolicyManagerBase::getStrategy( 1755f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::stream_type stream) { 1756f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // stream to strategy mapping 1757f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch (stream) { 1758f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::VOICE_CALL: 1759f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::BLUETOOTH_SCO: 1760f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return STRATEGY_PHONE; 1761f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::RING: 1762f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::ALARM: 1763f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return STRATEGY_SONIFICATION; 176412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi case AudioSystem::NOTIFICATION: 176512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi return STRATEGY_SONIFICATION_RESPECTFUL; 1766f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::DTMF: 1767f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return STRATEGY_DTMF; 1768f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 17695efbd421e0029d6fc44b1cc65c0e5e0d85e5161fSteve Block ALOGE("unknown stream type"); 1770f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::SYSTEM: 1771f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // NOTE: SYSTEM stream uses MEDIA strategy because muting music and switching outputs 1772f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // while key clicks are played produces a poor result 1773f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::TTS: 1774f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::MUSIC: 1775f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return STRATEGY_MEDIA; 1776c16ac09f510437e8340be691720177a490ae78f0Eric Laurent case AudioSystem::ENFORCED_AUDIBLE: 1777c16ac09f510437e8340be691720177a490ae78f0Eric Laurent return STRATEGY_ENFORCED_AUDIBLE; 1778f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1779f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1780f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 178112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivivoid AudioPolicyManagerBase::handleNotificationRoutingForStream(AudioSystem::stream_type stream) { 178212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi switch(stream) { 178312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi case AudioSystem::MUSIC: 178412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL); 178512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi updateDeviceForStrategy(); 178612bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi break; 178712bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi default: 178812bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi break; 178912bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi } 179012bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi} 179112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 17925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentaudio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy strategy, 17935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent bool fromCache) 1794f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1795f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t device = 0; 1796f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1797f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (fromCache) { 17985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("getDeviceForStrategy() from cache strategy %d, device %x", 17995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent strategy, mDeviceForStrategy[strategy]); 1800f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return mDeviceForStrategy[strategy]; 1801f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1802f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1803f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch (strategy) { 180412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 180512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi case STRATEGY_SONIFICATION_RESPECTFUL: 180612bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi if (isInCall()) { 18075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/); 180812bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi } else if (isStreamActive(AudioSystem::MUSIC, SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)) { 180912bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // while media is playing (or has recently played), use the same device 18105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/); 181112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi } else { 181212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi // when media is not playing anymore, fall back on the sonification behavior 18135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/); 181412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi } 181512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 181612bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi break; 181712bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi 1818f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case STRATEGY_DTMF: 1819f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!isInCall()) { 1820f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when off call, DTMF strategy follows the same rules as MEDIA strategy 18215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/); 1822f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1823f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1824f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when in call, DTMF and PHONE strategies follow the same rules 1825f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // FALL THROUGH 1826f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1827f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case STRATEGY_PHONE: 1828f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // for phone strategy, we first consider the forced use and then the available devices by order 1829f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // of priority 1830f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) { 1831f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FORCE_BT_SCO: 1832f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (!isInCall() || strategy != STRATEGY_DTMF) { 1833f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT; 1834f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1835f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1836f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET; 1837f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1838f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO; 1839f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1840f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if SCO device is requested but no SCO device is available, fall back to default case 1841f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // FALL THROUGH 1842f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1843f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: // FORCE_NONE 1844f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE; 1845f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1846f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET; 1847f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1848f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to A2DP 18495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mHasA2dp && !isInCall() && !mA2dpSuspended) { 1850f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP; 1851f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1852f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES; 1853f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1854f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1855f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET; 1856f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 185755ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL; 185855ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent if (device) break; 1859f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET; 1860f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1861f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_EARPIECE; 18625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (device) break; 18635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = mDefaultOutputDevice; 1864f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 18655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE"); 1866f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1867f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1868f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1869f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AudioSystem::FORCE_SPEAKER: 1870f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to 1871f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // A2DP speaker when forcing to speaker output 18725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mHasA2dp && !isInCall() && !mA2dpSuspended) { 1873f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER; 1874f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1875f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1876f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET; 1877f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 187855ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL; 187955ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent if (device) break; 1880f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET; 1881f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device) break; 1882f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER; 18835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (device) break; 18845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = mDefaultOutputDevice; 1885f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 18865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE, FORCE_SPEAKER"); 1887f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1888f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1889f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1890f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1891f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1892f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case STRATEGY_SONIFICATION: 1893f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1894f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // If incall, just select the STRATEGY_PHONE device: The rest of the behavior is handled by 1895f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // handleIncallSonification(). 1896f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isInCall()) { 18975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/); 1898f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1899f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1900c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // FALL THROUGH 1901c16ac09f510437e8340be691720177a490ae78f0Eric Laurent 1902c16ac09f510437e8340be691720177a490ae78f0Eric Laurent case STRATEGY_ENFORCED_AUDIBLE: 1903c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // strategy STRATEGY_ENFORCED_AUDIBLE uses same routing policy as STRATEGY_SONIFICATION 1904c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // except when in call where it doesn't default to STRATEGY_PHONE behavior 1905c16ac09f510437e8340be691720177a490ae78f0Eric Laurent 1906f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER; 1907f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 19085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE("getDeviceForStrategy() speaker device not found for STRATEGY_SONIFICATION"); 1909f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1910f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // The second device used for sonification is the same as the device used by media strategy 1911f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // FALL THROUGH 1912f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1913f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case STRATEGY_MEDIA: { 1914f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE; 1915f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1916f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET; 1917f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 19185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mHasA2dp && (getA2dpOutput() != 0) && !mA2dpSuspended) { 1919f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1920f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP; 1921f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1922f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1923f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES; 1924f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1925f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1926f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER; 1927f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1928f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1929f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 193055ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET; 1931f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1932f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 193355ac23bc116ad9ae38266a5e660fd22f5104348eEric Laurent device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL; 1934f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1935f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1936f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET; 1937f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1938f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device2 == 0) { 1939f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER; 1940f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1941f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1942c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION or 1943c16ac09f510437e8340be691720177a490ae78f0Eric Laurent // STRATEGY_ENFORCED_AUDIBLE, 0 otherwise 1944f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device |= device2; 19455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (device) break; 19465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = mDefaultOutputDevice; 1947f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 19485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGE("getDeviceForStrategy() no device found for STRATEGY_MEDIA"); 1949f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1950f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } break; 1951f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1952f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 195364cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("getDeviceForStrategy() unknown strategy: %d", strategy); 1954f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 1955f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 1956f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 19576a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getDeviceForStrategy() strategy %d, device %x", strategy, device); 1958f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent return (audio_devices_t)device; 1959f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 1960f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 1961f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::updateDeviceForStrategy() 1962f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 1963f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < NUM_STRATEGIES; i++) { 19645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/); 19655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 19665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 19675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 19685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::checkDeviceMuteStrategies(AudioOutputDescriptor *outputDesc, 19695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t delayMs) 19705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 19715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // mute/unmute strategies using an incompatible device combination 19725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // if muting, wait for the audio in pcm buffer to be drained before proceeding 19735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // if unmuting, unmute only after the specified delay 19745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 19755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputDesc->isDuplicated()) { 19765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 19775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 19785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 19795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t muteWaitMs = 0; 19805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t device = outputDesc->device(); 19815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent bool shouldMute = (outputDesc->refCount() != 0) && 19825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (AudioSystem::popCount(device) >= 2); 19835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 19845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < NUM_STRATEGIES; i++) { 19855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t curDevice = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/); 19865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent bool mute = shouldMute && (curDevice & device) && (curDevice != device); 19875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent bool doMute = false; 19885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 19895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mute && !outputDesc->mStrategyMutedByDevice[i]) { 19905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent doMute = true; 19915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mStrategyMutedByDevice[i] = true; 19925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (!mute && outputDesc->mStrategyMutedByDevice[i]){ 19935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent doMute = true; 19945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mStrategyMutedByDevice[i] = false; 19955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 19965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (doMute) { 19975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t j = 0; j < mOutputs.size(); j++) { 19985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioOutputDescriptor *desc = mOutputs.valueAt(j); 19995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((desc->supportedDevices() & outputDesc->supportedDevices()) == 0) { 20005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent continue; 20015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_io_handle_t curOutput = mOutputs.keyAt(j); 20035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("checkDeviceMuteStrategies() %s strategy %d (curDevice %04x) on output %d", 20045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mute ? "muting" : "unmuting", i, curDevice, curOutput); 20055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent setStrategyMute((routing_strategy)i, mute, curOutput, mute ? 0 : delayMs); 20065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mute && (desc->strategyRefCount((routing_strategy)i) != 0)) { 20075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (muteWaitMs < desc->latency()) { 20085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent muteWaitMs = desc->latency(); 20095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 20155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // FIXME: should not need to double latency if volume could be applied immediately by the 20165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // audioflinger mixer. We must account for the delay between now and the next time 20175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // the audioflinger thread for this output will process a buffer (which corresponds to 20185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // one buffer size, usually 1/2 or 1/4 of the latency). 20195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent muteWaitMs *= 2; 20205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // wait for the PCM output buffers to empty before proceeding with the rest of the command 20215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (muteWaitMs > delayMs) { 20225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent usleep((muteWaitMs - delayMs)*1000); 2023f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2024f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2025f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2026f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentvoid AudioPolicyManagerBase::setOutputDevice(audio_io_handle_t output, 2027f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device, 2028f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent bool force, 2029f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent int delayMs) 2030f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 20315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("setOutputDevice() output %d device %04x delayMs %d", output, device, delayMs); 2032f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 20335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent AudioParameter param; 2034f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2035f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->isDuplicated()) { 2036f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin setOutputDevice(outputDesc->mOutput1->mId, device, force, delayMs); 2037f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin setOutputDevice(outputDesc->mOutput2->mId, device, force, delayMs); 2038f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 2039f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2040f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // filter devices according to output selected 2041f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent device = (audio_devices_t)(device & outputDesc->mProfile->mSupportedDevices); 2042f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 20435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_devices_t prevDevice = outputDesc->mDevice; 20445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 20455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("setOutputDevice() prevDevice %04x", prevDevice); 20465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 20475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (device != 0) { 20485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent outputDesc->mDevice = device; 20495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent checkDeviceMuteStrategies(outputDesc, delayMs); 20515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 2052f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Do not change the routing if: 20535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // - the requested device is 0 2054f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // - the requested device is the same as current device and force is not specified. 2055f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Doing this check here allows the caller to call setOutputDevice() without conditions 2056f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if ((device == 0 || device == prevDevice) && !force) { 20575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("setOutputDevice() setting same device %04x or null device for output %d", device, output); 2058f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 2059f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2060f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 20615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("setOutputDevice() changing device"); 2062f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // do the routing 2063f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin param.addInt(String8(AudioParameter::keyRouting), (int)device); 20645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mpClientInterface->setParameters(output, param.toString(), delayMs); 20655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 2066f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // update stream volumes according to new device 2067f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin applyStreamVolumes(output, device, delayMs); 20685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 2069f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 20705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric LaurentAudioPolicyManagerBase::IOProfile *AudioPolicyManagerBase::getInputProfile(audio_devices_t device, 20715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t samplingRate, 20725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t format, 20735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t channelMask) 20745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 20755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent IOProfile *inProfile = NULL; 20765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 20775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // Choose an input profile based on the requested capture parameters: select the first available 20785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // profile supporting all requested parameters. 20795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 20805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mInputProfiles.size(); i++) 20815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent { 20825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent IOProfile *profile = mInputProfiles[i]; 20835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent size_t j; 20845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((profile->mSupportedDevices & device) == 0) { 20855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent continue; 20865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (j = 0; j < profile->mSamplingRates.size(); j++) 20885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent { 20895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (profile->mSamplingRates[j] == samplingRate) { 20905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent break; 20915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (j == profile->mSamplingRates.size()) { 20945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent continue; 20955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 20965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (j = 0; j < profile->mFormats.size(); j++) 20975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent { 20985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (profile->mFormats[j] == format) { 20995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent break; 21005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (j == profile->mFormats.size()) { 21035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent continue; 21045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (j = 0; j < profile->mChannelMasks.size(); j++) 21065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent { 21075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (profile->mChannelMasks[j] == channelMask) { 21085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent break; 21095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (j == profile->mChannelMasks.size()) { 21125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent continue; 21135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 21145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 21155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent inProfile = profile; 21165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent break; 2117f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 21185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(inProfile == NULL, "getInputProfile() no available input for device %04x" 21195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "samplingRate %d, format %d channel mask %04x", 21205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device, 21215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent samplingRate, 21225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent format, 21235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent channelMask); 21245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return inProfile; 2125f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2126f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2127f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentaudio_devices_t AudioPolicyManagerBase::getDeviceForInputSource(int inputSource) 2128f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 21295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t device = 0; 2130f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2131f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin switch(inputSource) { 2132f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_DEFAULT: 2133f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_MIC: 2134f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_RECOGNITION: 2135f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_COMMUNICATION: 2136f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO && 2137f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mAvailableInputDevices & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) { 2138f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET; 2139f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else if (mAvailableInputDevices & AudioSystem::DEVICE_IN_WIRED_HEADSET) { 2140f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_WIRED_HEADSET; 21415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (mAvailableInputDevices & AudioSystem::DEVICE_IN_BUILTIN_MIC) { 2142f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_BUILTIN_MIC; 2143f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2144f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 2145f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_CAMCORDER: 21465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mAvailableInputDevices & AudioSystem::DEVICE_IN_BACK_MIC) { 2147f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_BACK_MIC; 21485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (mAvailableInputDevices & AudioSystem::DEVICE_IN_BUILTIN_MIC) { 2149f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = AudioSystem::DEVICE_IN_BUILTIN_MIC; 2150f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2151f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 2152f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_UPLINK: 2153f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_DOWNLINK: 2154f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin case AUDIO_SOURCE_VOICE_CALL: 21555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (mAvailableInputDevices & AudioSystem::DEVICE_IN_VOICE_CALL) { 21565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device = AudioSystem::DEVICE_IN_VOICE_CALL; 21575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 2158f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 2159f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin default: 216064cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("getDeviceForInputSource() invalid input source %d", inputSource); 2161f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin break; 2162f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 21636a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("getDeviceForInputSource()input source %d, device %08x", inputSource, device); 2164f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent return (audio_devices_t)device; 2165f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2166f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2167f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinaudio_io_handle_t AudioPolicyManagerBase::getActiveInput() 2168f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2169f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (size_t i = 0; i < mInputs.size(); i++) { 2170f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mInputs.valueAt(i)->mRefCount > 0) { 2171f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return mInputs.keyAt(i); 2172f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2173f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2174f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0; 2175f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2176f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2177e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2178c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentaudio_devices_t AudioPolicyManagerBase::getDeviceForVolume(audio_devices_t device) 2179e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent{ 2180e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent if (device == 0) { 2181e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // this happens when forcing a route update and no track is active on an output. 2182e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // In this case the returned category is not important. 2183c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = AUDIO_DEVICE_OUT_SPEAKER; 2184c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } else if (AudioSystem::popCount(device) > 1) { 2185e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // Multiple device selection is either: 2186e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // - speaker + one other device: give priority to speaker in this case. 2187e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // - one A2DP device + another device: happens with duplicated output. In this case 2188e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // retain the device on the A2DP output as the other must not correspond to an active 2189e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent // selection if not the speaker. 2190c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (device & AUDIO_DEVICE_OUT_SPEAKER) { 2191c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = AUDIO_DEVICE_OUT_SPEAKER; 2192c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } else { 2193c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = (audio_devices_t)(device & AUDIO_DEVICE_OUT_ALL_A2DP); 2194c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 2195e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent } 2196e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 219764cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW_IF(AudioSystem::popCount(device) != 1, 2198c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent "getDeviceForVolume() invalid device combination: %08x", 2199e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent device); 2200e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2201c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent return device; 2202c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent} 2203c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 2204f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric LaurentAudioPolicyManagerBase::device_category AudioPolicyManagerBase::getDeviceCategory(audio_devices_t device) 2205c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent{ 2206f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent switch(getDeviceForVolume(device)) { 2207e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_EARPIECE: 2208e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent return DEVICE_CATEGORY_EARPIECE; 2209e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_WIRED_HEADSET: 2210e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: 2211e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_SCO: 2212e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 2213e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP: 2214e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES: 2215e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent return DEVICE_CATEGORY_HEADSET; 2216e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_SPEAKER: 2217e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 2218e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER: 2219c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent case AUDIO_DEVICE_OUT_AUX_DIGITAL: 2220e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent default: 2221e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent return DEVICE_CATEGORY_SPEAKER; 2222e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent } 2223e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent} 2224e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2225f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentfloat AudioPolicyManagerBase::volIndexToAmpl(audio_devices_t device, const StreamDescriptor& streamDesc, 2226e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent int indexInUi) 2227e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent{ 2228e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent device_category deviceCategory = getDeviceCategory(device); 2229e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent const VolumeCurvePoint *curve = streamDesc.mVolumeCurve[deviceCategory]; 2230e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2231f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // the volume index in the UI is relative to the min and max volume indices for this stream type 2232e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent int nbSteps = 1 + curve[VOLMAX].mIndex - 2233e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[VOLMIN].mIndex; 2234f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int volIdx = (nbSteps * (indexInUi - streamDesc.mIndexMin)) / 2235f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (streamDesc.mIndexMax - streamDesc.mIndexMin); 2236f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2237f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // find what part of the curve this index volume belongs to, or if it's out of bounds 2238f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int segment = 0; 2239e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent if (volIdx < curve[VOLMIN].mIndex) { // out of bounds 2240f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 0.0f; 2241e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent } else if (volIdx < curve[VOLKNEE1].mIndex) { 2242f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin segment = 0; 2243e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent } else if (volIdx < curve[VOLKNEE2].mIndex) { 2244f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin segment = 1; 2245e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent } else if (volIdx <= curve[VOLMAX].mIndex) { 2246f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin segment = 2; 2247f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { // out of bounds 2248f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 1.0f; 2249f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2250f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2251f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // linear interpolation in the attenuation table in dB 2252e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent float decibels = curve[segment].mDBAttenuation + 2253e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent ((float)(volIdx - curve[segment].mIndex)) * 2254e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent ( (curve[segment+1].mDBAttenuation - 2255e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment].mDBAttenuation) / 2256e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent ((float)(curve[segment+1].mIndex - 2257e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment].mIndex)) ); 2258f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2259f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin float amplification = exp( decibels * 0.115129f); // exp( dB * ln(10) / 20 ) 2260f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 22616a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("VOLUME vol index=[%d %d %d], dB=[%.1f %.1f %.1f] ampl=%.5f", 2262e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment].mIndex, volIdx, 2263e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment+1].mIndex, 2264e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment].mDBAttenuation, 2265cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent decibels, 2266e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent curve[segment+1].mDBAttenuation, 2267f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin amplification); 2268f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2269f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return amplification; 2270f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2271f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2272cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurentconst AudioPolicyManagerBase::VolumeCurvePoint 2273e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent AudioPolicyManagerBase::sDefaultVolumeCurve[AudioPolicyManagerBase::VOLCNT] = { 2274e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent {1, -49.5f}, {33, -33.5f}, {66, -17.0f}, {100, 0.0f} 2275e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent}; 2276e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2277e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurentconst AudioPolicyManagerBase::VolumeCurvePoint 2278e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent AudioPolicyManagerBase::sDefaultMediaVolumeCurve[AudioPolicyManagerBase::VOLCNT] = { 2279e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent {1, -58.0f}, {20, -40.0f}, {60, -17.0f}, {100, 0.0f} 2280cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent}; 2281cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent 2282e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurentconst AudioPolicyManagerBase::VolumeCurvePoint 2283e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent AudioPolicyManagerBase::sSpeakerMediaVolumeCurve[AudioPolicyManagerBase::VOLCNT] = { 2284e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent {1, -56.0f}, {20, -34.0f}, {60, -11.0f}, {100, 0.0f} 2285e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent}; 2286e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2287e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurentconst AudioPolicyManagerBase::VolumeCurvePoint 2288e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent AudioPolicyManagerBase::sSpeakerSonificationVolumeCurve[AudioPolicyManagerBase::VOLCNT] = { 2289e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent {1, -29.7f}, {33, -20.1f}, {66, -10.2f}, {100, 0.0f} 2290e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent}; 2291e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2292e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2293e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurentconst AudioPolicyManagerBase::VolumeCurvePoint 2294e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent *AudioPolicyManagerBase::sVolumeProfiles[AudioPolicyManagerBase::NUM_STRATEGIES] 2295e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent [AudioPolicyManagerBase::DEVICE_CATEGORY_CNT] = { 2296e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent { // STRATEGY_MEDIA 2297e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultMediaVolumeCurve, // DEVICE_CATEGORY_HEADSET 2298e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sSpeakerMediaVolumeCurve, // DEVICE_CATEGORY_SPEAKER 2299e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultMediaVolumeCurve // DEVICE_CATEGORY_EARPIECE 2300e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent }, 2301e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent { // STRATEGY_PHONE 2302e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_HEADSET 2303e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_SPEAKER 2304e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve // DEVICE_CATEGORY_EARPIECE 2305e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent }, 2306e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent { // STRATEGY_SONIFICATION 2307e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_HEADSET 2308e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sSpeakerSonificationVolumeCurve, // DEVICE_CATEGORY_SPEAKER 2309e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve // DEVICE_CATEGORY_EARPIECE 2310e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent }, 231112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi { // STRATEGY_SONIFICATION_RESPECTFUL uses same volumes as SONIFICATION 231212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi sDefaultVolumeCurve, // DEVICE_CATEGORY_HEADSET 231312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi sSpeakerSonificationVolumeCurve, // DEVICE_CATEGORY_SPEAKER 231412bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi sDefaultVolumeCurve // DEVICE_CATEGORY_EARPIECE 231512bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi }, 2316e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent { // STRATEGY_DTMF 2317e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_HEADSET 2318e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_SPEAKER 2319e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent sDefaultVolumeCurve // DEVICE_CATEGORY_EARPIECE 2320c16ac09f510437e8340be691720177a490ae78f0Eric Laurent }, 2321c16ac09f510437e8340be691720177a490ae78f0Eric Laurent { // STRATEGY_ENFORCED_AUDIBLE 2322c16ac09f510437e8340be691720177a490ae78f0Eric Laurent sDefaultVolumeCurve, // DEVICE_CATEGORY_HEADSET 2323c16ac09f510437e8340be691720177a490ae78f0Eric Laurent sSpeakerSonificationVolumeCurve, // DEVICE_CATEGORY_SPEAKER 2324c16ac09f510437e8340be691720177a490ae78f0Eric Laurent sDefaultVolumeCurve // DEVICE_CATEGORY_EARPIECE 2325c16ac09f510437e8340be691720177a490ae78f0Eric Laurent }, 2326e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent}; 2327e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent 2328e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurentvoid AudioPolicyManagerBase::initializeVolumeCurves() 2329e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent{ 2330e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) { 2331e43c5c4ca4477a6b384711552c3e990609039d93Eric Laurent for (int j = 0; j < DEVICE_CATEGORY_CNT; j++) { 2332cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent mStreams[i].mVolumeCurve[j] = 2333cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent sVolumeProfiles[getStrategy((AudioSystem::stream_type)i)][j]; 2334cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent } 2335cd057ad2774903c62f5c11bc71c4e7357aee71b8Eric Laurent } 2336f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2337f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2338c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentfloat AudioPolicyManagerBase::computeVolume(int stream, 2339c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int index, 2340c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent audio_io_handle_t output, 2341f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device) 2342f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2343f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin float volume = 1.0; 2344f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 2345f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin StreamDescriptor &streamDesc = mStreams[stream]; 2346f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2347f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (device == 0) { 2348f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin device = outputDesc->device(); 2349f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2350f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2351f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if volume is not 0 (not muted), force media volume to max on digital output 2352f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream == AudioSystem::MUSIC && 2353f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin index != mStreams[stream].mIndexMin && 2354f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent (device == AUDIO_DEVICE_OUT_AUX_DIGITAL || 2355f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent device == AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) { 2356f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return 1.0; 2357f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2358f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2359f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin volume = volIndexToAmpl(device, streamDesc, index); 2360f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2361f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if a headset is connected, apply the following rules to ring tones and notifications 2362f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // to avoid sound level bursts in user's ears: 2363f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // - always attenuate ring tones and notifications volume by 6dB 2364f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // - if music is playing, always limit the volume to current music volume, 2365f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // with a minimum threshold at -36dB so that notification is always perceived. 236612bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi const routing_strategy stream_strategy = getStrategy((AudioSystem::stream_type)stream); 236712bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi if ((device & (AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP | 236812bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | 236912bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi AudioSystem::DEVICE_OUT_WIRED_HEADSET | 237012bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi AudioSystem::DEVICE_OUT_WIRED_HEADPHONE)) && 237112bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi ((stream_strategy == STRATEGY_SONIFICATION) 237212bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL) 237312bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi || (stream == AudioSystem::SYSTEM)) && 2374f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin streamDesc.mCanBeMuted) { 2375f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin volume *= SONIFICATION_HEADSET_VOLUME_FACTOR; 2376f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // when the phone is ringing we must consider that music could have been paused just before 2377f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // by the music application and behave as if music was active if the last music track was 2378f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // just stopped 2379f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->mRefCount[AudioSystem::MUSIC] || mLimitRingtoneVolume) { 2380c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent float musicVol = computeVolume(AudioSystem::MUSIC, 2381f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mStreams[AudioSystem::MUSIC].getVolumeIndex(device), 2382c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent output, 2383f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent device); 2384c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent float minVol = (musicVol > SONIFICATION_HEADSET_VOLUME_MIN) ? 2385c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent musicVol : SONIFICATION_HEADSET_VOLUME_MIN; 2386f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (volume > minVol) { 2387f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin volume = minVol; 23886a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("computeVolume limiting volume to %f musicVol %f", minVol, musicVol); 2389f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2390f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2391f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2392f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2393f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return volume; 2394f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2395f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2396c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentstatus_t AudioPolicyManagerBase::checkAndSetVolume(int stream, 2397c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int index, 2398c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent audio_io_handle_t output, 2399f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device, 2400c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int delayMs, 2401c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent bool force) 2402f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2403f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2404f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // do not change actual stream volume if the stream is muted 2405f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) { 24065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("checkAndSetVolume() stream %d muted count %d", 24075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent stream, mOutputs.valueFor(output)->mMuteCount[stream]); 2408f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 2409f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2410f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2411f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // do not change in call volume if bluetooth is connected and vice versa 2412f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if ((stream == AudioSystem::VOICE_CALL && mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) || 2413f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (stream == AudioSystem::BLUETOOTH_SCO && mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO)) { 24146a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm", 2415f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream, mForceUse[AudioSystem::FOR_COMMUNICATION]); 2416f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return INVALID_OPERATION; 2417f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2418f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2419f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin float volume = computeVolume(stream, index, output, device); 2420f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // We actually change the volume if: 2421f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // - the float value returned by computeVolume() changed 2422f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // - the force flag is set 2423f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (volume != mOutputs.valueFor(output)->mCurVolume[stream] || 2424f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin force) { 2425f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutputs.valueFor(output)->mCurVolume[stream] = volume; 24265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("checkAndSetVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs); 2427f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream == AudioSystem::VOICE_CALL || 2428f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream == AudioSystem::DTMF || 2429f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream == AudioSystem::BLUETOOTH_SCO) { 2430f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // offset value to reflect actual hardware volume that never reaches 0 2431f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // 1% corresponds roughly to first step in VOICE_CALL stream volume setting (see AudioService.java) 2432f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin volume = 0.01 + 0.99 * volume; 2433f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is 2434f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // enabled 2435f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream == AudioSystem::BLUETOOTH_SCO) { 2436f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setStreamVolume(AudioSystem::VOICE_CALL, volume, output, delayMs); 2437f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2438f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2439f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2440f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs); 2441f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2442f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2443f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream == AudioSystem::VOICE_CALL || 2444f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream == AudioSystem::BLUETOOTH_SCO) { 2445f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin float voiceVolume; 2446f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // Force voice volume to max for bluetooth SCO as volume is managed by the headset 2447f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stream == AudioSystem::VOICE_CALL) { 2448f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin voiceVolume = (float)index/(float)mStreams[stream].mIndexMax; 2449f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 2450f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin voiceVolume = 1.0; 2451f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2452f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2453b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (voiceVolume != mLastVoiceVolume && output == mPrimaryOutput) { 2454f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->setVoiceVolume(voiceVolume, delayMs); 2455f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mLastVoiceVolume = voiceVolume; 2456f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2457f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2458f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2459f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 2460f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2461f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2462c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentvoid AudioPolicyManagerBase::applyStreamVolumes(audio_io_handle_t output, 2463f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device, 2464c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent int delayMs, 2465c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent bool force) 2466f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 24676a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("applyStreamVolumes() for output %d and device %x", output, device); 2468f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2469f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { 2470c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent checkAndSetVolume(stream, 2471f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mStreams[stream].getVolumeIndex(device), 2472c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent output, 2473c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device, 2474c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent delayMs, 2475c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent force); 2476f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2477f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2478f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2479f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::setStrategyMute(routing_strategy strategy, bool on, audio_io_handle_t output, int delayMs) 2480f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 24816a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setStrategyMute() strategy %d, mute %d, output %d", strategy, on, output); 2482f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { 2483f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (getStrategy((AudioSystem::stream_type)stream) == strategy) { 2484f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin setStreamMute(stream, on, output, delayMs); 2485f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2486f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2487f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2488f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2489f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::setStreamMute(int stream, bool on, audio_io_handle_t output, int delayMs) 2490f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2491f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin StreamDescriptor &streamDesc = mStreams[stream]; 2492f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 2493f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent audio_devices_t device = outputDesc->device(); 2494f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 24956a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("setStreamMute() stream %d, mute %d, output %d, mMuteCount %d", stream, on, output, outputDesc->mMuteCount[stream]); 2496f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2497f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (on) { 2498f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->mMuteCount[stream] == 0) { 2499f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (streamDesc.mCanBeMuted) { 2500c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent checkAndSetVolume(stream, 0, output, device, delayMs); 2501f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2502f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2503f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignored 2504f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin outputDesc->mMuteCount[stream]++; 2505f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 2506f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->mMuteCount[stream] == 0) { 250764cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("setStreamMute() unmuting non muted stream!"); 2508f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 2509f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2510f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (--outputDesc->mMuteCount[stream] == 0) { 2511c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent checkAndSetVolume(stream, 2512c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent streamDesc.getVolumeIndex((audio_devices_t)device), 2513c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent output, 2514c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device, 2515c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent delayMs); 2516f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2517f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2518f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2519f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2520f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting, bool stateChange) 2521f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2522f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if the stream pertains to sonification strategy and we are in call we must 2523f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // mute the stream if it is low visibility. If it is high visibility, we must play a tone 2524f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // in the device used for phone strategy and play the tone if the selected device does not 2525f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // interfere with the device used for phone strategy 2526f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as 2527f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // many times as there are active tracks on the output 252812bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi const routing_strategy stream_strategy = getStrategy((AudioSystem::stream_type)stream); 252912bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi if ((stream_strategy == STRATEGY_SONIFICATION) || 253012bd6e4a5c26bd8035bf804d0cc821bd9b8cce9bJean-Michel Trivi ((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) { 2531b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent AudioOutputDescriptor *outputDesc = mOutputs.valueFor(mPrimaryOutput); 25326a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d", 2533f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin stream, starting, outputDesc->mDevice, stateChange); 2534f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (outputDesc->mRefCount[stream]) { 2535f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin int muteCount = 1; 2536f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (stateChange) { 2537f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin muteCount = outputDesc->mRefCount[stream]; 2538f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2539f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (AudioSystem::isLowVisibility((AudioSystem::stream_type)stream)) { 25406a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount); 2541f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < muteCount; i++) { 2542b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setStreamMute(stream, starting, mPrimaryOutput); 2543f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2544f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 25456a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("handleIncallSonification() high visibility"); 25465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (outputDesc->device() & 25475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent getDeviceForStrategy(STRATEGY_PHONE, true /*fromCache*/)) { 25486a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount); 2549f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < muteCount; i++) { 2550b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent setStreamMute(stream, starting, mPrimaryOutput); 2551f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2552f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2553f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (starting) { 2554f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->startTone(ToneGenerator::TONE_SUP_CALL_WAITING, AudioSystem::VOICE_CALL); 2555f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 2556f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mpClientInterface->stopTone(); 2557f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2558f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2559f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2560f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2561f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2562f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2563f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinbool AudioPolicyManagerBase::isInCall() 2564f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2565f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return isStateInCall(mPhoneState); 2566f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2567f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2568f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinbool AudioPolicyManagerBase::isStateInCall(int state) { 2569f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return ((state == AudioSystem::MODE_IN_CALL) || 2570f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin (state == AudioSystem::MODE_IN_COMMUNICATION)); 2571f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2572f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2573f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinbool AudioPolicyManagerBase::needsDirectOuput(AudioSystem::stream_type stream, 2574f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t samplingRate, 2575f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t format, 2576f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t channels, 2577f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin AudioSystem::output_flags flags, 2578f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t device) 2579f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2580f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) || 2581b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent (format != 0 && !AudioSystem::isLinearPCM(format))); 2582f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2583f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2584f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinuint32_t AudioPolicyManagerBase::getMaxEffectsCpuLoad() 2585f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2586f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return MAX_EFFECTS_CPU_LOAD; 2587f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2588f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2589f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinuint32_t AudioPolicyManagerBase::getMaxEffectsMemory() 2590f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2591f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return MAX_EFFECTS_MEMORY; 2592f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2593f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2594f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// --- AudioOutputDescriptor class implementation 2595f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2596b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric LaurentAudioPolicyManagerBase::AudioOutputDescriptor::AudioOutputDescriptor( 25975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const IOProfile *profile) 2598f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin : mId(0), mSamplingRate(0), mFormat(0), mChannels(0), mLatency(0), 2599f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mFlags((AudioSystem::output_flags)0), mDevice((audio_devices_t)0), 2600f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mOutput1(0), mOutput2(0), mProfile(profile) 2601f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2602f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // clear usage count for all stream types 2603f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) { 2604f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mRefCount[i] = 0; 2605f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mCurVolume[i] = -1.0; 2606f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mMuteCount[i] = 0; 2607f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mStopTime[i] = 0; 2608f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2609f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2610f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2611f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentaudio_devices_t AudioPolicyManagerBase::AudioOutputDescriptor::device() 2612f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2613f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isDuplicated()) { 2614f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent return (audio_devices_t)(mOutput1->mDevice | mOutput2->mDevice); 2615f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } else { 2616f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent return mDevice; 2617f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2618f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2619f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 26205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentuint32_t AudioPolicyManagerBase::AudioOutputDescriptor::latency() 26215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 26225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (isDuplicated()) { 26235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return (mOutput1->mLatency > mOutput2->mLatency) ? mOutput1->mLatency : mOutput2->mLatency; 26245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else { 26255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return mLatency; 26265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 26275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 26285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 26295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentbool AudioPolicyManagerBase::AudioOutputDescriptor::sharesHwModuleWith( 26305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const AudioOutputDescriptor *outputDesc) 26315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 26325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (isDuplicated()) { 26335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return mOutput1->sharesHwModuleWith(outputDesc) || mOutput2->sharesHwModuleWith(outputDesc); 26345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (outputDesc->isDuplicated()){ 26355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return sharesHwModuleWith(outputDesc->mOutput1) || sharesHwModuleWith(outputDesc->mOutput2); 26365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else { 26375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return strcmp(mProfile->mModuleName, outputDesc->mProfile->mModuleName) == 0; 26385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 26395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 26405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 2641f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinvoid AudioPolicyManagerBase::AudioOutputDescriptor::changeRefCount(AudioSystem::stream_type stream, int delta) 2642f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2643f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin // forward usage count change to attached outputs 2644f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (isDuplicated()) { 2645f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutput1->changeRefCount(stream, delta); 2646f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mOutput2->changeRefCount(stream, delta); 2647f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2648f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if ((delta + (int)mRefCount[stream]) < 0) { 264964cca04dcbf4e21a51131224b9d0f0c596f876d4Steve Block ALOGW("changeRefCount() invalid delta %d for stream %d, refCount %d", delta, stream, mRefCount[stream]); 2650f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mRefCount[stream] = 0; 2651f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return; 2652f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2653f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin mRefCount[stream] += delta; 26546a70518b93928d1c91457ff805e375c82d76b0e5Steve Block ALOGV("changeRefCount() stream %d, count %d", stream, mRefCount[stream]); 2655f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2656f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2657f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinuint32_t AudioPolicyManagerBase::AudioOutputDescriptor::refCount() 2658f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2659f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t refcount = 0; 2660f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) { 2661f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin refcount += mRefCount[i]; 2662f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2663f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return refcount; 2664f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2665f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2666f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinuint32_t AudioPolicyManagerBase::AudioOutputDescriptor::strategyRefCount(routing_strategy strategy) 2667f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2668f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin uint32_t refCount = 0; 2669f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) { 2670f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin if (getStrategy((AudioSystem::stream_type)i) == strategy) { 2671f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin refCount += mRefCount[i]; 2672f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2673f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2674f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return refCount; 2675f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2676f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2677f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurentaudio_devices_t AudioPolicyManagerBase::AudioOutputDescriptor::supportedDevices() 2678b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent{ 2679b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent if (isDuplicated()) { 2680f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent return (audio_devices_t)(mOutput1->supportedDevices() | mOutput2->supportedDevices()); 2681b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } else { 2682b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent return mProfile->mSupportedDevices ; 2683b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent } 2684b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent} 2685b4696fc22ba822ed37bd2e3a19bc17514ccc79c8Eric Laurent 2686f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::AudioOutputDescriptor::dump(int fd) 2687f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2688f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const size_t SIZE = 256; 2689f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin char buffer[SIZE]; 2690f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 result; 2691f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2692f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Sampling rate: %d\n", mSamplingRate); 2693f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2694f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Format: %d\n", mFormat); 2695f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2696f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Channels: %08x\n", mChannels); 2697f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2698f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Latency: %d\n", mLatency); 2699f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2700f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Flags %08x\n", mFlags); 2701f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2702f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Devices %08x\n", device()); 2703f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2704f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Stream volume refCount muteCount\n"); 2705f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2706f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) { 2707f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " %02d %.03f %02d %02d\n", i, mCurVolume[i], mRefCount[i], mMuteCount[i]); 2708f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2709f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin } 2710f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, result.string(), result.size()); 2711f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2712f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 2713f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2714f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2715f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// --- AudioInputDescriptor class implementation 2716f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 27175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric LaurentAudioPolicyManagerBase::AudioInputDescriptor::AudioInputDescriptor(const IOProfile *profile) 2718f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin : mSamplingRate(0), mFormat(0), mChannels(0), 2719f9a4e2eccfbbe451512337af0806cfc54be0eaf9Eric Laurent mAcoustics((AudioSystem::audio_in_acoustics)0), mDevice((audio_devices_t)0), mRefCount(0), 27205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mInputSource(0), mProfile(profile) 2721f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2722f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2723f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2724f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::AudioInputDescriptor::dump(int fd) 2725f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2726f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const size_t SIZE = 256; 2727f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin char buffer[SIZE]; 2728f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 result; 2729f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2730f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Sampling rate: %d\n", mSamplingRate); 2731f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2732f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Format: %d\n", mFormat); 2733f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2734f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Channels: %08x\n", mChannels); 2735f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2736f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Acoustics %08x\n", mAcoustics); 2737f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2738f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Devices %08x\n", mDevice); 2739f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2740f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Ref Count %d\n", mRefCount); 2741f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2742f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, result.string(), result.size()); 2743f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2744f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 2745f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2746f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2747f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// --- StreamDescriptor class implementation 2748f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2749c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric LaurentAudioPolicyManagerBase::StreamDescriptor::StreamDescriptor() 2750c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent : mIndexMin(0), mIndexMax(1), mCanBeMuted(true) 2751c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent{ 2752c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mIndexCur.add(AUDIO_DEVICE_OUT_DEFAULT, 0); 2753c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent} 2754c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 2755c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentint AudioPolicyManagerBase::StreamDescriptor::getVolumeIndex(audio_devices_t device) 2756c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent{ 2757c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = AudioPolicyManagerBase::getDeviceForVolume(device); 2758c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent // there is always a valid entry for AUDIO_DEVICE_OUT_DEFAULT 2759c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent if (mIndexCur.indexOfKey(device) < 0) { 2760c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent device = AUDIO_DEVICE_OUT_DEFAULT; 2761c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 2762c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent return mIndexCur.valueFor(device); 2763c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent} 2764c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 2765c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurentvoid AudioPolicyManagerBase::StreamDescriptor::dump(int fd) 2766f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2767c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent const size_t SIZE = 256; 2768c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent char buffer[SIZE]; 2769c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent String8 result; 2770c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 2771c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent snprintf(buffer, SIZE, "%s %02d %02d ", 2772c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mCanBeMuted ? "true " : "false", mIndexMin, mIndexMax); 2773c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent result.append(buffer); 2774c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent for (size_t i = 0; i < mIndexCur.size(); i++) { 2775c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent snprintf(buffer, SIZE, "%04x : %02d, ", 2776c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mIndexCur.keyAt(i), 2777c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent mIndexCur.valueAt(i)); 2778c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent result.append(buffer); 2779c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent } 2780c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent result.append("\n"); 2781c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent 2782c6f331b3f48455c9a9cdf00fc82894badd0a7da6Eric Laurent write(fd, result.string(), result.size()); 2783f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2784f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2785f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin// --- EffectDescriptor class implementation 2786f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2787f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavinstatus_t AudioPolicyManagerBase::EffectDescriptor::dump(int fd) 2788f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin{ 2789f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin const size_t SIZE = 256; 2790f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin char buffer[SIZE]; 2791f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin String8 result; 2792f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 27931c65a49da0c89f75e528354ef02de5dc93a28232Eric Laurent snprintf(buffer, SIZE, " I/O: %d\n", mIo); 2794f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2795f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Strategy: %d\n", mStrategy); 2796f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2797f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Session: %d\n", mSession); 2798f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2799f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin snprintf(buffer, SIZE, " Name: %s\n", mDesc.name); 2800f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin result.append(buffer); 2801582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent snprintf(buffer, SIZE, " %s\n", mEnabled ? "Enabled" : "Disabled"); 2802582a15744be109fb630db7dbd1d1bdf22ff44f12Eric Laurent result.append(buffer); 2803f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin write(fd, result.string(), result.size()); 2804f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 2805f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin return NO_ERROR; 2806f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin} 2807f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 28085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// --- IOProfile class implementation 28095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric LaurentAudioPolicyManagerBase::IOProfile::IOProfile(const char *module) 28115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent : mFlags((audio_policy_output_flags_t)0), 28125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mModuleName(strndup(module, AUDIO_HARDWARE_MODULE_ID_MAX_LEN)) 28135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 28145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 28155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric LaurentAudioPolicyManagerBase::IOProfile::~IOProfile() 28175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 28185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent free(mModuleName); 28195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 28205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::IOProfile::dump(int fd) 28225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 28235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const size_t SIZE = 256; 28245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char buffer[SIZE]; 28255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent String8 result; 28265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - sampling rates: "); 28285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mSamplingRates.size(); i++) { 28305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "%d", mSamplingRates[i]); 28315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(i == (mSamplingRates.size() - 1) ? "\n" : ", "); 28335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 28345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - channel masks: "); 28365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mChannelMasks.size(); i++) { 28385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "%04x", mChannelMasks[i]); 28395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(i == (mChannelMasks.size() - 1) ? "\n" : ", "); 28415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 28425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - formats: "); 28445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < mFormats.size(); i++) { 28465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, "%d", mFormats[i]); 28475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(i == (mFormats.size() - 1) ? "\n" : ", "); 28495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 28505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - devices: %04x\n", mSupportedDevices); 28525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - flags: %04x\n", mFlags); 28545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent snprintf(buffer, SIZE, " - hw module: %s\n", mModuleName); 28565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent result.append(buffer); 28575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent write(fd, result.string(), result.size()); 28595ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 28605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent// --- audio_policy.conf file parsing 28625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentstruct StringToEnum { 28645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const char *name; 28655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t value; 28665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 28675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent#define STRING_TO_ENUM(string) { #string, string } 28695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 28705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentconst struct StringToEnum sDeviceNameToEnumTable[] = { 28725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_EARPIECE), 28735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_SPEAKER), 28745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_WIRED_HEADSET), 28755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_WIRED_HEADPHONE), 28765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_ALL_SCO), 28775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_ALL_A2DP), 28785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_AUX_DIGITAL), 28795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET), 28805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_BUILTIN_MIC), 28815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET), 28825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_WIRED_HEADSET), 28835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_AUX_DIGITAL), 28845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_VOICE_CALL), 28855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_DEVICE_IN_BACK_MIC), 28865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 28875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentconst struct StringToEnum sFlagNameToEnumTable[] = { 28895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_POLICY_OUTPUT_FLAG_DIRECT), 28905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_POLICY_OUTPUT_FLAG_PRIMARY), 28915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 28925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 28935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentconst struct StringToEnum sFormatNameToEnumTable[] = { 28945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_FORMAT_PCM_16_BIT), 28955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_FORMAT_PCM_8_BIT), 28965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_FORMAT_MP3), 28975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_FORMAT_AAC), 28985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_FORMAT_VORBIS), 28995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 29005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentconst struct StringToEnum sOutChannelsNameToEnumTable[] = { 29025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_OUT_MONO), 29035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO), 29045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1), 29055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1), 29065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 29075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentconst struct StringToEnum sInChannelsNameToEnumTable[] = { 29095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_IN_MONO), 29105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent STRING_TO_ENUM(AUDIO_CHANNEL_IN_STEREO), 29115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent}; 29125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentuint32_t AudioPolicyManagerBase::stringToEnum(const struct StringToEnum *table, 29155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent size_t size, 29165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const char *name) 29175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent for (size_t i = 0; i < size; i++) { 29195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strcmp(table[i].name, name) == 0) { 29205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("stringToEnum() found %s", table[i].name); 29215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return table[i].value; 29225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return 0; 29255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 29265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentaudio_policy_output_flags_t AudioPolicyManagerBase::parseFlagNames(char *name) 29285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t flag = 0; 29305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // it is OK to cast name to non const here as we are not going to use it after 29325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent // strtok() modifies it 29335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char *flagName = strtok(name, "|"); 29345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (flagName != NULL) { 29355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strlen(flagName) != 0) { 29365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent flag |= stringToEnum(sFlagNameToEnumTable, 29375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sFlagNameToEnumTable), 29385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent flagName); 29395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent flagName = strtok(NULL, "|"); 29415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return (audio_policy_output_flags_t)flag; 29435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 29445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentaudio_devices_t AudioPolicyManagerBase::parseDeviceNames(char *name) 29465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t device = 0; 29485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char *devName = strtok(name, "|"); 29505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (devName != NULL) { 29515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strlen(devName) != 0) { 29525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent device |= stringToEnum(sDeviceNameToEnumTable, 29535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sDeviceNameToEnumTable), 29545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent devName); 29555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent devName = strtok(NULL, "|"); 29575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return (audio_devices_t)device; 29595ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 29605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadSamplingRates(char *name, IOProfile *profile) 29625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char *str = strtok(name, "|"); 29645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (str != NULL) { 29665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent uint32_t rate = atoi(str); 29675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (rate != 0) { 29685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadSamplingRates() adding rate %d", rate); 29695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mSamplingRates.add(rate); 29705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str = strtok(NULL, "|"); 29725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 29745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 29755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadFormats(char *name, IOProfile *profile) 29775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char *str = strtok(name, "|"); 29795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (str != NULL) { 29815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_format_t format = (audio_format_t)stringToEnum(sFormatNameToEnumTable, 29825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sFormatNameToEnumTable), 29835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str); 29845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (format != 0) { 29855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mFormats.add(format); 29865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str = strtok(NULL, "|"); 29885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 29895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 29905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 29915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadInChannels(char *name, IOProfile *profile) 29935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 29945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const char *str = strtok(name, "|"); 29955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 29965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadInChannels() %s", name); 29975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (str != NULL) { 29985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_channel_mask_t channelMask = 29995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (audio_channel_mask_t)stringToEnum(sInChannelsNameToEnumTable, 30005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sInChannelsNameToEnumTable), 30015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str); 30025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (channelMask != 0) { 30035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadInChannels() adding channelMask %04x", channelMask); 30045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mChannelMasks.add(channelMask); 30055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str = strtok(NULL, "|"); 30075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 30095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 30105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadOutChannels(char *name, IOProfile *profile) 30125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 30135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent const char *str = strtok(name, "|"); 30145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent audio_channel_mask_t channelMask; 30155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (str != NULL) { 30175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent channelMask = stringToEnum(sOutChannelsNameToEnumTable, 30185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sOutChannelsNameToEnumTable), 30195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str); 30205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (channelMask != 0) { 30215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mChannelMasks.add(channelMask); 30225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent str = strtok(NULL, "|"); 30245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 30265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 30275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentstatus_t AudioPolicyManagerBase::loadInput(cnode *root, const char *module) 30295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 30305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *node = root->first_child; 30315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent IOProfile *profile = new IOProfile(module); 30335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 30355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strcmp(node->name, SAMPLING_RATES_TAG) == 0) { 30365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadSamplingRates((char *)node->value, profile); 30375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, FORMATS_TAG) == 0) { 30385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadFormats((char *)node->value, profile); 30395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, CHANNELS_TAG) == 0) { 30405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadInChannels((char *)node->value, profile); 30415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, DEVICES_TAG) == 0) { 30425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mSupportedDevices = parseDeviceNames((char *)node->value); 30435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 30455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mSupportedDevices == (audio_devices_t)0, 30475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadInput() invalid supported devices"); 30485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mChannelMasks.size() == 0, 30495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadInput() invalid supported channel masks"); 30505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mSamplingRates.size() == 0, 30515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadInput() invalid supported sampling rates"); 30525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mFormats.size() == 0, 30535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadInput() invalid supported formats"); 30545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((profile->mSupportedDevices != (audio_devices_t)0) && 30555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mChannelMasks.size() != 0) && 30565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mSamplingRates.size() != 0) && 30575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mFormats.size() != 0)) { 30585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30595ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadInput() adding input mSupportedDevices %04x", profile->mSupportedDevices); 30605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mInputProfiles.add(profile); 30625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return NO_ERROR; 30635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else { 30645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent delete profile; 30655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return BAD_VALUE; 30665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 30685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentstatus_t AudioPolicyManagerBase::loadOutput(cnode *root, const char *module) 30705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 30715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *node = root->first_child; 30725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent IOProfile *profile = new IOProfile(module); 30745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 30755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 30765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strcmp(node->name, SAMPLING_RATES_TAG) == 0) { 30775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadSamplingRates((char *)node->value, profile); 30785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, FORMATS_TAG) == 0) { 30795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadFormats((char *)node->value, profile); 30805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, CHANNELS_TAG) == 0) { 30815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadOutChannels((char *)node->value, profile); 30825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, DEVICES_TAG) == 0) { 30835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mSupportedDevices = parseDeviceNames((char *)node->value); 30845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(node->name, FLAGS_TAG) == 0) { 30855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mFlags = parseFlagNames((char *)node->value); 30865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 30885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 30895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mSupportedDevices == (audio_devices_t)0, 30905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadOutput() invalid supported devices"); 30915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mChannelMasks.size() == 0, 30925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadOutput() invalid supported channel masks"); 30935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mSamplingRates.size() == 0, 30945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadOutput() invalid supported sampling rates"); 30955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(profile->mFormats.size() == 0, 30965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent "loadOutput() invalid supported formats"); 30975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if ((profile->mSupportedDevices != (audio_devices_t)0) && 30985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mChannelMasks.size() != 0) && 30995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mSamplingRates.size() != 0) && 31005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (profile->mFormats.size() != 0)) { 31015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadOutput() adding output mSupportedDevices %04x, mFlags %04x", 31035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent profile->mSupportedDevices, profile->mFlags); 31045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mOutputProfiles.add(profile); 31065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return NO_ERROR; 31075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else { 31085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent delete profile; 31095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return BAD_VALUE; 31105ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31115ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 31125ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31135ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadHwModule(cnode *root) 31145ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 31155ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *node = config_find(root, OUTPUTS_TAG); 31165ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent status_t status = NAME_NOT_FOUND; 31175ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (node != NULL) { 31185ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strcmp(root->name, AUDIO_HARDWARE_MODULE_ID_A2DP) == 0) { 31195ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mHasA2dp = true; 31205ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31215ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->first_child; 31225ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 31235ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadHwModule() loading output %s", node->name); 31245ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent status_t tmpStatus = loadOutput(node, root->name); 31255ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (status == NAME_NOT_FOUND || status == NO_ERROR) { 31265ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent status = tmpStatus; 31275ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31285ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 31295ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31305ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31315ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = config_find(root, INPUTS_TAG); 31325ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (node != NULL) { 31335ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->first_child; 31345ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 31355ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadHwModule() loading input %s", node->name); 31365ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent status_t tmpStatus = loadInput(node, root->name); 31375ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (status == NAME_NOT_FOUND || status == NO_ERROR) { 31385ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent status = tmpStatus; 31395ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31405ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 31415ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31425ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31435ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (status == NO_ERROR) { 31445ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent //TODO: load HW module via audioflinger 31455ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31465ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 31475ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31485ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadHwModules(cnode *root) 31495ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 31505ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *node = config_find(root, AUDIO_HW_MODULE_TAG); 31515ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (node == NULL) { 31525ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 31535ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31545ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31555ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->first_child; 31565ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 31575ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadHwModules() loading module %s", node->name); 31585ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadHwModule(node); 31595ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 31605ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31615ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 31625ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31635ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentvoid AudioPolicyManagerBase::loadGlobalConfig(cnode *root) 31645ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 31655ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *node = config_find(root, GLOBAL_CONFIG_TAG); 31665ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (node == NULL) { 31675ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return; 31685ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31695ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->first_child; 31705ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent while (node) { 31715ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (strcmp(ATTACHED_OUTPUT_DEVICES_TAG, node->name) == 0) { 31725ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mAttachedOutputDevices = parseDeviceNames((char *)node->value); 31735ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(mAttachedOutputDevices == 0, "loadGlobalConfig() no attached output devices"); 31745ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadGlobalConfig() mAttachedOutputDevices %04x", mAttachedOutputDevices); 31755ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(DEFAULT_OUTPUT_DEVICE_TAG, node->name) == 0) { 31765ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mDefaultOutputDevice = (audio_devices_t)stringToEnum(sDeviceNameToEnumTable, 31775ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ARRAY_SIZE(sDeviceNameToEnumTable), 31785ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent (char *)node->value); 31795ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGW_IF(mDefaultOutputDevice == 0, "loadGlobalConfig() default device not specified"); 31805ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadGlobalConfig() mDefaultOutputDevice %04x", mDefaultOutputDevice); 31815ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } else if (strcmp(ATTACHED_INPUT_DEVICES_TAG, node->name) == 0) { 31825ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent mAvailableInputDevices = parseDeviceNames((char *)node->value); 31835ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent ALOGV("loadGlobalConfig() mAvailableInputDevices %04x", mAvailableInputDevices); 31845ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31855ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent node = node->next; 31865ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31875ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 31885ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31895ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurentstatus_t AudioPolicyManagerBase::loadAudioPolicyConfig(const char *path) 31905ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent{ 31915ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent cnode *root; 31925ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent char *data; 31935ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 31945ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent data = (char *)load_file(path, NULL); 31955ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent if (data == NULL) { 31965ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return -ENODEV; 31975ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent } 31985ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent root = config_node("", ""); 31995ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent config_load(root, data); 32005ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 32015ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadGlobalConfig(root); 32025ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent loadHwModules(root); 32035ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 32045ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent config_free(root); 32055ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent free(root); 32065ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent free(data); 32075ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent 32085ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent return NO_ERROR; 32095ccdf14a85ed66ac54036fb393acc06ea7acfed6Eric Laurent} 3210f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 3211f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin 3212f01215993dda68b6b52111d754bd0c7c2d5bcfa3Dima Zavin}; // namespace android 3213