AudioFlinger: Add more Thread interfaces
Add interfaces
IAfDirectOutputThread
IAfDuplicatingThread
IAfRecordThread
Test: atest audiorecord_tests audiotrack_tests audiorouting_tests trackplayerbase_tests audiosystem_tests
Test: atest AudioTrackTest AudioRecordTest
Test: YouTube Camera
Bug: 288339104
Bug: 289233517
Merged-In: Ibd46b7de4c4264294b645d0df2a69825513a1426
Change-Id: Ibd46b7de4c4264294b645d0df2a69825513a1426
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 2b6c848..0a15a43 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -433,8 +433,8 @@
for (const auto& [trackId, secondaryOutputs] : trackSecondaryOutputs) {
size_t i = 0;
for (; i < mPlaybackThreads.size(); ++i) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
- Mutex::Autolock _tl(thread->mLock);
+ IAfPlaybackThread* thread = mPlaybackThreads.valueAt(i).get();
+ Mutex::Autolock _tl(thread->mutex());
sp<IAfTrack> track = thread->getTrackById_l(trackId);
if (track != nullptr) {
ALOGD("%s trackId: %u", __func__, trackId);
@@ -1191,7 +1191,7 @@
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
+ IAfPlaybackThread* thread = checkPlaybackThread_l(output.outputId);
if (thread == NULL) {
ALOGE("no playback thread found for output handle %d", output.outputId);
lStatus = BAD_VALUE;
@@ -1200,14 +1200,14 @@
client = registerPid(clientPid);
- PlaybackThread *effectThread = NULL;
+ IAfPlaybackThread* effectThread = nullptr;
// check if an effect chain with the same session ID is present on another
// output thread and move it here.
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
+ sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
if (mPlaybackThreads.keyAt(i) != output.outputId) {
uint32_t sessions = t->hasAudioSession(sessionId);
- if (sessions & ThreadBase::EFFECT_SESSION) {
+ if (sessions & IAfThreadBase::EFFECT_SESSION) {
effectThread = t.get();
break;
}
@@ -1242,7 +1242,7 @@
if (lStatus == NO_ERROR) {
// no risk of deadlock because AudioFlinger::mLock is held
- Mutex::Autolock _dl(thread->mLock);
+ Mutex::Autolock _dl(thread->mutex());
// Connect secondary outputs. Failure on a secondary output must not imped the primary
// Any secondary output setup failure will lead to a desync between the AP and AF until
// the track is destroyed.
@@ -1250,7 +1250,7 @@
// move effect chain to this output thread if an effect on same session was waiting
// for a track to be created
if (effectThread != nullptr) {
- Mutex::Autolock _sl(effectThread->mLock);
+ Mutex::Autolock _sl(effectThread->mutex());
if (moveEffectChain_l(sessionId, effectThread, thread) == NO_ERROR) {
effectThreadId = thread->id();
effectIds = thread->getEffectIds_l(sessionId);
@@ -1310,7 +1310,7 @@
uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("sampleRate() unknown thread %d", ioHandle);
return 0;
@@ -1321,7 +1321,7 @@
audio_format_t AudioFlinger::format(audio_io_handle_t output) const
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
ALOGW("format() unknown thread %d", output);
return AUDIO_FORMAT_INVALID;
@@ -1332,7 +1332,7 @@
size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("frameCount() unknown thread %d", ioHandle);
return 0;
@@ -1345,7 +1345,7 @@
size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("frameCountHAL() unknown thread %d", ioHandle);
return 0;
@@ -1356,7 +1356,7 @@
uint32_t AudioFlinger::latency(audio_io_handle_t output) const
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
ALOGW("latency(): no playback thread found for output handle %d", output);
return 0;
@@ -1676,7 +1676,7 @@
return BAD_VALUE;
}
AutoMutex lock(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == nullptr) {
return BAD_VALUE;
}
@@ -1689,7 +1689,7 @@
return BAD_VALUE;
}
AutoMutex lock(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == nullptr) {
return BAD_VALUE;
}
@@ -1820,14 +1820,15 @@
// forwardAudioHwSyncToDownstreamPatches_l() must be called with AudioFlinger::mLock held
void AudioFlinger::forwardParametersToDownstreamPatches_l(
audio_io_handle_t upStream, const String8& keyValuePairs,
- const std::function<bool(const sp<PlaybackThread>&)>& useThread)
+ const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread)
{
std::vector<PatchPanel::SoftwarePatch> swPatches;
if (mPatchPanel.getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
ALOGV_IF(!swPatches.empty(), "%s found %zu downstream patches for stream ID %d",
__func__, swPatches.size(), upStream);
for (const auto& swPatch : swPatches) {
- sp<PlaybackThread> downStream = checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
+ const sp<IAfPlaybackThread> downStream =
+ checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
if (downStream != NULL && (useThread == nullptr || useThread(downStream))) {
downStream->setParameters(keyValuePairs);
}
@@ -1839,7 +1840,7 @@
const std::set<audio_io_handle_t>& streams)
{
for (const audio_io_handle_t stream : streams) {
- PlaybackThread *playbackThread = checkPlaybackThread_l(stream);
+ IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(stream);
if (playbackThread == nullptr || !playbackThread->isMsdDevice()) {
continue;
}
@@ -1962,7 +1963,7 @@
// hold a strong ref on thread in case closeOutput() or closeInput() is called
// and the thread is exited once the lock is released
- sp<ThreadBase> thread;
+ sp<IAfThreadBase> thread;
{
Mutex::Autolock _l(mLock);
thread = checkPlaybackThread_l(ioHandle);
@@ -2011,11 +2012,11 @@
return out_s8;
}
- ThreadBase *thread = (ThreadBase *)checkPlaybackThread_l(ioHandle);
+ IAfThreadBase* thread = checkPlaybackThread_l(ioHandle);
if (thread == NULL) {
- thread = (ThreadBase *)checkRecordThread_l(ioHandle);
+ thread = checkRecordThread_l(ioHandle);
if (thread == NULL) {
- thread = (ThreadBase *)checkMmapThread_l(ioHandle);
+ thread = checkMmapThread_l(ioHandle);
if (thread == NULL) {
return String8("");
}
@@ -2111,7 +2112,7 @@
{
Mutex::Autolock _l(mLock);
- RecordThread *recordThread = checkRecordThread_l(ioHandle);
+ IAfRecordThread* const recordThread = checkRecordThread_l(ioHandle);
if (recordThread != NULL) {
return recordThread->getInputFramesLost();
}
@@ -2151,7 +2152,7 @@
{
Mutex::Autolock _l(mLock);
- PlaybackThread *playbackThread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(output);
if (playbackThread != NULL) {
return playbackThread->getRenderPosition(halFrames, dspFrames);
}
@@ -2274,10 +2275,10 @@
}
// getEffectThread_l() must be called with AudioFlinger::mLock held
-sp<AudioFlinger::ThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
+sp<IAfThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
int effectId)
{
- sp<ThreadBase> thread;
+ sp<IAfThreadBase> thread;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
@@ -2480,7 +2481,7 @@
{
Mutex::Autolock _l(mLock);
- RecordThread *thread = checkRecordThread_l(output.inputId);
+ IAfRecordThread* const thread = checkRecordThread_l(output.inputId);
if (thread == NULL) {
ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
lStatus = FAILED_TRANSACTION;
@@ -2536,7 +2537,7 @@
// session and move it to this thread.
sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
if (chain != 0) {
- Mutex::Autolock _l2(thread->mLock);
+ Mutex::Autolock _l2(thread->mutex());
thread->addEffectChain_l(chain);
}
break;
@@ -2738,14 +2739,14 @@
uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = fastPlaybackThread_l();
+ IAfPlaybackThread* const thread = fastPlaybackThread_l();
return thread != NULL ? thread->sampleRate() : 0;
}
size_t AudioFlinger::getPrimaryOutputFrameCount()
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = fastPlaybackThread_l();
+ IAfPlaybackThread* const thread = fastPlaybackThread_l();
return thread != NULL ? thread->frameCountHAL() : 0;
}
@@ -2870,15 +2871,15 @@
mHwAvSyncIds.add(sessionId, value);
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i);
+ const sp<IAfPlaybackThread> thread = mPlaybackThreads.valueAt(i);
uint32_t sessions = thread->hasAudioSession(sessionId);
- if (sessions & ThreadBase::TRACK_SESSION) {
+ if (sessions & IAfThreadBase::TRACK_SESSION) {
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
String8 keyValuePairs = param.toString();
thread->setParameters(keyValuePairs);
forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
- [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
+ [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
break;
}
}
@@ -2897,15 +2898,15 @@
}
mSystemReady = true;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mPlaybackThreads.valueAt(i).get();
thread->systemReady();
}
for (size_t i = 0; i < mRecordThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mRecordThreads.valueAt(i).get();
thread->systemReady();
}
for (size_t i = 0; i < mMmapThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mMmapThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mMmapThreads.valueAt(i).get();
thread->systemReady();
}
@@ -2957,7 +2958,8 @@
}
// setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId)
+void AudioFlinger::setAudioHwSyncForSession_l(
+ IAfPlaybackThread* const thread, audio_session_t sessionId)
{
ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
if (index >= 0) {
@@ -2968,7 +2970,7 @@
String8 keyValuePairs = param.toString();
thread->setParameters(keyValuePairs);
forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
- [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
+ [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
}
}
@@ -2976,7 +2978,7 @@
// ----------------------------------------------------------------------------
-sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
+sp<IAfThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t *halConfig,
audio_config_base_t *mixerConfig,
@@ -3041,7 +3043,7 @@
*output, thread.get());
return thread;
} else {
- sp<PlaybackThread> thread;
+ sp<IAfPlaybackThread> thread;
if (flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) {
thread = sp<BitPerfectThread>::make(this, outputStream, *output, mSystemReady);
ALOGV("%s() created bit-perfect output: ID %d thread %p",
@@ -3116,12 +3118,12 @@
Mutex::Autolock _l(mLock);
- sp<ThreadBase> thread = openOutput_l(module, &output, &halConfig,
+ const sp<IAfThreadBase> thread = openOutput_l(module, &output, &halConfig,
&mixerConfig, deviceType, address, flags);
if (thread != 0) {
uint32_t latencyMs = 0;
if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
- PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
+ const auto playbackThread = thread->asIAfPlaybackThread();
latencyMs = playbackThread->latency();
// notify client processes of the new output creation
@@ -3139,8 +3141,7 @@
mHardwareStatus = AUDIO_HW_IDLE;
}
} else {
- MmapThread *mmapThread = (MmapThread *)thread.get();
- mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
+ thread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
}
response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
response->config = VALUE_OR_RETURN_STATUS(
@@ -3158,8 +3159,8 @@
audio_io_handle_t output2)
{
Mutex::Autolock _l(mLock);
- MixerThread *thread1 = checkMixerThread_l(output1);
- MixerThread *thread2 = checkMixerThread_l(output2);
+ IAfPlaybackThread* const thread1 = checkMixerThread_l(output1);
+ IAfPlaybackThread* const thread2 = checkMixerThread_l(output2);
if (thread1 == NULL || thread2 == NULL) {
ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
@@ -3168,7 +3169,7 @@
}
audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
- DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady);
+ IAfDuplicatingThread* const thread = new DuplicatingThread(this, thread1, id, mSystemReady);
thread->addOutputTrack(thread2);
mPlaybackThreads.add(id, thread);
// notify client processes of the new output creation
@@ -3185,7 +3186,7 @@
{
// keep strong reference on the playback thread so that
// it is not destroyed while exit() is executed
- sp<PlaybackThread> playbackThread;
+ sp<IAfPlaybackThread> playbackThread;
sp<MmapPlaybackThread> mmapThread;
{
Mutex::Autolock _l(mLock);
@@ -3195,12 +3196,12 @@
dumpToThreadLog_l(playbackThread);
- if (playbackThread->type() == ThreadBase::MIXER) {
+ if (playbackThread->type() == IAfThreadBase::MIXER) {
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
- DuplicatingThread *dupThread =
- (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
- dupThread->removeOutputTrack((MixerThread *)playbackThread.get());
+ IAfDuplicatingThread* const dupThread =
+ mPlaybackThreads.valueAt(i)->asIAfDuplicatingThread().get();
+ dupThread->removeOutputTrack(playbackThread.get());
}
}
}
@@ -3209,11 +3210,12 @@
mPlaybackThreads.removeItem(output);
// save all effects to the default thread
if (mPlaybackThreads.size()) {
- PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
+ IAfPlaybackThread* const dstThread =
+ checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
if (dstThread != NULL) {
// audioflinger lock is held so order of thread lock acquisition doesn't matter
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(playbackThread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(playbackThread->mutex());
Vector<sp<IAfEffectChain>> effectChains = playbackThread->getEffectChains_l();
for (size_t i = 0; i < effectChains.size(); i ++) {
moveEffectChain_l(effectChains[i]->sessionId(), playbackThread.get(),
@@ -3234,7 +3236,7 @@
mPatchPanel.notifyStreamClosed(output);
}
// The thread entity (active unit of execution) is no longer running here,
- // but the ThreadBase container still exists.
+ // but the IAfThreadBase container still exists.
if (playbackThread != 0) {
playbackThread->exit();
@@ -3252,7 +3254,7 @@
return NO_ERROR;
}
-void AudioFlinger::closeOutputFinish(const sp<PlaybackThread>& thread)
+void AudioFlinger::closeOutputFinish(const sp<IAfPlaybackThread>& thread)
{
AudioStreamOut *out = thread->clearOutput();
ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
@@ -3260,9 +3262,9 @@
delete out;
}
-void AudioFlinger::closeThreadInternal_l(const sp<PlaybackThread>& thread)
+void AudioFlinger::closeThreadInternal_l(const sp<IAfPlaybackThread>& thread)
{
- mPlaybackThreads.removeItem(thread->mId);
+ mPlaybackThreads.removeItem(thread->id());
thread->exit();
closeOutputFinish(thread);
}
@@ -3270,7 +3272,7 @@
status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
return BAD_VALUE;
@@ -3285,7 +3287,7 @@
status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
return BAD_VALUE;
@@ -3314,7 +3316,7 @@
audio_config_t config = VALUE_OR_RETURN_STATUS(
aidl2legacy_AudioConfig_audio_config_t(request.config, true /*isInput*/));
- sp<ThreadBase> thread = openInput_l(
+ const sp<IAfThreadBase> thread = openInput_l(
VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(request.module)),
&input,
&config,
@@ -3338,7 +3340,7 @@
return NO_INIT;
}
-sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
+sp<IAfThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
audio_io_handle_t *input,
audio_config_t *config,
audio_devices_t devices,
@@ -3412,9 +3414,10 @@
return thread;
} else {
// Start record thread
- // RecordThread requires both input and output device indication to forward to audio
- // pre processing modules
- sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);
+ // IAfRecordThread requires both input and output device indication
+ // to forward to audio pre processing modules
+ const sp<IAfRecordThread> thread =
+ IAfRecordThread::create(this, inputStream, *input, mSystemReady);
mRecordThreads.add(*input, thread);
ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
return thread;
@@ -3434,7 +3437,7 @@
{
// keep strong reference on the record thread so that
// it is not destroyed while exit() is executed
- sp<RecordThread> recordThread;
+ sp<IAfRecordThread> recordThread;
sp<MmapCaptureThread> mmapThread;
{
Mutex::Autolock _l(mLock);
@@ -3450,8 +3453,8 @@
// new capture on the same session
sp<IAfEffectChain> chain;
{
- Mutex::Autolock _sl(recordThread->mLock);
- Vector< sp<IAfEffectChain> > effectChains = recordThread->getEffectChains_l();
+ Mutex::Autolock _sl(recordThread->mutex());
+ const Vector<sp<IAfEffectChain>> effectChains = recordThread->getEffectChains_l();
// Note: maximum one chain per record thread
if (effectChains.size() != 0) {
chain = effectChains[0];
@@ -3463,12 +3466,12 @@
// creation of its replacement
size_t i;
for (i = 0; i < mRecordThreads.size(); i++) {
- sp<RecordThread> t = mRecordThreads.valueAt(i);
+ const sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
if (t == recordThread) {
continue;
}
if (t->hasAudioSession(chain->sessionId()) != 0) {
- Mutex::Autolock _l2(t->mLock);
+ Mutex::Autolock _l2(t->mutex());
ALOGV("closeInput() found thread %d for effect session %d",
t->id(), chain->sessionId());
t->addEffectChain_l(chain);
@@ -3505,7 +3508,7 @@
return NO_ERROR;
}
-void AudioFlinger::closeInputFinish(const sp<RecordThread>& thread)
+void AudioFlinger::closeInputFinish(const sp<IAfRecordThread>& thread)
{
thread->exit();
AudioStreamIn *in = thread->clearInput();
@@ -3514,9 +3517,9 @@
delete in;
}
-void AudioFlinger::closeThreadInternal_l(const sp<RecordThread>& thread)
+void AudioFlinger::closeThreadInternal_l(const sp<IAfRecordThread>& thread)
{
- mRecordThreads.removeItem(thread->mId);
+ mRecordThreads.removeItem(thread->id());
closeInputFinish(thread);
}
@@ -3526,7 +3529,7 @@
std::set<audio_port_handle_t> portIdSet(portIds.begin(), portIds.end());
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
thread->invalidateTracks(portIdSet);
if (portIdSet.empty()) {
return NO_ERROR;
@@ -3646,14 +3649,15 @@
ALOGV("purging stale effects");
- Vector< sp<IAfEffectChain> > chains;
+ Vector<sp<IAfEffectChain>> chains;
std::vector< sp<IAfEffectModule> > removedEffects;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
if (!audio_is_global_session(ec->sessionId())) {
chains.push(ec);
}
@@ -3661,19 +3665,21 @@
}
for (size_t i = 0; i < mRecordThreads.size(); i++) {
- sp<RecordThread> t = mRecordThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
chains.push(ec);
}
}
for (size_t i = 0; i < mMmapThreads.size(); i++) {
sp<MmapThread> t = mMmapThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
chains.push(ec);
}
}
@@ -3682,7 +3688,7 @@
// clang-tidy suggests const ref
sp<IAfEffectChain> ec = chains[i]; // NOLINT(performance-unnecessary-copy-initialization)
int sessionid = ec->sessionId();
- sp<ThreadBase> t = sp<ThreadBase>::cast(ec->thread().promote()); // TODO(b/288339104)
+ const auto t = sp<IAfThreadBase>::cast(ec->thread().promote()); // TODO(b/288339104)
if (t == 0) {
continue;
}
@@ -3698,7 +3704,7 @@
}
}
if (!found) {
- Mutex::Autolock _l(t->mLock);
+ Mutex::Autolock _l(t->mutex());
// remove all effects from the chain
while (ec->numberOfEffects()) {
sp<IAfEffectModule> effect = ec->getEffectModule(0);
@@ -3715,7 +3721,7 @@
}
// dumpToThreadLog_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::dumpToThreadLog_l(const sp<ThreadBase> &thread)
+void AudioFlinger::dumpToThreadLog_l(const sp<IAfThreadBase> &thread)
{
constexpr int THREAD_DUMP_TIMEOUT_MS = 2;
audio_utils::FdToString fdToString("- ", THREAD_DUMP_TIMEOUT_MS);
@@ -3727,9 +3733,9 @@
}
// checkThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
+IAfThreadBase* AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
{
- ThreadBase *thread = checkMmapThread_l(ioHandle);
+ IAfThreadBase* thread = checkMmapThread_l(ioHandle);
if (thread == 0) {
switch (audio_unique_id_get_use(ioHandle)) {
case AUDIO_UNIQUE_ID_USE_OUTPUT:
@@ -3746,13 +3752,13 @@
}
// checkOutputThread_l() must be called with AudioFlinger::mLock held
-sp<AudioFlinger::ThreadBase> AudioFlinger::checkOutputThread_l(audio_io_handle_t ioHandle) const
+sp<IAfThreadBase> AudioFlinger::checkOutputThread_l(audio_io_handle_t ioHandle) const
{
if (audio_unique_id_get_use(ioHandle) != AUDIO_UNIQUE_ID_USE_OUTPUT) {
return nullptr;
}
- sp<AudioFlinger::ThreadBase> thread = mPlaybackThreads.valueFor(ioHandle);
+ sp<IAfThreadBase> thread = mPlaybackThreads.valueFor(ioHandle);
if (thread == nullptr) {
thread = mMmapThreads.valueFor(ioHandle);
}
@@ -3760,20 +3766,20 @@
}
// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
+IAfPlaybackThread* AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
{
return mPlaybackThreads.valueFor(output).get();
}
// checkMixerThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
+IAfPlaybackThread* AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
{
- PlaybackThread *thread = checkPlaybackThread_l(output);
- return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
+ IAfPlaybackThread * const thread = checkPlaybackThread_l(output);
+ return thread != nullptr && thread->type() != IAfThreadBase::DIRECT ? thread : nullptr;
}
// checkRecordThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
+IAfRecordThread* AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
{
return mRecordThreads.valueFor(input).get();
}
@@ -3839,14 +3845,14 @@
// TODO Use a floor after wraparound. This may need a mutex.
}
-AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
+IAfPlaybackThread* AudioFlinger::primaryPlaybackThread_l() const
{
AutoMutex lock(mHardwareLock);
if (mPrimaryHardwareDev == nullptr) {
return nullptr;
}
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if(thread->isDuplicating()) {
continue;
}
@@ -3860,7 +3866,7 @@
DeviceTypeSet AudioFlinger::primaryOutputDevice_l() const
{
- PlaybackThread *thread = primaryPlaybackThread_l();
+ IAfPlaybackThread* const thread = primaryPlaybackThread_l();
if (thread == NULL) {
return {};
@@ -3869,12 +3875,12 @@
return thread->outDeviceTypes();
}
-AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const
+IAfPlaybackThread* AudioFlinger::fastPlaybackThread_l() const
{
size_t minFrameCount = 0;
- PlaybackThread *minThread = NULL;
+ IAfPlaybackThread* minThread = nullptr;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if (!thread->isDuplicating()) {
size_t frameCount = thread->frameCountHAL();
if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
@@ -3888,9 +3894,9 @@
return minThread;
}
-AudioFlinger::ThreadBase *AudioFlinger::hapticPlaybackThread_l() const {
+IAfThreadBase* AudioFlinger::hapticPlaybackThread_l() const {
for (size_t i = 0; i < mPlaybackThreads.size(); ++i) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if (thread->hapticChannelMask() != AUDIO_CHANNEL_NONE) {
return thread;
}
@@ -3900,11 +3906,11 @@
void AudioFlinger::updateSecondaryOutputsForTrack_l(
IAfTrack* track,
- PlaybackThread* thread,
+ IAfPlaybackThread* thread,
const std::vector<audio_io_handle_t> &secondaryOutputs) const {
TeePatches teePatches;
for (audio_io_handle_t secondaryOutput : secondaryOutputs) {
- PlaybackThread *secondaryThread = checkPlaybackThread_l(secondaryOutput);
+ IAfPlaybackThread* const secondaryThread = checkPlaybackThread_l(secondaryOutput);
if (secondaryThread == nullptr) {
ALOGE("no playback thread found for secondary output %d", thread->id());
continue;
@@ -3930,10 +3936,10 @@
// The frameCount should also not be smaller than the secondary thread min frame
// count
size_t minFrameCount = AudioSystem::calculateMinFrameCount(
- [&] { Mutex::Autolock _l(secondaryThread->mLock);
+ [&] { Mutex::Autolock _l(secondaryThread->mutex());
return secondaryThread->latency_l(); }(),
- secondaryThread->mNormalFrameCount,
- secondaryThread->mSampleRate,
+ secondaryThread->frameCount(), // normal frame count
+ secondaryThread->sampleRate(),
track->sampleRate(),
track->getSpeed());
frameCount = std::max(frameCount, minFrameCount);
@@ -4182,7 +4188,7 @@
lStatus = BAD_VALUE;
goto Exit;
}
- PlaybackThread *thread = checkPlaybackThread_l(io);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(io);
if (thread == nullptr) {
ALOGE("%s: invalid output %d specified for AUDIO_SESSION_OUTPUT_STAGE", __func__, io);
lStatus = BAD_VALUE;
@@ -4351,7 +4357,7 @@
}
const uint32_t sessionType =
mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId);
- if ((sessionType & ThreadBase::EFFECT_SESSION) != 0) {
+ if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) {
ALOGE("%s: effect %s io %d denied because session %d effect exists on io %d",
__func__, descOut.name, (int) io, (int) sessionId, (int) checkIo);
android_errorWriteLog(0x534e4554, "123237974");
@@ -4360,7 +4366,7 @@
}
}
}
- ThreadBase *thread = checkRecordThread_l(io);
+ IAfThreadBase* thread = checkRecordThread_l(io);
if (thread == NULL) {
thread = checkPlaybackThread_l(io);
if (thread == NULL) {
@@ -4376,7 +4382,7 @@
// session and used it instead of creating a new one.
sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
if (chain != 0) {
- Mutex::Autolock _l2(thread->mLock);
+ Mutex::Autolock _l2(thread->mutex());
thread->addEffectChain_l(chain);
}
}
@@ -4385,9 +4391,9 @@
// create effect on selected output thread
bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
- ThreadBase *oriThread = nullptr;
+ IAfThreadBase* oriThread = nullptr;
if (hapticPlaybackRequired && thread->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
- ThreadBase *hapticThread = hapticPlaybackThread_l();
+ IAfThreadBase* const hapticThread = hapticPlaybackThread_l();
if (hapticThread == nullptr) {
ALOGE("%s haptic thread not found while it is required", __func__);
lStatus = INVALID_OPERATION;
@@ -4450,26 +4456,26 @@
status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput,
audio_io_handle_t dstOutput)
{
- ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
- sessionId, srcOutput, dstOutput);
+ ALOGV("%s() session %d, srcOutput %d, dstOutput %d",
+ __func__, sessionId, srcOutput, dstOutput);
Mutex::Autolock _l(mLock);
if (srcOutput == dstOutput) {
- ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
+ ALOGW("%s() same dst and src outputs %d", __func__, dstOutput);
return NO_ERROR;
}
- PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
- if (srcThread == NULL) {
- ALOGW("moveEffects() bad srcOutput %d", srcOutput);
+ IAfPlaybackThread* const srcThread = checkPlaybackThread_l(srcOutput);
+ if (srcThread == nullptr) {
+ ALOGW("%s() bad srcOutput %d", __func__, srcOutput);
return BAD_VALUE;
}
- PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
- if (dstThread == NULL) {
- ALOGW("moveEffects() bad dstOutput %d", dstOutput);
+ IAfPlaybackThread* const dstThread = checkPlaybackThread_l(dstOutput);
+ if (dstThread == nullptr) {
+ ALOGW("%s() bad dstOutput %d", __func__, dstOutput);
return BAD_VALUE;
}
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(srcThread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(srcThread->mutex());
return moveEffectChain_l(sessionId, srcThread, dstThread);
}
@@ -4480,11 +4486,11 @@
{
Mutex::Autolock _l(mLock);
- sp<ThreadBase> thread = getEffectThread_l(sessionId, effectId);
+ sp<IAfThreadBase> thread = getEffectThread_l(sessionId, effectId);
if (thread == nullptr) {
return;
}
- Mutex::Autolock _sl(thread->mLock);
+ Mutex::Autolock _sl(thread->mutex());
sp<IAfEffectModule> effect = thread->getEffect_l(sessionId, effectId);
thread->setEffectSuspended_l(&effect->desc().type, suspended, sessionId);
}
@@ -4492,8 +4498,7 @@
// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
- AudioFlinger::PlaybackThread *srcThread,
- AudioFlinger::PlaybackThread *dstThread)
+ IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread)
NO_THREAD_SAFETY_ANALYSIS // requires srcThread and dstThread locks
{
ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
@@ -4603,17 +4608,16 @@
}
status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
- const sp<PlaybackThread>& dstThread,
- sp<PlaybackThread> *srcThread)
+ const sp<IAfPlaybackThread>& dstThread, sp<IAfPlaybackThread>* srcThread)
{
status_t status = NO_ERROR;
Mutex::Autolock _l(mLock);
- sp<PlaybackThread> thread =
- static_cast<PlaybackThread *>(getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId).get());
+ const sp<IAfThreadBase> threadBase = getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
+ const sp<IAfPlaybackThread> thread = threadBase ? threadBase->asIAfPlaybackThread() : nullptr;
if (EffectId != 0 && thread != 0 && dstThread != thread.get()) {
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(thread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(thread->mutex());
sp<IAfEffectChain> srcChain = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
sp<IAfEffectChain> dstChain;
if (srcChain == 0) {
@@ -4677,8 +4681,8 @@
mGlobalEffectEnableTime = systemTime();
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
- if (t->mType == ThreadBase::OFFLOAD) {
+ const sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
+ if (t->type() == IAfThreadBase::OFFLOAD) {
t->invalidateTracks(AUDIO_STREAM_MUSIC);
}
}