Effect.h revision a331de14219b34b08f4cbb462a45f1fd82a92d48 
1/*
2 * Copyright (C) 2016 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_V2_0_EFFECT_H
18#define ANDROID_HARDWARE_AUDIO_EFFECT_V2_0_EFFECT_H
19
20#include <atomic>
21#include <memory>
22#include <vector>
23
24#include <android/hardware/audio/effect/2.0/IEffect.h>
25#include <fmq/EventFlag.h>
26#include <fmq/MessageQueue.h>
27#include <hidl/MQDescriptor.h>
28#include <hidl/Status.h>
29#include <utils/Thread.h>
30
31#include <hardware/audio_effect.h>
32
33#include "AudioBufferManager.h"
34
35namespace android {
36namespace hardware {
37namespace audio {
38namespace effect {
39namespace V2_0 {
40namespace implementation {
41
42using ::android::hardware::audio::common::V2_0::AudioDevice;
43using ::android::hardware::audio::common::V2_0::AudioMode;
44using ::android::hardware::audio::common::V2_0::AudioSource;
45using ::android::hardware::audio::common::V2_0::Uuid;
46using ::android::hardware::audio::effect::V2_0::AudioBuffer;
47using ::android::hardware::audio::effect::V2_0::EffectAuxChannelsConfig;
48using ::android::hardware::audio::effect::V2_0::EffectConfig;
49using ::android::hardware::audio::effect::V2_0::EffectDescriptor;
50using ::android::hardware::audio::effect::V2_0::EffectFeature;
51using ::android::hardware::audio::effect::V2_0::EffectOffloadParameter;
52using ::android::hardware::audio::effect::V2_0::IEffect;
53using ::android::hardware::audio::effect::V2_0::IEffectBufferProviderCallback;
54using ::android::hardware::audio::effect::V2_0::Result;
55using ::android::hardware::Return;
56using ::android::hardware::Void;
57using ::android::hardware::hidl_vec;
58using ::android::hardware::hidl_string;
59using ::android::sp;
60
61struct Effect : public IEffect {
62    typedef MessageQueue<Result, kSynchronizedReadWrite> StatusMQ;
63
64    explicit Effect(effect_handle_t handle);
65
66    // Methods from ::android::hardware::audio::effect::V2_0::IEffect follow.
67    Return<Result> init()  override;
68    Return<Result> setConfig(
69            const EffectConfig& config,
70            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    Return<Result> setDevice(AudioDevice device)  override;
76    Return<void> setAndGetVolume(
77            const hidl_vec<uint32_t>& volumes, setAndGetVolume_cb _hidl_cb)  override;
78    Return<Result> setAudioMode(AudioMode mode)  override;
79    Return<Result> setConfigReverse(
80            const EffectConfig& config,
81            const sp<IEffectBufferProviderCallback>& inputBufferProvider,
82            const sp<IEffectBufferProviderCallback>& outputBufferProvider)  override;
83    Return<Result> setInputDevice(AudioDevice device)  override;
84    Return<void> getConfig(getConfig_cb _hidl_cb)  override;
85    Return<void> getConfigReverse(getConfigReverse_cb _hidl_cb)  override;
86    Return<void> getSupportedAuxChannelsConfigs(
87            uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb)  override;
88    Return<void> getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb)  override;
89    Return<Result> setAuxChannelsConfig(const EffectAuxChannelsConfig& config)  override;
90    Return<Result> setAudioSource(AudioSource source)  override;
91    Return<Result> offload(const EffectOffloadParameter& param)  override;
92    Return<void> getDescriptor(getDescriptor_cb _hidl_cb)  override;
93    Return<void> prepareForProcessing(prepareForProcessing_cb _hidl_cb)  override;
94    Return<Result> setProcessBuffers(
95            const AudioBuffer& inBuffer, const AudioBuffer& outBuffer)  override;
96    Return<void> command(
97            uint32_t commandId,
98            const hidl_vec<uint8_t>& data,
99            uint32_t resultMaxSize,
100            command_cb _hidl_cb)  override;
101    Return<Result> setParameter(
102            const hidl_vec<uint8_t>& parameter, const hidl_vec<uint8_t>& value)  override;
103    Return<void> getParameter(
104            const hidl_vec<uint8_t>& parameter,
105            uint32_t valueMaxSize,
106            getParameter_cb _hidl_cb)  override;
107    Return<void> getSupportedConfigsForFeature(
108            uint32_t featureId,
109            uint32_t maxConfigs,
110            uint32_t configSize,
111            getSupportedConfigsForFeature_cb _hidl_cb)  override;
112    Return<void> getCurrentConfigForFeature(
113            uint32_t featureId,
114            uint32_t configSize,
115            getCurrentConfigForFeature_cb _hidl_cb)  override;
116    Return<Result> setCurrentConfigForFeature(
117            uint32_t featureId, const hidl_vec<uint8_t>& configData)  override;
118    Return<Result> close()  override;
119
120    // Utility methods for extending interfaces.
121    template<typename T> Return<void> getIntegerParam(
122            uint32_t paramId, std::function<void(Result retval, T paramValue)> cb) {
123        T value;
124        Result retval = getParameterImpl(
125                sizeof(uint32_t), &paramId,
126                sizeof(T),
127                [&] (uint32_t valueSize, const void* valueData) {
128                    if (valueSize > sizeof(T)) valueSize = sizeof(T);
129                    memcpy(&value, valueData, valueSize);
130                });
131        cb(retval, value);
132        return Void();
133    }
134
135    template<typename T> Result getParam(uint32_t paramId, T& paramValue) {
136        return getParameterImpl(
137                sizeof(uint32_t), &paramId,
138                sizeof(T),
139                [&] (uint32_t valueSize, const void* valueData) {
140                    if (valueSize > sizeof(T)) valueSize = sizeof(T);
141                    memcpy(&paramValue, valueData, valueSize);
142                });
143    }
144
145    template<typename T> Result getParam(uint32_t paramId, uint32_t paramArg, T& paramValue) {
146        uint32_t params[2] = { paramId, paramArg };
147        return getParameterImpl(
148                sizeof(params), params,
149                sizeof(T),
150                [&] (uint32_t valueSize, const void* valueData) {
151                    if (valueSize > sizeof(T)) valueSize = sizeof(T);
152                    memcpy(&paramValue, valueData, valueSize);
153                });
154    }
155
156    template<typename T> Result setParam(uint32_t paramId, const T& paramValue) {
157        return setParameterImpl(sizeof(uint32_t), &paramId, sizeof(T), &paramValue);
158    }
159
160    template<typename T> Result setParam(uint32_t paramId, uint32_t paramArg, const T& paramValue) {
161        uint32_t params[2] = { paramId, paramArg };
162        return setParameterImpl(sizeof(params), params, sizeof(T), &paramValue);
163    }
164
165  private:
166    friend struct VirtualizerEffect;  // for getParameterImpl
167    friend struct VisualizerEffect;   // to allow executing commands
168
169    using CommandSuccessCallback = std::function<void()>;
170    using GetConfigCallback = std::function<void(Result retval, const EffectConfig& config)>;
171    using GetCurrentConfigSuccessCallback = std::function<void(void* configData)>;
172    using GetParameterSuccessCallback =
173            std::function<void(uint32_t valueSize, const void* valueData)>;
174    using GetSupportedConfigsSuccessCallback =
175            std::function<void(uint32_t supportedConfigs, void* configsData)>;
176
177    static const char *sContextResultOfCommand;
178    static const char *sContextCallToCommand;
179    static const char *sContextCallFunction;
180
181    bool mIsClosed;
182    effect_handle_t mHandle;
183    sp<AudioBufferWrapper> mInBuffer;
184    sp<AudioBufferWrapper> mOutBuffer;
185    std::atomic<audio_buffer_t*> mHalInBufferPtr;
186    std::atomic<audio_buffer_t*> mHalOutBufferPtr;
187    std::unique_ptr<StatusMQ> mStatusMQ;
188    EventFlag* mEfGroup;
189    std::atomic<bool> mStopProcessThread;
190    sp<Thread> mProcessThread;
191
192    virtual ~Effect();
193
194    template<typename T> static size_t alignedSizeIn(size_t s);
195    template<typename T> std::unique_ptr<uint8_t[]> hidlVecToHal(
196            const hidl_vec<T>& vec, uint32_t* halDataSize);
197    static void effectAuxChannelsConfigFromHal(
198            const channel_config_t& halConfig, EffectAuxChannelsConfig* config);
199    static void effectAuxChannelsConfigToHal(
200            const EffectAuxChannelsConfig& config, channel_config_t* halConfig);
201    static void effectBufferConfigFromHal(
202            const buffer_config_t& halConfig, EffectBufferConfig* config);
203    static void effectBufferConfigToHal(
204            const EffectBufferConfig& config, buffer_config_t* halConfig);
205    static void effectConfigFromHal(const effect_config_t& halConfig, EffectConfig* config);
206    static void effectConfigToHal(const EffectConfig& config, effect_config_t* halConfig);
207    static void effectOffloadParamToHal(
208            const EffectOffloadParameter& offload, effect_offload_param_t* halOffload);
209    static std::vector<uint8_t> parameterToHal(
210            uint32_t paramSize, const void* paramData, uint32_t valueSize, const void** valueData);
211
212    Result analyzeCommandStatus(
213            const char* commandName, const char* context, status_t status);
214    Result analyzeStatus(
215            const char* funcName,
216            const char* subFuncName,
217            const char* contextDescription,
218            status_t status);
219    void getConfigImpl(int commandCode, const char* commandName, GetConfigCallback cb);
220    Result getCurrentConfigImpl(
221            uint32_t featureId, uint32_t configSize, GetCurrentConfigSuccessCallback onSuccess);
222    Result getParameterImpl(
223            uint32_t paramSize,
224            const void* paramData,
225            uint32_t valueSize,
226            GetParameterSuccessCallback onSuccess);
227    Result getSupportedConfigsImpl(
228            uint32_t featureId,
229            uint32_t maxConfigs,
230            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(
235            int commandCode, const char* commandName, uint32_t* replySize, void* replyData);
236    Result sendCommandReturningData(
237            int commandCode, const char* commandName,
238            uint32_t size, void* data,
239            uint32_t* replySize, void* replyData);
240    Result sendCommandReturningStatus(int commandCode, const char* commandName);
241    Result sendCommandReturningStatus(
242            int commandCode, const char* commandName, uint32_t size, void* data);
243    Result sendCommandReturningStatusAndData(
244            int commandCode, const char* commandName,
245            uint32_t size, void* data,
246            uint32_t* replySize, void* replyData,
247            uint32_t minReplySize,
248            CommandSuccessCallback onSuccess);
249    Result setConfigImpl(
250            int commandCode, const char* commandName,
251            const EffectConfig& config,
252            const sp<IEffectBufferProviderCallback>& inputBufferProvider,
253            const sp<IEffectBufferProviderCallback>& outputBufferProvider);
254    Result setParameterImpl(
255            uint32_t paramSize, const void* paramData, uint32_t valueSize, const void* valueData);
256};
257
258}  // namespace implementation
259}  // namespace V2_0
260}  // namespace effect
261}  // namespace audio
262}  // namespace hardware
263}  // namespace android
264
265#endif  // ANDROID_HARDWARE_AUDIO_EFFECT_V2_0_EFFECT_H
266