Merge "Add support for manually set surround formats." into pi-dev
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 29bbddc..664442f 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -58,6 +58,7 @@
import android.database.Cursor;
import android.database.SQLException;
import android.location.LocationManager;
+import android.media.AudioFormat;
import android.net.ConnectivityManager;
import android.net.NetworkScoreManager;
import android.net.Uri;
@@ -11308,15 +11309,66 @@
public static final int ENCODED_SURROUND_OUTPUT_ALWAYS = 2;
/**
+ * Surround sound formats are available according to the choice
+ * of user, even if they are not detected by the hardware. Those
+ * formats will be reported as part of the HDMI output capability.
+ * Applications are then free to use either PCM or encoded output.
+ *
+ * An example use case would be an AVR that doesn't report a surround
+ * format while the user knows the AVR does support it.
+ * @hide
+ */
+ public static final int ENCODED_SURROUND_OUTPUT_MANUAL = 3;
+
+ /**
* Set to ENCODED_SURROUND_OUTPUT_AUTO,
- * ENCODED_SURROUND_OUTPUT_NEVER or
- * ENCODED_SURROUND_OUTPUT_ALWAYS
+ * ENCODED_SURROUND_OUTPUT_NEVER,
+ * ENCODED_SURROUND_OUTPUT_ALWAYS or
+ * ENCODED_SURROUND_OUTPUT_MANUAL
* @hide
*/
public static final String ENCODED_SURROUND_OUTPUT = "encoded_surround_output";
private static final Validator ENCODED_SURROUND_OUTPUT_VALIDATOR =
- new SettingsValidators.DiscreteValueValidator(new String[] {"0", "1", "2"});
+ new SettingsValidators.DiscreteValueValidator(new String[] {"0", "1", "2", "3"});
+
+ /**
+ * Surround sounds formats that are enabled when ENCODED_SURROUND_OUTPUT is set to
+ * ENCODED_SURROUND_OUTPUT_MANUAL. Encoded as comma separated list. Allowed values
+ * are the format constants defined in AudioFormat.java. Ex:
+ *
+ * "5,6"
+ *
+ * @hide
+ */
+ public static final String ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS =
+ "encoded_surround_output_enabled_formats";
+
+ private static final Validator ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS_VALIDATOR =
+ new Validator() {
+ @Override
+ public boolean validate(String value) {
+ try {
+ String[] surroundFormats = TextUtils.split(value, ",");
+ for (String format : surroundFormats) {
+ int audioFormat = Integer.valueOf(format);
+ boolean isSurroundFormat = false;
+ for (int sf : AudioFormat.SURROUND_SOUND_ENCODING) {
+ if (sf == audioFormat) {
+ isSurroundFormat = true;
+ break;
+ }
+ }
+ if (!isSurroundFormat) {
+ return false;
+ }
+ }
+ return true;
+ } catch (NumberFormatException e) {
+ return false;
+ }
+ }
+ };
/**
* Persisted safe headphone volume management state by AudioService
@@ -11963,6 +12015,7 @@
CALL_AUTO_RETRY,
DOCK_AUDIO_MEDIA_ENABLED,
ENCODED_SURROUND_OUTPUT,
+ ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS,
LOW_POWER_MODE_TRIGGER_LEVEL,
BLUETOOTH_ON,
PRIVATE_DNS_MODE,
@@ -11999,6 +12052,8 @@
VALIDATORS.put(CALL_AUTO_RETRY, CALL_AUTO_RETRY_VALIDATOR);
VALIDATORS.put(DOCK_AUDIO_MEDIA_ENABLED, DOCK_AUDIO_MEDIA_ENABLED_VALIDATOR);
VALIDATORS.put(ENCODED_SURROUND_OUTPUT, ENCODED_SURROUND_OUTPUT_VALIDATOR);
+ VALIDATORS.put(ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS,
+ ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS_VALIDATOR);
VALIDATORS.put(LOW_POWER_MODE_TRIGGER_LEVEL, LOW_POWER_MODE_TRIGGER_LEVEL_VALIDATOR);
VALIDATORS.put(LOW_POWER_MODE_TRIGGER_LEVEL_MAX,
LOW_POWER_MODE_TRIGGER_LEVEL_VALIDATOR);
diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp
index adaff1f..04918ba 100644
--- a/core/jni/android_media_AudioSystem.cpp
+++ b/core/jni/android_media_AudioSystem.cpp
@@ -48,6 +48,15 @@
jmethodID toArray;
} gArrayListMethods;
+static jclass gBooleanClass;
+static jmethodID gBooleanCstor;
+
+static jclass gIntegerClass;
+static jmethodID gIntegerCstor;
+
+static jclass gMapClass;
+static jmethodID gMapPut;
+
static jclass gAudioHandleClass;
static jmethodID gAudioHandleCstor;
static struct {
@@ -1829,6 +1838,72 @@
return jStatus;
}
+static jint
+android_media_AudioSystem_getSurroundFormats(JNIEnv *env, jobject thiz,
+ jobject jSurroundFormats, jboolean reported)
+{
+ ALOGV("getSurroundFormats");
+
+ if (jSurroundFormats == NULL) {
+ ALOGE("jSurroundFormats is NULL");
+ return (jint)AUDIO_JAVA_BAD_VALUE;
+ }
+ if (!env->IsInstanceOf(jSurroundFormats, gMapClass)) {
+ ALOGE("getSurroundFormats not a map");
+ return (jint)AUDIO_JAVA_BAD_VALUE;
+ }
+
+ jint jStatus;
+ unsigned int numSurroundFormats = 0;
+ audio_format_t *surroundFormats = NULL;
+ bool *surroundFormatsEnabled = NULL;
+ status_t status = AudioSystem::getSurroundFormats(
+ &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
+ if (status != NO_ERROR) {
+ ALOGE_IF(status != NO_ERROR, "AudioSystem::getSurroundFormats error %d", status);
+ jStatus = nativeToJavaStatus(status);
+ goto exit;
+ }
+ if (numSurroundFormats == 0) {
+ jStatus = (jint)AUDIO_JAVA_SUCCESS;
+ goto exit;
+ }
+ surroundFormats = (audio_format_t *)calloc(numSurroundFormats, sizeof(audio_format_t));
+ surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool));
+ status = AudioSystem::getSurroundFormats(
+ &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
+ jStatus = nativeToJavaStatus(status);
+ if (status != NO_ERROR) {
+ ALOGE_IF(status != NO_ERROR, "AudioSystem::getSurroundFormats error %d", status);
+ goto exit;
+ }
+ for (size_t i = 0; i < numSurroundFormats; i++) {
+ jobject surroundFormat = env->NewObject(gIntegerClass, gIntegerCstor,
+ audioFormatFromNative(surroundFormats[i]));
+ jobject enabled = env->NewObject(gBooleanClass, gBooleanCstor, surroundFormatsEnabled[i]);
+ env->CallObjectMethod(jSurroundFormats, gMapPut, surroundFormat, enabled);
+ env->DeleteLocalRef(surroundFormat);
+ env->DeleteLocalRef(enabled);
+ }
+
+exit:
+ free(surroundFormats);
+ free(surroundFormatsEnabled);
+ return jStatus;
+}
+
+static jint
+android_media_AudioSystem_setSurroundFormatEnabled(JNIEnv *env, jobject thiz,
+ jint audioFormat, jboolean enabled)
+{
+ status_t status = AudioSystem::setSurroundFormatEnabled(audioFormatToNative(audioFormat),
+ (bool)enabled);
+ if (status != NO_ERROR) {
+ ALOGE_IF(status != NO_ERROR, "AudioSystem::setSurroundFormatEnabled error %d", status);
+ }
+ return (jint)nativeToJavaStatus(status);
+}
+
// ----------------------------------------------------------------------------
static const JNINativeMethod gMethods[] = {
@@ -1884,6 +1959,8 @@
{"getStreamVolumeDB", "(III)F", (void *)android_media_AudioSystem_getStreamVolumeDB},
{"native_is_offload_supported", "(IIII)Z", (void *)android_media_AudioSystem_isOffloadSupported},
{"getMicrophones", "(Ljava/util/ArrayList;)I", (void *)android_media_AudioSystem_getMicrophones},
+ {"getSurroundFormats", "(Ljava/util/Map;Z)I", (void *)android_media_AudioSystem_getSurroundFormats},
+ {"setSurroundFormatEnabled", "(IZ)I", (void *)android_media_AudioSystem_setSurroundFormatEnabled},
};
@@ -1903,6 +1980,18 @@
gArrayListMethods.add = GetMethodIDOrDie(env, arrayListClass, "add", "(Ljava/lang/Object;)Z");
gArrayListMethods.toArray = GetMethodIDOrDie(env, arrayListClass, "toArray", "()[Ljava/lang/Object;");
+ jclass booleanClass = FindClassOrDie(env, "java/lang/Boolean");
+ gBooleanClass = MakeGlobalRefOrDie(env, booleanClass);
+ gBooleanCstor = GetMethodIDOrDie(env, booleanClass, "<init>", "(Z)V");
+
+ jclass integerClass = FindClassOrDie(env, "java/lang/Integer");
+ gIntegerClass = MakeGlobalRefOrDie(env, integerClass);
+ gIntegerCstor = GetMethodIDOrDie(env, integerClass, "<init>", "(I)V");
+
+ jclass mapClass = FindClassOrDie(env, "java/util/Map");
+ gMapClass = MakeGlobalRefOrDie(env, mapClass);
+ gMapPut = GetMethodIDOrDie(env, mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
jclass audioHandleClass = FindClassOrDie(env, "android/media/AudioHandle");
gAudioHandleClass = MakeGlobalRefOrDie(env, audioHandleClass);
gAudioHandleCstor = GetMethodIDOrDie(env, audioHandleClass, "<init>", "(I)V");
diff --git a/media/java/android/media/AudioFormat.java b/media/java/android/media/AudioFormat.java
index d0a2c98..e245425 100644
--- a/media/java/android/media/AudioFormat.java
+++ b/media/java/android/media/AudioFormat.java
@@ -1074,4 +1074,58 @@
@Retention(RetentionPolicy.SOURCE)
public @interface Encoding {}
+ /** @hide */
+ public static final int[] SURROUND_SOUND_ENCODING = {
+ ENCODING_AC3,
+ ENCODING_E_AC3,
+ ENCODING_DTS,
+ ENCODING_DTS_HD,
+ ENCODING_AAC_LC,
+ ENCODING_DOLBY_TRUEHD,
+ ENCODING_E_AC3_JOC,
+ };
+
+ /** @hide */
+ @IntDef(flag = false, prefix = "ENCODING", value = {
+ ENCODING_AC3,
+ ENCODING_E_AC3,
+ ENCODING_DTS,
+ ENCODING_DTS_HD,
+ ENCODING_AAC_LC,
+ ENCODING_DOLBY_TRUEHD,
+ ENCODING_E_AC3_JOC }
+ )
+ @Retention(RetentionPolicy.SOURCE)
+ public @interface SurroundSoundEncoding {}
+
+ /**
+ * @hide
+ *
+ * Return default name for a surround format. This is not an International name.
+ * It is just a default to use if an international name is not available.
+ *
+ * @param audioFormat a surround format
+ * @return short default name for the format, eg. “AC3” for ENCODING_AC3.
+ */
+ public static String toDisplayName(@SurroundSoundEncoding int audioFormat) {
+ switch (audioFormat) {
+ case ENCODING_AC3:
+ return "Dolby Digital (AC3)";
+ case ENCODING_E_AC3:
+ return "Dolby Digital Plus (E_AC3)";
+ case ENCODING_DTS:
+ return "DTS";
+ case ENCODING_DTS_HD:
+ return "DTS HD";
+ case ENCODING_AAC_LC:
+ return "AAC";
+ case ENCODING_DOLBY_TRUEHD:
+ return "Dolby TrueHD";
+ case ENCODING_E_AC3_JOC:
+ return "Dolby Atmos";
+ default:
+ return "Unknown surround sound format";
+ }
+ }
+
}
diff --git a/media/java/android/media/AudioManager.java b/media/java/android/media/AudioManager.java
index 566db94..3057501 100644
--- a/media/java/android/media/AudioManager.java
+++ b/media/java/android/media/AudioManager.java
@@ -66,6 +66,7 @@
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
@@ -5014,6 +5015,66 @@
}
}
+ /**
+ * @hide
+ * Returns all surround formats.
+ * @return a map where the key is a surround format and
+ * the value indicates the surround format is enabled or not
+ */
+ public Map<Integer, Boolean> getSurroundFormats() {
+ Map<Integer, Boolean> surroundFormats = new HashMap<>();
+ int status = AudioSystem.getSurroundFormats(surroundFormats, false);
+ if (status != AudioManager.SUCCESS) {
+ // fail and bail!
+ Log.e(TAG, "getSurroundFormats failed:" + status);
+ return new HashMap<Integer, Boolean>(); // Always return a map.
+ }
+ return surroundFormats;
+ }
+
+ /**
+ * @hide
+ * Set a certain surround format as enabled or not.
+ * @param audioFormat a surround format, the value is one of
+ * {@link AudioFormat#ENCODING_AC3}, {@link AudioFormat#ENCODING_E_AC3},
+ * {@link AudioFormat#ENCODING_DTS}, {@link AudioFormat#ENCODING_DTS_HD},
+ * {@link AudioFormat#ENCODING_AAC_LC}, {@link AudioFormat#ENCODING_DOLBY_TRUEHD},
+ * {@link AudioFormat#ENCODING_E_AC3_JOC}. Once {@link AudioFormat#ENCODING_AAC_LC} is
+ * set as enabled, {@link AudioFormat#ENCODING_AAC_LC},
+ * {@link AudioFormat#ENCODING_AAC_HE_V1}, {@link AudioFormat#ENCODING_AAC_HE_V2},
+ * {@link AudioFormat#ENCODING_AAC_ELD}, {@link AudioFormat#ENCODING_AAC_XHE} are
+ * all enabled.
+ * @param enabled the required surround format state, true for enabled, false for disabled
+ * @return true if successful, otherwise false
+ */
+ public boolean setSurroundFormatEnabled(
+ @AudioFormat.SurroundSoundEncoding int audioFormat, boolean enabled) {
+ int status = AudioSystem.setSurroundFormatEnabled(audioFormat, enabled);
+ return status == AudioManager.SUCCESS;
+ }
+
+ /**
+ * @hide
+ * Returns all surround formats that are reported by the connected HDMI device.
+ * The keys are not affected by calling setSurroundFormatEnabled(), and the values
+ * are not affected by calling setSurroundFormatEnabled() when in AUTO mode.
+ * This information can used to show the AUTO setting for SurroundSound.
+ *
+ * @return a map where the key is a surround format and
+ * the value indicates the surround format is enabled or not
+ */
+ public Map<Integer, Boolean> getReportedSurroundFormats() {
+ Map<Integer, Boolean> reportedSurroundFormats = new HashMap<>();
+ int status = AudioSystem.getSurroundFormats(reportedSurroundFormats, true);
+ if (status != AudioManager.SUCCESS) {
+ // fail and bail!
+ Log.e(TAG, "getReportedSurroundFormats failed:" + status);
+ return new HashMap<Integer, Boolean>(); // Always return a map.
+ }
+ return reportedSurroundFormats;
+ }
+
+
//---------------------------------------------------------
// Inner classes
//--------------------
diff --git a/media/java/android/media/AudioSystem.java b/media/java/android/media/AudioSystem.java
index aaba1e3..7c893d0 100644
--- a/media/java/android/media/AudioSystem.java
+++ b/media/java/android/media/AudioSystem.java
@@ -23,6 +23,7 @@
import android.util.Log;
import java.util.ArrayList;
+import java.util.Map;
/* IF YOU CHANGE ANY OF THE CONSTANTS IN THIS FILE, DO NOT FORGET
* TO UPDATE THE CORRESPONDING NATIVE GLUE AND AudioManager.java.
@@ -715,7 +716,8 @@
public static final int FORCE_HDMI_SYSTEM_AUDIO_ENFORCED = 12;
public static final int FORCE_ENCODED_SURROUND_NEVER = 13;
public static final int FORCE_ENCODED_SURROUND_ALWAYS = 14;
- public static final int NUM_FORCE_CONFIG = 15;
+ public static final int FORCE_ENCODED_SURROUND_MANUAL = 15;
+ public static final int NUM_FORCE_CONFIG = 16;
public static final int FORCE_DEFAULT = FORCE_NONE;
public static String forceUseConfigToString(int config) {
@@ -735,6 +737,7 @@
case FORCE_HDMI_SYSTEM_AUDIO_ENFORCED: return "FORCE_HDMI_SYSTEM_AUDIO_ENFORCED";
case FORCE_ENCODED_SURROUND_NEVER: return "FORCE_ENCODED_SURROUND_NEVER";
case FORCE_ENCODED_SURROUND_ALWAYS: return "FORCE_ENCODED_SURROUND_ALWAYS";
+ case FORCE_ENCODED_SURROUND_MANUAL: return "FORCE_ENCODED_SURROUND_MANUAL";
default: return "unknown config (" + config + ")" ;
}
}
@@ -836,6 +839,11 @@
public static native int getMicrophones(ArrayList<MicrophoneInfo> microphonesInfo);
+ public static native int getSurroundFormats(Map<Integer, Boolean> surroundFormats,
+ boolean reported);
+
+ public static native int setSurroundFormatEnabled(int audioFormat, boolean enabled);
+
// Items shared with audio service
/**
diff --git a/services/core/java/com/android/server/audio/AudioService.java b/services/core/java/com/android/server/audio/AudioService.java
index 3d25325..2843a2f 100644
--- a/services/core/java/com/android/server/audio/AudioService.java
+++ b/services/core/java/com/android/server/audio/AudioService.java
@@ -254,6 +254,7 @@
private static final int MSG_ACCESSORY_PLUG_MEDIA_UNMUTE = 27;
private static final int MSG_NOTIFY_VOL_EVENT = 28;
private static final int MSG_DISPATCH_AUDIO_SERVER_STATE = 29;
+ private static final int MSG_ENABLE_SURROUND_FORMATS = 30;
// start of messages handled under wakelock
// these messages can only be queued, i.e. sent with queueMsgUnderWakeLock(),
// and not with sendMsg(..., ..., SENDMSG_QUEUE, ...)
@@ -633,6 +634,10 @@
private int[] mAccessibilityServiceUids;
private final Object mAccessibilityServiceUidsLock = new Object();
+ private int mEncodedSurroundMode;
+ private String mEnabledSurroundFormats;
+ private boolean mSurroundModeChanged;
+
// Intent "extra" data keys.
public static final String CONNECT_INTENT_KEY_PORT_NAME = "portName";
public static final String CONNECT_INTENT_KEY_STATE = "state";
@@ -1035,6 +1040,7 @@
"onAudioServerDied"));
AudioSystem.setForceUse(AudioSystem.FOR_DOCK, forDock);
sendEncodedSurroundMode(mContentResolver, "onAudioServerDied");
+ sendEnabledSurroundFormats(mContentResolver, true);
}
if (mHdmiManager != null) {
synchronized (mHdmiManager) {
@@ -1288,6 +1294,9 @@
case Settings.Global.ENCODED_SURROUND_OUTPUT_ALWAYS:
forceSetting = AudioSystem.FORCE_ENCODED_SURROUND_ALWAYS;
break;
+ case Settings.Global.ENCODED_SURROUND_OUTPUT_MANUAL:
+ forceSetting = AudioSystem.FORCE_ENCODED_SURROUND_MANUAL;
+ break;
default:
Log.e(TAG, "updateSurroundSoundSettings: illegal value "
+ encodedSurroundMode);
@@ -1304,6 +1313,56 @@
}
}
+ private void sendEnabledSurroundFormats(ContentResolver cr, boolean forceUpdate) {
+ if (mEncodedSurroundMode != Settings.Global.ENCODED_SURROUND_OUTPUT_MANUAL) {
+ // Manually enable surround formats only when the setting is in manual mode.
+ return;
+ }
+ String enabledSurroundFormats = Settings.Global.getString(
+ cr, Settings.Global.ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS);
+ if (!forceUpdate && TextUtils.equals(enabledSurroundFormats, mEnabledSurroundFormats)) {
+ // Update enabled surround formats to AudioPolicyManager only when forceUpdate
+ // is true or enabled surround formats changed.
+ return;
+ }
+
+ mEnabledSurroundFormats = enabledSurroundFormats;
+ String[] surroundFormats = TextUtils.split(enabledSurroundFormats, ",");
+ ArrayList<Integer> formats = new ArrayList<>();
+ for (String format : surroundFormats) {
+ try {
+ int audioFormat = Integer.valueOf(format);
+ boolean isSurroundFormat = false;
+ for (int sf : AudioFormat.SURROUND_SOUND_ENCODING) {
+ if (sf == audioFormat) {
+ isSurroundFormat = true;
+ break;
+ }
+ }
+ if (isSurroundFormat && !formats.contains(audioFormat)) {
+ formats.add(audioFormat);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Invalid enabled surround format:" + format);
+ }
+ }
+ // Set filtered surround formats to settings DB in case
+ // there are invalid surround formats in original settings.
+ Settings.Global.putString(mContext.getContentResolver(),
+ Settings.Global.ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS,
+ TextUtils.join(",", formats));
+ sendMsg(mAudioHandler, MSG_ENABLE_SURROUND_FORMATS, SENDMSG_QUEUE, 0, 0, formats, 0);
+ }
+
+ private void onEnableSurroundFormats(ArrayList<Integer> enabledSurroundFormats) {
+ // Set surround format enabled accordingly.
+ for (int surroundFormat : AudioFormat.SURROUND_SOUND_ENCODING) {
+ boolean enabled = enabledSurroundFormats.contains(surroundFormat);
+ int ret = AudioSystem.setSurroundFormatEnabled(surroundFormat, enabled);
+ Log.i(TAG, "enable surround format:" + surroundFormat + " " + enabled + " " + ret);
+ }
+ }
+
private void readPersistedSettings() {
final ContentResolver cr = mContentResolver;
@@ -1346,6 +1405,7 @@
updateRingerAndZenModeAffectedStreams();
readDockAudioSettings(cr);
sendEncodedSurroundMode(cr, "readPersistedSettings");
+ sendEnabledSurroundFormats(cr, true);
}
mMuteAffectedStreams = System.getIntForUser(cr,
@@ -5623,14 +5683,16 @@
case MSG_NOTIFY_VOL_EVENT:
onNotifyVolumeEvent((IAudioPolicyCallback) msg.obj, msg.arg1);
break;
+
+ case MSG_ENABLE_SURROUND_FORMATS:
+ onEnableSurroundFormats((ArrayList<Integer>) msg.obj);
+ break;
}
}
}
private class SettingsObserver extends ContentObserver {
- private int mEncodedSurroundMode;
-
SettingsObserver() {
super(new Handler());
mContentResolver.registerContentObserver(Settings.Global.getUriFor(
@@ -5649,6 +5711,11 @@
Settings.Global.ENCODED_SURROUND_OUTPUT_AUTO);
mContentResolver.registerContentObserver(Settings.Global.getUriFor(
Settings.Global.ENCODED_SURROUND_OUTPUT), false, this);
+
+ mEnabledSurroundFormats = Settings.Global.getString(
+ mContentResolver, Settings.Global.ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS);
+ mContentResolver.registerContentObserver(Settings.Global.getUriFor(
+ Settings.Global.ENCODED_SURROUND_OUTPUT_ENABLED_FORMATS), false, this);
}
@Override
@@ -5669,6 +5736,7 @@
readDockAudioSettings(mContentResolver);
updateMasterMono(mContentResolver);
updateEncodedSurroundOutput();
+ sendEnabledSurroundFormats(mContentResolver, mSurroundModeChanged);
}
}
@@ -5695,6 +5763,9 @@
}
}
mEncodedSurroundMode = newSurroundMode;
+ mSurroundModeChanged = true;
+ } else {
+ mSurroundModeChanged = false;
}
}
}
@@ -6231,6 +6302,9 @@
}
}
}
+ if ((device & AudioSystem.DEVICE_OUT_HDMI) != 0) {
+ sendEnabledSurroundFormats(mContentResolver, true);
+ }
} else {
if (isPlatformTelevision() && ((device & AudioSystem.DEVICE_OUT_HDMI) != 0)) {
if (mHdmiManager != null) {