1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H 18 #define ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H 19 20 #include PATH(android/hardware/audio/effect/FILE_VERSION/IEffect.h) 21 22 #include "AudioBufferManager.h" 23 24 #include <atomic> 25 #include <memory> 26 #include <vector> 27 28 #include <fmq/EventFlag.h> 29 #include <fmq/MessageQueue.h> 30 #include <hidl/MQDescriptor.h> 31 #include <hidl/Status.h> 32 #include <mediautils/MethodStatistics.h> 33 #include <utils/Thread.h> 34 35 #include <hardware/audio_effect.h> 36 37 #include "VersionUtils.h" 38 39 namespace android { 40 namespace hardware { 41 namespace audio { 42 namespace effect { 43 namespace CPP_VERSION { 44 namespace implementation { 45 46 using ::android::sp; 47 using ::android::hardware::hidl_string; 48 using ::android::hardware::hidl_vec; 49 using ::android::hardware::Return; 50 using ::android::hardware::Void; 51 #if MAJOR_VERSION <= 6 52 using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation:: 53 AudioDeviceBitfield; 54 #endif 55 using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION; 56 using namespace ::android::hardware::audio::effect::CPP_VERSION; 57 58 struct Effect : public IEffect { 59 typedef MessageQueue<Result, kSynchronizedReadWrite> StatusMQ; 60 using GetParameterSuccessCallback = 61 std::function<void(uint32_t valueSize, const void* valueData)>; 62 63 Effect(bool isInput, effect_handle_t handle); 64 65 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow. 66 Return<Result> init() override; 67 Return<Result> setConfig( 68 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider, 69 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override; 70 Return<Result> reset() override; 71 Return<Result> enable() override; 72 Return<Result> disable() override; 73 #if MAJOR_VERSION <= 6 74 Return<Result> setAudioSource(AudioSource source) override; 75 Return<Result> setDevice(AudioDeviceBitfield device) override; 76 Return<Result> setInputDevice(AudioDeviceBitfield device) override; 77 #else 78 Return<Result> setAudioSource(const AudioSource& source) override; 79 Return<Result> setDevice(const DeviceAddress& device) override; 80 Return<Result> setInputDevice(const DeviceAddress& device) override; 81 #endif 82 Return<void> setAndGetVolume(const hidl_vec<uint32_t>& volumes, 83 setAndGetVolume_cb _hidl_cb) override; 84 Return<Result> volumeChangeNotification(const hidl_vec<uint32_t>& volumes) override; 85 Return<Result> setAudioMode(AudioMode mode) override; 86 Return<Result> setConfigReverse( 87 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider, 88 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override; 89 Return<void> getConfig(getConfig_cb _hidl_cb) override; 90 Return<void> getConfigReverse(getConfigReverse_cb _hidl_cb) override; 91 Return<void> getSupportedAuxChannelsConfigs( 92 uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) override; 93 Return<void> getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) override; 94 Return<Result> setAuxChannelsConfig(const EffectAuxChannelsConfig& config) override; 95 Return<Result> offload(const EffectOffloadParameter& param) override; 96 Return<void> getDescriptor(getDescriptor_cb _hidl_cb) override; 97 Return<void> prepareForProcessing(prepareForProcessing_cb _hidl_cb) override; 98 Return<Result> setProcessBuffers(const AudioBuffer& inBuffer, 99 const AudioBuffer& outBuffer) override; 100 Return<void> command(uint32_t commandId, const hidl_vec<uint8_t>& data, uint32_t resultMaxSize, 101 command_cb _hidl_cb) override; 102 Return<Result> setParameter(const hidl_vec<uint8_t>& parameter, 103 const hidl_vec<uint8_t>& value) override; 104 Return<void> getParameter(const hidl_vec<uint8_t>& parameter, uint32_t valueMaxSize, 105 getParameter_cb _hidl_cb) override; 106 Return<void> getSupportedConfigsForFeature(uint32_t featureId, uint32_t maxConfigs, 107 uint32_t configSize, 108 getSupportedConfigsForFeature_cb _hidl_cb) override; 109 Return<void> getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize, 110 getCurrentConfigForFeature_cb _hidl_cb) override; 111 Return<Result> setCurrentConfigForFeature(uint32_t featureId, 112 const hidl_vec<uint8_t>& configData) override; 113 Return<Result> close() override; 114 Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options) override; 115 116 // Utility methods for extending interfaces. 117 static const char* sContextConversion; 118 119 Result analyzeStatus(const char* funcName, const char* subFuncName, 120 const char* contextDescription, status_t status); 121 template <typename T> getIntegerParamEffect122 Return<void> getIntegerParam(uint32_t paramId, 123 std::function<void(Result retval, T paramValue)> cb) { 124 T value; 125 Result retval = getParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), 126 [&](uint32_t valueSize, const void* valueData) { 127 if (valueSize > sizeof(T)) valueSize = sizeof(T); 128 memcpy(&value, valueData, valueSize); 129 }); 130 cb(retval, value); 131 return Void(); 132 } 133 134 template <typename T> getParamEffect135 Result getParam(uint32_t paramId, T& paramValue) { 136 return getParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), 137 [&](uint32_t valueSize, const void* valueData) { 138 if (valueSize > sizeof(T)) valueSize = sizeof(T); 139 memcpy(¶mValue, valueData, valueSize); 140 }); 141 } 142 143 template <typename T> getParamEffect144 Result getParam(uint32_t paramId, uint32_t paramArg, T& paramValue) { 145 uint32_t params[2] = {paramId, paramArg}; 146 return getParameterImpl(sizeof(params), params, sizeof(T), 147 [&](uint32_t valueSize, const void* valueData) { 148 if (valueSize > sizeof(T)) valueSize = sizeof(T); 149 memcpy(¶mValue, valueData, valueSize); 150 }); 151 } 152 153 template <typename T> setParamEffect154 Result setParam(uint32_t paramId, const T& paramValue) { 155 return setParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), ¶mValue); 156 } 157 158 template <typename T> setParamEffect159 Result setParam(uint32_t paramId, uint32_t paramArg, const T& paramValue) { 160 uint32_t params[2] = {paramId, paramArg}; 161 return setParameterImpl(sizeof(params), params, sizeof(T), ¶mValue); 162 } 163 getParameterImplEffect164 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize, 165 GetParameterSuccessCallback onSuccess) { 166 return getParameterImpl(paramSize, paramData, valueSize, valueSize, onSuccess); 167 } 168 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t requestValueSize, 169 uint32_t replyValueSize, GetParameterSuccessCallback onSuccess); 170 Result setParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize, 171 const void* valueData); 172 173 // process execution statistics 174 const std::shared_ptr<mediautils::MethodStatistics<std::string>> mStatistics = 175 std::make_shared<mediautils::MethodStatistics<std::string>>(); 176 177 private: 178 friend struct VirtualizerEffect; // for getParameterImpl 179 friend struct VisualizerEffect; // to allow executing commands 180 181 using CommandSuccessCallback = std::function<void()>; 182 using GetConfigCallback = std::function<void(Result retval, const EffectConfig& config)>; 183 using GetCurrentConfigSuccessCallback = std::function<void(void* configData)>; 184 using GetSupportedConfigsSuccessCallback = 185 std::function<void(uint32_t supportedConfigs, void* configsData)>; 186 187 // Sets the limit on the maximum size of vendor-provided data structures. 188 static constexpr size_t kMaxDataSize = 1 << 20; 189 190 static const char* sContextResultOfCommand; 191 static const char* sContextCallToCommand; 192 static const char* sContextCallFunction; 193 194 const bool mIsInput; 195 effect_handle_t mHandle; 196 sp<AudioBufferWrapper> mInBuffer; 197 sp<AudioBufferWrapper> mOutBuffer; 198 std::atomic<audio_buffer_t*> mHalInBufferPtr; 199 std::atomic<audio_buffer_t*> mHalOutBufferPtr; 200 std::unique_ptr<StatusMQ> mStatusMQ; 201 EventFlag* mEfGroup; 202 std::atomic<bool> mStopProcessThread; 203 sp<Thread> mProcessThread; 204 205 virtual ~Effect(); 206 207 template <typename T> 208 static size_t alignedSizeIn(size_t s); 209 template <typename T> 210 std::unique_ptr<uint8_t[]> hidlVecToHal(const hidl_vec<T>& vec, uint32_t* halDataSize); 211 void effectAuxChannelsConfigFromHal(const channel_config_t& halConfig, 212 EffectAuxChannelsConfig* config); 213 static void effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config, 214 channel_config_t* halConfig); 215 static void effectOffloadParamToHal(const EffectOffloadParameter& offload, 216 effect_offload_param_t* halOffload); 217 static bool parameterToHal(uint32_t paramSize, const void* paramData, uint32_t valueSize, 218 const void** valueData, std::vector<uint8_t>* halParamBuffer); 219 220 Result analyzeCommandStatus(const char* commandName, const char* context, status_t status); 221 void getConfigImpl(int commandCode, const char* commandName, GetConfigCallback cb); 222 Result getCurrentConfigImpl(uint32_t featureId, uint32_t configSize, 223 GetCurrentConfigSuccessCallback onSuccess); 224 Result getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize, 225 GetSupportedConfigsSuccessCallback onSuccess); 226 Result sendCommand(int commandCode, const char* commandName); 227 Result sendCommand(int commandCode, const char* commandName, uint32_t size, void* data); 228 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t* replySize, 229 void* replyData); 230 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t size, 231 void* data, uint32_t* replySize, void* replyData); 232 Result sendCommandReturningStatus(int commandCode, const char* commandName); 233 Result sendCommandReturningStatus(int commandCode, const char* commandName, uint32_t size, 234 void* data); 235 Result sendCommandReturningStatusAndData(int commandCode, const char* commandName, 236 uint32_t size, void* data, uint32_t* replySize, 237 void* replyData, uint32_t minReplySize, 238 CommandSuccessCallback onSuccess); 239 Result setConfigImpl(int commandCode, const char* commandName, const EffectConfig& config, 240 const sp<IEffectBufferProviderCallback>& inputBufferProvider, 241 const sp<IEffectBufferProviderCallback>& outputBufferProvider); 242 }; 243 244 } // namespace implementation 245 } // namespace CPP_VERSION 246 } // namespace effect 247 } // namespace audio 248 } // namespace hardware 249 } // namespace android 250 251 #endif // ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H 252