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

Commit ee398adb authored by Eric Laurent's avatar Eric Laurent
Browse files

Spatializer: control audio HAL latency mode 

Add support of HAL stream latency mode control to Spatializer
effect controller.
- Query supported latency modes when attached to a new output stream
and register a callback to be notified of changes
- Only use a head tracker sensor if the HAL stream supports low
  latency or does not support latency mode control.
- Set the requested latency mode according to head tracking state.

Bug: 218273231
Test: make
Change-Id: Ia78156d1e190bb49a67988567df066c1ab90f9bd
parent 68a40a84

services/audiopolicy/service/Spatializer.cpp

+28 −1
Original line number Original line Diff line number Diff line
@@ -714,7 +714,9 @@ status_t Spatializer::attachOutput(audio_io_handle_t output, size_t numActiveTra 
            mEngine->setEnabled(false);

            mEngine->setEnabled(false);

            mEngine.clear();

            mEngine.clear();

            mPoseController.reset();

            mPoseController.reset();

            AudioSystem::removeSupportedLatencyModesCallback(this);

        }

        }



        // create FX instance on output

        // create FX instance on output

        AttributionSourceState attributionSource = AttributionSourceState();

        AttributionSourceState attributionSource = AttributionSourceState();

        mEngine = new AudioEffect(attributionSource);

        mEngine = new AudioEffect(attributionSource);
@@ -730,6 +732,13 @@ status_t Spatializer::attachOutput(audio_io_handle_t output, size_t numActiveTra 
        outputChanged = mOutput != output;

        outputChanged = mOutput != output;

        mOutput = output;

        mOutput = output;

        mNumActiveTracks = numActiveTracks;

        mNumActiveTracks = numActiveTracks;

        AudioSystem::addSupportedLatencyModesCallback(this);



        std::vector<audio_latency_mode_t> latencyModes;

        status = AudioSystem::getSupportedLatencyModes(mOutput, &latencyModes);

        if (status == OK) {

            mSupportedLatencyModes = latencyModes;

        }





        checkEngineState_l();

        checkEngineState_l();

        if (mSupportsHeadTracking) {

        if (mSupportsHeadTracking) {
@@ -759,6 +768,7 @@ audio_io_handle_t Spatializer::detachOutput() { 
        // remove FX instance

        // remove FX instance

        mEngine->setEnabled(false);

        mEngine->setEnabled(false);

        mEngine.clear();

        mEngine.clear();

        AudioSystem::removeSupportedLatencyModesCallback(this);

        output = mOutput;

        output = mOutput;

        mOutput = AUDIO_IO_HANDLE_NONE;

        mOutput = AUDIO_IO_HANDLE_NONE;

        mPoseController.reset();

        mPoseController.reset();
@@ -771,6 +781,15 @@ audio_io_handle_t Spatializer::detachOutput() { 
    return output;

    return output;

}

}





void Spatializer::onSupportedLatencyModesChanged(

        audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) {

    std::lock_guard lock(mLock);

    if (output == mOutput) {

        mSupportedLatencyModes = modes;

        checkSensorsState_l();

    }

}



void Spatializer::updateActiveTracks(size_t numActiveTracks) {

void Spatializer::updateActiveTracks(size_t numActiveTracks) {

    std::lock_guard lock(mLock);

    std::lock_guard lock(mLock);

    if (mNumActiveTracks != numActiveTracks) {

    if (mNumActiveTracks != numActiveTracks) {
@@ -781,17 +800,25 @@ void Spatializer::updateActiveTracks(size_t numActiveTracks) { 
}

}





void Spatializer::checkSensorsState_l() {

void Spatializer::checkSensorsState_l() {

    if (mSupportsHeadTracking && mPoseController != nullptr) {

    audio_latency_mode_t requestedLatencyMode = AUDIO_LATENCY_MODE_FREE;

    bool lowLatencySupported = mSupportedLatencyModes.empty()

            || (std::find(mSupportedLatencyModes.begin(), mSupportedLatencyModes.end(),

                    AUDIO_LATENCY_MODE_LOW) != mSupportedLatencyModes.end());

    if (mSupportsHeadTracking && mPoseController != nullptr && lowLatencySupported) {

        if (mNumActiveTracks > 0 && mLevel != SpatializationLevel::NONE

        if (mNumActiveTracks > 0 && mLevel != SpatializationLevel::NONE

            && mDesiredHeadTrackingMode != HeadTrackingMode::STATIC

            && mDesiredHeadTrackingMode != HeadTrackingMode::STATIC

            && mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {

            && mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {

            mPoseController->setHeadSensor(mHeadSensor);

            mPoseController->setHeadSensor(mHeadSensor);

            mPoseController->setScreenSensor(mScreenSensor);

            mPoseController->setScreenSensor(mScreenSensor);

            requestedLatencyMode = AUDIO_LATENCY_MODE_LOW;

        } else {

        } else {

            mPoseController->setHeadSensor(SpatializerPoseController::INVALID_SENSOR);

            mPoseController->setHeadSensor(SpatializerPoseController::INVALID_SENSOR);

            mPoseController->setScreenSensor(SpatializerPoseController::INVALID_SENSOR);

            mPoseController->setScreenSensor(SpatializerPoseController::INVALID_SENSOR);

        }

        }

    }

    }

    if (mOutput != AUDIO_IO_HANDLE_NONE) {

        AudioSystem::setRequestedLatencyMode(mOutput, requestedLatencyMode);

    }

}

}





void Spatializer::checkEngineState_l() {

void Spatializer::checkEngineState_l() {

services/audiopolicy/service/Spatializer.h

+7 −1
Original line number Original line Diff line number Diff line
@@ -85,7 +85,8 @@ public: 
 */

 */

class Spatializer : public media::BnSpatializer,

class Spatializer : public media::BnSpatializer,

                    public IBinder::DeathRecipient,

                    public IBinder::DeathRecipient,

                    private SpatializerPoseController::Listener {

                    private SpatializerPoseController::Listener,

                    public virtual AudioSystem::SupportedLatencyModesCallback {

  public:

  public:

    static sp<Spatializer> create(SpatializerPolicyCallback *callback);

    static sp<Spatializer> create(SpatializerPolicyCallback *callback);
@@ -122,6 +123,10 @@ class Spatializer : public media::BnSpatializer, 
    /** IBinder::DeathRecipient. Listen to the death of the INativeSpatializerCallback. */

    /** IBinder::DeathRecipient. Listen to the death of the INativeSpatializerCallback. */

    virtual void binderDied(const wp<IBinder>& who);

    virtual void binderDied(const wp<IBinder>& who);





    /** SupportedLatencyModesCallback */

    void onSupportedLatencyModesChanged(

            audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) override;



    /** Registers a INativeSpatializerCallback when a client is attached to this Spatializer

    /** Registers a INativeSpatializerCallback when a client is attached to this Spatializer

     * by audio policy service.

     * by audio policy service.

     */

     */
@@ -354,6 +359,7 @@ private: 
    sp<EngineCallbackHandler> mHandler;

    sp<EngineCallbackHandler> mHandler;





    size_t mNumActiveTracks GUARDED_BY(mLock) = 0;

    size_t mNumActiveTracks GUARDED_BY(mLock) = 0;

    std::vector<audio_latency_mode_t> mSupportedLatencyModes GUARDED_BY(mLock);





    static const std::vector<const char *> sHeadPoseKeys;

    static const std::vector<const char *> sHeadPoseKeys;

};

};