AudioPolicyManager.h revision 1e693b55d888b9d3e0a2ce770ae2b72b59c1a317
1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 18#include <stdint.h> 19#include <sys/types.h> 20#include <cutils/config_utils.h> 21#include <cutils/misc.h> 22#include <utils/Timers.h> 23#include <utils/Errors.h> 24#include <utils/KeyedVector.h> 25#include <utils/SortedVector.h> 26#include "AudioPolicyInterface.h" 27 28 29namespace android { 30 31// ---------------------------------------------------------------------------- 32 33// Attenuation applied to STRATEGY_SONIFICATION streams when a headset is connected: 6dB 34#define SONIFICATION_HEADSET_VOLUME_FACTOR 0.5 35// Min volume for STRATEGY_SONIFICATION streams when limited by music volume: -36dB 36#define SONIFICATION_HEADSET_VOLUME_MIN 0.016 37// Time in milliseconds during which we consider that music is still active after a music 38// track was stopped - see computeVolume() 39#define SONIFICATION_HEADSET_MUSIC_DELAY 5000 40// Time in milliseconds after media stopped playing during which we consider that the 41// sonification should be as unobtrusive as during the time media was playing. 42#define SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY 5000 43// Time in milliseconds during witch some streams are muted while the audio path 44// is switched 45#define MUTE_TIME_MS 2000 46 47#define NUM_TEST_OUTPUTS 5 48 49#define NUM_VOL_CURVE_KNEES 2 50 51// Default minimum length allowed for offloading a compressed track 52// Can be overridden by the audio.offload.min.duration.secs property 53#define OFFLOAD_DEFAULT_MIN_DURATION_SECS 60 54 55#define MAX_MIXER_SAMPLING_RATE 48000 56#define MAX_MIXER_CHANNEL_COUNT 2 57// See AudioPort::compareFormats() 58#define WORST_MIXER_FORMAT AUDIO_FORMAT_PCM_16_BIT 59#define BEST_MIXER_FORMAT AUDIO_FORMAT_PCM_24_BIT_PACKED 60 61// ---------------------------------------------------------------------------- 62// AudioPolicyManager implements audio policy manager behavior common to all platforms. 63// ---------------------------------------------------------------------------- 64 65class AudioPolicyManager: public AudioPolicyInterface 66#ifdef AUDIO_POLICY_TEST 67 , public Thread 68#endif //AUDIO_POLICY_TEST 69{ 70 71public: 72 AudioPolicyManager(AudioPolicyClientInterface *clientInterface); 73 virtual ~AudioPolicyManager(); 74 75 // AudioPolicyInterface 76 virtual status_t setDeviceConnectionState(audio_devices_t device, 77 audio_policy_dev_state_t state, 78 const char *device_address); 79 virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, 80 const char *device_address); 81 virtual void setPhoneState(audio_mode_t state); 82 virtual void setForceUse(audio_policy_force_use_t usage, 83 audio_policy_forced_cfg_t config); 84 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 85 virtual void setSystemProperty(const char* property, const char* value); 86 virtual status_t initCheck(); 87 virtual audio_io_handle_t getOutput(audio_stream_type_t stream, 88 uint32_t samplingRate, 89 audio_format_t format, 90 audio_channel_mask_t channelMask, 91 audio_output_flags_t flags, 92 const audio_offload_info_t *offloadInfo); 93 virtual audio_io_handle_t getOutputForAttr(const audio_attributes_t *attr, 94 uint32_t samplingRate, 95 audio_format_t format, 96 audio_channel_mask_t channelMask, 97 audio_output_flags_t flags, 98 const audio_offload_info_t *offloadInfo); 99 virtual status_t startOutput(audio_io_handle_t output, 100 audio_stream_type_t stream, 101 int session = 0); 102 virtual status_t stopOutput(audio_io_handle_t output, 103 audio_stream_type_t stream, 104 int session = 0); 105 virtual void releaseOutput(audio_io_handle_t output); 106 virtual audio_io_handle_t getInput(audio_source_t inputSource, 107 uint32_t samplingRate, 108 audio_format_t format, 109 audio_channel_mask_t channelMask, 110 audio_in_acoustics_t acoustics); 111 112 // indicates to the audio policy manager that the input starts being used. 113 virtual status_t startInput(audio_io_handle_t input); 114 115 // indicates to the audio policy manager that the input stops being used. 116 virtual status_t stopInput(audio_io_handle_t input); 117 virtual void releaseInput(audio_io_handle_t input); 118 virtual void closeAllInputs(); 119 virtual void initStreamVolume(audio_stream_type_t stream, 120 int indexMin, 121 int indexMax); 122 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 123 int index, 124 audio_devices_t device); 125 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 126 int *index, 127 audio_devices_t device); 128 129 // return the strategy corresponding to a given stream type 130 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 131 // return the strategy corresponding to the given audio attributes 132 virtual uint32_t getStrategyForAttr(const audio_attributes_t *attr); 133 134 // return the enabled output devices for the given stream type 135 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream); 136 137 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL); 138 virtual status_t registerEffect(const effect_descriptor_t *desc, 139 audio_io_handle_t io, 140 uint32_t strategy, 141 int session, 142 int id); 143 virtual status_t unregisterEffect(int id); 144 virtual status_t setEffectEnabled(int id, bool enabled); 145 146 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 147 // return whether a stream is playing remotely, override to change the definition of 148 // local/remote playback, used for instance by notification manager to not make 149 // media players lose audio focus when not playing locally 150 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 151 virtual bool isSourceActive(audio_source_t source) const; 152 153 virtual status_t dump(int fd); 154 155 virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo); 156 157 virtual status_t listAudioPorts(audio_port_role_t role, 158 audio_port_type_t type, 159 unsigned int *num_ports, 160 struct audio_port *ports, 161 unsigned int *generation); 162 virtual status_t getAudioPort(struct audio_port *port); 163 virtual status_t createAudioPatch(const struct audio_patch *patch, 164 audio_patch_handle_t *handle, 165 uid_t uid); 166 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 167 uid_t uid); 168 virtual status_t listAudioPatches(unsigned int *num_patches, 169 struct audio_patch *patches, 170 unsigned int *generation); 171 virtual status_t setAudioPortConfig(const struct audio_port_config *config); 172 virtual void clearAudioPatches(uid_t uid); 173 174protected: 175 176 enum routing_strategy { 177 STRATEGY_MEDIA, 178 STRATEGY_PHONE, 179 STRATEGY_SONIFICATION, 180 STRATEGY_SONIFICATION_RESPECTFUL, 181 STRATEGY_DTMF, 182 STRATEGY_ENFORCED_AUDIBLE, 183 NUM_STRATEGIES 184 }; 185 186 // 4 points to define the volume attenuation curve, each characterized by the volume 187 // index (from 0 to 100) at which they apply, and the attenuation in dB at that index. 188 // we use 100 steps to avoid rounding errors when computing the volume in volIndexToAmpl() 189 190 enum { VOLMIN = 0, VOLKNEE1 = 1, VOLKNEE2 = 2, VOLMAX = 3, VOLCNT = 4}; 191 192 class VolumeCurvePoint 193 { 194 public: 195 int mIndex; 196 float mDBAttenuation; 197 }; 198 199 // device categories used for volume curve management. 200 enum device_category { 201 DEVICE_CATEGORY_HEADSET, 202 DEVICE_CATEGORY_SPEAKER, 203 DEVICE_CATEGORY_EARPIECE, 204 DEVICE_CATEGORY_CNT 205 }; 206 207 class HwModule; 208 209 class AudioGain: public RefBase 210 { 211 public: 212 AudioGain(int index, bool useInChannelMask); 213 virtual ~AudioGain() {} 214 215 void dump(int fd, int spaces, int index) const; 216 217 void getDefaultConfig(struct audio_gain_config *config); 218 status_t checkConfig(const struct audio_gain_config *config); 219 int mIndex; 220 struct audio_gain mGain; 221 bool mUseInChannelMask; 222 }; 223 224 class AudioPort: public virtual RefBase 225 { 226 public: 227 AudioPort(const String8& name, audio_port_type_t type, 228 audio_port_role_t role, const sp<HwModule>& module); 229 virtual ~AudioPort() {} 230 231 virtual void toAudioPort(struct audio_port *port) const; 232 233 void loadSamplingRates(char *name); 234 void loadFormats(char *name); 235 void loadOutChannels(char *name); 236 void loadInChannels(char *name); 237 238 audio_gain_mode_t loadGainMode(char *name); 239 void loadGain(cnode *root, int index); 240 void loadGains(cnode *root); 241 242 status_t checkSamplingRate(uint32_t samplingRate) const; 243 status_t checkChannelMask(audio_channel_mask_t channelMask) const; 244 status_t checkFormat(audio_format_t format) const; 245 status_t checkGain(const struct audio_gain_config *gainConfig, int index) const; 246 247 uint32_t pickSamplingRate() const; 248 audio_channel_mask_t pickChannelMask() const; 249 audio_format_t pickFormat() const; 250 251 static const audio_format_t sPcmFormatCompareTable[]; 252 static int compareFormats(audio_format_t format1, audio_format_t format2); 253 254 void dump(int fd, int spaces) const; 255 256 String8 mName; 257 audio_port_type_t mType; 258 audio_port_role_t mRole; 259 bool mUseInChannelMask; 260 // by convention, "0' in the first entry in mSamplingRates, mChannelMasks or mFormats 261 // indicates the supported parameters should be read from the output stream 262 // after it is opened for the first time 263 Vector <uint32_t> mSamplingRates; // supported sampling rates 264 Vector <audio_channel_mask_t> mChannelMasks; // supported channel masks 265 Vector <audio_format_t> mFormats; // supported audio formats 266 Vector < sp<AudioGain> > mGains; // gain controllers 267 sp<HwModule> mModule; // audio HW module exposing this I/O stream 268 audio_output_flags_t mFlags; // attribute flags (e.g primary output, 269 // direct output...). For outputs only. 270 }; 271 272 class AudioPortConfig: public virtual RefBase 273 { 274 public: 275 AudioPortConfig(); 276 virtual ~AudioPortConfig() {} 277 278 status_t applyAudioPortConfig(const struct audio_port_config *config, 279 struct audio_port_config *backupConfig = NULL); 280 virtual void toAudioPortConfig(struct audio_port_config *dstConfig, 281 const struct audio_port_config *srcConfig = NULL) const = 0; 282 sp<AudioPort> mAudioPort; 283 uint32_t mSamplingRate; 284 audio_format_t mFormat; 285 audio_channel_mask_t mChannelMask; 286 struct audio_gain_config mGain; 287 }; 288 289 290 class AudioPatch: public RefBase 291 { 292 public: 293 AudioPatch(audio_patch_handle_t handle, 294 const struct audio_patch *patch, uid_t uid) : 295 mHandle(handle), mPatch(*patch), mUid(uid), mAfPatchHandle(0) {} 296 297 audio_patch_handle_t mHandle; 298 struct audio_patch mPatch; 299 uid_t mUid; 300 audio_patch_handle_t mAfPatchHandle; 301 }; 302 303 class DeviceDescriptor: public AudioPort, public AudioPortConfig 304 { 305 public: 306 DeviceDescriptor(const String8& name, audio_devices_t type); 307 308 virtual ~DeviceDescriptor() {} 309 310 bool equals(const sp<DeviceDescriptor>& other) const; 311 virtual void toAudioPortConfig(struct audio_port_config *dstConfig, 312 const struct audio_port_config *srcConfig = NULL) const; 313 314 virtual void toAudioPort(struct audio_port *port) const; 315 316 status_t dump(int fd, int spaces, int index) const; 317 318 audio_devices_t mDeviceType; 319 String8 mAddress; 320 audio_port_handle_t mId; 321 }; 322 323 class DeviceVector : public SortedVector< sp<DeviceDescriptor> > 324 { 325 public: 326 DeviceVector() : SortedVector(), mDeviceTypes(AUDIO_DEVICE_NONE) {} 327 328 ssize_t add(const sp<DeviceDescriptor>& item); 329 ssize_t remove(const sp<DeviceDescriptor>& item); 330 ssize_t indexOf(const sp<DeviceDescriptor>& item) const; 331 332 audio_devices_t types() const { return mDeviceTypes; } 333 334 void loadDevicesFromType(audio_devices_t types); 335 void loadDevicesFromName(char *name, const DeviceVector& declaredDevices); 336 337 sp<DeviceDescriptor> getDevice(audio_devices_t type, String8 address) const; 338 DeviceVector getDevicesFromType(audio_devices_t types) const; 339 sp<DeviceDescriptor> getDeviceFromId(audio_port_handle_t id) const; 340 sp<DeviceDescriptor> getDeviceFromName(const String8& name) const; 341 342 private: 343 void refreshTypes(); 344 audio_devices_t mDeviceTypes; 345 }; 346 347 // the IOProfile class describes the capabilities of an output or input stream. 348 // It is currently assumed that all combination of listed parameters are supported. 349 // It is used by the policy manager to determine if an output or input is suitable for 350 // a given use case, open/close it accordingly and connect/disconnect audio tracks 351 // to/from it. 352 class IOProfile : public AudioPort 353 { 354 public: 355 IOProfile(const String8& name, audio_port_role_t role, const sp<HwModule>& module); 356 virtual ~IOProfile(); 357 358 bool isCompatibleProfile(audio_devices_t device, 359 uint32_t samplingRate, 360 audio_format_t format, 361 audio_channel_mask_t channelMask, 362 audio_output_flags_t flags) const; 363 364 void dump(int fd); 365 void log(); 366 367 DeviceVector mSupportedDevices; // supported devices 368 // (devices this output can be routed to) 369 }; 370 371 class HwModule : public RefBase 372 { 373 public: 374 HwModule(const char *name); 375 ~HwModule(); 376 377 status_t loadOutput(cnode *root); 378 status_t loadInput(cnode *root); 379 status_t loadDevice(cnode *root); 380 381 void dump(int fd); 382 383 const char *const mName; // base name of the audio HW module (primary, a2dp ...) 384 uint32_t mHalVersion; // audio HAL API version 385 audio_module_handle_t mHandle; 386 Vector < sp<IOProfile> > mOutputProfiles; // output profiles exposed by this module 387 Vector < sp<IOProfile> > mInputProfiles; // input profiles exposed by this module 388 DeviceVector mDeclaredDevices; // devices declared in audio_policy.conf 389 390 }; 391 392 // default volume curve 393 static const VolumeCurvePoint sDefaultVolumeCurve[AudioPolicyManager::VOLCNT]; 394 // default volume curve for media strategy 395 static const VolumeCurvePoint sDefaultMediaVolumeCurve[AudioPolicyManager::VOLCNT]; 396 // volume curve for media strategy on speakers 397 static const VolumeCurvePoint sSpeakerMediaVolumeCurve[AudioPolicyManager::VOLCNT]; 398 static const VolumeCurvePoint sSpeakerMediaVolumeCurveDrc[AudioPolicyManager::VOLCNT]; 399 // volume curve for sonification strategy on speakers 400 static const VolumeCurvePoint sSpeakerSonificationVolumeCurve[AudioPolicyManager::VOLCNT]; 401 static const VolumeCurvePoint sSpeakerSonificationVolumeCurveDrc[AudioPolicyManager::VOLCNT]; 402 static const VolumeCurvePoint sDefaultSystemVolumeCurve[AudioPolicyManager::VOLCNT]; 403 static const VolumeCurvePoint sDefaultSystemVolumeCurveDrc[AudioPolicyManager::VOLCNT]; 404 static const VolumeCurvePoint sHeadsetSystemVolumeCurve[AudioPolicyManager::VOLCNT]; 405 static const VolumeCurvePoint sDefaultVoiceVolumeCurve[AudioPolicyManager::VOLCNT]; 406 static const VolumeCurvePoint sSpeakerVoiceVolumeCurve[AudioPolicyManager::VOLCNT]; 407 // default volume curves per stream and device category. See initializeVolumeCurves() 408 static const VolumeCurvePoint *sVolumeProfiles[AUDIO_STREAM_CNT][DEVICE_CATEGORY_CNT]; 409 410 // descriptor for audio outputs. Used to maintain current configuration of each opened audio output 411 // and keep track of the usage of this output by each audio stream type. 412 class AudioOutputDescriptor: public AudioPortConfig 413 { 414 public: 415 AudioOutputDescriptor(const sp<IOProfile>& profile); 416 417 status_t dump(int fd); 418 419 audio_devices_t device() const; 420 void changeRefCount(audio_stream_type_t stream, int delta); 421 422 bool isDuplicated() const { return (mOutput1 != NULL && mOutput2 != NULL); } 423 audio_devices_t supportedDevices(); 424 uint32_t latency(); 425 bool sharesHwModuleWith(const sp<AudioOutputDescriptor> outputDesc); 426 bool isActive(uint32_t inPastMs = 0) const; 427 bool isStreamActive(audio_stream_type_t stream, 428 uint32_t inPastMs = 0, 429 nsecs_t sysTime = 0) const; 430 bool isStrategyActive(routing_strategy strategy, 431 uint32_t inPastMs = 0, 432 nsecs_t sysTime = 0) const; 433 434 virtual void toAudioPortConfig(struct audio_port_config *dstConfig, 435 const struct audio_port_config *srcConfig = NULL) const; 436 void toAudioPort(struct audio_port *port) const; 437 438 audio_port_handle_t mId; 439 audio_io_handle_t mIoHandle; // output handle 440 uint32_t mLatency; // 441 audio_output_flags_t mFlags; // 442 audio_devices_t mDevice; // current device this output is routed to 443 audio_patch_handle_t mPatchHandle; 444 uint32_t mRefCount[AUDIO_STREAM_CNT]; // number of streams of each type using this output 445 nsecs_t mStopTime[AUDIO_STREAM_CNT]; 446 sp<AudioOutputDescriptor> mOutput1; // used by duplicated outputs: first output 447 sp<AudioOutputDescriptor> mOutput2; // used by duplicated outputs: second output 448 float mCurVolume[AUDIO_STREAM_CNT]; // current stream volume 449 int mMuteCount[AUDIO_STREAM_CNT]; // mute request counter 450 const sp<IOProfile> mProfile; // I/O profile this output derives from 451 bool mStrategyMutedByDevice[NUM_STRATEGIES]; // strategies muted because of incompatible 452 // device selection. See checkDeviceMuteStrategies() 453 uint32_t mDirectOpenCount; // number of clients using this output (direct outputs only) 454 }; 455 456 // descriptor for audio inputs. Used to maintain current configuration of each opened audio input 457 // and keep track of the usage of this input. 458 class AudioInputDescriptor: public AudioPortConfig 459 { 460 public: 461 AudioInputDescriptor(const sp<IOProfile>& profile); 462 463 status_t dump(int fd); 464 465 audio_port_handle_t mId; 466 audio_io_handle_t mIoHandle; // input handle 467 audio_devices_t mDevice; // current device this input is routed to 468 audio_patch_handle_t mPatchHandle; 469 uint32_t mRefCount; // number of AudioRecord clients using this output 470 audio_source_t mInputSource; // input source selected by application (mediarecorder.h) 471 const sp<IOProfile> mProfile; // I/O profile this output derives from 472 473 virtual void toAudioPortConfig(struct audio_port_config *dstConfig, 474 const struct audio_port_config *srcConfig = NULL) const; 475 void toAudioPort(struct audio_port *port) const; 476 }; 477 478 // stream descriptor used for volume control 479 class StreamDescriptor 480 { 481 public: 482 StreamDescriptor(); 483 484 int getVolumeIndex(audio_devices_t device); 485 void dump(int fd); 486 487 int mIndexMin; // min volume index 488 int mIndexMax; // max volume index 489 KeyedVector<audio_devices_t, int> mIndexCur; // current volume index per device 490 bool mCanBeMuted; // true is the stream can be muted 491 492 const VolumeCurvePoint *mVolumeCurve[DEVICE_CATEGORY_CNT]; 493 }; 494 495 // stream descriptor used for volume control 496 class EffectDescriptor : public RefBase 497 { 498 public: 499 500 status_t dump(int fd); 501 502 int mIo; // io the effect is attached to 503 routing_strategy mStrategy; // routing strategy the effect is associated to 504 int mSession; // audio session the effect is on 505 effect_descriptor_t mDesc; // effect descriptor 506 bool mEnabled; // enabled state: CPU load being used or not 507 }; 508 509 void addOutput(audio_io_handle_t output, sp<AudioOutputDescriptor> outputDesc); 510 void addInput(audio_io_handle_t input, sp<AudioInputDescriptor> inputDesc); 511 512 // return the strategy corresponding to a given stream type 513 static routing_strategy getStrategy(audio_stream_type_t stream); 514 515 // return appropriate device for streams handled by the specified strategy according to current 516 // phone state, connected devices... 517 // if fromCache is true, the device is returned from mDeviceForStrategy[], 518 // otherwise it is determine by current state 519 // (device connected,phone state, force use, a2dp output...) 520 // This allows to: 521 // 1 speed up process when the state is stable (when starting or stopping an output) 522 // 2 access to either current device selection (fromCache == true) or 523 // "future" device selection (fromCache == false) when called from a context 524 // where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND 525 // before updateDevicesAndOutputs() is called. 526 virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy, 527 bool fromCache); 528 529 // change the route of the specified output. Returns the number of ms we have slept to 530 // allow new routing to take effect in certain cases. 531 uint32_t setOutputDevice(audio_io_handle_t output, 532 audio_devices_t device, 533 bool force = false, 534 int delayMs = 0, 535 audio_patch_handle_t *patchHandle = NULL); 536 status_t resetOutputDevice(audio_io_handle_t output, 537 int delayMs = 0, 538 audio_patch_handle_t *patchHandle = NULL); 539 status_t setInputDevice(audio_io_handle_t input, 540 audio_devices_t device, 541 bool force = false, 542 audio_patch_handle_t *patchHandle = NULL); 543 status_t resetInputDevice(audio_io_handle_t input, 544 audio_patch_handle_t *patchHandle = NULL); 545 546 // select input device corresponding to requested audio source 547 virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource); 548 549 // return io handle of active input or 0 if no input is active 550 // Only considers inputs from physical devices (e.g. main mic, headset mic) when 551 // ignoreVirtualInputs is true. 552 audio_io_handle_t getActiveInput(bool ignoreVirtualInputs = true); 553 554 // initialize volume curves for each strategy and device category 555 void initializeVolumeCurves(); 556 557 // compute the actual volume for a given stream according to the requested index and a particular 558 // device 559 virtual float computeVolume(audio_stream_type_t stream, int index, 560 audio_io_handle_t output, audio_devices_t device); 561 562 // check that volume change is permitted, compute and send new volume to audio hardware 563 status_t checkAndSetVolume(audio_stream_type_t stream, int index, audio_io_handle_t output, 564 audio_devices_t device, int delayMs = 0, bool force = false); 565 566 // apply all stream volumes to the specified output and device 567 void applyStreamVolumes(audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false); 568 569 // Mute or unmute all streams handled by the specified strategy on the specified output 570 void setStrategyMute(routing_strategy strategy, 571 bool on, 572 audio_io_handle_t output, 573 int delayMs = 0, 574 audio_devices_t device = (audio_devices_t)0); 575 576 // Mute or unmute the stream on the specified output 577 void setStreamMute(audio_stream_type_t stream, 578 bool on, 579 audio_io_handle_t output, 580 int delayMs = 0, 581 audio_devices_t device = (audio_devices_t)0); 582 583 // handle special cases for sonification strategy while in call: mute streams or replace by 584 // a special tone in the device used for communication 585 void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange); 586 587 // true if device is in a telephony or VoIP call 588 virtual bool isInCall(); 589 590 // true if given state represents a device in a telephony or VoIP call 591 virtual bool isStateInCall(int state); 592 593 // when a device is connected, checks if an open output can be routed 594 // to this device. If none is open, tries to open one of the available outputs. 595 // Returns an output suitable to this device or 0. 596 // when a device is disconnected, checks if an output is not used any more and 597 // returns its handle if any. 598 // transfers the audio tracks and effects from one output thread to another accordingly. 599 status_t checkOutputsForDevice(audio_devices_t device, 600 audio_policy_dev_state_t state, 601 SortedVector<audio_io_handle_t>& outputs, 602 const String8 address); 603 604 status_t checkInputsForDevice(audio_devices_t device, 605 audio_policy_dev_state_t state, 606 SortedVector<audio_io_handle_t>& inputs, 607 const String8 address); 608 609 // close an output and its companion duplicating output. 610 void closeOutput(audio_io_handle_t output); 611 612 // checks and if necessary changes outputs used for all strategies. 613 // must be called every time a condition that affects the output choice for a given strategy 614 // changes: connected device, phone state, force use... 615 // Must be called before updateDevicesAndOutputs() 616 void checkOutputForStrategy(routing_strategy strategy); 617 618 // Same as checkOutputForStrategy() but for a all strategies in order of priority 619 void checkOutputForAllStrategies(); 620 621 // manages A2DP output suspend/restore according to phone state and BT SCO usage 622 void checkA2dpSuspend(); 623 624 // returns the A2DP output handle if it is open or 0 otherwise 625 audio_io_handle_t getA2dpOutput(); 626 627 // selects the most appropriate device on output for current state 628 // must be called every time a condition that affects the device choice for a given output is 629 // changed: connected device, phone state, force use, output start, output stop.. 630 // see getDeviceForStrategy() for the use of fromCache parameter 631 audio_devices_t getNewOutputDevice(audio_io_handle_t output, bool fromCache); 632 633 // updates cache of device used by all strategies (mDeviceForStrategy[]) 634 // must be called every time a condition that affects the device choice for a given strategy is 635 // changed: connected device, phone state, force use... 636 // cached values are used by getDeviceForStrategy() if parameter fromCache is true. 637 // Must be called after checkOutputForAllStrategies() 638 void updateDevicesAndOutputs(); 639 640 // selects the most appropriate device on input for current state 641 audio_devices_t getNewInputDevice(audio_io_handle_t input); 642 643 virtual uint32_t getMaxEffectsCpuLoad(); 644 virtual uint32_t getMaxEffectsMemory(); 645#ifdef AUDIO_POLICY_TEST 646 virtual bool threadLoop(); 647 void exit(); 648 int testOutputIndex(audio_io_handle_t output); 649#endif //AUDIO_POLICY_TEST 650 651 status_t setEffectEnabled(const sp<EffectDescriptor>& effectDesc, bool enabled); 652 653 // returns the category the device belongs to with regard to volume curve management 654 static device_category getDeviceCategory(audio_devices_t device); 655 656 // extract one device relevant for volume control from multiple device selection 657 static audio_devices_t getDeviceForVolume(audio_devices_t device); 658 659 SortedVector<audio_io_handle_t> getOutputsForDevice(audio_devices_t device, 660 DefaultKeyedVector<audio_io_handle_t, sp<AudioOutputDescriptor> > openOutputs); 661 bool vectorsEqual(SortedVector<audio_io_handle_t>& outputs1, 662 SortedVector<audio_io_handle_t>& outputs2); 663 664 // mute/unmute strategies using an incompatible device combination 665 // if muting, wait for the audio in pcm buffer to be drained before proceeding 666 // if unmuting, unmute only after the specified delay 667 // Returns the number of ms waited 668 uint32_t checkDeviceMuteStrategies(sp<AudioOutputDescriptor> outputDesc, 669 audio_devices_t prevDevice, 670 uint32_t delayMs); 671 672 audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs, 673 audio_output_flags_t flags); 674 sp<IOProfile> getInputProfile(audio_devices_t device, 675 uint32_t samplingRate, 676 audio_format_t format, 677 audio_channel_mask_t channelMask); 678 sp<IOProfile> getProfileForDirectOutput(audio_devices_t device, 679 uint32_t samplingRate, 680 audio_format_t format, 681 audio_channel_mask_t channelMask, 682 audio_output_flags_t flags); 683 684 audio_io_handle_t selectOutputForEffects(const SortedVector<audio_io_handle_t>& outputs); 685 686 bool isNonOffloadableEffectEnabled(); 687 688 status_t addAudioPatch(audio_patch_handle_t handle, 689 const sp<AudioPatch>& patch); 690 status_t removeAudioPatch(audio_patch_handle_t handle); 691 692 sp<AudioOutputDescriptor> getOutputFromId(audio_port_handle_t id) const; 693 sp<AudioInputDescriptor> getInputFromId(audio_port_handle_t id) const; 694 sp<HwModule> getModuleForDevice(audio_devices_t device) const; 695 sp<HwModule> getModuleFromName(const char *name) const; 696 // 697 // Audio policy configuration file parsing (audio_policy.conf) 698 // 699 static uint32_t stringToEnum(const struct StringToEnum *table, 700 size_t size, 701 const char *name); 702 static const char *enumToString(const struct StringToEnum *table, 703 size_t size, 704 uint32_t value); 705 static bool stringToBool(const char *value); 706 static audio_output_flags_t parseFlagNames(char *name); 707 static audio_devices_t parseDeviceNames(char *name); 708 void loadHwModule(cnode *root); 709 void loadHwModules(cnode *root); 710 void loadGlobalConfig(cnode *root, const sp<HwModule>& module); 711 status_t loadAudioPolicyConfig(const char *path); 712 void defaultAudioPolicyConfig(void); 713 714 715 uid_t mUidCached; 716 AudioPolicyClientInterface *mpClientInterface; // audio policy client interface 717 audio_io_handle_t mPrimaryOutput; // primary output handle 718 // list of descriptors for outputs currently opened 719 DefaultKeyedVector<audio_io_handle_t, sp<AudioOutputDescriptor> > mOutputs; 720 // copy of mOutputs before setDeviceConnectionState() opens new outputs 721 // reset to mOutputs when updateDevicesAndOutputs() is called. 722 DefaultKeyedVector<audio_io_handle_t, sp<AudioOutputDescriptor> > mPreviousOutputs; 723 DefaultKeyedVector<audio_io_handle_t, sp<AudioInputDescriptor> > mInputs; // list of input descriptors 724 DeviceVector mAvailableOutputDevices; // all available output devices 725 DeviceVector mAvailableInputDevices; // all available input devices 726 int mPhoneState; // current phone state 727 audio_policy_forced_cfg_t mForceUse[AUDIO_POLICY_FORCE_USE_CNT]; // current forced use configuration 728 729 StreamDescriptor mStreams[AUDIO_STREAM_CNT]; // stream descriptors for volume control 730 bool mLimitRingtoneVolume; // limit ringtone volume to music volume if headset connected 731 audio_devices_t mDeviceForStrategy[NUM_STRATEGIES]; 732 float mLastVoiceVolume; // last voice volume value sent to audio HAL 733 734 // Maximum CPU load allocated to audio effects in 0.1 MIPS (ARMv5TE, 0 WS memory) units 735 static const uint32_t MAX_EFFECTS_CPU_LOAD = 1000; 736 // Maximum memory allocated to audio effects in KB 737 static const uint32_t MAX_EFFECTS_MEMORY = 512; 738 uint32_t mTotalEffectsCpuLoad; // current CPU load used by effects 739 uint32_t mTotalEffectsMemory; // current memory used by effects 740 KeyedVector<int, sp<EffectDescriptor> > mEffects; // list of registered audio effects 741 bool mA2dpSuspended; // true if A2DP output is suspended 742 sp<DeviceDescriptor> mDefaultOutputDevice; // output device selected by default at boot time 743 bool mSpeakerDrcEnabled;// true on devices that use DRC on the DEVICE_CATEGORY_SPEAKER path 744 // to boost soft sounds, used to adjust volume curves accordingly 745 746 Vector < sp<HwModule> > mHwModules; 747 volatile int32_t mNextUniqueId; 748 volatile int32_t mAudioPortGeneration; 749 750 DefaultKeyedVector<audio_patch_handle_t, sp<AudioPatch> > mAudioPatches; 751 752#ifdef AUDIO_POLICY_TEST 753 Mutex mLock; 754 Condition mWaitWorkCV; 755 756 int mCurOutput; 757 bool mDirectOutput; 758 audio_io_handle_t mTestOutputs[NUM_TEST_OUTPUTS]; 759 int mTestInput; 760 uint32_t mTestDevice; 761 uint32_t mTestSamplingRate; 762 uint32_t mTestFormat; 763 uint32_t mTestChannels; 764 uint32_t mTestLatencyMs; 765#endif //AUDIO_POLICY_TEST 766 767private: 768 static float volIndexToAmpl(audio_devices_t device, const StreamDescriptor& streamDesc, 769 int indexInUi); 770 // updates device caching and output for streams that can influence the 771 // routing of notifications 772 void handleNotificationRoutingForStream(audio_stream_type_t stream); 773 static bool isVirtualInputDevice(audio_devices_t device); 774 uint32_t nextUniqueId(); 775 uint32_t nextAudioPortGeneration(); 776 uint32_t curAudioPortGeneration() const { return mAudioPortGeneration; } 777 // converts device address to string sent to audio HAL via setParameters 778 static String8 addressToParameter(audio_devices_t device, const String8 address); 779 // internal method to return the output handle for the given device and format 780 audio_io_handle_t getOutputForDevice( 781 audio_devices_t device, 782 audio_stream_type_t stream, 783 uint32_t samplingRate, 784 audio_format_t format, 785 audio_channel_mask_t channelMask, 786 audio_output_flags_t flags, 787 const audio_offload_info_t *offloadInfo); 788 // internal function to derive a stream type value from audio attributes 789 audio_stream_type_t streamTypefromAttributesInt(const audio_attributes_t *attr); 790}; 791 792}; 793