blob: a53eabcccd156feededce2652a3ebf26a8cfd383 [file] [log] [blame]
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -07001/*
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#define LOG_TAG "Visualizer_HAL"
18#include <system/audio_effects/effect_visualizer.h>
Yifan Hongf9d30342016-11-30 13:45:34 -080019#include <android/log.h>
Mikhail Naganov7cbf2f12016-10-27 20:05:35 -070020
21#include "VisualizerEffect.h"
22
23namespace android {
24namespace hardware {
25namespace audio {
26namespace effect {
27namespace V2_0 {
28namespace implementation {
29
30VisualizerEffect::VisualizerEffect(effect_handle_t handle)
31 : mEffect(new Effect(handle)), mCaptureSize(0), mMeasurementMode(MeasurementMode::NONE) {
32}
33
34VisualizerEffect::~VisualizerEffect() {}
35
36// Methods from ::android::hardware::audio::effect::V2_0::IEffect follow.
37Return<Result> VisualizerEffect::init() {
38 return mEffect->init();
39}
40
41Return<Result> VisualizerEffect::setConfig(
42 const EffectConfig& config,
43 const sp<IEffectBufferProviderCallback>& inputBufferProvider,
44 const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
45 return mEffect->setConfig(config, inputBufferProvider, outputBufferProvider);
46}
47
48Return<Result> VisualizerEffect::reset() {
49 return mEffect->reset();
50}
51
52Return<Result> VisualizerEffect::enable() {
53 return mEffect->enable();
54}
55
56Return<Result> VisualizerEffect::disable() {
57 return mEffect->disable();
58}
59
60Return<Result> VisualizerEffect::setDevice(AudioDevice device) {
61 return mEffect->setDevice(device);
62}
63
64Return<void> VisualizerEffect::setAndGetVolume(
65 const hidl_vec<uint32_t>& volumes, setAndGetVolume_cb _hidl_cb) {
66 return mEffect->setAndGetVolume(volumes, _hidl_cb);
67}
68
69Return<Result> VisualizerEffect::setAudioMode(AudioMode mode) {
70 return mEffect->setAudioMode(mode);
71}
72
73Return<Result> VisualizerEffect::setConfigReverse(
74 const EffectConfig& config,
75 const sp<IEffectBufferProviderCallback>& inputBufferProvider,
76 const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
77 return mEffect->setConfigReverse(config, inputBufferProvider, outputBufferProvider);
78}
79
80Return<Result> VisualizerEffect::setInputDevice(AudioDevice device) {
81 return mEffect->setInputDevice(device);
82}
83
84Return<void> VisualizerEffect::getConfig(getConfig_cb _hidl_cb) {
85 return mEffect->getConfig(_hidl_cb);
86}
87
88Return<void> VisualizerEffect::getConfigReverse(getConfigReverse_cb _hidl_cb) {
89 return mEffect->getConfigReverse(_hidl_cb);
90}
91
92Return<void> VisualizerEffect::getSupportedAuxChannelsConfigs(
93 uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) {
94 return mEffect->getSupportedAuxChannelsConfigs(maxConfigs, _hidl_cb);
95}
96
97Return<void> VisualizerEffect::getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) {
98 return mEffect->getAuxChannelsConfig(_hidl_cb);
99}
100
101Return<Result> VisualizerEffect::setAuxChannelsConfig(
102 const EffectAuxChannelsConfig& config) {
103 return mEffect->setAuxChannelsConfig(config);
104}
105
106Return<Result> VisualizerEffect::setAudioSource(AudioSource source) {
107 return mEffect->setAudioSource(source);
108}
109
110Return<Result> VisualizerEffect::offload(const EffectOffloadParameter& param) {
111 return mEffect->offload(param);
112}
113
114Return<void> VisualizerEffect::getDescriptor(getDescriptor_cb _hidl_cb) {
115 return mEffect->getDescriptor(_hidl_cb);
116}
117
118Return<void> VisualizerEffect::process(
119 const AudioBuffer& inBuffer, uint32_t outFrameSize, process_cb _hidl_cb) {
120 return mEffect->process(inBuffer, outFrameSize, _hidl_cb);
121}
122
123Return<void> VisualizerEffect::processReverse(
124 const AudioBuffer& inBuffer,
125 uint32_t outFrameSize,
126 processReverse_cb _hidl_cb) {
127 return mEffect->processReverse(inBuffer, outFrameSize, _hidl_cb);
128}
129
130Return<void> VisualizerEffect::command(
131 uint32_t commandId,
132 const hidl_vec<uint8_t>& data,
133 uint32_t resultMaxSize,
134 command_cb _hidl_cb) {
135 return mEffect->command(commandId, data, resultMaxSize, _hidl_cb);
136}
137
138Return<Result> VisualizerEffect::setParameter(
139 const hidl_vec<uint8_t>& parameter, const hidl_vec<uint8_t>& value) {
140 return mEffect->setParameter(parameter, value);
141}
142
143Return<void> VisualizerEffect::getParameter(
144 const hidl_vec<uint8_t>& parameter,
145 uint32_t valueMaxSize,
146 getParameter_cb _hidl_cb) {
147 return mEffect->getParameter(parameter, valueMaxSize, _hidl_cb);
148}
149
150Return<void> VisualizerEffect::getSupportedConfigsForFeature(
151 uint32_t featureId,
152 uint32_t maxConfigs,
153 uint32_t configSize,
154 getSupportedConfigsForFeature_cb _hidl_cb) {
155 return mEffect->getSupportedConfigsForFeature(featureId, maxConfigs, configSize, _hidl_cb);
156}
157
158Return<void> VisualizerEffect::getCurrentConfigForFeature(
159 uint32_t featureId,
160 uint32_t configSize,
161 getCurrentConfigForFeature_cb _hidl_cb) {
162 return mEffect->getCurrentConfigForFeature(featureId, configSize, _hidl_cb);
163}
164
165Return<Result> VisualizerEffect::setCurrentConfigForFeature(
166 uint32_t featureId, const hidl_vec<uint8_t>& configData) {
167 return mEffect->setCurrentConfigForFeature(featureId, configData);
168}
169
170
171// Methods from ::android::hardware::audio::effect::V2_0::IVisualizerEffect follow.
172Return<Result> VisualizerEffect::setCaptureSize(uint16_t captureSize) {
173 Result retval = mEffect->setParam(VISUALIZER_PARAM_CAPTURE_SIZE, captureSize);
174 if (retval == Result::OK) {
175 mCaptureSize = captureSize;
176 }
177 return retval;
178}
179
180Return<void> VisualizerEffect::getCaptureSize(getCaptureSize_cb _hidl_cb) {
181 return mEffect->getIntegerParam(VISUALIZER_PARAM_CAPTURE_SIZE, _hidl_cb);
182}
183
184Return<Result> VisualizerEffect::setScalingMode(IVisualizerEffect::ScalingMode scalingMode) {
185 return mEffect->setParam(VISUALIZER_PARAM_SCALING_MODE, static_cast<int32_t>(scalingMode));
186}
187
188Return<void> VisualizerEffect::getScalingMode(getScalingMode_cb _hidl_cb) {
189 int32_t halMode;
190 Result retval = mEffect->getParam(VISUALIZER_PARAM_SCALING_MODE, halMode);
191 _hidl_cb(retval, ScalingMode(halMode));
192 return Void();
193}
194
195Return<Result> VisualizerEffect::setLatency(uint32_t latencyMs) {
196 return mEffect->setParam(VISUALIZER_PARAM_LATENCY, latencyMs);
197}
198
199Return<void> VisualizerEffect::getLatency(getLatency_cb _hidl_cb) {
200 return mEffect->getIntegerParam(VISUALIZER_PARAM_LATENCY, _hidl_cb);
201}
202
203Return<Result> VisualizerEffect::setMeasurementMode(
204 IVisualizerEffect::MeasurementMode measurementMode) {
205 Result retval = mEffect->setParam(
206 VISUALIZER_PARAM_MEASUREMENT_MODE, static_cast<int32_t>(measurementMode));
207 if (retval == Result::OK) {
208 mMeasurementMode = measurementMode;
209 }
210 return retval;
211}
212
213Return<void> VisualizerEffect::getMeasurementMode(getMeasurementMode_cb _hidl_cb) {
214 int32_t halMode;
215 Result retval = mEffect->getParam(VISUALIZER_PARAM_MEASUREMENT_MODE, halMode);
216 _hidl_cb(retval, MeasurementMode(halMode));
217 return Void();
218}
219
220Return<void> VisualizerEffect::capture(capture_cb _hidl_cb) {
221 if (mCaptureSize == 0) {
222 _hidl_cb(Result::NOT_INITIALIZED, hidl_vec<uint8_t>());
223 return Void();
224 }
225 uint32_t halCaptureSize = mCaptureSize;
226 uint8_t halCapture[mCaptureSize];
227 Result retval = mEffect->sendCommandReturningData(
228 VISUALIZER_CMD_CAPTURE, "VISUALIZER_CAPTURE", &halCaptureSize, halCapture);
229 hidl_vec<uint8_t> capture;
230 if (retval == Result::OK) {
231 capture.setToExternal(&halCapture[0], halCaptureSize);
232 }
233 _hidl_cb(retval, capture);
234 return Void();
235}
236
237Return<void> VisualizerEffect::measure(measure_cb _hidl_cb) {
238 if (mMeasurementMode == MeasurementMode::NONE) {
239 _hidl_cb(Result::NOT_INITIALIZED, Measurement());
240 return Void();
241 }
242 int32_t halMeasurement[MEASUREMENT_COUNT];
243 uint32_t halMeasurementSize = sizeof(halMeasurement);
244 Result retval = mEffect->sendCommandReturningData(
245 VISUALIZER_CMD_MEASURE, "VISUALIZER_MEASURE", &halMeasurementSize, halMeasurement);
246 Measurement measurement = { .mode = MeasurementMode::PEAK_RMS };
247 measurement.value.peakAndRms.peakMb = 0;
248 measurement.value.peakAndRms.rmsMb = 0;
249 if (retval == Result::OK) {
250 measurement.value.peakAndRms.peakMb = halMeasurement[MEASUREMENT_IDX_PEAK];
251 measurement.value.peakAndRms.rmsMb = halMeasurement[MEASUREMENT_IDX_RMS];
252 }
253 _hidl_cb(retval, measurement);
254 return Void();
255}
256
257} // namespace implementation
258} // namespace V2_0
259} // namespace effect
260} // namespace audio
261} // namespace hardware
262} // namespace android