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

Commit 78643607 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Support non PCM output requests with dynamic policy active"

parents d9a7dc27 f6537ae8

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

+15 −11
Original line number Diff line number Diff line
@@ -1055,7 +1055,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;

    }
@@ -1064,10 +1069,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) {
@@ -5862,8 +5866,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;

            }
@@ -5969,8 +5973,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();
@@ -6239,8 +6243,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);

    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

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


    std::unique_ptr<AudioPolicyManagerTestClient> mClient;

    std::unique_ptr<AudioPolicyTestManager> mManager;



    const uint32_t k48000SamplingRate = 48000;

};



void AudioPolicyManagerTest::SetUp() {
@@ -405,11 +407,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);
@@ -464,7 +466,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);
@@ -482,7 +484,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");
@@ -540,8 +542,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());

}
@@ -550,7 +552,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());

}
@@ -558,13 +560,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());

}
@@ -572,8 +574,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());

}
@@ -584,9 +586,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);
@@ -596,9 +597,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);
@@ -607,8 +607,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());

    }
@@ -637,8 +637,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());

}
@@ -747,7 +747,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>());
@@ -786,7 +786,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>());
@@ -1008,7 +1008,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);
@@ -1042,7 +1042,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);
@@ -1058,7 +1058,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);
@@ -1085,8 +1085,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) ||
@@ -1228,7 +1228,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);
@@ -1244,7 +1244,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()));
@@ -1272,7 +1272,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);})
@@ -1422,11 +1422,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);
@@ -1450,6 +1450,45 @@ 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, GetOutputForAttrEncodedOutputAfterRegisteringPolicyMix) {

    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());

}



class AudioPolicyManagerTVTest : public AudioPolicyManagerTestWithConfigurationFile {

protected:

    std::string getConfigFile() override { return sTvConfig; }
@@ -1470,8 +1509,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",