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

Commit b16eac59 authored by Eric Laurent's avatar Eric Laurent Committed by Andy Hung
Browse files

Spatializer: Disable head tracking for stereo spatialization 

Do not enable head tracking if all the spatialized tracks are stereo.

Flag: EXEMPT bugfix
Test: manual spatial audio tests
Test: atest spatializer_tests
Bug: 356953811
Change-Id: I75e2cb63ee4c5c5bfba628802198d056fd30e216
parent 6acaf12b

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+3 −2
Original line number Diff line number Diff line
@@ -6358,10 +6358,11 @@ bool AudioPolicyManager::canBeSpatializedInt(const audio_attributes_t *attr, 
    // mode is not requested.



    if (config != nullptr && *config != AUDIO_CONFIG_INITIALIZER) {

        static const bool stereo_spatialization_enabled =

        static const bool stereo_spatialization_prop_enabled =

                property_get_bool("ro.audio.stereo_spatialization_enabled", false);

        const bool channel_mask_spatialized =

                (stereo_spatialization_enabled && com_android_media_audio_stereo_spatialization())

                (stereo_spatialization_prop_enabled

                        && com_android_media_audio_stereo_spatialization())

                ? audio_channel_mask_contains_stereo(config->channel_mask)

                : audio_is_channel_mask_spatialized(config->channel_mask);

        if (!channel_mask_spatialized) {

services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp

+1 −1
Original line number Diff line number Diff line
@@ -477,7 +477,7 @@ Status AudioPolicyService::getOutputForAttr(const media::audio::common::AudioAtt 


        sp<AudioPlaybackClient> client =

                new AudioPlaybackClient(attr, output, attributionSource, session,

                    portId, selectedDeviceId, stream, isSpatialized);

                    portId, selectedDeviceId, stream, isSpatialized, config.channel_mask);

        mAudioPlaybackClients.add(portId, client);



        _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(

services/audiopolicy/service/AudioPolicyService.cpp

+10 −9
Original line number Diff line number Diff line
@@ -590,12 +590,13 @@ void AudioPolicyService::doOnCheckSpatializer() 
            if (status == NO_ERROR && currentOutput == newOutput) {

                return;

            }

            size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);

            std::vector<audio_channel_mask_t> activeTracksMasks =

                    getActiveTracksMasks_l(newOutput);

            mMutex.unlock();

            // It is OK to call detachOutput() is none is already attached.

            mSpatializer->detachOutput();

            if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {

                status = mSpatializer->attachOutput(newOutput, numActiveTracks);

                status = mSpatializer->attachOutput(newOutput, activeTracksMasks);

            }

            mMutex.lock();

            if (status != NO_ERROR) {
@@ -613,17 +614,17 @@ void AudioPolicyService::doOnCheckSpatializer() 
    }

}



size_t AudioPolicyService::countActiveClientsOnOutput_l(

std::vector<audio_channel_mask_t> AudioPolicyService::getActiveTracksMasks_l(

        audio_io_handle_t output, bool spatializedOnly) {

    size_t count = 0;

    std::vector<audio_channel_mask_t> activeTrackMasks;

    for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {

        auto client = mAudioPlaybackClients.valueAt(i);

        if (client->io == output && client->active

                && (!spatializedOnly || client->isSpatialized)) {

            count++;

            activeTrackMasks.push_back(client->channelMask);

        }

    }

    return count;

    return activeTrackMasks;

}



void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
@@ -639,12 +640,12 @@ void AudioPolicyService::doOnUpdateActiveSpatializerTracks() 
        return;

    }

    audio_io_handle_t output = mSpatializer->getOutput();

    size_t activeClients;

    std::vector<audio_channel_mask_t> activeTracksMasks;

    {

        audio_utils::lock_guard _l(mMutex);

        activeClients = countActiveClientsOnOutput_l(output);

        activeTracksMasks = getActiveTracksMasks_l(output);

    }

    mSpatializer->updateActiveTracks(activeClients);

    mSpatializer->updateActiveTracks(activeTracksMasks);

}



status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,

services/audiopolicy/service/AudioPolicyService.h

+7 −5
Original line number Diff line number Diff line
@@ -976,13 +976,15 @@ private: 
                      const audio_io_handle_t io, AttributionSourceState attributionSource,

                            const audio_session_t session, audio_port_handle_t portId,

                            audio_port_handle_t deviceId, audio_stream_type_t stream,

                            bool isSpatialized) :

                            bool isSpatialized, audio_channel_mask_t channelMask) :

                    AudioClient(attributes, io, attributionSource, session, portId,

                        deviceId), stream(stream), isSpatialized(isSpatialized)  {}

                        deviceId), stream(stream), isSpatialized(isSpatialized),

                        channelMask(channelMask) {}

                ~AudioPlaybackClient() override = default;



        const audio_stream_type_t stream;

        const bool isSpatialized;

        const audio_channel_mask_t channelMask;

    };



    void getPlaybackClientAndEffects(audio_port_handle_t portId,
@@ -1013,14 +1015,14 @@ private: 
    void unloadAudioPolicyManager();



    /**

     * Returns the number of active audio tracks on the specified output mixer.

     * Returns the channel masks for active audio tracks on the specified output mixer.

     * The query can be specified to only include spatialized audio tracks or consider

     * all tracks.

     * @param output the I/O handle of the output mixer to consider

     * @param spatializedOnly true if only spatialized tracks should be considered

     * @return the number of active tracks.

     * @return a list of channel masks for all active tracks matching the condition.

     */

    size_t countActiveClientsOnOutput_l(

    std::vector<audio_channel_mask_t> getActiveTracksMasks_l(

            audio_io_handle_t output, bool spatializedOnly = true) REQUIRES(mMutex);



    mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioPolicyService_Mutex};

services/audiopolicy/service/Spatializer.cpp

+40 −12
Original line number Diff line number Diff line
@@ -936,7 +936,8 @@ void Spatializer::sortSupportedLatencyModes_l() { 
            });

}



status_t Spatializer::attachOutput(audio_io_handle_t output, size_t numActiveTracks) {

status_t Spatializer::attachOutput(audio_io_handle_t output,

          const std::vector<audio_channel_mask_t>& activeTracksMasks) {

    bool outputChanged = false;

    sp<media::INativeSpatializerCallback> callback;
@@ -944,7 +945,7 @@ status_t Spatializer::attachOutput(audio_io_handle_t output, size_t numActiveTra 
        audio_utils::lock_guard lock(mMutex);

        ALOGV("%s output %d mOutput %d", __func__, (int)output, (int)mOutput);

        mLocalLog.log("%s with output %d tracks %zu (mOutput %d)", __func__, (int)output,

                      numActiveTracks, (int)mOutput);

                      activeTracksMasks.size(), (int)mOutput);

        if (mOutput != AUDIO_IO_HANDLE_NONE) {

            LOG_ALWAYS_FATAL_IF(mEngine == nullptr, "%s output set without FX engine", __func__);

            // remove FX instance
@@ -969,7 +970,7 @@ status_t Spatializer::attachOutput(audio_io_handle_t output, size_t numActiveTra 


        outputChanged = mOutput != output;

        mOutput = output;

        mNumActiveTracks = numActiveTracks;

        mActiveTracksMasks = activeTracksMasks;

        AudioSystem::addSupportedLatencyModesCallback(this);



        std::vector<audio_latency_mode_t> latencyModes;
@@ -1008,7 +1009,8 @@ audio_io_handle_t Spatializer::detachOutput() { 


    {

        audio_utils::lock_guard lock(mMutex);

        mLocalLog.log("%s with output %d tracks %zu", __func__, (int)mOutput, mNumActiveTracks);

        mLocalLog.log("%s with output %d num tracks %zu",

            __func__, (int)mOutput, mActiveTracksMasks.size());

        ALOGV("%s mOutput %d", __func__, (int)mOutput);

        if (mOutput == AUDIO_IO_HANDLE_NONE) {

            return output;
@@ -1051,11 +1053,13 @@ void Spatializer::onSupportedLatencyModesChangedMsg( 
    }

}



void Spatializer::updateActiveTracks(size_t numActiveTracks) {

void Spatializer::updateActiveTracks(

        const std::vector<audio_channel_mask_t>& activeTracksMasks) {

    audio_utils::lock_guard lock(mMutex);

    if (mNumActiveTracks != numActiveTracks) {

        mLocalLog.log("%s from %zu to %zu", __func__, mNumActiveTracks, numActiveTracks);

        mNumActiveTracks = numActiveTracks;

    if (mActiveTracksMasks != activeTracksMasks) {

        mLocalLog.log("%s from %zu to %zu",

                __func__, mActiveTracksMasks.size(), activeTracksMasks.size());

        mActiveTracksMasks = activeTracksMasks;

        checkEngineState_l();

        checkSensorsState_l();

    }
@@ -1114,7 +1118,7 @@ void Spatializer::checkSensorsState_l() { 
        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 != Spatialization::Level::NONE

            if (shouldUseHeadTracking_l() && mLevel != Spatialization::Level::NONE

                    && mDesiredHeadTrackingMode != HeadTrackingMode::STATIC

                    && mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {

                if (supportsLowLatencyMode) {
@@ -1146,9 +1150,28 @@ void Spatializer::checkSensorsState_l() { 
    }

}





/* static */

bool Spatializer::containsImmersiveChannelMask(

        const std::vector<audio_channel_mask_t>& masks)

{

    for (auto mask : masks) {

        if (audio_is_channel_mask_spatialized(mask)) {

            return true;

        }

    }

    // Only non-immersive channel masks, e.g. AUDIO_CHANNEL_OUT_STEREO, are present.

    return false;

}



bool Spatializer::shouldUseHeadTracking_l() const {

    // Headtracking only available on immersive channel masks.

    return containsImmersiveChannelMask(mActiveTracksMasks);

}



void Spatializer::checkEngineState_l() {

    if (mEngine != nullptr) {

        if (mLevel != Spatialization::Level::NONE && mNumActiveTracks > 0) {

        if (mLevel != Spatialization::Level::NONE && mActiveTracksMasks.size() > 0) {

            mEngine->setEnabled(true);

            setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,

                    std::vector<Spatialization::Level>{mLevel});
@@ -1237,7 +1260,8 @@ std::string Spatializer::toString(unsigned level) const { 
    base::StringAppendF(&ss, "\n%smSupportsHeadTracking: %s\n", prefixSpace.c_str(),

                        mSupportsHeadTracking ? "true" : "false");

    // 2. Settings (Output, tracks)

    base::StringAppendF(&ss, "%smNumActiveTracks: %zu\n", prefixSpace.c_str(), mNumActiveTracks);

    base::StringAppendF(&ss, "%sNum Active Tracks: %zu\n",

            prefixSpace.c_str(), mActiveTracksMasks.size());

    base::StringAppendF(&ss, "%sOutputStreamHandle: %d\n", prefixSpace.c_str(), (int)mOutput);



    // 3. Sensors, Effect information.
@@ -1248,8 +1272,12 @@ std::string Spatializer::toString(unsigned level) const { 
                        mDisplayOrientation);



    // 4. Show flag or property state.

    static const bool stereo_spatialization_prop_enabled =

            property_get_bool("ro.audio.stereo_spatialization_enabled", false);

    const bool stereo_spatialization = com_android_media_audio_stereo_spatialization()

            && stereo_spatialization_prop_enabled;

    base::StringAppendF(&ss, "%sStereo Spatialization: %s\n", prefixSpace.c_str(),

            com_android_media_audio_stereo_spatialization() ? "true" : "false");

            stereo_spatialization ? "true" : "false");



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

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