Remove support for specific AC-4 profiles for Automotive scenarios

According to [DolbyVision Support](https://professionalsupport.dolby.com/s/article/Support-Dolby-Atmos-in-Android-Automotive-OS-media-apps?language=en_US), the "Dolby Atmos decoders in Android Automotive OS systems do not support Dolby AC-4 Immersive Stereo (IMS) decoding."

Issue: #2609
PiperOrigin-RevId: 845227548

Author: microkatz

RELEASENOTES.md

@@ -32,15 +32,16 @@
         'libiamf' to 'iamf_tools'.
     *   `IamfDecoder` now supports changing output mix (layout or ID) during
         playback.
+    *   Correctly remove support for `AC4Profile22` and other legacy profiles
+        when assessing AC-4 decoder support in Automotive scenarios
+        ([#2609](https://github.com/androidx/media/pull/2609)).
 *   Video:
 *   Text:
 *   Metadata:
 *   Image:
 *   DataSource:
 *   DRM:
 *   Effect:
-    *   Deprecate `TimestampAdjustment` and `TimestampAdjustmentShaderProgram`
-        in favour of `EditedMediaItem.Builder#setSpeed(SpeedProvider)`.
 *   Muxers:
 *   IMA extension:
     *   Bug fix: Corrected an issue where the ad MIME type did not match the

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

@@ -312,6 +312,7 @@ public MediaCodecAudioRenderer(
       AudioSink audioSink,
       @Nullable LoudnessCodecController loudnessCodecController) {
     super(
+        context.getApplicationContext(),
         C.TRACK_TYPE_AUDIO,
         codecAdapterFactory,
         mediaCodecSelector,
@@ -373,13 +374,13 @@ public String getName() {
     // Check whether the first decoder supports the format. This is the preferred decoder for the
     // format's MIME type, according to the MediaCodecSelector.
     MediaCodecInfo decoderInfo = decoderInfos.get(0);
-    boolean isFormatSupported = decoderInfo.isFormatSupported(format);
+    boolean isFormatSupported = decoderInfo.isFormatSupported(context, format);
     boolean isPreferredDecoder = true;
     if (!isFormatSupported) {
       // Check whether any of the other decoders support the format.
       for (int i = 1; i < decoderInfos.size(); i++) {
         MediaCodecInfo otherDecoderInfo = decoderInfos.get(i);
-        if (otherDecoderInfo.isFormatSupported(format)) {
+        if (otherDecoderInfo.isFormatSupported(context, format)) {
           decoderInfo = otherDecoderInfo;
           isFormatSupported = true;
           isPreferredDecoder = false;
@@ -431,7 +432,9 @@ protected List<MediaCodecInfo> getDecoderInfos(
       MediaCodecSelector mediaCodecSelector, Format format, boolean requiresSecureDecoder)
       throws DecoderQueryException {
     return MediaCodecUtil.getDecoderInfosSortedByFormatSupport(
-        getDecoderInfos(mediaCodecSelector, format, requiresSecureDecoder, audioSink), format);
+        context,
+        getDecoderInfos(mediaCodecSelector, format, requiresSecureDecoder, audioSink),
+        format);
   }
 
   /**

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

@@ -34,6 +34,7 @@
 import static androidx.media3.exoplayer.mediacodec.MediaCodecUtil.createCodecProfileLevel;
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import android.content.Context;
 import android.graphics.Point;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo.AudioCapabilities;
@@ -263,16 +264,17 @@ public int getMaxSupportedInstances() {
    * Returns whether the decoder may support decoding the given {@code format} both functionally and
    * performantly.
    *
+   * @param context A context.
    * @param format The input media format.
    * @return Whether the decoder may support decoding the given {@code format}.
-   * @throws MediaCodecUtil.DecoderQueryException Thrown if an error occurs while querying decoders.
    */
-  public boolean isFormatSupported(Format format) throws MediaCodecUtil.DecoderQueryException {
+  public boolean isFormatSupported(Context context, Format format) {
     if (!isSampleMimeTypeSupported(format)) {
       return false;
     }
 
-    if (!isCodecProfileAndLevelSupported(format, /* checkPerformanceCapabilities= */ true)) {
+    if (!isCodecProfileAndLevelSupported(
+        context, format, /* checkPerformanceCapabilities= */ true)) {
       return false;
     }
 
@@ -296,12 +298,14 @@ public boolean isFormatSupported(Format format) throws MediaCodecUtil.DecoderQue
   /**
    * Returns whether the decoder may functionally support decoding the given {@code format}.
    *
+   * @param context A context.
    * @param format The input media format.
    * @return Whether the decoder may functionally support decoding the given {@code format}.
    */
-  public boolean isFormatFunctionallySupported(Format format) {
+  public boolean isFormatFunctionallySupported(Context context, Format format) {
     return isSampleMimeTypeSupported(format)
-        && isCodecProfileAndLevelSupported(format, /* checkPerformanceCapabilities= */ false)
+        && isCodecProfileAndLevelSupported(
+            context, format, /* checkPerformanceCapabilities= */ false)
         && isCompressedAudioBitDepthSupported(format);
   }
 
@@ -311,7 +315,7 @@ private boolean isSampleMimeTypeSupported(Format format) {
   }
 
   private boolean isCodecProfileAndLevelSupported(
-      Format format, boolean checkPerformanceCapabilities) {
+      Context context, Format format, boolean checkPerformanceCapabilities) {
     Pair<Integer, Integer> codecProfileAndLevel =
         CodecSpecificDataUtil.getCodecProfileAndLevel(format);
     if (format.sampleMimeType != null && format.sampleMimeType.equals(MimeTypes.VIDEO_MV_HEVC)) {
@@ -370,7 +374,7 @@ private boolean isCodecProfileAndLevelSupported(
     if (mimeType.equals(MimeTypes.AUDIO_AC4) && profileLevels.length == 0) {
       // Some older devices don't report profile levels for AC-4. Estimate them using other data
       // in the codec capabilities.
-      profileLevels = estimateLegacyAc4ProfileLevels(capabilities);
+      profileLevels = estimateLegacyAc4ProfileLevels(context, capabilities);
     }
     if (SDK_INT == 23 && MimeTypes.VIDEO_VP9.equals(mimeType) && profileLevels.length == 0) {
       // Some older devices don't report profile levels for VP9. Estimate them using other data in
@@ -875,7 +879,7 @@ private static Point alignVideoSize(VideoCapabilities capabilities, int width, i
    * @return The estimated {@link CodecProfileLevel CodecProfileLevels} for the decoder.
    */
   private static CodecProfileLevel[] estimateLegacyAc4ProfileLevels(
-      @Nullable CodecCapabilities capabilities) {
+      Context context, @Nullable CodecCapabilities capabilities) {
     int maxInChannelCount = 2;
     if (capabilities != null) {
       @Nullable AudioCapabilities audioCapabilities = capabilities.getAudioCapabilities();
@@ -889,6 +893,15 @@ private static CodecProfileLevel[] estimateLegacyAc4ProfileLevels(
       level = CodecProfileLevel.AC4Level4;
     }
 
+    // Automotive platform MediaCodec AC-4 decoders are not expected to support AC4Profile22 and
+    // deprecated profiles AC4Profile00, AC4Profile10 and AC4Profile11. See
+    // https://professionalsupport.dolby.com/s/article/Support-Dolby-Atmos-in-Android-Automotive-OS-media-apps?language=en_US
+    if (Util.isAutomotive(context)) {
+      return new CodecProfileLevel[] {
+        createCodecProfileLevel(CodecProfileLevel.AC4Profile21, level)
+      };
+    }
+
     return new CodecProfileLevel[] {
       createCodecProfileLevel(CodecProfileLevel.AC4Profile00, level),
       createCodecProfileLevel(CodecProfileLevel.AC4Profile10, level),

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

@@ -32,6 +32,7 @@
 import static java.lang.Math.max;
 import static java.lang.annotation.ElementType.TYPE_USE;
 
+import android.content.Context;
 import android.media.MediaCodec;
 import android.media.MediaCodec.CodecException;
 import android.media.MediaCrypto;
@@ -330,6 +331,7 @@ private static String buildCustomDiagnosticInfo(int errorCode) {
 
   private static final int ADAPTATION_WORKAROUND_SLICE_WIDTH_HEIGHT = 32;
 
+  private final Context context;
   private final MediaCodecAdapter.Factory codecAdapterFactory;
   private final MediaCodecSelector mediaCodecSelector;
   private final boolean enableDecoderFallback;
@@ -415,6 +417,7 @@ private static String buildCustomDiagnosticInfo(int errorCode) {
   private ImmutableSet<String> subscribedCodecParameterKeys;
 
   /**
+   * @param context A context.
    * @param trackType The {@link C.TrackType track type} that the renderer handles.
    * @param codecAdapterFactory A factory for {@link MediaCodecAdapter} instances.
    * @param mediaCodecSelector A decoder selector.
@@ -426,12 +429,14 @@ private static String buildCustomDiagnosticInfo(int errorCode) {
    *     explicitly using {@link MediaFormat#KEY_OPERATING_RATE}).
    */
   public MediaCodecRenderer(
+      Context context,
       @C.TrackType int trackType,
       MediaCodecAdapter.Factory codecAdapterFactory,
       MediaCodecSelector mediaCodecSelector,
       boolean enableDecoderFallback,
       float assumedMinimumCodecOperatingRate) {
     super(trackType);
+    this.context = context.getApplicationContext();
     this.codecAdapterFactory = codecAdapterFactory;
     this.mediaCodecSelector = checkNotNull(mediaCodecSelector);
     this.enableDecoderFallback = enableDecoderFallback;
@@ -1390,7 +1395,7 @@ private void initCodec(MediaCodecInfo codecInfo, @Nullable MediaCrypto crypto) t
     }
     codecInitializedTimestamp = getClock().elapsedRealtime();
 
-    if (!codecInfo.isFormatSupported(inputFormat)) {
+    if (!codecInfo.isFormatSupported(context, inputFormat)) {
       Log.w(
           TAG,
           Util.formatInvariant(

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

@@ -20,6 +20,7 @@
 import static java.lang.Math.max;
 
 import android.annotation.SuppressLint;
+import android.content.Context;
 import android.media.MediaCodecInfo.CodecCapabilities;
 import android.media.MediaCodecInfo.CodecProfileLevel;
 import android.media.MediaCodecList;
@@ -256,10 +257,11 @@ public static List<MediaCodecInfo> getAlternativeDecoderInfos(
    */
   @CheckResult
   public static List<MediaCodecInfo> getDecoderInfosSortedByFormatSupport(
-      List<MediaCodecInfo> decoderInfos, Format format) {
+      Context context, List<MediaCodecInfo> decoderInfos, Format format) {
     decoderInfos = new ArrayList<>(decoderInfos);
     sortByScore(
-        decoderInfos, decoderInfo -> decoderInfo.isFormatFunctionallySupported(format) ? 1 : 0);
+        decoderInfos,
+        decoderInfo -> decoderInfo.isFormatFunctionallySupported(context, format) ? 1 : 0);
     return decoderInfos;
   }
 
@@ -269,16 +271,12 @@ public static List<MediaCodecInfo> getDecoderInfosSortedByFormatSupport(
    */
   @CheckResult
   public static List<MediaCodecInfo> getDecoderInfosSortedByFullFormatSupport(
-      List<MediaCodecInfo> decoderInfos, Format format) {
+      Context context, List<MediaCodecInfo> decoderInfos, Format format) {
     decoderInfos = new ArrayList<>(decoderInfos);
     sortByScore(
         decoderInfos,
         decoderInfo -> {
-          try {
-            return decoderInfo.isFormatSupported(format) ? 1 : 0;
-          } catch (DecoderQueryException e) {
-            return -1;
-          }
+          return decoderInfo.isFormatSupported(context, format) ? 1 : 0;
         });
     return decoderInfos;
   }

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java

@@ -622,6 +622,7 @@ public MediaCodecVideoRenderer(
    */
   protected MediaCodecVideoRenderer(Builder builder) {
     super(
+        builder.context.getApplicationContext(),
         C.TRACK_TYPE_VIDEO,
         builder.codecAdapterFactory,
         builder.mediaCodecSelector,
@@ -759,13 +760,13 @@ public String getName() {
     // Check whether the first decoder supports the format. This is the preferred decoder for the
     // format's MIME type, according to the MediaCodecSelector.
     MediaCodecInfo decoderInfo = decoderInfos.get(0);
-    boolean isFormatSupported = decoderInfo.isFormatSupported(format);
+    boolean isFormatSupported = decoderInfo.isFormatSupported(context, format);
     boolean isPreferredDecoder = true;
     if (!isFormatSupported) {
       // Check whether any of the other decoders support the format.
       for (int i = 1; i < decoderInfos.size(); i++) {
         MediaCodecInfo otherDecoderInfo = decoderInfos.get(i);
-        if (otherDecoderInfo.isFormatSupported(format)) {
+        if (otherDecoderInfo.isFormatSupported(context, format)) {
           decoderInfo = otherDecoderInfo;
           isFormatSupported = true;
           isPreferredDecoder = false;
@@ -805,9 +806,10 @@ public String getName() {
               /* requiresTunnelingDecoder= */ true);
       if (!tunnelingDecoderInfos.isEmpty()) {
         MediaCodecInfo tunnelingDecoderInfo =
-            MediaCodecUtil.getDecoderInfosSortedByFormatSupport(tunnelingDecoderInfos, format)
+            MediaCodecUtil.getDecoderInfosSortedByFormatSupport(
+                    context, tunnelingDecoderInfos, format)
                 .get(0);
-        if (tunnelingDecoderInfo.isFormatSupported(format)
+        if (tunnelingDecoderInfo.isFormatSupported(context, format)
             && tunnelingDecoderInfo.isSeamlessAdaptationSupported(format)) {
           tunnelingSupport = TUNNELING_SUPPORTED;
         }
@@ -827,6 +829,7 @@ protected List<MediaCodecInfo> getDecoderInfos(
       MediaCodecSelector mediaCodecSelector, Format format, boolean requiresSecureDecoder)
       throws DecoderQueryException {
     return MediaCodecUtil.getDecoderInfosSortedByFormatSupport(
+        context,
         getDecoderInfos(context, mediaCodecSelector, format, requiresSecureDecoder, tunneling),
         format);
   }
@@ -842,6 +845,7 @@ protected List<MediaCodecInfo> getDecoderInfos(
    * MediaCodecUtil#getDecoderInfosSortedByFormatSupport} can be used to further sort the list into
    * an order where decoders that fully support the format come first.
    *
+   * @param context A context.
    * @param mediaCodecSelector The decoder selector.
    * @param format The {@link Format} for which a decoder is required.
    * @param requiresSecureDecoder Whether a secure decoder is required.

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecInfoTest.java

@@ -34,14 +34,21 @@
 import static androidx.media3.exoplayer.DecoderReuseEvaluation.REUSE_RESULT_YES_WITH_RECONFIGURATION;
 import static com.google.common.truth.Truth.assertThat;
 
+import android.content.Context;
+import android.content.pm.PackageManager;
 import androidx.media3.common.C;
 import androidx.media3.common.ColorInfo;
 import androidx.media3.common.Format;
+import androidx.media3.common.util.MediaFormatUtil;
 import androidx.media3.exoplayer.DecoderReuseEvaluation;
+import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import com.google.common.collect.ImmutableList;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.robolectric.Shadows;
+import org.robolectric.shadows.MediaCodecInfoBuilder;
+import org.robolectric.shadows.ShadowPackageManager;
 
 /** Unit tests for {@link MediaCodecInfo}. */
 @RunWith(AndroidJUnit4.class)
@@ -433,7 +440,7 @@ public void canReuseCodec_eac3joc_returnsYesWithoutReconfiguration() {
 
   @Test
   public void canReuseCodec_ac4_returnsYesWithoutReconfiguration() {
-    MediaCodecInfo codecInfo = buildAc4CodecInfo();
+    MediaCodecInfo codecInfo = buildAc4CodecInfo(FORMAT_AC4);
 
     assertThat(codecInfo.canReuseCodec(FORMAT_AC4, FORMAT_AC4))
         .isEqualTo(
@@ -447,7 +454,7 @@ public void canReuseCodec_ac4_returnsYesWithoutReconfiguration() {
 
   @Test
   public void canReuseCodec_ac4WithDifferentCodecs_returnsYesWithFlush() {
-    MediaCodecInfo codecInfo = buildAc4CodecInfo();
+    MediaCodecInfo codecInfo = buildAc4CodecInfo(FORMAT_AC4);
 
     Format ac4VariantFormat = FORMAT_AC4.buildUpon().setCodecs("ac-4.02.01.03").build();
     assertThat(codecInfo.canReuseCodec(FORMAT_AC4, ac4VariantFormat))
@@ -460,6 +467,52 @@ public void canReuseCodec_ac4WithDifferentCodecs_returnsYesWithFlush() {
                 /* discardReasons= */ 0));
   }
 
+  @Test
+  public void isFormatSupported_ac4Profile00InAutomotiveContext_returnsFalse() throws Exception {
+    Context context = ApplicationProvider.getApplicationContext();
+    ShadowPackageManager shadowPackageManager = Shadows.shadowOf(context.getPackageManager());
+
+    Format formatAc4Profile00 =
+        new Format.Builder()
+            .setSampleMimeType(AUDIO_AC4)
+            .setCodecs("ac-4.00.00.01") // AC4Profile00
+            .setChannelCount(2)
+            .setSampleRate(48000)
+            .build();
+    MediaCodecInfo codecInfo = buildAc4CodecInfo(formatAc4Profile00);
+
+    // Test non-Automotive case (FEATURE_AUTOMOTIVE is false)
+    shadowPackageManager.setSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, false);
+    assertThat(codecInfo.isFormatSupported(context, formatAc4Profile00)).isTrue();
+
+    // Test Automotive case (FEATURE_AUTOMOTIVE is true)
+    shadowPackageManager.setSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, true);
+    assertThat(codecInfo.isFormatSupported(context, formatAc4Profile00)).isFalse();
+  }
+
+  @Test
+  public void isFormatSupported_ac4Profile21InAutomotiveContext_returnsTrue() throws Exception {
+    Context context = ApplicationProvider.getApplicationContext();
+    ShadowPackageManager shadowPackageManager = Shadows.shadowOf(context.getPackageManager());
+
+    Format formatAc4Profile21 =
+        new Format.Builder()
+            .setSampleMimeType(AUDIO_AC4)
+            .setCodecs("ac-4.21.01.01") // AC4Profile21
+            .setChannelCount(2)
+            .setSampleRate(48000)
+            .build();
+    MediaCodecInfo codecInfo = buildAc4CodecInfo(formatAc4Profile21);
+
+    // Test non-Automotive case (FEATURE_AUTOMOTIVE is false)
+    shadowPackageManager.setSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, false);
+    assertThat(codecInfo.isFormatSupported(context, formatAc4Profile21)).isTrue();
+
+    // Test Automotive case (FEATURE_AUTOMOTIVE is true)
+    shadowPackageManager.setSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, true);
+    assertThat(codecInfo.isFormatSupported(context, formatAc4Profile21)).isTrue();
+  }
+
   private static MediaCodecInfo buildH264CodecInfo(boolean adaptive) {
     return new MediaCodecInfo(
         "h264",
@@ -505,12 +558,18 @@ private static MediaCodecInfo buildAacCodecInfo() {
         /* detachedSurfaceSupported= */ false);
   }
 
-  private static MediaCodecInfo buildAc4CodecInfo() {
+  private static MediaCodecInfo buildAc4CodecInfo(Format ac4Format) {
+    @SuppressWarnings("UnnecessarilyFullyQualified") // Unnecessary to import CodecCapabilities.
+    android.media.MediaCodecInfo.CodecCapabilities capabilities =
+        MediaCodecInfoBuilder.CodecCapabilitiesBuilder.newBuilder()
+            .setMediaFormat(MediaFormatUtil.createMediaFormatFromFormat(ac4Format))
+            .build();
+
     return new MediaCodecInfo(
         "ac4",
         AUDIO_AC4,
         AUDIO_AC4,
-        /* capabilities= */ null,
+        /* capabilities= */ capabilities,
         /* hardwareAccelerated= */ false,
         /* softwareOnly= */ true,
         /* vendor= */ true,