Remove code associated with portid_volume_management flag (d9ed9183) · Commits · e / os / android_frameworks_av

media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp

+5 −14

Original line number	Diff line number	Diff line
		@@ -504,24 +504,15 @@ void AudioFlingerFuzzer::invokeAudioSystem() {
		AudioSystem::getMasterMute(&state);
		AudioSystem::isMicrophoneMuted(&state);

		audio_stream_type_t stream ;
		if (!audioserver_flags::portid_volume_management()) {
		stream = getValue(&mFdp, kStreamtypes);
		AudioSystem::setStreamMute(getValue(&mFdp, kStreamtypes), mFdp.ConsumeBool());

		stream = getValue(&mFdp, kStreamtypes);
		AudioSystem::setStreamVolume(stream, mFdp.ConsumeFloatingPoint<float>(),
		mFdp.ConsumeBool(), mFdp.ConsumeIntegral<int32_t>());
		} else {
		std::vector <audio_port_handle_t> portsForVolumeChange{};
		AudioSystem::setPortsVolume(portsForVolumeChange, mFdp.ConsumeFloatingPoint<float>(),
		mFdp.ConsumeBool(), mFdp.ConsumeIntegral<int32_t>());
		}

		audio_mode_t mode = getValue(&mFdp, kModes);
		AudioSystem::setMode(mode);

		size_t frameCount;
		stream = getValue(&mFdp, kStreamtypes);
		audio_stream_type_t stream = getValue(&mFdp, kStreamtypes);
		AudioSystem::getOutputFrameCount(&frameCount, stream);

		uint32_t latency;

services/audioflinger/Threads.cpp

+73 −213

Original line number	Diff line number	Diff line
		@@ -2323,18 +2323,6 @@ PlaybackThread::PlaybackThread(const sp<IAfThreadCallback>& afThreadCallback,
		(int64_t)(mIsMsdDevice ? AUDIO_DEVICE_OUT_BUS // turn on by default for MSD
		: AUDIO_DEVICE_NONE));
		}
		if (!audioserver_flags::portid_volume_management()) {
		for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
		const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
		mStreamTypes[stream].volume = 0.0f;
		mStreamTypes[stream].mute = mAfThreadCallback->streamMute_l(stream);
		}
		// Audio patch and call assistant volume are always max
		mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
		mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
		mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].volume = 1.0f;
		mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
		}
		}

		PlaybackThread::~PlaybackThread()
		@@ -2384,19 +2372,7 @@ void PlaybackThread::preExit()
		void PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& /* args */)
		{
		String8 result;
		if (!audioserver_flags::portid_volume_management()) {
		result.appendFormat(" Stream volumes in dB: ");
		for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
		const stream_type_t *st = &mStreamTypes[i];
		if (i > 0) {
		result.appendFormat(", ");
		}
		result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
		if (st->mute) {
		result.append("M");
		}
		}
		}

		result.append("\n");
		write(fd, result.c_str(), result.length());
		result.clear();
		@@ -5782,19 +5758,12 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		}
		sp<AudioTrackServerProxy> proxy = track->audioTrackServerProxy();
		float volume;
		if (!audioserver_flags::portid_volume_management()) {
		if (track->isPlaybackRestricted() \|\| mStreamTypes[track->streamType()].mute) {
		volume = 0.f;
		} else {
		volume = masterVolume * mStreamTypes[track->streamType()].volume;
		}
		} else {
		if (track->isPlaybackRestricted() \|\| track->getPortMute()) {
		volume = 0.f;
		} else {
		volume = masterVolume * track->getPortVolume();
		}
		}

		const auto amn = mAfThreadCallback->getAudioManagerNative();
		if (amn) {
		track->maybeLogPlaybackHardening(*amn);
		@@ -5811,17 +5780,6 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		float vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
		float vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
		if (amn) {
		if (!audioserver_flags::portid_volume_management()) {
		track->processMuteEvent(*amn,
		/muteState=/{masterVolume == 0.f,
		mStreamTypes[track->streamType()].volume == 0.f,
		mStreamTypes[track->streamType()].mute,
		track->isPlaybackRestrictedOp(),
		vlf == 0.f && vrf == 0.f,
		vh == 0.f,
		/muteFromPortVolume=/false,
		track->isPlaybackRestrictedControl()});
		} else {
		track->processMuteEvent(*amn,
		/muteState=/{masterVolume == 0.f,
		track->getPortVolume() == 0.f,
		@@ -5832,7 +5790,6 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		track->getPortMute(),
		track->isPlaybackRestrictedControl()});
		}
		}
		vlf *= volume;
		vrf *= volume;

		@@ -5986,18 +5943,11 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		const float vh = track->getVolumeHandler()->getVolume(
		track->audioTrackServerProxy()->framesReleased()).first;
		float v;
		if (!audioserver_flags::portid_volume_management()) {
		v = masterVolume * mStreamTypes[track->streamType()].volume;
		if (mStreamTypes[track->streamType()].mute \|\| track->isPlaybackRestricted()) {
		if (track->isPlaybackRestricted() \|\| track->getPortMute()) {
		v = 0;
		}
		} else {
		v = masterVolume * track->getPortVolume();
		if (track->isPlaybackRestricted() \|\| track->getPortMute()) {
		v = 0;
		}
		}

		handleVoipVolume_l(&v);
		const auto amn = mAfThreadCallback->getAudioManagerNative();
		if (amn) {
		@@ -6022,17 +5972,6 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		vrf = GAIN_FLOAT_UNITY;
		}
		if (amn) {
		if (!audioserver_flags::portid_volume_management()) {
		track->processMuteEvent(*amn,
		/muteState=/{masterVolume == 0.f,
		mStreamTypes[track->streamType()].volume == 0.f,
		mStreamTypes[track->streamType()].mute,
		track->isPlaybackRestrictedOp(),
		vlf == 0.f && vrf == 0.f,
		vh == 0.f,
		/muteFromPortVolume=/false,
		track->isPlaybackRestrictedControl()});
		} else {
		track->processMuteEvent(*amn,
		/muteState=/{masterVolume == 0.f,
		track->getPortVolume() == 0.f,
		@@ -6043,7 +5982,6 @@ PlaybackThread::mixer_state MixerThread::prepareTracks_l(
		track->getPortMute(),
		track->isPlaybackRestrictedControl()});
		}
		}
		// now apply the master volume and stream type volume and shaper volume
		vlf = v vh;
		vrf = v vh;
		@@ -6769,40 +6707,7 @@ void DirectOutputThread::processVolume_l(const sp<IAfTrack>& track, bool lastTra
		const bool clientVolumeMute = (left == 0.f && right == 0.f);

		const auto amn = mAfThreadCallback->getAudioManagerNative();
		if (!audioserver_flags::portid_volume_management()) {
		if (mMasterMute \|\| mStreamTypes[track->streamType()].mute \|\|
		track->isPlaybackRestricted()) {
		left = right = 0;
		} else {
		float typeVolume = mStreamTypes[track->streamType()].volume;
		const float v = mMasterVolume * typeVolume * shaperVolume;

		if (left > GAIN_FLOAT_UNITY) {
		left = GAIN_FLOAT_UNITY;
		}
		if (right > GAIN_FLOAT_UNITY) {
		right = GAIN_FLOAT_UNITY;
		}
		left *= v;
		right *= v;
		if (mAfThreadCallback->getMode() != AUDIO_MODE_IN_COMMUNICATION
		\|\| audio_channel_count_from_out_mask(mChannelMask) > 1) {
		left *= mMasterBalanceLeft; // DirectOutputThread balance applied as track volume
		right *= mMasterBalanceRight;
		}
		}
		if (amn) {
		track->processMuteEvent(*amn,
		/muteState=/{mMasterMute,
		mStreamTypes[track->streamType()].volume == 0.f,
		mStreamTypes[track->streamType()].mute,
		track->isPlaybackRestrictedOp(),
		clientVolumeMute,
		shaperVolume == 0.f,
		/muteFromPortVolume=/false,
		track->isPlaybackRestrictedControl()});
		}
		} else {
		if (mMasterMute \|\| track->isPlaybackRestricted()) {
		left = right = 0;
		} else {
		@@ -6833,9 +6738,7 @@ void DirectOutputThread::processVolume_l(const sp<IAfTrack>& track, bool lastTra
		shaperVolume == 0.f,
		track->getPortMute(),
		track->isPlaybackRestrictedControl()});
		}
		}
		if (amn) {

		track->maybeLogPlaybackHardening(*amn);
		}
		if (lastTrack) {
		@@ -7957,10 +7860,6 @@ void DuplicatingThread::addOutputTrack(IAfPlaybackThread* thread)
		ALOGE("addOutputTrack() initCheck failed %d", status);
		return;
		}
		if (!audioserver_flags::portid_volume_management()) {
		thread->asVolumeInterface()->setStreamVolume(
		AUDIO_STREAM_PATCH, /volume=/1.0f, /muted=/false);
		}

		mOutputTracks.emplace(outputTrack);
		ALOGV("addOutputTrack() track %p, on thread %p", outputTrack.get(), thread);
		@@ -11230,18 +11129,6 @@ MmapPlaybackThread::MmapPlaybackThread(
		mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
		mMasterVolume = afThreadCallback->masterVolume_l();
		mMasterMute = afThreadCallback->masterMute_l();
		if (!audioserver_flags::portid_volume_management()) {
		for (int i = AUDIO_STREAM_MIN; i < AUDIO_STREAM_FOR_POLICY_CNT; ++i) {
		const audio_stream_type_t stream{static_cast<audio_stream_type_t>(i)};
		mStreamTypes[stream].volume = 0.0f;
		mStreamTypes[stream].mute = mAfThreadCallback->streamMute_l(stream);
		}
		// Audio patch and call assistant volume are always max
		mStreamTypes[AUDIO_STREAM_PATCH].volume = 1.0f;
		mStreamTypes[AUDIO_STREAM_PATCH].mute = false;
		mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].volume = 1.0f;
		mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
		}
		if (mAudioHwDev) {
		if (mAudioHwDev->canSetMasterVolume()) {
		mMasterVolume = 1.0;
		@@ -11326,16 +11213,7 @@ void MmapPlaybackThread::processVolume_l()
		NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent
		{
		float volume = 0;
		if (!audioserver_flags::portid_volume_management()) {
		if (mMasterMute \|\| streamMuted_l()) {
		volume = 0;
		} else {
		volume = mMasterVolume * streamVolume_l();
		}
		} else {
		if (mMasterMute) {
		volume = 0;
		} else {
		if (!mMasterMute) {
		// All mmap tracks are declared with the same audio attributes to the audio policy
		// manager. Hence, they follow the same routing / volume group. Any change of volume
		// will be broadcasted to all tracks. Thus, take arbitrarily first track volume.
		@@ -11349,7 +11227,6 @@ NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent
		}
		}
		}
		}

		bool shouldMutePlaybackHardening = std::all_of(mActiveTracks.begin(), mActiveTracks.end(),
		[](const auto& x) { return x->asIAfMmapTrack()->isPlaybackRestrictedControl(); });
		@@ -11391,18 +11268,6 @@ NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent
		for (const auto& track : mActiveMmapTracksView) {
		track->setMetadataHasChanged();
		if (amn) {
		if (!audioserver_flags::portid_volume_management()) {
		track->processMuteEvent(*amn,
		/muteState=/{mMasterMute,
		streamVolume_l() == 0.f,
		streamMuted_l(),
		// TODO(b/241533526): adjust logic to include mute from AppOps
		false /muteFromPlaybackRestricted/,
		false /muteFromClientVolume/,
		false /muteFromVolumeShaper/,
		false /muteFromPortVolume/,
		shouldMutePlaybackHardening});
		} else {
		track->processMuteEvent(*amn,
		/muteState=/{mMasterMute,
		track->getPortVolume() == 0.f,
		@@ -11413,7 +11278,7 @@ NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent
		false /muteFromVolumeShaper/,
		track->getPortMute(),
		shouldMutePlaybackHardening});
		}

		track->maybeLogPlaybackHardening(*amn);
		}
		}
		@@ -11518,12 +11383,7 @@ void MmapPlaybackThread::stopMelComputation_l()
		void MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
		{
		MmapThread::dumpInternals_l(fd, args);
		if (!audioserver_flags::portid_volume_management()) {
		dprintf(fd, " Stream type: %d Stream volume: %f HAL volume: %f Stream mute %d",
		mStreamType, streamVolume_l(), mHalVolFloat, streamMuted_l());
		} else {
		dprintf(fd, " HAL volume: %f", mHalVolFloat);
		}
		dprintf(fd, "\n");
		dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
		}

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

+2 −2

Original line number	Diff line number	Diff line
		@@ -411,9 +411,9 @@ public:
		* @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.
		* @param delayMs potentially applied to prevent cut sounds.
		*/
		void setSwMute(bool muted, VolumeSource vs, const StreamTypeVector &streams,
		void setSwMute(bool muted, VolumeSource vs,
		const DeviceTypeSet& device, uint32_t delayMs);

		virtual bool setVolume(float volumeDb, bool muted,

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

+29 −81

Original line number	Diff line number	Diff line
		@@ -582,26 +582,11 @@ void SwAudioOutputDescriptor::toAudioPort(struct audio_port_v7 *port) const
		}

		void SwAudioOutputDescriptor::setSwMute(
		bool mutedByGroup, VolumeSource vs, const StreamTypeVector &streamTypes,
		bool mutedByGroup, VolumeSource vs,
		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 (!audioserver_flags::portid_volume_management()) {
		if (!streamTypes.empty() && isActive(vs) && (getActiveVolumeSources().size() > 1)) {
		for (const auto& devicePort : devices()) {
		if (isSingleDeviceType(deviceTypes, devicePort->type()) &&
		devicePort->hasGainController(true /canUseForVolume/)) {
		ALOGV("%s: output: %d, vs: %d, muted: %d, active vs count: %zu", __func__,
		mIoHandle, vs, mutedByGroup, getActiveVolumeSources().size());
		for (const auto &stream : streamTypes) {
		mClientInterface->setStreamVolume(stream, Volume::DbToAmpl(0), mutedByGroup,
		mIoHandle, delayMs);
		}
		return;
		}
		}
		}
		} else {

		if (isActive(vs) && (getActiveVolumeSources().size() > 1)) {
		for (const auto& devicePort: devices()) {
		if (isSingleDeviceType(deviceTypes, devicePort->type()) &&
		@@ -617,7 +602,6 @@ void SwAudioOutputDescriptor::setSwMute(
		}
		}
		}
		}

		bool SwAudioOutputDescriptor::setVolume(float volumeDb, bool mutedByGroup,
		VolumeSource vs, const StreamTypeVector &streamTypes,
		@@ -639,13 +623,8 @@ bool SwAudioOutputDescriptor::setVolume(float volumeDb, bool mutedByGroup,
		(volumeDb != getCurVolume(callVolSrc) \|\| mutedChanged)) {
		setCurVolume(callVolSrc, volumeDb, mutedByGroup, true);
		float volumeAmpl = Volume::DbToAmpl(volumeDb);
		if (audioserver_flags::portid_volume_management()) {
		mClientInterface->setPortsVolume(getPortsForVolumeSource(callVolSrc),
		volumeAmpl, mutedByGroup, mIoHandle, delayMs);
		} else {
		mClientInterface->setStreamVolume(AUDIO_STREAM_VOICE_CALL,
		volumeAmpl, mutedByGroup, mIoHandle, delayMs);
		}
		}
		}
		return false;
		@@ -662,29 +641,13 @@ bool SwAudioOutputDescriptor::setVolume(float volumeDb, bool mutedByGroup,
		ALOGV("%s: device %s has gain controller", __func__, devicePort->toString().c_str());
		// @todo: here we might be in trouble if the SwOutput has several active clients with
		// different Volume Source (or if we allow several curves within same volume group)
		if (!audioserver_flags::portid_volume_management()) {
		// @todo: default stream volume to max (0) when using HW Port gain?
		// 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 = mutedByGroup && !streamTypes.empty();
		const float volumeAmpl = Volume::DbToAmpl(0);
		for (const auto &stream: streams) {
		mClientInterface->setStreamVolume(stream, volumeAmpl, canMute, mIoHandle,
		delayMs);
		}
		}
		} else {

		float volumeAmpl = Volume::DbToAmpl(0);
		ALOGV("%s: output: %d, vs: %d, active vs count: %zu", __func__,
		mIoHandle, vs, getActiveVolumeSources().size());
		mClientInterface->setPortsVolume(
		getPortsForVolumeSource(vs), volumeAmpl, mutedByGroup, mIoHandle, delayMs);
		}

		AudioGains gains = devicePort->getGains();
		int gainMinValueInMb = gains[0]->getMinValueInMb();
		int gainMaxValueInMb = gains[0]->getMaxValueInMb();
		@@ -705,32 +668,17 @@ bool SwAudioOutputDescriptor::setVolume(float volumeDb, bool mutedByGroup,
		if (hasStream(streams, AUDIO_STREAM_BLUETOOTH_SCO) &&
		!com_android_media_audio_replace_stream_bt_sco()) {
		VolumeSource callVolSrc = getVoiceSource();
		if (audioserver_flags::portid_volume_management()) {
		if (callVolSrc != VOLUME_SOURCE_NONE) {
		mClientInterface->setPortsVolume(getPortsForVolumeSource(callVolSrc), volumeAmpl,
		mutedByGroup, mIoHandle, delayMs);
		}
		} else {
		mClientInterface->setStreamVolume(AUDIO_STREAM_VOICE_CALL, volumeAmpl, mutedByGroup,
		mIoHandle, delayMs);
		}
		if (callVolSrc != VOLUME_SOURCE_NONE) {

		setCurVolume(callVolSrc, getCurVolume(vs), mutedByGroup, true);
		}
		}
		if (audioserver_flags::portid_volume_management()) {
		ALOGV("%s output %d for volumeSource %d, volume %f, mutedByGroup %d, delay %d active=%d",
		__func__, mIoHandle, vs, volumeDb, mutedByGroup, delayMs, isActive(vs));
		mClientInterface->setPortsVolume(getPortsForVolumeSource(vs), volumeAmpl, mutedByGroup,
		mIoHandle, delayMs);
		} else {
		for (const auto &stream : streams) {
		ALOGV("%s output %d for volumeSource %d, volume %f, mutedByGroup %d delay %d stream=%s",
		__func__, mIoHandle, vs, volumeDb, mutedByGroup, delayMs,
		toString(stream).c_str());
		mClientInterface->setStreamVolume(stream, volumeAmpl, mutedByGroup, mIoHandle, delayMs);
		}
		}
		return true;
		}

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -3874,7 +3874,7 @@ status_t AudioPolicyManager::setVolumeIndexForGroup(volume_group_t group,
		if (desc->useHwGain()) {
		bool swMute = com_android_media_audio_ring_my_car() ? curves.isMuted() : (index == 0);
		// If the volume source is active with higher priority source, ensure at least Sw Muted
		desc->setSwMute(swMute, vs, curves.getStreamTypes(), curDevices, 0 /delayMs/);
		desc->setSwMute(swMute, vs, curDevices, 0 /delayMs/);
		if (!desc->canSetVolumeForVolumeSource(activityVs)) {
		continue; // next output
		}