Support DTS-HD MA profiles

Android supports a seperate AudioFormat.ENCODING_DTS_HD_MA and a MediaCodec
mime type with ;profile=dtsma since SDK 34, but ExoPlayer wasn't using this
even though the platform docs explicitly say to use the new encoding for
DTS-HD MA. Implement detection of DTS-HD MA and add plumbing to use this
constant where available, and fall back to previous behavior of using
ENCODING_DTS_HD otherwise for backwards compatibility with devices that
weren't updated to support the new constant/MIME type.

DTS-HD MA exists in two versions, in multi-layer version where fallback to
DTS decoders is valid and in a single-layer version where it is not. Add
detection for this and change fallbacks accordingly.

Issue: #2487

Author: nift4

libraries/common/src/main/java/androidx/media3/common/C.java

@@ -185,8 +185,8 @@ private C() {}
    * #ENCODING_PCM_FLOAT_BIG_ENDIAN}, {@link #ENCODING_PCM_DOUBLE}, {@link
    * #ENCODING_PCM_DOUBLE_BIG_ENDIAN}, {@link #ENCODING_MP3}, {@link #ENCODING_AC3}, {@link
    * #ENCODING_E_AC3}, {@link #ENCODING_E_AC3_JOC}, {@link #ENCODING_AC4}, {@link #ENCODING_DTS},
-   * {@link #ENCODING_DTS_HD}, {@link #ENCODING_DOLBY_TRUEHD}, {@link #ENCODING_OPUS} or {@link
-   * #ENCODING_DSD}.
+   * {@link #ENCODING_DTS_HD}, {@link #ENCODING_DTS_HD_MA}, {@link #ENCODING_DOLBY_TRUEHD}, {@link
+   * #ENCODING_OPUS} or {@link #ENCODING_DSD}.
    */
   @Documented
   @Retention(RetentionPolicy.SOURCE)
@@ -218,6 +218,7 @@ private C() {}
     ENCODING_AC4,
     ENCODING_DTS,
     ENCODING_DTS_HD,
+    ENCODING_DTS_HD_MA,
     ENCODING_DOLBY_TRUEHD,
     ENCODING_OPUS,
     ENCODING_DTS_UHD_P2,
@@ -329,6 +330,9 @@ private C() {}
   /** See {@link AudioFormat#ENCODING_DTS_HD}. */
   public static final int ENCODING_DTS_HD = AudioFormat.ENCODING_DTS_HD;
 
+  /** See {@link AudioFormat#ENCODING_DTS_HD_MA}. */
+  public static final int ENCODING_DTS_HD_MA = AudioFormat.ENCODING_DTS_HD_MA;
+
   /** See {@link AudioFormat#ENCODING_DTS_UHD_P2}. */
   public static final int ENCODING_DTS_UHD_P2 = AudioFormat.ENCODING_DTS_UHD_P2;
 

libraries/common/src/main/java/androidx/media3/common/MimeTypes.java

@@ -92,8 +92,20 @@ public final class MimeTypes {
   @UnstableApi public static final String AUDIO_DSD = BASE_TYPE_AUDIO + "/dsd";
   public static final String AUDIO_DTS = BASE_TYPE_AUDIO + "/vnd.dts";
   public static final String AUDIO_DTS_HD = BASE_TYPE_AUDIO + "/vnd.dts.hd";
+  public static final String AUDIO_DTS_HD_MA = BASE_TYPE_AUDIO + "/vnd.dts.hd;profile=dtsma";
   public static final String AUDIO_DTS_EXPRESS = BASE_TYPE_AUDIO + "/vnd.dts.hd;profile=lbr";
 
+  /**
+   * DTS-HD MA can be encoded in a multi-layer setup with a core layer ({@link #AUDIO_DTS_HD_MA}),
+   * where fallback to a DTS core decoder is possible, or in a single-layer setup with only a
+   * lossless layer, where this is not. The same MIME type is normally used for both, but it's
+   * important for ExoPlayer to differentiate this at extractor level to understand whether decoder
+   * fallback is possible or not. Hence, use this dummy MIME type to signal lossless-only DTS-HD MA.
+   */
+  @UnstableApi
+  public static final String AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS =
+      BASE_TYPE_AUDIO + "/x-exoplayer-dtsma-coreless";
+
   @UnstableApi
   public static final String AUDIO_DTS_UHD_P2 = BASE_TYPE_AUDIO + "/vnd.dts.uhd;profile=p2";
 
@@ -509,8 +521,10 @@ public static String getMediaMimeType(@Nullable String codec) {
       return MimeTypes.AUDIO_DTS;
     } else if (codec.startsWith("dtse")) {
       return MimeTypes.AUDIO_DTS_EXPRESS;
-    } else if (codec.startsWith("dtsh") || codec.startsWith("dtsl")) {
+    } else if (codec.startsWith("dtsh")) {
       return MimeTypes.AUDIO_DTS_HD;
+    } else if (codec.startsWith("dtsl")) {
+      return MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
     } else if (codec.startsWith("dtsx")) {
       return MimeTypes.AUDIO_DTS_UHD_P2;
     } else if (codec.startsWith("opus")) {
@@ -716,6 +730,9 @@ public static boolean isDolbyVisionCodec(
         return C.ENCODING_DTS;
       case MimeTypes.AUDIO_DTS_HD:
         return C.ENCODING_DTS_HD;
+      case MimeTypes.AUDIO_DTS_HD_MA:
+      case MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS:
+        return C.ENCODING_DTS_HD_MA;
       case MimeTypes.AUDIO_DTS_EXPRESS:
         return C.ENCODING_DTS_HD;
       case MimeTypes.AUDIO_DTS_UHD_P2:

libraries/common/src/main/java/androidx/media3/common/util/Util.java

@@ -2711,6 +2711,7 @@ public static int getApiLevelThatAudioFormatIntroducedAudioEncoding(int encoding
       case C.ENCODING_PCM_32BIT:
         return 31;
       case C.ENCODING_DTS_UHD_P2:
+      case C.ENCODING_DTS_HD_MA:
       case C.ENCODING_DSD:
         return 34;
       default:

libraries/common/src/test/java/androidx/media3/common/MimeTypesTest.java

@@ -179,7 +179,8 @@ public void getMediaMimeType_fromValidCodecs_returnsCorrectMimeType() {
     assertThat(MimeTypes.getMediaMimeType("dtsc")).isEqualTo(MimeTypes.AUDIO_DTS);
     assertThat(MimeTypes.getMediaMimeType("dtse")).isEqualTo(MimeTypes.AUDIO_DTS_EXPRESS);
     assertThat(MimeTypes.getMediaMimeType("dtsh")).isEqualTo(MimeTypes.AUDIO_DTS_HD);
-    assertThat(MimeTypes.getMediaMimeType("dtsl")).isEqualTo(MimeTypes.AUDIO_DTS_HD);
+    assertThat(MimeTypes.getMediaMimeType("dtsl"))
+        .isEqualTo(MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS);
     assertThat(MimeTypes.getMediaMimeType("dtsx")).isEqualTo(MimeTypes.AUDIO_DTS_UHD_P2);
     assertThat(MimeTypes.getMediaMimeType("opus")).isEqualTo(MimeTypes.AUDIO_OPUS);
     assertThat(MimeTypes.getMediaMimeType("vorbis")).isEqualTo(MimeTypes.AUDIO_VORBIS);

libraries/decoder_ffmpeg/src/main/java/androidx/media3/decoder/ffmpeg/FfmpegLibrary.java

@@ -133,6 +133,8 @@ public static boolean supportsFormat(String mimeType) {
       case MimeTypes.AUDIO_DTS:
       case MimeTypes.AUDIO_DTS_EXPRESS:
       case MimeTypes.AUDIO_DTS_HD:
+      case MimeTypes.AUDIO_DTS_HD_MA:
+      case MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS:
         return "dca";
       case MimeTypes.AUDIO_VORBIS:
         return "vorbis";

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioCapabilities.java

@@ -98,6 +98,7 @@ public final class AudioCapabilities {
           .put(C.ENCODING_E_AC3_JOC, 6)
           .put(C.ENCODING_E_AC3, 8)
           .put(C.ENCODING_DTS_HD, 8)
+          .put(C.ENCODING_DTS_HD_MA, 8)
           .put(C.ENCODING_DOLBY_TRUEHD, 8)
           .buildOrThrow();
 
@@ -398,6 +399,23 @@ public Pair<Integer, Integer> getEncodingAndChannelConfigForPassthrough(
         || (encoding == C.ENCODING_DTS_UHD_P2 && !supportsEncoding(C.ENCODING_DTS_UHD_P2))) {
       // DTS receivers support DTS-HD streams (but decode only the core layer).
       encoding = C.ENCODING_DTS;
+    } else if (MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS.equals(format.sampleMimeType)) {
+      // DTS-HD MA without core layer can only be decoded by DTS-HD MA receivers. However, because
+      // the constant for DTS-HD MA was only added in 2022 (https://r.android.com/1992892), we have
+      // to try the older DTS-HD constant for backwards compatibility.
+      if (!supportsEncoding(C.ENCODING_DTS_HD_MA)) {
+        encoding = C.ENCODING_DTS_HD;
+      }
+    } else if (encoding == C.ENCODING_DTS_HD_MA && !supportsEncoding(C.ENCODING_DTS_HD_MA)) {
+      // DTS-HD MA with core layer can be decoded by any DTS or DTS-HD MA receivers. Also, because
+      // the constant for DTS-HD MA was only added in 2022 (https://r.android.com/1992892), we have
+      // to try the older DTS-HD constant for backwards compatibility as well.
+      if (supportsEncoding(C.ENCODING_DTS_HD)) {
+        encoding = C.ENCODING_DTS_HD;
+      } else {
+        // DTS receivers support DTS-HD MA streams (but decode only the core layer).
+        encoding = C.ENCODING_DTS;
+      }
     }
     if (!supportsEncoding(encoding)) {
       return null;

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/DefaultAudioSink.java

@@ -1837,6 +1837,7 @@ private FormatConfig getFormatConfig(Format format, int preferredBufferSize) {
         return AacUtil.AAC_LD_AUDIO_SAMPLE_COUNT;
       case C.ENCODING_DTS:
       case C.ENCODING_DTS_HD:
+      case C.ENCODING_DTS_HD_MA:
       case C.ENCODING_DTS_UHD_P2:
         return DtsUtil.parseDtsAudioSampleCount(buffer);
       case C.ENCODING_AC3:

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecUtil.java

@@ -384,6 +384,18 @@ public static List<String> getAlternativeCodecMimeTypes(Format format) {
       // E-AC3 decoders can decode JOC streams, but in 2-D rather than 3-D.
       return Collections.singletonList(MimeTypes.AUDIO_E_AC3);
     }
+    if (MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS.equals(format.sampleMimeType)) {
+      // Coreless DTS-HD MA can only be decoded by a DTS-HD MA decoder. However, as DTS-HD MA was
+      // added as separate MIME type in platform in 2022, we need to try the older DTS-HD mime type
+      // for backwards compatibility. (https://r.android.com/2302237)
+      return List.of(MimeTypes.AUDIO_DTS_HD_MA, MimeTypes.AUDIO_DTS_HD);
+    }
+    if (MimeTypes.AUDIO_DTS_HD_MA.equals(format.sampleMimeType)) {
+      // DTS-HD MA was added as separate MIME type in platform in 2022, so we need to try the older
+      // DTS-HD mime type for backwards compatibility. (https://r.android.com/2302237)
+      // And because this is DTS-HD MA with core layer, even a DTS decoder can decode this stream.
+      return List.of(MimeTypes.AUDIO_DTS_HD, MimeTypes.AUDIO_DTS);
+    }
     if (MimeTypes.AUDIO_DTS_HD.equals(format.sampleMimeType)
         || MimeTypes.AUDIO_DTS_UHD_P2.equals(format.sampleMimeType)) {
       // DTS decoders support DTS-HD streams (but decode only the core layer).

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/util/EventLogger.java

@@ -805,6 +805,8 @@ private static String encodingAsString(@C.Encoding int encoding) {
         return "dts";
       case C.ENCODING_DTS_HD:
         return "dts-hd";
+      case C.ENCODING_DTS_HD_MA:
+        return "dts-hd-ma";
       case C.ENCODING_DTS_UHD_P2:
         return "dts-uhd-p2";
       case C.ENCODING_DSD:

libraries/exoplayer_smoothstreaming/src/main/java/androidx/media3/exoplayer/smoothstreaming/manifest/SsManifestParser.java

@@ -795,8 +795,10 @@ private static String fourCCToMimeType(String fourCC) {
         return MimeTypes.AUDIO_E_AC3;
       } else if (fourCC.equalsIgnoreCase("dtsc")) {
         return MimeTypes.AUDIO_DTS;
-      } else if (fourCC.equalsIgnoreCase("dtsh") || fourCC.equalsIgnoreCase("dtsl")) {
+      } else if (fourCC.equalsIgnoreCase("dtsh")) {
         return MimeTypes.AUDIO_DTS_HD;
+      } else if (fourCC.equalsIgnoreCase("dtsl")) {
+        return MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
       } else if (fourCC.equalsIgnoreCase("dtse")) {
         return MimeTypes.AUDIO_DTS_EXPRESS;
       } else if (fourCC.equalsIgnoreCase("opus")) {