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

Commit 3168fb0f authored by Lais Andrade's avatar Lais Andrade
Browse files

Add scale factor fields to HapticGenerator AIDL 

Add support for haptic scale factors introduced to the HapticScale
parcelable defined at HapticGenerator.aidl.

Make sure the fields are forwarded to the os::HapticScale representation
to be used by ExternalVibratorUtils scaling function.

Bug: 356406324
Bug: 356406686
Flag: android.os.vibrator.haptics_scale_v2_enabled
Test: libvibrator_test
Change-Id: I310527f6a45f52e9dbe44090fc6102f3a69ebe23
parent 1cce4817

media/libaudiohal/impl/effectsAidlConversion/AidlConversionHapticGenerator.cpp

+8 −3
Original line number Diff line number Diff line
@@ -52,12 +52,17 @@ status_t AidlConversionHapticGenerator::setParameter(EffectParamReader& param) { 
    switch (type) {

        case HG_PARAM_HAPTIC_INTENSITY: {

            int32_t id = 0, scale;

            if (OK != param.readFromValue(&id) || OK != param.readFromValue(&scale)) {

            float scaleFactor, adaptiveScaleFactor;

            if (OK != param.readFromValue(&id) || OK != param.readFromValue(&scale) ||

                OK != param.readFromValue(&scaleFactor) ||

                OK != param.readFromValue(&adaptiveScaleFactor)) {

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

                return BAD_VALUE;

            }

            HapticGenerator::HapticScale hpScale(

                    {.id = id, .scale = (HapticGenerator::VibratorScale)(scale)});

            HapticGenerator::HapticScale hpScale({.id = id,

                                                  .scale = (HapticGenerator::VibratorScale)(scale),

                                                  .scaleFactor = scaleFactor,

                                                  .adaptiveScaleFactor = adaptiveScaleFactor});

            aidlParam = MAKE_SPECIFIC_PARAMETER(HapticGenerator, hapticGenerator, hapticScales,

                                                {hpScale});

            break;

media/libeffects/hapticgenerator/EffectHapticGenerator.cpp

+11 −6
Original line number Diff line number Diff line
@@ -325,20 +325,25 @@ int HapticGenerator_SetParameter(struct HapticGeneratorContext *context, effect_ 
            ALOGE("%s invalid haptic intensity param size %s", __func__, reader.toString().c_str());

            return -EINVAL;

        }

        int32_t paramId;

        os::HapticScale hapticScale;

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

        int32_t id, scaleLevel;

        float scaleFactor, adaptiveScaleFactor;

        if (reader.readFromValue(&id) != OK || reader.readFromValue(&scaleLevel) != OK ||

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

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

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

            return -EINVAL;

        }

        os::HapticScale hapticScale(static_cast<os::HapticLevel>(scaleLevel), scaleFactor,

                                    adaptiveScaleFactor);

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

        if (hapticScale.isScaleMute()) {

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

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

        } else {

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

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

        }

        context->param.maxHapticScale = hapticScale;

        for (const auto&[id, scale] : context->param.id2HapticScale) {

        for (const auto&[_, scale] : context->param.id2HapticScale) {

            // TODO(b/360314386): update to use new scale factors

            if (scale.getLevel() > context->param.maxHapticScale.getLevel()) {

                context->param.maxHapticScale = scale;

            }

media/libeffects/hapticgenerator/aidl/HapticGeneratorContext.cpp

+19 −13
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ HapticGeneratorContext::HapticGeneratorContext(int statusDepth, const Parameter: 
    : EffectContext(statusDepth, common) {

    mState = HAPTIC_GENERATOR_STATE_UNINITIALIZED;



    mParams.mMaxVibratorScale = HapticGenerator::VibratorScale::MUTE;

    mParams.mMaxHapticScale = {.scale = HapticGenerator::VibratorScale::MUTE};

    mParams.mVibratorInfo.resonantFrequencyHz = DEFAULT_RESONANT_FREQUENCY;

    mParams.mVibratorInfo.qFactor = DEFAULT_BSF_ZERO_Q;

    mParams.mVibratorInfo.maxAmplitude = 0.f;
@@ -87,13 +87,17 @@ RetCode HapticGeneratorContext::reset() { 
RetCode HapticGeneratorContext::setHgHapticScales(

        const std::vector<HapticGenerator::HapticScale>& hapticScales) {

    for (auto hapticScale : hapticScales) {

        mParams.mHapticScales.insert_or_assign(hapticScale.id, hapticScale.scale);

        mParams.mHapticScales.insert_or_assign(hapticScale.id, hapticScale);

    }

    mParams.mMaxVibratorScale = HapticGenerator::VibratorScale::MUTE;

    mParams.mMaxHapticScale = {.scale = HapticGenerator::VibratorScale::MUTE};

    for (const auto& [id, vibratorScale] : mParams.mHapticScales) {

        mParams.mMaxVibratorScale = std::max(mParams.mMaxVibratorScale, vibratorScale);

        // TODO(b/360314386): update to use new scale factors

        if (vibratorScale.scale > mParams.mMaxHapticScale.scale) {

            mParams.mMaxHapticScale = vibratorScale;

        }

    LOG(INFO) << " HapticGenerator VibratorScale set to " << toString(mParams.mMaxVibratorScale);

    }

    LOG(INFO) << " HapticGenerator VibratorScale set to "

              << toString(mParams.mMaxHapticScale.scale);

    return RetCode::SUCCESS;

}
@@ -103,8 +107,8 @@ HapticGenerator::VibratorInformation HapticGeneratorContext::getHgVibratorInform 


std::vector<HapticGenerator::HapticScale> HapticGeneratorContext::getHgHapticScales() const {

    std::vector<HapticGenerator::HapticScale> result;

    for (const auto& [id, vibratorScale] : mParams.mHapticScales) {

        result.push_back({id, vibratorScale});

    for (const auto& [_, hapticScale] : mParams.mHapticScales) {

        result.push_back(hapticScale);

    }

    return result;

}
@@ -150,7 +154,7 @@ IEffect::Status HapticGeneratorContext::process(float* in, float* out, int sampl 
        return status;

    }



    if (mParams.mMaxVibratorScale == HapticGenerator::VibratorScale::MUTE) {

    if (mParams.mMaxHapticScale.scale == HapticGenerator::VibratorScale::MUTE) {

        // Haptic channels are muted, not need to generate haptic data.

        return {STATUS_OK, samples, samples};

    }
@@ -177,9 +181,10 @@ IEffect::Status HapticGeneratorContext::process(float* in, float* out, int sampl 
            runProcessingChain(mInputBuffer.data(), mOutputBuffer.data(), mFrameCount);

    ::android::os::scaleHapticData(

            hapticOutBuffer, hapticSampleCount,

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

            ::android::os::HapticScale(

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

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

                    mParams.mMaxHapticScale.scaleFactor,

                    mParams.mMaxHapticScale.adaptiveScaleFactor),

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



    // For haptic data, the haptic playback thread will copy the data from effect input
@@ -353,11 +358,12 @@ std::string HapticGeneratorContext::paramToString(const struct HapticGeneratorPa 
    ss << "\t\t- mAudioChannelCount: " << param.mAudioChannelCount << '\n';

    ss << "\t\t- mHapticChannelSource: " << param.mHapticChannelSource[0] << ", "

       << param.mHapticChannelSource[1] << '\n';

    ss << "\t\t- mMaxVibratorScale: " << ::android::internal::ToString(param.mMaxVibratorScale)

       << '\n';

    ss << "\t\t- mMaxHapticScale: " << ::android::internal::ToString(param.mMaxHapticScale.scale)

       << ", scaleFactor=" << param.mMaxHapticScale.scaleFactor

       << ", adaptiveScaleFactor=" << param.mMaxHapticScale.adaptiveScaleFactor << '\n';

    ss << "\t\t- mVibratorInfo: " << param.mVibratorInfo.toString() << '\n';

    for (const auto& it : param.mHapticScales)

        ss << "\t\t\t" << it.first << ": " << toString(it.second) << '\n';

        ss << "\t\t\t" << it.first << ": " << toString(it.second.scale) << '\n';



    return ss.str();

}

media/libeffects/hapticgenerator/aidl/HapticGeneratorContext.h

+2 −2
Original line number Diff line number Diff line
@@ -41,9 +41,9 @@ struct HapticGeneratorParam { 
    int mHapticChannelCount;

    int mAudioChannelCount;



    std::map<int, HapticGenerator::VibratorScale> mHapticScales;

    std::map<int, HapticGenerator::HapticScale> mHapticScales;

    // max intensity will be used to scale haptic data.

    HapticGenerator::VibratorScale mMaxVibratorScale;

    HapticGenerator::HapticScale mMaxHapticScale;



    HapticGenerator::VibratorInformation mVibratorInfo;

};

services/audioflinger/Effects.cpp

+10 −3
Original line number Diff line number Diff line
@@ -1587,18 +1587,25 @@ status_t EffectModule::setHapticScale_l(int id, os::HapticScale hapticScale) { 
        return INVALID_OPERATION;

    }



    // Scale param fields

    int32_t intensityParam = static_cast<int32_t>(HG_PARAM_HAPTIC_INTENSITY);

    int32_t scaleLevel = static_cast<int32_t>(hapticScale.getLevel());

    float scaleFactor = hapticScale.getScaleFactor();

    float adaptiveScaleFactor = hapticScale.getAdaptiveScaleFactor();



    size_t psize = sizeof(int32_t); // HG_PARAM_HAPTIC_INTENSITY

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

    size_t vsize = 2 * sizeof(int32_t) + 2 * sizeof(float); // id + scale fields

    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.writeToValue(&scaleLevel);

    writer.writeToValue(&scaleFactor);

    writer.writeToValue(&adaptiveScaleFactor);

    writer.finishValueWrite();



    std::vector<uint8_t> response;