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

Commit 2fd41e43 authored by Andy Hung's avatar Andy Hung Committed by Automerger Merge Worker
Browse files

Merge "AudioSystem: Add thread safety annotations" into main am: c2dab3d2

parents e4027b85 c2dab3d2
Loading
Loading
Loading
Loading
+1 −0
Original line number Diff line number Diff line
@@ -185,6 +185,7 @@ cc_library {
        "-Wall",
        "-Werror",
        "-Wno-error=deprecated-declarations",
        "-Wthread-safety",
    ],
    sanitize: {
        misc_undefined: [
+66 −73
Original line number Diff line number Diff line
@@ -62,36 +62,37 @@ using media::audio::common::AudioStreamType;
using media::audio::common::AudioUsage;
using media::audio::common::Int;

// client singleton for AudioFlinger binder interface
Mutex AudioSystem::gLock;
Mutex AudioSystem::gLockErrorCallbacks;
Mutex AudioSystem::gLockAPS;
std::mutex AudioSystem::gMutex;
sp<IAudioFlinger> AudioSystem::gAudioFlinger;
sp<IBinder> AudioSystem::gAudioFlingerBinder;
sp<IAudioFlinger> AudioSystem::gLocalAudioFlinger;
sp<AudioSystem::AudioFlingerClient> AudioSystem::gAudioFlingerClient;
std::set<audio_error_callback> AudioSystem::gAudioErrorCallbacks;
dynamic_policy_callback AudioSystem::gDynPolicyCallback = NULL;
record_config_callback AudioSystem::gRecordConfigCallback = NULL;
routing_callback AudioSystem::gRoutingCallback = NULL;
vol_range_init_req_callback AudioSystem::gVolRangeInitReqCallback = NULL;

// Required to be held while calling into gSoundTriggerCaptureStateListener.
class CaptureStateListenerImpl;
std::mutex AudioSystem::gErrorCallbacksMutex;
std::set<audio_error_callback> AudioSystem::gAudioErrorCallbacks;

std::mutex AudioSystem::gSoundTriggerMutex;
sp<CaptureStateListenerImpl> AudioSystem::gSoundTriggerCaptureStateListener;

Mutex gSoundTriggerCaptureStateListenerLock;
sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener = nullptr;
std::mutex AudioSystem::gAPSMutex;
sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;

// Binder for the AudioFlinger service that's passed to this client process from the system server.
// Sets the Binder for the AudioFlinger service, passed to this client process
// from the system server.
// This allows specific isolated processes to access the audio system. Currently used only for the
// HotwordDetectionService.
static sp<IBinder> gAudioFlingerBinder = nullptr;

void AudioSystem::setAudioFlingerBinder(const sp<IBinder>& audioFlinger) {
    if (audioFlinger->getInterfaceDescriptor() != media::IAudioFlingerService::descriptor) {
        ALOGE("setAudioFlingerBinder: received a binder of type %s",
              String8(audioFlinger->getInterfaceDescriptor()).c_str());
        return;
    }
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    if (gAudioFlinger != nullptr) {
        ALOGW("setAudioFlingerBinder: ignoring; AudioFlinger connection already established.");
        return;
@@ -99,10 +100,8 @@ void AudioSystem::setAudioFlingerBinder(const sp<IBinder>& audioFlinger) {
    gAudioFlingerBinder = audioFlinger;
}

static sp<IAudioFlinger> gLocalAudioFlinger; // set if we are local.

status_t AudioSystem::setLocalAudioFlinger(const sp<IAudioFlinger>& af) {
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    if (gAudioFlinger != nullptr) return INVALID_OPERATION;
    gLocalAudioFlinger = af;
    return OK;
@@ -114,7 +113,7 @@ const sp<IAudioFlinger> AudioSystem::getAudioFlingerImpl(bool canStartThreadPool
    sp<AudioFlingerClient> afc;
    bool reportNoError = false;
    {
        Mutex::Autolock _l(gLock);
        std::lock_guard _l(gMutex);
        if (gAudioFlinger != nullptr) {
            return gAudioFlinger;
        }
@@ -169,7 +168,7 @@ const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient() {
    // calling get_audio_flinger() will initialize gAudioFlingerClient if needed
    const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
    if (af == 0) return 0;
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    return gAudioFlingerClient;
}

@@ -305,23 +304,23 @@ String8 AudioSystem::getParameters(const String8& keys) {
// convert volume steps to natural log scale

// change this value to change volume scaling
static const float dBPerStep = 0.5f;
constexpr float kdbPerStep = 0.5f;
// shouldn't need to touch these
static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
static const float dBConvertInverse = 1.0f / dBConvert;
constexpr float kdBConvert = -kdbPerStep * 2.302585093f / 20.0f;
constexpr float kdBConvertInverse = 1.0f / kdBConvert;

float AudioSystem::linearToLog(int volume) {
    // float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
    // float v = volume ? exp(float(100 - volume) * kdBConvert) : 0;
    // ALOGD("linearToLog(%d)=%f", volume, v);
    // return v;
    return volume ? exp(float(100 - volume) * dBConvert) : 0;
    return volume ? exp(float(100 - volume) * kdBConvert) : 0;
}

int AudioSystem::logToLinear(float volume) {
    // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
    // int v = volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
    // ALOGD("logTolinear(%d)=%f", v, volume);
    // return v;
    return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
    return volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
}

/* static */ size_t AudioSystem::calculateMinFrameCount(
@@ -546,7 +545,7 @@ status_t AudioSystem::getFrameCountHAL(audio_io_handle_t ioHandle,


void AudioSystem::AudioFlingerClient::clearIoCache() {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    mIoDescriptors.clear();
    mInBuffSize = 0;
    mInSamplingRate = 0;
@@ -556,7 +555,7 @@ void AudioSystem::AudioFlingerClient::clearIoCache() {

void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused) {
    {
        Mutex::Autolock _l(AudioSystem::gLock);
        std::lock_guard _l(AudioSystem::gMutex);
        AudioSystem::gAudioFlinger.clear();
    }

@@ -584,7 +583,7 @@ Status AudioSystem::AudioFlingerClient::ioConfigChanged(
    audio_port_handle_t deviceId = AUDIO_PORT_HANDLE_NONE;
    std::vector<sp<AudioDeviceCallback>> callbacksToCall;
    {
        Mutex::Autolock _l(mLock);
        std::lock_guard _l(mMutex);
        auto callbacks = std::map<audio_port_handle_t, wp<AudioDeviceCallback>>();

        switch (event) {
@@ -689,8 +688,8 @@ Status AudioSystem::AudioFlingerClient::ioConfigChanged(
        }
    }

    // Callbacks must be called without mLock held. May lead to dead lock if calling for
    // example getRoutedDevice that updates the device and tries to acquire mLock.
    // Callbacks must be called without mMutex held. May lead to dead lock if calling for
    // example getRoutedDevice that updates the device and tries to acquire mMutex.
    for (auto cb  : callbacksToCall) {
        // If callbacksToCall is not empty, it implies ioDesc->getIoHandle() and deviceId are valid
        cb->onAudioDeviceUpdate(ioDesc->getIoHandle(), deviceId);
@@ -709,7 +708,7 @@ Status AudioSystem::AudioFlingerClient::onSupportedLatencyModesChanged(

    std::vector<sp<SupportedLatencyModesCallback>> callbacks;
    {
        Mutex::Autolock _l(mLock);
        std::lock_guard _l(mMutex);
        for (auto callback : mSupportedLatencyModesCallbacks) {
            if (auto ref = callback.promote(); ref != nullptr) {
                callbacks.push_back(ref);
@@ -730,7 +729,7 @@ status_t AudioSystem::AudioFlingerClient::getInputBufferSize(
    if (af == 0) {
        return PERMISSION_DENIED;
    }
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    // Do we have a stale mInBuffSize or are we requesting the input buffer size for new values
    if ((mInBuffSize == 0) || (sampleRate != mInSamplingRate) || (format != mInFormat)
        || (channelMask != mInChannelMask)) {
@@ -765,7 +764,7 @@ AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle) {
}

sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    return getIoDescriptor_l(ioHandle);
}

@@ -773,7 +772,7 @@ status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback(
        const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
        audio_port_handle_t portId) {
    ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    auto& callbacks = mAudioDeviceCallbacks.emplace(
            audioIo,
            std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
@@ -788,7 +787,7 @@ status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(
        const wp<AudioDeviceCallback>& callback __unused, audio_io_handle_t audioIo,
        audio_port_handle_t portId) {
    ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    auto it = mAudioDeviceCallbacks.find(audioIo);
    if (it == mAudioDeviceCallbacks.end()) {
        return INVALID_OPERATION;
@@ -804,7 +803,7 @@ status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(

status_t AudioSystem::AudioFlingerClient::addSupportedLatencyModesCallback(
        const sp<SupportedLatencyModesCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    if (std::find(mSupportedLatencyModesCallbacks.begin(),
                  mSupportedLatencyModesCallbacks.end(),
                  callback) != mSupportedLatencyModesCallbacks.end()) {
@@ -816,7 +815,7 @@ status_t AudioSystem::AudioFlingerClient::addSupportedLatencyModesCallback(

status_t AudioSystem::AudioFlingerClient::removeSupportedLatencyModesCallback(
        const sp<SupportedLatencyModesCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    auto it = std::find(mSupportedLatencyModesCallbacks.begin(),
                                 mSupportedLatencyModesCallbacks.end(),
                                 callback);
@@ -828,55 +827,49 @@ status_t AudioSystem::AudioFlingerClient::removeSupportedLatencyModesCallback(
}

/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb) {
    Mutex::Autolock _l(gLockErrorCallbacks);
    std::lock_guard _l(gErrorCallbacksMutex);
    gAudioErrorCallbacks.insert(cb);
    return reinterpret_cast<uintptr_t>(cb);
}

/* static */ void AudioSystem::removeErrorCallback(uintptr_t cb) {
    Mutex::Autolock _l(gLockErrorCallbacks);
    std::lock_guard _l(gErrorCallbacksMutex);
    gAudioErrorCallbacks.erase(reinterpret_cast<audio_error_callback>(cb));
}

/* static */ void AudioSystem::reportError(status_t err) {
    Mutex::Autolock _l(gLockErrorCallbacks);
    std::lock_guard _l(gErrorCallbacksMutex);
    for (auto callback : gAudioErrorCallbacks) {
        callback(err);
    }
}

/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) {
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    gDynPolicyCallback = cb;
}

/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb) {
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    gRecordConfigCallback = cb;
}

/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb) {
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    gRoutingCallback = cb;
}

/*static*/ void AudioSystem::setVolInitReqCallback(vol_range_init_req_callback cb) {
    Mutex::Autolock _l(gLock);
    std::lock_guard _l(gMutex);
    gVolRangeInitReqCallback = cb;
}

// client singleton for AudioPolicyService binder interface
// protected by gLockAPS
sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;


// establish binder interface to AudioPolicy service
const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
    sp<IAudioPolicyService> ap;
    sp<AudioPolicyServiceClient> apc;
    {
        Mutex::Autolock _l(gLockAPS);
        std::lock_guard _l(gAPSMutex);
        if (gAudioPolicyService == 0) {
            sp<IServiceManager> sm = defaultServiceManager();
            sp<IBinder> binder = sm->waitForService(String16("media.audio_policy"));
@@ -907,7 +900,7 @@ const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
}

void AudioSystem::clearAudioPolicyService() {
    Mutex::Autolock _l(gLockAPS);
    std::lock_guard _l(gAPSMutex);
    gAudioPolicyService.clear();
}

@@ -1510,7 +1503,7 @@ void AudioSystem::clearAudioConfigCache() {
    // called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances
    ALOGV("clearAudioConfigCache()");
    {
        Mutex::Autolock _l(gLock);
        std::lock_guard _l(gMutex);
        if (gAudioFlingerClient != 0) {
            gAudioFlingerClient->clearIoCache();
        }
@@ -1679,7 +1672,7 @@ status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    if (aps == 0) return PERMISSION_DENIED;

    Mutex::Autolock _l(gLockAPS);
    std::lock_guard _l(gAPSMutex);
    if (gAudioPolicyServiceClient == 0) {
        return NO_INIT;
    }
@@ -1695,7 +1688,7 @@ status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callb
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    if (aps == 0) return PERMISSION_DENIED;

    Mutex::Autolock _l(gLockAPS);
    std::lock_guard _l(gAPSMutex);
    if (gAudioPolicyServiceClient == 0) {
        return NO_INIT;
    }
@@ -1710,7 +1703,7 @@ status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallb
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    if (aps == 0) return PERMISSION_DENIED;

    Mutex::Autolock _l(gLockAPS);
    std::lock_guard _l(gAPSMutex);
    if (gAudioPolicyServiceClient == 0) {
        return NO_INIT;
    }
@@ -1725,7 +1718,7 @@ status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCa
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    if (aps == 0) return PERMISSION_DENIED;

    Mutex::Autolock _l(gLockAPS);
    std::lock_guard _l(gAPSMutex);
    if (gAudioPolicyServiceClient == 0) {
        return NO_INIT;
    }
@@ -2583,15 +2576,15 @@ public:
    }

    binder::Status setCaptureState(bool active) override {
        Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
        std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
        mListener->onStateChanged(active);
        return binder::Status::ok();
    }

    void binderDied(const wp<IBinder>&) override {
        Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
        std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
        mListener->onServiceDied();
        gSoundTriggerCaptureStateListener = nullptr;
        AudioSystem::gSoundTriggerCaptureStateListener = nullptr;
    }

private:
@@ -2610,7 +2603,7 @@ status_t AudioSystem::registerSoundTriggerCaptureStateListener(
        return PERMISSION_DENIED;
    }

    Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
    std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
    gSoundTriggerCaptureStateListener = new CaptureStateListenerImpl(aps, listener);
    gSoundTriggerCaptureStateListener->init();

@@ -2733,7 +2726,7 @@ status_t AudioSystem::clearPreferredMixerAttributes(const audio_attributes_t *at

int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
        const sp<AudioPortCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
        if (mAudioPortCallbacks[i] == callback) {
            return -1;
@@ -2745,7 +2738,7 @@ int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(

int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
        const sp<AudioPortCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    size_t i;
    for (i = 0; i < mAudioPortCallbacks.size(); i++) {
        if (mAudioPortCallbacks[i] == callback) {
@@ -2761,7 +2754,7 @@ int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(


Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
        mAudioPortCallbacks[i]->onAudioPortListUpdate();
    }
@@ -2769,7 +2762,7 @@ Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
}

Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
        mAudioPortCallbacks[i]->onAudioPatchListUpdate();
    }
@@ -2779,7 +2772,7 @@ Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
// ----------------------------------------------------------------------------
int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
        const sp<AudioVolumeGroupCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
        if (mAudioVolumeGroupCallback[i] == callback) {
            return -1;
@@ -2791,7 +2784,7 @@ int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(

int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
        const sp<AudioVolumeGroupCallback>& callback) {
    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    size_t i;
    for (i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
        if (mAudioVolumeGroupCallback[i] == callback) {
@@ -2811,7 +2804,7 @@ Status AudioSystem::AudioPolicyServiceClient::onAudioVolumeGroupChanged(int32_t
            aidl2legacy_int32_t_volume_group_t(group));
    int flagsLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(flags));

    Mutex::Autolock _l(mLock);
    std::lock_guard _l(mMutex);
    for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
        mAudioVolumeGroupCallback[i]->onAudioVolumeGroupChanged(groupLegacy, flagsLegacy);
    }
@@ -2827,7 +2820,7 @@ Status AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
    int stateLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(state));
    dynamic_policy_callback cb = NULL;
    {
        Mutex::Autolock _l(AudioSystem::gLock);
        std::lock_guard _l(AudioSystem::gMutex);
        cb = gDynPolicyCallback;
    }

@@ -2848,7 +2841,7 @@ Status AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
        AudioSource source) {
    record_config_callback cb = NULL;
    {
        Mutex::Autolock _l(AudioSystem::gLock);
        std::lock_guard _l(AudioSystem::gMutex);
        cb = gRecordConfigCallback;
    }

@@ -2881,7 +2874,7 @@ Status AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
Status AudioSystem::AudioPolicyServiceClient::onRoutingUpdated() {
    routing_callback cb = NULL;
    {
        Mutex::Autolock _l(AudioSystem::gLock);
        std::lock_guard _l(AudioSystem::gMutex);
        cb = gRoutingCallback;
    }

@@ -2894,7 +2887,7 @@ Status AudioSystem::AudioPolicyServiceClient::onRoutingUpdated() {
Status AudioSystem::AudioPolicyServiceClient::onVolumeRangeInitRequest() {
    vol_range_init_req_callback cb = NULL;
    {
        Mutex::Autolock _l(AudioSystem::gLock);
        std::lock_guard _l(AudioSystem::gMutex);
        cb = gVolRangeInitReqCallback;
    }

@@ -2906,7 +2899,7 @@ Status AudioSystem::AudioPolicyServiceClient::onVolumeRangeInitRequest() {

void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused) {
    {
        Mutex::Autolock _l(mLock);
        std::lock_guard _l(mMutex);
        for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
            mAudioPortCallbacks[i]->onServiceDied();
        }
+76 −62

File changed.

Preview size limit exceeded, changes collapsed.