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

Commit 838714d3 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 8813441 from ecbf2ee4 to tm-qpr1-release 

Change-Id: Ifba5c1db211289d9e81112f2859029dc36168ae2
parents 6a8fb1d1 ecbf2ee4

services/audiopolicy/common/managerdefinitions/include/AudioPolicyMix.h

+4 −2
Original line number Diff line number Diff line
@@ -70,8 +70,9 @@ public: 
     * @return OK if the request is valid

     *         otherwise if the request is not supported

     */

    status_t getOutputForAttr(const audio_attributes_t& attributes, uid_t uid,

                              audio_output_flags_t flags,

    status_t getOutputForAttr(const audio_attributes_t& attributes,

                              const audio_config_base_t& config,

                              uid_t uid, audio_output_flags_t flags,

                              sp<AudioPolicyMix> &primaryMix,

                              std::vector<sp<AudioPolicyMix>> *secondaryMixes);
@@ -126,6 +127,7 @@ private: 
    enum class MixMatchStatus { MATCH, NO_MATCH, INVALID_MIX };

    MixMatchStatus mixMatch(const AudioMix* mix, size_t mixIndex,

                            const audio_attributes_t& attributes,

                            const audio_config_base_t& config,

                            uid_t uid);

};

services/audiopolicy/common/managerdefinitions/src/AudioPolicyMix.cpp

+12 −3
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ void AudioPolicyMixCollection::closeOutput(sp<SwAudioOutputDescriptor> &desc) 
}



status_t AudioPolicyMixCollection::getOutputForAttr(

        const audio_attributes_t& attributes, uid_t uid,

        const audio_attributes_t& attributes, const audio_config_base_t& config, uid_t uid,

        audio_output_flags_t flags,

        sp<AudioPolicyMix> &primaryMix,

        std::vector<sp<AudioPolicyMix>> *secondaryMixes)
@@ -177,7 +177,7 @@ status_t AudioPolicyMixCollection::getOutputForAttr( 
            continue; // Primary output already found

        }



        switch (mixMatch(policyMix.get(), i, attributes, uid)) {

        switch (mixMatch(policyMix.get(), i, attributes, config, uid)) {

            case MixMatchStatus::INVALID_MIX:

                // The mix has contradictory rules, ignore it

                // TODO: reject invalid mix at registration
@@ -202,7 +202,8 @@ status_t AudioPolicyMixCollection::getOutputForAttr( 
}



AudioPolicyMixCollection::MixMatchStatus AudioPolicyMixCollection::mixMatch(

        const AudioMix* mix, size_t mixIndex, const audio_attributes_t& attributes, uid_t uid) {

        const AudioMix* mix, size_t mixIndex, const audio_attributes_t& attributes,

        const audio_config_base_t& config, uid_t uid) {



    if (mix->mMixType == MIX_TYPE_PLAYERS) {

        // Loopback render mixes are created from a public API and thus restricted
@@ -229,6 +230,14 @@ AudioPolicyMixCollection::MixMatchStatus AudioPolicyMixCollection::mixMatch( 
            }

        }



        // Permit match only if requested format and mix format are PCM and can be format

        // adapted by the mixer, or are the same (compressed) format.

        if (!((audio_is_linear_pcm(config.format) && audio_is_linear_pcm(mix->mFormat.format)) ||

              (config.format == mix->mFormat.format)) &&

              config.format != AUDIO_CONFIG_BASE_INITIALIZER.format) {

            return MixMatchStatus::NO_MATCH;

        }



        int userId = (int) multiuser_get_user_id(uid);



        // TODO if adding more player rules (currently only 2), make rule handling "generic"

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+29 −17
Original line number Diff line number Diff line
@@ -1161,7 +1161,12 @@ status_t AudioPolicyManager::getOutputForAttrInt( 
    //       otherwise, fallback to the dynamic policies, if none match, query the engine.

    // Secondary outputs are always found by dynamic policies as the engine do not support them

    sp<AudioPolicyMix> primaryMix;

    status = mPolicyMixes.getOutputForAttr(*resultAttr, uid, *flags, primaryMix, secondaryMixes);

    const audio_config_base_t clientConfig = {.sample_rate = config->sample_rate,

        .channel_mask = config->channel_mask,

        .format = config->format,

    };

    status = mPolicyMixes.getOutputForAttr(*resultAttr, clientConfig, uid, *flags, primaryMix,

                                           secondaryMixes);

    if (status != OK) {

        return status;

    }
@@ -1170,10 +1175,9 @@ status_t AudioPolicyManager::getOutputForAttrInt( 
    bool usePrimaryOutputFromPolicyMixes = requestedDevice == nullptr && primaryMix != nullptr;



    // FIXME: in case of RENDER policy, the output capabilities should be checked

    if ((usePrimaryOutputFromPolicyMixes

            || (secondaryMixes != nullptr && !secondaryMixes->empty()))

    if ((secondaryMixes != nullptr && !secondaryMixes->empty())

            && !audio_is_linear_pcm(config->format)) {

        ALOGD("%s: rejecting request as dynamic audio policy only support pcm", __func__);

        ALOGD("%s: rejecting request as secondary mixes only support pcm", __func__);

        return BAD_VALUE;

    }

    if (usePrimaryOutputFromPolicyMixes) {
@@ -1182,19 +1186,27 @@ status_t AudioPolicyManager::getOutputForAttrInt( 
                                                  primaryMix->mDeviceAddress,

                                                  AUDIO_FORMAT_DEFAULT);

        sp<SwAudioOutputDescriptor> policyDesc = primaryMix->getOutput();

        if (deviceDesc != nullptr

                && (policyDesc == nullptr || (policyDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT))) {

        bool tryDirectForFlags = policyDesc == nullptr ||

                (policyDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT);

        // if a direct output can be opened to deliver the track's multi-channel content to the

        // output rather than being downmixed by the primary output, then use this direct

        // output by by-passing the primary mix if possible, otherwise fall-through to primary

        // mix.

        bool tryDirectForChannelMask = policyDesc != nullptr

                    && (audio_channel_count_from_out_mask(policyDesc->getConfig().channel_mask) <

                        audio_channel_count_from_out_mask(config->channel_mask));

        if (deviceDesc != nullptr && (tryDirectForFlags || tryDirectForChannelMask)) {

            audio_io_handle_t newOutput;

            status = openDirectOutput(

                    *stream, session, config,

                    (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_DIRECT),

                    DeviceVector(deviceDesc), &newOutput);

            if (status != NO_ERROR) {

                policyDesc = nullptr;

            } else {

            if (status == NO_ERROR) {

                policyDesc = mOutputs.valueFor(newOutput);

                primaryMix->setOutput(policyDesc);

            }

            } else if (tryDirectForFlags) {

                policyDesc = nullptr;

            } // otherwise use primary if available.

        }

        if (policyDesc != nullptr) {

            policyDesc->mPolicyMix = primaryMix;
@@ -6326,8 +6338,8 @@ void AudioPolicyManager::checkOutputForAttributes(const audio_attributes_t &attr 
                continue;

            }

            sp<AudioPolicyMix> primaryMix;

            status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->uid(),

                    client->flags(), primaryMix, nullptr);

            status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->config(),

                    client->uid(), client->flags(), primaryMix, nullptr);

            if (status != OK) {

                continue;

            }
@@ -6439,8 +6451,8 @@ void AudioPolicyManager::checkSecondaryOutputs() { 
        for (const sp<TrackClientDescriptor>& client : outputDescriptor->getClientIterable()) {

            sp<AudioPolicyMix> primaryMix;

            std::vector<sp<AudioPolicyMix>> secondaryMixes;

            status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->uid(),

                    client->flags(), primaryMix, &secondaryMixes);

            status_t status = mPolicyMixes.getOutputForAttr(client->attributes(), client->config(),

                    client->uid(), client->flags(), primaryMix, &secondaryMixes);

            std::vector<sp<SwAudioOutputDescriptor>> secondaryDescs;

            for (auto &secondaryMix : secondaryMixes) {

                sp<SwAudioOutputDescriptor> outputDesc = secondaryMix->getOutput();
@@ -6698,8 +6710,8 @@ status_t AudioPolicyManager::getDevicesForAttributes( 
    // check dynamic policies but only for primary descriptors (secondary not used for audible

    // audio routing, only used for duplication for playback capture)

    sp<AudioPolicyMix> policyMix;

    status_t status = mPolicyMixes.getOutputForAttr(attr, 0 /*uid unknown here*/,

            AUDIO_OUTPUT_FLAG_NONE, policyMix, nullptr /* secondaryMixes */);

    status_t status = mPolicyMixes.getOutputForAttr(attr, AUDIO_CONFIG_BASE_INITIALIZER,

            0 /*uid unknown here*/, AUDIO_OUTPUT_FLAG_NONE, policyMix, nullptr);

    if (status != OK) {

        return status;

    }

services/audiopolicy/tests/audiopolicymanager_tests.cpp

+88 −37
Original line number Diff line number Diff line
@@ -148,6 +148,8 @@ class AudioPolicyManagerTest : public testing::Test { 


    std::unique_ptr<AudioPolicyManagerTestClient> mClient;

    std::unique_ptr<AudioPolicyTestManager> mManager;



    const uint32_t k48000SamplingRate = 48000;

};



void AudioPolicyManagerTest::SetUp() {
@@ -414,11 +416,11 @@ void AudioPolicyManagerTestMsd::SetUpManagerConfig() { 
    AudioPolicyConfig& config = mManager->getConfig();

    mMsdOutputDevice = new DeviceDescriptor(AUDIO_DEVICE_OUT_BUS);

    sp<AudioProfile> pcmOutputProfile = new AudioProfile(

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, 48000);

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);

    sp<AudioProfile> ac3OutputProfile = new AudioProfile(

            AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, 48000);

            AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, k48000SamplingRate);

    sp<AudioProfile> iec958OutputProfile = new AudioProfile(

            AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_OUT_STEREO, 48000);

            AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);

    mMsdOutputDevice->addAudioProfile(pcmOutputProfile);

    mMsdOutputDevice->addAudioProfile(ac3OutputProfile);

    mMsdOutputDevice->addAudioProfile(iec958OutputProfile);
@@ -473,7 +475,7 @@ void AudioPolicyManagerTestMsd::SetUpManagerConfig() { 
    // Add a profile with another encoding to the default device to test routing

    // of streams that are not supported by MSD.

    sp<AudioProfile> dtsOutputProfile = new AudioProfile(

            AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1, 48000);

            AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1, k48000SamplingRate);

    config.getDefaultOutputDevice()->addAudioProfile(dtsOutputProfile);

    sp<OutputProfile> primaryEncodedOutputProfile = new OutputProfile("encoded");

    primaryEncodedOutputProfile->addAudioProfile(dtsOutputProfile);
@@ -491,7 +493,7 @@ void AudioPolicyManagerTestMsd::SetUpManagerConfig() { 
    // Add HDMI input device with IEC60958 profile for HDMI in -> MSD patching.

    mHdmiInputDevice = new DeviceDescriptor(AUDIO_DEVICE_IN_HDMI);

    sp<AudioProfile> iec958InputProfile = new AudioProfile(

            AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_IN_STEREO, 48000);

            AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate);

    mHdmiInputDevice->addAudioProfile(iec958InputProfile);

    config.addDevice(mHdmiInputDevice);

    sp<InputProfile> hdmiInputProfile = new InputProfile("hdmi input");
@@ -556,8 +558,8 @@ TEST_P(AudioPolicyManagerTestMsd, PatchCreationSetReleaseMsdOutputPatches) { 
TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrEncodedRoutesToMsd) {

    const PatchCountCheck patchCount = snapshotPatchCount();

    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId,

            AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT);

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);

    ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

    ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());

}
@@ -566,7 +568,7 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrPcmRoutesToMsd) { 
    const PatchCountCheck patchCount = snapshotPatchCount();

    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId,

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, 48000);

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);

    ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

    ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());

}
@@ -574,13 +576,13 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrPcmRoutesToMsd) { 
TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrEncodedPlusPcmRoutesToMsd) {

    const PatchCountCheck patchCount = snapshotPatchCount();

    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId,

            AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT);

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);

    ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

    ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());

    selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId,

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, 48000);

            AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);

    ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

    ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());

}
@@ -588,8 +590,8 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrEncodedPlusPcmRoutesToMsd) { 
TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrUnsupportedFormatBypassesMsd) {

    const PatchCountCheck patchCount = snapshotPatchCount();

    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId,

            AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT);

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1,

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);

    ASSERT_NE(selectedDeviceId, mMsdOutputDevice->getId());

    ASSERT_EQ(0, patchCount.deltaFromSnapshot());

}
@@ -600,9 +602,8 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrFormatSwitching) { 
        const PatchCountCheck patchCount = snapshotPatchCount();

        audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

        audio_port_handle_t portId;

        getOutputForAttr(&selectedDeviceId,

                AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT,

                nullptr /*output*/, &portId);

        getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,

                k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, nullptr /*output*/, &portId);

        ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

        ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());

        mManager->releaseOutput(portId);
@@ -612,9 +613,8 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrFormatSwitching) { 
        const PatchCountCheck patchCount = snapshotPatchCount();

        audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

        audio_port_handle_t portId;

        getOutputForAttr(&selectedDeviceId,

                AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT,

                nullptr /*output*/, &portId);

        getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1,

                k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, nullptr /*output*/, &portId);

        ASSERT_NE(selectedDeviceId, mMsdOutputDevice->getId());

        ASSERT_EQ(-static_cast<int>(mExpectedAudioPatchCount), patchCount.deltaFromSnapshot());

        mManager->releaseOutput(portId);
@@ -623,8 +623,8 @@ TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrFormatSwitching) { 
    {

        const PatchCountCheck patchCount = snapshotPatchCount();

        audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

        getOutputForAttr(&selectedDeviceId,

                AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, 48000, AUDIO_OUTPUT_FLAG_DIRECT);

        getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,

                k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);

        ASSERT_EQ(selectedDeviceId, mDefaultOutputDevice->getId());

        ASSERT_EQ(0, patchCount.deltaFromSnapshot());

    }
@@ -653,8 +653,8 @@ TEST_P(AudioPolicyManagerTestMsd, PatchCreationFromHdmiInToMsd) { 
    ASSERT_EQ(AUDIO_FORMAT_IEC60958, patch->mPatch.sinks[0].format);

    ASSERT_EQ(AUDIO_CHANNEL_IN_STEREO, patch->mPatch.sources[0].channel_mask);

    ASSERT_EQ(AUDIO_CHANNEL_OUT_STEREO, patch->mPatch.sinks[0].channel_mask);

    ASSERT_EQ(48000, patch->mPatch.sources[0].sample_rate);

    ASSERT_EQ(48000, patch->mPatch.sinks[0].sample_rate);

    ASSERT_EQ(k48000SamplingRate, patch->mPatch.sources[0].sample_rate);

    ASSERT_EQ(k48000SamplingRate, patch->mPatch.sinks[0].sample_rate);

    ASSERT_EQ(1, patchCount.deltaFromSnapshot());

}
@@ -996,7 +996,7 @@ TEST_F(AudioPolicyManagerTestDynamicPolicy, RegisterPolicyMixes) { 
    clearPolicyMix();

    audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;

    audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;

    audioConfig.sample_rate = 48000;

    audioConfig.sample_rate = k48000SamplingRate;

    ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,

            AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig,

            std::vector<PolicyMixTuple>());
@@ -1035,7 +1035,7 @@ TEST_F(AudioPolicyManagerTestDynamicPolicy, UnregisterPolicyMixes) { 


    audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;

    audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;

    audioConfig.sample_rate = 48000;

    audioConfig.sample_rate = k48000SamplingRate;

    ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,

            AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig,

            std::vector<PolicyMixTuple>());
@@ -1273,7 +1273,7 @@ TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule, RegistrationFailure) { 
    audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;

    audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;

    audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;

    audioConfig.sample_rate = 48000;

    audioConfig.sample_rate = k48000SamplingRate;

    ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,

            AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "", audioConfig, std::vector<PolicyMixTuple>());

    ASSERT_EQ(INVALID_OPERATION, ret);
@@ -1307,7 +1307,7 @@ void AudioPolicyManagerTestDPPlaybackReRouting::SetUp() { 
    audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;

    audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;

    audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;

    audioConfig.sample_rate = 48000;

    audioConfig.sample_rate = k48000SamplingRate;

    status_t ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,

            AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig, mUsageRules);

    ASSERT_EQ(NO_ERROR, ret);
@@ -1323,7 +1323,7 @@ void AudioPolicyManagerTestDPPlaybackReRouting::SetUp() { 
    std::string tags = "addr=" + mMixAddress;

    strncpy(attr.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);

    getInputForAttr(attr, mTracker->getRiid(), &selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT,

            AUDIO_CHANNEL_IN_STEREO, 48000 /*sampleRate*/, AUDIO_INPUT_FLAG_NONE, &mPortId);

            AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate, AUDIO_INPUT_FLAG_NONE, &mPortId);

    ASSERT_EQ(NO_ERROR, mManager->startInput(mPortId));

    ASSERT_EQ(extractionPort.id, selectedDeviceId);
@@ -1350,8 +1350,8 @@ TEST_P(AudioPolicyManagerTestDPPlaybackReRouting, PlaybackReRouting) { 


    audio_port_handle_t playbackRoutedPortId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&playbackRoutedPortId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,

            48000 /*sampleRate*/, AUDIO_OUTPUT_FLAG_NONE,

            nullptr /*output*/, nullptr /*portId*/, attr);

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, nullptr /*output*/, nullptr /*portId*/,

            attr);

    if (std::find_if(begin(mUsageRules), end(mUsageRules), [&usage](const auto &usageRule) {

            return (std::get<0>(usageRule) == usage) &&

            (std::get<2>(usageRule) == RULE_MATCH_ATTRIBUTE_USAGE);}) != end(mUsageRules) ||
@@ -1493,7 +1493,7 @@ void AudioPolicyManagerTestDPMixRecordInjection::SetUp() { 
    audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;

    audioConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;

    audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;

    audioConfig.sample_rate = 48000;

    audioConfig.sample_rate = k48000SamplingRate;

    status_t ret = addPolicyMix(MIX_TYPE_RECORDERS, MIX_ROUTE_FLAG_LOOP_BACK,

            AUDIO_DEVICE_IN_REMOTE_SUBMIX, mMixAddress, audioConfig, mSourceRules);

    ASSERT_EQ(NO_ERROR, ret);
@@ -1509,7 +1509,7 @@ void AudioPolicyManagerTestDPMixRecordInjection::SetUp() { 
    std::string tags = std::string("addr=") + mMixAddress;

    strncpy(attr.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,

            48000 /*sampleRate*/, AUDIO_OUTPUT_FLAG_NONE, nullptr /*output*/, &mPortId, attr);

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, nullptr /*output*/, &mPortId, attr);

    ASSERT_EQ(NO_ERROR, mManager->startOutput(mPortId));

    ASSERT_EQ(injectionPort.id, getDeviceIdFromPatch(mClient->getLastAddedPatch()));
@@ -1537,7 +1537,7 @@ TEST_P(AudioPolicyManagerTestDPMixRecordInjection, RecordingInjection) { 
    audio_port_handle_t captureRoutedPortId = AUDIO_PORT_HANDLE_NONE;

    audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;

    getInputForAttr(attr, mTracker->getRiid(), &captureRoutedPortId, AUDIO_FORMAT_PCM_16_BIT,

            AUDIO_CHANNEL_IN_STEREO, 48000 /*sampleRate*/, AUDIO_INPUT_FLAG_NONE, &portId);

            AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate, AUDIO_INPUT_FLAG_NONE, &portId);

    if (std::find_if(begin(mSourceRules), end(mSourceRules), [&source](const auto &sourceRule) {

            return (std::get<1>(sourceRule) == source) &&

            (std::get<2>(sourceRule) == RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET);})
@@ -1687,11 +1687,11 @@ TEST_P(AudioPolicyManagerTestDeviceConnection, ExplicitlyRoutingAfterConnection) 
    // Try start input or output according to the device type

    if (audio_is_output_devices(type)) {

        getOutputForAttr(&routedPortId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,

                48000 /*sampleRate*/, AUDIO_OUTPUT_FLAG_NONE);

                k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE);

    } else if (audio_is_input_device(type)) {

        RecordingActivityTracker tracker;

        getInputForAttr({}, tracker.getRiid(), &routedPortId, AUDIO_FORMAT_PCM_16_BIT,

                AUDIO_CHANNEL_IN_STEREO, 48000 /*sampleRate*/, AUDIO_INPUT_FLAG_NONE);

                AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate, AUDIO_INPUT_FLAG_NONE);

    }

    ASSERT_EQ(devicePort.id, routedPortId);
@@ -1715,6 +1715,57 @@ INSTANTIATE_TEST_CASE_P( 
                )

        );



class AudioPolicyManagerCarTest : public AudioPolicyManagerTestDynamicPolicy {

protected:

    std::string getConfigFile() override { return sCarConfig; }



    static const std::string sCarConfig;

};



const std::string AudioPolicyManagerCarTest::sCarConfig =

        AudioPolicyManagerCarTest::sExecutableDir + "test_car_ap_atmos_offload_configuration.xml";



TEST_F(AudioPolicyManagerCarTest, InitSuccess) {

    // SetUp must finish with no assertions.

}



TEST_F(AudioPolicyManagerCarTest, Dump) {

    dumpToLog();

}



TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrAtmosOutputAfterRegisteringPolicyMix) {

    status_t ret;

    audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;

    const std::string kTestBusMediaOutput = "bus0_media_out";

    ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,

            AUDIO_DEVICE_OUT_BUS, kTestBusMediaOutput, audioConfig, std::vector<PolicyMixTuple>());

    ASSERT_EQ(NO_ERROR, ret);



    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    audio_io_handle_t output;

    audio_port_handle_t portId;

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_E_AC3_JOC, AUDIO_CHANNEL_OUT_5POINT1,

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId);

    ASSERT_NE(AUDIO_PORT_HANDLE_NONE, selectedDeviceId);

    sp<SwAudioOutputDescriptor> outDesc = mManager->getOutputs().valueFor(output);

    ASSERT_NE(nullptr, outDesc.get());

    ASSERT_EQ(AUDIO_FORMAT_E_AC3_JOC, outDesc->getFormat());

    ASSERT_EQ(AUDIO_CHANNEL_OUT_5POINT1, outDesc->getChannelMask());

    ASSERT_EQ(k48000SamplingRate, outDesc->getSamplingRate());



    selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    output = AUDIO_IO_HANDLE_NONE;

    portId = AUDIO_PORT_HANDLE_NONE;

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_7POINT1POINT4,

            k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId);

    ASSERT_NE(AUDIO_PORT_HANDLE_NONE, selectedDeviceId);

    outDesc = mManager->getOutputs().valueFor(output);

    ASSERT_NE(nullptr, outDesc.get());

    ASSERT_EQ(AUDIO_FORMAT_PCM_16_BIT, outDesc->getFormat());

    ASSERT_EQ(AUDIO_CHANNEL_OUT_7POINT1POINT4, outDesc->getChannelMask());

    ASSERT_EQ(k48000SamplingRate, outDesc->getSamplingRate());

}



class AudioPolicyManagerTVTest : public AudioPolicyManagerTestWithConfigurationFile {

protected:

    std::string getConfigFile() override { return sTvConfig; }
@@ -1735,8 +1786,8 @@ void AudioPolicyManagerTVTest::testHDMIPortSelection( 
    audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;

    audio_io_handle_t output;

    audio_port_handle_t portId;

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, 48000,

            flags, &output, &portId);

    getOutputForAttr(&selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,

            k48000SamplingRate, flags, &output, &portId);

    sp<SwAudioOutputDescriptor> outDesc = mManager->getOutputs().valueFor(output);

    ASSERT_NE(nullptr, outDesc.get());

    audio_port_v7 port = {};

services/audiopolicy/tests/resources/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ filegroup { 
    srcs: [

        "test_audio_policy_configuration.xml",

        "test_audio_policy_primary_only_configuration.xml",

        "test_car_ap_atmos_offload_configuration.xml",

        "test_invalid_audio_policy_configuration.xml",

        "test_tv_apm_configuration.xml",

        "test_settop_box_surround_configuration.xml",