blob: 9aa47ea7d9ab6137b818a5f7d99a9a5c8713045e [file] [log] [blame]
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -07001/*
Kevin Rocard96d2cd92018-11-14 16:22:07 -08002 * Copyright (C) 2018 The Android Open Source Project
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -07003 *
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
Kevin Rocard96d2cd92018-11-14 16:22:07 -080017#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"
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070023
Mikhail Naganova331de12017-01-04 16:33:55 -080024#include <atomic>
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -080025#include <memory>
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070026#include <vector>
27
Mikhail Naganova331de12017-01-04 16:33:55 -080028#include <fmq/EventFlag.h>
29#include <fmq/MessageQueue.h>
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070030#include <hidl/MQDescriptor.h>
Mikhail Naganova331de12017-01-04 16:33:55 -080031#include <hidl/Status.h>
32#include <utils/Thread.h>
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070033
34#include <hardware/audio_effect.h>
35
Kevin Rocard30a7fcc2018-03-01 15:08:07 -080036#include "VersionUtils.h"
37
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070038namespace android {
39namespace hardware {
40namespace audio {
41namespace effect {
Kevin Rocard96d2cd92018-11-14 16:22:07 -080042namespace CPP_VERSION {
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070043namespace implementation {
44
Kevin Rocard55b10612018-11-12 12:33:16 -080045using ::android::sp;
46using ::android::hardware::hidl_string;
47using ::android::hardware::hidl_vec;
48using ::android::hardware::Return;
49using ::android::hardware::Void;
Mikhail Naganov9036eda2020-12-10 18:47:51 -080050#if MAJOR_VERSION <= 6
Kevin Rocard96d2cd92018-11-14 16:22:07 -080051using ::android::hardware::audio::common::CPP_VERSION::implementation::AudioDeviceBitfield;
Mikhail Naganov9036eda2020-12-10 18:47:51 -080052#endif
Mikhail Naganov3907f762018-12-13 09:42:17 -080053using namespace ::android::hardware::audio::common::CPP_VERSION;
54using namespace ::android::hardware::audio::effect::CPP_VERSION;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070055
56struct Effect : public IEffect {
Mikhail Naganova331de12017-01-04 16:33:55 -080057 typedef MessageQueue<Result, kSynchronizedReadWrite> StatusMQ;
Mikhail Naganov9f289042017-02-23 08:39:36 -080058 using GetParameterSuccessCallback =
Kevin Rocard22505e62017-12-14 18:50:12 -080059 std::function<void(uint32_t valueSize, const void* valueData)>;
Mikhail Naganova331de12017-01-04 16:33:55 -080060
Mikhail Naganov9036eda2020-12-10 18:47:51 -080061 Effect(bool isInput, effect_handle_t handle);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070062
Kevin Rocard96d2cd92018-11-14 16:22:07 -080063 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow.
Kevin Rocard22505e62017-12-14 18:50:12 -080064 Return<Result> init() override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070065 Return<Result> setConfig(
Kevin Rocard22505e62017-12-14 18:50:12 -080066 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
67 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override;
68 Return<Result> reset() override;
69 Return<Result> enable() override;
70 Return<Result> disable() override;
Mikhail Naganov9036eda2020-12-10 18:47:51 -080071#if MAJOR_VERSION <= 6
72 Return<Result> setAudioSource(AudioSource source) override;
Kevin Rocard30a7fcc2018-03-01 15:08:07 -080073 Return<Result> setDevice(AudioDeviceBitfield device) override;
Mikhail Naganov9036eda2020-12-10 18:47:51 -080074 Return<Result> setInputDevice(AudioDeviceBitfield device) override;
75#else
76 Return<Result> setAudioSource(const AudioSource& source) override;
77 Return<Result> setDevice(const DeviceAddress& device) override;
78 Return<Result> setInputDevice(const DeviceAddress& device) override;
79#endif
Kevin Rocard22505e62017-12-14 18:50:12 -080080 Return<void> setAndGetVolume(const hidl_vec<uint32_t>& volumes,
81 setAndGetVolume_cb _hidl_cb) override;
82 Return<Result> volumeChangeNotification(const hidl_vec<uint32_t>& volumes) override;
83 Return<Result> setAudioMode(AudioMode mode) override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070084 Return<Result> setConfigReverse(
Kevin Rocard22505e62017-12-14 18:50:12 -080085 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
86 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override;
Kevin Rocard22505e62017-12-14 18:50:12 -080087 Return<void> getConfig(getConfig_cb _hidl_cb) override;
88 Return<void> getConfigReverse(getConfigReverse_cb _hidl_cb) override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070089 Return<void> getSupportedAuxChannelsConfigs(
Kevin Rocard22505e62017-12-14 18:50:12 -080090 uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) override;
91 Return<void> getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) override;
92 Return<Result> setAuxChannelsConfig(const EffectAuxChannelsConfig& config) override;
Kevin Rocard22505e62017-12-14 18:50:12 -080093 Return<Result> offload(const EffectOffloadParameter& param) override;
94 Return<void> getDescriptor(getDescriptor_cb _hidl_cb) override;
95 Return<void> prepareForProcessing(prepareForProcessing_cb _hidl_cb) override;
96 Return<Result> setProcessBuffers(const AudioBuffer& inBuffer,
97 const AudioBuffer& outBuffer) override;
98 Return<void> command(uint32_t commandId, const hidl_vec<uint8_t>& data, uint32_t resultMaxSize,
99 command_cb _hidl_cb) override;
100 Return<Result> setParameter(const hidl_vec<uint8_t>& parameter,
101 const hidl_vec<uint8_t>& value) override;
102 Return<void> getParameter(const hidl_vec<uint8_t>& parameter, uint32_t valueMaxSize,
103 getParameter_cb _hidl_cb) override;
104 Return<void> getSupportedConfigsForFeature(uint32_t featureId, uint32_t maxConfigs,
105 uint32_t configSize,
106 getSupportedConfigsForFeature_cb _hidl_cb) override;
107 Return<void> getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize,
108 getCurrentConfigForFeature_cb _hidl_cb) override;
109 Return<Result> setCurrentConfigForFeature(uint32_t featureId,
110 const hidl_vec<uint8_t>& configData) override;
111 Return<Result> close() override;
Mikhail Naganovfa021442019-02-22 14:28:26 -0800112 Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options) override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700113
114 // Utility methods for extending interfaces.
Mikhail Naganov9036eda2020-12-10 18:47:51 -0800115 static const char* sContextConversion;
116
117 Result analyzeStatus(const char* funcName, const char* subFuncName,
118 const char* contextDescription, status_t status);
Kevin Rocard22505e62017-12-14 18:50:12 -0800119 template <typename T>
120 Return<void> getIntegerParam(uint32_t paramId,
121 std::function<void(Result retval, T paramValue)> cb) {
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700122 T value;
Kevin Rocard22505e62017-12-14 18:50:12 -0800123 Result retval = getParameterImpl(sizeof(uint32_t), &paramId, sizeof(T),
124 [&](uint32_t valueSize, const void* valueData) {
125 if (valueSize > sizeof(T)) valueSize = sizeof(T);
126 memcpy(&value, valueData, valueSize);
127 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700128 cb(retval, value);
129 return Void();
130 }
131
Kevin Rocard22505e62017-12-14 18:50:12 -0800132 template <typename T>
133 Result getParam(uint32_t paramId, T& paramValue) {
134 return getParameterImpl(sizeof(uint32_t), &paramId, sizeof(T),
135 [&](uint32_t valueSize, const void* valueData) {
136 if (valueSize > sizeof(T)) valueSize = sizeof(T);
137 memcpy(&paramValue, valueData, valueSize);
138 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700139 }
140
Kevin Rocard22505e62017-12-14 18:50:12 -0800141 template <typename T>
142 Result getParam(uint32_t paramId, uint32_t paramArg, T& paramValue) {
143 uint32_t params[2] = {paramId, paramArg};
144 return getParameterImpl(sizeof(params), params, sizeof(T),
145 [&](uint32_t valueSize, const void* valueData) {
146 if (valueSize > sizeof(T)) valueSize = sizeof(T);
147 memcpy(&paramValue, valueData, valueSize);
148 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700149 }
150
Kevin Rocard22505e62017-12-14 18:50:12 -0800151 template <typename T>
152 Result setParam(uint32_t paramId, const T& paramValue) {
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700153 return setParameterImpl(sizeof(uint32_t), &paramId, sizeof(T), &paramValue);
154 }
155
Kevin Rocard22505e62017-12-14 18:50:12 -0800156 template <typename T>
157 Result setParam(uint32_t paramId, uint32_t paramArg, const T& paramValue) {
158 uint32_t params[2] = {paramId, paramArg};
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700159 return setParameterImpl(sizeof(params), params, sizeof(T), &paramValue);
160 }
161
Kevin Rocard22505e62017-12-14 18:50:12 -0800162 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize,
163 GetParameterSuccessCallback onSuccess) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800164 return getParameterImpl(paramSize, paramData, valueSize, valueSize, onSuccess);
165 }
Kevin Rocard22505e62017-12-14 18:50:12 -0800166 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t requestValueSize,
167 uint32_t replyValueSize, GetParameterSuccessCallback onSuccess);
168 Result setParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize,
169 const void* valueData);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800170
Kevin Rocard22505e62017-12-14 18:50:12 -0800171 private:
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700172 friend struct VirtualizerEffect; // for getParameterImpl
173 friend struct VisualizerEffect; // to allow executing commands
174
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700175 using CommandSuccessCallback = std::function<void()>;
176 using GetConfigCallback = std::function<void(Result retval, const EffectConfig& config)>;
177 using GetCurrentConfigSuccessCallback = std::function<void(void* configData)>;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700178 using GetSupportedConfigsSuccessCallback =
Kevin Rocard22505e62017-12-14 18:50:12 -0800179 std::function<void(uint32_t supportedConfigs, void* configsData)>;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700180
Kevin Rocard22505e62017-12-14 18:50:12 -0800181 static const char* sContextResultOfCommand;
182 static const char* sContextCallToCommand;
183 static const char* sContextCallFunction;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700184
Mikhail Naganov9036eda2020-12-10 18:47:51 -0800185 const bool mIsInput;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700186 effect_handle_t mHandle;
Mikhail Naganova331de12017-01-04 16:33:55 -0800187 sp<AudioBufferWrapper> mInBuffer;
188 sp<AudioBufferWrapper> mOutBuffer;
189 std::atomic<audio_buffer_t*> mHalInBufferPtr;
190 std::atomic<audio_buffer_t*> mHalOutBufferPtr;
191 std::unique_ptr<StatusMQ> mStatusMQ;
192 EventFlag* mEfGroup;
193 std::atomic<bool> mStopProcessThread;
194 sp<Thread> mProcessThread;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700195
196 virtual ~Effect();
197
Kevin Rocard22505e62017-12-14 18:50:12 -0800198 template <typename T>
199 static size_t alignedSizeIn(size_t s);
200 template <typename T>
201 std::unique_ptr<uint8_t[]> hidlVecToHal(const hidl_vec<T>& vec, uint32_t* halDataSize);
Mikhail Naganov9036eda2020-12-10 18:47:51 -0800202 void effectAuxChannelsConfigFromHal(const channel_config_t& halConfig,
203 EffectAuxChannelsConfig* config);
Kevin Rocard22505e62017-12-14 18:50:12 -0800204 static void effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config,
205 channel_config_t* halConfig);
Mikhail Naganov9036eda2020-12-10 18:47:51 -0800206 void effectBufferConfigFromHal(const buffer_config_t& halConfig, EffectBufferConfig* config);
Kevin Rocard22505e62017-12-14 18:50:12 -0800207 static void effectBufferConfigToHal(const EffectBufferConfig& config,
208 buffer_config_t* halConfig);
Mikhail Naganov9036eda2020-12-10 18:47:51 -0800209 void effectConfigFromHal(const effect_config_t& halConfig, EffectConfig* config);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700210 static void effectConfigToHal(const EffectConfig& config, effect_config_t* halConfig);
Kevin Rocard22505e62017-12-14 18:50:12 -0800211 static void effectOffloadParamToHal(const EffectOffloadParameter& offload,
212 effect_offload_param_t* halOffload);
213 static std::vector<uint8_t> parameterToHal(uint32_t paramSize, const void* paramData,
214 uint32_t valueSize, const void** valueData);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700215
Kevin Rocard22505e62017-12-14 18:50:12 -0800216 Result analyzeCommandStatus(const char* commandName, const char* context, status_t status);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700217 void getConfigImpl(int commandCode, const char* commandName, GetConfigCallback cb);
Kevin Rocard22505e62017-12-14 18:50:12 -0800218 Result getCurrentConfigImpl(uint32_t featureId, uint32_t configSize,
219 GetCurrentConfigSuccessCallback onSuccess);
220 Result getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize,
221 GetSupportedConfigsSuccessCallback onSuccess);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700222 Result sendCommand(int commandCode, const char* commandName);
223 Result sendCommand(int commandCode, const char* commandName, uint32_t size, void* data);
Kevin Rocard22505e62017-12-14 18:50:12 -0800224 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t* replySize,
225 void* replyData);
226 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t size,
227 void* data, uint32_t* replySize, void* replyData);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700228 Result sendCommandReturningStatus(int commandCode, const char* commandName);
Kevin Rocard22505e62017-12-14 18:50:12 -0800229 Result sendCommandReturningStatus(int commandCode, const char* commandName, uint32_t size,
230 void* data);
231 Result sendCommandReturningStatusAndData(int commandCode, const char* commandName,
232 uint32_t size, void* data, uint32_t* replySize,
233 void* replyData, uint32_t minReplySize,
234 CommandSuccessCallback onSuccess);
235 Result setConfigImpl(int commandCode, const char* commandName, const EffectConfig& config,
236 const sp<IEffectBufferProviderCallback>& inputBufferProvider,
237 const sp<IEffectBufferProviderCallback>& outputBufferProvider);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700238};
239
240} // namespace implementation
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800241} // namespace CPP_VERSION
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700242} // namespace effect
243} // namespace audio
244} // namespace hardware
245} // namespace android
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800246
247#endif // ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H