blob: f6a12d95e519b9b592a5beaed948fc8d9629eea2 [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;
Kevin Rocard96d2cd92018-11-14 16:22:07 -080050using ::android::hardware::audio::common::CPP_VERSION::AudioDevice;
51using ::android::hardware::audio::common::CPP_VERSION::AudioMode;
52using ::android::hardware::audio::common::CPP_VERSION::AudioSource;
53using ::android::hardware::audio::common::CPP_VERSION::Uuid;
54using ::android::hardware::audio::common::CPP_VERSION::implementation::AudioDeviceBitfield;
55using ::android::hardware::audio::effect::CPP_VERSION::AudioBuffer;
56using ::android::hardware::audio::effect::CPP_VERSION::EffectAuxChannelsConfig;
57using ::android::hardware::audio::effect::CPP_VERSION::EffectConfig;
58using ::android::hardware::audio::effect::CPP_VERSION::EffectDescriptor;
59using ::android::hardware::audio::effect::CPP_VERSION::EffectFeature;
60using ::android::hardware::audio::effect::CPP_VERSION::EffectOffloadParameter;
61using ::android::hardware::audio::effect::CPP_VERSION::IEffect;
62using ::android::hardware::audio::effect::CPP_VERSION::IEffectBufferProviderCallback;
63using ::android::hardware::audio::effect::CPP_VERSION::Result;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070064
65struct Effect : public IEffect {
Mikhail Naganova331de12017-01-04 16:33:55 -080066 typedef MessageQueue<Result, kSynchronizedReadWrite> StatusMQ;
Mikhail Naganov9f289042017-02-23 08:39:36 -080067 using GetParameterSuccessCallback =
Kevin Rocard22505e62017-12-14 18:50:12 -080068 std::function<void(uint32_t valueSize, const void* valueData)>;
Mikhail Naganova331de12017-01-04 16:33:55 -080069
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070070 explicit Effect(effect_handle_t handle);
71
Kevin Rocard96d2cd92018-11-14 16:22:07 -080072 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow.
Kevin Rocard22505e62017-12-14 18:50:12 -080073 Return<Result> init() override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070074 Return<Result> setConfig(
Kevin Rocard22505e62017-12-14 18:50:12 -080075 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
76 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override;
77 Return<Result> reset() override;
78 Return<Result> enable() override;
79 Return<Result> disable() override;
Kevin Rocard30a7fcc2018-03-01 15:08:07 -080080 Return<Result> setDevice(AudioDeviceBitfield device) override;
Kevin Rocard22505e62017-12-14 18:50:12 -080081 Return<void> setAndGetVolume(const hidl_vec<uint32_t>& volumes,
82 setAndGetVolume_cb _hidl_cb) override;
83 Return<Result> volumeChangeNotification(const hidl_vec<uint32_t>& volumes) override;
84 Return<Result> setAudioMode(AudioMode mode) override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070085 Return<Result> setConfigReverse(
Kevin Rocard22505e62017-12-14 18:50:12 -080086 const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
87 const sp<IEffectBufferProviderCallback>& outputBufferProvider) override;
Kevin Rocard30a7fcc2018-03-01 15:08:07 -080088 Return<Result> setInputDevice(AudioDeviceBitfield device) override;
Kevin Rocard22505e62017-12-14 18:50:12 -080089 Return<void> getConfig(getConfig_cb _hidl_cb) override;
90 Return<void> getConfigReverse(getConfigReverse_cb _hidl_cb) override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070091 Return<void> getSupportedAuxChannelsConfigs(
Kevin Rocard22505e62017-12-14 18:50:12 -080092 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> setAudioSource(AudioSource source) override;
96 Return<Result> offload(const EffectOffloadParameter& param) override;
97 Return<void> getDescriptor(getDescriptor_cb _hidl_cb) override;
98 Return<void> prepareForProcessing(prepareForProcessing_cb _hidl_cb) override;
99 Return<Result> setProcessBuffers(const AudioBuffer& inBuffer,
100 const AudioBuffer& outBuffer) override;
101 Return<void> command(uint32_t commandId, const hidl_vec<uint8_t>& data, uint32_t resultMaxSize,
102 command_cb _hidl_cb) override;
103 Return<Result> setParameter(const hidl_vec<uint8_t>& parameter,
104 const hidl_vec<uint8_t>& value) override;
105 Return<void> getParameter(const hidl_vec<uint8_t>& parameter, uint32_t valueMaxSize,
106 getParameter_cb _hidl_cb) override;
107 Return<void> getSupportedConfigsForFeature(uint32_t featureId, uint32_t maxConfigs,
108 uint32_t configSize,
109 getSupportedConfigsForFeature_cb _hidl_cb) override;
110 Return<void> getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize,
111 getCurrentConfigForFeature_cb _hidl_cb) override;
112 Return<Result> setCurrentConfigForFeature(uint32_t featureId,
113 const hidl_vec<uint8_t>& configData) override;
114 Return<Result> close() override;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700115
116 // Utility methods for extending interfaces.
Kevin Rocard22505e62017-12-14 18:50:12 -0800117 template <typename T>
118 Return<void> getIntegerParam(uint32_t paramId,
119 std::function<void(Result retval, T paramValue)> cb) {
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700120 T value;
Kevin Rocard22505e62017-12-14 18:50:12 -0800121 Result retval = getParameterImpl(sizeof(uint32_t), &paramId, sizeof(T),
122 [&](uint32_t valueSize, const void* valueData) {
123 if (valueSize > sizeof(T)) valueSize = sizeof(T);
124 memcpy(&value, valueData, valueSize);
125 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700126 cb(retval, value);
127 return Void();
128 }
129
Kevin Rocard22505e62017-12-14 18:50:12 -0800130 template <typename T>
131 Result getParam(uint32_t paramId, T& paramValue) {
132 return getParameterImpl(sizeof(uint32_t), &paramId, sizeof(T),
133 [&](uint32_t valueSize, const void* valueData) {
134 if (valueSize > sizeof(T)) valueSize = sizeof(T);
135 memcpy(&paramValue, valueData, valueSize);
136 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700137 }
138
Kevin Rocard22505e62017-12-14 18:50:12 -0800139 template <typename T>
140 Result getParam(uint32_t paramId, uint32_t paramArg, T& paramValue) {
141 uint32_t params[2] = {paramId, paramArg};
142 return getParameterImpl(sizeof(params), params, sizeof(T),
143 [&](uint32_t valueSize, const void* valueData) {
144 if (valueSize > sizeof(T)) valueSize = sizeof(T);
145 memcpy(&paramValue, valueData, valueSize);
146 });
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700147 }
148
Kevin Rocard22505e62017-12-14 18:50:12 -0800149 template <typename T>
150 Result setParam(uint32_t paramId, const T& paramValue) {
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700151 return setParameterImpl(sizeof(uint32_t), &paramId, sizeof(T), &paramValue);
152 }
153
Kevin Rocard22505e62017-12-14 18:50:12 -0800154 template <typename T>
155 Result setParam(uint32_t paramId, uint32_t paramArg, const T& paramValue) {
156 uint32_t params[2] = {paramId, paramArg};
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700157 return setParameterImpl(sizeof(params), params, sizeof(T), &paramValue);
158 }
159
Kevin Rocard22505e62017-12-14 18:50:12 -0800160 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize,
161 GetParameterSuccessCallback onSuccess) {
Mikhail Naganov9f289042017-02-23 08:39:36 -0800162 return getParameterImpl(paramSize, paramData, valueSize, valueSize, onSuccess);
163 }
Kevin Rocard22505e62017-12-14 18:50:12 -0800164 Result getParameterImpl(uint32_t paramSize, const void* paramData, uint32_t requestValueSize,
165 uint32_t replyValueSize, GetParameterSuccessCallback onSuccess);
166 Result setParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize,
167 const void* valueData);
Mikhail Naganov9f289042017-02-23 08:39:36 -0800168
Kevin Rocard22505e62017-12-14 18:50:12 -0800169 private:
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700170 friend struct VirtualizerEffect; // for getParameterImpl
171 friend struct VisualizerEffect; // to allow executing commands
172
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700173 using CommandSuccessCallback = std::function<void()>;
174 using GetConfigCallback = std::function<void(Result retval, const EffectConfig& config)>;
175 using GetCurrentConfigSuccessCallback = std::function<void(void* configData)>;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700176 using GetSupportedConfigsSuccessCallback =
Kevin Rocard22505e62017-12-14 18:50:12 -0800177 std::function<void(uint32_t supportedConfigs, void* configsData)>;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700178
Kevin Rocard22505e62017-12-14 18:50:12 -0800179 static const char* sContextResultOfCommand;
180 static const char* sContextCallToCommand;
181 static const char* sContextCallFunction;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700182
Mikhail Naganova331de12017-01-04 16:33:55 -0800183 bool mIsClosed;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700184 effect_handle_t mHandle;
Mikhail Naganova331de12017-01-04 16:33:55 -0800185 sp<AudioBufferWrapper> mInBuffer;
186 sp<AudioBufferWrapper> mOutBuffer;
187 std::atomic<audio_buffer_t*> mHalInBufferPtr;
188 std::atomic<audio_buffer_t*> mHalOutBufferPtr;
189 std::unique_ptr<StatusMQ> mStatusMQ;
190 EventFlag* mEfGroup;
191 std::atomic<bool> mStopProcessThread;
192 sp<Thread> mProcessThread;
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700193
194 virtual ~Effect();
195
Kevin Rocard22505e62017-12-14 18:50:12 -0800196 template <typename T>
197 static size_t alignedSizeIn(size_t s);
198 template <typename T>
199 std::unique_ptr<uint8_t[]> hidlVecToHal(const hidl_vec<T>& vec, uint32_t* halDataSize);
200 static void effectAuxChannelsConfigFromHal(const channel_config_t& halConfig,
201 EffectAuxChannelsConfig* config);
202 static void effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config,
203 channel_config_t* halConfig);
204 static void effectBufferConfigFromHal(const buffer_config_t& halConfig,
205 EffectBufferConfig* config);
206 static void effectBufferConfigToHal(const EffectBufferConfig& config,
207 buffer_config_t* halConfig);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700208 static void effectConfigFromHal(const effect_config_t& halConfig, EffectConfig* config);
209 static void effectConfigToHal(const EffectConfig& config, effect_config_t* halConfig);
Kevin Rocard22505e62017-12-14 18:50:12 -0800210 static void effectOffloadParamToHal(const EffectOffloadParameter& offload,
211 effect_offload_param_t* halOffload);
212 static std::vector<uint8_t> parameterToHal(uint32_t paramSize, const void* paramData,
213 uint32_t valueSize, const void** valueData);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700214
Kevin Rocard22505e62017-12-14 18:50:12 -0800215 Result analyzeCommandStatus(const char* commandName, const char* context, status_t status);
216 Result analyzeStatus(const char* funcName, const char* subFuncName,
217 const char* contextDescription, status_t status);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700218 void getConfigImpl(int commandCode, const char* commandName, GetConfigCallback cb);
Kevin Rocard22505e62017-12-14 18:50:12 -0800219 Result getCurrentConfigImpl(uint32_t featureId, uint32_t configSize,
220 GetCurrentConfigSuccessCallback onSuccess);
221 Result getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize,
222 GetSupportedConfigsSuccessCallback onSuccess);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700223 Result sendCommand(int commandCode, const char* commandName);
224 Result sendCommand(int commandCode, const char* commandName, uint32_t size, void* data);
Kevin Rocard22505e62017-12-14 18:50:12 -0800225 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t* replySize,
226 void* replyData);
227 Result sendCommandReturningData(int commandCode, const char* commandName, uint32_t size,
228 void* data, uint32_t* replySize, void* replyData);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700229 Result sendCommandReturningStatus(int commandCode, const char* commandName);
Kevin Rocard22505e62017-12-14 18:50:12 -0800230 Result sendCommandReturningStatus(int commandCode, const char* commandName, uint32_t size,
231 void* data);
232 Result sendCommandReturningStatusAndData(int commandCode, const char* commandName,
233 uint32_t size, void* data, uint32_t* replySize,
234 void* replyData, uint32_t minReplySize,
235 CommandSuccessCallback onSuccess);
236 Result setConfigImpl(int commandCode, const char* commandName, const EffectConfig& config,
237 const sp<IEffectBufferProviderCallback>& inputBufferProvider,
238 const sp<IEffectBufferProviderCallback>& outputBufferProvider);
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700239};
240
241} // namespace implementation
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800242} // namespace CPP_VERSION
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -0700243} // namespace effect
244} // namespace audio
245} // namespace hardware
246} // namespace android
Kevin Rocard96d2cd92018-11-14 16:22:07 -0800247
248#endif // ANDROID_HARDWARE_AUDIO_EFFECT_EFFECT_H