xref: /hardware/interfaces/audio/effect/all-versions/default/Effect.cpp

/*
 * 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.
 */

#include <memory.h>

#define LOG_TAG "EffectHAL"
#define ATRACE_TAG ATRACE_TAG_AUDIO

#include "Effect.h"
#include "common/all-versions/default/EffectMap.h"

#define ATRACE_TAG ATRACE_TAG_AUDIO
#include <HidlUtils.h>
#include <android/log.h>
#include <cutils/properties.h>
#include <media/EffectsFactoryApi.h>
#include <mediautils/ScopedStatistics.h>
#include <sys/syscall.h>
#include <system/audio_effects/effect_spatializer.h>
#include <util/EffectUtils.h>
#include <utils/Trace.h>

#include "VersionUtils.h"

namespace android {
namespace hardware {
namespace audio {
namespace effect {
namespace CPP_VERSION {
namespace implementation {

#if MAJOR_VERSION <= 6
using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation::
        AudioChannelBitfield;
#endif
using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation::HidlUtils;

namespace {

/**
 * Some basic scheduling tools.
 */
namespace scheduler {

int getCpu() {
    return sched_getcpu();
}

uint64_t getAffinity(pid_t tid) {
    cpu_set_t set;
    CPU_ZERO_S(sizeof(set), &set);

    if (sched_getaffinity(tid, sizeof(set), &set)) {
        ALOGW("%s: for tid:%d returning 0, failed %s", __func__, tid, strerror(errno));
        return 0;
    }
    const int count = CPU_COUNT_S(sizeof(set), &set);
    uint64_t mask = 0;
    for (int i = 0; i < CPU_SETSIZE; ++i) {
        if (CPU_ISSET_S(i, sizeof(set), &set)) {
            mask |= 1 << i;
        }
    }
    ALOGV("%s: for tid:%d returning cpu count %d mask %llu", __func__, tid, count,
          (unsigned long long)mask);
    return mask;
}

status_t setAffinity(pid_t tid, uint64_t mask) {
    cpu_set_t set;
    CPU_ZERO_S(sizeof(set), &set);

    for (uint64_t m = mask; m != 0;) {
        uint64_t tz = __builtin_ctz(m);
        CPU_SET_S(tz, sizeof(set), &set);
        m &= ~(1 << tz);
    }
    if (sched_setaffinity(tid, sizeof(set), &set)) {
        ALOGW("%s: for tid:%d setting cpu mask %llu failed %s", __func__, tid,
              (unsigned long long)mask, strerror(errno));
        return -errno;
    }
    ALOGV("%s: for tid:%d setting cpu mask %llu", __func__, tid, (unsigned long long)mask);
    return OK;
}

__unused status_t setPriority(pid_t tid, int policy, int priority) {
    struct sched_param param {
        .sched_priority = priority,
    };
    if (sched_setscheduler(tid, policy, &param) != 0) {
        ALOGW("%s: Cannot set FIFO priority for tid %d to policy %d priority %d  %s", __func__, tid,
              policy, priority, strerror(errno));
        return -errno;
    }
    ALOGV("%s: Successfully set priority for tid %d to policy %d priority %d", __func__, tid,
          policy, priority);
    return NO_ERROR;
}

status_t setUtilMin(pid_t tid, uint32_t utilMin) {
    // Currently, there is no wrapper in bionic: b/183240349.
    struct {
        uint32_t size;
        uint32_t sched_policy;
        uint64_t sched_flags;
        int32_t sched_nice;
        uint32_t sched_priority;
        uint64_t sched_runtime;
        uint64_t sched_deadline;
        uint64_t sched_period;
        uint32_t sched_util_min;
        uint32_t sched_util_max;
    } attr{
            .size = sizeof(attr),
            .sched_flags = SCHED_FLAG_KEEP_ALL | SCHED_FLAG_UTIL_CLAMP_MIN,
            .sched_util_min = utilMin,
    };

    if (syscall(__NR_sched_setattr, tid, &attr, 0 /* flags */)) {
        ALOGW("%s: Cannot set sched_util_min for pid %d to %u  %s", __func__, tid, utilMin,
              strerror(errno));
        return -errno;
    }
    ALOGV("%s: Successfully set sched_util_min for pid %d to %u", __func__, tid, utilMin);
    return NO_ERROR;
}

/*
   Attempts to raise the priority and usage of tid for spatialization.
   Returns OK if everything works.
*/
status_t updateSpatializerPriority(pid_t tid) {
    status_t status = OK;

    const int cpu = getCpu();
    ALOGV("%s: current CPU:%d", __func__, cpu);

    const auto currentAffinity = getAffinity(tid);
    ALOGV("%s: current Affinity:%llx", __func__, (unsigned long long)currentAffinity);

    // Set the desired CPU core affinity.
    // Typically this would be done to move the Spatializer effect off of the little cores.
    // The mid cores and large cores typically have more FP/NEON units
    // and will advantageously reduce power and prevent glitches due CPU limitations.
    //
    // Since this is SOC dependent, we do not set the core affinity here but
    // prefer to set the util_clamp_min below.
    //
    constexpr uint64_t kDefaultAffinity = 0;
    const int32_t desiredAffinity =
            property_get_int32("audio.spatializer.effect.affinity", kDefaultAffinity);
    if (desiredAffinity != 0 && (desiredAffinity & ~currentAffinity) == 0) {
        const status_t localStatus = setAffinity(tid, desiredAffinity);
        status = status ? status : localStatus;
    }

    // Set the util_clamp_min.
    // This is beneficial to reduce glitches when starting up, or due to scheduler
    // thread statistics reset (e.g. core migration), which cause the CPU frequency to drop
    // to minimum.
    //
    // Experimentation has found that moving to a mid core over a little core reduces
    // power if the mid core (e.g. A76/78) has more (e.g. 2x) FP/NEON units
    // than the little core (e.g. A55).
    // A possible value is 300.
    //
    constexpr uint32_t kUtilMin = 0;
    const int32_t utilMin = property_get_int32("audio.spatializer.effect.util_clamp_min", kUtilMin);
    if (utilMin > 0 && utilMin <= 1024) {
        const status_t localStatus = setUtilMin(tid, utilMin);
        status = status ? status : localStatus;
    }

#if 0
    // Provided for local vendor testing but not enabled as audioserver does this for us.
    //
    // Set priority if specified.
    constexpr int32_t kRTPriorityMin = 1;
    constexpr int32_t kRTPriorityMax = 3;
    const int32_t priorityBoost =
            property_get_int32("audio.spatializer.priority", kRTPriorityMin);
    if (priorityBoost >= kRTPriorityMin && priorityBoost <= kRTPriorityMax) {
        const status_t localStatus = scheduler::setPriority(threadId, SCHED_FIFO, priorityBoost);
        status = status ? status : localStatus;
    }
#endif

    return status;
}

}  // namespace scheduler

#define SCOPED_STATS()                                                       \
    ::android::mediautils::ScopedStatistics scopedStatistics {               \
        std::string("EffectHal::").append(__func__), mEffectHal->mStatistics \
    }

class ProcessThread : public Thread {
   public:
    // ProcessThread's lifespan never exceeds Effect's lifespan.
     ProcessThread(std::atomic<bool>* stop, effect_handle_t effect,
                   std::atomic<audio_buffer_t*>* inBuffer, std::atomic<audio_buffer_t*>* outBuffer,
                   Effect::StatusMQ* statusMQ, EventFlag* efGroup, Effect* effectHal)
         : Thread(false /*canCallJava*/),
           mStop(stop),
           mEffect(effect),
           mHasProcessReverse((*mEffect)->process_reverse != NULL),
           mInBuffer(inBuffer),
           mOutBuffer(outBuffer),
           mStatusMQ(statusMQ),
           mEfGroup(efGroup),
           mEffectHal(effectHal) {}
     virtual ~ProcessThread() {}

   private:
    std::atomic<bool>* mStop;
    effect_handle_t mEffect;
    bool mHasProcessReverse;
    std::atomic<audio_buffer_t*>* mInBuffer;
    std::atomic<audio_buffer_t*>* mOutBuffer;
    Effect::StatusMQ* mStatusMQ;
    EventFlag* mEfGroup;
    Effect* const mEffectHal;

    bool threadLoop() override;
};

bool ProcessThread::threadLoop() {
    // This implementation doesn't return control back to the Thread until it decides to stop,
    // as the Thread uses mutexes, and this can lead to priority inversion.
    while (!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
        uint32_t efState = 0;
        mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS_ALL), &efState);
        if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS_ALL)) ||
            (efState & static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_QUIT))) {
            continue;  // Nothing to do or time to quit.
        }
        Result retval = Result::OK;
        if (efState & static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS_REVERSE) &&
            !mHasProcessReverse) {
            retval = Result::NOT_SUPPORTED;
        }

        if (retval == Result::OK) {
            // affects both buffer pointers and their contents.
            std::atomic_thread_fence(std::memory_order_acquire);
            int32_t processResult;
            audio_buffer_t* inBuffer =
                std::atomic_load_explicit(mInBuffer, std::memory_order_relaxed);
            audio_buffer_t* outBuffer =
                std::atomic_load_explicit(mOutBuffer, std::memory_order_relaxed);
            if (inBuffer != nullptr && outBuffer != nullptr) {
                // Time this effect process
                SCOPED_STATS();

                if (efState & static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_PROCESS)) {
                    processResult = (*mEffect)->process(mEffect, inBuffer, outBuffer);
                } else {
                    processResult = (*mEffect)->process_reverse(mEffect, inBuffer, outBuffer);
                }
                std::atomic_thread_fence(std::memory_order_release);
            } else {
                ALOGE("processing buffers were not set before calling 'process'");
                processResult = -ENODEV;
            }
            switch (processResult) {
                case 0:
                    retval = Result::OK;
                    break;
                case -ENODATA:
                    retval = Result::INVALID_STATE;
                    break;
                case -EINVAL:
                    retval = Result::INVALID_ARGUMENTS;
                    break;
                default:
                    retval = Result::NOT_INITIALIZED;
            }
        }
        if (!mStatusMQ->write(&retval)) {
            ALOGW("status message queue write failed");
        }
        mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::DONE_PROCESSING));
    }

    return false;
}

}  // namespace

// static
const char* Effect::sContextResultOfCommand = "returned status";
const char* Effect::sContextCallToCommand = "error";
const char* Effect::sContextCallFunction = sContextCallToCommand;
const char* Effect::sContextConversion = "conversion";

Effect::Effect(bool isInput, effect_handle_t handle)
    : mIsInput(isInput), mHandle(handle), mEfGroup(nullptr), mStopProcessThread(false) {
    (void)mIsInput;  // prevent 'unused field' warnings in pre-V7 versions.
}

Effect::~Effect() {
    ATRACE_CALL();
    auto [_, handle] = closeImpl();
    if (mProcessThread.get()) {
        ATRACE_NAME("mProcessThread->join");
        status_t status = mProcessThread->join();
        ALOGE_IF(status, "processing thread exit error: %s", strerror(-status));
    }
    if (mEfGroup) {
        status_t status = EventFlag::deleteEventFlag(&mEfGroup);
        ALOGE_IF(status, "processing MQ event flag deletion error: %s", strerror(-status));
    }
    mInBuffer.clear();
    mOutBuffer.clear();
#if MAJOR_VERSION <= 5
    int status = EffectRelease(handle);
    ALOGW_IF(status, "Error releasing effect %p: %s", handle, strerror(-status));
#endif
    EffectMap::getInstance().remove(handle);
}

// static
template <typename T>
size_t Effect::alignedSizeIn(size_t s) {
    return (s + sizeof(T) - 1) / sizeof(T);
}

// static
template <typename T>
std::unique_ptr<uint8_t[]> Effect::hidlVecToHal(const hidl_vec<T>& vec, uint32_t* halDataSize) {
    // Due to bugs in HAL, they may attempt to write into the provided
    // input buffer. The original binder buffer is r/o, thus it is needed
    // to create a r/w version.
    *halDataSize = vec.size() * sizeof(T);
    std::unique_ptr<uint8_t[]> halData(new uint8_t[*halDataSize]);
    memcpy(&halData[0], &vec[0], *halDataSize);
    return halData;
}

#if MAJOR_VERSION <= 6

void Effect::effectAuxChannelsConfigFromHal(const channel_config_t& halConfig,
                                            EffectAuxChannelsConfig* config) {
    config->mainChannels = AudioChannelBitfield(halConfig.main_channels);
    config->auxChannels = AudioChannelBitfield(halConfig.aux_channels);
}

// static
void Effect::effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config,
                                          channel_config_t* halConfig) {
    halConfig->main_channels = static_cast<audio_channel_mask_t>(config.mainChannels);
    halConfig->aux_channels = static_cast<audio_channel_mask_t>(config.auxChannels);
}

#else  // MAJOR_VERSION <= 6

void Effect::effectAuxChannelsConfigFromHal(const channel_config_t& halConfig,
                                            EffectAuxChannelsConfig* config) {
    (void)HidlUtils::audioChannelMaskFromHal(halConfig.main_channels, mIsInput,
                                             &config->mainChannels);
    (void)HidlUtils::audioChannelMaskFromHal(halConfig.aux_channels, mIsInput,
                                             &config->auxChannels);
}

// static
void Effect::effectAuxChannelsConfigToHal(const EffectAuxChannelsConfig& config,
                                          channel_config_t* halConfig) {
    (void)HidlUtils::audioChannelMaskToHal(config.mainChannels, &halConfig->main_channels);
    (void)HidlUtils::audioChannelMaskToHal(config.auxChannels, &halConfig->aux_channels);
}

#endif  // MAJOR_VERSION <= 6

// static
void Effect::effectOffloadParamToHal(const EffectOffloadParameter& offload,
                                     effect_offload_param_t* halOffload) {
    halOffload->isOffload = offload.isOffload;
    halOffload->ioHandle = offload.ioHandle;
}

// static
bool Effect::parameterToHal(uint32_t paramSize, const void* paramData, uint32_t valueSize,
                            const void** valueData, std::vector<uint8_t>* halParamBuffer) {
    constexpr size_t kMaxSize = EFFECT_PARAM_SIZE_MAX - sizeof(effect_param_t);
    if (paramSize > kMaxSize) {
        ALOGE("%s: Parameter size is too big: %" PRIu32, __func__, paramSize);
        return false;
    }
    size_t valueOffsetFromData = alignedSizeIn<uint32_t>(paramSize) * sizeof(uint32_t);
    if (valueOffsetFromData > kMaxSize) {
        ALOGE("%s: Aligned parameter size is too big: %zu", __func__, valueOffsetFromData);
        return false;
    }
    if (valueSize > kMaxSize - valueOffsetFromData) {
        ALOGE("%s: Value size is too big: %" PRIu32 ", max size is %zu", __func__, valueSize,
              kMaxSize - valueOffsetFromData);
        android_errorWriteLog(0x534e4554, "237291425");
        return false;
    }
    size_t halParamBufferSize = sizeof(effect_param_t) + valueOffsetFromData + valueSize;
    halParamBuffer->resize(halParamBufferSize, 0);
    effect_param_t* halParam = reinterpret_cast<effect_param_t*>(halParamBuffer->data());
    halParam->psize = paramSize;
    halParam->vsize = valueSize;
    memcpy(halParam->data, paramData, paramSize);
    if (valueData) {
        if (*valueData) {
            // Value data is provided.
            memcpy(halParam->data + valueOffsetFromData, *valueData, valueSize);
        } else {
            // The caller needs the pointer to the value data location.
            *valueData = halParam->data + valueOffsetFromData;
        }
    }
    return true;
}

Result Effect::analyzeCommandStatus(const char* commandName, const char* context, status_t status) {
    return analyzeStatus("command", commandName, context, status);
}

Result Effect::analyzeStatus(const char* funcName, const char* subFuncName,
                             const char* contextDescription, status_t status) {
    if (status != OK) {
        ALOGW("Effect %p %s %s %s: %s", mHandle, funcName, subFuncName, contextDescription,
              strerror(-status));
    }
    switch (status) {
        case OK:
            return Result::OK;
        case -EINVAL:
            return Result::INVALID_ARGUMENTS;
        case -ENODATA:
            return Result::INVALID_STATE;
        case -ENODEV:
            return Result::NOT_INITIALIZED;
        case -ENOMEM:
            return Result::RESULT_TOO_BIG;
        case -ENOSYS:
            return Result::NOT_SUPPORTED;
        default:
            return Result::INVALID_STATE;
    }
}

#define RETURN_IF_EFFECT_CLOSED()          \
    if (mHandle == kInvalidEffectHandle) { \
        return Result::INVALID_STATE;      \
    }
#define RETURN_RESULT_IF_EFFECT_CLOSED(result)   \
    if (mHandle == kInvalidEffectHandle) {       \
        _hidl_cb(Result::INVALID_STATE, result); \
        return Void();                           \
    }

Return<void> Effect::getConfigImpl(int commandCode, const char* commandName,
                                   GetConfigCallback _hidl_cb) {
    RETURN_RESULT_IF_EFFECT_CLOSED(EffectConfig());
    uint32_t halResultSize = sizeof(effect_config_t);
    effect_config_t halConfig{};
    status_t status =
        (*mHandle)->command(mHandle, commandCode, 0, NULL, &halResultSize, &halConfig);
    EffectConfig config;
    if (status == OK) {
        status = EffectUtils::effectConfigFromHal(halConfig, mIsInput, &config);
    }
    _hidl_cb(analyzeCommandStatus(commandName, sContextCallToCommand, status), config);
    return Void();
}

Result Effect::getCurrentConfigImpl(uint32_t featureId, uint32_t configSize,
                                    GetCurrentConfigSuccessCallback onSuccess) {
    if (configSize > kMaxDataSize - sizeof(uint32_t)) {
        ALOGE("%s: Config size is too big: %" PRIu32, __func__, configSize);
        android_errorWriteLog(0x534e4554, "240266798");
        return Result::INVALID_ARGUMENTS;
    }
    uint32_t halCmd = featureId;
    std::vector<uint32_t> halResult(alignedSizeIn<uint32_t>(sizeof(uint32_t) + configSize), 0);
    uint32_t halResultSize = 0;
    return sendCommandReturningStatusAndData(
            EFFECT_CMD_GET_FEATURE_CONFIG, "GET_FEATURE_CONFIG", sizeof(uint32_t), &halCmd,
            &halResultSize, &halResult[0], sizeof(uint32_t), [&] { onSuccess(&halResult[1]); });
}

Result Effect::getParameterImpl(uint32_t paramSize, const void* paramData,
                                uint32_t requestValueSize, uint32_t replyValueSize,
                                GetParameterSuccessCallback onSuccess) {
    // As it is unknown what method HAL uses for copying the provided parameter data,
    // it is safer to make sure that input and output buffers do not overlap.
    std::vector<uint8_t> halCmdBuffer;
    if (!parameterToHal(paramSize, paramData, requestValueSize, nullptr, &halCmdBuffer)) {
        return Result::INVALID_ARGUMENTS;
    }
    const void* valueData = nullptr;
    std::vector<uint8_t> halParamBuffer;
    if (!parameterToHal(paramSize, paramData, replyValueSize, &valueData, &halParamBuffer)) {
        return Result::INVALID_ARGUMENTS;
    }
    uint32_t halParamBufferSize = halParamBuffer.size();

    return sendCommandReturningStatusAndData(
        EFFECT_CMD_GET_PARAM, "GET_PARAM", halCmdBuffer.size(), &halCmdBuffer[0],
        &halParamBufferSize, &halParamBuffer[0], sizeof(effect_param_t), [&] {
            effect_param_t* halParam = reinterpret_cast<effect_param_t*>(&halParamBuffer[0]);
            onSuccess(halParam->vsize, valueData);
        });
}

Result Effect::getSupportedConfigsImpl(uint32_t featureId, uint32_t maxConfigs, uint32_t configSize,
                                       GetSupportedConfigsSuccessCallback onSuccess) {
    if (maxConfigs != 0 && configSize > (kMaxDataSize - 2 * sizeof(uint32_t)) / maxConfigs) {
        ALOGE("%s: Config size is too big: %" PRIu32, __func__, configSize);
        return Result::INVALID_ARGUMENTS;
    }
    uint32_t halCmd[2] = {featureId, maxConfigs};
    uint32_t halResultSize = 2 * sizeof(uint32_t) + maxConfigs * configSize;
    std::vector<uint8_t> halResult(static_cast<size_t>(halResultSize), 0);
    return sendCommandReturningStatusAndData(
        EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS, "GET_FEATURE_SUPPORTED_CONFIGS", sizeof(halCmd),
        halCmd, &halResultSize, &halResult[0], 2 * sizeof(uint32_t), [&] {
            uint32_t* halResult32 = reinterpret_cast<uint32_t*>(&halResult[0]);
            uint32_t supportedConfigs = *(++halResult32);  // skip status field
            if (supportedConfigs > maxConfigs) supportedConfigs = maxConfigs;
            onSuccess(supportedConfigs, ++halResult32);
        });
}

Return<void> Effect::prepareForProcessing(prepareForProcessing_cb _hidl_cb) {
    RETURN_RESULT_IF_EFFECT_CLOSED(StatusMQ::Descriptor());
    status_t status;
    // Create message queue.
    if (mStatusMQ) {
        ALOGE("the client attempts to call prepareForProcessing_cb twice");
        _hidl_cb(Result::INVALID_STATE, StatusMQ::Descriptor());
        return Void();
    }
    std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1, true /*EventFlag*/));
    if (!tempStatusMQ->isValid()) {
        ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
        _hidl_cb(Result::INVALID_ARGUMENTS, StatusMQ::Descriptor());
        return Void();
    }
    status = EventFlag::createEventFlag(tempStatusMQ->getEventFlagWord(), &mEfGroup);
    if (status != OK || !mEfGroup) {
        ALOGE("failed creating event flag for status MQ: %s", strerror(-status));
        _hidl_cb(Result::INVALID_ARGUMENTS, StatusMQ::Descriptor());
        return Void();
    }

    // Create and launch the thread.
    mProcessThread = new ProcessThread(&mStopProcessThread, mHandle, &mHalInBufferPtr,
                                       &mHalOutBufferPtr, tempStatusMQ.get(), mEfGroup, this);
    status = mProcessThread->run("effect", PRIORITY_URGENT_AUDIO);
    if (status != OK) {
        ALOGW("failed to start effect processing thread: %s", strerror(-status));
        _hidl_cb(Result::INVALID_ARGUMENTS, MQDescriptorSync<Result>());
        return Void();
    }

    // For a spatializer effect, we perform scheduler adjustments to reduce glitches and power.
    // We do it here instead of the ProcessThread::threadLoop to ensure that mHandle is valid.
    if (effect_descriptor_t halDescriptor{};
        (*mHandle)->get_descriptor(mHandle, &halDescriptor) == NO_ERROR &&
        memcmp(&halDescriptor.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0) {
        const status_t status = scheduler::updateSpatializerPriority(mProcessThread->getTid());
        ALOGW_IF(status != OK, "Failed to update Spatializer priority");
    }

    mStatusMQ = std::move(tempStatusMQ);
    _hidl_cb(Result::OK, *mStatusMQ->getDesc());
    return Void();
}

Return<Result> Effect::setProcessBuffers(const AudioBuffer& inBuffer,
                                         const AudioBuffer& outBuffer) {
    RETURN_IF_EFFECT_CLOSED();
    AudioBufferManager& manager = AudioBufferManager::getInstance();
    sp<AudioBufferWrapper> tempInBuffer, tempOutBuffer;
    if (!manager.wrap(inBuffer, &tempInBuffer)) {
        ALOGE("Could not map memory of the input buffer");
        return Result::INVALID_ARGUMENTS;
    }
    if (!manager.wrap(outBuffer, &tempOutBuffer)) {
        ALOGE("Could not map memory of the output buffer");
        return Result::INVALID_ARGUMENTS;
    }
    mInBuffer = tempInBuffer;
    mOutBuffer = tempOutBuffer;
    // The processing thread only reads these pointers after waking up by an event flag,
    // so it's OK to update the pair non-atomically.
    mHalInBufferPtr.store(mInBuffer->getHalBuffer(), std::memory_order_release);
    mHalOutBufferPtr.store(mOutBuffer->getHalBuffer(), std::memory_order_release);
    return Result::OK;
}

Result Effect::sendCommand(int commandCode, const char* commandName) {
    return sendCommand(commandCode, commandName, 0, NULL);
}

Result Effect::sendCommand(int commandCode, const char* commandName, uint32_t size, void* data) {
    RETURN_IF_EFFECT_CLOSED();
    status_t status = (*mHandle)->command(mHandle, commandCode, size, data, 0, NULL);
    return analyzeCommandStatus(commandName, sContextCallToCommand, status);
}

Result Effect::sendCommandReturningData(int commandCode, const char* commandName,
                                        uint32_t* replySize, void* replyData) {
    return sendCommandReturningData(commandCode, commandName, 0, NULL, replySize, replyData);
}

Result Effect::sendCommandReturningData(int commandCode, const char* commandName, uint32_t size,
                                        void* data, uint32_t* replySize, void* replyData) {
    RETURN_IF_EFFECT_CLOSED();
    uint32_t expectedReplySize = *replySize;
    status_t status = (*mHandle)->command(mHandle, commandCode, size, data, replySize, replyData);
    if (status == OK && *replySize != expectedReplySize) {
        status = -ENODATA;
    }
    return analyzeCommandStatus(commandName, sContextCallToCommand, status);
}

Result Effect::sendCommandReturningStatus(int commandCode, const char* commandName) {
    return sendCommandReturningStatus(commandCode, commandName, 0, NULL);
}

Result Effect::sendCommandReturningStatus(int commandCode, const char* commandName, uint32_t size,
                                          void* data) {
    uint32_t replyCmdStatus;
    uint32_t replySize = sizeof(uint32_t);
    return sendCommandReturningStatusAndData(commandCode, commandName, size, data, &replySize,
                                             &replyCmdStatus, replySize, [] {});
}

Result Effect::sendCommandReturningStatusAndData(int commandCode, const char* commandName,
                                                 uint32_t size, void* data, uint32_t* replySize,
                                                 void* replyData, uint32_t minReplySize,
                                                 CommandSuccessCallback onSuccess) {
    RETURN_IF_EFFECT_CLOSED();
    status_t status = (*mHandle)->command(mHandle, commandCode, size, data, replySize, replyData);
    Result retval;
    if (status == OK && minReplySize >= sizeof(uint32_t) && *replySize >= minReplySize) {
        uint32_t commandStatus = *reinterpret_cast<uint32_t*>(replyData);
        retval = analyzeCommandStatus(commandName, sContextResultOfCommand, commandStatus);
        if (commandStatus == OK) {
            onSuccess();
        }
    } else {
        retval = analyzeCommandStatus(commandName, sContextCallToCommand, status);
    }
    return retval;
}

Result Effect::setConfigImpl(int commandCode, const char* commandName, const EffectConfig& config,
                             const sp<IEffectBufferProviderCallback>& inputBufferProvider,
                             const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
    effect_config_t halConfig;
    EffectUtils::effectConfigToHal(config, &halConfig);
    if (inputBufferProvider != 0) {
        LOG_FATAL("Using input buffer provider is not supported");
    }
    if (outputBufferProvider != 0) {
        LOG_FATAL("Using output buffer provider is not supported");
    }
    return sendCommandReturningStatus(commandCode, commandName, sizeof(effect_config_t),
                                      &halConfig);
}

Result Effect::setParameterImpl(uint32_t paramSize, const void* paramData, uint32_t valueSize,
                                const void* valueData) {
    std::vector<uint8_t> halParamBuffer;
    if (!parameterToHal(paramSize, paramData, valueSize, &valueData, &halParamBuffer)) {
        return Result::INVALID_ARGUMENTS;
    }
    return sendCommandReturningStatus(EFFECT_CMD_SET_PARAM, "SET_PARAM", halParamBuffer.size(),
                                      &halParamBuffer[0]);
}

// Methods from ::android::hardware::audio::effect::CPP_VERSION::IEffect follow.
Return<Result> Effect::init() {
    return sendCommandReturningStatus(EFFECT_CMD_INIT, "INIT");
}

Return<Result> Effect::setConfig(const EffectConfig& config,
                                 const sp<IEffectBufferProviderCallback>& inputBufferProvider,
                                 const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
    return setConfigImpl(EFFECT_CMD_SET_CONFIG, "SET_CONFIG", config, inputBufferProvider,
                         outputBufferProvider);
}

Return<Result> Effect::reset() {
    return sendCommand(EFFECT_CMD_RESET, "RESET");
}

Return<Result> Effect::enable() {
    return sendCommandReturningStatus(EFFECT_CMD_ENABLE, "ENABLE");
}

Return<Result> Effect::disable() {
    return sendCommandReturningStatus(EFFECT_CMD_DISABLE, "DISABLE");
}

Return<Result> Effect::setAudioSource(
#if MAJOR_VERSION <= 6
        AudioSource source
#else
        const AudioSource& source
#endif
) {
    audio_source_t halSource;
    if (status_t status = HidlUtils::audioSourceToHal(source, &halSource); status == NO_ERROR) {
        uint32_t halSourceParam = static_cast<uint32_t>(halSource);
        return sendCommand(EFFECT_CMD_SET_AUDIO_SOURCE, "SET_AUDIO_SOURCE", sizeof(uint32_t),
                           &halSourceParam);
    } else {
        return analyzeStatus(__func__, "audioSourceToHal", sContextConversion, status);
    }
}

#if MAJOR_VERSION <= 6

Return<Result> Effect::setDevice(AudioDeviceBitfield device) {
    uint32_t halDevice = static_cast<uint32_t>(device);
    return sendCommand(EFFECT_CMD_SET_DEVICE, "SET_DEVICE", sizeof(uint32_t), &halDevice);
}

Return<Result> Effect::setInputDevice(AudioDeviceBitfield device) {
    uint32_t halDevice = static_cast<uint32_t>(device);
    return sendCommand(EFFECT_CMD_SET_INPUT_DEVICE, "SET_INPUT_DEVICE", sizeof(uint32_t),
                       &halDevice);
}

#else  // MAJOR_VERSION <= 6

Return<Result> Effect::setDevice(const DeviceAddress& device) {
    audio_devices_t halDevice;
    char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
    if (status_t status = HidlUtils::deviceAddressToHal(device, &halDevice, halDeviceAddress);
        status == NO_ERROR) {
        uint32_t halDeviceParam = static_cast<uint32_t>(halDevice);
        return sendCommand(EFFECT_CMD_SET_DEVICE, "SET_DEVICE", sizeof(uint32_t), &halDeviceParam);
    } else {
        return analyzeStatus(__func__, "deviceAddressToHal", sContextConversion, status);
    }
}

Return<Result> Effect::setInputDevice(const DeviceAddress& device) {
    audio_devices_t halDevice;
    char halDeviceAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
    if (status_t status = HidlUtils::deviceAddressToHal(device, &halDevice, halDeviceAddress);
        status == NO_ERROR) {
        uint32_t halDeviceParam = static_cast<uint32_t>(halDevice);
        return sendCommand(EFFECT_CMD_SET_INPUT_DEVICE, "SET_INPUT_DEVICE", sizeof(uint32_t),
                           &halDeviceParam);
    } else {
        return analyzeStatus(__func__, "deviceAddressToHal", sContextConversion, status);
    }
}

#endif  // MAJOR_VERSION <= 6

Return<void> Effect::setAndGetVolume(const hidl_vec<uint32_t>& volumes,
                                     setAndGetVolume_cb _hidl_cb) {
    uint32_t halDataSize;
    std::unique_ptr<uint8_t[]> halData = hidlVecToHal(volumes, &halDataSize);
    uint32_t halResultSize = halDataSize;
    std::vector<uint32_t> halResult(volumes.size(), 0);
    Result retval = sendCommandReturningData(EFFECT_CMD_SET_VOLUME, "SET_VOLUME", halDataSize,
                                             &halData[0], &halResultSize, &halResult[0]);
    hidl_vec<uint32_t> result;
    if (retval == Result::OK) {
        result.setToExternal(&halResult[0], halResultSize);
    }
    _hidl_cb(retval, result);
    return Void();
}

Return<Result> Effect::volumeChangeNotification(const hidl_vec<uint32_t>& volumes) {
    uint32_t halDataSize;
    std::unique_ptr<uint8_t[]> halData = hidlVecToHal(volumes, &halDataSize);
    return sendCommand(EFFECT_CMD_SET_VOLUME, "SET_VOLUME", halDataSize, &halData[0]);
}

Return<Result> Effect::setAudioMode(AudioMode mode) {
    uint32_t halMode = static_cast<uint32_t>(mode);
    return sendCommand(EFFECT_CMD_SET_AUDIO_MODE, "SET_AUDIO_MODE", sizeof(uint32_t), &halMode);
}

Return<Result> Effect::setConfigReverse(
    const EffectConfig& config, const sp<IEffectBufferProviderCallback>& inputBufferProvider,
    const sp<IEffectBufferProviderCallback>& outputBufferProvider) {
    return setConfigImpl(EFFECT_CMD_SET_CONFIG_REVERSE, "SET_CONFIG_REVERSE", config,
                         inputBufferProvider, outputBufferProvider);
}

Return<void> Effect::getConfig(getConfig_cb _hidl_cb) {
    return getConfigImpl(EFFECT_CMD_GET_CONFIG, "GET_CONFIG", _hidl_cb);
}

Return<void> Effect::getConfigReverse(getConfigReverse_cb _hidl_cb) {
    return getConfigImpl(EFFECT_CMD_GET_CONFIG_REVERSE, "GET_CONFIG_REVERSE", _hidl_cb);
}

Return<void> Effect::getSupportedAuxChannelsConfigs(uint32_t maxConfigs,
                                                    getSupportedAuxChannelsConfigs_cb _hidl_cb) {
    hidl_vec<EffectAuxChannelsConfig> result;
    Result retval = getSupportedConfigsImpl(
        EFFECT_FEATURE_AUX_CHANNELS, maxConfigs, sizeof(channel_config_t),
        [&](uint32_t supportedConfigs, void* configsData) {
            result.resize(supportedConfigs);
            channel_config_t* config = reinterpret_cast<channel_config_t*>(configsData);
            for (size_t i = 0; i < result.size(); ++i) {
                effectAuxChannelsConfigFromHal(*config++, &result[i]);
            }
        });
    _hidl_cb(retval, result);
    return Void();
}

Return<void> Effect::getAuxChannelsConfig(getAuxChannelsConfig_cb _hidl_cb) {
    EffectAuxChannelsConfig result;
    Result retval = getCurrentConfigImpl(
        EFFECT_FEATURE_AUX_CHANNELS, sizeof(channel_config_t), [&](void* configData) {
            effectAuxChannelsConfigFromHal(*reinterpret_cast<channel_config_t*>(configData),
                                           &result);
        });
    _hidl_cb(retval, result);
    return Void();
}

Return<Result> Effect::setAuxChannelsConfig(const EffectAuxChannelsConfig& config) {
    std::vector<uint32_t> halCmd(
            alignedSizeIn<uint32_t>(sizeof(uint32_t) + sizeof(channel_config_t)), 0);
    halCmd[0] = EFFECT_FEATURE_AUX_CHANNELS;
    effectAuxChannelsConfigToHal(config, reinterpret_cast<channel_config_t*>(&halCmd[1]));
    return sendCommandReturningStatus(EFFECT_CMD_SET_FEATURE_CONFIG,
                                      "SET_FEATURE_CONFIG AUX_CHANNELS", halCmd.size(), &halCmd[0]);
}

Return<Result> Effect::offload(const EffectOffloadParameter& param) {
    effect_offload_param_t halParam;
    effectOffloadParamToHal(param, &halParam);
    return sendCommandReturningStatus(EFFECT_CMD_OFFLOAD, "OFFLOAD", sizeof(effect_offload_param_t),
                                      &halParam);
}

Return<void> Effect::getDescriptor(getDescriptor_cb _hidl_cb) {
    RETURN_RESULT_IF_EFFECT_CLOSED(EffectDescriptor());
    effect_descriptor_t halDescriptor;
    memset(&halDescriptor, 0, sizeof(effect_descriptor_t));
    status_t status = (*mHandle)->get_descriptor(mHandle, &halDescriptor);
    EffectDescriptor descriptor;
    if (status == OK) {
        status = EffectUtils::effectDescriptorFromHal(halDescriptor, &descriptor);
    }
    _hidl_cb(analyzeStatus("get_descriptor", "", sContextCallFunction, status), descriptor);
    return Void();
}

Return<void> Effect::command(uint32_t commandId, const hidl_vec<uint8_t>& data,
                             uint32_t resultMaxSize, command_cb _hidl_cb) {
    if (mHandle == kInvalidEffectHandle) {
        _hidl_cb(-ENODATA, hidl_vec<uint8_t>());
        return Void();
    }
    uint32_t halDataSize;
    std::unique_ptr<uint8_t[]> halData = hidlVecToHal(data, &halDataSize);
    uint32_t halResultSize = resultMaxSize;
    std::unique_ptr<uint8_t[]> halResult(new uint8_t[halResultSize]);
    memset(&halResult[0], 0, halResultSize);

    void* dataPtr = halDataSize > 0 ? &halData[0] : NULL;
    void* resultPtr = halResultSize > 0 ? &halResult[0] : NULL;
    status_t status = BAD_VALUE;
    switch (commandId) {
        case 'gtid':  // retrieve the tid, used for spatializer priority boost
            if (halDataSize == 0 && resultMaxSize == sizeof(int32_t)) {
                auto ptid = (int32_t*)resultPtr;
                ptid[0] = mProcessThread ? mProcessThread->getTid() : -1;
                status = OK;
                break;  // we have handled 'gtid' here.
            }
            [[fallthrough]];  // allow 'gtid' overload (checked halDataSize and resultMaxSize).
        default:
            status = (*mHandle)->command(mHandle, commandId, halDataSize, dataPtr, &halResultSize,
                                         resultPtr);
            break;
    }
    hidl_vec<uint8_t> result;
    if (status == OK && resultPtr != NULL) {
        result.setToExternal(&halResult[0], halResultSize);
    }
    _hidl_cb(status, result);
    return Void();
}

Return<Result> Effect::setParameter(const hidl_vec<uint8_t>& parameter,
                                    const hidl_vec<uint8_t>& value) {
    return setParameterImpl(parameter.size(), &parameter[0], value.size(), &value[0]);
}

Return<void> Effect::getParameter(const hidl_vec<uint8_t>& parameter, uint32_t valueMaxSize,
                                  getParameter_cb _hidl_cb) {
    hidl_vec<uint8_t> value;
    Result retval = getParameterImpl(
        parameter.size(), &parameter[0], valueMaxSize,
        [&](uint32_t valueSize, const void* valueData) {
            value.setToExternal(reinterpret_cast<uint8_t*>(const_cast<void*>(valueData)),
                                valueSize);
        });
    _hidl_cb(retval, value);
    return Void();
}

Return<void> Effect::getSupportedConfigsForFeature(uint32_t featureId, uint32_t maxConfigs,
                                                   uint32_t configSize,
                                                   getSupportedConfigsForFeature_cb _hidl_cb) {
    uint32_t configCount = 0;
    hidl_vec<uint8_t> result;
    Result retval = getSupportedConfigsImpl(featureId, maxConfigs, configSize,
                                            [&](uint32_t supportedConfigs, void* configsData) {
                                                configCount = supportedConfigs;
                                                result.resize(configCount * configSize);
                                                memcpy(&result[0], configsData, result.size());
                                            });
    _hidl_cb(retval, configCount, result);
    return Void();
}

Return<void> Effect::getCurrentConfigForFeature(uint32_t featureId, uint32_t configSize,
                                                getCurrentConfigForFeature_cb _hidl_cb) {
    hidl_vec<uint8_t> result;
    Result retval = getCurrentConfigImpl(featureId, configSize, [&](void* configData) {
        result.resize(configSize);
        memcpy(&result[0], configData, result.size());
    });
    _hidl_cb(retval, result);
    return Void();
}

Return<Result> Effect::setCurrentConfigForFeature(uint32_t featureId,
                                                  const hidl_vec<uint8_t>& configData) {
    std::vector<uint32_t> halCmd(alignedSizeIn<uint32_t>(sizeof(uint32_t) + configData.size()), 0);
    halCmd[0] = featureId;
    memcpy(&halCmd[1], &configData[0], configData.size());
    return sendCommandReturningStatus(EFFECT_CMD_SET_FEATURE_CONFIG, "SET_FEATURE_CONFIG",
                                      halCmd.size(), &halCmd[0]);
}

std::tuple<Result, effect_handle_t> Effect::closeImpl() {
    if (mStopProcessThread.load(std::memory_order_relaxed)) {  // only this thread modifies
        return {Result::INVALID_STATE, kInvalidEffectHandle};
    }
    mStopProcessThread.store(true, std::memory_order_release);
    if (mEfGroup) {
        mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::REQUEST_QUIT));
    }
    effect_handle_t handle = mHandle;
    mHandle = kInvalidEffectHandle;
#if MAJOR_VERSION <= 5
    return {Result::OK, handle};
#elif MAJOR_VERSION >= 6
    // No need to join the processing thread, it is part of the API contract that the client
    // must finish processing before closing the effect.
    Result retval = analyzeStatus("EffectRelease", "", sContextCallFunction, EffectRelease(handle));
    EffectMap::getInstance().remove(handle);
    return {retval, handle};
#endif
}

Return<Result> Effect::close() {
    RETURN_IF_EFFECT_CLOSED();
    auto [result, _] = closeImpl();
    return result;
}

Return<void> Effect::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& /* options */) {
    if (fd.getNativeHandle() != nullptr && fd->numFds == 1) {
        uint32_t cmdData = fd->data[0];
        (void)sendCommand(EFFECT_CMD_DUMP, "DUMP", sizeof(cmdData), &cmdData);
        const std::string s = mStatistics->dump();
        if (s.size() != 0) write(cmdData, s.c_str(), s.size());
    }
    return Void();
}

}  // namespace implementation
}  // namespace CPP_VERSION
}  // namespace effect
}  // namespace audio
}  // namespace hardware
}  // namespace android