Merge "Update Spatialization and HeadTracking AIDL usage" into main (a8c34f8d) · Commits · e / os / android_frameworks_base

media/Android.bp

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,10 @@ aidl_interface {
	name: "soundtrigger_middleware-aidl",		name: "soundtrigger_middleware-aidl",
	unstable: true,		unstable: true,
	local_include_dir: "aidl",		local_include_dir: "aidl",
			defaults: [
			"latest_android_media_audio_common_types_import_interface",
			"latest_android_media_soundtrigger_types_import_interface",
			],
	backend: {		backend: {
	java: {		java: {
	sdk_version: "module_current",		sdk_version: "module_current",
	@@ -32,8 +36,6 @@ aidl_interface {
	"aidl/android/media/soundtrigger_middleware/*.aidl",		"aidl/android/media/soundtrigger_middleware/*.aidl",
	],		],
	imports: [		imports: [
	"android.media.audio.common.types-V2",
	"android.media.soundtrigger.types-V1",
	"media_permission-aidl",		"media_permission-aidl",
	],		],
	}		}

services/core/java/com/android/server/audio/SpatializerHelper.java

+43 −45

Original line number	Original line	Diff line number	Diff line
	@@ -39,10 +39,9 @@ import android.media.ISpatializerHeadTrackingCallback;
	import android.media.ISpatializerHeadTrackingModeCallback;		import android.media.ISpatializerHeadTrackingModeCallback;
	import android.media.ISpatializerOutputCallback;		import android.media.ISpatializerOutputCallback;
	import android.media.MediaMetrics;		import android.media.MediaMetrics;
	import android.media.SpatializationLevel;
	import android.media.SpatializationMode;
	import android.media.Spatializer;		import android.media.Spatializer;
	import android.media.SpatializerHeadTrackingMode;		import android.media.audio.common.HeadTracking;
			import android.media.audio.common.Spatialization;
	import android.os.RemoteCallbackList;		import android.os.RemoteCallbackList;
	import android.os.RemoteException;		import android.os.RemoteException;
	import android.text.TextUtils;		import android.text.TextUtils;
	@@ -84,22 +83,22 @@ public class SpatializerHelper {

	/package/ static final SparseIntArray SPAT_MODE_FOR_DEVICE_TYPE = new SparseIntArray(14) {		/package/ static final SparseIntArray SPAT_MODE_FOR_DEVICE_TYPE = new SparseIntArray(14) {
	{		{
	append(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_WIRED_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_WIRED_HEADSET, Spatialization.Mode.BINAURAL);
	append(AudioDeviceInfo.TYPE_WIRED_HEADPHONES, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_WIRED_HEADPHONES, Spatialization.Mode.BINAURAL);
	// assumption for A2DP: mostly headsets		// assumption for A2DP: mostly headsets
	append(AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, Spatialization.Mode.BINAURAL);
	append(AudioDeviceInfo.TYPE_DOCK, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_DOCK, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_USB_ACCESSORY, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_USB_ACCESSORY, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_USB_DEVICE, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_USB_DEVICE, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_USB_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_USB_HEADSET, Spatialization.Mode.BINAURAL);
	append(AudioDeviceInfo.TYPE_LINE_ANALOG, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_LINE_ANALOG, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_LINE_DIGITAL, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_LINE_DIGITAL, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_AUX_LINE, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_AUX_LINE, Spatialization.Mode.TRANSAURAL);
	append(AudioDeviceInfo.TYPE_BLE_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_BLE_HEADSET, Spatialization.Mode.BINAURAL);
	append(AudioDeviceInfo.TYPE_BLE_SPEAKER, SpatializationMode.SPATIALIZER_TRANSAURAL);		append(AudioDeviceInfo.TYPE_BLE_SPEAKER, Spatialization.Mode.TRANSAURAL);
	// assumption that BLE broadcast would be mostly consumed on headsets		// assumption that BLE broadcast would be mostly consumed on headsets
	append(AudioDeviceInfo.TYPE_BLE_BROADCAST, SpatializationMode.SPATIALIZER_BINAURAL);		append(AudioDeviceInfo.TYPE_BLE_BROADCAST, Spatialization.Mode.BINAURAL);
	}		}
	};		};

	@@ -226,12 +225,12 @@ public class SpatializerHelper {
	ArrayList<Integer> list = new ArrayList<>(0);		ArrayList<Integer> list = new ArrayList<>(0);
	for (byte value : values) {		for (byte value : values) {
	switch (value) {		switch (value) {
	case SpatializerHeadTrackingMode.OTHER:		case HeadTracking.Mode.OTHER:
	case SpatializerHeadTrackingMode.DISABLED:		case HeadTracking.Mode.DISABLED:
	// not expected here, skip		// not expected here, skip
	break;		break;
	case SpatializerHeadTrackingMode.RELATIVE_WORLD:		case HeadTracking.Mode.RELATIVE_WORLD:
	case SpatializerHeadTrackingMode.RELATIVE_SCREEN:		case HeadTracking.Mode.RELATIVE_SCREEN:
	list.add(headTrackingModeTypeToSpatializerInt(value));		list.add(headTrackingModeTypeToSpatializerInt(value));
	break;		break;
	default:		default:
	@@ -254,10 +253,10 @@ public class SpatializerHelper {
	byte[] spatModes = spat.getSupportedModes();		byte[] spatModes = spat.getSupportedModes();
	for (byte mode : spatModes) {		for (byte mode : spatModes) {
	switch (mode) {		switch (mode) {
	case SpatializationMode.SPATIALIZER_BINAURAL:		case Spatialization.Mode.BINAURAL:
	mBinauralSupported = true;		mBinauralSupported = true;
	break;		break;
	case SpatializationMode.SPATIALIZER_TRANSAURAL:		case Spatialization.Mode.TRANSAURAL:
	mTransauralSupported = true;		mTransauralSupported = true;
	break;		break;
	default:		default:
	@@ -274,8 +273,8 @@ public class SpatializerHelper {
	// initialize list of compatible devices		// initialize list of compatible devices
	for (int i = 0; i < SPAT_MODE_FOR_DEVICE_TYPE.size(); i++) {		for (int i = 0; i < SPAT_MODE_FOR_DEVICE_TYPE.size(); i++) {
	int mode = SPAT_MODE_FOR_DEVICE_TYPE.valueAt(i);		int mode = SPAT_MODE_FOR_DEVICE_TYPE.valueAt(i);
	if ((mode == (int) SpatializationMode.SPATIALIZER_BINAURAL && mBinauralSupported)		if ((mode == (int) Spatialization.Mode.BINAURAL && mBinauralSupported)
	\|\| (mode == (int) SpatializationMode.SPATIALIZER_TRANSAURAL		\|\| (mode == (int) Spatialization.Mode.TRANSAURAL
	&& mTransauralSupported)) {		&& mTransauralSupported)) {
	mSACapableDeviceTypes.add(SPAT_MODE_FOR_DEVICE_TYPE.keyAt(i));		mSACapableDeviceTypes.add(SPAT_MODE_FOR_DEVICE_TYPE.keyAt(i));
	}		}
	@@ -577,9 +576,9 @@ public class SpatializerHelper {

	int spatMode = SPAT_MODE_FOR_DEVICE_TYPE.get(device.getDeviceType(),		int spatMode = SPAT_MODE_FOR_DEVICE_TYPE.get(device.getDeviceType(),
	Integer.MIN_VALUE);		Integer.MIN_VALUE);
	device.setSAEnabled(spatMode == SpatializationMode.SPATIALIZER_BINAURAL		device.setSAEnabled(spatMode == Spatialization.Mode.BINAURAL
	? mBinauralEnabledDefault		? mBinauralEnabledDefault
	: spatMode == SpatializationMode.SPATIALIZER_TRANSAURAL		: spatMode == Spatialization.Mode.TRANSAURAL
	? mTransauralEnabledDefault		? mTransauralEnabledDefault
	: false);		: false);
	device.setHeadTrackerEnabled(mHeadTrackingEnabledDefault);		device.setHeadTrackerEnabled(mHeadTrackingEnabledDefault);
	@@ -629,9 +628,9 @@ public class SpatializerHelper {
	if (isBluetoothDevice(internalDeviceType)) return deviceType;		if (isBluetoothDevice(internalDeviceType)) return deviceType;

	final int spatMode = SPAT_MODE_FOR_DEVICE_TYPE.get(deviceType, Integer.MIN_VALUE);		final int spatMode = SPAT_MODE_FOR_DEVICE_TYPE.get(deviceType, Integer.MIN_VALUE);
	if (spatMode == SpatializationMode.SPATIALIZER_TRANSAURAL) {		if (spatMode == Spatialization.Mode.TRANSAURAL) {
	return AudioDeviceInfo.TYPE_BUILTIN_SPEAKER;		return AudioDeviceInfo.TYPE_BUILTIN_SPEAKER;
	} else if (spatMode == SpatializationMode.SPATIALIZER_BINAURAL) {		} else if (spatMode == Spatialization.Mode.BINAURAL) {
	return AudioDeviceInfo.TYPE_WIRED_HEADPHONES;		return AudioDeviceInfo.TYPE_WIRED_HEADPHONES;
	}		}
	return AudioDeviceInfo.TYPE_UNKNOWN;		return AudioDeviceInfo.TYPE_UNKNOWN;
	@@ -690,8 +689,7 @@ public class SpatializerHelper {
	// since their physical characteristics are unknown		// since their physical characteristics are unknown
	if (deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_UNKNOWN		if (deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_UNKNOWN
	\|\| deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_HEADPHONES) {		\|\| deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_HEADPHONES) {
	available = (spatMode == SpatializationMode.SPATIALIZER_BINAURAL)		available = (spatMode == Spatialization.Mode.BINAURAL) && mBinauralSupported;
	&& mBinauralSupported;
	} else {		} else {
	available = false;		available = false;
	}		}
	@@ -804,8 +802,8 @@ public class SpatializerHelper {
	// not be included.		// not be included.
	final byte modeForDevice = (byte) SPAT_MODE_FOR_DEVICE_TYPE.get(ada.getType(),		final byte modeForDevice = (byte) SPAT_MODE_FOR_DEVICE_TYPE.get(ada.getType(),
	/default when type not found/ -1);		/default when type not found/ -1);
	if ((modeForDevice == SpatializationMode.SPATIALIZER_BINAURAL && mBinauralSupported)		if ((modeForDevice == Spatialization.Mode.BINAURAL && mBinauralSupported)
	\|\| (modeForDevice == SpatializationMode.SPATIALIZER_TRANSAURAL		\|\| (modeForDevice == Spatialization.Mode.TRANSAURAL
	&& mTransauralSupported)) {		&& mTransauralSupported)) {
	return true;		return true;
	}		}
	@@ -1479,7 +1477,7 @@ public class SpatializerHelper {
	}		}

	synchronized void onInitSensors() {		synchronized void onInitSensors() {
	final boolean init = mFeatureEnabled && (mSpatLevel != SpatializationLevel.NONE);		final boolean init = mFeatureEnabled && (mSpatLevel != Spatialization.Level.NONE);
	final String action = init ? "initializing" : "releasing";		final String action = init ? "initializing" : "releasing";
	if (mSpat == null) {		if (mSpat == null) {
	logloge("not " + action + " sensors, null spatializer");		logloge("not " + action + " sensors, null spatializer");
	@@ -1545,13 +1543,13 @@ public class SpatializerHelper {
	// SDK <-> AIDL converters		// SDK <-> AIDL converters
	private static int headTrackingModeTypeToSpatializerInt(byte mode) {		private static int headTrackingModeTypeToSpatializerInt(byte mode) {
	switch (mode) {		switch (mode) {
	case SpatializerHeadTrackingMode.OTHER:		case HeadTracking.Mode.OTHER:
	return Spatializer.HEAD_TRACKING_MODE_OTHER;		return Spatializer.HEAD_TRACKING_MODE_OTHER;
	case SpatializerHeadTrackingMode.DISABLED:		case HeadTracking.Mode.DISABLED:
	return Spatializer.HEAD_TRACKING_MODE_DISABLED;		return Spatializer.HEAD_TRACKING_MODE_DISABLED;
	case SpatializerHeadTrackingMode.RELATIVE_WORLD:		case HeadTracking.Mode.RELATIVE_WORLD:
	return Spatializer.HEAD_TRACKING_MODE_RELATIVE_WORLD;		return Spatializer.HEAD_TRACKING_MODE_RELATIVE_WORLD;
	case SpatializerHeadTrackingMode.RELATIVE_SCREEN:		case HeadTracking.Mode.RELATIVE_SCREEN:
	return Spatializer.HEAD_TRACKING_MODE_RELATIVE_DEVICE;		return Spatializer.HEAD_TRACKING_MODE_RELATIVE_DEVICE;
	default:		default:
	throw (new IllegalArgumentException("Unexpected head tracking mode:" + mode));		throw (new IllegalArgumentException("Unexpected head tracking mode:" + mode));
	@@ -1561,13 +1559,13 @@ public class SpatializerHelper {
	private static byte spatializerIntToHeadTrackingModeType(int sdkMode) {		private static byte spatializerIntToHeadTrackingModeType(int sdkMode) {
	switch (sdkMode) {		switch (sdkMode) {
	case Spatializer.HEAD_TRACKING_MODE_OTHER:		case Spatializer.HEAD_TRACKING_MODE_OTHER:
	return SpatializerHeadTrackingMode.OTHER;		return HeadTracking.Mode.OTHER;
	case Spatializer.HEAD_TRACKING_MODE_DISABLED:		case Spatializer.HEAD_TRACKING_MODE_DISABLED:
	return SpatializerHeadTrackingMode.DISABLED;		return HeadTracking.Mode.DISABLED;
	case Spatializer.HEAD_TRACKING_MODE_RELATIVE_WORLD:		case Spatializer.HEAD_TRACKING_MODE_RELATIVE_WORLD:
	return SpatializerHeadTrackingMode.RELATIVE_WORLD;		return HeadTracking.Mode.RELATIVE_WORLD;
	case Spatializer.HEAD_TRACKING_MODE_RELATIVE_DEVICE:		case Spatializer.HEAD_TRACKING_MODE_RELATIVE_DEVICE:
	return SpatializerHeadTrackingMode.RELATIVE_SCREEN;		return HeadTracking.Mode.RELATIVE_SCREEN;
	default:		default:
	throw (new IllegalArgumentException("Unexpected head tracking mode:" + sdkMode));		throw (new IllegalArgumentException("Unexpected head tracking mode:" + sdkMode));
	}		}
	@@ -1575,11 +1573,11 @@ public class SpatializerHelper {

	private static int spatializationLevelToSpatializerInt(byte level) {		private static int spatializationLevelToSpatializerInt(byte level) {
	switch (level) {		switch (level) {
	case SpatializationLevel.NONE:		case Spatialization.Level.NONE:
	return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_NONE;		return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_NONE;
	case SpatializationLevel.SPATIALIZER_MULTICHANNEL:		case Spatialization.Level.MULTICHANNEL:
	return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_MULTICHANNEL;		return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_MULTICHANNEL;
	case SpatializationLevel.SPATIALIZER_MCHAN_BED_PLUS_OBJECTS:		case Spatialization.Level.BED_PLUS_OBJECTS:
	return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_MCHAN_BED_PLUS_OBJECTS;		return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_MCHAN_BED_PLUS_OBJECTS;
	default:		default:
	throw (new IllegalArgumentException("Unexpected spatializer level:" + level));		throw (new IllegalArgumentException("Unexpected spatializer level:" + level));