Snap for 12923841 from eea4ddba4d75c9e51525bf091dc36d23400853ff to 25Q2-release (5a5c4bed) · Commits · e / os / android_frameworks_av

media/libeffects/loudness/aidl/EffectLoudnessEnhancer.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@

		#include "EffectLoudnessEnhancer.h"

		using aidl::android::hardware::audio::common::getChannelCount;
		using aidl::android::hardware::audio::effect::Descriptor;
		using aidl::android::hardware::audio::effect::getEffectImplUuidLoudnessEnhancer;
		using aidl::android::hardware::audio::effect::getEffectTypeUuidLoudnessEnhancer;
		@@ -138,6 +139,11 @@ std::shared_ptr<EffectContext> LoudnessEnhancerImpl::createContext(
		LOG(DEBUG) << __func__ << " context already exist";
		return mContext;
		}
		if (2 < getChannelCount(common.input.base.channelMask)) {
		LOG(ERROR) << __func__
		<< " channelCount not supported: " << common.input.base.channelMask.toString();
		return nullptr;
		}

		mContext = std::make_shared<LoudnessEnhancerContext>(1 /* statusFmqDepth */, common);
		return mContext;

media/libeffects/loudness/aidl/LoudnessEnhancerContext.cpp

+0 −4

Original line number	Diff line number	Diff line
		@@ -102,10 +102,6 @@ IEffect::Status LoudnessEnhancerContext::process(float* in, float* out, int samp
		}

		void LoudnessEnhancerContext::init_params() {
		int channelCount = ::aidl::android::hardware::audio::common::getChannelCount(
		mCommon.input.base.channelMask);
		LOG_ALWAYS_FATAL_IF(channelCount != 2, "channel count %d not supported", channelCount);

		mGain = LOUDNESS_ENHANCER_DEFAULT_TARGET_GAIN_MB;
		float targetAmp = pow(10, mGain / 2000.0f); // mB to linear amplification
		LOG(VERBOSE) << __func__ << "Target gain = " << mGain << "mB <=> factor = " << targetAmp;

media/libstagefright/MPEG4Writer.cpp

+5 −0

Original line number	Diff line number	Diff line
		@@ -2640,6 +2640,11 @@ void MPEG4Writer::Track::addItemOffsetAndSize(off64_t offset, size_t size, bool
		}

		if (mProperties.empty()) {
		// Min length of hvcC CSD is 23. (ISO/IEC 14496-15:2014 Chapter 8.4.1.1.2)
		if (mIsHeif && mCodecSpecificDataSize < 23) {
		ALOGE("hvcC csd size is less than 23 bytes");
		return;
		}
		mProperties.push_back(mOwner->addProperty_l({
		.type = static_cast<uint32_t>(mIsAvif ?
		FOURCC('a', 'v', '1', 'C') :

services/audiopolicy/tests/audiopolicymanager_tests.cpp

+290 −0

Original line number	Diff line number	Diff line
		@@ -4020,6 +4020,296 @@ TEST_F(AudioPolicyManagerPreProcEffectTest, DeviceDisconnectWhileClientActive) {
		ASSERT_EQ(NO_ERROR, mManager->unregisterEffect(effectId));
		}

		namespace {

		class AudioPolicyManagerTestClientVolumeChecker : public AudioPolicyManagerTestClient {
		public:
		status_t setStreamVolume(audio_stream_type_t stream,
		float volume,
		bool /muted/,
		audio_io_handle_t /output/,
		int /delayMs/) override {
		mLastStreamVolume[stream] = volume;
		return NO_ERROR;
		}

		status_t setPortsVolume(const std::vector<audio_port_handle_t>& ports, float volume,
		bool /muted/, audio_io_handle_t /output/,
		int /delayMs/) override {
		for (const auto& port : ports) {
		mLastPortVolume[port] = volume;
		}
		return NO_ERROR;
		}

		status_t setVoiceVolume(float volume, int /delayMs/) override {
		mLastVoiceVolume = volume;
		return NO_ERROR;
		}

		float getLastPortVolume(audio_port_handle_t port) {
		return mLastPortVolume[port];
		}

		float getLastStreamVolume(audio_stream_type_t stream) {
		return mLastStreamVolume[stream];
		}

		float getLastVoiceVolume() const {
		return mLastVoiceVolume;
		}

		private:
		std::unordered_map<audio_port_handle_t, float> mLastPortVolume;
		std::unordered_map<audio_stream_type_t, float> mLastStreamVolume;
		float mLastVoiceVolume;
		};

		} // namespace

		class AudioPolicyManagerTestAbsoluteVolume : public AudioPolicyManagerTestWithConfigurationFile {
		protected:
		void SetUp() override;
		void TearDown() override;

		AudioPolicyManagerTestClientVolumeChecker* mVolumeCheckerClient;

		AudioPolicyManagerTestClient* getClient() override {
		return mVolumeCheckerClient = new AudioPolicyManagerTestClientVolumeChecker();
		}

		void setVolumeIndexForAttributesForDrivingStream(bool withPortApi);
		void setVolumeIndexForAttributesForNonDrivingStream(bool withPortApi);
		void setVolumeIndexForDtmfAttributesOnSco(bool withPortApi);

		audio_port_handle_t mOutputPortId = AUDIO_PORT_HANDLE_NONE;
		static constexpr audio_attributes_t sMediaAttr = {
		.content_type = AUDIO_CONTENT_TYPE_MUSIC,
		.usage = AUDIO_USAGE_MEDIA,
		};
		static constexpr audio_attributes_t sNotifAttr = {
		.content_type = AUDIO_CONTENT_TYPE_SONIFICATION,
		.usage = AUDIO_USAGE_NOTIFICATION,
		};
		static constexpr audio_attributes_t sVoiceCallAttr = {
		.content_type = AUDIO_CONTENT_TYPE_SPEECH,
		.usage = AUDIO_USAGE_VOICE_COMMUNICATION,
		};
		static constexpr audio_attributes_t sDtmfAttr = {
		.content_type = AUDIO_CONTENT_TYPE_UNKNOWN,
		.usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING,
		};

		static constexpr char sDefBtAddress[] = "00:11:22:33:44:55";
		};

		void AudioPolicyManagerTestAbsoluteVolume::SetUp() {
		ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestWithConfigurationFile::SetUp());

		mManager->setDeviceAbsoluteVolumeEnabled(AUDIO_DEVICE_OUT_USB_DEVICE, "", /enabled=/true,
		AUDIO_STREAM_MUSIC);
		}

		void AudioPolicyManagerTestAbsoluteVolume::TearDown() {
		mManager->setPhoneState(AUDIO_MODE_NORMAL);

		ASSERT_EQ(NO_ERROR, mManager->stopOutput(mOutputPortId));
		ASSERT_EQ(NO_ERROR, mManager->releaseOutput(mOutputPortId));

		ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestWithConfigurationFile::TearDown());
		}

		void AudioPolicyManagerTestAbsoluteVolume::setVolumeIndexForAttributesForDrivingStream(
		bool withPortApi) {
		DeviceIdVector selectedDeviceIds;
		audio_io_handle_t mediaOutput = AUDIO_IO_HANDLE_NONE;
		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
		AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
		"", "", AUDIO_FORMAT_PCM_16_BIT));
		ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
		AUDIO_CHANNEL_OUT_STEREO, 48000,
		AUDIO_OUTPUT_FLAG_NONE,
		&mediaOutput, &mOutputPortId, sMediaAttr));
		ASSERT_EQ(NO_ERROR, mManager->startOutput(mOutputPortId));

		EXPECT_EQ(NO_ERROR, mManager->setVolumeIndexForAttributes(sMediaAttr, /index=/1,
		/muted=/false,
		AUDIO_DEVICE_OUT_USB_DEVICE));

		if (withPortApi) {
		EXPECT_EQ(1.f, mVolumeCheckerClient->getLastPortVolume(mOutputPortId));
		} else {
		EXPECT_EQ(1.f, mVolumeCheckerClient->getLastStreamVolume(AUDIO_STREAM_MUSIC));
		}

		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
		AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
		"", "", AUDIO_FORMAT_DEFAULT));
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForAttributesForDrivingStreamWithPortApi,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForAttributesForDrivingStream(/withPortApi=/true);
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForAttributesForDrivingStreamWithStreamApi,
		REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForAttributesForDrivingStream(/withPortApi=/false);
		}

		void AudioPolicyManagerTestAbsoluteVolume::setVolumeIndexForAttributesForNonDrivingStream(
		bool withPortApi) {
		DeviceIdVector selectedDeviceIds;
		audio_io_handle_t notifOutput = AUDIO_IO_HANDLE_NONE;
		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
		AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
		"", "", AUDIO_FORMAT_PCM_16_BIT));
		ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
		AUDIO_CHANNEL_OUT_STEREO, 48000,
		AUDIO_OUTPUT_FLAG_NONE,
		&notifOutput, &mOutputPortId, sNotifAttr));
		ASSERT_EQ(NO_ERROR, mManager->startOutput(mOutputPortId));

		EXPECT_EQ(NO_ERROR, mManager->setVolumeIndexForAttributes(sNotifAttr, /index=/1,
		/muted=/false,
		AUDIO_DEVICE_OUT_USB_DEVICE));

		if (withPortApi) {
		EXPECT_GT(1.f, mVolumeCheckerClient->getLastPortVolume(mOutputPortId));
		} else {
		EXPECT_GT(1.f, mVolumeCheckerClient->getLastStreamVolume(AUDIO_STREAM_NOTIFICATION));
		}

		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
		AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
		"", "", AUDIO_FORMAT_DEFAULT));
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForAttributesForNonDrivingStreamWithPortApi,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForAttributesForNonDrivingStream(/withPortApi=/true);
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForAttributesForNonDrivingStreamWithStreamApi,
		REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForAttributesForNonDrivingStream(/withPortApi=/false);
		}

		TEST_F(AudioPolicyManagerTestAbsoluteVolume, SetVolumeIndexForVoiceCallAttributesNoScoBle) {
		mManager->setPhoneState(AUDIO_MODE_IN_COMMUNICATION);

		DeviceIdVector selectedDeviceIds;
		audio_io_handle_t voiceOutput = AUDIO_IO_HANDLE_NONE;
		ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
		AUDIO_CHANNEL_OUT_STEREO, 48000,
		AUDIO_OUTPUT_FLAG_PRIMARY,
		&voiceOutput, &mOutputPortId, sVoiceCallAttr));
		ASSERT_EQ(NO_ERROR, mManager->startOutput(mOutputPortId));

		EXPECT_EQ(NO_ERROR, mManager->setVolumeIndexForAttributes(sVoiceCallAttr, /index=/1,
		/muted=/false,
		AUDIO_DEVICE_OUT_USB_DEVICE));

		// setVoiceVolume is sent with actual value if no sco/ble device is connected
		EXPECT_GT(1.f, mVolumeCheckerClient->getLastVoiceVolume());
		}

		TEST_F(AudioPolicyManagerTestAbsoluteVolume, SetVolumeIndexForVoiceCallAttributesOnSco) {
		mManager->setPhoneState(AUDIO_MODE_IN_COMMUNICATION);
		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
		AUDIO_DEVICE_OUT_BLUETOOTH_SCO, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
		sDefBtAddress, "", AUDIO_FORMAT_DEFAULT));

		const AudioDeviceTypeAddr scoOutputDevice(AUDIO_DEVICE_OUT_BLUETOOTH_SCO, sDefBtAddress);
		const AudioDeviceTypeAddrVector outputDevices = {scoOutputDevice};
		ASSERT_EQ(NO_ERROR, mManager->setDevicesRoleForStrategy(
		mManager->getStrategyForStream(AUDIO_STREAM_VOICE_CALL),
		DEVICE_ROLE_PREFERRED, outputDevices));

		DeviceIdVector selectedDeviceIds;
		audio_io_handle_t voiceOutput = AUDIO_IO_HANDLE_NONE;
		ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
		AUDIO_CHANNEL_OUT_STEREO, 48000,
		AUDIO_OUTPUT_FLAG_PRIMARY,
		&voiceOutput, &mOutputPortId, sVoiceCallAttr));
		ASSERT_EQ(NO_ERROR, mManager->startOutput(mOutputPortId));

		EXPECT_EQ(NO_ERROR, mManager->setVolumeIndexForAttributes(sVoiceCallAttr, /index=/1,
		/muted=/false,
		AUDIO_DEVICE_OUT_BLUETOOTH_SCO));

		EXPECT_EQ(1.f, mVolumeCheckerClient->getLastVoiceVolume());

		EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_BLUETOOTH_SCO,
		AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
		sDefBtAddress, "",
		AUDIO_FORMAT_DEFAULT));
		EXPECT_EQ(NO_ERROR, mManager->clearDevicesRoleForStrategy(
		mManager->getStrategyForStream(AUDIO_STREAM_VOICE_CALL),
		DEVICE_ROLE_PREFERRED));
		}

		void AudioPolicyManagerTestAbsoluteVolume::setVolumeIndexForDtmfAttributesOnSco(bool withPortApi) {
		mManager->setPhoneState(AUDIO_MODE_IN_COMMUNICATION);
		ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
		AUDIO_DEVICE_OUT_BLUETOOTH_SCO, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
		sDefBtAddress, "", AUDIO_FORMAT_DEFAULT));

		const AudioDeviceTypeAddr scoOutputDevice(AUDIO_DEVICE_OUT_BLUETOOTH_SCO, sDefBtAddress);
		const AudioDeviceTypeAddrVector outputDevices = {scoOutputDevice};
		ASSERT_EQ(NO_ERROR, mManager->setDevicesRoleForStrategy(
		mManager->getStrategyForStream(AUDIO_STREAM_VOICE_CALL),
		DEVICE_ROLE_PREFERRED, outputDevices));

		DeviceIdVector selectedDeviceIds;
		audio_io_handle_t dtmfOutput = AUDIO_IO_HANDLE_NONE;
		ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
		AUDIO_CHANNEL_OUT_STEREO, 48000,
		AUDIO_OUTPUT_FLAG_PRIMARY,
		&dtmfOutput, &mOutputPortId, sDtmfAttr));
		ASSERT_EQ(NO_ERROR, mManager->startOutput(mOutputPortId));

		EXPECT_EQ(NO_ERROR, mManager->setVolumeIndexForAttributes(sDtmfAttr, /index=/1,
		/muted=/false,
		AUDIO_DEVICE_OUT_BLUETOOTH_SCO));

		if (withPortApi) {
		EXPECT_EQ(1.f, mVolumeCheckerClient->getLastPortVolume(mOutputPortId));
		} else {
		EXPECT_EQ(1.f, mVolumeCheckerClient->getLastStreamVolume(AUDIO_STREAM_DTMF));
		}

		EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_BLUETOOTH_SCO,
		AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
		sDefBtAddress, "",
		AUDIO_FORMAT_DEFAULT));
		EXPECT_EQ(NO_ERROR, mManager->clearDevicesRoleForStrategy(
		mManager->getStrategyForStream(AUDIO_STREAM_VOICE_CALL),
		DEVICE_ROLE_PREFERRED));
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForDtmfAttributesOnScoWithPortApi,
		REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForDtmfAttributesOnSco(/withPortApi=/true);
		}

		TEST_F_WITH_FLAGS(AudioPolicyManagerTestAbsoluteVolume,
		SetVolumeIndexForDtmfAttributesOnScoWithStreamApi,
		REQUIRES_FLAGS_DISABLED(ACONFIG_FLAG(com::android::media::audioserver,
		portid_volume_management))) {
		setVolumeIndexForDtmfAttributesOnSco(/withPortApi=/false);
		}

		class AudioPolicyManagerTestBitPerfectBase : public AudioPolicyManagerTestWithConfigurationFile {
		protected:
		void SetUp() override;

services/audiopolicy/tests/resources/test_audio_policy_configuration.xml

+1 −1

Original line number	Diff line number	Diff line
		@@ -113,7 +113,7 @@
		<route type="mix" sink="Hdmi"
		sources="primary output"/>
		<route type="mix" sink="BT SCO"
		sources="mixport_bt_hfp_output,voip_rx"/>
		sources="mixport_bt_hfp_output,voip_rx,primary output"/>
		<route type="mix" sink="mixport_bt_hfp_input"
		sources="BT SCO Headset Mic"/>
		<route type="mix" sink="BT A2DP Out"