From 96d2cd9d5c87d8bf9766a7190cf358adccab349a Mon Sep 17 00:00:00 2001 From: Kevin Rocard Date: Wed, 14 Nov 2018 16:22:07 -0800 Subject: Audio HAL: Factorize V2 and V4 like libaudiohal Use the same technique developed for the simpler libaudiohal to factorize the audio HAL impl. Generated with script: set -euo pipefail cd hardware/interfaces/audio # Make 2.0 and 4.0 files mostly identical by removing all 2.0, V4.0... # and replacing it by CPP_VERSION and FILE_VERSION # This allow both implementation to be mostly identical, except for code difference # Also remove IncludeGuard.h as it will be included from compiler flag # Also update license to 2018 find -name *.cpp -o -name *h | grep -v -e service.cpp | xargs sed -Ei \ -e 's/(#.*)V[42]_0_(.*_H_?)$/\1\2/' \ -e 's/(LOG_TAG.*)[24]_0/\1/' \ -e '/#ifndef AUDIO_HAL_VERSION/,/#endif/d' \ -e '/^#.*def.*AUDIO_HAL_VERSION\b/d' \ -e's/V[42]_0/CPP_VERSION/' \ -e 's/(#include ).(android.*)[24].0(.*).$/\1PATH(\2FILE_VERSION\3)/' \ -e 's|(#include) .(.*)[24].0/(default/.*).$|\1 "\2\3"|' \ -e 's/\bAUDIO_HAL_VERSION\b/CPP_VERSION/' \ -e '/IncludeGuard.h/d' \ -e 's/(Copyright .C. 201)./\18/' # set MAJOR_VERSION instead of having a different macro for each version # this allow to do preprocessor arithmetic (eg: MAJOR_VERSION >= 4) for v in 2 4; do find -ipath '*/'$v'.0/*/Android.bp' | xargs sed -i -e '/cflags:/,/^$/d' -e '/vndk/{:a;/}/!{N;ba};d}' -e '$i\ cflags: [\ "-DMAJOR_VERSION='$v'",\ "-DMINOR_VERSION=0",\ "-include common/all-versions/VersionMacro.h",\ ]'; done # replace# ifdef VERSION_X by #if MAJOR_VERSION == X find -path *all-versions/*.h | xargs sed -Ei -e 's/def.*AUDIO_HAL_VERSION_([24])_0.*/ MAJOR_VERSION == \1/' \ -e 'T;s/ +/ /' # copy all-versions impl in each version impl find -path '*/[24].0/*.[hc]*' | grep -ve all-versions -e test | xargs -P99 -n4 sed -i -Ee '/include <.*all-versions.default/!b' \ -e 's#.*<#find -path */#' -e 's/>$/|xargs tail -n +16/' -e e # remove all-versions impl rm -r {core,effect}/all-versions/ # merge version impl into a single all-version for dir in core/*.0/vts/functional/*.0/ ;do dest=$(echo $dir | sed 's#/..0/#/all-versions/#') mkdir -p $dest mv -T $dir $dest done find -mindepth 3 -path '*/2.0/*' -a \( -name '*cpp' -o -name '*h' \) | grep -v 'all-versions' | sed -E 'h;s/2/4/g;H;s/4.0/all-versions/;s/4.0//;H;g;s/\n/ /g;'| xargs -P99 -L1 sh -c ' set -euo pipefail mkdir -p $(dirname $2); diff --old-group-format="#if MAJOR_VERSION == 2 %<#endif " \ --new-group-format="#if MAJOR_VERSION == 4 %>#endif " $0 $1 > $2 || true; rm $0 $1' # merge the X.0 Android.bp & OWNERS in the all-versions for dir in common effect core; do for sub in default vts/functional; do test -f $dir/2.0/$sub/Android.bp || continue awk 1 $dir/*.0/$sub/Android.bp >> $dir/all-versions/$sub/Android.bp # delete licenses except for the first one and add whitelines sed -i -e '/^}$/{N;/^}\n$/!s/\n/&\n/}' $dir/all-versions/$sub/Android.bp sed -i -e '1,17b;/^\/\//,/^$/{d}' $dir/all-versions/$sub/Android.bp done for sub in default vts; do test -d $dir/2.0/$sub || continue test -f $dir/2.0/$sub/OWNERS && awk 1 $dir/*.0/$sub/OWNERS | sort -u > $dir/all-versions/$sub/OWNERS || true rm -r $dir/*.0/$sub done done # delete all-versions-impl dependencies find -name 'Android.bp' | xargs sed -i -e '/all-versions-impl/d' # cleanup unused files rm common/all-versions/default/include/common/all-versions/default/HidlUtils* rm common/all-versions/util/include/common/all-versions/IncludeGuard.h find -depth -type d -empty -delete # Clamp consecutive number of empty lines to 2 find -name *.cpp -o -name *h | xargs sed -Ei ':a;/^\n*$/{N;ba};s/\n\n+/\n\n/' # transform #endif\n#if to #elif find -name *.cpp -o -name *h | xargs sed -i '/^#endif/{N;s/.*\n#if/#elif/}' # remove leftover include guard in cpp find -name *.cpp |xargs sed -Ei '/^#.*_H_?$/d' # apply clang-format find -name *cpp -o -name *h | xargs ../../../prebuilts/clang/host/linux-x86/clang-stable/bin/clang-format --style file -i # clang format breaks PATH(a/b) to PATH(a / b), remove the space surrounding / find -name *cpp -o -name *h | xargs sed -i "/#include PATH/s# / #/#g" Test: compile Bug: 118203066 Change-Id: I3692a444307afc5f71064fe0b9e6b8af3c9ff1dd Signed-off-by: Kevin Rocard --- .../all-versions/default/VisualizerEffect.cpp | 256 +++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 audio/effect/all-versions/default/VisualizerEffect.cpp (limited to 'audio/effect/all-versions/default/VisualizerEffect.cpp') diff --git a/audio/effect/all-versions/default/VisualizerEffect.cpp b/audio/effect/all-versions/default/VisualizerEffect.cpp new file mode 100644 index 0000000000..77bf46bcd3 --- /dev/null +++ b/audio/effect/all-versions/default/VisualizerEffect.cpp @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "Visualizer_HAL" + +#include "VisualizerEffect.h" + +#include +#include + +#include "VersionUtils.h" + +namespace android { +namespace hardware { +namespace audio { +namespace effect { +namespace CPP_VERSION { +namespace implementation { + +VisualizerEffect::VisualizerEffect(effect_handle_t handle) + : mEffect(new Effect(handle)), mCaptureSize(0), mMeasurementMode(MeasurementMode::NONE) {} + +VisualizerEffect::~VisualizerEffect() {} + +// Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow. +Return VisualizerEffect::init() { + return mEffect->init(); +} + +Return VisualizerEffect::setConfig( + const EffectConfig& config, const sp& inputBufferProvider, + const sp& outputBufferProvider) { + return mEffect->setConfig(config, inputBufferProvider, outputBufferProvider); +} + +Return VisualizerEffect::reset() { + return mEffect->reset(); +} + +Return VisualizerEffect::enable() { + return mEffect->enable(); +} + +Return VisualizerEffect::disable() { + return mEffect->disable(); +} + +Return VisualizerEffect::setDevice(AudioDeviceBitfield device) { + return mEffect->setDevice(device); +} + +Return VisualizerEffect::setAndGetVolume(const hidl_vec& volumes, + setAndGetVolume_cb _hidl_cb) { + return mEffect->setAndGetVolume(volumes, _hidl_cb); +} + +Return VisualizerEffect::volumeChangeNotification(const hidl_vec& volumes) { + return mEffect->volumeChangeNotification(volumes); +} + +Return VisualizerEffect::setAudioMode(AudioMode mode) { + return mEffect->setAudioMode(mode); +} + +Return VisualizerEffect::setConfigReverse( + const EffectConfig& config, const sp& inputBufferProvider, + const sp& outputBufferProvider) { + return mEffect->setConfigReverse(config, inputBufferProvider, outputBufferProvider); +} + +Return VisualizerEffect::setInputDevice(AudioDeviceBitfield device) { + return mEffect->setInputDevice(device); +} + +Return VisualizerEffect::getConfig(getConfig_cb _hidl_cb) { + return mEffect->getConfig(_hidl_cb); +} + +Return VisualizerEffect::getConfigReverse(getConfigReverse_cb _hidl_cb) { + return mEffect->getConfigReverse(_hidl_cb); +} + +Return VisualizerEffect::getSupportedAuxChannelsConfigs( + uint32_t maxConfigs, getSupportedAuxChannelsConfigs_cb _hidl_cb) { + return mEffect->getSupportedAuxChannelsConfigs(maxConfigs, _hidl_cb); +} + +Return VisualizerEffect::getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) { + return mEffect->getAuxChannelsConfig(_hidl_cb); +} + +Return VisualizerEffect::setAuxChannelsConfig(const EffectAuxChannelsConfig& config) { + return mEffect->setAuxChannelsConfig(config); +} + +Return VisualizerEffect::setAudioSource(AudioSource source) { + return mEffect->setAudioSource(source); +} + +Return VisualizerEffect::offload(const EffectOffloadParameter& param) { + return mEffect->offload(param); +} + +Return VisualizerEffect::getDescriptor(getDescriptor_cb _hidl_cb) { + return mEffect->getDescriptor(_hidl_cb); +} + +Return VisualizerEffect::prepareForProcessing(prepareForProcessing_cb _hidl_cb) { + return mEffect->prepareForProcessing(_hidl_cb); +} + +Return VisualizerEffect::setProcessBuffers(const AudioBuffer& inBuffer, + const AudioBuffer& outBuffer) { + return mEffect->setProcessBuffers(inBuffer, outBuffer); +} + +Return VisualizerEffect::command(uint32_t commandId, const hidl_vec& data, + uint32_t resultMaxSize, command_cb _hidl_cb) { + return mEffect->command(commandId, data, resultMaxSize, _hidl_cb); +} + +Return VisualizerEffect::setParameter(const hidl_vec& parameter, + const hidl_vec& value) { + return mEffect->setParameter(parameter, value); +} + +Return VisualizerEffect::getParameter(const hidl_vec& parameter, + uint32_t valueMaxSize, getParameter_cb _hidl_cb) { + return mEffect->getParameter(parameter, valueMaxSize, _hidl_cb); +} + +Return VisualizerEffect::getSupportedConfigsForFeature( + uint32_t featureId, uint32_t maxConfigs, uint32_t configSize, + getSupportedConfigsForFeature_cb _hidl_cb) { + return mEffect->getSupportedConfigsForFeature(featureId, maxConfigs, configSize, _hidl_cb); +} + +Return VisualizerEffect::getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize, + getCurrentConfigForFeature_cb _hidl_cb) { + return mEffect->getCurrentConfigForFeature(featureId, configSize, _hidl_cb); +} + +Return VisualizerEffect::setCurrentConfigForFeature(uint32_t featureId, + const hidl_vec& configData) { + return mEffect->setCurrentConfigForFeature(featureId, configData); +} + +Return VisualizerEffect::close() { + return mEffect->close(); +} + +// Methods from ::android::hardware::audio::effect::CPP_VERSION::IVisualizerEffect follow. +Return VisualizerEffect::setCaptureSize(uint16_t captureSize) { + Result retval = mEffect->setParam(VISUALIZER_PARAM_CAPTURE_SIZE, captureSize); + if (retval == Result::OK) { + mCaptureSize = captureSize; + } + return retval; +} + +Return VisualizerEffect::getCaptureSize(getCaptureSize_cb _hidl_cb) { + return mEffect->getIntegerParam(VISUALIZER_PARAM_CAPTURE_SIZE, _hidl_cb); +} + +Return VisualizerEffect::setScalingMode(IVisualizerEffect::ScalingMode scalingMode) { + return mEffect->setParam(VISUALIZER_PARAM_SCALING_MODE, static_cast(scalingMode)); +} + +Return VisualizerEffect::getScalingMode(getScalingMode_cb _hidl_cb) { + int32_t halMode; + Result retval = mEffect->getParam(VISUALIZER_PARAM_SCALING_MODE, halMode); + _hidl_cb(retval, ScalingMode(halMode)); + return Void(); +} + +Return VisualizerEffect::setLatency(uint32_t latencyMs) { + return mEffect->setParam(VISUALIZER_PARAM_LATENCY, latencyMs); +} + +Return VisualizerEffect::getLatency(getLatency_cb _hidl_cb) { + return mEffect->getIntegerParam(VISUALIZER_PARAM_LATENCY, _hidl_cb); +} + +Return VisualizerEffect::setMeasurementMode( + IVisualizerEffect::MeasurementMode measurementMode) { + Result retval = + mEffect->setParam(VISUALIZER_PARAM_MEASUREMENT_MODE, static_cast(measurementMode)); + if (retval == Result::OK) { + mMeasurementMode = measurementMode; + } + return retval; +} + +Return VisualizerEffect::getMeasurementMode(getMeasurementMode_cb _hidl_cb) { + int32_t halMode; + Result retval = mEffect->getParam(VISUALIZER_PARAM_MEASUREMENT_MODE, halMode); + _hidl_cb(retval, MeasurementMode(halMode)); + return Void(); +} + +Return VisualizerEffect::capture(capture_cb _hidl_cb) { + if (mCaptureSize == 0) { + _hidl_cb(Result::NOT_INITIALIZED, hidl_vec()); + return Void(); + } + uint32_t halCaptureSize = mCaptureSize; + uint8_t halCapture[mCaptureSize]; + Result retval = mEffect->sendCommandReturningData(VISUALIZER_CMD_CAPTURE, "VISUALIZER_CAPTURE", + &halCaptureSize, halCapture); + hidl_vec capture; + if (retval == Result::OK) { + capture.setToExternal(&halCapture[0], halCaptureSize); + } + _hidl_cb(retval, capture); + return Void(); +} + +Return VisualizerEffect::measure(measure_cb _hidl_cb) { + if (mMeasurementMode == MeasurementMode::NONE) { + _hidl_cb(Result::NOT_INITIALIZED, Measurement()); + return Void(); + } + int32_t halMeasurement[MEASUREMENT_COUNT]; + uint32_t halMeasurementSize = sizeof(halMeasurement); + Result retval = mEffect->sendCommandReturningData(VISUALIZER_CMD_MEASURE, "VISUALIZER_MEASURE", + &halMeasurementSize, halMeasurement); + Measurement measurement = {.mode = MeasurementMode::PEAK_RMS}; + measurement.value.peakAndRms.peakMb = 0; + measurement.value.peakAndRms.rmsMb = 0; + if (retval == Result::OK) { + measurement.value.peakAndRms.peakMb = halMeasurement[MEASUREMENT_IDX_PEAK]; + measurement.value.peakAndRms.rmsMb = halMeasurement[MEASUREMENT_IDX_RMS]; + } + _hidl_cb(retval, measurement); + return Void(); +} + +} // namespace implementation +} // namespace CPP_VERSION +} // namespace effect +} // namespace audio +} // namespace hardware +} // namespace android -- cgit v1.2.3 From fa02144f8d501c55fc85ca37f4cd283f8734b86b Mon Sep 17 00:00:00 2001 From: Mikhail Naganov Date: Fri, 22 Feb 2019 14:28:26 -0800 Subject: audio: Add support for dumping info from effect HAL modules The implementation uses IBase::debug() method which can write debugging info into the provided file descriptor (same model as used for devices and streams). Bug: 69939533 Test: adb shell dumpsys media.audio_flinger Change-Id: I7876fd43a7066c0f081ea2ca0b3b4b37bbdf8e6c --- audio/effect/all-versions/default/VisualizerEffect.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'audio/effect/all-versions/default/VisualizerEffect.cpp') diff --git a/audio/effect/all-versions/default/VisualizerEffect.cpp b/audio/effect/all-versions/default/VisualizerEffect.cpp index 77bf46bcd3..ae533bf946 100644 --- a/audio/effect/all-versions/default/VisualizerEffect.cpp +++ b/audio/effect/all-versions/default/VisualizerEffect.cpp @@ -162,6 +162,10 @@ Return VisualizerEffect::close() { return mEffect->close(); } +Return VisualizerEffect::debug(const hidl_handle& fd, const hidl_vec& options) { + return mEffect->debug(fd, options); +} + // Methods from ::android::hardware::audio::effect::CPP_VERSION::IVisualizerEffect follow. Return VisualizerEffect::setCaptureSize(uint16_t captureSize) { Result retval = mEffect->setParam(VISUALIZER_PARAM_CAPTURE_SIZE, captureSize); -- cgit v1.2.3