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

Commit 7dbf9627 authored by Shunkai Yao's avatar Shunkai Yao Committed by Automerger Merge Worker
Browse files

Merge "Effect AIDL: relax dynamics processing effect parameter validations"... 

Merge "Effect AIDL: relax dynamics processing effect parameter validations" into 24D1-dev am: d7b9e61d

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/av/+/26767577



Change-Id: I4a7f4f520baf036c3b840919dce93fab6f047eb4
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents e8528998 d7b9e61d

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp

+5 −25
Original line number Original line Diff line number Diff line
@@ -118,26 +118,21 @@ RetCode DynamicsProcessingContext::setEngineArchitecture( 




RetCode DynamicsProcessingContext::setPreEq(

RetCode DynamicsProcessingContext::setPreEq(

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

    return setDpChannels_l<dp_fx::DPEq>(channels, mEngineArchitecture.preEqStage.inUse,

    return setDpChannels_l<dp_fx::DPEq>(channels, StageType::PREEQ);

                                        StageType::PREEQ);

}

}





RetCode DynamicsProcessingContext::setPostEq(

RetCode DynamicsProcessingContext::setPostEq(

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

    return setDpChannels_l<dp_fx::DPEq>(channels, mEngineArchitecture.postEqStage.inUse,

    return setDpChannels_l<dp_fx::DPEq>(channels, StageType::POSTEQ);

                                        StageType::POSTEQ);

}

}





RetCode DynamicsProcessingContext::setMbc(

RetCode DynamicsProcessingContext::setMbc(

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

        const std::vector<DynamicsProcessing::ChannelConfig>& channels) {

    return setDpChannels_l<dp_fx::DPMbc>(channels, mEngineArchitecture.mbcStage.inUse,

    return setDpChannels_l<dp_fx::DPMbc>(channels, StageType::MBC);

                                         StageType::MBC);

}

}





RetCode DynamicsProcessingContext::setPreEqBand(

RetCode DynamicsProcessingContext::setPreEqBand(

        const std::vector<DynamicsProcessing::EqBandConfig>& bands) {

        const std::vector<DynamicsProcessing::EqBandConfig>& bands) {

    RETURN_VALUE_IF(!mEngineArchitecture.preEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "preEqNotInUse");

    RETURN_VALUE_IF(

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.preEqStage.bandCount),

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.preEqStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
@@ -146,8 +141,6 @@ RetCode DynamicsProcessingContext::setPreEqBand( 




RetCode DynamicsProcessingContext::setPostEqBand(

RetCode DynamicsProcessingContext::setPostEqBand(

        const std::vector<DynamicsProcessing::EqBandConfig>& bands) {

        const std::vector<DynamicsProcessing::EqBandConfig>& bands) {

    RETURN_VALUE_IF(!mEngineArchitecture.postEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "postEqNotInUse");

    RETURN_VALUE_IF(

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.postEqStage.bandCount),

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.postEqStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
@@ -156,8 +149,6 @@ RetCode DynamicsProcessingContext::setPostEqBand( 




RetCode DynamicsProcessingContext::setMbcBand(

RetCode DynamicsProcessingContext::setMbcBand(

        const std::vector<DynamicsProcessing::MbcBandConfig>& bands) {

        const std::vector<DynamicsProcessing::MbcBandConfig>& bands) {

    RETURN_VALUE_IF(!mEngineArchitecture.mbcStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "mbcNotInUse");

    RETURN_VALUE_IF(

    RETURN_VALUE_IF(

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.mbcStage.bandCount),

            !validateBandConfig(bands, mChannelCount, mEngineArchitecture.mbcStage.bandCount),

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");

            RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
@@ -166,8 +157,6 @@ RetCode DynamicsProcessingContext::setMbcBand( 




RetCode DynamicsProcessingContext::setLimiter(

RetCode DynamicsProcessingContext::setLimiter(

        const std::vector<DynamicsProcessing::LimiterConfig>& limiters) {

        const std::vector<DynamicsProcessing::LimiterConfig>& limiters) {

    RETURN_VALUE_IF(!mEngineArchitecture.limiterInUse, RetCode::ERROR_ILLEGAL_PARAMETER,

                    "limiterNotInUse");

    RETURN_VALUE_IF(!validateLimiterConfig(limiters, mChannelCount),

    RETURN_VALUE_IF(!validateLimiterConfig(limiters, mChannelCount),

                    RetCode::ERROR_ILLEGAL_PARAMETER, "limiterConfigNotValid");

                    RetCode::ERROR_ILLEGAL_PARAMETER, "limiterConfigNotValid");

    return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, StageType::LIMITER);

    return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, StageType::LIMITER);
@@ -419,9 +408,7 @@ bool DynamicsProcessingContext::validateBandConfig(const std::vector<T>& bands, 
        }

        }

        freqs[band.band] = band.cutoffFrequencyHz;

        freqs[band.band] = band.cutoffFrequencyHz;

    }

    }

    return std::is_sorted(freqs.begin(), freqs.end(), [](const auto& a, const auto& b) {

    return true;

        return a.second <= b.second; //index is already sorted as map key

    });

}

}





bool DynamicsProcessingContext::validateLimiterConfig(

bool DynamicsProcessingContext::validateLimiterConfig(
@@ -442,17 +429,10 @@ bool DynamicsProcessingContext::validateInputGainConfig( 




template <typename D>

template <typename D>

RetCode DynamicsProcessingContext::setDpChannels_l(

RetCode DynamicsProcessingContext::setDpChannels_l(

        const std::vector<DynamicsProcessing::ChannelConfig>& channels, bool stageInUse,

        const std::vector<DynamicsProcessing::ChannelConfig>& channels, StageType type) {

        StageType type) {

    RetCode ret = RetCode::SUCCESS;

    RetCode ret = RetCode::SUCCESS;

    std::unordered_set<int> channelSet;

    std::unordered_set<int> channelSet;





    if (!stageInUse) {

        LOG(WARNING) << __func__ << " not in use " << ::android::internal::ToString(channels);

        return RetCode::ERROR_ILLEGAL_PARAMETER;

    }



    RETURN_VALUE_IF(!stageInUse, RetCode::ERROR_ILLEGAL_PARAMETER, "stageNotInUse");

    for (auto& it : channels) {

    for (auto& it : channels) {

        if (0 != channelSet.count(it.channel)) {

        if (0 != channelSet.count(it.channel)) {

            LOG(WARNING) << __func__ << " duplicated channel " << it.channel;

            LOG(WARNING) << __func__ << " duplicated channel " << it.channel;

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.h

+1 −1
Original line number Original line Diff line number Diff line
@@ -99,7 +99,7 @@ class DynamicsProcessingContext final : public EffectContext { 
    dp_fx::DPEq* getEqWithType_l(StageType type, int ch);

    dp_fx::DPEq* getEqWithType_l(StageType type, int ch);

    template <typename D>

    template <typename D>

    RetCode setDpChannels_l(const std::vector<DynamicsProcessing::ChannelConfig>& channels,

    RetCode setDpChannels_l(const std::vector<DynamicsProcessing::ChannelConfig>& channels,

                            bool stageInUse, StageType type);

                            StageType type);

    template <typename T /* BandConfig */>

    template <typename T /* BandConfig */>

    RetCode setBands_l(const std::vector<T>& bands, StageType type);

    RetCode setBands_l(const std::vector<T>& bands, StageType type);

    RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type,

    RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type,