Spatializer: process callbacks in separate thread am: 8a4259fcc5 (9d02ae8e) · Commits · e / os / android_frameworks_av

services/audiopolicy/service/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -49,6 +49,7 @@ cc_library_shared {
	"libsensorprivacy",		"libsensorprivacy",
	"libshmemcompat",		"libshmemcompat",
	"libutils",		"libutils",
			"libstagefright_foundation",
	"audioclient-types-aidl-cpp",		"audioclient-types-aidl-cpp",
	"audioflinger-aidl-cpp",		"audioflinger-aidl-cpp",
	"audiopolicy-aidl-cpp",		"audiopolicy-aidl-cpp",

services/audiopolicy/service/Spatializer.cpp

+138 −9

Original line number	Original line	Diff line number	Diff line
	@@ -29,8 +29,10 @@
	#include <audio_utils/fixedfft.h>		#include <audio_utils/fixedfft.h>
	#include <cutils/bitops.h>		#include <cutils/bitops.h>
	#include <hardware/sensors.h>		#include <hardware/sensors.h>
	#include <media/ShmemCompat.h>
	#include <media/audiohal/EffectsFactoryHalInterface.h>		#include <media/audiohal/EffectsFactoryHalInterface.h>
			#include <media/stagefright/foundation/AHandler.h>
			#include <media/stagefright/foundation/AMessage.h>
			#include <media/ShmemCompat.h>
	#include <mediautils/ServiceUtilities.h>		#include <mediautils/ServiceUtilities.h>
	#include <utils/Thread.h>		#include <utils/Thread.h>

	@@ -49,7 +51,6 @@ using media::SpatializationMode;
	using media::SpatializerHeadTrackingMode;		using media::SpatializerHeadTrackingMode;
	using media::SensorPoseProvider;		using media::SensorPoseProvider;


	using namespace std::chrono_literals;		using namespace std::chrono_literals;

	#define VALUE_OR_RETURN_BINDER_STATUS(x) \		#define VALUE_OR_RETURN_BINDER_STATUS(x) \
	@@ -65,6 +66,90 @@ using namespace std::chrono_literals;

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

			class Spatializer::EngineCallbackHandler : public AHandler {
			public:
			EngineCallbackHandler(wp<Spatializer> spatializer)
			: mSpatializer(spatializer) {
			}

			enum {
			// Device state callbacks
			kWhatOnFramesProcessed, // AudioEffect::EVENT_FRAMES_PROCESSED
			kWhatOnHeadToStagePose, // SpatializerPoseController::Listener::onHeadToStagePose
			kWhatOnActualModeChange, // SpatializerPoseController::Listener::onActualModeChange
			};
			static constexpr const char *kNumFramesKey = "numFrames";
			static constexpr const char *kModeKey = "mode";
			static constexpr const char *kTranslation0Key = "translation0";
			static constexpr const char *kTranslation1Key = "translation1";
			static constexpr const char *kTranslation2Key = "translation2";
			static constexpr const char *kRotation0Key = "rotation0";
			static constexpr const char *kRotation1Key = "rotation1";
			static constexpr const char *kRotation2Key = "rotation2";

			void onMessageReceived(const sp<AMessage> &msg) override {
			switch (msg->what()) {
			case kWhatOnFramesProcessed: {
			sp<Spatializer> spatializer = mSpatializer.promote();
			if (spatializer == nullptr) {
			ALOGW("%s: Cannot promote spatializer", __func__);
			return;
			}
			int numFrames;
			if (!msg->findInt32(kNumFramesKey, &numFrames)) {
			ALOGE("%s: Cannot find num frames!", __func__);
			return;
			}
			if (numFrames > 0) {
			spatializer->calculateHeadPose();
			}
			} break;
			case kWhatOnHeadToStagePose: {
			sp<Spatializer> spatializer = mSpatializer.promote();
			if (spatializer == nullptr) {
			ALOGW("%s: Cannot promote spatializer", __func__);
			return;
			}
			std::vector<float> headToStage(sHeadPoseKeys.size());
			for (size_t i = 0 ; i < sHeadPoseKeys.size(); i++) {
			if (!msg->findFloat(sHeadPoseKeys[i], &headToStage[i])) {
			ALOGE("%s: Cannot find kTranslation0Key!", __func__);
			return;
			}
			}
			spatializer->onHeadToStagePoseMsg(headToStage);
			} break;
			case kWhatOnActualModeChange: {
			sp<Spatializer> spatializer = mSpatializer.promote();
			if (spatializer == nullptr) {
			ALOGW("%s: Cannot promote spatializer", __func__);
			return;
			}
			int mode;
			if (!msg->findInt32(EngineCallbackHandler::kModeKey, &mode)) {
			ALOGE("%s: Cannot find actualMode!", __func__);
			return;
			}
			spatializer->onActualModeChangeMsg(static_cast<HeadTrackingMode>(mode));
			} break;
			default:
			LOG_ALWAYS_FATAL("Invalid callback message %d", msg->what());
			}
			}
			private:
			wp<Spatializer> mSpatializer;
			};

			const std::vector<const char *> Spatializer::sHeadPoseKeys = {
			Spatializer::EngineCallbackHandler::kTranslation0Key,
			Spatializer::EngineCallbackHandler::kTranslation1Key,
			Spatializer::EngineCallbackHandler::kTranslation2Key,
			Spatializer::EngineCallbackHandler::kRotation0Key,
			Spatializer::EngineCallbackHandler::kRotation1Key,
			Spatializer::EngineCallbackHandler::kRotation2Key,
			};

			// ---------------------------------------------------------------------------
	sp<Spatializer> Spatializer::create(SpatializerPolicyCallback *callback) {		sp<Spatializer> Spatializer::create(SpatializerPolicyCallback *callback) {
	sp<Spatializer> spatializer;		sp<Spatializer> spatializer;

	@@ -107,8 +192,26 @@ Spatializer::Spatializer(effect_descriptor_t engineDescriptor, SpatializerPolicy
	ALOGV("%s", __func__);		ALOGV("%s", __func__);
	}		}

			void Spatializer::onFirstRef() {
			mLooper = new ALooper;
			mLooper->setName("Spatializer-looper");
			mLooper->start(
			/runOnCallingThread/false,
			/canCallJava/ false,
			PRIORITY_AUDIO);

			mHandler = new EngineCallbackHandler(this);
			mLooper->registerHandler(mHandler);
			}

	Spatializer::~Spatializer() {		Spatializer::~Spatializer() {
	ALOGV("%s", __func__);		ALOGV("%s", __func__);
			if (mLooper != nullptr) {
			mLooper->stop();
			mLooper->unregisterHandler(mHandler->id());
			}
			mLooper.clear();
			mHandler.clear();
	}		}

	status_t Spatializer::loadEngineConfiguration(sp<EffectHalInterface> effect) {		status_t Spatializer::loadEngineConfiguration(sp<EffectHalInterface> effect) {
	@@ -391,23 +494,44 @@ Status Spatializer::getSupportedModes(std::vector<SpatializationMode> *modes) {
	// SpatializerPoseController::Listener		// SpatializerPoseController::Listener
	void Spatializer::onHeadToStagePose(const Pose3f& headToStage) {		void Spatializer::onHeadToStagePose(const Pose3f& headToStage) {
	ALOGV("%s", __func__);		ALOGV("%s", __func__);
	sp<media::INativeSpatializerCallback> callback;
	auto vec = headToStage.toVector();		auto vec = headToStage.toVector();
			LOG_ALWAYS_FATAL_IF(vec.size() != sHeadPoseKeys.size(),
			"%s invalid head to stage vector size %zu", __func__, vec.size());

			sp<AMessage> msg =
			new AMessage(EngineCallbackHandler::kWhatOnHeadToStagePose, mHandler);
			for (size_t i = 0 ; i < sHeadPoseKeys.size(); i++) {
			msg->setFloat(sHeadPoseKeys[i], vec[i]);
			}
			msg->post();
			}

			void Spatializer::onHeadToStagePoseMsg(const std::vector<float>& headToStage) {
			ALOGV("%s", __func__);
			sp<media::INativeSpatializerCallback> callback;
	{		{
	std::lock_guard lock(mLock);		std::lock_guard lock(mLock);
	callback = mSpatializerCallback;		callback = mSpatializerCallback;
	if (mEngine != nullptr) {		if (mEngine != nullptr) {
	setEffectParameter_l(SPATIALIZER_PARAM_HEAD_TO_STAGE, vec);		setEffectParameter_l(SPATIALIZER_PARAM_HEAD_TO_STAGE, headToStage);
	}		}
	}		}

	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onHeadToSoundStagePoseUpdated(vec);		callback->onHeadToSoundStagePoseUpdated(headToStage);
	}		}
	}		}

	void Spatializer::onActualModeChange(HeadTrackingMode mode) {		void Spatializer::onActualModeChange(HeadTrackingMode mode) {
	ALOGV("onActualModeChange(%d)", (int) mode);		ALOGV("%s(%d)", __func__, (int)mode);
			sp<AMessage> msg =
			new AMessage(EngineCallbackHandler::kWhatOnActualModeChange, mHandler);
			msg->setInt32(EngineCallbackHandler::kModeKey, static_cast<int>(mode));
			msg->post();
			}

			void Spatializer::onActualModeChangeMsg(HeadTrackingMode mode) {
			ALOGV("%s(%d)", __func__, (int) mode);
	sp<media::INativeSpatializerCallback> callback;		sp<media::INativeSpatializerCallback> callback;
	SpatializerHeadTrackingMode spatializerMode;		SpatializerHeadTrackingMode spatializerMode;
	{		{
	@@ -534,9 +658,7 @@ void Spatializer::engineCallback(int32_t event, void user, void info) {
	case AudioEffect::EVENT_FRAMES_PROCESSED: {		case AudioEffect::EVENT_FRAMES_PROCESSED: {
	int frames = info == nullptr ? 0 : (int)info;		int frames = info == nullptr ? 0 : (int)info;
	ALOGD("%s frames processed %d for me %p", __func__, frames, me);		ALOGD("%s frames processed %d for me %p", __func__, frames, me);
	if (frames > 0) {		me->postFramesProcessedMsg(frames);
	me->calculateHeadPose();
	}
	} break;		} break;
	default:		default:
	ALOGD("%s event %d", __func__, event);		ALOGD("%s event %d", __func__, event);
	@@ -544,6 +666,13 @@ void Spatializer::engineCallback(int32_t event, void user, void info) {
	}		}
	}		}

			void Spatializer::postFramesProcessedMsg(int frames) {
			sp<AMessage> msg =
			new AMessage(EngineCallbackHandler::kWhatOnFramesProcessed, mHandler);
			msg->setInt32(EngineCallbackHandler::kNumFramesKey, frames);
			msg->post();
			}

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

	Spatializer::EffectClient::EffectClient(const sp<media::IEffectClient>& effectClient,		Spatializer::EffectClient::EffectClient(const sp<media::IEffectClient>& effectClient,

services/audiopolicy/service/Spatializer.h

+19 −1

Original line number	Original line	Diff line number	Diff line
	@@ -24,6 +24,7 @@
	#include <android/media/SpatializerHeadTrackingMode.h>		#include <android/media/SpatializerHeadTrackingMode.h>
	#include <android/sensor.h>		#include <android/sensor.h>
	#include <media/audiohal/EffectHalInterface.h>		#include <media/audiohal/EffectHalInterface.h>
			#include <media/stagefright/foundation/ALooper.h>
	#include <media/AudioEffect.h>		#include <media/AudioEffect.h>
	#include <system/audio_effects/effect_spatializer.h>		#include <system/audio_effects/effect_spatializer.h>

	@@ -91,6 +92,9 @@ class Spatializer : public media::BnSpatializer,

	~Spatializer() override;		~Spatializer() override;

			/** RefBase */
			void onFirstRef();

	/** ISpatializer, see ISpatializer.aidl */		/** ISpatializer, see ISpatializer.aidl */
	binder::Status release() override;		binder::Status release() override;
	binder::Status getSupportedLevels(std::vector<media::SpatializationLevel>* levels) override;		binder::Status getSupportedLevels(std::vector<media::SpatializationLevel>* levels) override;
	@@ -138,6 +142,8 @@ class Spatializer : public media::BnSpatializer,
	/** Gets the channel mask, sampling rate and format set for the spatializer input. */		/** Gets the channel mask, sampling rate and format set for the spatializer input. */
	audio_config_base_t getAudioInConfig() const;		audio_config_base_t getAudioInConfig() const;

			void calculateHeadPose();

	/** An implementation of an IEffect interface that can be used to pass advanced parameters to		/** An implementation of an IEffect interface that can be used to pass advanced parameters to
	* the spatializer engine. All APis are noop (i.e. the interface cannot be used to control		* the spatializer engine. All APis are noop (i.e. the interface cannot be used to control
	* the effect) except for passing parameters via the command() API. */		* the effect) except for passing parameters via the command() API. */
	@@ -176,7 +182,9 @@ private:
	void onHeadToStagePose(const media::Pose3f& headToStage) override;		void onHeadToStagePose(const media::Pose3f& headToStage) override;
	void onActualModeChange(media::HeadTrackingMode mode) override;		void onActualModeChange(media::HeadTrackingMode mode) override;

	void calculateHeadPose();		void onHeadToStagePoseMsg(const std::vector<float>& headToStage);
			void onActualModeChangeMsg(media::HeadTrackingMode mode);


	static ConversionResult<ASensorRef> getSensorFromHandle(int handle);		static ConversionResult<ASensorRef> getSensorFromHandle(int handle);

	@@ -251,6 +259,8 @@ private:
	return mEngine->setParameter(p);		return mEngine->setParameter(p);
	}		}

			void postFramesProcessedMsg(int frames);

	/** Effect engine descriptor */		/** Effect engine descriptor */
	const effect_descriptor_t mEngineDescriptor;		const effect_descriptor_t mEngineDescriptor;
	/** Callback interface to parent audio policy service */		/** Callback interface to parent audio policy service */
	@@ -298,6 +308,14 @@ private:
	std::vector<media::SpatializationMode> mSpatializationModes;		std::vector<media::SpatializationMode> mSpatializationModes;
	std::vector<audio_channel_mask_t> mChannelMasks;		std::vector<audio_channel_mask_t> mChannelMasks;
	bool mSupportsHeadTracking;		bool mSupportsHeadTracking;

			// Looper thread for mEngine callbacks
			class EngineCallbackHandler;

			sp<ALooper> mLooper;
			sp<EngineCallbackHandler> mHandler;

			static const std::vector<const char *> sHeadPoseKeys;
	};		};