Home | History | Annotate | Download | only in default 
      1 /*
      2  * Copyright (C) 2018 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 "BassBoost_HAL"
     18 
     19 #include "BassBoostEffect.h"
     20 
     21 #include <android/log.h>
     22 #include <system/audio_effects/effect_bassboost.h>
     23 
     24 #include "VersionUtils.h"
     25 
     26 namespace android {
     27 namespace hardware {
     28 namespace audio {
     29 namespace effect {
     30 namespace CPP_VERSION {
     31 namespace implementation {
     32 
     33 BassBoostEffect::BassBoostEffect(effect_handle_t handle) : mEffect(new Effect(handle)) {}
     34 
     35 BassBoostEffect::~BassBoostEffect() {}
     36 
     37 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow.
     38 Return<Result> BassBoostEffect::init() {
     39     return mEffect->init();
     40 }
     41 
     42 Return<Result> BassBoostEffect::setConfig(
     43     const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
     44     const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
     45     return mEffect->setConfig(config, inputBufferProvider, outputBufferProvider);
     46 }
     47 
     48 Return<Result> BassBoostEffect::reset() {
     49     return mEffect->reset();
     50 }
     51 
     52 Return<Result> BassBoostEffect::enable() {
     53     return mEffect->enable();
     54 }
     55 
     56 Return<Result> BassBoostEffect::disable() {
     57     return mEffect->disable();
     58 }
     59 
     60 Return<Result> BassBoostEffect::setDevice(AudioDeviceBitfield device) {
     61     return mEffect->setDevice(device);
     62 }
     63 
     64 Return<void> BassBoostEffect::setAndGetVolume(const hidl_vec<uint32_t>& volumes,
     65                                               setAndGetVolume_cb _hidl_cb) {
     66     return mEffect->setAndGetVolume(volumes, _hidl_cb);
     67 }
     68 
     69 Return<Result> BassBoostEffect::volumeChangeNotification(const hidl_vec<uint32_t>& volumes) {
     70     return mEffect->volumeChangeNotification(volumes);
     71 }
     72 
     73 Return<Result> BassBoostEffect::setAudioMode(AudioMode mode) {
     74     return mEffect->setAudioMode(mode);
     75 }
     76 
     77 Return<Result> BassBoostEffect::setConfigReverse(
     78     const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
     79     const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
     80     return mEffect->setConfigReverse(config, inputBufferProvider, outputBufferProvider);
     81 }
     82 
     83 Return<Result> BassBoostEffect::setInputDevice(AudioDeviceBitfield device) {
     84     return mEffect->setInputDevice(device);
     85 }
     86 
     87 Return<void> BassBoostEffect::getConfig(getConfig_cb _hidl_cb) {
     88     return mEffect->getConfig(_hidl_cb);
     89 }
     90 
     91 Return<void> BassBoostEffect::getConfigReverse(getConfigReverse_cb _hidl_cb) {
     92     return mEffect->getConfigReverse(_hidl_cb);
     93 }
     94 
     95 Return<void> BassBoostEffect::getSupportedAuxChannelsConfigs(
     96     uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) {
     97     return mEffect->getSupportedAuxChannelsConfigs(maxConfigs, _hidl_cb);
     98 }
     99 
    100 Return<void> BassBoostEffect::getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) {
    101     return mEffect->getAuxChannelsConfig(_hidl_cb);
    102 }
    103 
    104 Return<Result> BassBoostEffect::setAuxChannelsConfig(const EffectAuxChannelsConfig& config) {
    105     return mEffect->setAuxChannelsConfig(config);
    106 }
    107 
    108 Return<Result> BassBoostEffect::setAudioSource(AudioSource source) {
    109     return mEffect->setAudioSource(source);
    110 }
    111 
    112 Return<Result> BassBoostEffect::offload(const EffectOffloadParameter& param) {
    113     return mEffect->offload(param);
    114 }
    115 
    116 Return<void> BassBoostEffect::getDescriptor(getDescriptor_cb _hidl_cb) {
    117     return mEffect->getDescriptor(_hidl_cb);
    118 }
    119 
    120 Return<void> BassBoostEffect::prepareForProcessing(prepareForProcessing_cb _hidl_cb) {
    121     return mEffect->prepareForProcessing(_hidl_cb);
    122 }
    123 
    124 Return<Result> BassBoostEffect::setProcessBuffers(const AudioBuffer& inBuffer,
    125                                                   const AudioBuffer& outBuffer) {
    126     return mEffect->setProcessBuffers(inBuffer, outBuffer);
    127 }
    128 
    129 Return<void> BassBoostEffect::command(uint32_t commandId, const hidl_vec<uint8_t>& data,
    130                                       uint32_t resultMaxSize, command_cb _hidl_cb) {
    131     return mEffect->command(commandId, data, resultMaxSize, _hidl_cb);
    132 }
    133 
    134 Return<Result> BassBoostEffect::setParameter(const hidl_vec<uint8_t>& parameter,
    135                                              const hidl_vec<uint8_t>& value) {
    136     return mEffect->setParameter(parameter, value);
    137 }
    138 
    139 Return<void> BassBoostEffect::getParameter(const hidl_vec<uint8_t>& parameter,
    140                                            uint32_t valueMaxSize, getParameter_cb _hidl_cb) {
    141     return mEffect->getParameter(parameter, valueMaxSize, _hidl_cb);
    142 }
    143 
    144 Return<void> BassBoostEffect::getSupportedConfigsForFeature(
    145     uint32_t featureId, uint32_t maxConfigs, uint32_t configSize,
    146     getSupportedConfigsForFeature_cb _hidl_cb) {
    147     return mEffect->getSupportedConfigsForFeature(featureId, maxConfigs, configSize, _hidl_cb);
    148 }
    149 
    150 Return<void> BassBoostEffect::getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize,
    151                                                          getCurrentConfigForFeature_cb _hidl_cb) {
    152     return mEffect->getCurrentConfigForFeature(featureId, configSize, _hidl_cb);
    153 }
    154 
    155 Return<Result> BassBoostEffect::setCurrentConfigForFeature(uint32_t featureId,
    156                                                            const hidl_vec<uint8_t>& configData) {
    157     return mEffect->setCurrentConfigForFeature(featureId, configData);
    158 }
    159 
    160 Return<Result> BassBoostEffect::close() {
    161     return mEffect->close();
    162 }
    163 
    164 Return<void> BassBoostEffect::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options) {
    165     return mEffect->debug(fd, options);
    166 }
    167 
    168 // Methods from ::android::hardware::audio::effect::CPP_VERSION::IBassBoostEffect follow.
    169 Return<void> BassBoostEffect::isStrengthSupported(isStrengthSupported_cb _hidl_cb) {
    170     return mEffect->getIntegerParam(BASSBOOST_PARAM_STRENGTH_SUPPORTED, _hidl_cb);
    171 }
    172 
    173 Return<Result> BassBoostEffect::setStrength(uint16_t strength) {
    174     return mEffect->setParam(BASSBOOST_PARAM_STRENGTH, strength);
    175 }
    176 
    177 Return<void> BassBoostEffect::getStrength(getStrength_cb _hidl_cb) {
    178     return mEffect->getIntegerParam(BASSBOOST_PARAM_STRENGTH, _hidl_cb);
    179 }
    180 
    181 }  // namespace implementation
    182 }  // namespace CPP_VERSION
    183 }  // namespace effect
    184 }  // namespace audio
    185 }  // namespace hardware
    186 }  // namespace android
    187