1 /*
2 **
3 ** Copyright 2014, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18
19 #define LOG_TAG "AudioFlinger::PatchPanel"
20 //#define LOG_NDEBUG 0
21
22 #include "Configuration.h"
23 #include <utils/Log.h>
24 #include <audio_utils/primitives.h>
25
26 #include "AudioFlinger.h"
27 #include <media/AudioParameter.h>
28 #include <media/AudioValidator.h>
29 #include <media/DeviceDescriptorBase.h>
30 #include <media/PatchBuilder.h>
31 #include <mediautils/ServiceUtilities.h>
32
33 // ----------------------------------------------------------------------------
34
35 // Note: the following macro is used for extremely verbose logging message. In
36 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
37 // 0; but one side effect of this is to turn all LOGV's as well. Some messages
38 // are so verbose that we want to suppress them even when we have ALOG_ASSERT
39 // turned on. Do not uncomment the #def below unless you really know what you
40 // are doing and want to see all of the extremely verbose messages.
41 //#define VERY_VERY_VERBOSE_LOGGING
42 #ifdef VERY_VERY_VERBOSE_LOGGING
43 #define ALOGVV ALOGV
44 #else
45 #define ALOGVV(a...) do { } while(0)
46 #endif
47
48 namespace android {
49
50 /* List connected audio ports and their attributes */
listAudioPorts(unsigned int * num_ports,struct audio_port * ports)51 status_t AudioFlinger::listAudioPorts(unsigned int *num_ports,
52 struct audio_port *ports)
53 {
54 Mutex::Autolock _l(mLock);
55 return mPatchPanel.listAudioPorts(num_ports, ports);
56 }
57
58 /* Get supported attributes for a given audio port */
getAudioPort(struct audio_port_v7 * port)59 status_t AudioFlinger::getAudioPort(struct audio_port_v7 *port) {
60 status_t status = AudioValidator::validateAudioPort(*port);
61 if (status != NO_ERROR) {
62 return status;
63 }
64
65 Mutex::Autolock _l(mLock);
66 return mPatchPanel.getAudioPort(port);
67 }
68
69 /* Connect a patch between several source and sink ports */
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)70 status_t AudioFlinger::createAudioPatch(const struct audio_patch *patch,
71 audio_patch_handle_t *handle)
72 {
73 status_t status = AudioValidator::validateAudioPatch(*patch);
74 if (status != NO_ERROR) {
75 return status;
76 }
77
78 Mutex::Autolock _l(mLock);
79 return mPatchPanel.createAudioPatch(patch, handle);
80 }
81
82 /* Disconnect a patch */
releaseAudioPatch(audio_patch_handle_t handle)83 status_t AudioFlinger::releaseAudioPatch(audio_patch_handle_t handle)
84 {
85 Mutex::Autolock _l(mLock);
86 return mPatchPanel.releaseAudioPatch(handle);
87 }
88
89 /* List connected audio ports and they attributes */
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches)90 status_t AudioFlinger::listAudioPatches(unsigned int *num_patches,
91 struct audio_patch *patches)
92 {
93 Mutex::Autolock _l(mLock);
94 return mPatchPanel.listAudioPatches(num_patches, patches);
95 }
96
getLatencyMs_l(double * latencyMs) const97 status_t AudioFlinger::PatchPanel::SoftwarePatch::getLatencyMs_l(double *latencyMs) const
98 {
99 const auto& iter = mPatchPanel.mPatches.find(mPatchHandle);
100 if (iter != mPatchPanel.mPatches.end()) {
101 return iter->second.getLatencyMs(latencyMs);
102 } else {
103 return BAD_VALUE;
104 }
105 }
106
107 /* List connected audio ports and their attributes */
listAudioPorts(unsigned int * num_ports __unused,struct audio_port * ports __unused)108 status_t AudioFlinger::PatchPanel::listAudioPorts(unsigned int *num_ports __unused,
109 struct audio_port *ports __unused)
110 {
111 ALOGV(__func__);
112 return NO_ERROR;
113 }
114
115 /* Get supported attributes for a given audio port */
getAudioPort(struct audio_port_v7 * port)116 status_t AudioFlinger::PatchPanel::getAudioPort(struct audio_port_v7 *port)
117 {
118 if (port->type != AUDIO_PORT_TYPE_DEVICE) {
119 // Only query the HAL when the port is a device.
120 // TODO: implement getAudioPort for mix.
121 return INVALID_OPERATION;
122 }
123 AudioHwDevice* hwDevice = findAudioHwDeviceByModule(port->ext.device.hw_module);
124 if (hwDevice == nullptr) {
125 ALOGW("%s cannot find hw module %d", __func__, port->ext.device.hw_module);
126 return BAD_VALUE;
127 }
128 if (!hwDevice->supportsAudioPatches()) {
129 return INVALID_OPERATION;
130 }
131 return hwDevice->getAudioPort(port);
132 }
133
134 /* Connect a patch between several source and sink ports */
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle,bool endpointPatch)135 status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *patch,
136 audio_patch_handle_t *handle,
137 bool endpointPatch)
138 {
139 if (handle == NULL || patch == NULL) {
140 return BAD_VALUE;
141 }
142 ALOGV("%s() num_sources %d num_sinks %d handle %d",
143 __func__, patch->num_sources, patch->num_sinks, *handle);
144 status_t status = NO_ERROR;
145 audio_patch_handle_t halHandle = AUDIO_PATCH_HANDLE_NONE;
146
147 if (!audio_patch_is_valid(patch) || (patch->num_sinks == 0 && patch->num_sources != 2)) {
148 return BAD_VALUE;
149 }
150 // limit number of sources to 1 for now or 2 sources for special cross hw module case.
151 // only the audio policy manager can request a patch creation with 2 sources.
152 if (patch->num_sources > 2) {
153 return INVALID_OPERATION;
154 }
155
156 if (*handle != AUDIO_PATCH_HANDLE_NONE) {
157 auto iter = mPatches.find(*handle);
158 if (iter != mPatches.end()) {
159 ALOGV("%s() removing patch handle %d", __func__, *handle);
160 Patch &removedPatch = iter->second;
161 // free resources owned by the removed patch if applicable
162 // 1) if a software patch is present, release the playback and capture threads and
163 // tracks created. This will also release the corresponding audio HAL patches
164 if (removedPatch.isSoftware()) {
165 removedPatch.clearConnections(this);
166 }
167 // 2) if the new patch and old patch source or sink are devices from different
168 // hw modules, clear the audio HAL patches now because they will not be updated
169 // by call to create_audio_patch() below which will happen on a different HW module
170 if (removedPatch.mHalHandle != AUDIO_PATCH_HANDLE_NONE) {
171 audio_module_handle_t hwModule = AUDIO_MODULE_HANDLE_NONE;
172 const struct audio_patch &oldPatch = removedPatch.mAudioPatch;
173 if (oldPatch.sources[0].type == AUDIO_PORT_TYPE_DEVICE &&
174 (patch->sources[0].type != AUDIO_PORT_TYPE_DEVICE ||
175 oldPatch.sources[0].ext.device.hw_module !=
176 patch->sources[0].ext.device.hw_module)) {
177 hwModule = oldPatch.sources[0].ext.device.hw_module;
178 } else if (patch->num_sinks == 0 ||
179 (oldPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE &&
180 (patch->sinks[0].type != AUDIO_PORT_TYPE_DEVICE ||
181 oldPatch.sinks[0].ext.device.hw_module !=
182 patch->sinks[0].ext.device.hw_module))) {
183 // Note on (patch->num_sinks == 0): this situation should not happen as
184 // these special patches are only created by the policy manager but just
185 // in case, systematically clear the HAL patch.
186 // Note that removedPatch.mAudioPatch.num_sinks cannot be 0 here because
187 // removedPatch.mHalHandle would be AUDIO_PATCH_HANDLE_NONE in this case.
188 hwModule = oldPatch.sinks[0].ext.device.hw_module;
189 }
190 sp<DeviceHalInterface> hwDevice = findHwDeviceByModule(hwModule);
191 if (hwDevice != 0) {
192 hwDevice->releaseAudioPatch(removedPatch.mHalHandle);
193 }
194 halHandle = removedPatch.mHalHandle;
195 }
196 erasePatch(*handle);
197 }
198 }
199
200 Patch newPatch{*patch, endpointPatch};
201 audio_module_handle_t insertedModule = AUDIO_MODULE_HANDLE_NONE;
202
203 switch (patch->sources[0].type) {
204 case AUDIO_PORT_TYPE_DEVICE: {
205 audio_module_handle_t srcModule = patch->sources[0].ext.device.hw_module;
206 AudioHwDevice *audioHwDevice = findAudioHwDeviceByModule(srcModule);
207 if (!audioHwDevice) {
208 status = BAD_VALUE;
209 goto exit;
210 }
211 for (unsigned int i = 0; i < patch->num_sinks; i++) {
212 // support only one sink if connection to a mix or across HW modules
213 if ((patch->sinks[i].type == AUDIO_PORT_TYPE_MIX ||
214 (patch->sinks[i].type == AUDIO_PORT_TYPE_DEVICE &&
215 patch->sinks[i].ext.device.hw_module != srcModule)) &&
216 patch->num_sinks > 1) {
217 ALOGW("%s() multiple sinks for mix or across modules not supported", __func__);
218 status = INVALID_OPERATION;
219 goto exit;
220 }
221 // reject connection to different sink types
222 if (patch->sinks[i].type != patch->sinks[0].type) {
223 ALOGW("%s() different sink types in same patch not supported", __func__);
224 status = BAD_VALUE;
225 goto exit;
226 }
227 }
228
229 // manage patches requiring a software bridge
230 // - special patch request with 2 sources (reuse one existing output mix) OR
231 // - Device to device AND
232 // - source HW module != destination HW module OR
233 // - audio HAL does not support audio patches creation
234 if ((patch->num_sources == 2) ||
235 ((patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) &&
236 ((patch->sinks[0].ext.device.hw_module != srcModule) ||
237 !audioHwDevice->supportsAudioPatches()))) {
238 audio_devices_t outputDevice = patch->sinks[0].ext.device.type;
239 String8 outputDeviceAddress = String8(patch->sinks[0].ext.device.address);
240 if (patch->num_sources == 2) {
241 if (patch->sources[1].type != AUDIO_PORT_TYPE_MIX ||
242 (patch->num_sinks != 0 && patch->sinks[0].ext.device.hw_module !=
243 patch->sources[1].ext.mix.hw_module)) {
244 ALOGW("%s() invalid source combination", __func__);
245 status = INVALID_OPERATION;
246 goto exit;
247 }
248
249 sp<ThreadBase> thread =
250 mAudioFlinger.checkPlaybackThread_l(patch->sources[1].ext.mix.handle);
251 if (thread == 0) {
252 ALOGW("%s() cannot get playback thread", __func__);
253 status = INVALID_OPERATION;
254 goto exit;
255 }
256 // existing playback thread is reused, so it is not closed when patch is cleared
257 newPatch.mPlayback.setThread(
258 reinterpret_cast<PlaybackThread*>(thread.get()), false /*closeThread*/);
259 } else {
260 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
261 audio_config_base_t mixerConfig = AUDIO_CONFIG_BASE_INITIALIZER;
262 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
263 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
264 if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
265 config.sample_rate = patch->sinks[0].sample_rate;
266 }
267 if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
268 config.channel_mask = patch->sinks[0].channel_mask;
269 }
270 if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FORMAT) {
271 config.format = patch->sinks[0].format;
272 }
273 if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS) {
274 flags = patch->sinks[0].flags.output;
275 }
276 sp<ThreadBase> thread = mAudioFlinger.openOutput_l(
277 patch->sinks[0].ext.device.hw_module,
278 &output,
279 &config,
280 &mixerConfig,
281 outputDevice,
282 outputDeviceAddress,
283 flags);
284 ALOGV("mAudioFlinger.openOutput_l() returned %p", thread.get());
285 if (thread == 0) {
286 status = NO_MEMORY;
287 goto exit;
288 }
289 newPatch.mPlayback.setThread(reinterpret_cast<PlaybackThread*>(thread.get()));
290 }
291 audio_devices_t device = patch->sources[0].ext.device.type;
292 String8 address = String8(patch->sources[0].ext.device.address);
293 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
294 // open input stream with source device audio properties if provided or
295 // default to peer output stream properties otherwise.
296 if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
297 config.sample_rate = patch->sources[0].sample_rate;
298 } else {
299 config.sample_rate = newPatch.mPlayback.thread()->sampleRate();
300 }
301 if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
302 config.channel_mask = patch->sources[0].channel_mask;
303 } else {
304 config.channel_mask = audio_channel_in_mask_from_count(
305 newPatch.mPlayback.thread()->channelCount());
306 }
307 if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_FORMAT) {
308 config.format = patch->sources[0].format;
309 } else {
310 config.format = newPatch.mPlayback.thread()->format();
311 }
312 audio_input_flags_t flags =
313 patch->sources[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
314 patch->sources[0].flags.input : AUDIO_INPUT_FLAG_NONE;
315 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
316 audio_source_t source = AUDIO_SOURCE_MIC;
317 // For telephony patches, propagate voice communication use case to record side
318 if (patch->num_sources == 2
319 && patch->sources[1].ext.mix.usecase.stream
320 == AUDIO_STREAM_VOICE_CALL) {
321 source = AUDIO_SOURCE_VOICE_COMMUNICATION;
322 }
323 sp<ThreadBase> thread = mAudioFlinger.openInput_l(srcModule,
324 &input,
325 &config,
326 device,
327 address,
328 source,
329 flags,
330 outputDevice,
331 outputDeviceAddress);
332 ALOGV("mAudioFlinger.openInput_l() returned %p inChannelMask %08x",
333 thread.get(), config.channel_mask);
334 if (thread == 0) {
335 status = NO_MEMORY;
336 goto exit;
337 }
338 newPatch.mRecord.setThread(reinterpret_cast<RecordThread*>(thread.get()));
339 status = newPatch.createConnections(this);
340 if (status != NO_ERROR) {
341 goto exit;
342 }
343 if (audioHwDevice->isInsert()) {
344 insertedModule = audioHwDevice->handle();
345 }
346 } else {
347 if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
348 sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(
349 patch->sinks[0].ext.mix.handle);
350 if (thread == 0) {
351 thread = mAudioFlinger.checkMmapThread_l(patch->sinks[0].ext.mix.handle);
352 if (thread == 0) {
353 ALOGW("%s() bad capture I/O handle %d",
354 __func__, patch->sinks[0].ext.mix.handle);
355 status = BAD_VALUE;
356 goto exit;
357 }
358 }
359 status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
360 if (status == NO_ERROR) {
361 newPatch.setThread(thread);
362 }
363
364 // remove stale audio patch with same input as sink if any
365 for (auto& iter : mPatches) {
366 if (iter.second.mAudioPatch.sinks[0].ext.mix.handle == thread->id()) {
367 erasePatch(iter.first);
368 break;
369 }
370 }
371 } else {
372 sp<DeviceHalInterface> hwDevice = audioHwDevice->hwDevice();
373 status = hwDevice->createAudioPatch(patch->num_sources,
374 patch->sources,
375 patch->num_sinks,
376 patch->sinks,
377 &halHandle);
378 if (status == INVALID_OPERATION) goto exit;
379 }
380 }
381 } break;
382 case AUDIO_PORT_TYPE_MIX: {
383 audio_module_handle_t srcModule = patch->sources[0].ext.mix.hw_module;
384 ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(srcModule);
385 if (index < 0) {
386 ALOGW("%s() bad src hw module %d", __func__, srcModule);
387 status = BAD_VALUE;
388 goto exit;
389 }
390 // limit to connections between devices and output streams
391 DeviceDescriptorBaseVector devices;
392 for (unsigned int i = 0; i < patch->num_sinks; i++) {
393 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
394 ALOGW("%s() invalid sink type %d for mix source",
395 __func__, patch->sinks[i].type);
396 status = BAD_VALUE;
397 goto exit;
398 }
399 // limit to connections between sinks and sources on same HW module
400 if (patch->sinks[i].ext.device.hw_module != srcModule) {
401 status = BAD_VALUE;
402 goto exit;
403 }
404 sp<DeviceDescriptorBase> device = new DeviceDescriptorBase(
405 patch->sinks[i].ext.device.type);
406 device->setAddress(patch->sinks[i].ext.device.address);
407 device->applyAudioPortConfig(&patch->sinks[i]);
408 devices.push_back(device);
409 }
410 sp<ThreadBase> thread =
411 mAudioFlinger.checkPlaybackThread_l(patch->sources[0].ext.mix.handle);
412 if (thread == 0) {
413 thread = mAudioFlinger.checkMmapThread_l(patch->sources[0].ext.mix.handle);
414 if (thread == 0) {
415 ALOGW("%s() bad playback I/O handle %d",
416 __func__, patch->sources[0].ext.mix.handle);
417 status = BAD_VALUE;
418 goto exit;
419 }
420 }
421 if (thread == mAudioFlinger.primaryPlaybackThread_l()) {
422 mAudioFlinger.updateOutDevicesForRecordThreads_l(devices);
423 }
424
425 status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
426 if (status == NO_ERROR) {
427 newPatch.setThread(thread);
428 }
429
430 // remove stale audio patch with same output as source if any
431 // Prevent to remove endpoint patches (involved in a SwBridge)
432 // Prevent to remove AudioPatch used to route an output involved in an endpoint.
433 if (!endpointPatch) {
434 for (auto& iter : mPatches) {
435 if (iter.second.mAudioPatch.sources[0].ext.mix.handle == thread->id() &&
436 !iter.second.mIsEndpointPatch) {
437 erasePatch(iter.first);
438 break;
439 }
440 }
441 }
442 } break;
443 default:
444 status = BAD_VALUE;
445 goto exit;
446 }
447 exit:
448 ALOGV("%s() status %d", __func__, status);
449 if (status == NO_ERROR) {
450 *handle = (audio_patch_handle_t) mAudioFlinger.nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH);
451 newPatch.mHalHandle = halHandle;
452 mAudioFlinger.mDeviceEffectManager.createAudioPatch(*handle, newPatch);
453 if (insertedModule != AUDIO_MODULE_HANDLE_NONE) {
454 addSoftwarePatchToInsertedModules(insertedModule, *handle, &newPatch.mAudioPatch);
455 }
456 mPatches.insert(std::make_pair(*handle, std::move(newPatch)));
457 } else {
458 newPatch.clearConnections(this);
459 }
460 return status;
461 }
462
~Patch()463 AudioFlinger::PatchPanel::Patch::~Patch()
464 {
465 ALOGE_IF(isSoftware(), "Software patch connections leaked %d %d",
466 mRecord.handle(), mPlayback.handle());
467 }
468
createConnections(PatchPanel * panel)469 status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
470 {
471 // create patch from source device to record thread input
472 status_t status = panel->createAudioPatch(
473 PatchBuilder().addSource(mAudioPatch.sources[0]).
474 addSink(mRecord.thread(), { .source = AUDIO_SOURCE_MIC }).patch(),
475 mRecord.handlePtr(),
476 true /*endpointPatch*/);
477 if (status != NO_ERROR) {
478 *mRecord.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
479 return status;
480 }
481
482 // create patch from playback thread output to sink device
483 if (mAudioPatch.num_sinks != 0) {
484 status = panel->createAudioPatch(
485 PatchBuilder().addSource(mPlayback.thread()).addSink(mAudioPatch.sinks[0]).patch(),
486 mPlayback.handlePtr(),
487 true /*endpointPatch*/);
488 if (status != NO_ERROR) {
489 *mPlayback.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
490 return status;
491 }
492 } else {
493 *mPlayback.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
494 }
495
496 // create a special record track to capture from record thread
497 uint32_t channelCount = mPlayback.thread()->channelCount();
498 audio_channel_mask_t inChannelMask = audio_channel_in_mask_from_count(channelCount);
499 audio_channel_mask_t outChannelMask = mPlayback.thread()->channelMask();
500 uint32_t sampleRate = mPlayback.thread()->sampleRate();
501 audio_format_t format = mPlayback.thread()->format();
502
503 audio_format_t inputFormat = mRecord.thread()->format();
504 if (!audio_is_linear_pcm(inputFormat)) {
505 // The playbackThread format will say PCM for IEC61937 packetized stream.
506 // Use recordThread format.
507 format = inputFormat;
508 }
509 audio_input_flags_t inputFlags = mAudioPatch.sources[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
510 mAudioPatch.sources[0].flags.input : AUDIO_INPUT_FLAG_NONE;
511 if (sampleRate == mRecord.thread()->sampleRate() &&
512 inChannelMask == mRecord.thread()->channelMask() &&
513 mRecord.thread()->fastTrackAvailable() &&
514 mRecord.thread()->hasFastCapture()) {
515 // Create a fast track if the record thread has fast capture to get better performance.
516 // Only enable fast mode when there is no resample needed.
517 inputFlags = (audio_input_flags_t) (inputFlags | AUDIO_INPUT_FLAG_FAST);
518 } else {
519 // Fast mode is not available in this case.
520 inputFlags = (audio_input_flags_t) (inputFlags & ~AUDIO_INPUT_FLAG_FAST);
521 }
522
523 audio_output_flags_t outputFlags = mAudioPatch.sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
524 mAudioPatch.sinks[0].flags.output : AUDIO_OUTPUT_FLAG_NONE;
525 audio_stream_type_t streamType = AUDIO_STREAM_PATCH;
526 audio_source_t source = AUDIO_SOURCE_DEFAULT;
527 if (mAudioPatch.num_sources == 2 && mAudioPatch.sources[1].type == AUDIO_PORT_TYPE_MIX) {
528 // "reuse one existing output mix" case
529 streamType = mAudioPatch.sources[1].ext.mix.usecase.stream;
530 // For telephony patches, propagate voice communication use case to record side
531 if (streamType == AUDIO_STREAM_VOICE_CALL) {
532 source = AUDIO_SOURCE_VOICE_COMMUNICATION;
533 }
534 }
535 if (mPlayback.thread()->hasFastMixer()) {
536 // Create a fast track if the playback thread has fast mixer to get better performance.
537 // Note: we should have matching channel mask, sample rate, and format by the logic above.
538 outputFlags = (audio_output_flags_t) (outputFlags | AUDIO_OUTPUT_FLAG_FAST);
539 } else {
540 outputFlags = (audio_output_flags_t) (outputFlags & ~AUDIO_OUTPUT_FLAG_FAST);
541 }
542
543 sp<RecordThread::PatchRecord> tempRecordTrack;
544 const bool usePassthruPatchRecord =
545 (inputFlags & AUDIO_INPUT_FLAG_DIRECT) && (outputFlags & AUDIO_OUTPUT_FLAG_DIRECT);
546 const size_t playbackFrameCount = mPlayback.thread()->frameCount();
547 const size_t recordFrameCount = mRecord.thread()->frameCount();
548 size_t frameCount = 0;
549 if (usePassthruPatchRecord) {
550 // PassthruPatchRecord producesBufferOnDemand, so use
551 // maximum of playback and record thread framecounts
552 frameCount = std::max(playbackFrameCount, recordFrameCount);
553 ALOGV("%s() playframeCount %zu recordFrameCount %zu frameCount %zu",
554 __func__, playbackFrameCount, recordFrameCount, frameCount);
555 tempRecordTrack = new RecordThread::PassthruPatchRecord(
556 mRecord.thread().get(),
557 sampleRate,
558 inChannelMask,
559 format,
560 frameCount,
561 inputFlags,
562 source);
563 } else {
564 // use a pseudo LCM between input and output framecount
565 int playbackShift = __builtin_ctz(playbackFrameCount);
566 int shift = __builtin_ctz(recordFrameCount);
567 if (playbackShift < shift) {
568 shift = playbackShift;
569 }
570 frameCount = (playbackFrameCount * recordFrameCount) >> shift;
571 ALOGV("%s() playframeCount %zu recordFrameCount %zu frameCount %zu",
572 __func__, playbackFrameCount, recordFrameCount, frameCount);
573
574 tempRecordTrack = new RecordThread::PatchRecord(
575 mRecord.thread().get(),
576 sampleRate,
577 inChannelMask,
578 format,
579 frameCount,
580 nullptr,
581 (size_t)0 /* bufferSize */,
582 inputFlags,
583 {} /* timeout */,
584 source);
585 }
586 status = mRecord.checkTrack(tempRecordTrack.get());
587 if (status != NO_ERROR) {
588 return status;
589 }
590
591 // create a special playback track to render to playback thread.
592 // this track is given the same buffer as the PatchRecord buffer
593
594 // Default behaviour is to start as soon as possible to have the lowest possible latency even if
595 // it might glitch.
596 // Disable this behavior for FM Tuner source if no fast capture/mixer available.
597 const bool isFmBridge = mAudioPatch.sources[0].ext.device.type == AUDIO_DEVICE_IN_FM_TUNER;
598 const size_t frameCountToBeReady = isFmBridge && !usePassthruPatchRecord ? frameCount / 4 : 1;
599 sp<PlaybackThread::PatchTrack> tempPatchTrack = new PlaybackThread::PatchTrack(
600 mPlayback.thread().get(),
601 streamType,
602 sampleRate,
603 outChannelMask,
604 format,
605 frameCount,
606 tempRecordTrack->buffer(),
607 tempRecordTrack->bufferSize(),
608 outputFlags,
609 {} /*timeout*/,
610 frameCountToBeReady);
611 status = mPlayback.checkTrack(tempPatchTrack.get());
612 if (status != NO_ERROR) {
613 return status;
614 }
615
616 // tie playback and record tracks together
617 // In the case of PassthruPatchRecord no I/O activity happens on RecordThread,
618 // everything is driven from PlaybackThread. Thus AudioBufferProvider methods
619 // of PassthruPatchRecord can only be called if the corresponding PatchTrack
620 // is alive. There is no need to hold a reference, and there is no need
621 // to clear it. In fact, since playback stopping is asynchronous, there is
622 // no proper time when clearing could be done.
623 mRecord.setTrackAndPeer(tempRecordTrack, tempPatchTrack, !usePassthruPatchRecord);
624 mPlayback.setTrackAndPeer(tempPatchTrack, tempRecordTrack, true /*holdReference*/);
625
626 // start capture and playback
627 mRecord.track()->start(AudioSystem::SYNC_EVENT_NONE, AUDIO_SESSION_NONE);
628 mPlayback.track()->start();
629
630 return status;
631 }
632
clearConnections(PatchPanel * panel)633 void AudioFlinger::PatchPanel::Patch::clearConnections(PatchPanel *panel)
634 {
635 ALOGV("%s() mRecord.handle %d mPlayback.handle %d",
636 __func__, mRecord.handle(), mPlayback.handle());
637 mRecord.stopTrack();
638 mPlayback.stopTrack();
639 mRecord.clearTrackPeer(); // mRecord stop is synchronous. Break PeerProxy sp<> cycle.
640 mRecord.closeConnections(panel);
641 mPlayback.closeConnections(panel);
642 }
643
getLatencyMs(double * latencyMs) const644 status_t AudioFlinger::PatchPanel::Patch::getLatencyMs(double *latencyMs) const
645 {
646 if (!isSoftware()) return INVALID_OPERATION;
647
648 auto recordTrack = mRecord.const_track();
649 if (recordTrack.get() == nullptr) return INVALID_OPERATION;
650
651 auto playbackTrack = mPlayback.const_track();
652 if (playbackTrack.get() == nullptr) return INVALID_OPERATION;
653
654 // Latency information for tracks may be called without obtaining
655 // the underlying thread lock.
656 //
657 // We use record server latency + playback track latency (generally smaller than the
658 // reverse due to internal biases).
659 //
660 // TODO: is this stable enough? Consider a PatchTrack synchronized version of this.
661
662 // For PCM tracks get server latency.
663 if (audio_is_linear_pcm(recordTrack->format())) {
664 double recordServerLatencyMs, playbackTrackLatencyMs;
665 if (recordTrack->getServerLatencyMs(&recordServerLatencyMs) == OK
666 && playbackTrack->getTrackLatencyMs(&playbackTrackLatencyMs) == OK) {
667 *latencyMs = recordServerLatencyMs + playbackTrackLatencyMs;
668 return OK;
669 }
670 }
671
672 // See if kernel latencies are available.
673 // If so, do a frame diff and time difference computation to estimate
674 // the total patch latency. This requires that frame counts are reported by the
675 // HAL are matched properly in the case of record overruns and playback underruns.
676 ThreadBase::TrackBase::FrameTime recordFT{}, playFT{};
677 recordTrack->getKernelFrameTime(&recordFT);
678 playbackTrack->getKernelFrameTime(&playFT);
679 if (recordFT.timeNs > 0 && playFT.timeNs > 0) {
680 const int64_t frameDiff = recordFT.frames - playFT.frames;
681 const int64_t timeDiffNs = recordFT.timeNs - playFT.timeNs;
682
683 // It is possible that the patch track and patch record have a large time disparity because
684 // one thread runs but another is stopped. We arbitrarily choose the maximum timestamp
685 // time difference based on how often we expect the timestamps to update in normal operation
686 // (typical should be no more than 50 ms).
687 //
688 // If the timestamps aren't sampled close enough, the patch latency is not
689 // considered valid.
690 //
691 // TODO: change this based on more experiments.
692 constexpr int64_t maxValidTimeDiffNs = 200 * NANOS_PER_MILLISECOND;
693 if (std::abs(timeDiffNs) < maxValidTimeDiffNs) {
694 *latencyMs = frameDiff * 1e3 / recordTrack->sampleRate()
695 - timeDiffNs * 1e-6;
696 return OK;
697 }
698 }
699
700 return INVALID_OPERATION;
701 }
702
dump(audio_patch_handle_t myHandle) const703 String8 AudioFlinger::PatchPanel::Patch::dump(audio_patch_handle_t myHandle) const
704 {
705 // TODO: Consider table dump form for patches, just like tracks.
706 String8 result = String8::format("Patch %d: %s (thread %p => thread %p)",
707 myHandle, isSoftware() ? "Software bridge between" : "No software bridge",
708 mRecord.const_thread().get(), mPlayback.const_thread().get());
709
710 bool hasSinkDevice =
711 mAudioPatch.num_sinks > 0 && mAudioPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE;
712 bool hasSourceDevice =
713 mAudioPatch.num_sources > 0 && mAudioPatch.sources[0].type == AUDIO_PORT_TYPE_DEVICE;
714 result.appendFormat(" thread %p %s (%d) first device type %08x", mThread.unsafe_get(),
715 hasSinkDevice ? "num sinks" :
716 (hasSourceDevice ? "num sources" : "no devices"),
717 hasSinkDevice ? mAudioPatch.num_sinks :
718 (hasSourceDevice ? mAudioPatch.num_sources : 0),
719 hasSinkDevice ? mAudioPatch.sinks[0].ext.device.type :
720 (hasSourceDevice ? mAudioPatch.sources[0].ext.device.type : 0));
721
722 // add latency if it exists
723 double latencyMs;
724 if (getLatencyMs(&latencyMs) == OK) {
725 result.appendFormat(" latency: %.2lf ms", latencyMs);
726 }
727 return result;
728 }
729
730 /* Disconnect a patch */
releaseAudioPatch(audio_patch_handle_t handle)731 status_t AudioFlinger::PatchPanel::releaseAudioPatch(audio_patch_handle_t handle)
732 {
733 ALOGV("%s handle %d", __func__, handle);
734 status_t status = NO_ERROR;
735
736 auto iter = mPatches.find(handle);
737 if (iter == mPatches.end()) {
738 return BAD_VALUE;
739 }
740 Patch &removedPatch = iter->second;
741 const struct audio_patch &patch = removedPatch.mAudioPatch;
742
743 const struct audio_port_config &src = patch.sources[0];
744 switch (src.type) {
745 case AUDIO_PORT_TYPE_DEVICE: {
746 sp<DeviceHalInterface> hwDevice = findHwDeviceByModule(src.ext.device.hw_module);
747 if (hwDevice == 0) {
748 ALOGW("%s() bad src hw module %d", __func__, src.ext.device.hw_module);
749 status = BAD_VALUE;
750 break;
751 }
752
753 if (removedPatch.isSoftware()) {
754 removedPatch.clearConnections(this);
755 break;
756 }
757
758 if (patch.sinks[0].type == AUDIO_PORT_TYPE_MIX) {
759 audio_io_handle_t ioHandle = patch.sinks[0].ext.mix.handle;
760 sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(ioHandle);
761 if (thread == 0) {
762 thread = mAudioFlinger.checkMmapThread_l(ioHandle);
763 if (thread == 0) {
764 ALOGW("%s() bad capture I/O handle %d", __func__, ioHandle);
765 status = BAD_VALUE;
766 break;
767 }
768 }
769 status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
770 } else {
771 status = hwDevice->releaseAudioPatch(removedPatch.mHalHandle);
772 }
773 } break;
774 case AUDIO_PORT_TYPE_MIX: {
775 if (findHwDeviceByModule(src.ext.mix.hw_module) == 0) {
776 ALOGW("%s() bad src hw module %d", __func__, src.ext.mix.hw_module);
777 status = BAD_VALUE;
778 break;
779 }
780 audio_io_handle_t ioHandle = src.ext.mix.handle;
781 sp<ThreadBase> thread = mAudioFlinger.checkPlaybackThread_l(ioHandle);
782 if (thread == 0) {
783 thread = mAudioFlinger.checkMmapThread_l(ioHandle);
784 if (thread == 0) {
785 ALOGW("%s() bad playback I/O handle %d", __func__, ioHandle);
786 status = BAD_VALUE;
787 break;
788 }
789 }
790 status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
791 } break;
792 default:
793 status = BAD_VALUE;
794 }
795
796 erasePatch(handle);
797 return status;
798 }
799
erasePatch(audio_patch_handle_t handle)800 void AudioFlinger::PatchPanel::erasePatch(audio_patch_handle_t handle) {
801 mPatches.erase(handle);
802 removeSoftwarePatchFromInsertedModules(handle);
803 mAudioFlinger.mDeviceEffectManager.releaseAudioPatch(handle);
804 }
805
806 /* List connected audio ports and they attributes */
listAudioPatches(unsigned int * num_patches __unused,struct audio_patch * patches __unused)807 status_t AudioFlinger::PatchPanel::listAudioPatches(unsigned int *num_patches __unused,
808 struct audio_patch *patches __unused)
809 {
810 ALOGV(__func__);
811 return NO_ERROR;
812 }
813
getDownstreamSoftwarePatches(audio_io_handle_t stream,std::vector<AudioFlinger::PatchPanel::SoftwarePatch> * patches) const814 status_t AudioFlinger::PatchPanel::getDownstreamSoftwarePatches(
815 audio_io_handle_t stream,
816 std::vector<AudioFlinger::PatchPanel::SoftwarePatch> *patches) const
817 {
818 for (const auto& module : mInsertedModules) {
819 if (module.second.streams.count(stream)) {
820 for (const auto& patchHandle : module.second.sw_patches) {
821 const auto& patch_iter = mPatches.find(patchHandle);
822 if (patch_iter != mPatches.end()) {
823 const Patch &patch = patch_iter->second;
824 patches->emplace_back(*this, patchHandle,
825 patch.mPlayback.const_thread()->id(),
826 patch.mRecord.const_thread()->id());
827 } else {
828 ALOGE("Stale patch handle in the cache: %d", patchHandle);
829 }
830 }
831 return OK;
832 }
833 }
834 // The stream is not associated with any of inserted modules.
835 return BAD_VALUE;
836 }
837
notifyStreamOpened(AudioHwDevice * audioHwDevice,audio_io_handle_t stream,struct audio_patch * patch)838 void AudioFlinger::PatchPanel::notifyStreamOpened(
839 AudioHwDevice *audioHwDevice, audio_io_handle_t stream, struct audio_patch *patch)
840 {
841 if (audioHwDevice->isInsert()) {
842 mInsertedModules[audioHwDevice->handle()].streams.insert(stream);
843 if (patch != nullptr) {
844 std::vector <SoftwarePatch> swPatches;
845 getDownstreamSoftwarePatches(stream, &swPatches);
846 if (swPatches.size() > 0) {
847 auto iter = mPatches.find(swPatches[0].getPatchHandle());
848 if (iter != mPatches.end()) {
849 *patch = iter->second.mAudioPatch;
850 }
851 }
852 }
853 }
854 }
855
notifyStreamClosed(audio_io_handle_t stream)856 void AudioFlinger::PatchPanel::notifyStreamClosed(audio_io_handle_t stream)
857 {
858 for (auto& module : mInsertedModules) {
859 module.second.streams.erase(stream);
860 }
861 }
862
findAudioHwDeviceByModule(audio_module_handle_t module)863 AudioHwDevice* AudioFlinger::PatchPanel::findAudioHwDeviceByModule(audio_module_handle_t module)
864 {
865 if (module == AUDIO_MODULE_HANDLE_NONE) return nullptr;
866 ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(module);
867 if (index < 0) {
868 ALOGW("%s() bad hw module %d", __func__, module);
869 return nullptr;
870 }
871 return mAudioFlinger.mAudioHwDevs.valueAt(index);
872 }
873
findHwDeviceByModule(audio_module_handle_t module)874 sp<DeviceHalInterface> AudioFlinger::PatchPanel::findHwDeviceByModule(audio_module_handle_t module)
875 {
876 AudioHwDevice *audioHwDevice = findAudioHwDeviceByModule(module);
877 return audioHwDevice ? audioHwDevice->hwDevice() : nullptr;
878 }
879
addSoftwarePatchToInsertedModules(audio_module_handle_t module,audio_patch_handle_t handle,const struct audio_patch * patch)880 void AudioFlinger::PatchPanel::addSoftwarePatchToInsertedModules(
881 audio_module_handle_t module, audio_patch_handle_t handle,
882 const struct audio_patch *patch)
883 {
884 mInsertedModules[module].sw_patches.insert(handle);
885 if (!mInsertedModules[module].streams.empty()) {
886 mAudioFlinger.updateDownStreamPatches_l(patch, mInsertedModules[module].streams);
887 }
888 }
889
removeSoftwarePatchFromInsertedModules(audio_patch_handle_t handle)890 void AudioFlinger::PatchPanel::removeSoftwarePatchFromInsertedModules(
891 audio_patch_handle_t handle)
892 {
893 for (auto& module : mInsertedModules) {
894 module.second.sw_patches.erase(handle);
895 }
896 }
897
dump(int fd) const898 void AudioFlinger::PatchPanel::dump(int fd) const
899 {
900 String8 patchPanelDump;
901 const char *indent = " ";
902
903 bool headerPrinted = false;
904 for (const auto& iter : mPatches) {
905 if (!headerPrinted) {
906 patchPanelDump += "\nPatches:\n";
907 headerPrinted = true;
908 }
909 patchPanelDump.appendFormat("%s%s\n", indent, iter.second.dump(iter.first).string());
910 }
911
912 headerPrinted = false;
913 for (const auto& module : mInsertedModules) {
914 if (!module.second.streams.empty() || !module.second.sw_patches.empty()) {
915 if (!headerPrinted) {
916 patchPanelDump += "\nTracked inserted modules:\n";
917 headerPrinted = true;
918 }
919 String8 moduleDump = String8::format("Module %d: I/O handles: ", module.first);
920 for (const auto& stream : module.second.streams) {
921 moduleDump.appendFormat("%d ", stream);
922 }
923 moduleDump.append("; SW Patches: ");
924 for (const auto& patch : module.second.sw_patches) {
925 moduleDump.appendFormat("%d ", patch);
926 }
927 patchPanelDump.appendFormat("%s%s\n", indent, moduleDump.string());
928 }
929 }
930
931 if (!patchPanelDump.isEmpty()) {
932 write(fd, patchPanelDump.string(), patchPanelDump.size());
933 }
934 }
935
936 } // namespace android
937