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

Commit e49e56e3 authored by Eric Laurent's avatar Eric Laurent Committed by Gerrit Code Review
Browse files

Merge changes I0817586a,I2799ac71,I6f9795e1 

* changes:
  [BUG] Do not fallback on music group for orphan streams
  [BUG] AudioPolicy: combo UC: mute may not work
  [BUG] AudioPolicyManager: fix volume on output using Hw Gain
parents 09b9e25e 4404ddb0

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

+18 −3
Original line number Diff line number Diff line
@@ -158,7 +158,7 @@ public: 
    virtual bool isDuplicated() const { return false; }

    virtual uint32_t latency() { return 0; }

    virtual bool isFixedVolume(const DeviceTypeSet& deviceTypes);

    virtual bool setVolume(float volumeDb,

    virtual bool setVolume(float volumeDb, bool muted,

                           VolumeSource volumeSource, const StreamTypeVector &streams,

                           const DeviceTypeSet& deviceTypes,

                           uint32_t delayMs,
@@ -352,7 +352,22 @@ public: 
            setClientActive(client, false);

        }

    }

    virtual bool setVolume(float volumeDb,



    /**

     * @brief setSwMute for SwOutput routed on a device that supports Hw Gain, this function allows

     * to mute the tracks associated to a given volume source only.

     * As an output may host one or more source(s), and as AudioPolicyManager may dispatch or not

     * the volume change request according to the priority of the volume source to control the

     * unique hw gain controller, a separated API allows to force a mute/unmute of a volume source.

     * @param muted true to mute, false otherwise

     * @param vs volume source to be considered

     * @param device scoped for the change

     * @param delayMs potentially applyed to prevent cut sounds.

     */

    void setSwMute(bool muted, VolumeSource vs, const StreamTypeVector &streams,

                   const DeviceTypeSet& device, uint32_t delayMs);



    virtual bool setVolume(float volumeDb, bool muted,

                           VolumeSource volumeSource, const StreamTypeVector &streams,

                           const DeviceTypeSet& device,

                           uint32_t delayMs,
@@ -435,7 +450,7 @@ public: 


            void dump(String8 *dst) const override;



    virtual bool setVolume(float volumeDb,

    virtual bool setVolume(float volumeDb, bool muted,

                           VolumeSource volumeSource, const StreamTypeVector &streams,

                           const DeviceTypeSet& deviceTypes,

                           uint32_t delayMs,

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

+37 −9
Original line number Diff line number Diff line
@@ -155,7 +155,7 @@ bool AudioOutputDescriptor::isFixedVolume(const DeviceTypeSet& deviceTypes __unu 
    return false;

}



bool AudioOutputDescriptor::setVolume(float volumeDb,

bool AudioOutputDescriptor::setVolume(float volumeDb, bool /*muted*/,

                                      VolumeSource volumeSource,

                                      const StreamTypeVector &/*streams*/,

                                      const DeviceTypeSet& deviceTypes,
@@ -435,14 +435,36 @@ void SwAudioOutputDescriptor::toAudioPort(struct audio_port_v7 *port) const 
            mFlags & AUDIO_OUTPUT_FLAG_FAST ? AUDIO_LATENCY_LOW : AUDIO_LATENCY_NORMAL;

}



bool SwAudioOutputDescriptor::setVolume(float volumeDb,

void SwAudioOutputDescriptor::setSwMute(

        bool muted, VolumeSource vs, const StreamTypeVector &streamTypes,

        const DeviceTypeSet& deviceTypes, uint32_t delayMs) {

    // volume source active and more than one volume source is active, otherwise, no-op or let

    // setVolume controlling SW and/or HW Gains

    if (!streamTypes.empty() && isActive(vs) && (getActiveVolumeSources().size() > 1)) {

        for (const auto& devicePort : devices()) {

            if (isSingleDeviceType(deviceTypes, devicePort->type()) &&

                    devicePort->hasGainController(true /*canUseForVolume*/)) {

                float volumeAmpl = muted ? 0.0f : Volume::DbToAmpl(0);

                ALOGV("%s: output: %d, vs: %d, muted: %d, active vs count: %zu", __func__,

                      mIoHandle, vs, muted, getActiveVolumeSources().size());

                for (const auto &stream : streamTypes) {

                    mClientInterface->setStreamVolume(stream, volumeAmpl, mIoHandle, delayMs);

                }

                return;

            }

        }

    }

}



bool SwAudioOutputDescriptor::setVolume(float volumeDb, bool muted,

                                        VolumeSource vs, const StreamTypeVector &streamTypes,

                                        const DeviceTypeSet& deviceTypes,

                                        uint32_t delayMs,

                                        bool force)

{

    StreamTypeVector streams = streamTypes;

    if (!AudioOutputDescriptor::setVolume(volumeDb, vs, streamTypes, deviceTypes, delayMs, force)) {

    if (!AudioOutputDescriptor::setVolume(

            volumeDb, muted, vs, streamTypes, deviceTypes, delayMs, force)) {

        return false;

    }

    if (streams.empty()) {
@@ -459,11 +481,17 @@ bool SwAudioOutputDescriptor::setVolume(float volumeDb, 
            // different Volume Source (or if we allow several curves within same volume group)

            //

            // @todo: default stream volume to max (0) when using HW Port gain?

            float volumeAmpl = Volume::DbToAmpl(0);

            // Allows to set SW Gain on AudioFlinger if:

            //    -volume group has explicit stream(s) associated

            //    -volume group with no explicit stream(s) is the only active source on this output

            // Allows to mute SW Gain on AudioFlinger only for volume group with explicit stream(s)

            if (!streamTypes.empty() || (getActiveVolumeSources().size() == 1)) {

                const bool canMute = muted && (volumeDb != 0.0f) && !streamTypes.empty();

                float volumeAmpl = canMute ? 0.0f : Volume::DbToAmpl(0);

                for (const auto &stream : streams) {

                    mClientInterface->setStreamVolume(stream, volumeAmpl, mIoHandle, delayMs);

                }



            }

            AudioGains gains = devicePort->getGains();

            int gainMinValueInMb = gains[0]->getMinValueInMb();

            int gainMaxValueInMb = gains[0]->getMaxValueInMb();
@@ -679,14 +707,14 @@ void HwAudioOutputDescriptor::toAudioPort(struct audio_port_v7 *port) const 
}





bool HwAudioOutputDescriptor::setVolume(float volumeDb,

bool HwAudioOutputDescriptor::setVolume(float volumeDb, bool muted,

                                        VolumeSource volumeSource, const StreamTypeVector &streams,

                                        const DeviceTypeSet& deviceTypes,

                                        uint32_t delayMs,

                                        bool force)

{

    bool changed = AudioOutputDescriptor::setVolume(

            volumeDb, volumeSource, streams, deviceTypes, delayMs, force);

            volumeDb, muted, volumeSource, streams, deviceTypes, delayMs, force);



    if (changed) {

      // TODO: use gain controller on source device if any to adjust volume

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+56 −33
Original line number Diff line number Diff line
@@ -1810,7 +1810,7 @@ status_t AudioPolicyManager::startSource(const sp<SwAudioOutputDescriptor>& outp 
    if (stream == AUDIO_STREAM_TTS) {

        ALOGV("\t found BEACON stream");

        if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(

                                    toVolumeSource(AUDIO_STREAM_TTS) /*sourceToIgnore*/)) {

                                    toVolumeSource(AUDIO_STREAM_TTS, false) /*sourceToIgnore*/)) {

            return INVALID_OPERATION;

        } else {

            beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
@@ -2032,12 +2032,20 @@ status_t AudioPolicyManager::stopSource(const sp<SwAudioOutputDescriptor>& outpu 
        if (outputDesc->getActivityCount(clientVolSrc) == 0 || forceDeviceUpdate) {

            outputDesc->setStopTime(client, systemTime());

            DeviceVector newDevices = getNewOutputDevices(outputDesc, false /*fromCache*/);



            // If the routing does not change, if an output is routed on a device using HwGain

            // (aka setAudioPortConfig) and there are still active clients following different

            // volume group(s), force reapply volume

            bool requiresVolumeCheck = outputDesc->getActivityCount(clientVolSrc) == 0 &&

                    outputDesc->useHwGain() && outputDesc->isAnyActive(VOLUME_SOURCE_NONE);



            // delay the device switch by twice the latency because stopOutput() is executed when

            // the track stop() command is received and at that time the audio track buffer can

            // still contain data that needs to be drained. The latency only covers the audio HAL

            // and kernel buffers. Also the latency does not always include additional delay in the

            // audio path (audio DSP, CODEC ...)

            setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2);

            setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2,

                             nullptr, true /*requiresMuteCheck*/, requiresVolumeCheck);



            // force restoring the device selection on other active outputs if it differs from the

            // one being selected for this output
@@ -2793,6 +2801,8 @@ status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_ 
        // HW Gain management, do not change the volume

        if (desc->useHwGain()) {

            applyVolume = false;

            // If the volume source is active with higher priority source, ensure at least Sw Muted

            desc->setSwMute((index == 0), vs, curves.getStreamTypes(), curDevices, 0 /*delayMs*/);

            for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {

                auto activeClients = desc->clientsList(true /*activeOnly*/, productStrategy,

                                                       false /*preferredDevice*/);
@@ -2832,7 +2842,7 @@ status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_ 
        // handled by system UI

        status_t volStatus = checkAndSetVolume(

                    curves, vs, index, desc, curDevices,

                    ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM))?

                    ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM, false))?

                         TOUCH_SOUND_FIXED_DELAY_MS : 0));

        if (volStatus != NO_ERROR) {

            status = volStatus;
@@ -3034,12 +3044,14 @@ status_t AudioPolicyManager::moveEffectsToIo(const std::vector<int>& ids, audio_ 


bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const

{

    return mOutputs.isActive(toVolumeSource(stream), inPastMs);

    auto vs = toVolumeSource(stream, false);

    return vs != VOLUME_SOURCE_NONE ? mOutputs.isActive(vs, inPastMs) : false;

}



bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const

{

    return mOutputs.isActiveRemotely(toVolumeSource(stream), inPastMs);

    auto vs = toVolumeSource(stream, false);

    return vs != VOLUME_SOURCE_NONE ? mOutputs.isActiveRemotely(vs, inPastMs) : false;

}



bool AudioPolicyManager::isSourceActive(audio_source_t source) const
@@ -5858,7 +5870,7 @@ DeviceVector AudioPolicyManager::getNewOutputDevices(const sp<SwAudioOutputDescr 


        auto doGetOutputDevicesForVoice = [&]() {

            return hasVoiceStream(streams) && (outputDesc == mPrimaryOutput ||

                outputDesc->isActive(toVolumeSource(AUDIO_STREAM_VOICE_CALL))) &&

                outputDesc->isActive(toVolumeSource(AUDIO_STREAM_VOICE_CALL, false))) &&

                (isInCall() ||

                 mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) &&

                !isStreamActive(AUDIO_STREAM_ENFORCED_AUDIBLE, 0);
@@ -5954,7 +5966,7 @@ audio_devices_t AudioPolicyManager::getDevicesForStream(audio_stream_type_t stre 
        devices.merge(curDevices);

        for (audio_io_handle_t output : getOutputsForDevices(curDevices, mOutputs)) {

            sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);

            if (outputDesc->isActive(toVolumeSource(curStream))) {

            if (outputDesc->isActive(toVolumeSource(curStream, false))) {

                activeDevices.merge(outputDesc->devices());

            }

        }
@@ -6055,7 +6067,11 @@ uint32_t AudioPolicyManager::setBeaconMute(bool mute) { 
        // mute/unmute AUDIO_STREAM_TTS on all outputs

        ALOGV("\t muting %d", mute);

        uint32_t maxLatency = 0;

        auto ttsVolumeSource = toVolumeSource(AUDIO_STREAM_TTS);

        auto ttsVolumeSource = toVolumeSource(AUDIO_STREAM_TTS, false);

        if (ttsVolumeSource == VOLUME_SOURCE_NONE) {

            ALOGV("\t no tts volume source available");

            return 0;

        }

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

            sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);

            setVolumeSourceMute(ttsVolumeSource, mute/*on*/, desc, 0 /*delay*/, DeviceTypeSet());
@@ -6165,7 +6181,7 @@ uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& 
                                              bool force,

                                              int delayMs,

                                              audio_patch_handle_t *patchHandle,

                                              bool requiresMuteCheck)

                                              bool requiresMuteCheck, bool requiresVolumeCheck)

{

    ALOGV("%s device %s delayMs %d", __func__, devices.toString().c_str(), delayMs);

    uint32_t muteWaitMs;
@@ -6181,6 +6197,7 @@ uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& 
    // filter devices according to output selected

    DeviceVector filteredDevices = outputDesc->filterSupportedDevices(devices);

    DeviceVector prevDevices = outputDesc->devices();

    DeviceVector availPrevDevices = mAvailableOutputDevices.filter(prevDevices);



    ALOGV("setOutputDevices() prevDevice %s", prevDevices.toString().c_str());
@@ -6199,8 +6216,7 @@ uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& 
    // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current

    // output profile or if new device is not supported AND previous device(s) is(are) still

    // available (otherwise reset device must be done on the output)

    if (!devices.isEmpty() && filteredDevices.isEmpty() &&

            !mAvailableOutputDevices.filter(prevDevices).empty()) {

    if (!devices.isEmpty() && filteredDevices.isEmpty() && !availPrevDevices.empty()) {

        ALOGV("%s: unsupported device %s for output", __func__, devices.toString().c_str());

        // restore previous device after evaluating strategy mute state

        outputDesc->setDevices(prevDevices);
@@ -6214,16 +6230,20 @@ uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& 
    //  AND the output is connected by a valid audio patch.

    // Doing this check here allows the caller to call setOutputDevices() without conditions

    if ((filteredDevices.isEmpty() || filteredDevices == prevDevices) &&

            !force && outputDesc->getPatchHandle() != 0) {

            !force && outputDesc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {

        ALOGV("%s setting same device %s or null device, force=%d, patch handle=%d", __func__,

              filteredDevices.toString().c_str(), force, outputDesc->getPatchHandle());

        if (requiresVolumeCheck && !filteredDevices.isEmpty()) {

            ALOGV("%s setting same device on routed output, force apply volumes", __func__);

            applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs, true /*force*/);

        }

        return muteWaitMs;

    }



    ALOGV("%s changing device to %s", __func__, filteredDevices.toString().c_str());



    // do the routing

    if (filteredDevices.isEmpty()) {

    if (filteredDevices.isEmpty() || mAvailableOutputDevices.filter(filteredDevices).empty()) {

        resetOutputDevice(outputDesc, delayMs, NULL);

    } else {

        PatchBuilder patchBuilder;
@@ -6387,11 +6407,11 @@ float AudioPolicyManager::computeVolume(IVolumeCurves &curves, 
    // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch

    // exploration of the dialer UI. In this situation, bring the accessibility volume closer to

    // the ringtone volume

    const auto callVolumeSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);

    const auto ringVolumeSrc = toVolumeSource(AUDIO_STREAM_RING);

    const auto musicVolumeSrc = toVolumeSource(AUDIO_STREAM_MUSIC);

    const auto alarmVolumeSrc = toVolumeSource(AUDIO_STREAM_ALARM);

    const auto a11yVolumeSrc = toVolumeSource(AUDIO_STREAM_ACCESSIBILITY);

    const auto callVolumeSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL, false);

    const auto ringVolumeSrc = toVolumeSource(AUDIO_STREAM_RING, false);

    const auto musicVolumeSrc = toVolumeSource(AUDIO_STREAM_MUSIC, false);

    const auto alarmVolumeSrc = toVolumeSource(AUDIO_STREAM_ALARM, false);

    const auto a11yVolumeSrc = toVolumeSource(AUDIO_STREAM_ACCESSIBILITY, false);



    if (volumeSource == a11yVolumeSrc

            && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState()) &&
@@ -6404,12 +6424,12 @@ float AudioPolicyManager::computeVolume(IVolumeCurves &curves, 
    // in-call: always cap volume by voice volume + some low headroom

    if ((volumeSource != callVolumeSrc && (isInCall() ||

                                           mOutputs.isActiveLocally(callVolumeSrc))) &&

            (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM) ||

            (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM, false) ||

             volumeSource == ringVolumeSrc || volumeSource == musicVolumeSrc ||

             volumeSource == alarmVolumeSrc ||

             volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION) ||

             volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||

             volumeSource == toVolumeSource(AUDIO_STREAM_DTMF) ||

             volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION, false) ||

             volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false) ||

             volumeSource == toVolumeSource(AUDIO_STREAM_DTMF, false) ||

             volumeSource == a11yVolumeSrc)) {

        auto &voiceCurves = getVolumeCurves(callVolumeSrc);

        int voiceVolumeIndex = voiceCurves.getVolumeIndex(deviceTypes);
@@ -6447,9 +6467,9 @@ float AudioPolicyManager::computeVolume(IVolumeCurves &curves, 
             AUDIO_DEVICE_OUT_BLE_HEADSET}).empty() &&

            ((volumeSource == alarmVolumeSrc ||

              volumeSource == ringVolumeSrc) ||

             (volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION)) ||

             (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM)) ||

             ((volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE)) &&

             (volumeSource == toVolumeSource(AUDIO_STREAM_NOTIFICATION, false)) ||

             (volumeSource == toVolumeSource(AUDIO_STREAM_SYSTEM, false)) ||

             ((volumeSource == toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false)) &&

              (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&

            curves.canBeMuted()) {
@@ -6535,10 +6555,10 @@ status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves, 
               outputDesc->getMuteCount(volumeSource), outputDesc->isActive(volumeSource));

        return NO_ERROR;

    }

    VolumeSource callVolSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL);

    VolumeSource btScoVolSrc = toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO);

    bool isVoiceVolSrc = callVolSrc == volumeSource;

    bool isBtScoVolSrc = btScoVolSrc == volumeSource;

    VolumeSource callVolSrc = toVolumeSource(AUDIO_STREAM_VOICE_CALL, false);

    VolumeSource btScoVolSrc = toVolumeSource(AUDIO_STREAM_BLUETOOTH_SCO, false);

    bool isVoiceVolSrc = (volumeSource != VOLUME_SOURCE_NONE) && (callVolSrc == volumeSource);

    bool isBtScoVolSrc = (volumeSource != VOLUME_SOURCE_NONE) && (btScoVolSrc == volumeSource);



    bool isScoRequested = isScoRequestedForComm();

    // do not change in call volume if bluetooth is connected and vice versa
@@ -6563,8 +6583,9 @@ status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves, 
                    isSingleDeviceType(deviceTypes, audio_is_bluetooth_out_sco_device))) {

        volumeDb = 0.0f;

    }

    const bool muted = (index == 0) && (volumeDb != 0.0f);

    outputDesc->setVolume(

            volumeDb, volumeSource, curves.getStreamTypes(), deviceTypes, delayMs, force);

            volumeDb, muted, volumeSource, curves.getStreamTypes(), deviceTypes, delayMs, force);



    if (outputDesc == mPrimaryOutput && (isVoiceVolSrc || isBtScoVolSrc)) {

        float voiceVolume;
@@ -6606,8 +6627,10 @@ void AudioPolicyManager::setStrategyMute(product_strategy_t strategy, 
    for (auto attributes: mEngine->getAllAttributesForProductStrategy(strategy)) {

        ALOGVV("%s() attributes %s, mute %d, output ID %d", __func__,

               toString(attributes).c_str(), on, outputDesc->getId());

        VolumeSource source = toVolumeSource(attributes);

        if (std::find(begin(sourcesToMute), end(sourcesToMute), source) == end(sourcesToMute)) {

        VolumeSource source = toVolumeSource(attributes, false);

        if ((source != VOLUME_SOURCE_NONE) &&

                (std::find(begin(sourcesToMute), end(sourcesToMute), source)

                        == end(sourcesToMute))) {

            sourcesToMute.push_back(source);

        }

    }
@@ -6630,7 +6653,7 @@ void AudioPolicyManager::setVolumeSourceMute(VolumeSource volumeSource, 
    if (on) {

        if (!outputDesc->isMuted(volumeSource)) {

            if (curves.canBeMuted() &&

                    (volumeSource != toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE) ||

                    (volumeSource != toVolumeSource(AUDIO_STREAM_ENFORCED_AUDIBLE, false) ||

                     (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) ==

                      AUDIO_POLICY_FORCE_NONE))) {

                checkAndSetVolume(curves, volumeSource, 0, outputDesc, deviceTypes, delayMs);

services/audiopolicy/managerdefault/AudioPolicyManager.h

+37 −7
Original line number Diff line number Diff line
@@ -421,13 +421,30 @@ protected: 
        {

            return static_cast<VolumeSource>(volumeGroup);

        }

        VolumeSource toVolumeSource(const audio_attributes_t &attributes) const

        /**

         * @brief toVolumeSource converts an audio attributes into a volume source

         * (either a legacy stream or a volume group). If fallback on default is allowed, and if

         * the audio attributes do not follow any specific product strategy's rule, it will be

         * associated to default volume source, e.g. music. Thus, any of call of volume API

         * using this translation function may affect the default volume source.

         * If fallback is not allowed and no matching rule is identified for the given attributes,

         * the volume source will be undefined, thus, no volume will be altered/modified.

         * @param attributes to be considered

         * @param fallbackOnDefault

         * @return volume source associated with given attributes, otherwise either music if

         * fallbackOnDefault is set or none.

         */

        VolumeSource toVolumeSource(

            const audio_attributes_t &attributes, bool fallbackOnDefault = true) const

        {

            return toVolumeSource(mEngine->getVolumeGroupForAttributes(attributes));

            return toVolumeSource(mEngine->getVolumeGroupForAttributes(

                attributes, fallbackOnDefault));

        }

        VolumeSource toVolumeSource(audio_stream_type_t stream) const

        VolumeSource toVolumeSource(

            audio_stream_type_t stream, bool fallbackOnDefault = true) const

        {

            return toVolumeSource(mEngine->getVolumeGroupForStreamType(stream));

            return toVolumeSource(mEngine->getVolumeGroupForStreamType(

                stream, fallbackOnDefault));

        }

        IVolumeCurves &getVolumeCurves(VolumeSource volumeSource)

        {
@@ -453,14 +470,27 @@ protected: 
        void removeOutput(audio_io_handle_t output);

        void addInput(audio_io_handle_t input, const sp<AudioInputDescriptor>& inputDesc);



        // change the route of the specified output. Returns the number of ms we have slept to

        // allow new routing to take effect in certain cases.

        /**

         * @brief setOutputDevices change the route of the specified output.

         * @param outputDesc to be considered

         * @param device to be considered to route the output

         * @param force if true, force the routing even if no change.

         * @param delayMs if specified, delay to apply for mute/volume op when changing device

         * @param patchHandle if specified, the patch handle this output is connected through.

         * @param requiresMuteCheck if specified, for e.g. when another output is on a shared device

         *        and currently active, allow to have proper drain and avoid pops

         * @param requiresVolumeCheck true if called requires to reapply volume if the routing did

         * not change (but the output is still routed).

         * @return the number of ms we have slept to allow new routing to take effect in certain

         * cases.

         */

        uint32_t setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,

                                  const DeviceVector &device,

                                  bool force = false,

                                  int delayMs = 0,

                                  audio_patch_handle_t *patchHandle = NULL,

                                  bool requiresMuteCheck = true);

                                  bool requiresMuteCheck = true,

                                  bool requiresVolumeCheck = false);

        status_t resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,

                                   int delayMs = 0,

                                   audio_patch_handle_t *patchHandle = NULL);