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

Commit 5a5c4bed authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 12923841 from eea4ddba to 25Q2-release

Change-Id: Icfa5e4620a8176f249ced82fee550a19b24ae504
parents 15959400 eea4ddba
Loading
Loading
Loading
Loading
+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;
+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;
+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') :
+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;
+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"