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

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

Snap for 11498394 from 70764b31 to 24Q2-release 

Change-Id: I1fa20dd034fd3ffd47a5625aedfe1a244a84d024
parents 032d0d5b 70764b31

media/libaudioclient/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -188,6 +188,7 @@ cc_library { 
        "-Wall",

        "-Werror",

        "-Wno-error=deprecated-declarations",

        "-Wthread-safety",

    ],

    sanitize: {

        misc_undefined: [

media/libaudioclient/AudioSystem.cpp

+213 −221

File changed.

Preview size limit exceeded, changes collapsed.

media/libaudioclient/include/media/AudioSystem.h

+79 −65
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#include <sys/types.h>



#include <mutex>

#include <set>

#include <vector>
@@ -86,6 +87,7 @@ typedef void (*record_config_callback)(int event, 
typedef void (*routing_callback)();

typedef void (*vol_range_init_req_callback)();



class CaptureStateListenerImpl;

class IAudioFlinger;

class String8;
@@ -95,6 +97,9 @@ class IAudioPolicyService; 


class AudioSystem

{

    friend class AudioFlingerClient;

    friend class AudioPolicyServiceClient;

    friend class CaptureStateListenerImpl;

public:



    // FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp
@@ -177,8 +182,8 @@ public: 
    static status_t setLocalAudioFlinger(const sp<IAudioFlinger>& af);



    // helper function to obtain AudioFlinger service handle

    static const sp<IAudioFlinger> get_audio_flinger();

    static const sp<IAudioFlinger> get_audio_flinger_for_fuzzer();

    static sp<IAudioFlinger> get_audio_flinger();

    static sp<IAudioFlinger> get_audio_flinger_for_fuzzer();



    static float linearToLog(int volume);

    static int logToLinear(float volume);
@@ -402,7 +407,7 @@ public: 
    // and output configuration cache (gOutputs)

    static void clearAudioConfigCache();



    static const sp<media::IAudioPolicyService> get_audio_policy_service();

    static sp<media::IAudioPolicyService> get_audio_policy_service();

    static void clearAudioPolicyService();



    // helpers for android.media.AudioManager.getProperty(), see description there for meaning
@@ -781,18 +786,15 @@ private: 
    class AudioFlingerClient: public IBinder::DeathRecipient, public media::BnAudioFlingerClient

    {

    public:

        AudioFlingerClient() :

            mInBuffSize(0), mInSamplingRate(0),

            mInFormat(AUDIO_FORMAT_DEFAULT), mInChannelMask(AUDIO_CHANNEL_NONE) {

        }

        AudioFlingerClient() = default;



        void clearIoCache();

        void clearIoCache() EXCLUDES(mMutex);

        status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,

                                    audio_channel_mask_t channelMask, size_t* buffSize);

        sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle);

                audio_channel_mask_t channelMask, size_t* buffSize) EXCLUDES(mMutex);

        sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle) EXCLUDES(mMutex);



        // DeathRecipient

        virtual void binderDied(const wp<IBinder>& who);

        void binderDied(const wp<IBinder>& who) final;



        // IAudioFlingerClient
@@ -800,61 +802,72 @@ private: 
        // values for output/input parameters up-to-date in client process

        binder::Status ioConfigChanged(

                media::AudioIoConfigEvent event,

                const media::AudioIoDescriptor& ioDesc) override;

                const media::AudioIoDescriptor& ioDesc) final EXCLUDES(mMutex);



        binder::Status onSupportedLatencyModesChanged(

                int output,

                const std::vector<media::audio::common::AudioLatencyMode>& latencyModes) override;

                const std::vector<media::audio::common::AudioLatencyMode>& latencyModes)

                final EXCLUDES(mMutex);



        status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback,

                                               audio_io_handle_t audioIo,

                                               audio_port_handle_t portId);

                audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex);

        status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback,

                                           audio_io_handle_t audioIo,

                                           audio_port_handle_t portId);

                audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex);



        status_t addSupportedLatencyModesCallback(

                        const sp<SupportedLatencyModesCallback>& callback);

                const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex);

        status_t removeSupportedLatencyModesCallback(

                        const sp<SupportedLatencyModesCallback>& callback);

                const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex);



        audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo);

        audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo) EXCLUDES(mMutex);



    private:

        Mutex                               mLock;

        DefaultKeyedVector<audio_io_handle_t, sp<AudioIoDescriptor> >   mIoDescriptors;

        mutable std::mutex mMutex;

        DefaultKeyedVector<audio_io_handle_t, sp<AudioIoDescriptor>>

                mIoDescriptors GUARDED_BY(mMutex);



        std::map<audio_io_handle_t, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>>

                mAudioDeviceCallbacks;

                mAudioDeviceCallbacks GUARDED_BY(mMutex);



        std::vector<wp<SupportedLatencyModesCallback>>

                mSupportedLatencyModesCallbacks GUARDED_BY(mLock);

                mSupportedLatencyModesCallbacks GUARDED_BY(mMutex);



        // cached values for recording getInputBufferSize() queries

        size_t                              mInBuffSize;    // zero indicates cache is invalid

        uint32_t                            mInSamplingRate;

        audio_format_t                      mInFormat;

        audio_channel_mask_t                mInChannelMask;

        sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle);

        size_t mInBuffSize GUARDED_BY(mMutex) = 0; // zero indicates cache is invalid

        uint32_t mInSamplingRate GUARDED_BY(mMutex) = 0;

        audio_format_t mInFormat GUARDED_BY(mMutex) = AUDIO_FORMAT_DEFAULT;

        audio_channel_mask_t mInChannelMask GUARDED_BY(mMutex) = AUDIO_CHANNEL_NONE;



        sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle) REQUIRES(mMutex);

    };



    class AudioPolicyServiceClient: public IBinder::DeathRecipient,

                                    public media::BnAudioPolicyServiceClient

    {

                                    public media::BnAudioPolicyServiceClient {

    public:

        AudioPolicyServiceClient() {

        AudioPolicyServiceClient() = default;



        int addAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex);



        int removeAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex);



        bool isAudioPortCbEnabled() const EXCLUDES(mMutex) {

            std::lock_guard _l(mMutex);

            return (mAudioPortCallbacks.size() != 0);

        }



        int addAudioPortCallback(const sp<AudioPortCallback>& callback);

        int removeAudioPortCallback(const sp<AudioPortCallback>& callback);

        bool isAudioPortCbEnabled() const { return (mAudioPortCallbacks.size() != 0); }

        int addAudioVolumeGroupCallback(

                const sp<AudioVolumeGroupCallback>& callback) EXCLUDES(mMutex);



        int addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);

        int removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);

        bool isAudioVolumeGroupCbEnabled() const { return (mAudioVolumeGroupCallback.size() != 0); }

        int removeAudioVolumeGroupCallback(

                const sp<AudioVolumeGroupCallback>& callback) EXCLUDES(mMutex);



        bool isAudioVolumeGroupCbEnabled() const EXCLUDES(mMutex) {

            std::lock_guard _l(mMutex);

            return (mAudioVolumeGroupCallback.size() != 0);

        }



        // DeathRecipient

        virtual void binderDied(const wp<IBinder>& who);

        void binderDied(const wp<IBinder>& who) final;



        // IAudioPolicyServiceClient

        binder::Status onAudioVolumeGroupChanged(int32_t group, int32_t flags) override;
@@ -875,9 +888,9 @@ private: 
        binder::Status onVolumeRangeInitRequest();



    private:

        Mutex                               mLock;

        Vector <sp <AudioPortCallback> >    mAudioPortCallbacks;

        Vector <sp <AudioVolumeGroupCallback> > mAudioVolumeGroupCallback;

        mutable std::mutex mMutex;

        Vector<sp<AudioPortCallback>> mAudioPortCallbacks GUARDED_BY(mMutex);

        Vector<sp<AudioVolumeGroupCallback>> mAudioVolumeGroupCallback GUARDED_BY(mMutex);

    };



    static audio_io_handle_t getOutput(audio_stream_type_t stream);
@@ -888,30 +901,31 @@ private: 
    // Invokes all registered error callbacks with the given error code.

    static void reportError(status_t err);



    static sp<AudioFlingerClient> gAudioFlingerClient;

    static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;

    friend class AudioFlingerClient;

    friend class AudioPolicyServiceClient;



    static Mutex gLock;      // protects gAudioFlinger

    static Mutex gLockErrorCallbacks;      // protects gAudioErrorCallbacks

    static Mutex gLockAPS;   // protects gAudioPolicyService and gAudioPolicyServiceClient

    static sp<IAudioFlinger> gAudioFlinger;

    static std::set<audio_error_callback> gAudioErrorCallbacks;

    static dynamic_policy_callback gDynPolicyCallback;

    static record_config_callback gRecordConfigCallback;

    static routing_callback gRoutingCallback;

    static vol_range_init_req_callback gVolRangeInitReqCallback;



    static size_t gInBuffSize;

    // previous parameters for recording buffer size queries

    static uint32_t gPrevInSamplingRate;

    static audio_format_t gPrevInFormat;

    static audio_channel_mask_t gPrevInChannelMask;



    static sp<media::IAudioPolicyService> gAudioPolicyService;

    [[clang::no_destroy]] static std::mutex gMutex;

    [[clang::no_destroy]] static sp<IAudioFlinger> gAudioFlinger GUARDED_BY(gMutex);

    [[clang::no_destroy]] static sp<IBinder> gAudioFlingerBinder GUARDED_BY(gMutex);

    [[clang::no_destroy]] static sp<IAudioFlinger> gLocalAudioFlinger GUARDED_BY(gMutex);

    [[clang::no_destroy]] static sp<AudioFlingerClient> gAudioFlingerClient GUARDED_BY(gMutex);

    static dynamic_policy_callback gDynPolicyCallback GUARDED_BY(gMutex);

    static record_config_callback gRecordConfigCallback GUARDED_BY(gMutex);

    static routing_callback gRoutingCallback GUARDED_BY(gMutex);

    static vol_range_init_req_callback gVolRangeInitReqCallback GUARDED_BY(gMutex);



    [[clang::no_destroy]] static std::mutex gErrorCallbacksMutex;

    [[clang::no_destroy]] static std::set<audio_error_callback> gAudioErrorCallbacks

            GUARDED_BY(gErrorCallbacksMutex);



    [[clang::no_destroy]] static std::mutex gSoundTriggerMutex;

    [[clang::no_destroy]] static sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener

            GUARDED_BY(gSoundTriggerMutex);



    [[clang::no_destroy]] static std::mutex gAPSMutex;

    [[clang::no_destroy]] static sp<media::IAudioPolicyService> gAudioPolicyService

            GUARDED_BY(gAPSMutex);

    [[clang::no_destroy]] static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient

            GUARDED_BY(gAPSMutex);

};



};  // namespace android

}  // namespace android



#endif  /*ANDROID_AUDIOSYSTEM_H_*/

media/libaudioclient/tests/audio_test_utils.cpp

+6 −2
Original line number Diff line number Diff line
@@ -565,12 +565,14 @@ status_t listAudioPorts(std::vector<audio_port_v7>& portsVec) { 
    int attempts = 5;

    status_t status;

    unsigned int generation1, generation;

    unsigned int numPorts = 0;

    unsigned int numPorts;

    do {

        if (attempts-- < 0) {

            status = TIMED_OUT;

            break;

        }

        // query for number of ports.

        numPorts = 0;

        status = AudioSystem::listAudioPorts(AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_NONE, &numPorts,

                                             nullptr, &generation1);

        if (status != NO_ERROR) {
@@ -622,12 +624,14 @@ status_t listAudioPatches(std::vector<struct audio_patch>& patchesVec) { 
    int attempts = 5;

    status_t status;

    unsigned int generation1, generation;

    unsigned int numPatches = 0;

    unsigned int numPatches;

    do {

        if (attempts-- < 0) {

            status = TIMED_OUT;

            break;

        }

        // query for number of patches.

        numPatches = 0;

        status = AudioSystem::listAudioPatches(&numPatches, nullptr, &generation1);

        if (status != NO_ERROR) {

            ALOGE("AudioSystem::listAudioPatches returned error %d", status);

media/module/codecserviceregistrant/CodecServiceRegistrant.cpp

+15 −13
Original line number Diff line number Diff line
@@ -819,19 +819,21 @@ extern "C" void RegisterCodecServices() { 
    }



    bool registered = false;

    if (platformVersion >= __ANDROID_API_V__) {

    const std::string aidlServiceName =

        std::string(c2_aidl::IComponentStore::descriptor) + "/software";

    if (__builtin_available(android __ANDROID_API_S__, *)) {

        if (AServiceManager_isDeclared(aidlServiceName.c_str())) {

            if (!aidlStore) {

                aidlStore = ::ndk::SharedRefBase::make<c2_aidl::utils::ComponentStore>(

                        std::make_shared<H2C2ComponentStore>(nullptr));

            }

        const std::string serviceName =

            std::string(c2_aidl::IComponentStore::descriptor) + "/software";

            binder_exception_t ex = AServiceManager_addService(

                aidlStore->asBinder().get(), serviceName.c_str());

                    aidlStore->asBinder().get(), aidlServiceName.c_str());

            if (ex == EX_NONE) {

                registered = true;

            } else {

            LOG(ERROR) << "Cannot register software Codec2 AIDL service.";

                LOG(WARNING) << "Cannot register software Codec2 AIDL service. Exception: " << ex;

            }

        }

    }