services/audioflinger/RecordTracks.h - LeafOS-Project/android_frameworks_av - Gitiles

 /*
 **
 ** Copyright 2012, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */

 #pragma once

 #include "TrackBase.h"

 #include <android/content/AttributionSourceState.h>
 #include <audio_utils/mutex.h>
 #include <datapath/AudioStreamIn.h> // struct Source

 namespace android {

 // record track
 class RecordTrack : public TrackBase, public virtual IAfRecordTrack {
 public:
     RecordTrack(IAfRecordThread* thread,
                                 const sp<Client>& client,
                                 const audio_attributes_t& attr,
                                 uint32_t sampleRate,
                                 audio_format_t format,
                                 audio_channel_mask_t channelMask,
                                 size_t frameCount,
                                 void *buffer,
                                 size_t bufferSize,
                                 audio_session_t sessionId,
                                 pid_t creatorPid,
                                 const AttributionSourceState& attributionSource,
                                 audio_input_flags_t flags,
                                 track_type type,
                                 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
                                 int32_t startFrames = -1);
     ~RecordTrack() override;
     status_t initCheck() const final;

     status_t start(AudioSystem::sync_event_t event, audio_session_t triggerSession) final;
     void stop() final;
     void destroy() final;
     void invalidate() final;

             // clear the buffer overflow flag
     void clearOverflow() final { mOverflow = false; }
             // set the buffer overflow flag and return previous value
     bool setOverflow() final { bool tmp = mOverflow; mOverflow = true;
                                                 return tmp; }

     void appendDumpHeader(String8& result) const final;
     void appendDump(String8& result, bool active) const final;

     void handleSyncStartEvent(const sp<audioflinger::SyncEvent>& event) final;
     void clearSyncStartEvent() final;

     void updateTrackFrameInfo(int64_t trackFramesReleased,
                                              int64_t sourceFramesRead,
                                              uint32_t halSampleRate,
                                              const ExtendedTimestamp &timestamp) final;

     bool isFastTrack() const final { return (mFlags & AUDIO_INPUT_FLAG_FAST) != 0; }
     bool isDirect() const final
                                 { return (mFlags & AUDIO_INPUT_FLAG_DIRECT) != 0; }

     void setSilenced(bool silenced) final { if (!isPatchTrack()) mSilenced = silenced; }
     bool isSilenced() const final { return mSilenced; }

     status_t getActiveMicrophones(
             std::vector<media::MicrophoneInfoFw>* activeMicrophones) const final;

     status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) final;
     status_t setPreferredMicrophoneFieldDimension(float zoom) final;
     status_t shareAudioHistory(const std::string& sharedAudioPackageName,
             int64_t sharedAudioStartMs) final;
     int32_t startFrames() const final { return mStartFrames; }

     using SinkMetadatas = std::vector<record_track_metadata_v7_t>;
     using MetadataInserter = std::back_insert_iterator<SinkMetadatas>;
     void copyMetadataTo(MetadataInserter& backInserter) const final;

     AudioBufferProvider::Buffer& sinkBuffer() final { return mSink; }
     audioflinger::SynchronizedRecordState& synchronizedRecordState() final {
         return mSynchronizedRecordState;
     }
     RecordBufferConverter* recordBufferConverter() const final { return mRecordBufferConverter; }
     ResamplerBufferProvider* resamplerBufferProvider() const final {
         return mResamplerBufferProvider;
     }

 private:
     DISALLOW_COPY_AND_ASSIGN(RecordTrack);

 protected:
     // AudioBufferProvider interface
     status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
     // releaseBuffer() not overridden

 private:

     bool                mOverflow;  // overflow on most recent attempt to fill client buffer

             AudioBufferProvider::Buffer mSink;  // references client's buffer sink in shared memory

             // sync event triggering actual audio capture. Frames read before this event will
             // be dropped and therefore not read by the application.
             sp<audioflinger::SyncEvent>        mSyncStartEvent;

             audioflinger::SynchronizedRecordState
                     mSynchronizedRecordState{mSampleRate}; // sampleRate defined in base

             // used by resampler to find source frames
             ResamplerBufferProvider* mResamplerBufferProvider;

             // used by the record thread to convert frames to proper destination format
             RecordBufferConverter              *mRecordBufferConverter;
             audio_input_flags_t                mFlags;

             bool                               mSilenced;

             std::string                        mSharedAudioPackageName = {};
             int32_t                            mStartFrames = -1;
 };

 // playback track, used by PatchPanel
 class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord {
 public:
     PatchRecord(IAfRecordThread* recordThread,
                 uint32_t sampleRate,
                 audio_channel_mask_t channelMask,
                 audio_format_t format,
                 size_t frameCount,
                 void *buffer,
                 size_t bufferSize,
                 audio_input_flags_t flags,
                 const Timeout& timeout = {},
                 audio_source_t source = AUDIO_SOURCE_DEFAULT);
     ~PatchRecord() override;

     Source* getSource() override { return nullptr; }

     // AudioBufferProvider interface
     status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
     void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;

     // PatchProxyBufferProvider interface
     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) final {
         return writeFrames(this, src, frameCount, frameSize);
     }

 protected:
     /** Write the source data into the buffer provider. @return written frame count. */
     static size_t writeFrames(AudioBufferProvider* dest, const void* src,
             size_t frameCount, size_t frameSize);

 };  // end of PatchRecord

 class PassthruPatchRecord : public PatchRecord, public Source {
 public:
     PassthruPatchRecord(IAfRecordThread* recordThread,
                         uint32_t sampleRate,
                         audio_channel_mask_t channelMask,
                         audio_format_t format,
                         size_t frameCount,
                         audio_input_flags_t flags,
                         audio_source_t source = AUDIO_SOURCE_DEFAULT);

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

     // Source interface
     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) final;
     void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;

     // PatchProxyBufferProvider interface
     // This interface is used from DirectOutputThread to acquire data from HAL.
     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
     struct PatchRecordAudioBufferProvider : public AudioBufferProvider {
         explicit PatchRecordAudioBufferProvider(PassthruPatchRecord& passthru) :
                 mPassthru(passthru) {}
         status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override {
             return mPassthru.PatchRecord::getNextBuffer(buffer);
         }
         void releaseBuffer(AudioBufferProvider::Buffer* buffer) override {
             return mPassthru.PatchRecord::releaseBuffer(buffer);
         }
     private:
         PassthruPatchRecord& mPassthru;
     };

     sp<StreamInHalInterface> obtainStream(sp<IAfThreadBase>* thread);
     audio_utils::mutex& readMutex() const { return mReadMutex; }

     PatchRecordAudioBufferProvider mPatchRecordAudioBufferProvider;
     std::unique_ptr<void, decltype(free)*> mSinkBuffer;  // frame size aligned continuous buffer
     std::unique_ptr<void, decltype(free)*> mStubBuffer;  // buffer used for AudioBufferProvider
     size_t mUnconsumedFrames = 0;
     mutable audio_utils::mutex mReadMutex;
     audio_utils::condition_variable mReadCV;
     size_t mReadBytes = 0; // GUARDED_BY(readMutex())
     status_t mReadError = NO_ERROR; // GUARDED_BY(readMutex())
     int64_t mLastReadFrames = 0;  // accessed on RecordThread only
 };

 } // namespace android
	/*
	**
	** Copyright 2012, The Android Open Source Project
	**
	** Licensed under the Apache License, Version 2.0 (the "License");
	** you may not use this file except in compliance with the License.
	** You may obtain a copy of the License at
	**
	** http://www.apache.org/licenses/LICENSE-2.0
	**
	** Unless required by applicable law or agreed to in writing, software
	** distributed under the License is distributed on an "AS IS" BASIS,
	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	** See the License for the specific language governing permissions and
	** limitations under the License.
	*/

	#pragma once

	#include "TrackBase.h"

	#include <android/content/AttributionSourceState.h>
	#include <audio_utils/mutex.h>
	#include <datapath/AudioStreamIn.h> // struct Source

	namespace android {

	// record track
	class RecordTrack : public TrackBase, public virtual IAfRecordTrack {
	public:
	RecordTrack(IAfRecordThread* thread,
	const sp<Client>& client,
	const audio_attributes_t& attr,
	uint32_t sampleRate,
	audio_format_t format,
	audio_channel_mask_t channelMask,
	size_t frameCount,
	void *buffer,
	size_t bufferSize,
	audio_session_t sessionId,
	pid_t creatorPid,
	const AttributionSourceState& attributionSource,
	audio_input_flags_t flags,
	track_type type,
	audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
	int32_t startFrames = -1);
	~RecordTrack() override;
	status_t initCheck() const final;

	status_t start(AudioSystem::sync_event_t event, audio_session_t triggerSession) final;
	void stop() final;
	void destroy() final;
	void invalidate() final;

	// clear the buffer overflow flag
	void clearOverflow() final { mOverflow = false; }
	// set the buffer overflow flag and return previous value
	bool setOverflow() final { bool tmp = mOverflow; mOverflow = true;
	return tmp; }

	void appendDumpHeader(String8& result) const final;
	void appendDump(String8& result, bool active) const final;

	void handleSyncStartEvent(const sp<audioflinger::SyncEvent>& event) final;
	void clearSyncStartEvent() final;

	void updateTrackFrameInfo(int64_t trackFramesReleased,
	int64_t sourceFramesRead,
	uint32_t halSampleRate,
	const ExtendedTimestamp &timestamp) final;

	bool isFastTrack() const final { return (mFlags & AUDIO_INPUT_FLAG_FAST) != 0; }
	bool isDirect() const final
	{ return (mFlags & AUDIO_INPUT_FLAG_DIRECT) != 0; }

	void setSilenced(bool silenced) final { if (!isPatchTrack()) mSilenced = silenced; }
	bool isSilenced() const final { return mSilenced; }

	status_t getActiveMicrophones(
	std::vector<media::MicrophoneInfoFw>* activeMicrophones) const final;

	status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) final;
	status_t setPreferredMicrophoneFieldDimension(float zoom) final;
	status_t shareAudioHistory(const std::string& sharedAudioPackageName,
	int64_t sharedAudioStartMs) final;
	int32_t startFrames() const final { return mStartFrames; }

	using SinkMetadatas = std::vector<record_track_metadata_v7_t>;
	using MetadataInserter = std::back_insert_iterator<SinkMetadatas>;
	void copyMetadataTo(MetadataInserter& backInserter) const final;

	AudioBufferProvider::Buffer& sinkBuffer() final { return mSink; }
	audioflinger::SynchronizedRecordState& synchronizedRecordState() final {
	return mSynchronizedRecordState;
	}
	RecordBufferConverter* recordBufferConverter() const final { return mRecordBufferConverter; }
	ResamplerBufferProvider* resamplerBufferProvider() const final {
	return mResamplerBufferProvider;
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(RecordTrack);

	protected:
	// AudioBufferProvider interface
	status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
	// releaseBuffer() not overridden

	private:

	bool mOverflow; // overflow on most recent attempt to fill client buffer

	AudioBufferProvider::Buffer mSink; // references client's buffer sink in shared memory

	// sync event triggering actual audio capture. Frames read before this event will
	// be dropped and therefore not read by the application.
	sp<audioflinger::SyncEvent> mSyncStartEvent;

	audioflinger::SynchronizedRecordState
	mSynchronizedRecordState{mSampleRate}; // sampleRate defined in base

	// used by resampler to find source frames
	ResamplerBufferProvider* mResamplerBufferProvider;

	// used by the record thread to convert frames to proper destination format
	RecordBufferConverter *mRecordBufferConverter;
	audio_input_flags_t mFlags;

	bool mSilenced;

	std::string mSharedAudioPackageName = {};
	int32_t mStartFrames = -1;
	};

	// playback track, used by PatchPanel
	class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord {
	public:
	PatchRecord(IAfRecordThread* recordThread,
	uint32_t sampleRate,
	audio_channel_mask_t channelMask,
	audio_format_t format,
	size_t frameCount,
	void *buffer,
	size_t bufferSize,
	audio_input_flags_t flags,
	const Timeout& timeout = {},
	audio_source_t source = AUDIO_SOURCE_DEFAULT);
	~PatchRecord() override;

	Source* getSource() override { return nullptr; }

	// AudioBufferProvider interface
	status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override;
	void releaseBuffer(AudioBufferProvider::Buffer* buffer) override;

	// PatchProxyBufferProvider interface
	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) final {
	return writeFrames(this, src, frameCount, frameSize);
	}

	protected:
	/** Write the source data into the buffer provider. @return written frame count. */
	static size_t writeFrames(AudioBufferProvider* dest, const void* src,
	size_t frameCount, size_t frameSize);

	}; // end of PatchRecord

	class PassthruPatchRecord : public PatchRecord, public Source {
	public:
	PassthruPatchRecord(IAfRecordThread* recordThread,
	uint32_t sampleRate,
	audio_channel_mask_t channelMask,
	audio_format_t format,
	size_t frameCount,
	audio_input_flags_t flags,
	audio_source_t source = AUDIO_SOURCE_DEFAULT);

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

	// Source interface
	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) final;
	void releaseBuffer(AudioBufferProvider::Buffer* buffer) final;

	// PatchProxyBufferProvider interface
	// This interface is used from DirectOutputThread to acquire data from HAL.
	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
	struct PatchRecordAudioBufferProvider : public AudioBufferProvider {
	explicit PatchRecordAudioBufferProvider(PassthruPatchRecord& passthru) :
	mPassthru(passthru) {}
	status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override {
	return mPassthru.PatchRecord::getNextBuffer(buffer);
	}
	void releaseBuffer(AudioBufferProvider::Buffer* buffer) override {
	return mPassthru.PatchRecord::releaseBuffer(buffer);
	}
	private:
	PassthruPatchRecord& mPassthru;
	};

	sp<StreamInHalInterface> obtainStream(sp<IAfThreadBase>* thread);
	audio_utils::mutex& readMutex() const { return mReadMutex; }

	PatchRecordAudioBufferProvider mPatchRecordAudioBufferProvider;
	std::unique_ptr<void, decltype(free)*> mSinkBuffer; // frame size aligned continuous buffer
	std::unique_ptr<void, decltype(free)*> mStubBuffer; // buffer used for AudioBufferProvider
	size_t mUnconsumedFrames = 0;
	mutable audio_utils::mutex mReadMutex;
	audio_utils::condition_variable mReadCV;
	size_t mReadBytes = 0; // GUARDED_BY(readMutex())
	status_t mReadError = NO_ERROR; // GUARDED_BY(readMutex())
	int64_t mLastReadFrames = 0; // accessed on RecordThread only
	};

	} // namespace android