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

Commit 672d39a3 authored by Andy Hung's avatar Andy Hung Committed by Android (Google) Code Review
Browse files

Merge "AudioFlinger: Add PatchRecord PatchTrack interfaces"

parents 01ea86c3 ca9be059

services/audioflinger/AudioFlinger.h

+0 −10
Original line number Diff line number Diff line
@@ -594,16 +594,6 @@ private: 
        bool        mute;

    };



    // Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).

    struct Source

    {

        virtual ~Source() = default;

        // The following methods have the same signatures as in StreamHalInterface.

        virtual status_t read(void *buffer, size_t bytes, size_t *read) = 0;

        virtual status_t getCapturePosition(int64_t *frames, int64_t *time) = 0;

        virtual status_t standby() = 0;

    };



    // --- PlaybackThread ---



#include "Threads.h"

services/audioflinger/IAfTrack.h

+36 −0
Original line number Diff line number Diff line
@@ -388,4 +388,40 @@ public: 
    virtual void copyMetadataTo(MetadataInserter& backInserter) const = 0; // see IAfTrack

};



// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.

// it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)

class PatchProxyBufferProvider {

public:

    virtual ~PatchProxyBufferProvider() = default;

    virtual bool producesBufferOnDemand() const = 0;

    virtual status_t obtainBuffer(

            Proxy::Buffer* buffer, const struct timespec* requested = nullptr) = 0;

    virtual void releaseBuffer(Proxy::Buffer* buffer) = 0;

};



class IAfPatchTrackBase : public virtual RefBase {

public:

    virtual void setPeerTimeout(std::chrono::nanoseconds timeout) = 0;

    virtual void setPeerProxy(const sp<IAfPatchTrackBase>& proxy, bool holdReference) = 0;

    virtual void clearPeerProxy() = 0;

    virtual PatchProxyBufferProvider* asPatchProxyBufferProvider() = 0;

};



class IAfPatchTrack : public virtual IAfTrack, public virtual IAfPatchTrackBase {};



// Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).

struct Source {

    virtual ~Source() = default;

    // The following methods have the same signatures as in StreamHalInterface.

    virtual status_t read(void* buffer, size_t bytes, size_t* read) = 0;

    virtual status_t getCapturePosition(int64_t* frames, int64_t* time) = 0;

    virtual status_t standby() = 0;

};



class IAfPatchRecord : public virtual IAfRecordTrack, public virtual IAfPatchTrackBase {

public:

    virtual Source* getSource() = 0;

    virtual size_t writeFrames(const void* src, size_t frameCount, size_t frameSize) = 0;

};



}  // namespace android

services/audioflinger/PlaybackTracks.h

+1 −1
Original line number Diff line number Diff line
@@ -449,7 +449,7 @@ private: 
};  // end of OutputTrack



// playback track, used by PatchPanel

class PatchTrack : public Track, public PatchTrackBase {

class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {

public:



                        PatchTrack(PlaybackThread *playbackThread,

services/audioflinger/RecordTracks.h

+19 −19
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ 
#endif



// record track

class RecordTrack : public TrackBase, public IAfRecordTrack {

class RecordTrack : public TrackBase, public virtual IAfRecordTrack {

public:

                        RecordTrack(RecordThread *thread,

                                const sp<Client>& client,
@@ -119,7 +119,7 @@ private: 
};



// playback track, used by PatchPanel

class PatchRecord : public RecordTrack, public PatchTrackBase {

class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord {

public:



    PatchRecord(RecordThread *recordThread,
@@ -132,20 +132,20 @@ public: 
                audio_input_flags_t flags,

                const Timeout& timeout = {},

                audio_source_t source = AUDIO_SOURCE_DEFAULT);

    virtual             ~PatchRecord();

    ~PatchRecord() override;



    virtual Source* getSource() { return nullptr; }

    Source* getSource() override { return nullptr; }



    // AudioBufferProvider interface

    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);

    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);

    status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;

    void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;



    // PatchProxyBufferProvider interface

    virtual status_t    obtainBuffer(Proxy::Buffer *buffer,

                                     const struct timespec *timeOut = NULL);

    virtual void        releaseBuffer(Proxy::Buffer *buffer);

    status_t obtainBuffer(Proxy::Buffer* buffer,

                                     const struct timespec* timeOut = nullptr) override;

    void releaseBuffer(Proxy::Buffer* buffer) override;



    size_t writeFrames(const void* src, size_t frameCount, size_t frameSize) {

    size_t writeFrames(const void* src, size_t frameCount, size_t frameSize) final {

        return writeFrames(this, src, frameCount, frameSize);

    }
@@ -166,25 +166,25 @@ public: 
                        audio_input_flags_t flags,

                        audio_source_t source = AUDIO_SOURCE_DEFAULT);



    Source* getSource() override { return static_cast<Source*>(this); }

    Source* getSource() final { return static_cast<Source*>(this); }



    // Source interface

    status_t read(void *buffer, size_t bytes, size_t *read) override;

    status_t getCapturePosition(int64_t *frames, int64_t *time) override;

    status_t standby() override;

    status_t read(void* buffer, size_t bytes, size_t* read) final;

    status_t getCapturePosition(int64_t* frames, int64_t* time) final;

    status_t standby() final;



    // AudioBufferProvider interface

    // This interface is used by RecordThread to pass the data obtained

    // from HAL or other source to the client. PassthruPatchRecord receives

    // the data in 'obtainBuffer' so these calls are stubbed out.

    status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;

    void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;

    status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final;

    void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;



    // PatchProxyBufferProvider interface

    // This interface is used from DirectOutputThread to acquire data from HAL.

    bool producesBufferOnDemand() const override { return true; }

    status_t obtainBuffer(Proxy::Buffer *buffer, const struct timespec *timeOut = nullptr) override;

    void releaseBuffer(Proxy::Buffer *buffer) override;

    bool producesBufferOnDemand() const final { return true; }

    status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final;

    void releaseBuffer(Proxy::Buffer* buffer) final;



private:

    // This is to use with PatchRecord::writeFrames

services/audioflinger/TrackBase.h

+13 −22
Original line number Diff line number Diff line
@@ -388,37 +388,28 @@ protected: 
    std::optional<mediautils::BatteryStatsAudioHandle> mBatteryStatsHolder;

};



// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.

// it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)

class PatchProxyBufferProvider

{

public:



    virtual ~PatchProxyBufferProvider() = default;



    virtual bool        producesBufferOnDemand() const = 0;

    virtual status_t    obtainBuffer(Proxy::Buffer* buffer,

                                     const struct timespec *requested = NULL) = 0;

    virtual void        releaseBuffer(Proxy::Buffer* buffer) = 0;

};



class PatchTrackBase : public PatchProxyBufferProvider

class PatchTrackBase : public PatchProxyBufferProvider, public virtual IAfPatchTrackBase

{

public:

    using Timeout = std::optional<std::chrono::nanoseconds>;

                        PatchTrackBase(const sp<ClientProxy>& proxy, const ThreadBase& thread,

                                       const Timeout& timeout);

            void        setPeerTimeout(std::chrono::nanoseconds timeout);

            template <typename T>

            void        setPeerProxy(const sp<T> &proxy, bool holdReference) {

            void setPeerTimeout(std::chrono::nanoseconds timeout) final;

            void setPeerProxy(const sp<IAfPatchTrackBase>& proxy, bool holdReference) final {

                if (proxy) {

                    mPeerReferenceHold = holdReference ? proxy : nullptr;

                            mPeerProxy = proxy.get();

                    mPeerProxy = proxy->asPatchProxyBufferProvider();

                } else {

                    clearPeerProxy();

                }

            void        clearPeerProxy() {

            }

            void clearPeerProxy() final {

                            mPeerReferenceHold.clear();

                            mPeerProxy = nullptr;

                        }



            PatchProxyBufferProvider* asPatchProxyBufferProvider() final { return this; }



            bool        producesBufferOnDemand() const override { return false; }



protected: