Merge changes I52ec5b02,I376656e3,I3f005583,Icba4e33d,I78400f6c, ... (d7a15067) · Commits · e / os / android_frameworks_av

media/audioserver/Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,7 @@ LOCAL_SHARED_LIBRARIES := \
	libaaudioservice \		libaaudioservice \
	libaudioflinger \		libaudioflinger \
	libaudiopolicyservice \		libaudiopolicyservice \
			libaudioprocessing \
	libbinder \		libbinder \
	libcutils \		libcutils \
	liblog \		liblog \

media/libaudioclient/include/media/AudioMixer.h

+34 −315

Original line number	Original line	Diff line number	Diff line
	@@ -18,87 +18,38 @@
	#ifndef ANDROID_AUDIO_MIXER_H		#ifndef ANDROID_AUDIO_MIXER_H
	#define ANDROID_AUDIO_MIXER_H		#define ANDROID_AUDIO_MIXER_H

	#include <map>
	#include <pthread.h>		#include <pthread.h>
	#include <sstream>
	#include <stdint.h>		#include <stdint.h>
	#include <sys/types.h>		#include <sys/types.h>
	#include <unordered_map>
	#include <vector>

	#include <android/os/IExternalVibratorService.h>		#include <android/os/IExternalVibratorService.h>
	#include <media/AudioBufferProvider.h>		#include <media/AudioMixerBase.h>
	#include <media/AudioResampler.h>
	#include <media/AudioResamplerPublic.h>
	#include <media/BufferProviders.h>		#include <media/BufferProviders.h>
	#include <system/audio.h>
	#include <utils/Compat.h>
	#include <utils/threads.h>		#include <utils/threads.h>

	// FIXME This is actually unity gain, which might not be max in future, expressed in U.12		// FIXME This is actually unity gain, which might not be max in future, expressed in U.12
	#define MAX_GAIN_INT AudioMixer::UNITY_GAIN_INT		#define MAX_GAIN_INT AudioMixerBase::UNITY_GAIN_INT

	// This must match frameworks/av/services/audioflinger/Configuration.h
	#define FLOAT_AUX

	namespace android {		namespace android {

	namespace NBLog {
	class Writer;
	} // namespace NBLog

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	class AudioMixer		// AudioMixer extends AudioMixerBase by adding support for down- and up-mixing
			// and time stretch that are implemented via Effects HAL, and adding support
			// for haptic channels which depends on Vibrator service. This is the version
			// that is used by Audioflinger.

			class AudioMixer : public AudioMixerBase
	{		{
	public:		public:
	// Do not change these unless underlying code changes.
	// This mixer has a hard-coded upper limit of 8 channels for output.
	static constexpr uint32_t MAX_NUM_CHANNELS = FCC_8;
	static constexpr uint32_t MAX_NUM_VOLUMES = FCC_2; // stereo volume only
	// maximum number of channels supported for the content		// maximum number of channels supported for the content
	static const uint32_t MAX_NUM_CHANNELS_TO_DOWNMIX = AUDIO_CHANNEL_COUNT_MAX;		static const uint32_t MAX_NUM_CHANNELS_TO_DOWNMIX = AUDIO_CHANNEL_COUNT_MAX;

	static const uint16_t UNITY_GAIN_INT = 0x1000;		enum { // extension of AudioMixerBase parameters
	static const CONSTEXPR float UNITY_GAIN_FLOAT = 1.0f;		DOWNMIX_TYPE = 0x4004,

	enum { // names
	// setParameter targets
	TRACK = 0x3000,
	RESAMPLE = 0x3001,
	RAMP_VOLUME = 0x3002, // ramp to new volume
	VOLUME = 0x3003, // don't ramp
	TIMESTRETCH = 0x3004,

	// set Parameter names
	// for target TRACK
	CHANNEL_MASK = 0x4000,
	FORMAT = 0x4001,
	MAIN_BUFFER = 0x4002,
	AUX_BUFFER = 0x4003,
	DOWNMIX_TYPE = 0X4004,
	MIXER_FORMAT = 0x4005, // AUDIO_FORMAT_PCM_(FLOAT\|16_BIT)
	MIXER_CHANNEL_MASK = 0x4006, // Channel mask for mixer output
	// for haptic		// for haptic
	HAPTIC_ENABLED = 0x4007, // Set haptic data from this track should be played or not.		HAPTIC_ENABLED = 0x4007, // Set haptic data from this track should be played or not.
	HAPTIC_INTENSITY = 0x4008, // Set the intensity to play haptic data.		HAPTIC_INTENSITY = 0x4008, // Set the intensity to play haptic data.
	// for target RESAMPLE
	SAMPLE_RATE = 0x4100, // Configure sample rate conversion on this track name;
	// parameter 'value' is the new sample rate in Hz.
	// Only creates a sample rate converter the first time that
	// the track sample rate is different from the mix sample rate.
	// If the new sample rate is the same as the mix sample rate,
	// and a sample rate converter already exists,
	// then the sample rate converter remains present but is a no-op.
	RESET = 0x4101, // Reset sample rate converter without changing sample rate.
	// This clears out the resampler's input buffer.
	REMOVE = 0x4102, // Remove the sample rate converter on this track name;
	// the track is restored to the mix sample rate.
	// for target RAMP_VOLUME and VOLUME (8 channels max)
	// FIXME use float for these 3 to improve the dynamic range
	VOLUME0 = 0x4200,
	VOLUME1 = 0x4201,
	AUXLEVEL = 0x4210,
	// for target TIMESTRETCH		// for target TIMESTRETCH
	PLAYBACK_RATE = 0x4300, // Configure timestretch on this track name;		PLAYBACK_RATE = 0x4300, // Configure timestretch on this track name;
	// parameter 'value' is a pointer to the new playback rate.		// parameter 'value' is a pointer to the new playback rate.
	@@ -131,142 +82,23 @@ public:
	}		}

	AudioMixer(size_t frameCount, uint32_t sampleRate)		AudioMixer(size_t frameCount, uint32_t sampleRate)
	: mSampleRate(sampleRate)		: AudioMixerBase(frameCount, sampleRate) {
	, mFrameCount(frameCount) {
	pthread_once(&sOnceControl, &sInitRoutine);		pthread_once(&sOnceControl, &sInitRoutine);
	}		}

	// Create a new track in the mixer.		bool isValidChannelMask(audio_channel_mask_t channelMask) const override;
	//
	// \param name a unique user-provided integer associated with the track.
	// If name already exists, the function will abort.
	// \param channelMask output channel mask.
	// \param format PCM format
	// \param sessionId Session id for the track. Tracks with the same
	// session id will be submixed together.
	//
	// \return OK on success.
	// BAD_VALUE if the format does not satisfy isValidFormat()
	// or the channelMask does not satisfy isValidChannelMask().
	status_t create(
	int name, audio_channel_mask_t channelMask, audio_format_t format, int sessionId);

	bool exists(int name) const {
	return mTracks.count(name) > 0;
	}

	// Free an allocated track by name.
	void destroy(int name);

	// Enable or disable an allocated track by name
	void enable(int name);
	void disable(int name);

	void setParameter(int name, int target, int param, void *value);

			void setParameter(int name, int target, int param, void *value) override;
	void setBufferProvider(int name, AudioBufferProvider* bufferProvider);		void setBufferProvider(int name, AudioBufferProvider* bufferProvider);

	void process() {
	for (const auto &pair : mTracks) {
	// Clear contracted buffer before processing if contracted channels are saved
	const std::shared_ptr<Track> &t = pair.second;
	if (t->mKeepContractedChannels) {
	t->clearContractedBuffer();
	}
	}
	(this->*mHook)();
	processHapticData();
	}

	size_t getUnreleasedFrames(int name) const;

	std::string trackNames() const {
	std::stringstream ss;
	for (const auto &pair : mTracks) {
	ss << pair.first << " ";
	}
	return ss.str();
	}

	void setNBLogWriter(NBLog::Writer *logWriter) {
	mNBLogWriter = logWriter;
	}

	static inline bool isValidFormat(audio_format_t format) {
	switch (format) {
	case AUDIO_FORMAT_PCM_8_BIT:
	case AUDIO_FORMAT_PCM_16_BIT:
	case AUDIO_FORMAT_PCM_24_BIT_PACKED:
	case AUDIO_FORMAT_PCM_32_BIT:
	case AUDIO_FORMAT_PCM_FLOAT:
	return true;
	default:
	return false;
	}
	}

	static inline bool isValidChannelMask(audio_channel_mask_t channelMask) {
	return audio_channel_mask_is_valid(channelMask); // the RemixBufferProvider is flexible.
	}

	private:		private:

	/* For multi-format functions (calls template functions		struct Track : public TrackBase {
	* in AudioMixerOps.h). The template parameters are as follows:		Track() : TrackBase() {}
	*
	* MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
	* USEFLOATVOL (set to true if float volume is used)
	* ADJUSTVOL (set to true if volume ramp parameters needs adjustment afterwards)
	* TO: int32_t (Q4.27) or float
	* TI: int32_t (Q4.27) or int16_t (Q0.15) or float
	* TA: int32_t (Q4.27)
	*/

	enum {
	// FIXME this representation permits up to 8 channels
	NEEDS_CHANNEL_COUNT__MASK = 0x00000007,
	};

	enum {
	NEEDS_CHANNEL_1 = 0x00000000, // mono
	NEEDS_CHANNEL_2 = 0x00000001, // stereo

	// sample format is not explicitly specified, and is assumed to be AUDIO_FORMAT_PCM_16_BIT

	NEEDS_MUTE = 0x00000100,
	NEEDS_RESAMPLE = 0x00001000,
	NEEDS_AUX = 0x00010000,
	};

	// hook types
	enum {
	PROCESSTYPE_NORESAMPLEONETRACK, // others set elsewhere
	};

	enum {
	TRACKTYPE_NOP,
	TRACKTYPE_RESAMPLE,
	TRACKTYPE_NORESAMPLE,
	TRACKTYPE_NORESAMPLEMONO,
	};

	// process hook functionality
	using process_hook_t = void(AudioMixer::*)();

	struct Track;
	using hook_t = void(Track::)(int32_t output, size_t numOutFrames, int32_t* temp, int32_t* aux);

	struct Track {
	Track()
	: bufferProvider(nullptr)
	{
	// TODO: move additional initialization here.
	}

	~Track()		~Track()
	{		{
	// bufferProvider, mInputBufferProvider need not be deleted.		// mInputBufferProvider need not be deleted.
	mResampler.reset(nullptr);
	// Ensure the order of destruction of buffer providers as they		// Ensure the order of destruction of buffer providers as they
	// release the upstream provider in the destructor.		// release the upstream provider in the destructor.
	mTimestretchBufferProvider.reset(nullptr);		mTimestretchBufferProvider.reset(nullptr);
	@@ -277,13 +109,12 @@ private:
	mAdjustChannelsBufferProvider.reset(nullptr);		mAdjustChannelsBufferProvider.reset(nullptr);
	}		}

	bool needsRamp() { return (volumeInc[0] \| volumeInc[1] \| auxInc) != 0; }		uint32_t getOutputChannelCount() override {
	bool setResampler(uint32_t trackSampleRate, uint32_t devSampleRate);		return mDownmixerBufferProvider.get() != nullptr ? mMixerChannelCount : channelCount;
	bool doesResample() const { return mResampler.get() != nullptr; }		}
	void resetResampler() { if (mResampler.get() != nullptr) mResampler->reset(); }		uint32_t getMixerChannelCount() override {
	void adjustVolumeRamp(bool aux, bool useFloat = false);		return mMixerChannelCount + mMixerHapticChannelCount;
	size_t getUnreleasedFrames() const { return mResampler.get() != nullptr ?		}
	mResampler->getUnreleasedFrames() : 0; };

	status_t prepareForDownmix();		status_t prepareForDownmix();
	void unprepareForDownmix();		void unprepareForDownmix();
	@@ -297,51 +128,9 @@ private:
	bool setPlaybackRate(const AudioPlaybackRate &playbackRate);		bool setPlaybackRate(const AudioPlaybackRate &playbackRate);
	void reconfigureBufferProviders();		void reconfigureBufferProviders();

	static hook_t getTrackHook(int trackType, uint32_t channelCount,
	audio_format_t mixerInFormat, audio_format_t mixerOutFormat);

	void track__nop(int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);

	template <int MIXTYPE, bool USEFLOATVOL, bool ADJUSTVOL,
	typename TO, typename TI, typename TA>
	void volumeMix(TO out, size_t outFrames, const TI in, TA *aux, bool ramp);

	uint32_t needs;

	// TODO: Eventually remove legacy integer volume settings
	union {
	int16_t volume[MAX_NUM_VOLUMES]; // U4.12 fixed point (top bit should be zero)
	int32_t volumeRL;
	};

	int32_t prevVolume[MAX_NUM_VOLUMES];
	int32_t volumeInc[MAX_NUM_VOLUMES];
	int32_t auxInc;
	int32_t prevAuxLevel;
	int16_t auxLevel; // 0 <= auxLevel <= MAX_GAIN_INT, but signed for mul performance

	uint16_t frameCount;

	uint8_t channelCount; // 1 or 2, redundant with (needs & NEEDS_CHANNEL_COUNT__MASK)
	uint8_t unused_padding; // formerly format, was always 16
	uint16_t enabled; // actually bool
	audio_channel_mask_t channelMask;

	// actual buffer provider used by the track hooks, see DownmixerBufferProvider below
	// for how the Track buffer provider is wrapped by another one when dowmixing is required
	AudioBufferProvider* bufferProvider;

	mutable AudioBufferProvider::Buffer buffer; // 8 bytes

	hook_t hook;
	const void *mIn; // current location in buffer

	std::unique_ptr<AudioResampler> mResampler;
	uint32_t sampleRate;
	int32_t* mainBuffer;
	int32_t* auxBuffer;

	/* Buffer providers are constructed to translate the track input data as needed.		/* Buffer providers are constructed to translate the track input data as needed.
			* See DownmixerBufferProvider below for how the Track buffer provider
			* is wrapped by another one when dowmixing is required.
	*		*
	* TODO: perhaps make a single PlaybackConverterProvider class to move		* TODO: perhaps make a single PlaybackConverterProvider class to move
	* all pre-mixer track buffer conversions outside the AudioMixer class.		* all pre-mixer track buffer conversions outside the AudioMixer class.
	@@ -373,27 +162,10 @@ private:
	std::unique_ptr<PassthruBufferProvider> mPostDownmixReformatBufferProvider;		std::unique_ptr<PassthruBufferProvider> mPostDownmixReformatBufferProvider;
	std::unique_ptr<PassthruBufferProvider> mTimestretchBufferProvider;		std::unique_ptr<PassthruBufferProvider> mTimestretchBufferProvider;

	int32_t sessionId;

	audio_format_t mMixerFormat; // output mix format: AUDIO_FORMAT_PCM_(FLOAT\|16_BIT)
	audio_format_t mFormat; // input track format
	audio_format_t mMixerInFormat; // mix internal format AUDIO_FORMAT_PCM_(FLOAT\|16_BIT)
	// each track must be converted to this format.
	audio_format_t mDownmixRequiresFormat; // required downmixer format		audio_format_t mDownmixRequiresFormat; // required downmixer format
	// AUDIO_FORMAT_PCM_16_BIT if 16 bit necessary		// AUDIO_FORMAT_PCM_16_BIT if 16 bit necessary
	// AUDIO_FORMAT_INVALID if no required format		// AUDIO_FORMAT_INVALID if no required format

	float mVolume[MAX_NUM_VOLUMES]; // floating point set volume
	float mPrevVolume[MAX_NUM_VOLUMES]; // floating point previous volume
	float mVolumeInc[MAX_NUM_VOLUMES]; // floating point volume increment

	float mAuxLevel; // floating point set aux level
	float mPrevAuxLevel; // floating point prev aux level
	float mAuxInc; // floating point aux increment

	audio_channel_mask_t mMixerChannelMask;
	uint32_t mMixerChannelCount;

	AudioPlaybackRate mPlaybackRate;		AudioPlaybackRate mPlaybackRate;

	// Haptic		// Haptic
	@@ -440,76 +212,23 @@ private:
	return 0.0f;		return 0.0f;
	}		}
	}		}

	private:
	// hooks
	void track__genericResample(int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
	void track__16BitsStereo(int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
	void track__16BitsMono(int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);

	void volumeRampStereo(int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
	void volumeStereo(int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);

	// multi-format track hooks
	template <int MIXTYPE, typename TO, typename TI, typename TA>
	void track__Resample(TO* out, size_t frameCount, TO* temp __unused, TA* aux);
	template <int MIXTYPE, typename TO, typename TI, typename TA>
	void track__NoResample(TO* out, size_t frameCount, TO* temp __unused, TA* aux);
	};		};

	// TODO: remove BLOCKSIZE unit of processing - it isn't needed anymore.		inline std::shared_ptr<Track> getTrack(int name) {
	static constexpr int BLOCKSIZE = 16;		return std::static_pointer_cast<Track>(mTracks[name]);

	bool setChannelMasks(int name,
	audio_channel_mask_t trackChannelMask, audio_channel_mask_t mixerChannelMask);

	// Called when track info changes and a new process hook should be determined.
	void invalidate() {
	mHook = &AudioMixer::process__validate;
	}		}

	void process__validate();		std::shared_ptr<TrackBase> preCreateTrack() override;
	void process__nop();		status_t postCreateTrack(TrackBase *track) override;
	void process__genericNoResampling();
	void process__genericResampling();
	void process__oneTrack16BitsStereoNoResampling();

	template <int MIXTYPE, typename TO, typename TI, typename TA>
	void process__noResampleOneTrack();

	void processHapticData();		void preProcess() override;
			void postProcess() override;

	static process_hook_t getProcessHook(int processType, uint32_t channelCount,		bool setChannelMasks(int name,
	audio_format_t mixerInFormat, audio_format_t mixerOutFormat);		audio_channel_mask_t trackChannelMask, audio_channel_mask_t mixerChannelMask) override;

	static void convertMixerFormat(void *out, audio_format_t mixerOutFormat,
	void *in, audio_format_t mixerInFormat, size_t sampleCount);

	static void sInitRoutine();		static void sInitRoutine();

	// initialization constants
	const uint32_t mSampleRate;
	const size_t mFrameCount;

	NBLog::Writer *mNBLogWriter = nullptr; // associated NBLog::Writer

	process_hook_t mHook = &AudioMixer::process__nop; // one of process__*, never nullptr

	// the size of the type (int32_t) should be the largest of all types supported
	// by the mixer.
	std::unique_ptr<int32_t[]> mOutputTemp;
	std::unique_ptr<int32_t[]> mResampleTemp;

	// track names grouped by main buffer, in no particular order of main buffer.
	// however names for a particular main buffer are in order (by construction).
	std::unordered_map<void * /* mainBuffer /, std::vector<int / name */>> mGroups;

	// track names that are enabled, in increasing order (by construction).
	std::vector<int /* name */> mEnabled;

	// track smart pointers, by name, in increasing order of name.
	std::map<int /* name */, std::shared_ptr<Track>> mTracks;

	static pthread_once_t sOnceControl; // initialized in constructor by first new		static pthread_once_t sOnceControl; // initialized in constructor by first new
	};		};

media/libaudioprocessing/Android.bp

+18 −12

Original line number	Original line	Diff line number	Diff line
	@@ -3,20 +3,13 @@ cc_defaults {

	export_include_dirs: ["include"],		export_include_dirs: ["include"],

			header_libs: ["libaudioclient_headers"],

	shared_libs: [		shared_libs: [
	"libaudiohal",
	"libaudioutils",		"libaudioutils",
	"libcutils",		"libcutils",
	"liblog",		"liblog",
	"libnbaio",
	"libnblog",
	"libsonic",
	"libutils",		"libutils",
	"libvibrator",
	],

	header_libs: [
	"libbase_headers",
	],		],

	cflags: [		cflags: [
	@@ -33,18 +26,31 @@ cc_library_shared {
	defaults: ["libaudioprocessing_defaults"],		defaults: ["libaudioprocessing_defaults"],

	srcs: [		srcs: [
			"AudioMixer.cpp",
	"BufferProviders.cpp",		"BufferProviders.cpp",
	"RecordBufferConverter.cpp",		"RecordBufferConverter.cpp",
	],		],
	whole_static_libs: ["libaudioprocessing_arm"],
			header_libs: [
			"libbase_headers",
			],

			shared_libs: [
			"libaudiohal",
			"libsonic",
			"libvibrator",
			],

			whole_static_libs: ["libaudioprocessing_base"],
	}		}

	cc_library_static {		cc_library_static {
	name: "libaudioprocessing_arm",		name: "libaudioprocessing_base",
	defaults: ["libaudioprocessing_defaults"],		defaults: ["libaudioprocessing_defaults"],
			vendor_available: true,

	srcs: [		srcs: [
	"AudioMixer.cpp",		"AudioMixerBase.cpp",
	"AudioResampler.cpp",		"AudioResampler.cpp",
	"AudioResamplerCubic.cpp",		"AudioResamplerCubic.cpp",
	"AudioResamplerSinc.cpp",		"AudioResamplerSinc.cpp",

media/libaudioprocessing/AudioMixer.cpp

+82 −1575

File changed.

Preview size limit exceeded, changes collapsed.

media/libaudioprocessing/AudioMixerBase.cpp

0 → 100644

+1692 −0

File added.

Preview size limit exceeded, changes collapsed.