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

Commit 4847de1a authored by Vlad Popa's avatar Vlad Popa
Browse files

CSD: rename get/setOutputRs2 to include upper bound 

RS2 represents an interval of power levels. This is why it is clearer to
specify upper bound in the naming to make it clear that we refer to the
upper limit which when exceeded will trigger a momentary exposure.

Test: atest sounddosemanager_tests
Bug: 273961110
Change-Id: I4e155f2a8cdb23f85623c471364ba1e5d245386b
parent cb658d7a

media/libaudioclient/aidl/android/media/ISoundDose.aidl

+4 −4
Original line number Diff line number Diff line
@@ -23,8 +23,8 @@ import android.media.SoundDoseRecord; 
 * AudioService#SoundDoseHelper to the audio server

 */

interface ISoundDose {

    /** Set a new RS2 value used for momentary exposure warnings. */

    oneway void setOutputRs2(float rs2Value);

    /** Set a new RS2 upper bound used for momentary exposure warnings. */

    oneway void setOutputRs2UpperBound(float rs2Value);



    /**

     * Resets the native CSD values. This can happen after a crash in the
@@ -49,8 +49,8 @@ interface ISoundDose { 
    oneway void updateAttenuation(float attenuationDB, int device);



    /* -------------------------- Test API methods --------------------------

    /** Get the currently used RS2 value. */

    float getOutputRs2();

    /** Get the currently used RS2 upper bound. */

    float getOutputRs2UpperBound();

    /** Get the current CSD from audioserver. */

    float getCsd();

    /** Enables/Disables MEL computations from framework. */

services/audioflinger/sounddose/SoundDoseManager.cpp

+15 −15
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
#include <android-base/stringprintf.h>

#include <media/AidlConversionCppNdk.h>

#include <cinttypes>

#include <time.h>

#include <ctime>

#include <utils/Log.h>



namespace android {
@@ -65,12 +65,12 @@ sp<audio_utils::MelProcessor> SoundDoseManager::getOrCreateProcessorForDevice( 
            processor->setAttenuation(mMelAttenuationDB[activeTypeIt->second]);

        }

        processor->setDeviceId(deviceId);

        processor->setOutputRs2(mRs2Value);

        processor->setOutputRs2UpperBound(mRs2UpperBound);

        return processor;

    } else {

        ALOGV("%s: creating new callback for stream id %d", __func__, streamHandle);

        sp<audio_utils::MelProcessor> melProcessor = sp<audio_utils::MelProcessor>::make(

                sampleRate, channelCount, format, this, deviceId, mRs2Value);

                sampleRate, channelCount, format, this, deviceId, mRs2UpperBound);

        const auto activeTypeIt = mActiveDeviceTypes.find(deviceId);

        if (activeTypeIt != mActiveDeviceTypes.end()) {

            melProcessor->setAttenuation(mMelAttenuationDB[activeTypeIt->second]);
@@ -92,10 +92,10 @@ bool SoundDoseManager::setHalSoundDoseInterface(const std::shared_ptr<ISoundDose 
            return false;

        }



        if (!mHalSoundDose->setOutputRs2(mRs2Value).isOk()) {

        if (!mHalSoundDose->setOutputRs2UpperBound(mRs2UpperBound).isOk()) {

            ALOGW("%s: Cannot set RS2 value for momentary exposure %f",

                  __func__,

                  mRs2Value);

                  mRs2UpperBound);

        }



        // initialize the HAL sound dose callback lazily
@@ -116,30 +116,30 @@ bool SoundDoseManager::setHalSoundDoseInterface(const std::shared_ptr<ISoundDose 
    return true;

}



void SoundDoseManager::setOutputRs2(float rs2Value) {

void SoundDoseManager::setOutputRs2UpperBound(float rs2Value) {

    ALOGV("%s", __func__);

    std::lock_guard _l(mLock);



    if (mHalSoundDose != nullptr) {

        // using the HAL sound dose interface

        if (!mHalSoundDose->setOutputRs2(rs2Value).isOk()) {

        if (!mHalSoundDose->setOutputRs2UpperBound(rs2Value).isOk()) {

            ALOGE("%s: Cannot set RS2 value for momentary exposure %f", __func__, rs2Value);

            return;

        }

        mRs2Value = rs2Value;

        mRs2UpperBound = rs2Value;

        return;

    }



    for (auto& streamProcessor : mActiveProcessors) {

        sp<audio_utils::MelProcessor> processor = streamProcessor.second.promote();

        if (processor != nullptr) {

            status_t result = processor->setOutputRs2(rs2Value);

            status_t result = processor->setOutputRs2UpperBound(rs2Value);

            if (result != NO_ERROR) {

                ALOGW("%s: could not set RS2 value %f for stream %d", __func__, rs2Value,

                ALOGW("%s: could not set RS2 upper bound %f for stream %d", __func__, rs2Value,

                      streamProcessor.first);

                return;

            }

            mRs2Value = rs2Value;

            mRs2UpperBound = rs2Value;

        }

    }

}
@@ -259,11 +259,11 @@ void SoundDoseManager::SoundDose::binderDied(__unused const wp<IBinder>& who) { 
    }

}



binder::Status SoundDoseManager::SoundDose::setOutputRs2(float value) {

binder::Status SoundDoseManager::SoundDose::setOutputRs2UpperBound(float value) {

    ALOGV("%s", __func__);

    auto soundDoseManager = mSoundDoseManager.promote();

    if (soundDoseManager != nullptr) {

        soundDoseManager->setOutputRs2(value);

        soundDoseManager->setOutputRs2UpperBound(value);

    }

    return binder::Status::ok();

}
@@ -287,12 +287,12 @@ binder::Status SoundDoseManager::SoundDose::updateAttenuation(float attenuationD 
    return binder::Status::ok();

}



binder::Status SoundDoseManager::SoundDose::getOutputRs2(float* value) {

binder::Status SoundDoseManager::SoundDose::getOutputRs2UpperBound(float* value) {

    ALOGV("%s", __func__);

    auto soundDoseManager = mSoundDoseManager.promote();

    if (soundDoseManager != nullptr) {

        std::lock_guard _l(soundDoseManager->mLock);

        *value = soundDoseManager->mRs2Value;

        *value = soundDoseManager->mRs2UpperBound;

    }

    return binder::Status::ok();

}

services/audioflinger/sounddose/SoundDoseManager.h

+8 −8
Original line number Diff line number Diff line
@@ -36,12 +36,12 @@ class SoundDoseManager : public audio_utils::MelProcessor::MelCallback { 
public:

    /** CSD is computed with a rolling window of 7 days. */

    static constexpr int64_t kCsdWindowSeconds = 604800;  // 60s * 60m * 24h * 7d

    /** Default RS2 value in dBA as defined in IEC 62368-1 3rd edition. */

    static constexpr float kDefaultRs2Value = 100.f;

    /** Default RS2 upper bound in dBA as defined in IEC 62368-1 3rd edition. */

    static constexpr float kDefaultRs2UpperBound = 100.f;



    SoundDoseManager()

        : mMelAggregator(sp<audio_utils::MelAggregator>::make(kCsdWindowSeconds)),

          mRs2Value(kDefaultRs2Value) {};

          mRs2UpperBound(kDefaultRs2UpperBound) {};



    /**

     * \brief Creates or gets the MelProcessor assigned to the streamHandle
@@ -68,12 +68,12 @@ public: 
    void removeStreamProcessor(audio_io_handle_t streamHandle);



    /**

     * Sets the output RS2 value for momentary exposure warnings. Must not be

     * Sets the output RS2 upper bound for momentary exposure warnings. Must not be

     * higher than 100dBA and not lower than 80dBA.

     *

     * \param rs2Value value to use for momentary exposure

     */

    void setOutputRs2(float rs2Value);

    void setOutputRs2UpperBound(float rs2Value);



    /**

     * \brief Registers the interface for passing callbacks to the AudioService and gets
@@ -129,11 +129,11 @@ private: 
        virtual void binderDied(const wp<IBinder>& who);



        /** BnSoundDose override */

        binder::Status setOutputRs2(float value) override;

        binder::Status setOutputRs2UpperBound(float value) override;

        binder::Status resetCsd(float currentCsd,

                                const std::vector<media::SoundDoseRecord>& records) override;

        binder::Status updateAttenuation(float attenuationDB, int device) override;

        binder::Status getOutputRs2(float* value) override;

        binder::Status getOutputRs2UpperBound(float* value) override;

        binder::Status getCsd(float* value) override;

        binder::Status forceUseFrameworkMel(bool useFrameworkMel) override;

        binder::Status forceComputeCsdOnAllDevices(bool computeCsdOnAllDevices) override;
@@ -183,7 +183,7 @@ private: 
    std::map<AudioDeviceTypeAddr, audio_port_handle_t> mActiveDevices GUARDED_BY(mLock);

    std::unordered_map<audio_port_handle_t, audio_devices_t> mActiveDeviceTypes GUARDED_BY(mLock);



    float mRs2Value GUARDED_BY(mLock);

    float mRs2UpperBound GUARDED_BY(mLock);

    std::unordered_map<audio_devices_t, float> mMelAttenuationDB GUARDED_BY(mLock);



    sp<SoundDose> mSoundDose GUARDED_BY(mLock);

services/audioflinger/sounddose/tests/sounddosemanager_tests.cpp

+8 −8
Original line number Diff line number Diff line
@@ -33,8 +33,8 @@ using aidl::android::media::audio::common::AudioDeviceAddress; 


class HalSoundDoseMock : public BnSoundDose {

public:

    MOCK_METHOD(ndk::ScopedAStatus, getOutputRs2, (float*), (override));

    MOCK_METHOD(ndk::ScopedAStatus, setOutputRs2, (float), (override));

    MOCK_METHOD(ndk::ScopedAStatus, getOutputRs2UpperBound, (float*), (override));

    MOCK_METHOD(ndk::ScopedAStatus, setOutputRs2UpperBound, (float), (override));

    MOCK_METHOD(ndk::ScopedAStatus, registerSoundDoseCallback,

                (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>&), (override));

};
@@ -45,7 +45,7 @@ protected: 
        mSoundDoseManager = sp<SoundDoseManager>::make();

        mHalSoundDose = ndk::SharedRefBase::make<HalSoundDoseMock>();



        ON_CALL(*mHalSoundDose.get(), setOutputRs2)

        ON_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound)

            .WillByDefault([] (float rs2) {

                EXPECT_EQ(rs2, ISoundDose::DEFAULT_MAX_RS2);

                return ndk::ScopedAStatus::ok();
@@ -105,7 +105,7 @@ TEST_F(SoundDoseManagerTest, InvalidHalInterfaceIsNotSet) { 
}



TEST_F(SoundDoseManagerTest, SetHalSoundDoseDisablesNewMelProcessorCallbacks) {

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), registerSoundDoseCallback)

        .Times(1)

        .WillOnce([&] (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>& callback) {
@@ -123,7 +123,7 @@ TEST_F(SoundDoseManagerTest, SetHalSoundDoseDisablesNewMelProcessorCallbacks) { 
}



TEST_F(SoundDoseManagerTest, SetHalSoundDoseRegistersHalCallbacks) {

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), registerSoundDoseCallback)

        .Times(1)

        .WillOnce([&] (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>& callback) {
@@ -137,7 +137,7 @@ TEST_F(SoundDoseManagerTest, SetHalSoundDoseRegistersHalCallbacks) { 
TEST_F(SoundDoseManagerTest, MomentaryExposureFromHalWithNoAddressIllegalArgument) {

    std::shared_ptr<ISoundDose::IHalSoundDoseCallback> halCallback;



    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), registerSoundDoseCallback)

       .Times(1)

       .WillOnce([&] (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>& callback) {
@@ -158,7 +158,7 @@ TEST_F(SoundDoseManagerTest, MomentaryExposureFromHalWithNoAddressIllegalArgumen 
TEST_F(SoundDoseManagerTest, MomentaryExposureFromHalAfterInternalSelectedReturnsException) {

    std::shared_ptr<ISoundDose::IHalSoundDoseCallback> halCallback;



    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), registerSoundDoseCallback)

       .Times(1)

       .WillOnce([&] (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>& callback) {
@@ -180,7 +180,7 @@ TEST_F(SoundDoseManagerTest, MomentaryExposureFromHalAfterInternalSelectedReturn 
TEST_F(SoundDoseManagerTest, OnNewMelValuesFromHalWithNoAddressIllegalArgument) {

    std::shared_ptr<ISoundDose::IHalSoundDoseCallback> halCallback;



    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), setOutputRs2UpperBound).Times(1);

    EXPECT_CALL(*mHalSoundDose.get(), registerSoundDoseCallback)

       .Times(1)

       .WillOnce([&] (const std::shared_ptr<ISoundDose::IHalSoundDoseCallback>& callback) {