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

Commit 1e2bd24f authored by Andy Hung's avatar Andy Hung Committed by Gerrit Code Review
Browse files

Merge changes I6e372603,I3c8fee7c

* changes:
  Spatializer: Workaround for Head Tracking on BT AAC
  Spatializer: recenter head pose when head tracking is disabled
parents e8478652 c0896c7d
Loading
Loading
Loading
Loading
+43 −17
Original line number Original line Diff line number Diff line
@@ -741,6 +741,17 @@ void Spatializer::onHeadToStagePose(const Pose3f& headToStage) {
    msg->post();
    msg->post();
}
}


void Spatializer::resetEngineHeadPose_l() {
    ALOGV("%s mEngine %p", __func__, mEngine.get());
    if (mEngine == nullptr) {
        return;
    }
    const std::vector<float> headToStage(6, 0.0);
    setEffectParameter_l(SPATIALIZER_PARAM_HEAD_TO_STAGE, headToStage);
    setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
            std::vector<SpatializerHeadTrackingMode>{SpatializerHeadTrackingMode::DISABLED});
}

void Spatializer::onHeadToStagePoseMsg(const std::vector<float>& headToStage) {
void Spatializer::onHeadToStagePoseMsg(const std::vector<float>& headToStage) {
    ALOGV("%s", __func__);
    ALOGV("%s", __func__);
    sp<media::ISpatializerHeadTrackingCallback> callback;
    sp<media::ISpatializerHeadTrackingCallback> callback;
@@ -792,9 +803,13 @@ void Spatializer::onActualModeChangeMsg(HeadTrackingMode mode) {
        }
        }
        mActualHeadTrackingMode = spatializerMode;
        mActualHeadTrackingMode = spatializerMode;
        if (mEngine != nullptr) {
        if (mEngine != nullptr) {
            if (spatializerMode == SpatializerHeadTrackingMode::DISABLED) {
                resetEngineHeadPose_l();
            } else {
                setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
                setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
                                     std::vector<SpatializerHeadTrackingMode>{spatializerMode});
                                     std::vector<SpatializerHeadTrackingMode>{spatializerMode});
            }
            }
        }
        callback = mHeadTrackingCallback;
        callback = mHeadTrackingCallback;
        mLocalLog.log("%s: %s, spatializerMode %s", __func__, media::toString(mode).c_str(),
        mLocalLog.log("%s: %s, spatializerMode %s", __func__, media::toString(mode).c_str(),
                      media::toString(spatializerMode).c_str());
                      media::toString(spatializerMode).c_str());
@@ -920,22 +935,34 @@ void Spatializer::updateActiveTracks(size_t numActiveTracks) {


void Spatializer::checkSensorsState_l() {
void Spatializer::checkSensorsState_l() {
    audio_latency_mode_t requestedLatencyMode = AUDIO_LATENCY_MODE_FREE;
    audio_latency_mode_t requestedLatencyMode = AUDIO_LATENCY_MODE_FREE;
    bool lowLatencySupported = mSupportedLatencyModes.empty()
    const bool supportsSetLatencyMode = !mSupportedLatencyModes.empty();
            || (std::find(mSupportedLatencyModes.begin(), mSupportedLatencyModes.end(),
    const bool supportsLowLatencyMode = supportsSetLatencyMode && std::find(
                    AUDIO_LATENCY_MODE_LOW) != mSupportedLatencyModes.end());
            mSupportedLatencyModes.begin(), mSupportedLatencyModes.end(),
    if (mSupportsHeadTracking && mPoseController != nullptr) {
            AUDIO_LATENCY_MODE_LOW) != mSupportedLatencyModes.end();
        if (lowLatencySupported && mNumActiveTracks > 0 && mLevel != SpatializationLevel::NONE
    if (mSupportsHeadTracking) {
        if (mPoseController != nullptr) {
            // TODO(b/253297301, b/255433067) reenable low latency condition check
            // for Head Tracking after Bluetooth HAL supports it correctly.
            if (mNumActiveTracks > 0 && mLevel != SpatializationLevel::NONE
                && mDesiredHeadTrackingMode != HeadTrackingMode::STATIC
                && mDesiredHeadTrackingMode != HeadTrackingMode::STATIC
                && mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {
                && mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {
                if (mEngine != nullptr) {
                    setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
                            std::vector<SpatializerHeadTrackingMode>{mActualHeadTrackingMode});
                }
                mPoseController->setHeadSensor(mHeadSensor);
                mPoseController->setHeadSensor(mHeadSensor);
                mPoseController->setScreenSensor(mScreenSensor);
                mPoseController->setScreenSensor(mScreenSensor);
            requestedLatencyMode = AUDIO_LATENCY_MODE_LOW;
                if (supportsLowLatencyMode) 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);
                resetEngineHeadPose_l();
            }
            }
        } else {
            resetEngineHeadPose_l();
        }
        }
    if (mOutput != AUDIO_IO_HANDLE_NONE) {
    }
    if (mOutput != AUDIO_IO_HANDLE_NONE && supportsSetLatencyMode) {
        AudioSystem::setRequestedLatencyMode(mOutput, requestedLatencyMode);
        AudioSystem::setRequestedLatencyMode(mOutput, requestedLatencyMode);
    }
    }
}
}
@@ -946,8 +973,6 @@ void Spatializer::checkEngineState_l() {
            mEngine->setEnabled(true);
            mEngine->setEnabled(true);
            setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
            setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
                    std::vector<SpatializationLevel>{mLevel});
                    std::vector<SpatializationLevel>{mLevel});
            setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
                    std::vector<SpatializerHeadTrackingMode>{mActualHeadTrackingMode});
        } else {
        } else {
            setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
            setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
                    std::vector<SpatializationLevel>{SpatializationLevel::NONE});
                    std::vector<SpatializationLevel>{SpatializationLevel::NONE});
@@ -969,6 +994,7 @@ void Spatializer::checkPoseController_l() {
        mPoseController->setDisplayOrientation(mDisplayOrientation);
        mPoseController->setDisplayOrientation(mDisplayOrientation);
    } else if (!isControllerNeeded && mPoseController != nullptr) {
    } else if (!isControllerNeeded && mPoseController != nullptr) {
        mPoseController.reset();
        mPoseController.reset();
        resetEngineHeadPose_l();
    }
    }
    if (mPoseController != nullptr) {
    if (mPoseController != nullptr) {
        mPoseController->setDesiredMode(mDesiredHeadTrackingMode);
        mPoseController->setDesiredMode(mDesiredHeadTrackingMode);
+6 −0
Original line number Original line Diff line number Diff line
@@ -350,6 +350,12 @@ private:
     */
     */
    void checkEngineState_l() REQUIRES(mLock);
    void checkEngineState_l() REQUIRES(mLock);


    /**
     * Reset head tracking mode and recenter pose in engine: Called when the head tracking
     * is disabled.
     */
    void resetEngineHeadPose_l() REQUIRES(mLock);

    /** Effect engine descriptor */
    /** Effect engine descriptor */
    const effect_descriptor_t mEngineDescriptor;
    const effect_descriptor_t mEngineDescriptor;
    /** Callback interface to parent audio policy service */
    /** Callback interface to parent audio policy service */