1 /* 2 ** 3 ** Copyright 2019, 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 // DeviceEffectManager is concealed within AudioFlinger, their lifetimes are the same. 23 class DeviceEffectManager : public PatchCommandThread::PatchCommandListener { 24 public: DeviceEffectManager(AudioFlinger & audioFlinger)25 explicit DeviceEffectManager(AudioFlinger& audioFlinger) 26 : mAudioFlinger(audioFlinger), 27 mMyCallback(new DeviceEffectManagerCallback(*this)) {} 28 onFirstRef()29 void onFirstRef() override { 30 mAudioFlinger.mPatchCommandThread->addListener(this); 31 } 32 33 sp<EffectHandle> createEffect_l(effect_descriptor_t *descriptor, 34 const AudioDeviceTypeAddr& device, 35 const sp<AudioFlinger::Client>& client, 36 const sp<media::IEffectClient>& effectClient, 37 const std::map<audio_patch_handle_t, PatchPanel::Patch>& patches, 38 int *enabled, 39 status_t *status, 40 bool probe, 41 bool notifyFramesProcessed); 42 43 size_t removeEffect(const sp<DeviceEffectProxy>& effect); 44 status_t createEffectHal(const effect_uuid_t *pEffectUuid, 45 int32_t sessionId, int32_t deviceId, 46 sp<EffectHalInterface> *effect); addEffectToHal(const struct audio_port_config * device,const sp<EffectHalInterface> & effect)47 status_t addEffectToHal(const struct audio_port_config *device, 48 const sp<EffectHalInterface>& effect) { 49 return mAudioFlinger.addEffectToHal(device, effect); 50 }; removeEffectFromHal(const struct audio_port_config * device,const sp<EffectHalInterface> & effect)51 status_t removeEffectFromHal(const struct audio_port_config *device, 52 const sp<EffectHalInterface>& effect) { 53 return mAudioFlinger.removeEffectFromHal(device, effect); 54 }; 55 audioFlinger()56 AudioFlinger& audioFlinger() const { return mAudioFlinger; } 57 58 void dump(int fd); 59 60 // PatchCommandThread::PatchCommandListener implementation 61 62 void onCreateAudioPatch(audio_patch_handle_t handle, 63 const PatchPanel::Patch& patch) override; 64 void onReleaseAudioPatch(audio_patch_handle_t handle) override; 65 66 private: 67 status_t checkEffectCompatibility(const effect_descriptor_t *desc); 68 69 Mutex mLock; 70 AudioFlinger &mAudioFlinger; 71 const sp<DeviceEffectManagerCallback> mMyCallback; 72 std::map<AudioDeviceTypeAddr, sp<DeviceEffectProxy>> mDeviceEffects; 73 }; 74 75 class DeviceEffectManagerCallback : public EffectCallbackInterface { 76 public: DeviceEffectManagerCallback(DeviceEffectManager & manager)77 explicit DeviceEffectManagerCallback(DeviceEffectManager& manager) 78 : mManager(manager) {} 79 createEffectHal(const effect_uuid_t * pEffectUuid,int32_t sessionId,int32_t deviceId,sp<EffectHalInterface> * effect)80 status_t createEffectHal(const effect_uuid_t *pEffectUuid, 81 int32_t sessionId, int32_t deviceId, 82 sp<EffectHalInterface> *effect) override { 83 return mManager.createEffectHal(pEffectUuid, sessionId, deviceId, effect); 84 } allocateHalBuffer(size_t size __unused,sp<EffectBufferHalInterface> * buffer __unused)85 status_t allocateHalBuffer(size_t size __unused, 86 sp<EffectBufferHalInterface>* buffer __unused) override { return NO_ERROR; } updateOrphanEffectChains(const sp<EffectBase> & effect __unused)87 bool updateOrphanEffectChains(const sp<EffectBase>& effect __unused) override { return false; } 88 io()89 audio_io_handle_t io() const override { return AUDIO_IO_HANDLE_NONE; } isOutput()90 bool isOutput() const override { return false; } isOffload()91 bool isOffload() const override { return false; } isOffloadOrDirect()92 bool isOffloadOrDirect() const override { return false; } isOffloadOrMmap()93 bool isOffloadOrMmap() const override { return false; } isSpatializer()94 bool isSpatializer() const override { return false; } 95 sampleRate()96 uint32_t sampleRate() const override { return 0; } inChannelMask(int id __unused)97 audio_channel_mask_t inChannelMask(int id __unused) const override { 98 return AUDIO_CHANNEL_NONE; 99 } inChannelCount(int id __unused)100 uint32_t inChannelCount(int id __unused) const override { return 0; } outChannelMask()101 audio_channel_mask_t outChannelMask() const override { return AUDIO_CHANNEL_NONE; } outChannelCount()102 uint32_t outChannelCount() const override { return 0; } 103 hapticChannelMask()104 audio_channel_mask_t hapticChannelMask() const override { return AUDIO_CHANNEL_NONE; } frameCount()105 size_t frameCount() const override { return 0; } latency()106 uint32_t latency() const override { return 0; } 107 addEffectToHal(const sp<EffectHalInterface> &)108 status_t addEffectToHal(const sp<EffectHalInterface>& /* effect */) override { 109 return NO_ERROR; 110 } removeEffectFromHal(const sp<EffectHalInterface> &)111 status_t removeEffectFromHal(const sp<EffectHalInterface>& /* effect */) override { 112 return NO_ERROR; 113 } 114 115 bool disconnectEffectHandle(EffectHandle *handle, bool unpinIfLast) override; setVolumeForOutput(float left __unused,float right __unused)116 void setVolumeForOutput(float left __unused, float right __unused) const override {} 117 118 // check if effects should be suspended or restored when a given effect is enable or disabled checkSuspendOnEffectEnabled(const sp<EffectBase> & effect __unused,bool enabled __unused,bool threadLocked __unused)119 void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused, 120 bool enabled __unused, bool threadLocked __unused) override {} resetVolume()121 void resetVolume() override {} strategy()122 product_strategy_t strategy() const override { return static_cast<product_strategy_t>(0); } activeTrackCnt()123 int32_t activeTrackCnt() const override { return 0; } onEffectEnable(const sp<EffectBase> & effect __unused)124 void onEffectEnable(const sp<EffectBase>& effect __unused) override {} onEffectDisable(const sp<EffectBase> & effect __unused)125 void onEffectDisable(const sp<EffectBase>& effect __unused) override {} 126 chain()127 wp<EffectChain> chain() const override { return nullptr; } 128 isAudioPolicyReady()129 bool isAudioPolicyReady() const override { 130 return mManager.audioFlinger().isAudioPolicyReady(); 131 } 132 newEffectId()133 int newEffectId() { return mManager.audioFlinger().nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT); } 134 addEffectToHal(const struct audio_port_config * device,const sp<EffectHalInterface> & effect)135 status_t addEffectToHal(const struct audio_port_config *device, 136 const sp<EffectHalInterface>& effect) { 137 return mManager.addEffectToHal(device, effect); 138 } removeEffectFromHal(const struct audio_port_config * device,const sp<EffectHalInterface> & effect)139 status_t removeEffectFromHal(const struct audio_port_config *device, 140 const sp<EffectHalInterface>& effect) { 141 return mManager.removeEffectFromHal(device, effect); 142 } 143 private: 144 DeviceEffectManager& mManager; 145 }; 146