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