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

Commit 5137945a authored by Shunkai Yao's avatar Shunkai Yao
Browse files

Spatializer dumpsys: Add mode selector and pose rate limiter in dumpsys 

Bug: 233092747
Test: m and "adb shell dumpsys media.audio_policy"
Merged-In: I7ec026ed0e5005cd9f56f3a16d37cc547e1dcc99
Change-Id: I7ec026ed0e5005cd9f56f3a16d37cc547e1dcc99
(cherry picked from commit 56e43f09)
parent 42b9c416

media/libheadtracking/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -83,6 +83,7 @@ cc_test_host { 
        "Twist-test.cpp",

    ],

    shared_libs: [

        "libaudioutils",

        "libheadtracking",

    ],

}

media/libheadtracking/HeadTrackingProcessor.cpp

+30 −17
Original line number Diff line number Diff line
@@ -161,29 +161,30 @@ class HeadTrackingProcessorImpl : public HeadTrackingProcessor { 
    std::string toString_l(unsigned level) const override {

        std::string prefixSpace(level, ' ');

        std::string ss = prefixSpace + "HeadTrackingProcessor:\n";

        StringAppendF(&ss, "%smaxTranslationalVelocity: %f\n", prefixSpace.c_str(),

        StringAppendF(&ss, "%s maxTranslationalVelocity: %f meter/second\n", prefixSpace.c_str(),

                      mOptions.maxTranslationalVelocity);

        StringAppendF(&ss, "%smaxRotationalVelocity: %f\n", prefixSpace.c_str(),

        StringAppendF(&ss, "%s maxRotationalVelocity: %f rad/second\n", prefixSpace.c_str(),

                      mOptions.maxRotationalVelocity);

        StringAppendF(&ss, "%sfreshnessTimeout: %" PRId64 "\n", prefixSpace.c_str(),

                      mOptions.freshnessTimeout);

        StringAppendF(&ss, "%spredictionDuration: %f\n", prefixSpace.c_str(),

                      mOptions.predictionDuration);

        StringAppendF(&ss, "%sautoRecenterWindowDuration: %" PRId64 "\n", prefixSpace.c_str(),

                      mOptions.autoRecenterWindowDuration);

        StringAppendF(&ss, "%sautoRecenterTranslationalThreshold: %f\n", prefixSpace.c_str(),

        StringAppendF(&ss, "%s freshnessTimeout: %0.4f ms\n", prefixSpace.c_str(),

                      media::nsToFloatMs(mOptions.freshnessTimeout));

        StringAppendF(&ss, "%s predictionDuration: %0.4f ms\n", prefixSpace.c_str(),

                      media::nsToFloatMs(mOptions.predictionDuration));

        StringAppendF(&ss, "%s autoRecenterWindowDuration: %0.4f ms\n", prefixSpace.c_str(),

                      media::nsToFloatMs(mOptions.autoRecenterWindowDuration));

        StringAppendF(&ss, "%s autoRecenterTranslationalThreshold: %f meter\n", prefixSpace.c_str(),

                      mOptions.autoRecenterTranslationalThreshold);

        StringAppendF(&ss, "%sautoRecenterRotationalThreshold: %f\n", prefixSpace.c_str(),

        StringAppendF(&ss, "%s autoRecenterRotationalThreshold: %f radians\n", prefixSpace.c_str(),

                      mOptions.autoRecenterRotationalThreshold);

        StringAppendF(&ss, "%sscreenStillnessWindowDuration: %" PRId64 "\n", prefixSpace.c_str(),

                      mOptions.screenStillnessWindowDuration);

        StringAppendF(&ss, "%sscreenStillnessTranslationalThreshold: %f\n", prefixSpace.c_str(),

                      mOptions.screenStillnessTranslationalThreshold);

        StringAppendF(&ss, "%sscreenStillnessRotationalThreshold: %f\n", prefixSpace.c_str(),

                      mOptions.screenStillnessRotationalThreshold);

        StringAppendF(&ss, "%s screenStillnessWindowDuration: %0.4f ms\n", prefixSpace.c_str(),

                      media::nsToFloatMs(mOptions.screenStillnessWindowDuration));

        StringAppendF(&ss, "%s screenStillnessTranslationalThreshold: %f meter\n",

                      prefixSpace.c_str(), mOptions.screenStillnessTranslationalThreshold);

        StringAppendF(&ss, "%s screenStillnessRotationalThreshold: %f radians\n",

                      prefixSpace.c_str(), mOptions.screenStillnessRotationalThreshold);

        ss += mModeSelector.toString(level + 1);

        ss += mRateLimiter.toString(level + 1);

        ss.append(prefixSpace + "ReCenterHistory:\n");

        ss += mLocalLog.dumpToString((prefixSpace + " ").c_str(), mMaxLocalLogLine);

        // TODO: 233092747 add string from PoseRateLimiter/PoseRateLimiter etc...

        return ss;

    }
@@ -214,5 +215,17 @@ std::unique_ptr<HeadTrackingProcessor> createHeadTrackingProcessor( 
    return std::make_unique<HeadTrackingProcessorImpl>(options, initialMode);

}



std::string toString(HeadTrackingMode mode) {

    switch (mode) {

        case HeadTrackingMode::STATIC:

            return "STATIC";

        case HeadTrackingMode::WORLD_RELATIVE:

            return "WORLD_RELATIVE";

        case HeadTrackingMode::SCREEN_RELATIVE:

            return "SCREEN_RELATIVE";

    }

    return "EnumNotImplemented";

};



}  // namespace media

}  // namespace android

media/libheadtracking/ModeSelector.cpp

+32 −7
Original line number Diff line number Diff line
@@ -13,11 +13,13 @@ 
 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <android-base/stringprintf.h>



#include "ModeSelector.h"



namespace android {

namespace media {

using android::base::StringAppendF;



ModeSelector::ModeSelector(const Options& options, HeadTrackingMode initialMode)

    : mOptions(options), mDesiredMode(initialMode), mActualMode(initialMode) {}
@@ -47,12 +49,15 @@ void ModeSelector::setScreenStable(int64_t timestamp, bool stable) { 
}



void ModeSelector::calculateActualMode(int64_t timestamp) {

    bool isValidScreenToHead = mScreenToHead.has_value() &&

                               timestamp - mScreenToHeadTimestamp < mOptions.freshnessTimeout;

    bool isValidWorldToHead = mWorldToHead.has_value() &&

                              timestamp - mWorldToHeadTimestamp < mOptions.freshnessTimeout;

    bool isValidScreenStable = mScreenStable.has_value() &&

                              timestamp - mScreenStableTimestamp < mOptions.freshnessTimeout;

    int64_t screenToHeadGap = timestamp - mScreenToHeadTimestamp;

    int64_t worldToHeadGap = timestamp - mWorldToHeadTimestamp;

    int64_t screenStableGap = timestamp - mScreenStableTimestamp;

    bool isValidScreenToHead =

            mScreenToHead.has_value() && screenToHeadGap < mOptions.freshnessTimeout;

    bool isValidWorldToHead =

            mWorldToHead.has_value() && worldToHeadGap < mOptions.freshnessTimeout;

    bool isValidScreenStable =

            mScreenStable.has_value() && screenStableGap < mOptions.freshnessTimeout;



    HeadTrackingMode mode = mDesiredMode;
@@ -70,8 +75,18 @@ void ModeSelector::calculateActualMode(int64_t timestamp) { 
        }

    }



    if (mode != mActualMode) {

        mLocalLog.log(

                "HT mode change from %s to %s, this ts %0.4f ms, lastTs+gap [ScreenToHead %0.4f + "

                "%0.4f, WorldToHead %0.4f + %0.4f, ScreenStable %0.4f + %0.4f] ms",

                media::toString(mActualMode).c_str(), media::toString(mode).c_str(),

                media::nsToFloatMs(timestamp), media::nsToFloatMs(mScreenToHeadTimestamp),

                media::nsToFloatMs(screenToHeadGap), media::nsToFloatMs(mWorldToHeadTimestamp),

                media::nsToFloatMs(worldToHeadGap), media::nsToFloatMs(mScreenStableTimestamp),

                media::nsToFloatMs(screenStableGap));

        mActualMode = mode;

    }

}



void ModeSelector::calculate(int64_t timestamp) {

    calculateActualMode(timestamp);
@@ -99,5 +114,15 @@ HeadTrackingMode ModeSelector::getActualMode() const { 
    return mActualMode;

}



std::string ModeSelector::toString(unsigned level) const {

    std::string prefixSpace(level, ' ');

    std::string ss(prefixSpace);

    StringAppendF(&ss, "ModeSelector: ScreenToStage %s\n",

                    mScreenToStage.toString().c_str());

    ss.append(prefixSpace + "Mode downgrade history:\n");

    ss += mLocalLog.dumpToString((prefixSpace + " ").c_str(), sMaxLocalLogLine);

    return ss;

}



}  // namespace media

}  // namespace android

media/libheadtracking/ModeSelector.h

+6 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#pragma once



#include <optional>

#include <audio_utils/SimpleLog.h>



#include "media/HeadTrackingMode.h"

#include "media/Pose.h"
@@ -114,6 +115,8 @@ class ModeSelector { 
     */

    HeadTrackingMode getActualMode() const;



    std::string toString(unsigned level) const;



  private:

    const Options mOptions;
@@ -129,6 +132,9 @@ class ModeSelector { 
    HeadTrackingMode mActualMode;

    Pose3f mHeadToStage;



    static constexpr std::size_t sMaxLocalLogLine = 10;

    SimpleLog mLocalLog{sMaxLocalLogLine};



    void calculateActualMode(int64_t timestamp);

};

media/libheadtracking/Pose.cpp

+15 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <android-base/stringprintf.h>



#include "media/Pose.h"

#include "media/Twist.h"
@@ -21,6 +22,7 @@ 
namespace android {

namespace media {



using android::base::StringAppendF;

using Eigen::Vector3f;



std::optional<Pose3f> Pose3f::fromVector(const std::vector<float>& vec) {
@@ -35,6 +37,19 @@ std::vector<float> Pose3f::toVector() const { 
    return {mTranslation[0], mTranslation[1], mTranslation[2], rot[0], rot[1], rot[2]};

}



std::string Pose3f::toString() const {

    const auto& vec = this->toVector();

    std::string ss = "[";

    for (auto f = vec.begin(); f != vec.end(); ++f) {

        if (f != vec.begin()) {

            ss.append(", ");

        }

        StringAppendF(&ss, "%0.2f", *f);

    }

    ss.append("]");

    return ss;

}



std::tuple<Pose3f, bool> moveWithRateLimit(const Pose3f& from, const Pose3f& to, float t,

                                           float maxTranslationalVelocity,

                                           float maxRotationalVelocity) {