Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 72f47036 authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Add field to HapticGenerator scale params" into main

parents 0ccf481d e8995e98

media/libaudioprocessing/AudioMixer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -585,7 +585,7 @@ status_t AudioMixer::postCreateTrack(TrackBase *track) 
    t->mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT;

    // haptic

    t->mHapticPlaybackEnabled = false;

    t->mHapticScale = {/*level=*/os::HapticLevel::NONE };

    t->mHapticScale = os::HapticScale::none();

    t->mHapticMaxAmplitude = NAN;

    t->mMixerHapticChannelMask = AUDIO_CHANNEL_NONE;

    t->mMixerHapticChannelCount = 0;

media/libeffects/hapticgenerator/EffectHapticGenerator.cpp

+35 −21
Original line number Diff line number Diff line
@@ -35,12 +35,15 @@ 
#include <audio_utils/format.h>

#include <audio_utils/safe_math.h>

#include <system/audio.h>

#include <system/audio_effects/audio_effects_utils.h>



static constexpr float DEFAULT_RESONANT_FREQUENCY = 150.0f;

static constexpr float DEFAULT_BSF_ZERO_Q = 8.0f;

static constexpr float DEFAULT_BSF_POLE_Q = 4.0f;

static constexpr float DEFAULT_DISTORTION_OUTPUT_GAIN = 1.5f;



using android::effect::utils::EffectParamReader;



// This is the only symbol that needs to be exported

__attribute__ ((visibility ("default")))

audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
@@ -307,25 +310,32 @@ int HapticGenerator_Reset(struct HapticGeneratorContext *context) { 
    return 0;

}



int HapticGenerator_SetParameter(struct HapticGeneratorContext *context,

                                 int32_t param,

                                 uint32_t size,

                                 void *value) {

    switch (param) {

int HapticGenerator_SetParameter(struct HapticGeneratorContext *context, effect_param_t* param) {

    if (param == nullptr) {

        ALOGE("%s invalid effect_param_t is nullptr", __func__);

        return -EINVAL;

    }

    int32_t paramType;

    EffectParamReader reader(*param);

    reader.readFromParameter(&paramType);



    switch (paramType) {

    case HG_PARAM_HAPTIC_INTENSITY: {

        if (value == nullptr || size != (uint32_t) (2 * sizeof(int) + sizeof(float))) {

        if (param->vsize != (sizeof(int32_t) + sizeof(os::HapticScale))) {

            ALOGE("%s invalid haptic intensity param size %s", __func__, reader.toString().c_str());

            return -EINVAL;

        }

        const int id = *(int *) value;

        const os::HapticLevel hapticLevel = static_cast<os::HapticLevel>(*((int *) value + 1));

        const float adaptiveScaleFactor = (*((float *) value + 2));

        const os::HapticScale hapticScale = {hapticLevel, adaptiveScaleFactor};

        ALOGD("Updating haptic scale, hapticLevel=%d, adaptiveScaleFactor=%f",

              static_cast<int>(hapticLevel), adaptiveScaleFactor);

        int32_t paramId;

        os::HapticScale hapticScale;

        if (reader.readFromValue(&paramId) != OK || reader.readFromValue(&hapticScale) != OK) {

            ALOGE("%s error reading haptic intensity %s", __func__, reader.toString().c_str());

            return -EINVAL;

        }

        ALOGD("Updating haptic scale, %s", hapticScale.toString().c_str());

        if (hapticScale.isScaleMute()) {

            context->param.id2HapticScale.erase(id);

            context->param.id2HapticScale.erase(paramId);

        } else {

            context->param.id2HapticScale.emplace(id, hapticScale);

            context->param.id2HapticScale.emplace(paramId, hapticScale);

        }

        context->param.maxHapticScale = hapticScale;

        for (const auto&[id, scale] : context->param.id2HapticScale) {
@@ -336,12 +346,17 @@ int HapticGenerator_SetParameter(struct HapticGeneratorContext *context, 
        break;

    }

    case HG_PARAM_VIBRATOR_INFO: {

        if (value == nullptr || size != 3 * sizeof(float)) {

        if (param->vsize != (3 * sizeof(float))) {

            ALOGE("%s invalid vibrator info param size %s", __func__, reader.toString().c_str());

            return -EINVAL;

        }

        float resonantFrequency, qFactor, maxAmplitude;

        if (reader.readFromValue(&resonantFrequency) != OK ||

            reader.readFromValue(&qFactor) != OK ||

            reader.readFromValue(&maxAmplitude) != OK) {

            ALOGE("%s error reading vibrator info %s", __func__, reader.toString().c_str());

            return -EINVAL;

        }

        const float resonantFrequency = *(float*) value;

        const float qFactor = *((float *) value + 1);

        const float maxAmplitude = *((float *) value + 2);

        context->param.resonantFrequency =

                audio_utils::safe_isnan(resonantFrequency) ? DEFAULT_RESONANT_FREQUENCY

                                                           : resonantFrequency;
@@ -369,7 +384,7 @@ int HapticGenerator_SetParameter(struct HapticGeneratorContext *context, 
        HapticGenerator_Reset(context);

    } break;

    default:

        ALOGW("Unknown param: %d", param);

        ALOGW("Unknown param: %d", paramType);

        return -EINVAL;

    }
@@ -573,8 +588,7 @@ int32_t HapticGenerator_Command(effect_handle_t self, uint32_t cmdCode, uint32_t 
                return -EINVAL;

            }

            effect_param_t *cmd = (effect_param_t *) cmdData;

            *(int *) replyData = HapticGenerator_SetParameter(

                    context, *(int32_t *) cmd->data, cmd->vsize, cmd->data + sizeof(int32_t));

            *(int *) replyData = HapticGenerator_SetParameter(context, cmd);

        }

            break;

media/libeffects/hapticgenerator/aidl/HapticGeneratorContext.cpp

+3 −1
Original line number Diff line number Diff line
@@ -177,7 +177,9 @@ IEffect::Status HapticGeneratorContext::process(float* in, float* out, int sampl 
            runProcessingChain(mInputBuffer.data(), mOutputBuffer.data(), mFrameCount);

    ::android::os::scaleHapticData(

            hapticOutBuffer, hapticSampleCount,

            {static_cast<::android::os::HapticLevel>(mParams.mMaxVibratorScale)} /* scale */,

            // TODO(b/356406686): add the new HapticScale fields to the AIDL interface.

            ::android::os::HapticScale(

                    static_cast<::android::os::HapticLevel>(mParams.mMaxVibratorScale)),

            mParams.mVibratorInfo.maxAmplitude /* limit */);



    // For haptic data, the haptic playback thread will copy the data from effect input

services/audioflinger/Effects.cpp

+31 −21
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ 
#include <mediautils/MethodStatistics.h>

#include <mediautils/ServiceUtilities.h>

#include <mediautils/TimeCheck.h>

#include <system/audio_effects/audio_effects_utils.h>

#include <system/audio_effects/effect_aec.h>

#include <system/audio_effects/effect_downmix.h>

#include <system/audio_effects/effect_dynamicsprocessing.h>
@@ -70,6 +71,7 @@ 
namespace android {



using aidl_utils::statusTFromBinderStatus;

using android::effect::utils::EffectParamWriter;

using audioflinger::EffectConfiguration;

using binder::Status;
@@ -1585,16 +1587,20 @@ status_t EffectModule::setHapticScale_l(int id, os::HapticScale hapticScale) { 
        return INVALID_OPERATION;

    }



    std::vector<uint8_t> request(sizeof(effect_param_t) + 3 * sizeof(uint32_t) + sizeof(float));

    effect_param_t *param = (effect_param_t*) request.data();

    param->psize = sizeof(int32_t);

    param->vsize = sizeof(int32_t) * 2 + sizeof(float);

    *(int32_t*)param->data = HG_PARAM_HAPTIC_INTENSITY;

    int32_t* hapticScalePtr = reinterpret_cast<int32_t*>(param->data + sizeof(int32_t));

    hapticScalePtr[0] = id;

    hapticScalePtr[1] = static_cast<int32_t>(hapticScale.getLevel());

    float* adaptiveScaleFactorPtr = reinterpret_cast<float*>(param->data + 3 * sizeof(int32_t));

    *adaptiveScaleFactorPtr = hapticScale.getAdaptiveScaleFactor();

    size_t psize = sizeof(int32_t); // HG_PARAM_HAPTIC_INTENSITY

    size_t vsize = sizeof(int32_t) + sizeof(os::HapticScale); // id + hapticScale

    std::vector<uint8_t> request(sizeof(effect_param_t) + psize + vsize);

    effect_param_t *effectParam = (effect_param_t*) request.data();

    effectParam->psize = psize;

    effectParam->vsize = vsize;



    int32_t intensityParam = static_cast<int32_t>(HG_PARAM_HAPTIC_INTENSITY);

    EffectParamWriter writer(*effectParam);

    writer.writeToParameter(&intensityParam);

    writer.writeToValue(&id);

    writer.writeToValue(&hapticScale);

    writer.finishValueWrite();



    std::vector<uint8_t> response;

    status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);

    if (status == NO_ERROR) {
@@ -1613,17 +1619,21 @@ status_t EffectModule::setVibratorInfo_l(const media::AudioVibratorInfo& vibrato 
        return INVALID_OPERATION;

    }



    const size_t paramCount = 3;

    std::vector<uint8_t> request(

            sizeof(effect_param_t) + sizeof(int32_t) + paramCount * sizeof(float));

    effect_param_t *param = (effect_param_t*) request.data();

    param->psize = sizeof(int32_t);

    param->vsize = paramCount * sizeof(float);

    *(int32_t*)param->data = HG_PARAM_VIBRATOR_INFO;

    float* vibratorInfoPtr = reinterpret_cast<float*>(param->data + sizeof(int32_t));

    vibratorInfoPtr[0] = vibratorInfo.resonantFrequency;

    vibratorInfoPtr[1] = vibratorInfo.qFactor;

    vibratorInfoPtr[2] = vibratorInfo.maxAmplitude;

    size_t psize = sizeof(int32_t); // HG_PARAM_VIBRATOR_INFO

    size_t vsize = 3 * sizeof(float); // resonantFrequency + qFactor + maxAmplitude

    std::vector<uint8_t> request(sizeof(effect_param_t) + psize + vsize);

    effect_param_t *effectParam = (effect_param_t*) request.data();

    effectParam->psize = psize;

    effectParam->vsize = vsize;



    int32_t infoParam = static_cast<int32_t>(HG_PARAM_VIBRATOR_INFO);

    EffectParamWriter writer(*effectParam);

    writer.writeToParameter(&infoParam);

    writer.writeToValue(&vibratorInfo.resonantFrequency);

    writer.writeToValue(&vibratorInfo.qFactor);

    writer.writeToValue(&vibratorInfo.maxAmplitude);

    writer.finishValueWrite();



    std::vector<uint8_t> response;

    status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);

    if (status == NO_ERROR) {

services/audioflinger/Threads.cpp

+1 −1
Original line number Diff line number Diff line
@@ -5209,7 +5209,7 @@ MixerThread::MixerThread(const sp<IAfThreadCallback>& afThreadCallback, AudioStr 
                                                    // audio to FastMixer

        fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer

        fastTrack->mHapticPlaybackEnabled = mHapticChannelMask != AUDIO_CHANNEL_NONE;

        fastTrack->mHapticScale = {/*level=*/os::HapticLevel::NONE };

        fastTrack->mHapticScale = os::HapticScale::none();

        fastTrack->mHapticMaxAmplitude = NAN;

        fastTrack->mGeneration++;

        state->mFastTracksGen++;