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

Commit 9cf5f182 authored by Jeremy Wu's avatar Jeremy Wu Committed by Android (Google) Code Review
Browse files

Merge changes I180618b4,If3b439f8,I44c6e8ad into main 

* changes:
  APM: improve getAudioMixPort simulation in test
  Reapply "APM: use routing checks with ioprofile"
  Reapply "ioprofile: implement |isRoutableToDevice|"
parents 9f632e18 9c61cc1e

media/libaudiofoundation/include/media/AudioPort.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -114,6 +114,7 @@ public: 
                        ((mFlags.input & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0)));

                        ((mFlags.input & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0)));

    }

    }





    void setHalIdForTest(int32_t halId) { mHalId = halId; }

    int32_t getHalId() const { return mHalId; }

    int32_t getHalId() const { return mHalId; }





    void dump(std::string *dst, int spaces,

    void dump(std::string *dst, int spaces,

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

+3 −1
Original line number Original line Diff line number Diff line
@@ -54,6 +54,8 @@ public: 
    void setDevice(const sp<DeviceDescriptor> &device) { mDevice = device; }

    void setDevice(const sp<DeviceDescriptor> &device) { mDevice = device; }

    DeviceVector supportedDevices() const  {

    DeviceVector supportedDevices() const  {

        return mProfile != nullptr ? mProfile->getSupportedDevices() : DeviceVector(); }

        return mProfile != nullptr ? mProfile->getSupportedDevices() : DeviceVector(); }

    DeviceVector routableDevices() const  {

        return mProfile != nullptr ? mProfile->getRoutableDevices() : DeviceVector(); }





    void dump(String8 *dst, int spaces, const char* extraInfo) const override;

    void dump(String8 *dst, int spaces, const char* extraInfo) const override;

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

+42 −0
Original line number Original line Diff line number Diff line
@@ -162,6 +162,7 @@ public: 
    virtual DeviceVector devices() const { return mDevices; }

    virtual DeviceVector devices() const { return mDevices; }

    bool sharesHwModuleWith(const sp<AudioOutputDescriptor>& outputDesc);

    bool sharesHwModuleWith(const sp<AudioOutputDescriptor>& outputDesc);

    virtual DeviceVector supportedDevices() const  { return mDevices; }

    virtual DeviceVector supportedDevices() const  { return mDevices; }

    virtual DeviceVector routableDevices() const  { return mDevices; }

    virtual bool isDuplicated() const { return false; }

    virtual bool isDuplicated() const { return false; }

    virtual uint32_t latency() { return 0; }

    virtual uint32_t latency() { return 0; }

    virtual bool isFixedVolume(const DeviceTypeSet& deviceTypes);

    virtual bool isFixedVolume(const DeviceTypeSet& deviceTypes);
@@ -384,6 +385,7 @@ public: 
    void setDevices(const DeviceVector &devices);

    void setDevices(const DeviceVector &devices);

    bool sharesHwModuleWith(const sp<SwAudioOutputDescriptor>& outputDesc);

    bool sharesHwModuleWith(const sp<SwAudioOutputDescriptor>& outputDesc);

    virtual DeviceVector supportedDevices() const;

    virtual DeviceVector supportedDevices() const;

    virtual DeviceVector routableDevices() const;

    virtual bool devicesSupportEncodedFormats(const DeviceTypeSet& deviceTypes);

    virtual bool devicesSupportEncodedFormats(const DeviceTypeSet& deviceTypes);

    virtual bool containsSingleDeviceSupportingEncodedFormats(

    virtual bool containsSingleDeviceSupportingEncodedFormats(

            const sp<DeviceDescriptor>& device) const;

            const sp<DeviceDescriptor>& device) const;
@@ -453,6 +455,14 @@ public: 
     */

     */

    bool supportsDevice(const sp<DeviceDescriptor> &device) const;

    bool supportsDevice(const sp<DeviceDescriptor> &device) const;





    /**

     * @brief routesToDevice

     * @param device to be checked against

     * @return true if the device is routable from/to this profile.

     *         false otherwise

     */

    bool routesToDevice(const sp<DeviceDescriptor> &device) const;



    /**

    /**

     * @brief supportsAllDevices

     * @brief supportsAllDevices

     * @param devices to be checked against

     * @param devices to be checked against
@@ -462,6 +472,14 @@ public: 
     */

     */

    bool supportsAllDevices(const DeviceVector &devices) const;

    bool supportsAllDevices(const DeviceVector &devices) const;





    /**

     * @brief routesToAllDevices

     * @param devices to be checked against

     * @return true if all devices are routable to this profile

     *         false otherwise

     */

    bool routesToAllDevices(const DeviceVector &devices) const;



    /**

    /**

     * @brief supportsAtLeastOne checks if any device in devices is currently supported

     * @brief supportsAtLeastOne checks if any device in devices is currently supported

     * @param devices to be checked against

     * @param devices to be checked against
@@ -471,6 +489,14 @@ public: 
     */

     */

    bool supportsAtLeastOne(const DeviceVector &devices) const;

    bool supportsAtLeastOne(const DeviceVector &devices) const;





    /**

     * @brief routesToAtLeastOne checks if any device in devices is currently routable

     * @param devices to be checked against

     * @return true if any device is routable to this profile

     *         false otherwise

     */

    bool routesToAtLeastOne(const DeviceVector &devices) const;



    /**

    /**

     * @brief supportsDevicesForPlayback

     * @brief supportsDevicesForPlayback

     * @param devices to be checked against

     * @param devices to be checked against
@@ -479,6 +505,14 @@ public: 
     */

     */

    bool supportsDevicesForPlayback(const DeviceVector &devices) const;

    bool supportsDevicesForPlayback(const DeviceVector &devices) const;





    /**

     * @brief routesToDevicesForPlayback

     * @param devices to be checked against

     * @return true if the devices is a routable combo for playback

     *         false otherwise

     */

    bool routesToDevicesForPlayback(const DeviceVector &devices) const;



    /**

    /**

     * @brief filterSupportedDevices takes a vector of devices and filters them according to the

     * @brief filterSupportedDevices takes a vector of devices and filters them according to the

     * device supported by this output (the profile from which this output derives from)

     * device supported by this output (the profile from which this output derives from)
@@ -488,6 +522,14 @@ public: 
     */

     */

    DeviceVector filterSupportedDevices(const DeviceVector &devices) const;

    DeviceVector filterSupportedDevices(const DeviceVector &devices) const;





    /**

     * @brief filterRoutableDevices takes a vector of devices and filters them according to the

     * device routable to this output (the profile from which this output derives from)

     * @param devices reference device vector to be filtered

     * @return vector of devices filtered from the routable devices of this output

     */

    DeviceVector filterRoutableDevices(const DeviceVector &devices) const;



    uint32_t getRecommendedMuteDurationMs() const override;

    uint32_t getRecommendedMuteDurationMs() const override;





    void setTracksInvalidatedStatusByStrategy(product_strategy_t strategy);

    void setTracksInvalidatedStatusByStrategy(product_strategy_t strategy);

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

+57 −1
Original line number Original line Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include "DeviceDescriptor.h"

#include "DeviceDescriptor.h"

#include "PolicyAudioPort.h"

#include "PolicyAudioPort.h"

#include "policy.h"

#include "policy.h"

#include <com_android_media_audioserver.h>

#include <media/AudioContainers.h>

#include <media/AudioContainers.h>

#include <utils/String8.h>

#include <utils/String8.h>

#include <system/audio.h>

#include <system/audio.h>
@@ -122,6 +123,7 @@ public: 
     * @return true if all devices are supported, false otherwise.

     * @return true if all devices are supported, false otherwise.

     */

     */

    bool areAllDevicesSupported(const DeviceVector &devices) const;

    bool areAllDevicesSupported(const DeviceVector &devices) const;

    bool areAllDevicesRoutable(const DeviceVector &devices) const;





    /**

    /**

     * @brief isCompatibleProfileForFlags: Checks if the IO profile is compatible with

     * @brief isCompatibleProfileForFlags: Checks if the IO profile is compatible with
@@ -136,6 +138,7 @@ public: 
    void log();

    void log();





    bool hasSupportedDevices() const { return !mSupportedDevices.isEmpty(); }

    bool hasSupportedDevices() const { return !mSupportedDevices.isEmpty(); }

    bool hasRoutableDevices() const { return !mRoutableDevices.isEmpty(); }





    bool supportsDeviceTypes(const DeviceTypeSet& deviceTypes) const

    bool supportsDeviceTypes(const DeviceTypeSet& deviceTypes) const

    {

    {
@@ -175,6 +178,27 @@ public: 
        return mSupportedDevices.contains(device);

        return mSupportedDevices.contains(device);

    }

    }





    /**

     * @brief routesToDevice

     * @param device to be checked against

     * @return true if the device is routable as indicated by the HAL.

     *         false otherwise.

     */

    bool routesToDevice(const sp<DeviceDescriptor> &device) const

    {

        if (!com::android::media::audioserver::enable_strict_port_routing_checks()) {

            return supportsDevice(device);

        }



        // If profile does not contain ID, this is most likely indicating HIDL.

        // Return routable so as to follow the legacy behavior.

        if (getHalId() == AUDIO_PORT_HANDLE_NONE) {

            return supportsDevice(device);

        }



        return mRoutableDevices.contains(device);

    }



    bool devicesSupportEncodedFormats(DeviceTypeSet deviceTypes) const

    bool devicesSupportEncodedFormats(DeviceTypeSet deviceTypes) const

    {

    {

        if (deviceTypes.empty()) {

        if (deviceTypes.empty()) {
@@ -193,6 +217,7 @@ public: 
    bool containsSingleDeviceSupportingEncodedFormats(const sp<DeviceDescriptor>& device) const;

    bool containsSingleDeviceSupportingEncodedFormats(const sp<DeviceDescriptor>& device) const;





    void clearSupportedDevices() { mSupportedDevices.clear(); }

    void clearSupportedDevices() { mSupportedDevices.clear(); }

    void clearRoutableDevices() { mRoutableDevices.clear(); }

    void addSupportedDevice(const sp<DeviceDescriptor> &device)

    void addSupportedDevice(const sp<DeviceDescriptor> &device)

    {

    {

        mSupportedDevices.add(device);

        mSupportedDevices.add(device);
@@ -211,9 +236,31 @@ public: 
    {

    {

        mSupportedDevices = devices;

        mSupportedDevices = devices;

    }

    }

    void setRoutableDevices(const DeviceVector &devices)

    {

        mRoutableDevices = devices;

    }





    const DeviceVector &getSupportedDevices() const { return mSupportedDevices; }

    const DeviceVector &getSupportedDevices() const { return mSupportedDevices; }





    void addRoutableDevice(const sp<DeviceDescriptor> &device)

    {

        mRoutableDevices.add(device);

    }



    void removeRoutableDevice(const sp<DeviceDescriptor> &device)

    {

        mRoutableDevices.remove(device);

    }



    const DeviceVector &getRoutableDevices() const { return mRoutableDevices; }



    void addSupportedRoutableDevice(const sp<DeviceDescriptor> &device)

    {

        mSupportedDevices.add(device);

        mRoutableDevices.add(device);

    }



    bool canOpenNewIo() {

    bool canOpenNewIo() {

        if (maxOpenCount == 0 || curOpenCount < maxOpenCount) {

        if (maxOpenCount == 0 || curOpenCount < maxOpenCount) {

            return true;

            return true;
@@ -245,7 +292,16 @@ private: 
    CompatibilityScore getFlagsCompatibleScore(uint32_t flags,

    CompatibilityScore getFlagsCompatibleScore(uint32_t flags,

                                               uint32_t additionalMandatoryFlags = 0) const;

                                               uint32_t additionalMandatoryFlags = 0) const;





    DeviceVector mSupportedDevices; // supported devices: this input/output can be routed from/to

    // supported devices: this input/output can potentially be routed from/to

    // it is deduced by type and may end up being not necessarily routable,

    // this is due to that `DeviceDescriptor` has the flexibility to be created

    // before HAL connection, at which point it will find candidate/supported profiles

    // where routability can yet be validated.

    DeviceVector mSupportedDevices;



    // routable devices as indicated via AudioRoute by the HAL, updated on device dis/connection.

    // in pre-AIDL HAL we will assume everything is routable.

    DeviceVector mRoutableDevices;





    MixerBehaviorSet mMixerBehaviors;

    MixerBehaviorSet mMixerBehaviors;

};

};

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

+39 −0
Original line number Original line Diff line number Diff line
@@ -419,6 +419,19 @@ bool SwAudioOutputDescriptor::sharesHwModuleWith( 
    }

    }

}

}





DeviceVector SwAudioOutputDescriptor::routableDevices() const

{

    if (isDuplicated()) {

        DeviceVector routableDevices = mOutput1->routableDevices();

        routableDevices.merge(mOutput2->routableDevices());

        return routableDevices;

    }

    if (mProfile != nullptr) {

        return mProfile->getRoutableDevices();

    }

    return DeviceVector();

}



DeviceVector SwAudioOutputDescriptor::supportedDevices() const

DeviceVector SwAudioOutputDescriptor::supportedDevices() const

{

{

    if (isDuplicated()) {

    if (isDuplicated()) {
@@ -437,16 +450,31 @@ bool SwAudioOutputDescriptor::supportsDevice(const sp<DeviceDescriptor> &device) 
    return supportedDevices().contains(device);

    return supportedDevices().contains(device);

}

}





bool SwAudioOutputDescriptor::routesToDevice(const sp<DeviceDescriptor> &device) const

{

    return routableDevices().contains(device);

}



bool SwAudioOutputDescriptor::supportsAllDevices(const DeviceVector &devices) const

bool SwAudioOutputDescriptor::supportsAllDevices(const DeviceVector &devices) const

{

{

    return supportedDevices().containsAllDevices(devices);

    return supportedDevices().containsAllDevices(devices);

}

}





bool SwAudioOutputDescriptor::routesToAllDevices(const DeviceVector &devices) const

{

    return routableDevices().containsAllDevices(devices);

}



bool SwAudioOutputDescriptor::supportsAtLeastOne(const DeviceVector &devices) const

bool SwAudioOutputDescriptor::supportsAtLeastOne(const DeviceVector &devices) const

{

{

    return filterSupportedDevices(devices).size() > 0;

    return filterSupportedDevices(devices).size() > 0;

}

}





bool SwAudioOutputDescriptor::routesToAtLeastOne(const DeviceVector &devices) const

{

    return filterRoutableDevices(devices).size() > 0;

}



bool SwAudioOutputDescriptor::supportsDevicesForPlayback(const DeviceVector &devices) const

bool SwAudioOutputDescriptor::supportsDevicesForPlayback(const DeviceVector &devices) const

{

{

    // No considering duplicated output

    // No considering duplicated output
@@ -454,12 +482,23 @@ bool SwAudioOutputDescriptor::supportsDevicesForPlayback(const DeviceVector &dev 
    return !isDuplicated() && supportsAllDevices(devices);

    return !isDuplicated() && supportsAllDevices(devices);

}

}





bool SwAudioOutputDescriptor::routesToDevicesForPlayback(const DeviceVector &devices) const

{

    return !isDuplicated() && routesToAllDevices(devices);

}



DeviceVector SwAudioOutputDescriptor::filterSupportedDevices(const DeviceVector &devices) const

DeviceVector SwAudioOutputDescriptor::filterSupportedDevices(const DeviceVector &devices) const

{

{

    DeviceVector filteredDevices = supportedDevices();

    DeviceVector filteredDevices = supportedDevices();

    return filteredDevices.filter(devices);

    return filteredDevices.filter(devices);

}

}





DeviceVector SwAudioOutputDescriptor::filterRoutableDevices(const DeviceVector &devices) const

{

    DeviceVector filteredDevices = routableDevices();

    return filteredDevices.filter(devices);

}



bool SwAudioOutputDescriptor::devicesSupportEncodedFormats(const DeviceTypeSet& deviceTypes)

bool SwAudioOutputDescriptor::devicesSupportEncodedFormats(const DeviceTypeSet& deviceTypes)

{

{

    if (isDuplicated()) {

    if (isDuplicated()) {