NoiseSuppressionEffect.cpp revision f9d303435d80161fabb16cdff3b8f2f75f362480
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#define LOG_TAG "NS_Effect_HAL" 18#include <android/log.h> 19 20#include "NoiseSuppressionEffect.h" 21 22namespace android { 23namespace hardware { 24namespace audio { 25namespace effect { 26namespace V2_0 { 27namespace implementation { 28 29NoiseSuppressionEffect::NoiseSuppressionEffect(effect_handle_t handle) 30 : mEffect(new Effect(handle)) { 31} 32 33NoiseSuppressionEffect::~NoiseSuppressionEffect() {} 34 35void NoiseSuppressionEffect::propertiesFromHal( 36 const t_ns_settings& halProperties, 37 INoiseSuppressionEffect::AllProperties* properties) { 38 properties->level = Level(halProperties.level); 39 properties->type = Type(halProperties.type); 40} 41 42void NoiseSuppressionEffect::propertiesToHal( 43 const INoiseSuppressionEffect::AllProperties& properties, 44 t_ns_settings* halProperties) { 45 halProperties->level = static_cast<uint32_t>(properties.level); 46 halProperties->type = static_cast<uint32_t>(properties.type); 47} 48 49// Methods from ::android::hardware::audio::effect::V2_0::IEffect follow. 50Return<Result> NoiseSuppressionEffect::init() { 51 return mEffect->init(); 52} 53 54Return<Result> NoiseSuppressionEffect::setConfig( 55 const EffectConfig& config, 56 const sp<IEffectBufferProviderCallback>& inputBufferProvider, 57 const sp<IEffectBufferProviderCallback>& outputBufferProvider) { 58 return mEffect->setConfig(config, inputBufferProvider, outputBufferProvider); 59} 60 61Return<Result> NoiseSuppressionEffect::reset() { 62 return mEffect->reset(); 63} 64 65Return<Result> NoiseSuppressionEffect::enable() { 66 return mEffect->enable(); 67} 68 69Return<Result> NoiseSuppressionEffect::disable() { 70 return mEffect->disable(); 71} 72 73Return<Result> NoiseSuppressionEffect::setDevice(AudioDevice device) { 74 return mEffect->setDevice(device); 75} 76 77Return<void> NoiseSuppressionEffect::setAndGetVolume( 78 const hidl_vec<uint32_t>& volumes, setAndGetVolume_cb _hidl_cb) { 79 return mEffect->setAndGetVolume(volumes, _hidl_cb); 80} 81 82Return<Result> NoiseSuppressionEffect::setAudioMode(AudioMode mode) { 83 return mEffect->setAudioMode(mode); 84} 85 86Return<Result> NoiseSuppressionEffect::setConfigReverse( 87 const EffectConfig& config, 88 const sp<IEffectBufferProviderCallback>& inputBufferProvider, 89 const sp<IEffectBufferProviderCallback>& outputBufferProvider) { 90 return mEffect->setConfigReverse(config, inputBufferProvider, outputBufferProvider); 91} 92 93Return<Result> NoiseSuppressionEffect::setInputDevice(AudioDevice device) { 94 return mEffect->setInputDevice(device); 95} 96 97Return<void> NoiseSuppressionEffect::getConfig(getConfig_cb _hidl_cb) { 98 return mEffect->getConfig(_hidl_cb); 99} 100 101Return<void> NoiseSuppressionEffect::getConfigReverse(getConfigReverse_cb _hidl_cb) { 102 return mEffect->getConfigReverse(_hidl_cb); 103} 104 105Return<void> NoiseSuppressionEffect::getSupportedAuxChannelsConfigs( 106 uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) { 107 return mEffect->getSupportedAuxChannelsConfigs(maxConfigs, _hidl_cb); 108} 109 110Return<void> NoiseSuppressionEffect::getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) { 111 return mEffect->getAuxChannelsConfig(_hidl_cb); 112} 113 114Return<Result> NoiseSuppressionEffect::setAuxChannelsConfig( 115 const EffectAuxChannelsConfig& config) { 116 return mEffect->setAuxChannelsConfig(config); 117} 118 119Return<Result> NoiseSuppressionEffect::setAudioSource(AudioSource source) { 120 return mEffect->setAudioSource(source); 121} 122 123Return<Result> NoiseSuppressionEffect::offload(const EffectOffloadParameter& param) { 124 return mEffect->offload(param); 125} 126 127Return<void> NoiseSuppressionEffect::getDescriptor(getDescriptor_cb _hidl_cb) { 128 return mEffect->getDescriptor(_hidl_cb); 129} 130 131Return<void> NoiseSuppressionEffect::process( 132 const AudioBuffer& inBuffer, uint32_t outFrameSize, process_cb _hidl_cb) { 133 return mEffect->process(inBuffer, outFrameSize, _hidl_cb); 134} 135 136Return<void> NoiseSuppressionEffect::processReverse( 137 const AudioBuffer& inBuffer, 138 uint32_t outFrameSize, 139 processReverse_cb _hidl_cb) { 140 return mEffect->processReverse(inBuffer, outFrameSize, _hidl_cb); 141} 142 143Return<void> NoiseSuppressionEffect::command( 144 uint32_t commandId, 145 const hidl_vec<uint8_t>& data, 146 uint32_t resultMaxSize, 147 command_cb _hidl_cb) { 148 return mEffect->command(commandId, data, resultMaxSize, _hidl_cb); 149} 150 151Return<Result> NoiseSuppressionEffect::setParameter( 152 const hidl_vec<uint8_t>& parameter, const hidl_vec<uint8_t>& value) { 153 return mEffect->setParameter(parameter, value); 154} 155 156Return<void> NoiseSuppressionEffect::getParameter( 157 const hidl_vec<uint8_t>& parameter, 158 uint32_t valueMaxSize, 159 getParameter_cb _hidl_cb) { 160 return mEffect->getParameter(parameter, valueMaxSize, _hidl_cb); 161} 162 163Return<void> NoiseSuppressionEffect::getSupportedConfigsForFeature( 164 uint32_t featureId, 165 uint32_t maxConfigs, 166 uint32_t configSize, 167 getSupportedConfigsForFeature_cb _hidl_cb) { 168 return mEffect->getSupportedConfigsForFeature(featureId, maxConfigs, configSize, _hidl_cb); 169} 170 171Return<void> NoiseSuppressionEffect::getCurrentConfigForFeature( 172 uint32_t featureId, 173 uint32_t configSize, 174 getCurrentConfigForFeature_cb _hidl_cb) { 175 return mEffect->getCurrentConfigForFeature(featureId, configSize, _hidl_cb); 176} 177 178Return<Result> NoiseSuppressionEffect::setCurrentConfigForFeature( 179 uint32_t featureId, const hidl_vec<uint8_t>& configData) { 180 return mEffect->setCurrentConfigForFeature(featureId, configData); 181} 182 183 184// Methods from ::android::hardware::audio::effect::V2_0::INoiseSuppressionEffect follow. 185Return<Result> NoiseSuppressionEffect::setSuppressionLevel(INoiseSuppressionEffect::Level level) { 186 return mEffect->setParam(NS_PARAM_LEVEL, static_cast<int32_t>(level)); 187} 188 189Return<void> NoiseSuppressionEffect::getSuppressionLevel(getSuppressionLevel_cb _hidl_cb) { 190 int32_t halLevel = 0; 191 Result retval = mEffect->getParam(NS_PARAM_LEVEL, halLevel); 192 _hidl_cb(retval, Level(halLevel)); 193 return Void(); 194} 195 196Return<Result> NoiseSuppressionEffect::setSuppressionType(INoiseSuppressionEffect::Type type) { 197 return mEffect->setParam(NS_PARAM_TYPE, static_cast<int32_t>(type)); 198} 199 200Return<void> NoiseSuppressionEffect::getSuppressionType(getSuppressionType_cb _hidl_cb) { 201 int32_t halType = 0; 202 Result retval = mEffect->getParam(NS_PARAM_TYPE, halType); 203 _hidl_cb(retval, Type(halType)); 204 return Void(); 205} 206 207Return<Result> NoiseSuppressionEffect::setAllProperties( 208 const INoiseSuppressionEffect::AllProperties& properties) { 209 t_ns_settings halProperties; 210 propertiesToHal(properties, &halProperties); 211 return mEffect->setParam(NS_PARAM_PROPERTIES, halProperties); 212} 213 214Return<void> NoiseSuppressionEffect::getAllProperties(getAllProperties_cb _hidl_cb) { 215 t_ns_settings halProperties; 216 Result retval = mEffect->getParam(NS_PARAM_PROPERTIES, halProperties); 217 AllProperties properties; 218 propertiesFromHal(halProperties, &properties); 219 _hidl_cb(retval, properties); 220 return Void(); 221} 222 223} // namespace implementation 224} // namespace V2_0 225} // namespace effect 226} // namespace audio 227} // namespace hardware 228} // namespace android 229