Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 37bb027c authored by Shunkai Yao's avatar Shunkai Yao
Browse files

Update Spatialization and HeadTracking AIDL usage 

Bug: 273373363
Test: m
Change-Id: Id5b2ffba2131aebf0ec6656511f2f10f79db7567
Merged-In: Id5b2ffba2131aebf0ec6656511f2f10f79db7567
parent d4d9479b

media/Android.bp

+4 −2
Original line number Diff line number Diff line
@@ -23,6 +23,10 @@ aidl_interface { 
    name: "soundtrigger_middleware-aidl",

    unstable: true,

    local_include_dir: "aidl",

    defaults: [

        "latest_android_media_audio_common_types_import_interface",

        "latest_android_media_soundtrigger_types_import_interface",

    ],

    backend: {

        java: {

            sdk_version: "module_current",
@@ -32,8 +36,6 @@ aidl_interface { 
        "aidl/android/media/soundtrigger_middleware/*.aidl",

    ],

    imports: [

        "android.media.audio.common.types-V2",

        "android.media.soundtrigger.types-V1",

        "media_permission-aidl",

    ],

}

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

+43 −45
Original line number Diff line number Diff line
@@ -39,10 +39,9 @@ import android.media.ISpatializerHeadTrackingCallback; 
import android.media.ISpatializerHeadTrackingModeCallback;

import android.media.ISpatializerOutputCallback;

import android.media.MediaMetrics;

import android.media.SpatializationLevel;

import android.media.SpatializationMode;

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.RemoteException;

import android.text.TextUtils;
@@ -84,22 +83,22 @@ public class SpatializerHelper { 


    /*package*/ static final SparseIntArray SPAT_MODE_FOR_DEVICE_TYPE = new SparseIntArray(14) {

        {

            append(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_WIRED_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);

            append(AudioDeviceInfo.TYPE_WIRED_HEADPHONES, SpatializationMode.SPATIALIZER_BINAURAL);

            append(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_WIRED_HEADSET, Spatialization.Mode.BINAURAL);

            append(AudioDeviceInfo.TYPE_WIRED_HEADPHONES, Spatialization.Mode.BINAURAL);

            // assumption for A2DP: mostly headsets

            append(AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, SpatializationMode.SPATIALIZER_BINAURAL);

            append(AudioDeviceInfo.TYPE_DOCK, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_ACCESSORY, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_DEVICE, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);

            append(AudioDeviceInfo.TYPE_LINE_ANALOG, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_LINE_DIGITAL, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_AUX_LINE, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_BLE_HEADSET, SpatializationMode.SPATIALIZER_BINAURAL);

            append(AudioDeviceInfo.TYPE_BLE_SPEAKER, SpatializationMode.SPATIALIZER_TRANSAURAL);

            append(AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, Spatialization.Mode.BINAURAL);

            append(AudioDeviceInfo.TYPE_DOCK, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_ACCESSORY, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_DEVICE, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_USB_HEADSET, Spatialization.Mode.BINAURAL);

            append(AudioDeviceInfo.TYPE_LINE_ANALOG, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_LINE_DIGITAL, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_AUX_LINE, Spatialization.Mode.TRANSAURAL);

            append(AudioDeviceInfo.TYPE_BLE_HEADSET, Spatialization.Mode.BINAURAL);

            append(AudioDeviceInfo.TYPE_BLE_SPEAKER, Spatialization.Mode.TRANSAURAL);

            // 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);

                for (byte value : values) {

                    switch (value) {

                        case SpatializerHeadTrackingMode.OTHER:

                        case SpatializerHeadTrackingMode.DISABLED:

                        case HeadTracking.Mode.OTHER:

                        case HeadTracking.Mode.DISABLED:

                            // not expected here, skip

                            break;

                        case SpatializerHeadTrackingMode.RELATIVE_WORLD:

                        case SpatializerHeadTrackingMode.RELATIVE_SCREEN:

                        case HeadTracking.Mode.RELATIVE_WORLD:

                        case HeadTracking.Mode.RELATIVE_SCREEN:

                            list.add(headTrackingModeTypeToSpatializerInt(value));

                            break;

                        default:
@@ -254,10 +253,10 @@ public class SpatializerHelper { 
            byte[] spatModes = spat.getSupportedModes();

            for (byte mode : spatModes) {

                switch (mode) {

                    case SpatializationMode.SPATIALIZER_BINAURAL:

                    case Spatialization.Mode.BINAURAL:

                        mBinauralSupported = true;

                        break;

                    case SpatializationMode.SPATIALIZER_TRANSAURAL:

                    case Spatialization.Mode.TRANSAURAL:

                        mTransauralSupported = true;

                        break;

                    default:
@@ -274,8 +273,8 @@ public class SpatializerHelper { 
            // initialize list of compatible devices

            for (int i = 0; i < SPAT_MODE_FOR_DEVICE_TYPE.size(); i++) {

                int mode = SPAT_MODE_FOR_DEVICE_TYPE.valueAt(i);

                if ((mode == (int) SpatializationMode.SPATIALIZER_BINAURAL && mBinauralSupported)

                        || (mode == (int) SpatializationMode.SPATIALIZER_TRANSAURAL

                if ((mode == (int) Spatialization.Mode.BINAURAL && mBinauralSupported)

                        || (mode == (int) Spatialization.Mode.TRANSAURAL

                            && mTransauralSupported)) {

                    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(),

                Integer.MIN_VALUE);

        device.setSAEnabled(spatMode == SpatializationMode.SPATIALIZER_BINAURAL

        device.setSAEnabled(spatMode == Spatialization.Mode.BINAURAL

                ? mBinauralEnabledDefault

                : spatMode == SpatializationMode.SPATIALIZER_TRANSAURAL

                : spatMode == Spatialization.Mode.TRANSAURAL

                        ? mTransauralEnabledDefault

                        : false);

        device.setHeadTrackerEnabled(mHeadTrackingEnabledDefault);
@@ -629,9 +628,9 @@ public class SpatializerHelper { 
        if (isBluetoothDevice(internalDeviceType)) return deviceType;



        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;

        } else if (spatMode == SpatializationMode.SPATIALIZER_BINAURAL) {

        } else if (spatMode == Spatialization.Mode.BINAURAL) {

            return AudioDeviceInfo.TYPE_WIRED_HEADPHONES;

        }

        return AudioDeviceInfo.TYPE_UNKNOWN;
@@ -690,8 +689,7 @@ public class SpatializerHelper { 
            // since their physical characteristics are unknown

            if (deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_UNKNOWN

                    || deviceState.getAudioDeviceCategory() == AUDIO_DEVICE_CATEGORY_HEADPHONES) {

                available = (spatMode == SpatializationMode.SPATIALIZER_BINAURAL)

                        && mBinauralSupported;

                available = (spatMode == Spatialization.Mode.BINAURAL) && mBinauralSupported;

            } else {

                available = false;

            }
@@ -804,8 +802,8 @@ public class SpatializerHelper { 
        // not be included.

        final byte modeForDevice = (byte) SPAT_MODE_FOR_DEVICE_TYPE.get(ada.getType(),

                /*default when type not found*/ -1);

        if ((modeForDevice == SpatializationMode.SPATIALIZER_BINAURAL && mBinauralSupported)

                || (modeForDevice == SpatializationMode.SPATIALIZER_TRANSAURAL

        if ((modeForDevice == Spatialization.Mode.BINAURAL && mBinauralSupported)

                || (modeForDevice == Spatialization.Mode.TRANSAURAL

                        && mTransauralSupported)) {

            return true;

        }
@@ -1479,7 +1477,7 @@ public class SpatializerHelper { 
    }



    synchronized void onInitSensors() {

        final boolean init = mFeatureEnabled && (mSpatLevel != SpatializationLevel.NONE);

        final boolean init = mFeatureEnabled && (mSpatLevel != Spatialization.Level.NONE);

        final String action = init ? "initializing" : "releasing";

        if (mSpat == null) {

            logloge("not " + action + " sensors, null spatializer");
@@ -1545,13 +1543,13 @@ public class SpatializerHelper { 
    // SDK <-> AIDL converters

    private static int headTrackingModeTypeToSpatializerInt(byte mode) {

        switch (mode) {

            case SpatializerHeadTrackingMode.OTHER:

            case HeadTracking.Mode.OTHER:

                return Spatializer.HEAD_TRACKING_MODE_OTHER;

            case SpatializerHeadTrackingMode.DISABLED:

            case HeadTracking.Mode.DISABLED:

                return Spatializer.HEAD_TRACKING_MODE_DISABLED;

            case SpatializerHeadTrackingMode.RELATIVE_WORLD:

            case HeadTracking.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;

            default:

                throw (new IllegalArgumentException("Unexpected head tracking mode:" + mode));
@@ -1561,13 +1559,13 @@ public class SpatializerHelper { 
    private static byte spatializerIntToHeadTrackingModeType(int sdkMode) {

        switch (sdkMode) {

            case Spatializer.HEAD_TRACKING_MODE_OTHER:

                return SpatializerHeadTrackingMode.OTHER;

                return HeadTracking.Mode.OTHER;

            case Spatializer.HEAD_TRACKING_MODE_DISABLED:

                return SpatializerHeadTrackingMode.DISABLED;

                return HeadTracking.Mode.DISABLED;

            case Spatializer.HEAD_TRACKING_MODE_RELATIVE_WORLD:

                return SpatializerHeadTrackingMode.RELATIVE_WORLD;

                return HeadTracking.Mode.RELATIVE_WORLD;

            case Spatializer.HEAD_TRACKING_MODE_RELATIVE_DEVICE:

                return SpatializerHeadTrackingMode.RELATIVE_SCREEN;

                return HeadTracking.Mode.RELATIVE_SCREEN;

            default:

                throw (new IllegalArgumentException("Unexpected head tracking mode:" + sdkMode));

        }
@@ -1575,11 +1573,11 @@ public class SpatializerHelper { 


    private static int spatializationLevelToSpatializerInt(byte level) {

        switch (level) {

            case SpatializationLevel.NONE:

            case Spatialization.Level.NONE:

                return Spatializer.SPATIALIZER_IMMERSIVE_LEVEL_NONE;

            case SpatializationLevel.SPATIALIZER_MULTICHANNEL:

            case Spatialization.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;

            default:

                throw (new IllegalArgumentException("Unexpected spatializer level:" + level));