blob: 42614cc02b0abdb6d597dae8ae4045d7e5558201 [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, 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#ifndef INCLUDING_FROM_AUDIOFLINGER_H
19 #error This header file should only be included from AudioFlinger.h
20#endif
21
22//--- Audio Effect Management
23
Eric Laurent6b446ce2019-12-13 10:56:31 -080024// Interface implemented by the EffectModule parent or owner (e.g an EffectChain) to abstract
25// interactions between the EffectModule and the reset of the audio framework.
26class EffectCallbackInterface : public RefBase {
27public:
28 ~EffectCallbackInterface() override = default;
29
30 // Trivial methods usually implemented with help from ThreadBase
31 virtual audio_io_handle_t io() const = 0;
32 virtual bool isOutput() const = 0;
33 virtual bool isOffload() const = 0;
34 virtual bool isOffloadOrDirect() const = 0;
35 virtual bool isOffloadOrMmap() const = 0;
Eric Laurent0dccd2e2021-10-26 17:40:18 +020036 virtual bool isSpatializer() const = 0;
Eric Laurentb82e6b72019-11-22 17:25:04 -080037 virtual uint32_t sampleRate() const = 0;
Eric Laurentf1f22e72021-07-13 14:04:14 +020038 virtual audio_channel_mask_t inChannelMask(int id) const = 0;
39 virtual uint32_t inChannelCount(int id) const = 0;
40 virtual audio_channel_mask_t outChannelMask() const = 0;
41 virtual uint32_t outChannelCount() const = 0;
jiabineb3bda02020-06-30 14:07:03 -070042 virtual audio_channel_mask_t hapticChannelMask() const = 0;
Eric Laurent6b446ce2019-12-13 10:56:31 -080043 virtual size_t frameCount() const = 0;
44
45 // Non trivial methods usually implemented with help from ThreadBase:
46 // pay attention to mutex locking order
47 virtual uint32_t latency() const { return 0; }
48 virtual status_t addEffectToHal(sp<EffectHalInterface> effect) = 0;
49 virtual status_t removeEffectFromHal(sp<EffectHalInterface> effect) = 0;
50 virtual void setVolumeForOutput(float left, float right) const = 0;
51 virtual bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) = 0;
Eric Laurent41709552019-12-16 19:34:05 -080052 virtual void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect,
Eric Laurent6b446ce2019-12-13 10:56:31 -080053 bool enabled,
54 bool threadLocked) = 0;
Eric Laurent41709552019-12-16 19:34:05 -080055 virtual void onEffectEnable(const sp<EffectBase>& effect) = 0;
56 virtual void onEffectDisable(const sp<EffectBase>& effect) = 0;
Eric Laurent6b446ce2019-12-13 10:56:31 -080057
58 // Methods usually implemented with help from AudioFlinger: pay attention to mutex locking order
59 virtual status_t createEffectHal(const effect_uuid_t *pEffectUuid,
60 int32_t sessionId, int32_t deviceId, sp<EffectHalInterface> *effect) = 0;
61 virtual status_t allocateHalBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) = 0;
Eric Laurent41709552019-12-16 19:34:05 -080062 virtual bool updateOrphanEffectChains(const sp<EffectBase>& effect) = 0;
Eric Laurent6b446ce2019-12-13 10:56:31 -080063
64 // Methods usually implemented with help from EffectChain: pay attention to mutex locking order
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080065 virtual product_strategy_t strategy() const = 0;
Eric Laurent6b446ce2019-12-13 10:56:31 -080066 virtual int32_t activeTrackCnt() const = 0;
67 virtual void resetVolume() = 0;
68
69 virtual wp<EffectChain> chain() const = 0;
Eric Laurentd66d7a12021-07-13 13:35:32 +020070
71 virtual bool isAudioPolicyReady() const = 0;
Eric Laurent6b446ce2019-12-13 10:56:31 -080072};
73
Eric Laurent41709552019-12-16 19:34:05 -080074// EffectBase(EffectModule) and EffectChain classes both have their own mutex to protect
Eric Laurent81784c32012-11-19 14:55:58 -080075// state changes or resource modifications. Always respect the following order
76// if multiple mutexes must be acquired to avoid cross deadlock:
Eric Laurent41709552019-12-16 19:34:05 -080077// AudioFlinger -> ThreadBase -> EffectChain -> EffectBase(EffectModule)
78// AudioHandle -> ThreadBase -> EffectChain -> EffectBase(EffectModule)
Eric Laurent6b446ce2019-12-13 10:56:31 -080079
80// NOTE: When implementing the EffectCallbackInterface, in an EffectChain or other, it is important
81// to pay attention to this locking order as some callback methods can be called from a state where
82// EffectModule and/or EffectChain mutexes are held.
83
Eric Laurenteb3c3372013-09-25 12:25:29 -070084// In addition, methods that lock the AudioPolicyService mutex (getOutputForEffect(),
Eric Laurent3bc859b2016-12-05 11:07:22 -080085// startOutput(), getInputForAttr(), releaseInput()...) should never be called with AudioFlinger or
86// Threadbase mutex locked to avoid cross deadlock with other clients calling AudioPolicyService
87// methods that in turn call AudioFlinger thus locking the same mutexes in the reverse order.
Eric Laurent81784c32012-11-19 14:55:58 -080088
Eric Laurent41709552019-12-16 19:34:05 -080089
90// The EffectBase class contains common properties, state and behavior for and EffectModule or
91// other derived classes managing an audio effect instance within the effect framework.
92// It also contains the class mutex (see comment on locking order above).
93class EffectBase : public RefBase {
Eric Laurent81784c32012-11-19 14:55:58 -080094public:
Eric Laurent41709552019-12-16 19:34:05 -080095 EffectBase(const sp<EffectCallbackInterface>& callback,
96 effect_descriptor_t *desc,
97 int id,
98 audio_session_t sessionId,
99 bool pinned);
100
101 ~EffectBase() override = default;
Eric Laurent81784c32012-11-19 14:55:58 -0800102
103 enum effect_state {
104 IDLE,
105 RESTART,
106 STARTING,
107 ACTIVE,
108 STOPPING,
109 STOPPED,
110 DESTROYED
111 };
112
Eric Laurent41709552019-12-16 19:34:05 -0800113 int id() const { return mId; }
Eric Laurent81784c32012-11-19 14:55:58 -0800114 effect_state state() const {
115 return mState;
116 }
Glenn Kastend848eb42016-03-08 13:42:11 -0800117 audio_session_t sessionId() const {
Eric Laurent81784c32012-11-19 14:55:58 -0800118 return mSessionId;
119 }
Eric Laurent81784c32012-11-19 14:55:58 -0800120 const effect_descriptor_t& desc() const { return mDescriptor; }
Eric Laurent5baf2af2013-09-12 17:37:00 -0700121 bool isOffloadable() const
122 { return (mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0; }
Eric Laurent4c415062016-06-17 16:14:16 -0700123 bool isImplementationSoftware() const
124 { return (mDescriptor.flags & EFFECT_FLAG_HW_ACC_MASK) == 0; }
Eric Laurent6dd0fd92016-09-15 12:44:53 -0700125 bool isProcessImplemented() const
126 { return (mDescriptor.flags & EFFECT_FLAG_NO_PROCESS) == 0; }
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900127 bool isVolumeControl() const
128 { return (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK)
129 == EFFECT_FLAG_VOLUME_CTRL; }
Jasmine Cha934ecfb2019-01-23 18:19:14 +0800130 bool isVolumeMonitor() const
131 { return (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK)
132 == EFFECT_FLAG_VOLUME_MONITOR; }
Eric Laurent41709552019-12-16 19:34:05 -0800133
134 virtual status_t setEnabled(bool enabled, bool fromHandle);
135 status_t setEnabled_l(bool enabled);
136 bool isEnabled() const;
137
138 void setSuspended(bool suspended);
139 bool suspended() const;
140
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700141 virtual status_t command(int32_t __unused,
142 const std::vector<uint8_t>& __unused,
143 int32_t __unused,
144 std::vector<uint8_t>* __unused) { return NO_ERROR; };
Eric Laurent41709552019-12-16 19:34:05 -0800145
Andy Hungfda44002021-06-03 17:23:16 -0700146 // mCallback is atomic so this can be lock-free.
Eric Laurent41709552019-12-16 19:34:05 -0800147 void setCallback(const sp<EffectCallbackInterface>& callback) { mCallback = callback; }
Andy Hungfda44002021-06-03 17:23:16 -0700148 sp<EffectCallbackInterface> getCallback() const { return mCallback.load(); }
Eric Laurent41709552019-12-16 19:34:05 -0800149
150 status_t addHandle(EffectHandle *handle);
151 ssize_t disconnectHandle(EffectHandle *handle, bool unpinIfLast);
152 ssize_t removeHandle(EffectHandle *handle);
Jaideep Sharmaed8688022020-08-07 14:09:16 +0530153 ssize_t removeHandle_l(EffectHandle *handle);
Eric Laurent41709552019-12-16 19:34:05 -0800154 EffectHandle* controlHandle_l();
155 bool purgeHandles();
156
157 void checkSuspendOnEffectEnabled(bool enabled, bool threadLocked);
158
159 bool isPinned() const { return mPinned; }
160 void unPin() { mPinned = false; }
161
162 void lock() { mLock.lock(); }
163 void unlock() { mLock.unlock(); }
Eric Laurent81784c32012-11-19 14:55:58 -0800164
Eric Laurent6c796322019-04-09 14:13:17 -0700165 status_t updatePolicyState();
Eric Laurent41709552019-12-16 19:34:05 -0800166
167 virtual sp<EffectModule> asEffectModule() { return nullptr; }
Eric Laurentb82e6b72019-11-22 17:25:04 -0800168 virtual sp<DeviceEffectProxy> asDeviceEffectProxy() { return nullptr; }
Eric Laurent6c796322019-04-09 14:13:17 -0700169
Eric Laurent81784c32012-11-19 14:55:58 -0800170 void dump(int fd, const Vector<String16>& args);
171
Eric Laurentd66d7a12021-07-13 13:35:32 +0200172protected:
173 bool isInternal_l() const {
174 for (auto handle : mHandles) {
175 if (handle->client() != nullptr) {
176 return false;
177 }
178 }
179 return true;
180 }
181
Mikhail Naganovbf493082017-04-17 17:37:12 -0700182private:
Eric Laurent81784c32012-11-19 14:55:58 -0800183 friend class AudioFlinger; // for mHandles
Eric Laurent41709552019-12-16 19:34:05 -0800184 bool mPinned = false;
185
186 DISALLOW_COPY_AND_ASSIGN(EffectBase);
187
188mutable Mutex mLock; // mutex for process, commands and handles list protection
Andy Hungfda44002021-06-03 17:23:16 -0700189 mediautils::atomic_sp<EffectCallbackInterface> mCallback; // parent effect chain
Eric Laurent41709552019-12-16 19:34:05 -0800190 const int mId; // this instance unique ID
191 const audio_session_t mSessionId; // audio session ID
192 const effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
193 effect_state mState = IDLE; // current activation state
Eric Laurentd9eb4962019-12-19 09:20:49 -0800194 // effect is suspended: temporarily disabled by framework
195 bool mSuspended = false;
Eric Laurent41709552019-12-16 19:34:05 -0800196
197 Vector<EffectHandle *> mHandles; // list of client handles
198 // First handle in mHandles has highest priority and controls the effect module
199
200 // Audio policy effect state management
201 // Mutex protecting transactions with audio policy manager as mLock cannot
202 // be held to avoid cross deadlocks with audio policy mutex
203 Mutex mPolicyLock;
204 // Effect is registered in APM or not
205 bool mPolicyRegistered = false;
206 // Effect enabled state communicated to APM. Enabled state corresponds to
207 // state requested by the EffectHandle with control
208 bool mPolicyEnabled = false;
209};
210
211// The EffectModule class is a wrapper object controlling the effect engine implementation
212// in the effect library. It prevents concurrent calls to process() and command() functions
213// from different client threads. It keeps a list of EffectHandle objects corresponding
214// to all client applications using this effect and notifies applications of effect state,
215// control or parameter changes. It manages the activation state machine to send appropriate
216// reset, enable, disable commands to effect engine and provide volume
217// ramping when effects are activated/deactivated.
218// When controlling an auxiliary effect, the EffectModule also provides an input buffer used by
219// the attached track(s) to accumulate their auxiliary channel.
220class EffectModule : public EffectBase {
221public:
222 EffectModule(const sp<EffectCallbackInterface>& callabck,
223 effect_descriptor_t *desc,
224 int id,
225 audio_session_t sessionId,
Eric Laurentb82e6b72019-11-22 17:25:04 -0800226 bool pinned,
227 audio_port_handle_t deviceId);
Eric Laurent41709552019-12-16 19:34:05 -0800228 virtual ~EffectModule();
229
230 void process();
231 bool updateState();
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700232 status_t command(int32_t cmdCode,
233 const std::vector<uint8_t>& cmdData,
234 int32_t maxReplySize,
235 std::vector<uint8_t>* reply) override;
Eric Laurent41709552019-12-16 19:34:05 -0800236
237 void reset_l();
238 status_t configure();
239 status_t init();
240
241 uint32_t status() {
242 return mStatus;
243 }
244
245 bool isProcessEnabled() const;
246 bool isOffloadedOrDirect() const;
247 bool isVolumeControlEnabled() const;
248
249 void setInBuffer(const sp<EffectBufferHalInterface>& buffer);
250 int16_t *inBuffer() const {
251 return mInBuffer != 0 ? reinterpret_cast<int16_t*>(mInBuffer->ptr()) : NULL;
252 }
253 void setOutBuffer(const sp<EffectBufferHalInterface>& buffer);
254 int16_t *outBuffer() const {
255 return mOutBuffer != 0 ? reinterpret_cast<int16_t*>(mOutBuffer->ptr()) : NULL;
256 }
257
Andy Hung799c8d02021-10-28 17:05:40 -0700258 // Updates the access mode if it is out of date. May issue a new effect configure.
259 void updateAccessMode() {
260 if (requiredEffectBufferAccessMode() != mConfig.outputCfg.accessMode) {
261 configure();
262 }
263 }
264
Eric Laurent41709552019-12-16 19:34:05 -0800265 status_t setDevices(const AudioDeviceTypeAddrVector &devices);
266 status_t setInputDevice(const AudioDeviceTypeAddr &device);
267 status_t setVolume(uint32_t *left, uint32_t *right, bool controller);
268 status_t setMode(audio_mode_t mode);
269 status_t setAudioSource(audio_source_t source);
270 status_t start();
271 status_t stop();
272
273 status_t setOffloaded(bool offloaded, audio_io_handle_t io);
274 bool isOffloaded() const;
275 void addEffectToHal_l();
276 void release_l();
277
278 sp<EffectModule> asEffectModule() override { return this; }
279
jiabineb3bda02020-06-30 14:07:03 -0700280 static bool isHapticGenerator(const effect_uuid_t* type);
281 bool isHapticGenerator() const;
282
jiabine70bc7f2020-06-30 22:07:55 -0700283 status_t setHapticIntensity(int id, int intensity);
Lais Andradebc3f37a2021-07-02 00:13:19 +0100284 status_t setVibratorInfo(const media::AudioVibratorInfo& vibratorInfo);
jiabine70bc7f2020-06-30 22:07:55 -0700285
Eric Laurent41709552019-12-16 19:34:05 -0800286 void dump(int fd, const Vector<String16>& args);
287
288private:
289 friend class AudioFlinger; // for mHandles
Eric Laurent81784c32012-11-19 14:55:58 -0800290
291 // Maximum time allocated to effect engines to complete the turn off sequence
292 static const uint32_t MAX_DISABLE_TIME_MS = 10000;
293
Mikhail Naganovbf493082017-04-17 17:37:12 -0700294 DISALLOW_COPY_AND_ASSIGN(EffectModule);
Eric Laurent81784c32012-11-19 14:55:58 -0800295
296 status_t start_l();
297 status_t stop_l();
Eric Laurent6b446ce2019-12-13 10:56:31 -0800298 status_t removeEffectFromHal_l();
jiabin8f278ee2019-11-11 12:16:27 -0800299 status_t sendSetAudioDevicesCommand(const AudioDeviceTypeAddrVector &devices, uint32_t cmdCode);
Andy Hung799c8d02021-10-28 17:05:40 -0700300 effect_buffer_access_e requiredEffectBufferAccessMode() const {
301 return mConfig.inputCfg.buffer.raw == mConfig.outputCfg.buffer.raw
302 ? EFFECT_BUFFER_ACCESS_WRITE : EFFECT_BUFFER_ACCESS_ACCUMULATE;
303 }
304
Eric Laurent81784c32012-11-19 14:55:58 -0800305
Eric Laurent81784c32012-11-19 14:55:58 -0800306 effect_config_t mConfig; // input and output audio configuration
Mikhail Naganov4a3d5c22016-08-15 13:47:42 -0700307 sp<EffectHalInterface> mEffectInterface; // Effect module HAL
Mikhail Naganov022b9952017-01-04 16:36:51 -0800308 sp<EffectBufferHalInterface> mInBuffer; // Buffers for interacting with HAL
309 sp<EffectBufferHalInterface> mOutBuffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800310 status_t mStatus; // initialization status
Eric Laurent81784c32012-11-19 14:55:58 -0800311 // First handle in mHandles has highest priority and controls the effect module
312 uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after
313 // sending disable command.
314 uint32_t mDisableWaitCnt; // current process() calls count during disable period.
Eric Laurent5baf2af2013-09-12 17:37:00 -0700315 bool mOffloaded; // effect is currently offloaded to the audio DSP
David Li6c8ac4b2021-06-22 22:17:52 +0800316 bool mAddedToHal; // effect has been added to the audio HAL
rago94a1ee82017-07-21 15:11:02 -0700317
318#ifdef FLOAT_EFFECT_CHAIN
319 bool mSupportsFloat; // effect supports float processing
Andy Hungbded9c82017-11-30 18:47:35 -0800320 sp<EffectBufferHalInterface> mInConversionBuffer; // Buffers for HAL conversion if needed.
321 sp<EffectBufferHalInterface> mOutConversionBuffer;
Andy Hung9aad48c2017-11-29 10:29:19 -0800322 uint32_t mInChannelCountRequested;
323 uint32_t mOutChannelCountRequested;
rago94a1ee82017-07-21 15:11:02 -0700324#endif
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900325
326 class AutoLockReentrant {
327 public:
328 AutoLockReentrant(Mutex& mutex, pid_t allowedTid)
329 : mMutex(gettid() == allowedTid ? nullptr : &mutex)
330 {
331 if (mMutex != nullptr) mMutex->lock();
332 }
333 ~AutoLockReentrant() {
334 if (mMutex != nullptr) mMutex->unlock();
335 }
336 private:
337 Mutex * const mMutex;
338 };
339
340 static constexpr pid_t INVALID_PID = (pid_t)-1;
341 // this tid is allowed to call setVolume() without acquiring the mutex.
342 pid_t mSetVolumeReentrantTid = INVALID_PID;
Eric Laurent81784c32012-11-19 14:55:58 -0800343};
344
345// The EffectHandle class implements the IEffect interface. It provides resources
346// to receive parameter updates, keeps track of effect control
347// ownership and state and has a pointer to the EffectModule object it is controlling.
348// There is one EffectHandle object for each application controlling (or using)
349// an effect module.
350// The EffectHandle is obtained by calling AudioFlinger::createEffect().
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700351class EffectHandle: public android::media::BnEffect {
Eric Laurent81784c32012-11-19 14:55:58 -0800352public:
353
Eric Laurent41709552019-12-16 19:34:05 -0800354 EffectHandle(const sp<EffectBase>& effect,
Eric Laurent81784c32012-11-19 14:55:58 -0800355 const sp<AudioFlinger::Client>& client,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700356 const sp<media::IEffectClient>& effectClient,
Eric Laurentde8caf42021-08-11 17:19:25 +0200357 int32_t priority, bool notifyFramesProcessed);
Eric Laurent81784c32012-11-19 14:55:58 -0800358 virtual ~EffectHandle();
Andy Hungc747c532022-03-07 21:41:14 -0800359 status_t onTransact(
360 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
Glenn Kastene75da402013-11-20 13:54:52 -0800361 virtual status_t initCheck();
Eric Laurent81784c32012-11-19 14:55:58 -0800362
363 // IEffect
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700364 android::binder::Status enable(int32_t* _aidl_return) override;
365 android::binder::Status disable(int32_t* _aidl_return) override;
366 android::binder::Status command(int32_t cmdCode,
367 const std::vector<uint8_t>& cmdData,
368 int32_t maxResponseSize,
369 std::vector<uint8_t>* response,
370 int32_t* _aidl_return) override;
371 android::binder::Status disconnect() override;
372 android::binder::Status getCblk(media::SharedFileRegion* _aidl_return) override;
Eric Laurent81784c32012-11-19 14:55:58 -0800373
Eric Laurentd66d7a12021-07-13 13:35:32 +0200374 sp<Client> client() const { return mClient; }
375
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700376private:
377 void disconnect(bool unpinIfLast);
Eric Laurent81784c32012-11-19 14:55:58 -0800378
379 // Give or take control of effect module
380 // - hasControl: true if control is given, false if removed
381 // - signal: true client app should be signaled of change, false otherwise
382 // - enabled: state of the effect when control is passed
383 void setControl(bool hasControl, bool signal, bool enabled);
384 void commandExecuted(uint32_t cmdCode,
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700385 const std::vector<uint8_t>& cmdData,
386 const std::vector<uint8_t>& replyData);
Eric Laurent81784c32012-11-19 14:55:58 -0800387 void setEnabled(bool enabled);
388 bool enabled() const { return mEnabled; }
389
Eric Laurentde8caf42021-08-11 17:19:25 +0200390 void framesProcessed(int32_t frames) const;
391
Eric Laurent81784c32012-11-19 14:55:58 -0800392 // Getters
Eric Laurent41709552019-12-16 19:34:05 -0800393 wp<EffectBase> effect() const { return mEffect; }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800394 int id() const {
Eric Laurent41709552019-12-16 19:34:05 -0800395 sp<EffectBase> effect = mEffect.promote();
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800396 if (effect == 0) {
397 return 0;
398 }
399 return effect->id();
400 }
Eric Laurent81784c32012-11-19 14:55:58 -0800401 int priority() const { return mPriority; }
402 bool hasControl() const { return mHasControl; }
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800403 bool disconnected() const { return mDisconnected; }
Eric Laurent81784c32012-11-19 14:55:58 -0800404
Glenn Kasten01d3acb2014-02-06 08:24:07 -0800405 void dumpToBuffer(char* buffer, size_t size);
Eric Laurent81784c32012-11-19 14:55:58 -0800406
Mikhail Naganovbf493082017-04-17 17:37:12 -0700407private:
Eric Laurent81784c32012-11-19 14:55:58 -0800408 friend class AudioFlinger; // for mEffect, mHasControl, mEnabled
Mikhail Naganovbf493082017-04-17 17:37:12 -0700409 DISALLOW_COPY_AND_ASSIGN(EffectHandle);
Eric Laurent81784c32012-11-19 14:55:58 -0800410
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700411 Mutex mLock; // protects IEffect method calls
Andy Hung318e0242020-12-21 10:33:49 -0800412 const wp<EffectBase> mEffect; // pointer to controlled EffectModule
413 const sp<media::IEffectClient> mEffectClient; // callback interface for client notifications
Ytai Ben-Tsvi9cd89812020-07-01 17:12:06 -0700414 /*const*/ sp<Client> mClient; // client for shared memory allocation, see
415 // disconnect()
416 sp<IMemory> mCblkMemory; // shared memory for control block
417 effect_param_cblk_t* mCblk; // control block for deferred parameter setting via
418 // shared memory
419 uint8_t* mBuffer; // pointer to parameter area in shared memory
420 int mPriority; // client application priority to control the effect
421 bool mHasControl; // true if this handle is controlling the effect
422 bool mEnabled; // cached enable state: needed when the effect is
423 // restored after being suspended
424 bool mDisconnected; // Set to true by disconnect()
Eric Laurentde8caf42021-08-11 17:19:25 +0200425 const bool mNotifyFramesProcessed; // true if the client callback event
426 // EVENT_FRAMES_PROCESSED must be generated
Eric Laurent81784c32012-11-19 14:55:58 -0800427};
428
429// the EffectChain class represents a group of effects associated to one audio session.
430// There can be any number of EffectChain objects per output mixer thread (PlaybackThread).
Glenn Kastend848eb42016-03-08 13:42:11 -0800431// The EffectChain with session ID AUDIO_SESSION_OUTPUT_MIX contains global effects applied
432// to the output mix.
Eric Laurent81784c32012-11-19 14:55:58 -0800433// Effects in this chain can be insert or auxiliary. Effects in other chains (attached to
434// tracks) are insert only. The EffectChain maintains an ordered list of effect module, the
Glenn Kastend848eb42016-03-08 13:42:11 -0800435// order corresponding in the effect process order. When attached to a track (session ID !=
436// AUDIO_SESSION_OUTPUT_MIX),
Eric Laurent81784c32012-11-19 14:55:58 -0800437// it also provide it's own input buffer used by the track as accumulation buffer.
438class EffectChain : public RefBase {
439public:
Glenn Kastend848eb42016-03-08 13:42:11 -0800440 EffectChain(const wp<ThreadBase>& wThread, audio_session_t sessionId);
Eric Laurent81784c32012-11-19 14:55:58 -0800441 virtual ~EffectChain();
442
443 // special key used for an entry in mSuspendedEffects keyed vector
444 // corresponding to a suspend all request.
445 static const int kKeyForSuspendAll = 0;
446
447 // minimum duration during which we force calling effect process when last track on
448 // a session is stopped or removed to allow effect tail to be rendered
449 static const int kProcessTailDurationMs = 1000;
450
451 void process_l();
452
453 void lock() {
454 mLock.lock();
455 }
456 void unlock() {
457 mLock.unlock();
458 }
459
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800460 status_t createEffect_l(sp<EffectModule>& effect,
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800461 effect_descriptor_t *desc,
462 int id,
463 audio_session_t sessionId,
464 bool pinned);
Eric Laurent81784c32012-11-19 14:55:58 -0800465 status_t addEffect_l(const sp<EffectModule>& handle);
Eric Laurent0d5a2ed2016-12-01 15:28:29 -0800466 status_t addEffect_ll(const sp<EffectModule>& handle);
467 size_t removeEffect_l(const sp<EffectModule>& handle, bool release = false);
Eric Laurent81784c32012-11-19 14:55:58 -0800468
Glenn Kastend848eb42016-03-08 13:42:11 -0800469 audio_session_t sessionId() const { return mSessionId; }
470 void setSessionId(audio_session_t sessionId) { mSessionId = sessionId; }
Eric Laurent81784c32012-11-19 14:55:58 -0800471
472 sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor);
473 sp<EffectModule> getEffectFromId_l(int id);
474 sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type);
Eric Laurent6c796322019-04-09 14:13:17 -0700475 std::vector<int> getEffectIds();
Glenn Kastenc56f3422014-03-21 17:53:17 -0700476 // FIXME use float to improve the dynamic range
Eric Laurentfa1e1232016-08-02 19:01:49 -0700477 bool setVolume_l(uint32_t *left, uint32_t *right, bool force = false);
478 void resetVolume_l();
jiabin8f278ee2019-11-11 12:16:27 -0800479 void setDevices_l(const AudioDeviceTypeAddrVector &devices);
480 void setInputDevice_l(const AudioDeviceTypeAddr &device);
Eric Laurent81784c32012-11-19 14:55:58 -0800481 void setMode_l(audio_mode_t mode);
482 void setAudioSource_l(audio_source_t source);
483
Mikhail Naganov022b9952017-01-04 16:36:51 -0800484 void setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
Eric Laurent81784c32012-11-19 14:55:58 -0800485 mInBuffer = buffer;
Eric Laurent81784c32012-11-19 14:55:58 -0800486 }
rago94a1ee82017-07-21 15:11:02 -0700487 effect_buffer_t *inBuffer() const {
488 return mInBuffer != 0 ? reinterpret_cast<effect_buffer_t*>(mInBuffer->ptr()) : NULL;
Eric Laurent81784c32012-11-19 14:55:58 -0800489 }
Mikhail Naganov022b9952017-01-04 16:36:51 -0800490 void setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
Eric Laurent81784c32012-11-19 14:55:58 -0800491 mOutBuffer = buffer;
492 }
rago94a1ee82017-07-21 15:11:02 -0700493 effect_buffer_t *outBuffer() const {
494 return mOutBuffer != 0 ? reinterpret_cast<effect_buffer_t*>(mOutBuffer->ptr()) : NULL;
Eric Laurent81784c32012-11-19 14:55:58 -0800495 }
496
497 void incTrackCnt() { android_atomic_inc(&mTrackCnt); }
498 void decTrackCnt() { android_atomic_dec(&mTrackCnt); }
499 int32_t trackCnt() const { return android_atomic_acquire_load(&mTrackCnt); }
500
501 void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt);
502 mTailBufferCount = mMaxTailBuffers; }
503 void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
504 int32_t activeTrackCnt() const { return android_atomic_acquire_load(&mActiveTrackCnt); }
505
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800506 product_strategy_t strategy() const { return mStrategy; }
507 void setStrategy(product_strategy_t strategy)
Eric Laurent81784c32012-11-19 14:55:58 -0800508 { mStrategy = strategy; }
509
Eric Laurentd8365c52017-07-16 15:27:05 -0700510 // suspend or restore effects of the specified type. The number of suspend requests is counted
511 // and restore occurs once all suspend requests are cancelled.
Eric Laurent81784c32012-11-19 14:55:58 -0800512 void setEffectSuspended_l(const effect_uuid_t *type,
513 bool suspend);
514 // suspend all eligible effects
515 void setEffectSuspendedAll_l(bool suspend);
Eric Laurent6b446ce2019-12-13 10:56:31 -0800516 // check if effects should be suspended or restored when a given effect is enable or disabled
517 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, bool enabled);
Eric Laurent81784c32012-11-19 14:55:58 -0800518
519 void clearInputBuffer();
520
Eric Laurent5baf2af2013-09-12 17:37:00 -0700521 // At least one non offloadable effect in the chain is enabled
522 bool isNonOffloadableEnabled();
Shingo Kitajima1f8df9a2018-05-29 11:35:06 +0900523 bool isNonOffloadableEnabled_l();
Eric Laurent813e2a72013-08-31 12:59:48 -0700524
Eric Laurent1b928682014-10-02 19:41:47 -0700525 void syncHalEffectsState();
526
Andy Hungd3bb0ad2016-10-11 17:16:43 -0700527 // flags is an ORed set of audio_output_flags_t which is updated on return.
528 void checkOutputFlagCompatibility(audio_output_flags_t *flags) const;
529
530 // flags is an ORed set of audio_input_flags_t which is updated on return.
531 void checkInputFlagCompatibility(audio_input_flags_t *flags) const;
532
533 // Is this EffectChain compatible with the RAW audio flag.
534 bool isRawCompatible() const;
535
536 // Is this EffectChain compatible with the FAST audio flag.
537 bool isFastCompatible() const;
Eric Laurent4c415062016-06-17 16:14:16 -0700538
539 // isCompatibleWithThread_l() must be called with thread->mLock held
540 bool isCompatibleWithThread_l(const sp<ThreadBase>& thread) const;
541
jiabineb3bda02020-06-30 14:07:03 -0700542 bool containsHapticGeneratingEffect_l();
543
jiabine70bc7f2020-06-30 22:07:55 -0700544 void setHapticIntensity_l(int id, int intensity);
545
Eric Laurent6b446ce2019-12-13 10:56:31 -0800546 sp<EffectCallbackInterface> effectCallback() const { return mEffectCallback; }
547 wp<ThreadBase> thread() const { return mEffectCallback->thread(); }
548
Eric Laurentf1f22e72021-07-13 14:04:14 +0200549 bool isFirstEffect(int id) const { return !mEffects.isEmpty() && id == mEffects[0]->id(); }
550
Eric Laurent81784c32012-11-19 14:55:58 -0800551 void dump(int fd, const Vector<String16>& args);
552
Mikhail Naganovbf493082017-04-17 17:37:12 -0700553private:
Eric Laurent6b446ce2019-12-13 10:56:31 -0800554
Andy Hung328d6772021-01-12 12:32:21 -0800555 // For transaction consistency, please consider holding the EffectChain lock before
556 // calling the EffectChain::EffectCallback methods, excepting
557 // createEffectHal and allocateHalBuffer.
558 //
559 // This prevents migration of the EffectChain to another PlaybackThread
560 // for the purposes of the EffectCallback.
Eric Laurent6b446ce2019-12-13 10:56:31 -0800561 class EffectCallback : public EffectCallbackInterface {
562 public:
Ytai Ben-Tsvi4f043362020-01-28 12:39:23 -0800563 // Note: ctors taking a weak pointer to their owner must not promote it
564 // during construction (but may keep a reference for later promotion).
565 EffectCallback(const wp<EffectChain>& owner,
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800566 const wp<ThreadBase>& thread)
Andy Hung6626a012021-01-12 13:38:00 -0800567 : mChain(owner)
568 , mThread(thread)
569 , mAudioFlinger(*gAudioFlinger) {
Greg Kaiseree71ebd2021-11-09 07:37:38 -0800570 sp<ThreadBase> base = thread.promote();
571 if (base != nullptr) {
572 mThreadType = base->type();
573 } else {
574 mThreadType = ThreadBase::MIXER; // assure a consistent value.
575 }
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800576 }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800577
578 status_t createEffectHal(const effect_uuid_t *pEffectUuid,
579 int32_t sessionId, int32_t deviceId, sp<EffectHalInterface> *effect) override;
580 status_t allocateHalBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) override;
Eric Laurent41709552019-12-16 19:34:05 -0800581 bool updateOrphanEffectChains(const sp<EffectBase>& effect) override;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800582
583 audio_io_handle_t io() const override;
584 bool isOutput() const override;
585 bool isOffload() const override;
586 bool isOffloadOrDirect() const override;
587 bool isOffloadOrMmap() const override;
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200588 bool isSpatializer() const override;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800589
590 uint32_t sampleRate() const override;
Eric Laurentf1f22e72021-07-13 14:04:14 +0200591 audio_channel_mask_t inChannelMask(int id) const override;
592 uint32_t inChannelCount(int id) const override;
593 audio_channel_mask_t outChannelMask() const override;
594 uint32_t outChannelCount() const override;
jiabineb3bda02020-06-30 14:07:03 -0700595 audio_channel_mask_t hapticChannelMask() const override;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800596 size_t frameCount() const override;
597 uint32_t latency() const override;
598
599 status_t addEffectToHal(sp<EffectHalInterface> effect) override;
600 status_t removeEffectFromHal(sp<EffectHalInterface> effect) override;
601 bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) override;
602 void setVolumeForOutput(float left, float right) const override;
603
604 // check if effects should be suspended/restored when a given effect is enable/disabled
Eric Laurent41709552019-12-16 19:34:05 -0800605 void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect,
Eric Laurent6b446ce2019-12-13 10:56:31 -0800606 bool enabled, bool threadLocked) override;
607 void resetVolume() override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800608 product_strategy_t strategy() const override;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800609 int32_t activeTrackCnt() const override;
Eric Laurent41709552019-12-16 19:34:05 -0800610 void onEffectEnable(const sp<EffectBase>& effect) override;
611 void onEffectDisable(const sp<EffectBase>& effect) override;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800612
613 wp<EffectChain> chain() const override { return mChain; }
614
Eric Laurentd66d7a12021-07-13 13:35:32 +0200615 bool isAudioPolicyReady() const override {
616 return mAudioFlinger.isAudioPolicyReady();
617 }
618
Andy Hung328d6772021-01-12 12:32:21 -0800619 wp<ThreadBase> thread() const { return mThread.load(); }
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800620
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200621 void setThread(const sp<ThreadBase>& thread) {
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800622 mThread = thread;
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200623 mThreadType = thread->type();
Ytai Ben-Tsvi3de1bbf2020-01-21 16:41:17 -0800624 }
Eric Laurent6b446ce2019-12-13 10:56:31 -0800625
626 private:
Andy Hung318e0242020-12-21 10:33:49 -0800627 const wp<EffectChain> mChain;
Andy Hung328d6772021-01-12 12:32:21 -0800628 mediautils::atomic_wp<ThreadBase> mThread;
Andy Hung6626a012021-01-12 13:38:00 -0800629 AudioFlinger &mAudioFlinger; // implementation detail: outer instance always exists.
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200630 ThreadBase::type_t mThreadType;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800631 };
632
Eric Laurent81784c32012-11-19 14:55:58 -0800633 friend class AudioFlinger; // for mThread, mEffects
Mikhail Naganovbf493082017-04-17 17:37:12 -0700634 DISALLOW_COPY_AND_ASSIGN(EffectChain);
Eric Laurent81784c32012-11-19 14:55:58 -0800635
636 class SuspendedEffectDesc : public RefBase {
637 public:
638 SuspendedEffectDesc() : mRefCount(0) {}
639
Eric Laurentd8365c52017-07-16 15:27:05 -0700640 int mRefCount; // > 0 when suspended
Eric Laurent81784c32012-11-19 14:55:58 -0800641 effect_uuid_t mType;
642 wp<EffectModule> mEffect;
643 };
644
645 // get a list of effect modules to suspend when an effect of the type
646 // passed is enabled.
647 void getSuspendEligibleEffects(Vector< sp<EffectModule> > &effects);
648
649 // get an effect module if it is currently enable
650 sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type);
651 // true if the effect whose descriptor is passed can be suspended
652 // OEMs can modify the rules implemented in this method to exclude specific effect
653 // types or implementations from the suspend/restore mechanism.
654 bool isEffectEligibleForSuspend(const effect_descriptor_t& desc);
655
Eric Laurentd8365c52017-07-16 15:27:05 -0700656 static bool isEffectEligibleForBtNrecSuspend(const effect_uuid_t *type);
657
Eric Laurent6b446ce2019-12-13 10:56:31 -0800658 void clearInputBuffer_l();
Eric Laurent81784c32012-11-19 14:55:58 -0800659
Eric Laurentaaa44472014-09-12 17:41:50 -0700660 void setThread(const sp<ThreadBase>& thread);
661
Zhou Songd505c642020-02-20 16:35:37 +0800662 // true if any effect module within the chain has volume control
663 bool hasVolumeControlEnabled_l() const;
664
Tomoharu Kasahara1990bd42014-12-12 14:04:11 +0900665 void setVolumeForOutput_l(uint32_t left, uint32_t right);
666
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200667 ssize_t getInsertIndex(const effect_descriptor_t& desc);
668
Eric Laurent4c415062016-06-17 16:14:16 -0700669 mutable Mutex mLock; // mutex protecting effect list
670 Vector< sp<EffectModule> > mEffects; // list of effect modules
671 audio_session_t mSessionId; // audio session ID
Mikhail Naganov022b9952017-01-04 16:36:51 -0800672 sp<EffectBufferHalInterface> mInBuffer; // chain input buffer
673 sp<EffectBufferHalInterface> mOutBuffer; // chain output buffer
Eric Laurent81784c32012-11-19 14:55:58 -0800674
675 // 'volatile' here means these are accessed with atomic operations instead of mutex
676 volatile int32_t mActiveTrackCnt; // number of active tracks connected
677 volatile int32_t mTrackCnt; // number of tracks connected
678
Eric Laurent4c415062016-06-17 16:14:16 -0700679 int32_t mTailBufferCount; // current effect tail buffer count
680 int32_t mMaxTailBuffers; // maximum effect tail buffers
Eric Laurent4c415062016-06-17 16:14:16 -0700681 int mVolumeCtrlIdx; // index of insert effect having control over volume
682 uint32_t mLeftVolume; // previous volume on left channel
683 uint32_t mRightVolume; // previous volume on right channel
684 uint32_t mNewLeftVolume; // new volume on left channel
685 uint32_t mNewRightVolume; // new volume on right channel
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800686 product_strategy_t mStrategy; // strategy for this effect chain
Eric Laurent4c415062016-06-17 16:14:16 -0700687 // mSuspendedEffects lists all effects currently suspended in the chain.
688 // Use effect type UUID timelow field as key. There is no real risk of identical
689 // timeLow fields among effect type UUIDs.
Eric Laurentd8365c52017-07-16 15:27:05 -0700690 // Updated by setEffectSuspended_l() and setEffectSuspendedAll_l() only.
Eric Laurent4c415062016-06-17 16:14:16 -0700691 KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects;
Eric Laurent6b446ce2019-12-13 10:56:31 -0800692
693 const sp<EffectCallback> mEffectCallback;
Eric Laurent81784c32012-11-19 14:55:58 -0800694};
Eric Laurentb82e6b72019-11-22 17:25:04 -0800695
696class DeviceEffectProxy : public EffectBase {
697public:
698 DeviceEffectProxy (const AudioDeviceTypeAddr& device,
699 const sp<DeviceEffectManagerCallback>& callback,
Eric Laurentde8caf42021-08-11 17:19:25 +0200700 effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
Eric Laurentb82e6b72019-11-22 17:25:04 -0800701 : EffectBase(callback, desc, id, AUDIO_SESSION_DEVICE, false),
702 mDevice(device), mManagerCallback(callback),
Eric Laurentde8caf42021-08-11 17:19:25 +0200703 mMyCallback(new ProxyCallback(wp<DeviceEffectProxy>(this), callback)),
704 mNotifyFramesProcessed(notifyFramesProcessed) {}
Eric Laurentb82e6b72019-11-22 17:25:04 -0800705
706 status_t setEnabled(bool enabled, bool fromHandle) override;
707 sp<DeviceEffectProxy> asDeviceEffectProxy() override { return this; }
708
709 status_t init(const std::map<audio_patch_handle_t, PatchPanel::Patch>& patches);
710 status_t onCreatePatch(audio_patch_handle_t patchHandle, const PatchPanel::Patch& patch);
711 void onReleasePatch(audio_patch_handle_t patchHandle);
712
713 size_t removeEffect(const sp<EffectModule>& effect);
714
715 status_t addEffectToHal(sp<EffectHalInterface> effect);
716 status_t removeEffectFromHal(sp<EffectHalInterface> effect);
717
718 const AudioDeviceTypeAddr& device() { return mDevice; };
719 bool isOutput() const;
720 uint32_t sampleRate() const;
721 audio_channel_mask_t channelMask() const;
722 uint32_t channelCount() const;
723
724 void dump(int fd, int spaces);
725
726private:
727
728 class ProxyCallback : public EffectCallbackInterface {
729 public:
Ytai Ben-Tsvi4f043362020-01-28 12:39:23 -0800730 // Note: ctors taking a weak pointer to their owner must not promote it
731 // during construction (but may keep a reference for later promotion).
732 ProxyCallback(const wp<DeviceEffectProxy>& owner,
733 const sp<DeviceEffectManagerCallback>& callback)
734 : mProxy(owner), mManagerCallback(callback) {}
Eric Laurentb82e6b72019-11-22 17:25:04 -0800735
736 status_t createEffectHal(const effect_uuid_t *pEffectUuid,
737 int32_t sessionId, int32_t deviceId, sp<EffectHalInterface> *effect) override;
738 status_t allocateHalBuffer(size_t size __unused,
739 sp<EffectBufferHalInterface>* buffer __unused) override { return NO_ERROR; }
740 bool updateOrphanEffectChains(const sp<EffectBase>& effect __unused) override {
741 return false;
742 }
743
744 audio_io_handle_t io() const override { return AUDIO_IO_HANDLE_NONE; }
745 bool isOutput() const override;
746 bool isOffload() const override { return false; }
747 bool isOffloadOrDirect() const override { return false; }
748 bool isOffloadOrMmap() const override { return false; }
Eric Laurent0dccd2e2021-10-26 17:40:18 +0200749 bool isSpatializer() const override { return false; }
Eric Laurentb82e6b72019-11-22 17:25:04 -0800750
751 uint32_t sampleRate() const override;
Eric Laurentf1f22e72021-07-13 14:04:14 +0200752 audio_channel_mask_t inChannelMask(int id) const override;
753 uint32_t inChannelCount(int id) const override;
754 audio_channel_mask_t outChannelMask() const override;
755 uint32_t outChannelCount() const override;
jiabineb3bda02020-06-30 14:07:03 -0700756 audio_channel_mask_t hapticChannelMask() const override { return AUDIO_CHANNEL_NONE; }
Eric Laurentb82e6b72019-11-22 17:25:04 -0800757 size_t frameCount() const override { return 0; }
758 uint32_t latency() const override { return 0; }
759
760 status_t addEffectToHal(sp<EffectHalInterface> effect) override;
761 status_t removeEffectFromHal(sp<EffectHalInterface> effect) override;
762
763 bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) override;
764 void setVolumeForOutput(float left __unused, float right __unused) const override {}
765
766 void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused,
767 bool enabled __unused, bool threadLocked __unused) override {}
768 void resetVolume() override {}
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800769 product_strategy_t strategy() const override { return static_cast<product_strategy_t>(0); }
Eric Laurentb82e6b72019-11-22 17:25:04 -0800770 int32_t activeTrackCnt() const override { return 0; }
Eric Laurent76c89f32021-12-03 17:13:23 +0100771 void onEffectEnable(const sp<EffectBase>& effect __unused) override;
772 void onEffectDisable(const sp<EffectBase>& effect __unused) override;
Eric Laurentb82e6b72019-11-22 17:25:04 -0800773
774 wp<EffectChain> chain() const override { return nullptr; }
775
Eric Laurentd66d7a12021-07-13 13:35:32 +0200776 bool isAudioPolicyReady() const override {
777 return mManagerCallback->isAudioPolicyReady();
778 }
779
Eric Laurentb82e6b72019-11-22 17:25:04 -0800780 int newEffectId();
781
782 private:
783 const wp<DeviceEffectProxy> mProxy;
784 const sp<DeviceEffectManagerCallback> mManagerCallback;
785 };
786
787 status_t checkPort(const PatchPanel::Patch& patch, const struct audio_port_config *port,
788 sp<EffectHandle> *handle);
789
790 const AudioDeviceTypeAddr mDevice;
791 const sp<DeviceEffectManagerCallback> mManagerCallback;
792 const sp<ProxyCallback> mMyCallback;
793
794 Mutex mProxyLock;
795 std::map<audio_patch_handle_t, sp<EffectHandle>> mEffectHandles; // protected by mProxyLock
796 sp<EffectModule> mHalEffect; // protected by mProxyLock
797 struct audio_port_config mDevicePort = { .id = AUDIO_PORT_HANDLE_NONE };
Eric Laurentde8caf42021-08-11 17:19:25 +0200798 const bool mNotifyFramesProcessed;
Eric Laurentb82e6b72019-11-22 17:25:04 -0800799};