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 <tuple> 27 #include <vector> 28 #include <mutex> 29 30 #include <fmq/EventFlag.h> 31 #include <fmq/MessageQueue.h> 32 #include <hidl/MQDescriptor.h> 33 #include <hidl/Status.h> 34 #include <mediautils/MethodStatistics.h> 35 #include <utils/Thread.h> 36 37 #include <hardware/audio_effect.h> 38 39 #include "VersionUtils.h" 40 41 namespace android { 42 namespace hardware { 43 namespace audio { 44 namespace effect { 45 namespace CPP_VERSION { 46 namespace implementation { 47 48 using ::android::sp; 49 using ::android::hardware::hidl_string; 50 using ::android::hardware::hidl_vec; 51 using ::android::hardware::Return; 52 using ::android::hardware::Void; 53 #if MAJOR_VERSION <= 6 54 using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation:: 55 AudioDeviceBitfield; 56 #endif 57 using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION; 58 using namespace ::android::hardware::audio::effect::CPP_VERSION; 59 60 struct Effect : public IEffect { 61 typedef MessageQueue<Result, kSynchronizedReadWrite> StatusMQ; 62 using GetParameterSuccessCallback = 63 std::function<void(uint32_t valueSize, const void* valueData)>; 64 65 Effect(bool isInput, effect_handle_t handle); 66 67 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow. 68 Return<Result> init() override; 69 Return<Result> setConfig( 70 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider, 71 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override; 72 Return<Result> reset() override; 73 Return<Result> enable() override; 74 Return<Result> disable() override; 75 #if MAJOR_VERSION <= 6 76 Return<Result> setAudioSource(AudioSource source) override; 77 Return<Result> setDevice(AudioDeviceBitfield device) override; 78 Return<Result> setInputDevice(AudioDeviceBitfield device) override; 79 #else 80 Return<Result> setAudioSource(const AudioSource& source) override; 81 Return<Result> setDevice(const DeviceAddress& device) override; 82 Return<Result> setInputDevice(const DeviceAddress& device) override; 83 #endif 84 Return<void> setAndGetVolume(const hidl_vec<uint32_t>& volumes, 85 setAndGetVolume_cb _hidl_cb) override; 86 Return<Result> volumeChangeNotification(const hidl_vec<uint32_t>& volumes) override; 87 Return<Result> setAudioMode(AudioMode mode) override; 88 Return<Result> setConfigReverse( 89 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider, 90 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override; 91 Return<void> getConfig(getConfig_cb _hidl_cb) override; 92 Return<void> getConfigReverse(getConfigReverse_cb _hidl_cb) override; 93 Return<void> getSupportedAuxChannelsConfigs( 94 uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) override; 95 Return<void> getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) override; 96 Return<Result> setAuxChannelsConfig(const EffectAuxChannelsConfig& config) override; 97 Return<Result> offload(const EffectOffloadParameter& param) override; 98 Return<void> getDescriptor(getDescriptor_cb _hidl_cb) override; 99 Return<void> prepareForProcessing(prepareForProcessing_cb _hidl_cb) override; 100 Return<Result> setProcessBuffers(const AudioBuffer& inBuffer, 101 const AudioBuffer& outBuffer) override; 102 Return<void> command(uint32_t commandId, const hidl_vec<uint8_t>& data, uint32_t resultMaxSize, 103 command_cb _hidl_cb) override; 104 Return<Result> setParameter(const hidl_vec<uint8_t>& parameter, 105 const hidl_vec<uint8_t>& value) override; 106 Return<void> getParameter(const hidl_vec<uint8_t>& parameter, uint32_t valueMaxSize, 107 getParameter_cb _hidl_cb) override; 108 Return<void> getSupportedConfigsForFeature(uint32_t featureId, uint32_t maxConfigs, 109 uint32_t configSize, 110 getSupportedConfigsForFeature_cb _hidl_cb) override; 111 Return<void> getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize, 112 getCurrentConfigForFeature_cb _hidl_cb) override; 113 Return<Result> setCurrentConfigForFeature(uint32_t featureId, 114 const hidl_vec<uint8_t>& configData) override; 115 Return<Result> close() override; 116 Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options) override; 117 118 // Utility methods for extending interfaces. 119 static const char* sContextConversion; 120 121 Result analyzeStatus(const char* funcName, const char* subFuncName, 122 const char* contextDescription, status_t status); 123 template <typename T> getIntegerParamEffect124 Return<void> getIntegerParam(uint32_t paramId, 125 std::function<void(Result retval, T paramValue)> cb) { 126 T value; 127 Result retval = getParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), 128 [&](uint32_t valueSize, const void* valueData) { 129 if (valueSize > sizeof(T)) valueSize = sizeof(T); 130 memcpy(&value, valueData, valueSize); 131 }); 132 cb(retval, value); 133 return Void(); 134 } 135 136 template <typename T> getParamEffect137 Result getParam(uint32_t paramId, T& paramValue) { 138 return getParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), 139 [&](uint32_t valueSize, const void* valueData) { 140 if (valueSize > sizeof(T)) valueSize = sizeof(T); 141 memcpy(¶mValue, valueData, valueSize); 142 }); 143 } 144 145 template <typename T> getParamEffect146 Result getParam(uint32_t paramId, uint32_t paramArg, T& paramValue) { 147 uint32_t params[2] = {paramId, paramArg}; 148 return getParameterImpl(sizeof(params), params, sizeof(T), 149 [&](uint32_t valueSize, const void* valueData) { 150 if (valueSize > sizeof(T)) valueSize = sizeof(T); 151 memcpy(¶mValue, valueData, valueSize); 152 }); 153 } 154 155 template <typename T> setParamEffect156 Result setParam(uint32_t paramId, const T& paramValue) { 157 return setParameterImpl(sizeof(uint32_t), ¶mId, sizeof(T), ¶mValue); 158 } 159 160 template <typename T> setParamEffect161 Result setParam(uint32_t paramId, uint32_t paramArg, const T& paramValue) { 162 uint32_t params[2] = {paramId, paramArg}; 163 return setParameterImpl(sizeof(params), params, sizeof(T), ¶mValue); 164 } 165 getParameterImplEffect166 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize, 167 GetParameterSuccessCallback onSuccess) { 168 return getParameterImpl(paramSize, paramData, valueSize, valueSize, onSuccess); 169 } 170 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t requestValueSize, 171 uint32_t replyValueSize, GetParameterSuccessCallback onSuccess); 172 Result setParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize, 173 const void* valueData); 174 175 // process execution statistics 176 const std::shared_ptr<mediautils::MethodStatistics<std::string>> mStatistics = 177 std::make_shared<mediautils::MethodStatistics<std::string>>(); 178 179 private: 180 friend struct VirtualizerEffect; // for getParameterImpl 181 friend struct VisualizerEffect; // to allow executing commands 182 183 using CommandSuccessCallback = std::function<void()>; 184 using GetConfigCallback = std::function<void(Result retval, const EffectConfig& config)>; 185 using GetCurrentConfigSuccessCallback = std::function<void(void* configData)>; 186 using GetSupportedConfigsSuccessCallback = 187 std::function<void(uint32_t supportedConfigs, void* configsData)>; 188 189 // Sets the limit on the maximum size of vendor-provided data structures. 190 static constexpr size_t kMaxDataSize = 1 << 20; 191 static constexpr effect_handle_t kInvalidEffectHandle = nullptr; 192 193 static const char* sContextResultOfCommand; 194 static const char* sContextCallToCommand; 195 static const char* sContextCallFunction; 196 197 const bool mIsInput; 198 std::mutex mLock; 199 effect_handle_t mHandle GUARDED_BY(mLock); 200 sp<AudioBufferWrapper> mInBuffer; 201 sp<AudioBufferWrapper> mOutBuffer; 202 std::atomic<audio_buffer_t*> mHalInBufferPtr; 203 std::atomic<audio_buffer_t*> mHalOutBufferPtr; 204 std::unique_ptr<StatusMQ> mStatusMQ; 205 std::atomic<EventFlag*> mEfGroup; 206 std::atomic<bool> mStopProcessThread; 207 sp<Thread> mProcessThread; 208 209 virtual ~Effect(); 210 211 template <typename T> 212 static size_t alignedSizeIn(size_t s); 213 template <typename T> 214 std::unique_ptr<uint8_t[]> hidlVecToHal(const hidl_vec<T>& vec, uint32_t* halDataSize); 215 std::tuple<Result, effect_handle_t> closeImpl(); 216 void effectAuxChannelsConfigFromHal(const channel_config_t& halConfig, 217 EffectAuxChannelsConfig* config); 218 static void effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config, 219 channel_config_t* halConfig); 220 static void effectOffloadParamToHal(const EffectOffloadParameter& offload, 221 effect_offload_param_t* halOffload); 222 static bool parameterToHal(uint32_t paramSize, const void* paramData, uint32_t valueSize, 223 const void** valueData, std::vector<uint8_t>* halParamBuffer); 224 225 Result analyzeCommandStatus(const char* commandName, const char* context, status_t status); 226 Return<void> getConfigImpl(int commandCode, const char* commandName, 227 GetConfigCallback _hidl_cb); 228 Result getCurrentConfigImpl(uint32_t featureId, uint32_t configSize, 229 GetCurrentConfigSuccessCallback onSuccess); 230 Result getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize, 231 GetSupportedConfigsSuccessCallback onSuccess); 232 Result sendCommand(int commandCode, const char* commandName); 233 Result sendCommand(int commandCode, const char* commandName, uint32_t size, void* data); 234 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t* replySize, 235 void* replyData); 236 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t size, 237 void* data, uint32_t* replySize, void* replyData); 238 Result sendCommandReturningStatus(int commandCode, const char* commandName); 239 Result sendCommandReturningStatus(int commandCode, const char* commandName, uint32_t size, 240 void* data); 241 Result sendCommandReturningStatusAndData(int commandCode, const char* commandName, 242 uint32_t size, void* data, uint32_t* replySize, 243 void* replyData, uint32_t minReplySize, 244 CommandSuccessCallback onSuccess); 245 Result setConfigImpl(int commandCode, const char* commandName, const EffectConfig& config, 246 const sp<IEffectBufferProviderCallback>& inputBufferProvider, 247 const sp<IEffectBufferProviderCallback>& outputBufferProvider); 248 }; 249 250 } // namespace implementation 251 } // namespace CPP_VERSION 252 } // namespace effect 253 } // namespace audio 254 } // namespace hardware 255 } // namespace android 256 257 #endif // ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H 258