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