Merge "AudioFlinger: Extract inner Track classes" (691df2d6) · Commits · e / os / android_frameworks_av

services/audioflinger/AudioFlinger.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -2394,7 +2394,7 @@ status_t AudioFlinger::createRecord(const media::CreateRecordRequest& _input,
		CreateRecordInput input = VALUE_OR_RETURN_STATUS(CreateRecordInput::fromAidl(_input));
		CreateRecordOutput output;

		sp<RecordThread::RecordTrack> recordTrack;
		sp<IAfRecordTrack> recordTrack;
		sp<Client> client;
		status_t lStatus;
		audio_session_t sessionId = input.sessionId;
		@@ -3985,7 +3985,7 @@ void AudioFlinger::updateSecondaryOutputsForTrack_l(
		// use an index mask here to create the PatchRecord.
		inChannelMask = audio_channel_mask_out_to_in_index_mask(track->channelMask());
		}
		sp patchRecord = new RecordThread::PatchRecord(nullptr /* thread */,
		sp<IAfPatchRecord> patchRecord = IAfPatchRecord::create(nullptr /* thread */,
		track->sampleRate(),
		inChannelMask,
		track->format(),
		@@ -4005,7 +4005,7 @@ void AudioFlinger::updateSecondaryOutputsForTrack_l(
		// for now, we exclude fast tracks by removing the Fast flag.
		const audio_output_flags_t outputFlags =
		(audio_output_flags_t)(track->getOutputFlags() & ~AUDIO_OUTPUT_FLAG_FAST);
		sp patchTrack = new PlaybackThread::PatchTrack(secondaryThread,
		sp<IAfPatchTrack> patchTrack = IAfPatchTrack::create(secondaryThread,
		track->streamType(),
		track->sampleRate(),
		track->channelMask(),

services/audioflinger/AudioFlinger.h

+15 −8

Original line number	Diff line number	Diff line
		@@ -119,6 +119,7 @@
		#include "android/media/BnEffect.h"

		#include "Client.h"
		#include "ResamplerBufferProvider.h"

		// include AudioFlinger component interfaces
		#include "IAfEffect.h"
		@@ -136,7 +137,6 @@ class EffectsFactoryHalInterface;
		class FastMixer;
		class IAudioManager;
		class PassthruBufferProvider;
		class RecordBufferConverter;
		class ServerProxy;

		// ----------------------------------------------------------------------------
		@@ -571,8 +571,6 @@ public:
		class AsyncCallbackThread;
		class BitPerfectThread;
		private:
		class Track;
		class RecordTrack;
		class DeviceEffectManager;
		// TODO(b/288339104) these should be separate files
		public:
		@@ -581,8 +579,9 @@ public:
		private:
		struct AudioStreamIn;
		struct TeePatch;
		public:
		using TeePatches = std::vector<TeePatch>;

		private:

		struct stream_type_t {
		stream_type_t()
		@@ -708,9 +707,12 @@ private:
		RecordThread *srcThread,
		RecordThread *dstThread);

		public:
		// TODO(b/288339104) cluster together
		status_t moveAuxEffectToIo(int EffectId,
		const sp<PlaybackThread>& dstThread,
		sp<PlaybackThread> *srcThread);
		private:

		// return thread associated with primary hardware device, or NULL
		PlaybackThread *primaryPlaybackThread_l() const;
		@@ -731,7 +733,10 @@ private:

		void removeClient_l(pid_t pid);
		void removeNotificationClient(pid_t pid);
		public:
		// TODO(b/288339104) cluster together
		bool isNonOffloadableGlobalEffectEnabled_l();
		private:
		void onNonOffloadableGlobalEffectEnable();
		bool isSessionAcquired_l(audio_session_t audioSession);

		@@ -789,8 +794,8 @@ private:
		};

		struct TeePatch {
		sp<RecordThread::PatchRecord> patchRecord;
		sp<PlaybackThread::PatchTrack> patchTrack;
		sp<IAfPatchRecord> patchRecord;
		sp<IAfPatchTrack> patchTrack;
		};

		// for mAudioSessionRefs only
		@@ -803,11 +808,13 @@ private:
		int mCnt;
		};

		public:
		// TODO(b/288339104) access by getter,
		mutable Mutex mLock;
		// protects mClients and mNotificationClients.
		// must be locked after mLock and ThreadBase::mLock if both must be locked
		// avoids acquiring AudioFlinger::mLock from inside thread loop.
		public:

		// TODO(b/288339104) access by getter,
		mutable Mutex mClientLock;
		private:
		@@ -916,9 +923,9 @@ private:
		size_t rejectedKVPSize, const String8& rejectedKVPs,
		uid_t callingUid);

		public:
		sp<IAudioManager> getOrCreateAudioManager();

		public:
		// These methods read variables atomically without mLock,
		// though the variables are updated with mLock.
		bool isLowRamDevice() const { return mIsLowRamDevice; }

services/audioflinger/IAfTrack.h

+162 −1

Original line number	Diff line number	Diff line
		@@ -223,6 +223,9 @@ public:
		// Common interface for Playback tracks.
		class IAfTrack : public virtual IAfTrackBase {
		public:
		// FillingStatus is used for suppressing volume ramp at begin of playing
		enum FillingStatus { FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE };

		// createIAudioTrackAdapter() is a static constructor which creates an
		// IAudioTrack AIDL interface adapter from the Track object that
		// may be passed back to the client (if needed).
		@@ -230,6 +233,31 @@ public:
		// Only one AIDL IAudioTrack interface adapter should be created per Track.
		static sp<media::IAudioTrack> createIAudioTrackAdapter(const sp<IAfTrack>& track);

		static sp<IAfTrack> create( // TODO(b/288339104) void*
		void* /* AudioFlinger::PlaybackThread */ thread,
		const sp<Client>& client,
		audio_stream_type_t streamType,
		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,
		const sp<IMemory>& sharedBuffer,
		audio_session_t sessionId,
		pid_t creatorPid,
		const AttributionSourceState& attributionSource,
		audio_output_flags_t flags,
		track_type type,
		audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
		/** default behaviour is to start when there are as many frames
		* ready as possible (aka. Buffer is full). */
		size_t frameCountToBeReady = SIZE_MAX,
		float speed = 1.0f,
		bool isSpatialized = false,
		bool isBitPerfect = false);

		virtual void pause() = 0;
		virtual void flush() = 0;
		virtual audio_stream_type_t streamType() const = 0;
		@@ -316,11 +344,66 @@ public:
		virtual void disable() = 0;
		virtual int& fastIndex() = 0;
		virtual bool isPlaybackRestricted() const = 0;

		// Used by thread only

		virtual bool isPausing() const = 0;
		virtual bool isPaused() const = 0;
		virtual bool isResuming() const = 0;
		virtual bool isReady() const = 0;
		virtual void setPaused() = 0;
		virtual void reset() = 0;
		virtual bool isFlushPending() const = 0;
		virtual void flushAck() = 0;
		virtual bool isResumePending() const = 0;
		virtual void resumeAck() = 0;
		// For direct or offloaded tracks ensure that the pause state is acknowledged
		// by the playback thread in case of an immediate flush.
		virtual bool isPausePending() const = 0;
		virtual void pauseAck() = 0;
		virtual void updateTrackFrameInfo(
		int64_t trackFramesReleased, int64_t sinkFramesWritten, uint32_t halSampleRate,
		const ExtendedTimestamp& timeStamp) = 0;
		virtual sp<IMemory> sharedBuffer() const = 0;

		// Dup with ExtendedAudioBufferProvider
		virtual size_t framesReady() const = 0;

		// presentationComplete checked by frames. (Mixed Tracks).
		// framesWritten is cumulative, never reset, and is shared all tracks
		// audioHalFrames is derived from output latency
		virtual bool presentationComplete(int64_t framesWritten, size_t audioHalFrames) = 0;

		// presentationComplete checked by time. (Direct Tracks).
		virtual bool presentationComplete(uint32_t latencyMs) = 0;

		virtual void resetPresentationComplete() = 0;

		virtual bool hasVolumeController() const = 0;
		virtual void setHasVolumeController(bool hasVolumeController) = 0;
		virtual const sp<AudioTrackServerProxy>& audioTrackServerProxy() const = 0;
		virtual void setCachedVolume(float volume) = 0;
		virtual void setResetDone(bool resetDone) = 0;

		virtual ExtendedAudioBufferProvider* asExtendedAudioBufferProvider() = 0;
		virtual VolumeProvider* asVolumeProvider() = 0;

		// TODO(b/288339104) split into getter/setter
		virtual FillingStatus& fillingStatus() = 0;
		virtual int8_t& retryCount() = 0;
		virtual FastTrackUnderruns& fastTrackUnderruns() = 0;
		};

		// playback track, used by DuplicatingThread
		class IAfOutputTrack : public virtual IAfTrack {
		public:
		// TODO(b/288339104) void*
		static sp<IAfOutputTrack> create(
		void* /* AudioFlinger::PlaybackThread */ playbackThread,
		void* /* AudioFlinger::DuplicatingThread */ sourceThread, uint32_t sampleRate,
		audio_format_t format, audio_channel_mask_t channelMask, size_t frameCount,
		const AttributionSourceState& attributionSource);

		virtual ssize_t write(void* data, uint32_t frames) = 0;
		virtual bool bufferQueueEmpty() const = 0;
		virtual bool isActive() const = 0;
		@@ -333,6 +416,18 @@ public:

		class IAfMmapTrack : public virtual IAfTrackBase {
		public:
		// TODO(b/288339104) void*
		static sp<IAfMmapTrack> create(void* /AudioFlinger::ThreadBase / thread,
		const audio_attributes_t& attr,
		uint32_t sampleRate,
		audio_format_t format,
		audio_channel_mask_t channelMask,
		audio_session_t sessionId,
		bool isOut,
		const android::content::AttributionSourceState& attributionSource,
		pid_t creatorPid,
		audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);

		// protected by MMapThread::mLock
		virtual void setSilenced_l(bool silenced) = 0;
		// protected by MMapThread::mLock
		@@ -348,6 +443,8 @@ public:
		const sp<IAudioManager>& audioManager, mute_state_t muteState) = 0;
		};

		class RecordBufferConverter;

		class IAfRecordTrack : public virtual IAfTrackBase {
		public:
		// createIAudioRecordAdapter() is a static constructor which creates an
		@@ -357,6 +454,24 @@ public:
		// Only one AIDL IAudioRecord interface adapter should be created per RecordTrack.
		static sp<media::IAudioRecord> createIAudioRecordAdapter(const sp<IAfRecordTrack>& recordTrack);

		// TODO(b/288339104) void*
		static sp<IAfRecordTrack> create(void* /* AudioFlinger::RecordThread */ 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);

		// clear the buffer overflow flag
		virtual void clearOverflow() = 0;
		// set the buffer overflow flag and return previous value
		@@ -386,6 +501,12 @@ public:
		using SinkMetadatas = std::vector<record_track_metadata_v7_t>;
		using MetadataInserter = std::back_insert_iterator<SinkMetadatas>;
		virtual void copyMetadataTo(MetadataInserter& backInserter) const = 0; // see IAfTrack

		// private to Threads
		virtual AudioBufferProvider::Buffer& sinkBuffer() = 0;
		virtual audioflinger::SynchronizedRecordState& synchronizedRecordState() = 0;
		virtual RecordBufferConverter* recordBufferConverter() const = 0;
		virtual ResamplerBufferProvider* resamplerBufferProvider() const = 0;
		};

		// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
		@@ -401,13 +522,32 @@ public:

		class IAfPatchTrackBase : public virtual RefBase {
		public:
		using Timeout = std::optional<std::chrono::nanoseconds>;

		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 {};
		class IAfPatchTrack : public virtual IAfTrack, public virtual IAfPatchTrackBase {
		public:
		static sp<IAfPatchTrack> create(
		void * /* PlaybackThread */ playbackThread, // TODO(b/288339104)
		audio_stream_type_t streamType,
		uint32_t sampleRate,
		audio_channel_mask_t channelMask,
		audio_format_t format,
		size_t frameCount,
		void *buffer,
		size_t bufferSize,
		audio_output_flags_t flags,
		const Timeout& timeout = {},
		size_t frameCountToBeReady = 1 /** Default behaviour is to start
		* as soon as possible to have
		* the lowest possible latency
		* even if it might glitch. */);
		};

		// Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).
		struct Source {
		@@ -420,6 +560,27 @@ struct Source {

		class IAfPatchRecord : public virtual IAfRecordTrack, public virtual IAfPatchTrackBase {
		public:
		static sp<IAfPatchRecord> create(
		void* /* RecordThread */ recordThread, // TODO(b/288339104)
		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);

		static sp<IAfPatchRecord> createPassThru(
		void* /* RecordThread */ recordThread, // TODO(b/288339104)
		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);

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

services/audioflinger/MmapTracks.h

+5 −4

Original line number	Diff line number	Diff line
		@@ -15,14 +15,14 @@
		** limitations under the License.
		*/

		#ifndef INCLUDING_FROM_AUDIOFLINGER_H
		#error This header file should only be included from AudioFlinger.h
		#endif
		#pragma once

		namespace android {

		// playback track
		class MmapTrack : public TrackBase, public IAfMmapTrack {
		public:
		MmapTrack(ThreadBase *thread,
		MmapTrack(AudioFlinger::ThreadBase* thread,
		const audio_attributes_t& attr,
		uint32_t sampleRate,
		audio_format_t format,
		@@ -87,3 +87,4 @@ private:
		GUARDED_BY(AudioFlinger::MmapPlaybackThread::mLock);
		}; // end of Track

		} // namespace android
		No newline at end of file

services/audioflinger/PatchPanel.cpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -556,7 +556,7 @@ status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
		outputFlags = (audio_output_flags_t) (outputFlags & ~AUDIO_OUTPUT_FLAG_FAST);
		}

		sp<RecordThread::PatchRecord> tempRecordTrack;
		sp<IAfPatchRecord> tempRecordTrack;
		const bool usePassthruPatchRecord =
		(inputFlags & AUDIO_INPUT_FLAG_DIRECT) && (outputFlags & AUDIO_OUTPUT_FLAG_DIRECT);
		const size_t playbackFrameCount = mPlayback.thread()->frameCount();
		@@ -568,7 +568,7 @@ status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
		frameCount = std::max(playbackFrameCount, recordFrameCount);
		ALOGV("%s() playframeCount %zu recordFrameCount %zu frameCount %zu",
		__func__, playbackFrameCount, recordFrameCount, frameCount);
		tempRecordTrack = new RecordThread::PassthruPatchRecord(
		tempRecordTrack = IAfPatchRecord::createPassThru(
		mRecord.thread().get(),
		sampleRate,
		inChannelMask,
		@@ -587,7 +587,7 @@ status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
		ALOGV("%s() playframeCount %zu recordFrameCount %zu frameCount %zu",
		__func__, playbackFrameCount, recordFrameCount, frameCount);

		tempRecordTrack = new RecordThread::PatchRecord(
		tempRecordTrack = IAfPatchRecord::create(
		mRecord.thread().get(),
		sampleRate,
		inChannelMask,
		@@ -612,7 +612,7 @@ status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
		// Disable this behavior for FM Tuner source if no fast capture/mixer available.
		const bool isFmBridge = mAudioPatch.sources[0].ext.device.type == AUDIO_DEVICE_IN_FM_TUNER;
		const size_t frameCountToBeReady = isFmBridge && !usePassthruPatchRecord ? frameCount / 4 : 1;
		sp<PlaybackThread::PatchTrack> tempPatchTrack = new PlaybackThread::PatchTrack(
		sp<IAfPatchTrack> tempPatchTrack = IAfPatchTrack::create(
		mPlayback.thread().get(),
		streamType,
		sampleRate,