AudioPolicyService.h revision dce54a1492c410ad0d93253b341fb33305337505
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#ifndef ANDROID_AUDIOPOLICYSERVICE_H 18#define ANDROID_AUDIOPOLICYSERVICE_H 19 20#include <cutils/misc.h> 21#include <cutils/config_utils.h> 22#include <cutils/compiler.h> 23#include <utils/String8.h> 24#include <utils/Vector.h> 25#include <utils/SortedVector.h> 26#include <binder/BinderService.h> 27#include <system/audio.h> 28#include <system/audio_policy.h> 29#include <hardware/audio_policy.h> 30#include <media/IAudioPolicyService.h> 31#include <media/ToneGenerator.h> 32#include <media/AudioEffect.h> 33#include <hardware_legacy/AudioPolicyInterface.h> 34#include "AudioPolicyManager.h" 35 36namespace android { 37 38// ---------------------------------------------------------------------------- 39 40class AudioPolicyService : 41 public BinderService<AudioPolicyService>, 42 public BnAudioPolicyService, 43 public IBinder::DeathRecipient 44{ 45 friend class BinderService<AudioPolicyService>; 46 47public: 48 // for BinderService 49 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 50 51 virtual status_t dump(int fd, const Vector<String16>& args); 52 53 // 54 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 55 // 56 57 virtual status_t setDeviceConnectionState(audio_devices_t device, 58 audio_policy_dev_state_t state, 59 const char *device_address); 60 virtual audio_policy_dev_state_t getDeviceConnectionState( 61 audio_devices_t device, 62 const char *device_address); 63 virtual status_t setPhoneState(audio_mode_t state); 64 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 65 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 66 virtual audio_io_handle_t getOutput(audio_stream_type_t stream, 67 uint32_t samplingRate = 0, 68 audio_format_t format = AUDIO_FORMAT_DEFAULT, 69 audio_channel_mask_t channelMask = 0, 70 audio_output_flags_t flags = 71 AUDIO_OUTPUT_FLAG_NONE, 72 const audio_offload_info_t *offloadInfo = NULL); 73 virtual status_t startOutput(audio_io_handle_t output, 74 audio_stream_type_t stream, 75 int session = 0); 76 virtual status_t stopOutput(audio_io_handle_t output, 77 audio_stream_type_t stream, 78 int session = 0); 79 virtual void releaseOutput(audio_io_handle_t output); 80 virtual audio_io_handle_t getInput(audio_source_t inputSource, 81 uint32_t samplingRate = 0, 82 audio_format_t format = AUDIO_FORMAT_DEFAULT, 83 audio_channel_mask_t channelMask = 0, 84 int audioSession = 0); 85 virtual status_t startInput(audio_io_handle_t input); 86 virtual status_t stopInput(audio_io_handle_t input); 87 virtual void releaseInput(audio_io_handle_t input); 88 virtual status_t initStreamVolume(audio_stream_type_t stream, 89 int indexMin, 90 int indexMax); 91 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 92 int index, 93 audio_devices_t device); 94 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 95 int *index, 96 audio_devices_t device); 97 98 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 99 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream); 100 101 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc); 102 virtual status_t registerEffect(const effect_descriptor_t *desc, 103 audio_io_handle_t io, 104 uint32_t strategy, 105 int session, 106 int id); 107 virtual status_t unregisterEffect(int id); 108 virtual status_t setEffectEnabled(int id, bool enabled); 109 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 110 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 111 virtual bool isSourceActive(audio_source_t source) const; 112 113 virtual status_t queryDefaultPreProcessing(int audioSession, 114 effect_descriptor_t *descriptors, 115 uint32_t *count); 116 virtual status_t onTransact( 117 uint32_t code, 118 const Parcel& data, 119 Parcel* reply, 120 uint32_t flags); 121 122 // IBinder::DeathRecipient 123 virtual void binderDied(const wp<IBinder>& who); 124 125 // 126 // Helpers for the struct audio_policy_service_ops implementation. 127 // This is used by the audio policy manager for certain operations that 128 // are implemented by the policy service. 129 // 130 virtual void setParameters(audio_io_handle_t ioHandle, 131 const char *keyValuePairs, 132 int delayMs); 133 134 virtual status_t setStreamVolume(audio_stream_type_t stream, 135 float volume, 136 audio_io_handle_t output, 137 int delayMs = 0); 138 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 139 virtual status_t stopTone(); 140 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 141 virtual bool isOffloadSupported(const audio_offload_info_t &config); 142 143 status_t doStopOutput(audio_io_handle_t output, 144 audio_stream_type_t stream, 145 int session = 0); 146 void doReleaseOutput(audio_io_handle_t output); 147 148private: 149 AudioPolicyService() ANDROID_API; 150 virtual ~AudioPolicyService(); 151 152 status_t dumpInternals(int fd); 153 154 // Thread used for tone playback and to send audio config commands to audio flinger 155 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because 156 // startTone() and stopTone() are normally called with mLock locked and requesting a tone start 157 // or stop will cause calls to AudioPolicyService and an attempt to lock mLock. 158 // For audio config commands, it is necessary because audio flinger requires that the calling 159 // process (user) has permission to modify audio settings. 160 class AudioCommandThread : public Thread { 161 class AudioCommand; 162 public: 163 164 // commands for tone AudioCommand 165 enum { 166 START_TONE, 167 STOP_TONE, 168 SET_VOLUME, 169 SET_PARAMETERS, 170 SET_VOICE_VOLUME, 171 STOP_OUTPUT, 172 RELEASE_OUTPUT 173 }; 174 175 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 176 virtual ~AudioCommandThread(); 177 178 status_t dump(int fd); 179 180 // Thread virtuals 181 virtual void onFirstRef(); 182 virtual bool threadLoop(); 183 184 void exit(); 185 void startToneCommand(ToneGenerator::tone_type type, 186 audio_stream_type_t stream); 187 void stopToneCommand(); 188 status_t volumeCommand(audio_stream_type_t stream, float volume, 189 audio_io_handle_t output, int delayMs = 0); 190 status_t parametersCommand(audio_io_handle_t ioHandle, 191 const char *keyValuePairs, int delayMs = 0); 192 status_t voiceVolumeCommand(float volume, int delayMs = 0); 193 void stopOutputCommand(audio_io_handle_t output, 194 audio_stream_type_t stream, 195 int session); 196 void releaseOutputCommand(audio_io_handle_t output); 197 198 void insertCommand_l(AudioCommand *command, int delayMs = 0); 199 200 private: 201 // descriptor for requested tone playback event 202 class AudioCommand { 203 204 public: 205 AudioCommand() 206 : mCommand(-1) {} 207 208 void dump(char* buffer, size_t size); 209 210 int mCommand; // START_TONE, STOP_TONE ... 211 nsecs_t mTime; // time stamp 212 Condition mCond; // condition for status return 213 status_t mStatus; // command status 214 bool mWaitStatus; // true if caller is waiting for status 215 void *mParam; // command parameter (ToneData, VolumeData, ParametersData) 216 }; 217 218 class ToneData { 219 public: 220 ToneGenerator::tone_type mType; // tone type (START_TONE only) 221 audio_stream_type_t mStream; // stream type (START_TONE only) 222 }; 223 224 class VolumeData { 225 public: 226 audio_stream_type_t mStream; 227 float mVolume; 228 audio_io_handle_t mIO; 229 }; 230 231 class ParametersData { 232 public: 233 audio_io_handle_t mIO; 234 String8 mKeyValuePairs; 235 }; 236 237 class VoiceVolumeData { 238 public: 239 float mVolume; 240 }; 241 242 class StopOutputData { 243 public: 244 audio_io_handle_t mIO; 245 audio_stream_type_t mStream; 246 int mSession; 247 }; 248 249 class ReleaseOutputData { 250 public: 251 audio_io_handle_t mIO; 252 }; 253 254 Mutex mLock; 255 Condition mWaitWorkCV; 256 Vector <AudioCommand *> mAudioCommands; // list of pending commands 257 ToneGenerator *mpToneGenerator; // the tone generator 258 AudioCommand mLastCommand; // last processed command (used by dump) 259 String8 mName; // string used by wake lock fo delayed commands 260 wp<AudioPolicyService> mService; 261 }; 262 263 class EffectDesc { 264 public: 265 EffectDesc(const char *name, const effect_uuid_t& uuid) : 266 mName(strdup(name)), 267 mUuid(uuid) { } 268 EffectDesc(const EffectDesc& orig) : 269 mName(strdup(orig.mName)), 270 mUuid(orig.mUuid) { 271 // deep copy mParams 272 for (size_t k = 0; k < orig.mParams.size(); k++) { 273 effect_param_t *origParam = orig.mParams[k]; 274 // psize and vsize are rounded up to an int boundary for allocation 275 size_t origSize = sizeof(effect_param_t) + 276 ((origParam->psize + 3) & ~3) + 277 ((origParam->vsize + 3) & ~3); 278 effect_param_t *dupParam = (effect_param_t *) malloc(origSize); 279 memcpy(dupParam, origParam, origSize); 280 // This works because the param buffer allocation is also done by 281 // multiples of 4 bytes originally. In theory we should memcpy only 282 // the actual param size, that is without rounding vsize. 283 mParams.add(dupParam); 284 } 285 } 286 /*virtual*/ ~EffectDesc() { 287 free(mName); 288 for (size_t k = 0; k < mParams.size(); k++) { 289 free(mParams[k]); 290 } 291 } 292 char *mName; 293 effect_uuid_t mUuid; 294 Vector <effect_param_t *> mParams; 295 }; 296 297 class InputSourceDesc { 298 public: 299 InputSourceDesc() {} 300 /*virtual*/ ~InputSourceDesc() { 301 for (size_t j = 0; j < mEffects.size(); j++) { 302 delete mEffects[j]; 303 } 304 } 305 Vector <EffectDesc *> mEffects; 306 }; 307 308 309 class InputDesc { 310 public: 311 InputDesc(int session) : mSessionId(session) {} 312 /*virtual*/ ~InputDesc() {} 313 const int mSessionId; 314 Vector< sp<AudioEffect> >mEffects; 315 }; 316 317 class AudioPolicyClient : public AudioPolicyClientInterface 318 { 319 public: 320 AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} 321 virtual ~AudioPolicyClient() {} 322 323 // 324 // Audio HW module functions 325 // 326 327 // loads a HW module. 328 virtual audio_module_handle_t loadHwModule(const char *name); 329 330 // 331 // Audio output Control functions 332 // 333 334 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 335 // in case the audio policy manager has no specific requirements for the output being opened. 336 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 337 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 338 virtual audio_io_handle_t openOutput(audio_module_handle_t module, 339 audio_devices_t *pDevices, 340 uint32_t *pSamplingRate, 341 audio_format_t *pFormat, 342 audio_channel_mask_t *pChannelMask, 343 uint32_t *pLatencyMs, 344 audio_output_flags_t flags, 345 const audio_offload_info_t *offloadInfo = NULL); 346 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 347 // a special mixer thread in the AudioFlinger. 348 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 349 // closes the output stream 350 virtual status_t closeOutput(audio_io_handle_t output); 351 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 352 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 353 virtual status_t suspendOutput(audio_io_handle_t output); 354 // restores a suspended output. 355 virtual status_t restoreOutput(audio_io_handle_t output); 356 357 // 358 // Audio input Control functions 359 // 360 361 // opens an audio input 362 virtual audio_io_handle_t openInput(audio_module_handle_t module, 363 audio_devices_t *pDevices, 364 uint32_t *pSamplingRate, 365 audio_format_t *pFormat, 366 audio_channel_mask_t *pChannelMask); 367 // closes an audio input 368 virtual status_t closeInput(audio_io_handle_t input); 369 // 370 // misc control functions 371 // 372 373 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 374 // for each output (destination device) it is attached to. 375 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 376 377 // invalidate a stream type, causing a reroute to an unspecified new output 378 virtual status_t invalidateStream(audio_stream_type_t stream); 379 380 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 381 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 382 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 383 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 384 385 // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing 386 // over a telephony device during a phone call. 387 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 388 virtual status_t stopTone(); 389 390 // set down link audio volume. 391 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 392 393 // move effect to the specified output 394 virtual status_t moveEffects(int session, 395 audio_io_handle_t srcOutput, 396 audio_io_handle_t dstOutput); 397 398 private: 399 AudioPolicyService *mAudioPolicyService; 400 }; 401 402 static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1]; 403 404 void setPreProcessorEnabled(const InputDesc *inputDesc, bool enabled); 405 status_t loadPreProcessorConfig(const char *path); 406 status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects); 407 EffectDesc *loadEffect(cnode *root); 408 status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects); 409 audio_source_t inputSourceNameToEnum(const char *name); 410 InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects); 411 void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params); 412 effect_param_t *loadEffectParameter(cnode *root); 413 size_t readParamValue(cnode *node, 414 char *param, 415 size_t *curSize, 416 size_t *totSize); 417 size_t growParamSize(char *param, 418 size_t size, 419 size_t *curSize, 420 size_t *totSize); 421 422 // Internal dump utilities. 423 status_t dumpPermissionDenial(int fd); 424 425 426 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 427 // device connection state or routing 428 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 429 sp<AudioCommandThread> mTonePlaybackThread; // tone playback thread 430 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 431 struct audio_policy_device *mpAudioPolicyDev; 432 struct audio_policy *mpAudioPolicy; 433 AudioPolicyManager *mAudioPolicyManager; 434 AudioPolicyClient *mAudioPolicyClient; 435 436 KeyedVector< audio_source_t, InputSourceDesc* > mInputSources; 437 KeyedVector< audio_io_handle_t, InputDesc* > mInputs; 438}; 439 440}; // namespace android 441 442#endif // ANDROID_AUDIOPOLICYSERVICE_H 443