Support DTS-HD MA profiles

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/MediaCodecInfo.java

@@ -312,7 +312,7 @@ && isCodecProfileAndLevelSupported(
 
   private boolean isSampleMimeTypeSupported(Format format) {
     return mimeType.equals(format.sampleMimeType)
-        || mimeType.equals(MediaCodecUtil.getAlternativeCodecMimeType(format));
+        || MediaCodecUtil.getAlternativeCodecMimeTypes(format).contains(mimeType);
   }
 
   private boolean isCodecProfileAndLevelSupported(

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

@@ -193,7 +193,7 @@ public static synchronized List<MediaCodecInfo> getDecoderInfos(
    * decoders that fully support the format come first.
    *
    * <p>This list is more complete than {@link #getDecoderInfos}, as it also considers alternative
-   * MIME types that are a close match using {@link #getAlternativeCodecMimeType}.
+   * MIME types that are a close match using {@link #getAlternativeCodecMimeTypes}.
    *
    * @param mediaCodecSelector The decoder selector.
    * @param format The {@link Format} for which a decoder is required.
@@ -222,9 +222,9 @@ public static List<MediaCodecInfo> getDecoderInfosSoftMatch(
   }
 
   /**
-   * Returns a list of decoders for {@linkplain #getAlternativeCodecMimeType alternative MIME types}
-   * that can decode samples of the provided {@link Format}, in the priority order specified by the
-   * {@link MediaCodecSelector}.
+   * Returns a list of decoders for {@linkplain #getAlternativeCodecMimeTypes alternative MIME
+   * types} that can decode samples of the provided {@link Format}, in the priority order specified
+   * by the {@link MediaCodecSelector}.
    *
    * <p>Since the {@link MediaCodecSelector} only has access to {@link Format#sampleMimeType}, the
    * list is not ordered to account for whether each decoder supports the details of the format
@@ -245,12 +245,17 @@ public static List<MediaCodecInfo> getAlternativeDecoderInfos(
       boolean requiresSecureDecoder,
       boolean requiresTunnelingDecoder)
       throws DecoderQueryException {
-    @Nullable String alternativeMimeType = getAlternativeCodecMimeType(format);
-    if (alternativeMimeType == null) {
+    List<String> alternativeMimeTypes = getAlternativeCodecMimeTypes(format);
+    if (alternativeMimeTypes.isEmpty()) {
       return ImmutableList.of();
     }
-    return mediaCodecSelector.getDecoderInfos(
-        alternativeMimeType, requiresSecureDecoder, requiresTunnelingDecoder);
+    ImmutableList.Builder<MediaCodecInfo> listBuilder = new ImmutableList.Builder<>();
+    for (String alternativeMimeType : alternativeMimeTypes) {
+      listBuilder.addAll(
+          mediaCodecSelector.getDecoderInfos(
+              alternativeMimeType, requiresSecureDecoder, requiresTunnelingDecoder));
+    }
+    return listBuilder.build();
   }
 
   /**
@@ -366,24 +371,35 @@ public static MediaCodecProfileAndLevel getHevcBaseLayerCodecProfileAndLevel(For
   }
 
   /**
-   * Returns an alternative codec MIME type (besides the default {@link Format#sampleMimeType}) that
-   * can be used to decode samples of the provided {@link Format}.
+   * Returns alternative codec MIME types (besides the default {@link Format#sampleMimeType}) that
+   * can be used to decode samples of the provided {@link Format}, in order of preference.
    *
    * @param format The media format.
-   * @return An alternative MIME type of a codec that be used decode samples of the provided {@code
-   *     Format} (besides the default {@link Format#sampleMimeType}), or null if no such alternative
-   *     exists.
+   * @return Alternative MIME types of a codec that be used decode samples of the provided {@code
+   *     Format} (besides the default {@link Format#sampleMimeType}), or an empty List if no such
+   *     alternative exists.
    */
-  @Nullable
-  public static String getAlternativeCodecMimeType(Format format) {
+  public static List<String> getAlternativeCodecMimeTypes(Format format) {
     if (MimeTypes.AUDIO_E_AC3_JOC.equals(format.sampleMimeType)) {
       // E-AC3 decoders can decode JOC streams, but in 2-D rather than 3-D.
-      return MimeTypes.AUDIO_E_AC3;
+      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).
-      return MimeTypes.AUDIO_DTS;
+      return Collections.singletonList(MimeTypes.AUDIO_DTS);
     }
     if (MimeTypes.VIDEO_DOLBY_VISION.equals(format.sampleMimeType)) {
       // H.264/AVC, H.265/HEVC or AV1 decoders can decode the base layer of some DV profiles.
@@ -397,24 +413,24 @@ public static String getAlternativeCodecMimeType(Format format) {
         int profile = codecProfileAndLevel.getProfile();
         if (profile == CodecProfileLevel.DolbyVisionProfileDvheDtr
             || profile == CodecProfileLevel.DolbyVisionProfileDvheSt) {
-          return MimeTypes.VIDEO_H265;
+          return Collections.singletonList(MimeTypes.VIDEO_H265);
         } else if (profile == CodecProfileLevel.DolbyVisionProfileDvavSe) {
-          return MimeTypes.VIDEO_H264;
+          return Collections.singletonList(MimeTypes.VIDEO_H264);
         } else if (profile == CodecProfileLevel.DolbyVisionProfileDvav110) {
           if (format.colorInfo != null
               && format.colorInfo.colorTransfer == C.COLOR_TRANSFER_ST2084
               && format.colorInfo.colorRange == C.COLOR_RANGE_FULL) {
-            return null;
+            return Collections.emptyList();
           }
-          return MimeTypes.VIDEO_AV1;
+          return Collections.singletonList(MimeTypes.VIDEO_AV1);
         }
       }
     }
     if (MimeTypes.VIDEO_MV_HEVC.equals(format.sampleMimeType)) {
       // Single-layer HEVC decoders can decode the base layer of MV-HEVC streams.
-      return MimeTypes.VIDEO_H265;
+      return Collections.singletonList(MimeTypes.VIDEO_H265);
     }
-    return null;
+    return Collections.emptyList();
   }
 
   // Internal methods.

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelector.java

@@ -3912,9 +3912,9 @@ public VideoTrackInfo(
       @RendererCapabilities.DecoderSupport
       int decoderSupport = RendererCapabilities.getDecoderSupport(formatSupport);
       if (decoderSupport == RendererCapabilities.DECODER_SUPPORT_FALLBACK_MIMETYPE) {
-        String fallbackMimeType = MediaCodecUtil.getAlternativeCodecMimeType(format);
-        if (fallbackMimeType != null) {
-          resolvedMimeType = fallbackMimeType;
+        List<String> fallbackMimeType = MediaCodecUtil.getAlternativeCodecMimeTypes(format);
+        if (!fallbackMimeType.isEmpty()) {
+          resolvedMimeType = fallbackMimeType.get(0);
         }
       }
 

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/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecUtilTest.java

@@ -25,6 +25,7 @@
 import androidx.media3.common.util.CodecSpecificDataUtil.MediaCodecProfileAndLevel;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import com.google.common.collect.ImmutableList;
+import java.util.Collections;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -228,7 +229,7 @@ public void getHevcBaseLayerCodecProfileAndLevel_rejectsFormatWithNoInitializati
   }
 
   @Test
-  public void getAlternativeCodecMimeType_withNonFallbackCompatibleFormat_returnsNull() {
+  public void getAlternativeCodecMimeType_withNonFallbackCompatibleFormat_returnsEmpty() {
     // Profile 10.0 (Full Range PQ) which does NOT allow fallback.
     Format formatDav1NoFallbackPossible =
         new Format.Builder()
@@ -254,9 +255,9 @@ public void getAlternativeCodecMimeType_withNonFallbackCompatibleFormat_returnsN
                     .build())
             .build();
 
-    assertThat(MediaCodecUtil.getAlternativeCodecMimeType(formatDav1NoFallbackPossible)).isNull();
-    assertThat(MediaCodecUtil.getAlternativeCodecMimeType(formatDav1FallbackToAv1))
-        .isEqualTo(MimeTypes.VIDEO_AV1);
+    assertThat(MediaCodecUtil.getAlternativeCodecMimeTypes(formatDav1NoFallbackPossible)).isEmpty();
+    assertThat(MediaCodecUtil.getAlternativeCodecMimeTypes(formatDav1FallbackToAv1))
+        .isEqualTo(Collections.singletonList(MimeTypes.VIDEO_AV1));
   }
 
   private static void assertHevcBaseLayerCodecProfileAndLevelForFormat(

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")) {

libraries/extractor/src/main/java/androidx/media3/extractor/DtsUtil.java

@@ -89,6 +89,8 @@ private DtsHeader(
    *   <li>{@link MimeTypes#AUDIO_DTS}
    *   <li>{@link MimeTypes#AUDIO_DTS_EXPRESS}
    *   <li>{@link MimeTypes#AUDIO_DTS_HD}
+   *   <li>{@link MimeTypes#AUDIO_DTS_HD_MA}
+   *   <li>{@link MimeTypes#AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS}
    *   <li>{@link MimeTypes#AUDIO_DTS_UHD_P2}
    * </ul>
    */
@@ -99,6 +101,8 @@ private DtsHeader(
     MimeTypes.AUDIO_DTS,
     MimeTypes.AUDIO_DTS_EXPRESS,
     MimeTypes.AUDIO_DTS_HD,
+    MimeTypes.AUDIO_DTS_HD_MA,
+    MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS,
     MimeTypes.AUDIO_DTS_UHD_P2
   })
   public @interface DtsAudioMimeType {}
@@ -656,11 +660,17 @@ private static String parseDecoderNavigationData(ParsableBitArray headerBits)
         int extensionMask = headerBits.readBits(12);
         if ((extensionMask & 0x100) != 0) { // Low bit rate component
           return MimeTypes.AUDIO_DTS_EXPRESS;
+        } else if ((extensionMask & 0x200) != 0) { // Lossless extension
+          if ((extensionMask & 0x001) != 0) { // Core component within the core substream
+            return MimeTypes.AUDIO_DTS_HD_MA;
+          } else {
+            return MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
+          }
         } else {
           return MimeTypes.AUDIO_DTS_HD;
         }
       case 1: // DTS-HD Loss-less coding mode without CBR component
-        return MimeTypes.AUDIO_DTS_HD;
+        return MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
       case 2: // DTS-HD Low bit-rate mode
         return MimeTypes.AUDIO_DTS_EXPRESS;
       case 3: // The auxiliary coding mode is reserved for future applications.

libraries/extractor/src/main/java/androidx/media3/extractor/ExtractorUtil.java

@@ -155,6 +155,7 @@ public static int getMaximumEncodedRateBytesPerSecond(@C.Encoding int encoding)
       case C.ENCODING_DTS:
         return DtsUtil.DTS_MAX_RATE_BYTES_PER_SECOND;
       case C.ENCODING_DTS_HD:
+      case C.ENCODING_DTS_HD_MA:
       case C.ENCODING_DTS_UHD_P2:
         return DtsUtil.DTS_HD_MAX_RATE_BYTES_PER_SECOND;
       case C.ENCODING_DOLBY_TRUEHD:

libraries/extractor/src/main/java/androidx/media3/extractor/mkv/MatroskaExtractor.java

@@ -2549,7 +2549,7 @@ public void initializeFormat(int trackId) throws ParserException {
           mimeType = MimeTypes.AUDIO_DTS_EXPRESS;
           break;
         case CODEC_ID_DTS_LOSSLESS:
-          mimeType = MimeTypes.AUDIO_DTS_HD;
+          mimeType = MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
           break;
         case CODEC_ID_FLAC:
           mimeType = MimeTypes.AUDIO_FLAC;

libraries/extractor/src/main/java/androidx/media3/extractor/mp4/BoxParser.java

@@ -2125,8 +2125,10 @@ private static void parseAudioSampleEntry(
       mimeType = MimeTypes.AUDIO_AC4;
     } else if (atomType == Mp4Box.TYPE_dtsc) {
       mimeType = MimeTypes.AUDIO_DTS;
-    } else if (atomType == Mp4Box.TYPE_dtsh || atomType == Mp4Box.TYPE_dtsl) {
+    } else if (atomType == Mp4Box.TYPE_dtsh) {
       mimeType = MimeTypes.AUDIO_DTS_HD;
+    } else if (atomType == Mp4Box.TYPE_dtsl) {
+      mimeType = MimeTypes.AUDIO_EXOPLAYER_DTS_HD_MA_CORELESS;
     } else if (atomType == Mp4Box.TYPE_dtse) {
       mimeType = MimeTypes.AUDIO_DTS_EXPRESS;
     } else if (atomType == Mp4Box.TYPE_dtsx) {