Add Dolby Vision Transcoding and Editing Support

libraries/transformer/src/androidTest/java/androidx/media3/transformer/TransformerEndToEndTest.java

@@ -1280,6 +1280,38 @@ public void transcode_withOutputVideoMimeTypeAv1_completesSuccessfully() throws
     assertThat(exportResult.videoMimeType).isEqualTo(MimeTypes.VIDEO_AV1);
   }
 
+  @Test
+  public void transcode_withOutputVideoMimeTypeDolbyVision_completesSuccessfully() throws Exception {
+    if (AndroidTestUtil.skipAndLogIfFormatsUnsupported(
+        context,
+        testId,
+        /* inputFormat= */ MP4_ASSET_FORMAT,
+        /* outputFormat= */ MP4_ASSET_FORMAT
+            .buildUpon()
+            .setSampleMimeType(MimeTypes.VIDEO_DOLBY_VISION)
+            .setCodecs(null)
+            .build())) {
+      return;
+    }
+    MediaItem mediaItem = MediaItem.fromUri(Uri.parse(MP4_ASSET_URI_STRING));
+    EditedMediaItem editedMediaItem = new EditedMediaItem.Builder(mediaItem).build();
+    Transformer transformer =
+        new Transformer.Builder(context).setVideoMimeType(MimeTypes.VIDEO_DOLBY_VISION).build();
+
+    ExportTestResult exportTestResult =
+        new TransformerAndroidTestRunner.Builder(context, transformer)
+            .build()
+            .run(testId, editedMediaItem);
+    ExportResult exportResult = exportTestResult.exportResult;
+
+    String actualMimeType =
+        retrieveTrackFormat(context, exportTestResult.filePath, C.TRACK_TYPE_VIDEO).sampleMimeType;
+    assertThat(actualMimeType).isEqualTo(MimeTypes.VIDEO_DOLBY_VISION);
+    assertThat(exportResult.exportException).isNull();
+    assertThat(exportResult.durationMs).isGreaterThan(0);
+    assertThat(exportResult.videoMimeType).isEqualTo(MimeTypes.VIDEO_DOLBY_VISION);
+  }
+
   @Test
   public void transcode_withOutputAudioMimeTypeAac_completesSuccessfully() throws Exception {
     MediaItem mediaItem = MediaItem.fromUri(Uri.parse(MP3_ASSET_URI_STRING));

libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/HdrEditingTest.java

@@ -15,6 +15,7 @@
  */
 package androidx.media3.transformer.mh;
 
+import static androidx.media3.common.MimeTypes.VIDEO_DOLBY_VISION;
 import static androidx.media3.common.MimeTypes.VIDEO_H265;
 import static androidx.media3.common.util.Assertions.checkState;
 import static androidx.media3.test.utils.TestUtil.retrieveTrackFormat;
@@ -139,6 +140,43 @@ public void export_transmuxHlg10File() throws Exception {
     assertThat(actualColorTransfer).isEqualTo(C.COLOR_TRANSFER_HLG);
   }
 
+  @Test
+  public void export_transmuxDolbyVisionFile() throws Exception {
+    Context context = ApplicationProvider.getApplicationContext();
+
+    if (Util.SDK_INT < 24) {
+      // TODO: b/285543404 - Remove suppression once we can transmux H.265/HEVC before API 24.
+      recordTestSkipped(context, testId, /* reason= */ "Can't transmux H.265/HEVC before API 24");
+      return;
+    }
+
+    if (AndroidTestUtil.skipAndLogIfFormatsUnsupported(
+        context,
+        testId,
+        /* inputFormat= */ MP4_ASSET_DOLBY_VISION_HDR_FORMAT,
+        /* outputFormat= */ null)) {
+      return;
+    }
+
+    Transformer transformer = new Transformer.Builder(context).build();
+    MediaItem mediaItem = MediaItem.fromUri(Uri.parse(MP4_ASSET_DOLBY_VISION_HDR));
+
+    ExportTestResult exportTestResult =
+        new TransformerAndroidTestRunner.Builder(context, transformer)
+            .build()
+            .run(testId, mediaItem);
+    @C.ColorTransfer
+    int actualColorTransfer =
+        retrieveTrackFormat(context, exportTestResult.filePath, C.TRACK_TYPE_VIDEO)
+            .colorInfo
+            .colorTransfer;
+    assertThat(actualColorTransfer).isEqualTo(C.COLOR_TRANSFER_HLG);
+    String actualMimeType =
+        retrieveTrackFormat(context, exportTestResult.filePath, C.TRACK_TYPE_VIDEO)
+            .sampleMimeType;
+    assertThat(actualMimeType).isEqualTo(VIDEO_DOLBY_VISION);
+  }
+
   @Test
   public void exportAndTranscode_hdr10File_whenHdrEditingIsSupported() throws Exception {
     Context context = ApplicationProvider.getApplicationContext();
@@ -360,6 +398,71 @@ public void onFallbackApplied(
     }
   }
 
+  @Test
+  public void exportAndTranscode_dolbyVisionFile_whenHdrEditingUnsupported_toneMapsOrThrows()
+      throws Exception {
+    Context context = ApplicationProvider.getApplicationContext();
+    Format format = MP4_ASSET_DOLBY_VISION_HDR_FORMAT;
+    if (deviceSupportsHdrEditing(VIDEO_H265, format.colorInfo)) {
+      recordTestSkipped(context, testId, /* reason= */ "Device supports Dolby Vision editing.");
+      return;
+    }
+
+    if (AndroidTestUtil.skipAndLogIfFormatsUnsupported(
+        context, testId, /* inputFormat= */ format, /* outputFormat= */ null)) {
+      return;
+    }
+
+    AtomicBoolean isFallbackListenerInvoked = new AtomicBoolean();
+    AtomicBoolean isToneMappingFallbackApplied = new AtomicBoolean();
+    Transformer transformer =
+        new Transformer.Builder(context)
+            .addListener(
+                new Transformer.Listener() {
+                  @Override
+                  public void onFallbackApplied(
+                      MediaItem inputMediaItem,
+                      TransformationRequest originalTransformationRequest,
+                      TransformationRequest fallbackTransformationRequest) {
+                    isFallbackListenerInvoked.set(true);
+                    assertThat(originalTransformationRequest.hdrMode).isEqualTo(HDR_MODE_KEEP_HDR);
+                    isToneMappingFallbackApplied.set(
+                        fallbackTransformationRequest.hdrMode
+                            == HDR_MODE_TONE_MAP_HDR_TO_SDR_USING_OPEN_GL);
+                  }
+                })
+            .build();
+    MediaItem mediaItem = MediaItem.fromUri(Uri.parse(MP4_ASSET_DOLBY_VISION_HDR));
+    EditedMediaItem editedMediaItem =
+        new EditedMediaItem.Builder(mediaItem).setEffects(FORCE_TRANSCODE_VIDEO_EFFECTS).build();
+
+    try {
+      ExportTestResult exportTestResult =
+          new TransformerAndroidTestRunner.Builder(context, transformer)
+              .build()
+              .run(testId, editedMediaItem);
+      assertThat(isToneMappingFallbackApplied.get()).isTrue();
+      @C.ColorTransfer
+      int actualColorTransfer =
+          retrieveTrackFormat(context, exportTestResult.filePath, C.TRACK_TYPE_VIDEO)
+              .colorInfo
+              .colorTransfer;
+      assertThat(actualColorTransfer).isEqualTo(C.COLOR_TRANSFER_SDR);
+    } catch (ExportException exception) {
+      if (exception.getCause() != null) {
+        @Nullable String message = exception.getCause().getMessage();
+        if (message != null
+            && (Objects.equals(message, "Decoding HDR is not supported on this device.")
+            || message.contains(
+            "OpenGL ES 3.0 context support is required for HDR input or output.")
+            || Objects.equals(message, "Device lacks YUV extension support."))) {
+          return;
+        }
+      }
+      throw exception;
+    }
+  }
+
   private static boolean deviceSupportsHdrEditing(String mimeType, ColorInfo colorInfo) {
     checkState(ColorInfo.isTransferHdr(colorInfo));
     return !EncoderUtil.getSupportedEncodersForHdrEditing(mimeType, colorInfo).isEmpty();

libraries/transformer/src/main/java/androidx/media3/transformer/DefaultDecoderFactory.java

@@ -42,6 +42,7 @@
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * Default implementation of {@link Codec.DecoderFactory} that uses {@link MediaCodec} for decoding.
@@ -135,6 +136,9 @@ public DefaultCodec createForVideoDecoding(
     if (SDK_INT >= 31 && requestSdrToneMapping) {
       mediaFormat.setInteger(
           MediaFormat.KEY_COLOR_TRANSFER_REQUEST, MediaFormat.COLOR_TRANSFER_SDR_VIDEO);
+    } else if (SDK_INT >= 31 && Objects.equals(format.sampleMimeType, MimeTypes.VIDEO_DOLBY_VISION)) {
+      mediaFormat.setInteger(
+          MediaFormat.KEY_COLOR_TRANSFER_REQUEST, MediaFormat.COLOR_TRANSFER_HLG);
     }
 
     @Nullable

libraries/transformer/src/main/java/androidx/media3/transformer/EncoderUtil.java

@@ -150,6 +150,13 @@ public static ImmutableList<Integer> getCodecProfilesForHdrFormat(
           return ImmutableList.of(MediaCodecInfo.CodecProfileLevel.AV1ProfileMain10HDR10);
         }
         break;
+      case MimeTypes.VIDEO_DOLBY_VISION:
+        if (colorTransfer == C.COLOR_TRANSFER_HLG) {
+          return ImmutableList.of(
+              MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt);
+        }
+        // CodecProfileLevel does not support PQ for Dolby Vision.
+        break;
       default:
         break;
     }

libraries/transformer/src/main/java/androidx/media3/transformer/FrameworkMuxer.java

@@ -22,9 +22,12 @@
 
 import android.annotation.SuppressLint;
 import android.media.MediaCodec;
+import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
 import android.media.MediaMuxer;
+import android.os.Build;
 import android.util.SparseLongArray;
+import androidx.annotation.RequiresApi;
 import androidx.media3.common.C;
 import androidx.media3.common.Format;
 import androidx.media3.common.Metadata;
@@ -108,6 +111,10 @@ public int addTrack(Format format) throws MuxerException {
     if (isVideo) {
       mediaFormat = MediaFormat.createVideoFormat(sampleMimeType, format.width, format.height);
       MediaFormatUtil.maybeSetColorInfo(mediaFormat, format.colorInfo);
+      if (sampleMimeType.equals(MimeTypes.VIDEO_DOLBY_VISION) && SDK_INT >= 33) {
+        mediaFormat.setInteger(MediaFormat.KEY_PROFILE, getDvProfile(format));
+        mediaFormat.setInteger(MediaFormat.KEY_LEVEL, getDvLevel(format));
+      }
       try {
         mediaMuxer.setOrientationHint(format.rotationDegrees);
       } catch (RuntimeException e) {
@@ -276,9 +283,64 @@ private static ImmutableList<String> getSupportedVideoSampleMimeTypes() {
     if (SDK_INT >= 24) {
       supportedMimeTypes.add(MimeTypes.VIDEO_H265);
     }
+    if (SDK_INT >= 33) {
+      supportedMimeTypes.add(MimeTypes.VIDEO_DOLBY_VISION);
+    }
     if (SDK_INT >= 34) {
       supportedMimeTypes.add(MimeTypes.VIDEO_AV1);
     }
     return supportedMimeTypes.build();
   }
+
+  // Get Dolby Vision profile
+  // Refer to https://professionalsupport.dolby.com/s/article/What-is-Dolby-Vision-Profile
+  @RequiresApi(33)
+  private static int getDvProfile(Format format) {
+    // Currently, only profile 8 is supported for encoding
+    // TODO: set profile ID based on format.
+    return MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt;
+  }
+
+  // Get Dolby Vision level
+  // Refer to https://professionalsupport.dolby.com/s/article/What-is-Dolby-Vision-Profile
+  @RequiresApi(33)
+  private static int getDvLevel(Format format) {
+    int level = -1;
+    int maxWidthHeight = Math.max(format.width, format.height);
+    float pps = format.width * format.height * format.frameRate;
+
+    if (maxWidthHeight <= 1280) {
+      if (pps <= 22118400) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelHd24;  // Level 01
+      } else { // pps <= 27648000
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelHd30;  // Level 02
+      }
+    } else if (maxWidthHeight <= 1920 && pps <= 49766400) {
+      level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd24;  // Level 03
+    } else if (maxWidthHeight <= 2560 && pps <= 62208000) {
+      level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd30;  // Level 04
+    } else if (maxWidthHeight <= 3840) {
+      if (pps <= 124416000) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd60;  // Level 05
+      } else if (pps <= 199065600) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd24;  // Level 06
+      } else if (pps <= 248832000) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd30;  // Level 07
+      } else if (pps <= 398131200) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd48;  // Level 08
+      } else if (pps <= 497664000) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd60;  // Level 09
+      } else { // pps <= 995328000
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd120;  // Level 10
+      }
+    } else if (maxWidthHeight <= 7680) {
+      if (pps <= 995328000) {
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevel8k30;  // Level 11
+      } else { // pps <= 1990656000
+        level = MediaCodecInfo.CodecProfileLevel.DolbyVisionLevel8k60;  // Level 12
+      }
+    }
+
+    return level;
+  }
 }