Merge "Revert "Revert "Audio effects: define interface between EffectModule and audio framework""" (4d9eec5c) · Commits · e / os / android_frameworks_av

services/audioflinger/AudioFlinger.cpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -2971,7 +2971,7 @@ std::vector<sp<AudioFlinger::EffectModule>> AudioFlinger::purgeStaleEffects_l()
		for (size_t i = 0; i < chains.size(); i++) {
		sp<EffectChain> ec = chains[i];
		int sessionid = ec->sessionId();
		sp<ThreadBase> t = ec->mThread.promote();
		sp<ThreadBase> t = ec->thread().promote();
		if (t == 0) {
		continue;
		}
		@@ -2994,7 +2994,7 @@ std::vector<sp<AudioFlinger::EffectModule>> AudioFlinger::purgeStaleEffects_l()
		effect->unPin();
		t->removeEffect_l(effect, /release/ true);
		if (effect->purgeHandles()) {
		t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId());
		effect->checkSuspendOnEffectEnabled(false, true /threadLocked/);
		}
		removedEffects.push_back(effect);
		}
		@@ -3617,7 +3617,7 @@ status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
		// if the move request is not received from audio policy manager, the effect must be
		// re-registered with the new strategy and output
		if (dstChain == 0) {
		dstChain = effect->chain().promote();
		dstChain = effect->callback()->chain().promote();
		if (dstChain == 0) {
		ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get());
		status = NO_INIT;
		@@ -3667,7 +3667,7 @@ status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
		goto Exit;
		}

		dstChain = effect->chain().promote();
		dstChain = effect->callback()->chain().promote();
		if (dstChain == 0) {
		thread->addEffect_l(effect);
		status = INVALID_OPERATION;

services/audioflinger/Effects.cpp

+303 −170

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/Effects.h

+112 −19

Original line number	Diff line number	Diff line
		@@ -21,11 +21,60 @@

		//--- Audio Effect Management

		// Interface implemented by the EffectModule parent or owner (e.g an EffectChain) to abstract
		// interactions between the EffectModule and the reset of the audio framework.
		class EffectCallbackInterface : public RefBase {
		public:
		~EffectCallbackInterface() override = default;

		// Trivial methods usually implemented with help from ThreadBase
		virtual audio_io_handle_t io() const = 0;
		virtual bool isOutput() const = 0;
		virtual bool isOffload() const = 0;
		virtual bool isOffloadOrDirect() const = 0;
		virtual bool isOffloadOrMmap() const = 0;
		virtual uint32_t sampleRate() const = 0;
		virtual audio_channel_mask_t channelMask() const = 0;
		virtual uint32_t channelCount() const = 0;
		virtual size_t frameCount() const = 0;

		// Non trivial methods usually implemented with help from ThreadBase:
		// pay attention to mutex locking order
		virtual uint32_t latency() const { return 0; }
		virtual status_t addEffectToHal(sp<EffectHalInterface> effect) = 0;
		virtual status_t removeEffectFromHal(sp<EffectHalInterface> effect) = 0;
		virtual void setVolumeForOutput(float left, float right) const = 0;
		virtual bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) = 0;
		virtual void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
		bool enabled,
		bool threadLocked) = 0;
		virtual void onEffectEnable(const sp<EffectModule>& effect) = 0;
		virtual void onEffectDisable(const sp<EffectModule>& effect) = 0;

		// Methods usually implemented with help from AudioFlinger: pay attention to mutex locking order
		virtual status_t createEffectHal(const effect_uuid_t *pEffectUuid,
		int32_t sessionId, int32_t deviceId, sp<EffectHalInterface> *effect) = 0;
		virtual status_t allocateHalBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) = 0;
		virtual bool updateOrphanEffectChains(const sp<EffectModule>& effect) = 0;

		// Methods usually implemented with help from EffectChain: pay attention to mutex locking order
		virtual uint32_t strategy() const = 0;
		virtual int32_t activeTrackCnt() const = 0;
		virtual void resetVolume() = 0;

		virtual wp<EffectChain> chain() const = 0;
		};

		// EffectModule and EffectChain classes both have their own mutex to protect
		// state changes or resource modifications. Always respect the following order
		// if multiple mutexes must be acquired to avoid cross deadlock:
		// AudioFlinger -> ThreadBase -> EffectChain -> EffectModule
		// AudioHandle -> ThreadBase -> EffectChain -> EffectModule

		// NOTE: When implementing the EffectCallbackInterface, in an EffectChain or other, it is important
		// to pay attention to this locking order as some callback methods can be called from a state where
		// EffectModule and/or EffectChain mutexes are held.

		// In addition, methods that lock the AudioPolicyService mutex (getOutputForEffect(),
		// startOutput(), getInputForAttr(), releaseInput()...) should never be called with AudioFlinger or
		// Threadbase mutex locked to avoid cross deadlock with other clients calling AudioPolicyService
		@@ -42,8 +91,7 @@
		// the attached track(s) to accumulate their auxiliary channel.
		class EffectModule : public RefBase {
		public:
		EffectModule(ThreadBase *thread,
		const wp<AudioFlinger::EffectChain>& chain,
		EffectModule(const sp<EffectCallbackInterface>& chain,
		effect_descriptor_t *desc,
		int id,
		audio_session_t sessionId,
		@@ -81,7 +129,7 @@ public:
		audio_session_t sessionId() const {
		return mSessionId;
		}
		status_t setEnabled(bool enabled);
		status_t setEnabled(bool enabled, bool fromHandle);
		status_t setEnabled_l(bool enabled);
		bool isEnabled() const;
		bool isProcessEnabled() const;
		@@ -96,10 +144,7 @@ public:
		int16_t *outBuffer() const {
		return mOutBuffer != 0 ? reinterpret_cast<int16_t*>(mOutBuffer->ptr()) : NULL;
		}
		void setChain(const wp<EffectChain>& chain) { mChain = chain; }
		void setThread(const wp<ThreadBase>& thread)
		{ mThread = thread; mThreadType = thread.promote()->type(); }
		const wp<ThreadBase>& thread() { return mThread; }
		void setCallback(const sp<EffectCallbackInterface>& callback) { mCallback = callback; }

		status_t addHandle(EffectHandle *handle);
		ssize_t disconnectHandle(EffectHandle *handle, bool unpinIfLast);
		@@ -107,7 +152,7 @@ public:
		ssize_t removeHandle_l(EffectHandle *handle);

		const effect_descriptor_t& desc() const { return mDescriptor; }
		wp<EffectChain>& chain() { return mChain; }
		sp<EffectCallbackInterface>& callback() { return mCallback; }

		status_t setDevices(const AudioDeviceTypeAddrVector &devices);
		status_t setInputDevice(const AudioDeviceTypeAddr &device);
		@@ -144,6 +189,7 @@ public:
		void release_l();

		status_t updatePolicyState();
		void checkSuspendOnEffectEnabled(bool enabled, bool threadLocked);

		void dump(int fd, const Vector<String16>& args);

		@@ -158,13 +204,11 @@ private:

		status_t start_l();
		status_t stop_l();
		status_t remove_effect_from_hal_l();
		status_t removeEffectFromHal_l();
		status_t sendSetAudioDevicesCommand(const AudioDeviceTypeAddrVector &devices, uint32_t cmdCode);

		mutable Mutex mLock; // mutex for process, commands and handles list protection
		wp<ThreadBase> mThread; // parent thread
		ThreadBase::type_t mThreadType; // parent thread type
		wp<EffectChain> mChain; // parent effect chain
		sp<EffectCallbackInterface> mCallback; // parent effect chain
		const int mId; // this instance unique ID
		const audio_session_t mSessionId; // audio session ID
		const effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
		@@ -181,7 +225,6 @@ mutable Mutex mLock; // mutex for process, commands and handl
		uint32_t mDisableWaitCnt; // current process() calls count during disable period.
		bool mSuspended; // effect is suspended: temporarily disabled by framework
		bool mOffloaded; // effect is currently offloaded to the audio DSP
		wp<AudioFlinger> mAudioFlinger;

		#ifdef FLOAT_EFFECT_CHAIN
		bool mSupportsFloat; // effect supports float processing
		@@ -333,7 +376,6 @@ public:
		}

		status_t createEffect_l(sp<EffectModule>& effect,
		ThreadBase *thread,
		effect_descriptor_t *desc,
		int id,
		audio_session_t sessionId,
		@@ -389,9 +431,8 @@ public:
		bool suspend);
		// suspend all eligible effects
		void setEffectSuspendedAll_l(bool suspend);
		// check if effects should be suspend or restored when a given effect is enable or disabled
		void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
		bool enabled);
		// check if effects should be suspended or restored when a given effect is enable or disabled
		void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, bool enabled);

		void clearInputBuffer();

		@@ -416,9 +457,60 @@ public:
		// isCompatibleWithThread_l() must be called with thread->mLock held
		bool isCompatibleWithThread_l(const sp<ThreadBase>& thread) const;

		sp<EffectCallbackInterface> effectCallback() const { return mEffectCallback; }
		wp<ThreadBase> thread() const { return mEffectCallback->thread(); }

		void dump(int fd, const Vector<String16>& args);

		private:

		class EffectCallback : public EffectCallbackInterface {
		public:
		EffectCallback(EffectChain chain, ThreadBase thread, AudioFlinger *audioFlinger)
		: mChain(chain), mThread(thread), mAudioFlinger(audioFlinger) {}

		status_t createEffectHal(const effect_uuid_t *pEffectUuid,
		int32_t sessionId, int32_t deviceId, sp<EffectHalInterface> *effect) override;
		status_t allocateHalBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) override;
		bool updateOrphanEffectChains(const sp<EffectModule>& effect) override;

		audio_io_handle_t io() const override;
		bool isOutput() const override;
		bool isOffload() const override;
		bool isOffloadOrDirect() const override;
		bool isOffloadOrMmap() const override;

		uint32_t sampleRate() const override;
		audio_channel_mask_t channelMask() const override;
		uint32_t channelCount() const override;
		size_t frameCount() const override;
		uint32_t latency() const override;

		status_t addEffectToHal(sp<EffectHalInterface> effect) override;
		status_t removeEffectFromHal(sp<EffectHalInterface> effect) override;
		bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) override;
		void setVolumeForOutput(float left, float right) const override;

		// check if effects should be suspended/restored when a given effect is enable/disabled
		void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
		bool enabled, bool threadLocked) override;
		void resetVolume() override;
		uint32_t strategy() const override;
		int32_t activeTrackCnt() const override;
		void onEffectEnable(const sp<EffectModule>& effect) override;
		void onEffectDisable(const sp<EffectModule>& effect) override;

		wp<EffectChain> chain() const override { return mChain; }

		wp<ThreadBase> thread() { return mThread; }
		void setThread(ThreadBase *thread) { mThread = thread; };

		private:
		wp<EffectChain> mChain;
		wp<ThreadBase> mThread;
		wp<AudioFlinger> mAudioFlinger;
		};

		friend class AudioFlinger; // for mThread, mEffects
		DISALLOW_COPY_AND_ASSIGN(EffectChain);

		@@ -444,13 +536,12 @@ private:

		static bool isEffectEligibleForBtNrecSuspend(const effect_uuid_t *type);

		void clearInputBuffer_l(const sp<ThreadBase>& thread);
		void clearInputBuffer_l();

		void setThread(const sp<ThreadBase>& thread);

		void setVolumeForOutput_l(uint32_t left, uint32_t right);

		wp<ThreadBase> mThread; // parent mixer thread
		mutable Mutex mLock; // mutex protecting effect list
		Vector< sp<EffectModule> > mEffects; // list of effect modules
		audio_session_t mSessionId; // audio session ID
		@@ -474,4 +565,6 @@ private:
		// timeLow fields among effect type UUIDs.
		// Updated by setEffectSuspended_l() and setEffectSuspendedAll_l() only.
		KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects;

		const sp<EffectCallback> mEffectCallback;
		};

services/audioflinger/Threads.cpp

+35 −18

Original line number	Diff line number	Diff line
		@@ -1146,18 +1146,13 @@ void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *ty
		}
		}

		void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
		bool enabled,
		audio_session_t sessionId)
		{
		Mutex::Autolock _l(mLock);
		checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
		void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
		audio_session_t sessionId,
		bool threadLocked) {
		if (!threadLocked) {
		mLock.lock();
		}

		void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
		bool enabled,
		audio_session_t sessionId)
		{
		if (mType != RECORD) {
		// suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
		// another session. This gives the priority to well behaved effect control panels
		@@ -1169,9 +1164,8 @@ void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModu
		}
		}

		sp<EffectChain> chain = getEffectChain_l(sessionId);
		if (chain != 0) {
		chain->checkSuspendOnEffectEnabled(effect, enabled);
		if (!threadLocked) {
		mLock.unlock();
		}
		}

		@@ -1379,7 +1373,7 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
		if (effect == 0) {
		effectId = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
		// create a new effect module if none present in the chain
		lStatus = chain->createEffect_l(effect, this, desc, effectId, sessionId, pinned);
		lStatus = chain->createEffect_l(effect, desc, effectId, sessionId, pinned);
		if (lStatus != NO_ERROR) {
		goto Exit;
		}
		@@ -1427,7 +1421,7 @@ void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
		Mutex::Autolock _l(mLock);

		effect = handle->effect().promote();
		if (effect == 0) {
		if (effect == nullptr) {
		return;
		}
		// restore suspended effects if the disconnected handle was enabled and the last one.
		@@ -1439,9 +1433,32 @@ void AudioFlinger::ThreadBase::disconnectEffectHandle(EffectHandle *handle,
		if (remove) {
		mAudioFlinger->updateOrphanEffectChains(effect);
		if (handle->enabled()) {
		checkSuspendOnEffectEnabled(effect, false, effect->sessionId());
		effect->checkSuspendOnEffectEnabled(false, false /threadLocked/);
		}
		}
		}

		void AudioFlinger::ThreadBase::onEffectEnable(const sp<EffectModule>& effect) {
		if (mType == OFFLOAD \|\| mType == MMAP) {
		Mutex::Autolock _l(mLock);
		broadcast_l();
		}
		if (!effect->isOffloadable()) {
		if (mType == ThreadBase::OFFLOAD) {
		PlaybackThread t = (PlaybackThread )this;
		t->invalidateTracks(AUDIO_STREAM_MUSIC);
		}
		if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) {
		mAudioFlinger->onNonOffloadableGlobalEffectEnable();
		}
		}
		}

		void AudioFlinger::ThreadBase::onEffectDisable() {
		if (mType == OFFLOAD \|\| mType == MMAP) {
		Mutex::Autolock _l(mLock);
		broadcast_l();
		}
		}

		sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
		@@ -1519,7 +1536,7 @@ void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect, bo
		detachAuxEffect_l(effect->id());
		}

		sp<EffectChain> chain = effect->chain().promote();
		sp<EffectChain> chain = effect->callback()->chain().promote();
		if (chain != 0) {
		// remove effect chain if removing last effect
		if (chain->removeEffect_l(effect, release) == 0) {

services/audioflinger/Threads.h

+10 −10

Original line number	Diff line number	Diff line
		@@ -271,6 +271,8 @@ public:
		// Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
		// and returns the [normal mix] buffer's frame count.
		virtual size_t frameCount() const = 0;
		virtual uint32_t latency_l() const { return 0; }
		virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}

		// Return's the HAL's frame count i.e. fast mixer buffer size.
		size_t frameCountHAL() const { return mFrameCount; }
		@@ -424,14 +426,9 @@ public:

		// check if some effects must be suspended/restored when an effect is enabled
		// or disabled
		void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
		bool enabled,
		audio_session_t sessionId =
		AUDIO_SESSION_OUTPUT_MIX);
		void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
		bool enabled,
		audio_session_t sessionId =
		AUDIO_SESSION_OUTPUT_MIX);
		void checkSuspendOnEffectEnabled(bool enabled,
		audio_session_t sessionId,
		bool threadLocked);

		virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0;
		virtual bool isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
		@@ -465,6 +462,9 @@ public:

		mutable Mutex mLock;

		void onEffectEnable(const sp<EffectModule>& effect);
		void onEffectDisable();

		protected:

		// entry describing an effect being suspended in mSuspendedSessions keyed vector
		@@ -814,7 +814,7 @@ public:
		// return estimated latency in milliseconds, as reported by HAL
		uint32_t latency() const;
		// same, but lock must already be held
		uint32_t latency_l() const;
		uint32_t latency_l() const override;

		// VolumeInterface
		virtual void setMasterVolume(float value);
		@@ -824,7 +824,7 @@ public:
		virtual void setStreamMute(audio_stream_type_t stream, bool muted);
		virtual float streamVolume(audio_stream_type_t stream) const;

		void setVolumeForOutput_l(float left, float right) const;
		void setVolumeForOutput_l(float left, float right) const override;

		sp<Track> createTrack_l(
		const sp<AudioFlinger::Client>& client,