Open source muxer module

PiperOrigin-RevId: 526683141

core_settings.gradle

@@ -85,6 +85,9 @@ project(modulePrefix + 'extension-cast').projectDir = new File(rootDir, 'extensi
 include modulePrefix + 'library-effect'
 project(modulePrefix + 'library-effect').projectDir = new File(rootDir, 'library/effect')
 
+include modulePrefix + 'library-muxer'
+project(modulePrefix + 'library-muxer').projectDir = new File(rootDir, 'library/muxer')
+
 include modulePrefix + 'library-transformer'
 project(modulePrefix + 'library-transformer').projectDir = new File(rootDir, 'library/transformer')
 

library/muxer/README.md

+# Muxer module
+
+Provides functionality for producing media container files.
+
+## Getting the module
+
+The easiest way to get the module is to add it as a gradle dependency:
+
+```gradle
+implementation 'com.google.android.exoplayer:exoplayer-muxer:2.X.X'
+```
+
+where `2.X.X` is the version, which must match the version of the other media
+modules being used.
+
+Alternatively, you can clone this GitHub project and depend on the module
+locally. Instructions for doing this can be found in the [top level README][].
+
+[top level README]: https://github.com/google/ExoPlayer/blob/release-v2/README.md

library/muxer/build.gradle

+// Copyright 2022 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+apply from: "$gradle.ext.exoplayerSettingsDir/common_library_config.gradle"
+android {
+
+    defaultConfig {
+        // The following argument makes the Android Test Orchestrator run its
+        // "pm clear" command after each test invocation. This command ensures
+        // that the app's state is completely cleared between tests.
+        testInstrumentationRunnerArguments clearPackageData: 'true'
+        multiDexEnabled true
+    }
+
+    buildTypes {
+        debug {
+            testCoverageEnabled = true
+        }
+    }
+
+    sourceSets {
+        androidTest.assets.srcDir '../../testdata/src/test/assets/'
+        test.assets.srcDir '../../testdata/src/test/assets/'
+    }
+}
+
+ext {
+    javadocTitle = 'Muxer module'
+}
+
+dependencies {
+    implementation project(modulePrefix + 'library-common')
+    implementation 'androidx.annotation:annotation:' + androidxAnnotationVersion
+    compileOnly 'com.google.errorprone:error_prone_annotations:' + errorProneVersion
+    compileOnly 'org.checkerframework:checker-qual:' + checkerframeworkVersion
+    testImplementation project(modulePrefix + 'library-extractor')
+    testImplementation project(modulePrefix + 'robolectricutils')
+    testImplementation project(modulePrefix + 'testutils')
+    testImplementation project(modulePrefix + 'testdata')
+    testImplementation 'org.robolectric:robolectric:' + robolectricVersion
+    testImplementation 'com.google.truth:truth:' + truthVersion
+    androidTestImplementation 'junit:junit:' + junitVersion
+    androidTestImplementation 'androidx.test:runner:' + androidxTestRunnerVersion
+    androidTestImplementation 'com.google.truth:truth:' + truthVersion
+    androidTestImplementation project(modulePrefix + 'testutils')
+    androidTestImplementation project(modulePrefix + 'library-extractor')
+}
+apply from: '../../javadoc_library.gradle'
+
+ext {
+    releaseArtifactId = 'exoplayer-muxer'
+    releaseDescription = 'The ExoPlayer library muxer module.'
+}
+apply from: '../../publish.gradle'

library/muxer/src/androidTest/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright 2022 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  package="androidx.media3.muxer">
+
+  <uses-permission android:name="android.permission.INTERNET"/>
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+  <uses-sdk/>
+
+  <application
+    android:allowBackup="false"
+    tools:ignore="MissingApplicationIcon,HardcodedDebugMode"
+    android:usesCleartextTraffic="true"/>
+
+  <instrumentation
+    android:targetPackage="androidx.media3.muxer"
+    android:name="androidx.test.runner.AndroidJUnitRunner"/>
+</manifest>

library/muxer/src/androidTest/java/androidx/media3/muxer/AndroidMuxerTestUtil.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+/** Utilities for muxer test cases. */
+/* package */ final class AndroidMuxerTestUtil {
+  private static final String DUMP_FILE_OUTPUT_DIRECTORY = "muxerdumps";
+  private static final String DUMP_FILE_EXTENSION = "dump";
+
+  private AndroidMuxerTestUtil() {}
+
+  public static String getExpectedDumpFilePath(String originalFileName) {
+    return DUMP_FILE_OUTPUT_DIRECTORY + '/' + originalFileName + '.' + DUMP_FILE_EXTENSION;
+  }
+}

library/muxer/src/androidTest/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import android.content.Context;
+import android.media.MediaCodec;
+import android.media.MediaExtractor;
+import androidx.test.core.app.ApplicationProvider;
+import com.google.android.exoplayer2.extractor.mp4.Mp4Extractor;
+import com.google.android.exoplayer2.testutil.DumpFileAsserts;
+import com.google.android.exoplayer2.testutil.FakeExtractorOutput;
+import com.google.android.exoplayer2.testutil.TestUtil;
+import com.google.android.exoplayer2.util.MediaFormatUtil;
+import com.google.common.collect.ImmutableList;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+/** End to end instrumentation tests for {@link Mp4Muxer}. */
+@RunWith(Parameterized.class)
+public class Mp4MuxerEndToEndTest {
+  private static final String H264_MP4 = "sample.mp4";
+  private static final String H265_HDR10_MP4 = "hdr10-720p.mp4";
+  private static final String AV1_MP4 = "sample_av1.mp4";
+
+  @Parameters(name = "{0}")
+  public static ImmutableList<String> mediaSamples() {
+    return ImmutableList.of(H264_MP4, H265_HDR10_MP4, AV1_MP4);
+  }
+
+  @Parameter public String inputFile;
+
+  @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  private static final String MP4_FILE_ASSET_DIRECTORY = "media/mp4/";
+
+  private Context context;
+  private String outputPath;
+  private FileOutputStream outputStream;
+
+  @Before
+  public void setUp() throws Exception {
+    context = ApplicationProvider.getApplicationContext();
+    outputPath = temporaryFolder.newFile("muxeroutput.mp4").getPath();
+    outputStream = new FileOutputStream(outputPath);
+  }
+
+  @After
+  public void tearDown() throws IOException {
+    outputStream.close();
+  }
+
+  @Test
+  public void createMp4File_fromInputFileSampleData_matchesExpected() throws IOException {
+    Mp4Muxer mp4Muxer = null;
+
+    try {
+      mp4Muxer = new Mp4Muxer.Builder(outputStream).build();
+      feedInputDataToMuxer(mp4Muxer, inputFile);
+    } finally {
+      if (mp4Muxer != null) {
+        mp4Muxer.close();
+      }
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputPath);
+    DumpFileAsserts.assertOutput(
+        context, fakeExtractorOutput, AndroidMuxerTestUtil.getExpectedDumpFilePath(inputFile));
+  }
+
+  @Test
+  public void createMp4File_muxerNotClosed_createsPartiallyWrittenValidFile() throws IOException {
+    Mp4Muxer mp4Muxer = new Mp4Muxer.Builder(outputStream).build();
+    feedInputDataToMuxer(mp4Muxer, H265_HDR10_MP4);
+
+    // Muxer not closed.
+
+    // Audio sample written = 192 out of 195.
+    // Video sample written = 94 out of 127.
+    // Output is still a valid MP4 file.
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputPath);
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        AndroidMuxerTestUtil.getExpectedDumpFilePath("partial_" + H265_HDR10_MP4));
+  }
+
+  private void feedInputDataToMuxer(Mp4Muxer mp4Muxer, String inputFileName) throws IOException {
+    MediaExtractor extractor = new MediaExtractor();
+    extractor.setDataSource(
+        context.getResources().getAssets().openFd(MP4_FILE_ASSET_DIRECTORY + inputFileName));
+
+    List<Mp4Muxer.TrackToken> addedTracks = new ArrayList<>();
+    int sortKey = 0;
+    for (int i = 0; i < extractor.getTrackCount(); i++) {
+      Mp4Muxer.TrackToken trackToken =
+          mp4Muxer.addTrack(
+              sortKey++, MediaFormatUtil.createFormatFromMediaFormat(extractor.getTrackFormat(i)));
+      addedTracks.add(trackToken);
+      extractor.selectTrack(i);
+    }
+
+    do {
+      MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+      bufferInfo.flags = extractor.getSampleFlags();
+      bufferInfo.offset = 0;
+      bufferInfo.presentationTimeUs = extractor.getSampleTime();
+      int sampleSize = (int) extractor.getSampleSize();
+      bufferInfo.size = sampleSize;
+
+      ByteBuffer sampleBuffer = ByteBuffer.allocateDirect(sampleSize);
+      extractor.readSampleData(sampleBuffer, /* offset= */ 0);
+
+      sampleBuffer.rewind();
+
+      mp4Muxer.writeSampleData(
+          addedTracks.get(extractor.getSampleTrackIndex()), sampleBuffer, bufferInfo);
+    } while (extractor.advance());
+
+    extractor.release();
+  }
+}

library/muxer/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright 2022 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest package="androidx.media3.muxer">
+  <uses-sdk />
+</manifest>

library/muxer/src/main/java/androidx/media3/muxer/AnnexBToAvccConverter.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.android.exoplayer2.util.Assertions.checkArgument;
+
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+
+/**
+ * Converts a buffer containing H.264/H.265 NAL units from the Annex-B format (ISO/IEC 14496-14
+ * Annex B, which uses start codes to delineate NAL units) to the avcC format (ISO/IEC 14496-15,
+ * which uses length prefixes).
+ */
+public interface AnnexBToAvccConverter {
+  /** Default implementation for {@link AnnexBToAvccConverter}. */
+  AnnexBToAvccConverter DEFAULT =
+      (ByteBuffer inputBuffer) -> {
+        if (!inputBuffer.hasRemaining()) {
+          return;
+        }
+
+        checkArgument(
+            inputBuffer.position() == 0, "The input buffer should have position set to 0.");
+
+        ImmutableList<ByteBuffer> nalUnitList = AnnexBUtils.findNalUnits(inputBuffer);
+
+        for (int i = 0; i < nalUnitList.size(); i++) {
+          int currentNalUnitLength = nalUnitList.get(i).remaining();
+
+          // Replace the start code with the NAL unit length.
+          inputBuffer.putInt(currentNalUnitLength);
+
+          // Shift the input buffer's position to next start code.
+          int newPosition = inputBuffer.position() + currentNalUnitLength;
+          inputBuffer.position(newPosition);
+        }
+        inputBuffer.rewind();
+      };
+
+  /**
+   * Processes a buffer in-place.
+   *
+   * <p>Expects a {@link ByteBuffer} input with a zero offset.
+   *
+   * @param inputBuffer The buffer to be converted.
+   */
+  void process(ByteBuffer inputBuffer);
+}

library/muxer/src/main/java/androidx/media3/muxer/AnnexBUtils.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+
+/** NAL unit utilities for start codes and emulation prevention. */
+/* package */ final class AnnexBUtils {
+  private AnnexBUtils() {}
+
+  /**
+   * Splits a {@link ByteBuffer} into individual NAL units (0x00000001 start code).
+   *
+   * <p>An empty list is returned if the input is not NAL units.
+   *
+   * <p>The position of the input buffer is unchanged after calling this method.
+   */
+  public static ImmutableList<ByteBuffer> findNalUnits(ByteBuffer input) {
+    if (input.remaining() < 4 || input.getInt(0) != 1) {
+      return ImmutableList.of();
+    }
+
+    ImmutableList.Builder<ByteBuffer> nalUnits = new ImmutableList.Builder<>();
+
+    int lastStart = 4;
+    int zerosSeen = 0;
+
+    for (int i = 4; i < input.limit(); i++) {
+      if (input.get(i) == 1 && zerosSeen >= 3) {
+        // We're just looking at a start code.
+        nalUnits.add(getBytes(input, lastStart, i - 3 - lastStart));
+        lastStart = i + 1;
+      }
+
+      // Handle the end of the stream.
+      if (i == input.limit() - 1) {
+        nalUnits.add(getBytes(input, lastStart, input.limit() - lastStart));
+      }
+
+      if (input.get(i) == 0) {
+        zerosSeen++;
+      } else {
+        zerosSeen = 0;
+      }
+    }
+    input.rewind();
+    return nalUnits.build();
+  }
+
+  /** Removes Annex-B emulation prevention bytes from a buffer. */
+  public static ByteBuffer stripEmulationPrevention(ByteBuffer input) {
+    // For simplicity, we allocate the same number of bytes (although the eventual number might be
+    // smaller).
+    ByteBuffer output = ByteBuffer.allocate(input.limit());
+    int zerosSeen = 0;
+    for (int i = 0; i < input.limit(); i++) {
+      boolean lookingAtEmulationPreventionByte = input.get(i) == 0x03 && zerosSeen >= 2;
+
+      // Only copy bytes if they aren't emulation prevention bytes.
+      if (!lookingAtEmulationPreventionByte) {
+        output.put(input.get(i));
+      }
+
+      if (input.get(i) == 0) {
+        zerosSeen++;
+      } else {
+        zerosSeen = 0;
+      }
+    }
+
+    output.flip();
+
+    return output;
+  }
+
+  private static ByteBuffer getBytes(ByteBuffer buf, int offset, int length) {
+    ByteBuffer result = buf.duplicate();
+    result.position(offset);
+    result.limit(offset + length);
+    return result.slice();
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/BoxUtils.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import com.google.common.base.Charsets;
+import java.nio.ByteBuffer;
+import java.util.List;
+
+/** Utilities for dealing with MP4 boxes. */
+/* package */ final class BoxUtils {
+  private static final int BOX_TYPE_BYTES = 4;
+  private static final int BOX_SIZE_BYTES = 4;
+
+  private BoxUtils() {}
+
+  /** Wraps content into a box, prefixing it with a length and a box type. */
+  public static ByteBuffer wrapIntoBox(String boxType, ByteBuffer contents) {
+    byte[] typeByteArray = boxType.getBytes(Charsets.UTF_8);
+    return wrapIntoBox(typeByteArray, contents);
+  }
+
+  /**
+   * Wraps content into a box, prefixing it with a length and a box type.
+   *
+   * <p>Use this method for box types with special characters. For example location box, which has a
+   * copyright symbol in the beginning.
+   */
+  public static ByteBuffer wrapIntoBox(byte[] boxType, ByteBuffer contents) {
+    ByteBuffer box = ByteBuffer.allocate(contents.remaining() + BOX_TYPE_BYTES + BOX_SIZE_BYTES);
+    box.putInt(contents.remaining() + BOX_TYPE_BYTES + BOX_SIZE_BYTES);
+    box.put(boxType, 0, BOX_SIZE_BYTES);
+    box.put(contents);
+    box.flip();
+    return box;
+  }
+
+  /** Concatenate multiple boxes into a box, prefixing it with a length and a box type. */
+  public static ByteBuffer wrapBoxesIntoBox(String boxType, List<ByteBuffer> boxes) {
+    int totalSize = BOX_TYPE_BYTES + BOX_SIZE_BYTES;
+    for (int i = 0; i < boxes.size(); i++) {
+      totalSize += boxes.get(i).limit();
+    }
+
+    ByteBuffer result = ByteBuffer.allocate(totalSize);
+    result.putInt(totalSize);
+    result.put(boxType.getBytes(Charsets.UTF_8), 0, BOX_TYPE_BYTES);
+
+    for (int i = 0; i < boxes.size(); i++) {
+      result.put(boxes.get(i));
+    }
+
+    result.flip();
+    return result;
+  }
+
+  /**
+   * Concatenates multiple {@linkplain ByteBuffer byte buffers} into a single {@link ByteBuffer}.
+   */
+  public static ByteBuffer concatenateBuffers(ByteBuffer... buffers) {
+    int totalSize = 0;
+    for (ByteBuffer buffer : buffers) {
+      totalSize += buffer.limit();
+    }
+
+    ByteBuffer result = ByteBuffer.allocate(totalSize);
+    for (ByteBuffer buffer : buffers) {
+      result.put(buffer);
+    }
+
+    result.flip();
+    return result;
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Boxes.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static androidx.media3.muxer.ColorUtils.MEDIAFORMAT_STANDARD_TO_PRIMARIES_AND_MATRIX;
+import static androidx.media3.muxer.ColorUtils.MEDIAFORMAT_TRANSFER_TO_MP4_TRANSFER;
+import static androidx.media3.muxer.Mp4Utils.MVHD_TIMEBASE;
+import static com.google.android.exoplayer2.util.Assertions.checkArgument;
+import static com.google.android.exoplayer2.util.Assertions.checkNotNull;
+import static com.google.android.exoplayer2.util.Assertions.checkState;
+
+import android.media.MediaCodec;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.exoplayer2.util.NalUnitUtil;
+import com.google.android.exoplayer2.util.Util;
+import com.google.android.exoplayer2.video.ColorInfo;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.primitives.Bytes;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Writes out various types of boxes as per MP4 (ISO/IEC 14496-12) standards.
+ *
+ * <p>Boxes do not construct their sub-boxes but take them as input {@linkplain ByteBuffer byte
+ * buffers}.
+ */
+/* package */ final class Boxes {
+  private Boxes() {}
+
+  public static final ImmutableList<Byte> XMP_UUID =
+      ImmutableList.of(
+          (byte) 0xBE,
+          (byte) 0x7A,
+          (byte) 0xCF,
+          (byte) 0xCB,
+          (byte) 0x97,
+          (byte) 0xA9,
+          (byte) 0x42,
+          (byte) 0xE8,
+          (byte) 0x9C,
+          (byte) 0x71,
+          (byte) 0x99,
+          (byte) 0x94,
+          (byte) 0x91,
+          (byte) 0xE3,
+          (byte) 0xAF,
+          (byte) 0xAC);
+
+  /**
+   * Returns the tkhd box.
+   *
+   * <p>This is a per-track header box.
+   */
+  public static ByteBuffer tkhd(
+      int trackId,
+      int trackDurationVu,
+      long modificationDateUnixMs,
+      int orientation,
+      Format format) {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x00000007); // version and flags; allow presentation, etc.
+
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // creation_time
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // modification_time
+
+    contents.putInt(trackId);
+    contents.putInt(0); // reserved
+
+    contents.putInt(trackDurationVu);
+
+    contents.putInt(0); // reserved
+    contents.putInt(0); // reserved
+
+    contents.putInt(0); // layer = 0 and alternate_group = 0
+    contents.putShort(MimeTypes.isAudio(format.sampleMimeType) ? (short) 0x0100 : 0); // volume
+    contents.putShort((short) 0); // reserved
+
+    contents.put(rotationMatrixFromOrientation(orientation));
+
+    int width = format.width != Format.NO_VALUE ? format.width : 0;
+    int height = format.height != Format.NO_VALUE ? format.height : 0;
+
+    contents.putInt(width << 16);
+    contents.putInt(height << 16);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("tkhd", contents);
+  }
+
+  /**
+   * Returns the mvhd box.
+   *
+   * <p>This is the movie header for the entire MP4 file.
+   */
+  public static ByteBuffer mvhd(
+      int nextEmptyTrackId, long modificationDateUnixMs, long videoDurationUs) {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0); // version and flags
+
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // creation_time
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // modification_time
+    contents.putInt((int) MVHD_TIMEBASE); // The per-track timescales might be different.
+    contents.putInt(
+        (int) Mp4Utils.vuFromUs(videoDurationUs, MVHD_TIMEBASE)); // Duration of the entire video.
+    contents.putInt(0x00010000); // rate = 1.0
+    contents.putShort((short) 0x0100); // volume = full volume
+    contents.putShort((short) 0); // reserved
+
+    contents.putInt(0); // reserved
+    contents.putInt(0); // reserved
+
+    // Default values (unity matrix). It looks like that this needs to be an identity matrix, since
+    // some players will apply both this and the per-track transformation, while some only go with
+    // the per-track one.
+    int[] matrix = {0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
+    for (int i = 0; i < matrix.length; i++) {
+      contents.putInt(matrix[i]);
+    }
+
+    for (int i = 0; i < 6; i++) {
+      contents.putInt(0); // pre_defined
+    }
+
+    // Next empty track id.
+    contents.putInt(nextEmptyTrackId);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("mvhd", contents);
+  }
+
+  /**
+   * Returns the mdhd box.
+   *
+   * <p>This is a per-track (media) header.
+   */
+  public static ByteBuffer mdhd(
+      long trackDurationVu,
+      int videoUnitTimebase,
+      long modificationDateUnixMs,
+      @Nullable String languageCode) {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags
+
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // creation_time
+    contents.putInt(toMp4Time(modificationDateUnixMs)); // modification_time
+
+    contents.putInt(videoUnitTimebase);
+
+    contents.putInt((int) trackDurationVu);
+
+    contents.putShort(languageCodeFromString(languageCode));
+    contents.putShort((short) 0);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("mdhd", contents);
+  }
+
+  /**
+   * Returns the vmhd box.
+   *
+   * <p>This is a header for video tracks.
+   */
+  public static ByteBuffer vmhd() {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags
+
+    contents.putShort((short) 0); // graphicsmode
+    // opcolor (red, green, blue)
+    contents.putShort((short) 0);
+    contents.putShort((short) 0);
+    contents.putShort((short) 0);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("vmhd", contents);
+  }
+
+  /**
+   * Returns the smhd box.
+   *
+   * <p>This is a header for audio tracks.
+   */
+  public static ByteBuffer smhd() {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags
+
+    contents.putShort((short) 0); // balance
+    contents.putShort((short) 0); // reserved
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("smhd", contents);
+  }
+
+  /**
+   * Returns the nmhd box.
+   *
+   * <p>This is a header for metadata tracks.
+   */
+  public static ByteBuffer nmhd() {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("nmhd", contents);
+  }
+
+  /**
+   * Returns a metadata sample entry box.
+   *
+   * <p>This contains the sample entry (to be placed within the sample description box) for metadata
+   * tracks.
+   *
+   * <p>The mett box corresponds to text metadata sample entry.
+   */
+  public static ByteBuffer metadataSampleEntry(Format format) {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    String mimeType = checkNotNull(format.sampleMimeType);
+    byte[] mimeBytes = Util.getUtf8Bytes(mimeType);
+    contents.put(mimeBytes);
+    contents.put((byte) 0x00);
+    contents.put(mimeBytes);
+    contents.put((byte) 0x00);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("mett", contents);
+  }
+
+  /** Returns the minf (media info) box. */
+  public static ByteBuffer minf(ByteBuffer... subBoxes) {
+    return BoxUtils.wrapBoxesIntoBox("minf", Arrays.asList(subBoxes));
+  }
+
+  /** Returns the dref (data references) box. */
+  public static ByteBuffer dref(ByteBuffer... dataLocationBoxes) {
+    // We have a "number of contained boxes" field; let's pretend this is also a box so that
+    // wrapBoxesIntoBoxes() can concatenate it with the rest.
+    ByteBuffer header = ByteBuffer.allocate(8);
+    header.putInt(0);
+    header.putInt(dataLocationBoxes.length);
+    header.flip();
+
+    List<ByteBuffer> contents = new ArrayList<>();
+    contents.add(header);
+    Collections.addAll(contents, dataLocationBoxes);
+
+    return BoxUtils.wrapBoxesIntoBox("dref", contents);
+  }
+
+  /** Returns the dinf (data information) box. */
+  public static ByteBuffer dinf(ByteBuffer dref) {
+    return BoxUtils.wrapIntoBox("dinf", dref);
+  }
+
+  /**
+   * Returns the url box.
+   *
+   * <p>This box declares the location of media data (whether it is in this file or in some other
+   * remote file).
+   */
+  public static ByteBuffer localUrl() {
+    ByteBuffer contents = ByteBuffer.allocate(4);
+
+    // Flag indicating that the data is in fact in this very file instead of a remote
+    // URL. Accordingly, no actual URL string is present.
+    contents.putInt(1);
+
+    // Since we set the flag to 1, no actual URL needs to follow.
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("url ", contents);
+  }
+
+  /**
+   * Returns the hdlr box.
+   *
+   * <p>This box includes tha handler specification for a track (signals whether this is video,
+   * audio or metadata).
+   *
+   * @param handlerType The handle type, as defined in ISO/IEC 14496-12: 8.4.3.3.
+   * @param handlerName The handler name, a human-readable name to identify track type for debugging
+   *     and inspection purposes.
+   * @return {@link ByteBuffer} containing the hdlr box.
+   */
+  public static ByteBuffer hdlr(String handlerType, String handlerName) {
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags.
+    contents.putInt(0); // pre_defined.
+    contents.put(Util.getUtf8Bytes(handlerType)); // handler_type.
+    contents.putInt(0); // reserved.
+    contents.putInt(0); // reserved.
+    contents.putInt(0); // reserved.
+    contents.put(Util.getUtf8Bytes(handlerName)); // name.
+    contents.put((byte) 0); // The null terminator for name.
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("hdlr", contents);
+  }
+
+  /**
+   * Returns the mdia box.
+   *
+   * <p>This box describes the media format of a track.
+   */
+  public static ByteBuffer mdia(ByteBuffer... subBoxes) {
+    return BoxUtils.wrapBoxesIntoBox("mdia", Arrays.asList(subBoxes));
+  }
+
+  /**
+   * Returns the trak box.
+   *
+   * <p>This is a top level track descriptor box; each track has one.
+   */
+  public static ByteBuffer trak(ByteBuffer... subBoxes) {
+    return BoxUtils.wrapBoxesIntoBox("trak", Arrays.asList(subBoxes));
+  }
+
+  /**
+   * Returns the udta box.
+   *
+   * <p>This box contains user data like location info.
+   */
+  public static ByteBuffer udta(@Nullable Mp4Location location) {
+    // We can just omit the entire box if there is no location info available.
+    if (location == null) {
+      return ByteBuffer.allocate(0);
+    }
+
+    String locationString =
+        String.format(Locale.US, "%+.4f%+.4f/", location.latitude, location.longitude);
+
+    ByteBuffer xyzBoxContents = ByteBuffer.allocate(locationString.length() + 2 + 2);
+    xyzBoxContents.putShort((short) (xyzBoxContents.capacity() - 4));
+    xyzBoxContents.putShort((short) 0x15C7); // language code?
+
+    xyzBoxContents.put(Util.getUtf8Bytes(locationString));
+    checkState(xyzBoxContents.limit() == xyzBoxContents.capacity());
+    xyzBoxContents.flip();
+
+    return BoxUtils.wrapIntoBox(
+        "udta",
+        BoxUtils.wrapIntoBox(
+            new byte[] {
+              (byte) 0xA9, // copyright symbol
+              'x',
+              'y',
+              'z'
+            },
+            xyzBoxContents));
+  }
+
+  /**
+   * Returns the keys box.
+   *
+   * <p>This box contains a list of metadata keys.
+   */
+  public static ByteBuffer keys(List<String> keyNames) {
+    // This should be an adaptive size here; we don't yet care since it's usually small.
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags.
+    contents.putInt(keyNames.size()); // num of entries
+
+    for (int i = 0; i < keyNames.size(); i++) {
+      ByteBuffer keyNameBuffer = ByteBuffer.wrap(Util.getUtf8Bytes(keyNames.get(i)));
+      contents.put(BoxUtils.wrapIntoBox("mdta", keyNameBuffer));
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("keys", contents);
+  }
+
+  /**
+   * Returns the ilst box.
+   *
+   * <p>This box contains a list of metadata values.
+   */
+  public static ByteBuffer ilst(List<Object> values) {
+    // This should be an adaptive size here; we don't yet care since it's usually small.
+    ByteBuffer contents = ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    for (int i = 0; i < values.size(); i++) {
+      int keyId = i + 1;
+      Object value = values.get(i);
+
+      ByteBuffer valueContents;
+      if (value instanceof String) {
+        String valueString = (String) value;
+        byte[] valueBytes = Util.getUtf8Bytes(valueString);
+        valueContents = ByteBuffer.allocate(valueBytes.length + 8);
+        valueContents.putInt(1); // type code for UTF-8 string
+        valueContents.putInt(0); // default country / language
+        valueContents.put(valueBytes);
+
+      } else if (value instanceof Float) {
+        valueContents = ByteBuffer.allocate(12);
+        valueContents.putInt(23); // float32
+        valueContents.putInt(0); // language / country
+        valueContents.putFloat((float) value);
+      } else {
+        throw new IllegalArgumentException("Unknown metadata type: " + value.getClass());
+      }
+
+      valueContents.flip();
+      ByteBuffer valueBox = BoxUtils.wrapIntoBox("data", valueContents);
+      contents.putInt(valueBox.remaining() + 8);
+      contents.putInt(keyId);
+      contents.put(valueBox);
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("ilst", contents);
+  }
+
+  /** Returns the meta (metadata) box. */
+  public static ByteBuffer meta(ByteBuffer... subBoxes) {
+    return BoxUtils.wrapBoxesIntoBox("meta", Arrays.asList(subBoxes));
+  }
+
+  /**
+   * Returns the uuid box.
+   *
+   * <p>This box is used for XMP and other metadata.
+   */
+  public static ByteBuffer uuid(List<Byte> uuid, ByteBuffer contents) {
+    checkArgument(contents.remaining() > 0);
+    return BoxUtils.wrapBoxesIntoBox(
+        "uuid", ImmutableList.of(ByteBuffer.wrap(Bytes.toArray(uuid)), contents));
+  }
+
+  /**
+   * Returns the moov box.
+   *
+   * <p>This box is a top level movie descriptor box (there is a single one of this per Mp4 file).
+   */
+  public static ByteBuffer moov(
+      ByteBuffer mvhdBox,
+      ByteBuffer udtaBox,
+      ByteBuffer metaBox,
+      List<ByteBuffer> trakBoxes,
+      ByteBuffer mvexBox) {
+    List<ByteBuffer> subBoxes = new ArrayList<>();
+    subBoxes.add(mvhdBox);
+    subBoxes.add(udtaBox);
+    subBoxes.add(metaBox);
+    subBoxes.addAll(trakBoxes);
+    subBoxes.add(mvexBox);
+
+    return BoxUtils.wrapBoxesIntoBox("moov", subBoxes);
+  }
+
+  /** Returns an audio sample entry box based on the MIME type. */
+  public static ByteBuffer audioSampleEntry(Format format) {
+    String mimeType = checkNotNull(format.sampleMimeType);
+    checkArgument(mimeType.equals(MimeTypes.AUDIO_AAC), "Unsupported audio format: " + mimeType);
+    String fourcc = "mp4a";
+
+    checkArgument(!format.initializationData.isEmpty(), "csd-0 not found in the format.");
+    ByteBuffer csd0 = ByteBuffer.wrap(format.initializationData.get(0));
+    ByteBuffer contents = ByteBuffer.allocate(csd0.limit() + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x00); // reserved
+    contents.putShort((short) 0x0); // reserved
+    contents.putShort((short) 0x1); // data ref index
+    contents.putInt(0x00); // reserved
+    contents.putInt(0x00); // reserved
+
+    int channelCount = format.channelCount;
+    contents.putShort((short) channelCount);
+    contents.putShort((short) 16); // sample size
+    contents.putShort((short) 0x0); // predefined
+    contents.putShort((short) 0x0); // reserved
+
+    int sampleRate = format.sampleRate;
+    contents.putInt(sampleRate << 16);
+
+    contents.put(audioEsdsBox(format));
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox(fourcc, contents);
+  }
+
+  /** Returns a codec specific box. */
+  public static ByteBuffer codecSpecificBox(Format format) {
+    String mimeType = checkNotNull(format.sampleMimeType);
+    switch (mimeType) {
+      case "video/avc":
+        return avcCBox(format);
+      case "video/hevc":
+        return hvcCBox(format);
+      case "video/av01":
+        return av1CBox(format);
+      default:
+        throw new IllegalArgumentException("Unsupported video format: " + mimeType);
+    }
+  }
+
+  /**
+   * Returns a {@code VisualSampleEntry} box based upon the MIME type.
+   *
+   * <p>The {@code VisualSampleEntry} schema is defined in ISO/IEC 14496-12: 8.5.2.2.
+   */
+  public static ByteBuffer videoSampleEntry(Format format) {
+    ByteBuffer codecSpecificBox = codecSpecificBox(format);
+    String fourcc = codecSpecificFourcc(format);
+
+    ByteBuffer contents =
+        ByteBuffer.allocate(Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE + codecSpecificBox.limit());
+
+    // reserved = 0 (6 bytes)
+    contents.putInt(0);
+    contents.putShort((short) 0);
+
+    contents.putShort((short) 1); // data_reference_index
+
+    contents.putShort((short) 0); // pre_defined
+    contents.putShort((short) 0); // reserved
+
+    // pre_defined
+    contents.putInt(0);
+    contents.putInt(0);
+    contents.putInt(0);
+
+    contents.putShort(format.width != Format.NO_VALUE ? (short) format.width : 0);
+    contents.putShort(format.height != Format.NO_VALUE ? (short) format.height : 0);
+
+    contents.putInt(0x00480000); // horizresolution = 72 dpi
+    contents.putInt(0x00480000); // vertresolution = 72 dpi
+
+    contents.putInt(0); // reserved
+
+    contents.putShort((short) 1); // frame_count
+
+    // compressorname
+    contents.putLong(0);
+    contents.putLong(0);
+    contents.putLong(0);
+    contents.putLong(0);
+
+    contents.putShort((short) 0x0018); // depth
+    contents.putShort((short) -1); // pre_defined
+
+    contents.put(codecSpecificBox);
+
+    contents.put(paspBox());
+
+    // Put in a "colr" box if any of the three color format parameters has a non-default (0) value.
+    // TODO(b/278101856): Only null check should be enough once we disallow invalid values.
+    if (format.colorInfo != null
+        && (format.colorInfo.colorSpace != 0
+            || format.colorInfo.colorTransfer != 0
+            || format.colorInfo.colorRange != 0)) {
+      contents.put(colrBox(format.colorInfo));
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox(fourcc, contents);
+  }
+
+  /**
+   * Converts sample presentation times (in microseconds) to sample durations (in timebase units)
+   * that will go into the stts box.
+   *
+   * <p>ISO/IEC 14496-12: 8.6.1.3.1 recommends each track starts at 0. Therefore, the first sample
+   * presentation timestamp is set to 0 and the duration of that sample may be larger as a result.
+   *
+   * @param writtenSamples All the written samples.
+   * @param minInputPresentationTimestampUs The global minimum presentation timestamp which needs to
+   *     be subtracted from each sample's presentation timestamp.
+   * @param videoUnitTimescale The timescale of the track.
+   * @param lastDurationBehavior The behaviour for the last sample duration.
+   * @return A list of all the sample durations.
+   */
+  public static List<Long> durationsVuForStts(
+      List<MediaCodec.BufferInfo> writtenSamples,
+      long minInputPresentationTimestampUs,
+      int videoUnitTimescale,
+      @Mp4Muxer.LastFrameDurationBehavior int lastDurationBehavior) {
+    List<Long> durationsVu = new ArrayList<>();
+
+    long currentTimeVu = 0L;
+
+    for (int sampleId = 0; sampleId < writtenSamples.size(); sampleId++) {
+      long samplePtsUs = writtenSamples.get(sampleId).presentationTimeUs;
+      long sampleSpanEndsAtUs =
+          sampleId == writtenSamples.size() - 1
+              ? samplePtsUs
+              : writtenSamples.get(sampleId + 1).presentationTimeUs;
+
+      sampleSpanEndsAtUs -= minInputPresentationTimestampUs;
+
+      long sampleSpanEndsAtVu = Mp4Utils.vuFromUs(sampleSpanEndsAtUs, videoUnitTimescale);
+
+      long durationVu = sampleSpanEndsAtVu - currentTimeVu;
+      currentTimeVu = sampleSpanEndsAtVu;
+
+      if (durationVu >= Integer.MAX_VALUE) {
+        throw new IllegalArgumentException(
+            String.format(Locale.US, "Timestamp delta %d doesn't fit into an int", durationVu));
+      }
+
+      durationsVu.add(durationVu);
+    }
+
+    adjustLastSampleDuration(durationsVu, lastDurationBehavior);
+
+    return durationsVu;
+  }
+
+  /** Generates the stts (decoding time to sample) box. */
+  public static ByteBuffer stts(List<Long> durationsVu) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(durationsVu.size() * 8 + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version and flags.
+
+    // We will know total entry count only after processing all the sample durations, so put in a
+    // placeholder for total entry count and store its index.
+    int totalEntryCountIndex = contents.position();
+    contents.putInt(0x0); // entry_count.
+
+    int totalEntryCount = 0;
+    long lastDurationVu = -1L;
+    int lastSampleCountIndex = -1;
+
+    // Note that the framework MediaMuxer adjust time deltas within plus-minus 100 us, so that
+    // samples have repeating duration values. It saves few entries in the table.
+    for (int i = 0; i < durationsVu.size(); i++) {
+      long durationVu = durationsVu.get(i);
+      if (lastDurationVu != durationVu) {
+        lastDurationVu = durationVu;
+        lastSampleCountIndex = contents.position();
+
+        // sample_count; this will be updated instead of adding a new entry if the next sample has
+        // the same duration.
+        contents.putInt(1);
+        contents.putInt((int) durationVu); // sample_delta.
+        totalEntryCount++;
+      } else {
+        contents.putInt(lastSampleCountIndex, contents.getInt(lastSampleCountIndex) + 1);
+      }
+    }
+
+    contents.putInt(totalEntryCountIndex, totalEntryCount);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("stts", contents);
+  }
+
+  /** Returns the stsz (sample size) box. */
+  public static ByteBuffer stsz(List<MediaCodec.BufferInfo> writtenSamples) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(writtenSamples.size() * 4 + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version and flags.
+
+    // TODO(b/270583563): Consider optimizing for identically-sized samples.
+    //  sample_size; specifying the default sample size. Set to zero to indicate that the samples
+    //  have different sizes and they are stored in the sample size table.
+    contents.putInt(0);
+
+    contents.putInt(writtenSamples.size()); // sample_count.
+
+    for (int i = 0; i < writtenSamples.size(); i++) {
+      contents.putInt(writtenSamples.get(i).size);
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("stsz", contents);
+  }
+
+  /** Returns the stsc (sample to chunk) box. */
+  public static ByteBuffer stsc(List<Integer> writtenChunkSampleCounts) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(
+            writtenChunkSampleCounts.size() * 12 + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version and flags.
+    contents.putInt(writtenChunkSampleCounts.size()); // entry_count.
+
+    int currentChunk = 1;
+
+    // TODO(b/270583563): Consider optimizing for consecutive chunks having same number of samples.
+    for (int i = 0; i < writtenChunkSampleCounts.size(); i++) {
+      int samplesInChunk = writtenChunkSampleCounts.get(i);
+      contents.putInt(currentChunk); // first_chunk.
+      contents.putInt(samplesInChunk); // samples_per_chunk.
+      // sample_description_index; we have only one sample description in each track.
+      contents.putInt(1);
+
+      currentChunk += 1;
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("stsc", contents);
+  }
+
+  /** Returns the co64 (chunk offset) box. */
+  public static ByteBuffer co64(List<Long> writtenChunkOffsets) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(writtenChunkOffsets.size() * 8 + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version.
+    contents.putInt(writtenChunkOffsets.size()); // entry_count.
+
+    for (int i = 0; i < writtenChunkOffsets.size(); i++) {
+      contents.putLong(writtenChunkOffsets.get(i)); // chunk_offset.
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("co64", contents);
+  }
+
+  /** Returns the stss (sync sample) box. */
+  public static ByteBuffer stss(List<MediaCodec.BufferInfo> writtenSamples) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(writtenSamples.size() * 4 + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version and flags.
+
+    // We will know total entry count only after processing all the sample, so put in a placeholder
+    // for total entry count and store its index.
+    int totalEntryCountIndex = contents.position();
+    contents.putInt(writtenSamples.size()); // entry_count.
+
+    int currentSampleNumber = 1;
+    int totalKeyFrames = 0;
+    for (int i = 0; i < writtenSamples.size(); i++) {
+      MediaCodec.BufferInfo info = writtenSamples.get(i);
+      if ((info.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) > 0) {
+        contents.putInt(currentSampleNumber); // sample_number.
+        totalKeyFrames++;
+      }
+
+      currentSampleNumber++;
+    }
+
+    contents.putInt(totalEntryCountIndex, totalKeyFrames);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("stss", contents);
+  }
+
+  /** Returns the stsd (sample description) box. */
+  public static ByteBuffer stsd(ByteBuffer sampleEntryBox) {
+    ByteBuffer contents =
+        ByteBuffer.allocate(sampleEntryBox.limit() + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.putInt(0x0); // version and flags.
+    contents.putInt(1); // entry_count, We have only one sample description in each track.
+    contents.put(sampleEntryBox);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("stsd", contents);
+  }
+
+  /** Returns the stbl (sample table) box. */
+  public static ByteBuffer stbl(ByteBuffer... subBoxes) {
+    return BoxUtils.wrapBoxesIntoBox("stbl", Arrays.asList(subBoxes));
+  }
+
+  /** Creates the ftyp box. */
+  public static ByteBuffer ftyp() {
+    List<ByteBuffer> boxBytes = new ArrayList<>();
+
+    String majorVersion = "isom";
+    boxBytes.add(ByteBuffer.wrap(Util.getUtf8Bytes(majorVersion)));
+
+    int minorVersion = 0x020000;
+    ByteBuffer minorBytes = ByteBuffer.allocate(4);
+    minorBytes.putInt(minorVersion);
+    minorBytes.flip();
+    boxBytes.add(minorBytes);
+
+    String[] compatibleBrands = {"isom", "iso2", "mp41"};
+    for (String compatibleBrand : compatibleBrands) {
+      boxBytes.add(ByteBuffer.wrap(Util.getUtf8Bytes(compatibleBrand)));
+    }
+
+    return BoxUtils.wrapBoxesIntoBox("ftyp", boxBytes);
+  }
+
+  /** Adjusts the duration of the very last sample if needed. */
+  private static void adjustLastSampleDuration(
+      List<Long> durationsToBeAdjustedVu, @Mp4Muxer.LastFrameDurationBehavior int behavior) {
+    // Technically, MP4 files store not timestamps but frame durations. Thus, if we interpret
+    // timestamps as the start of frames then it's not obvious what's the duration of the very
+    // last frame should be. If our samples follow each other in roughly regular intervals (e.g. in
+    // a normal, 30 fps video), it makes sense to assume that the last sample will last the same ~33
+    // ms as the all the other ones before. On the other hand, if we have just a few, irregularly
+    // spaced frames, with duplication, the entire duration of the video will increase, creating
+    // abnormal gaps.
+
+    if (durationsToBeAdjustedVu.size() <= 2) {
+      // Nothing to duplicate if there are 0 or 1 entries.
+      return;
+    }
+
+    switch (behavior) {
+      case Mp4Muxer.LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION:
+        // This is the default MediaMuxer behavior: the last sample duration is a copy of the
+        // previous sample duration.
+        durationsToBeAdjustedVu.set(
+            durationsToBeAdjustedVu.size() - 1,
+            durationsToBeAdjustedVu.get(durationsToBeAdjustedVu.size() - 2));
+        break;
+      case Mp4Muxer.LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME:
+        // Keep the last sample duration as short as possible.
+        checkState(Iterables.getLast(durationsToBeAdjustedVu) == 0L);
+        break;
+      default:
+        throw new IllegalArgumentException(
+            "Unexpected value for the last frame duration behavior " + behavior);
+    }
+  }
+
+  /** Returns the avcC box as per ISO/IEC 14496-15: 5.3.3.1.2. */
+  private static ByteBuffer avcCBox(Format format) {
+    checkArgument(
+        format.initializationData.size() >= 2, "csd-0 and/or csd-1 not found in the format.");
+
+    ByteBuffer csd0 = ByteBuffer.wrap(format.initializationData.get(0));
+    ByteBuffer csd1 = ByteBuffer.wrap(format.initializationData.get(1));
+
+    ByteBuffer contents =
+        ByteBuffer.allocate(csd0.limit() + csd1.limit() + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    contents.put((byte) 0x01); // configurationVersion
+
+    ImmutableList<ByteBuffer> csd0NalUnits = AnnexBUtils.findNalUnits(csd0);
+    checkArgument(csd0NalUnits.size() == 1, "SPS data not found in csd0.");
+
+    ByteBuffer sps = csd0NalUnits.get(0);
+    byte[] spsData = new byte[sps.remaining()];
+    sps.get(spsData);
+    sps.rewind();
+
+    NalUnitUtil.SpsData h264SpsData =
+        NalUnitUtil.parseSpsNalUnit(spsData, /* nalOffset= */ 0, spsData.length);
+    contents.put((byte) h264SpsData.profileIdc); // AVCProfileIndication
+    contents.put((byte) h264SpsData.constraintsFlagsAndReservedZero2Bits); // profile_compatibility
+    contents.put((byte) h264SpsData.levelIdc); // AVCLevelIndication
+
+    contents.put((byte) 0xFF); // 6 bits reserved ('0b111111') + 2 bits lengthSizeMinusOne (3)
+    contents.put((byte) 0xE1); // 3 bits reserved ('0b111') + 5 bits numOfSequenceParameterSets (1)
+    contents.putShort((short) sps.remaining()); // sequenceParameterSetLength
+    contents.put(sps); // sequenceParameterSetNALUnit
+    sps.rewind();
+
+    ImmutableList<ByteBuffer> csd1NalUnits = AnnexBUtils.findNalUnits(csd1);
+    checkState(csd1NalUnits.size() == 1, "PPS data not found in csd1.");
+
+    contents.put((byte) 0x01); // numOfPictureParameterSets
+
+    ByteBuffer pps = csd1NalUnits.get(0);
+    contents.putShort((short) pps.remaining()); // pictureParameterSetLength
+    contents.put(pps); // pictureParameterSetNALUnit
+    pps.rewind();
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("avcC", contents);
+  }
+
+  /** Returns the hvcC box as per ISO/IEC 14496-15: 8.3.3.1.2. */
+  private static ByteBuffer hvcCBox(Format format) {
+    // For H.265, all three codec-specific NALUs (VPS, SPS, PPS) are packed into csd-0.
+    checkArgument(!format.initializationData.isEmpty(), "csd-0 not found in the format.");
+    ByteBuffer csd0 = ByteBuffer.wrap(format.initializationData.get(0));
+
+    ByteBuffer contents = ByteBuffer.allocate(csd0.limit() + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+
+    ImmutableList<ByteBuffer> nalusWithEmulationPrevention = AnnexBUtils.findNalUnits(csd0);
+
+    // Remove emulation prevention bytes to parse the actual csd-0 data.
+    // For storing the csd-0 data into MP4 file, use original NALUs with emulation prevention bytes.
+    List<ByteBuffer> nalusWithoutEmulationPrevention = new ArrayList<>();
+    for (int i = 0; i < nalusWithEmulationPrevention.size(); i++) {
+      nalusWithoutEmulationPrevention.add(
+          AnnexBUtils.stripEmulationPrevention(nalusWithEmulationPrevention.get(i)));
+    }
+
+    contents.put((byte) 0x01); // configurationVersion
+
+    // Assuming that VPS, SPS and PPS are in this order in csd-0.
+    ByteBuffer vps = nalusWithoutEmulationPrevention.get(0);
+
+    if (vps.get(vps.position()) != 0x40) {
+      throw new IllegalArgumentException("First NALU in csd-0 is not the VPS.");
+    }
+
+    // general_profile_space (2 bits) + general_tier_flag (1 bit) + general_profile_idc (5 bits)
+    contents.put(vps.get(6));
+
+    contents.putInt(vps.getInt(7)); // general_profile_compatibility_flags
+
+    // general_constraint_indicator_flags (6 bytes)
+    contents.putInt(vps.getInt(11));
+    contents.putShort(vps.getShort(15));
+
+    contents.put(vps.get(17)); // general_level_idc
+
+    // First 4 bits reserved + min_spatial_segmentation_idc (12 bits)
+    contents.putShort((short) 0xF000);
+
+    // First 6 bits reserved + parallelismType (2 bits)
+    contents.put((byte) 0xFC);
+
+    ByteBuffer sps = nalusWithEmulationPrevention.get(1);
+    byte[] spsArray = new byte[sps.remaining()];
+    sps.get(spsArray);
+    sps.rewind();
+
+    NalUnitUtil.H265SpsData h265SpsData =
+        NalUnitUtil.parseH265SpsNalUnit(
+            spsArray, /* nalOffset= */ 0, /* nalLimit= */ spsArray.length);
+
+    byte chromaFormat = (byte) (0xFC | h265SpsData.chromaFormatIdc); // First 6 bits reserved
+    byte bitDepthLumaMinus8 =
+        (byte) (0xF8 | h265SpsData.bitDepthLumaMinus8); // First 5 bits reserved
+    byte bitDepthChromaMinus8 =
+        (byte) (0xF8 | h265SpsData.bitDepthChromaMinus8); // First 5 bits reserved
+    contents.put(chromaFormat);
+    contents.put(bitDepthLumaMinus8);
+    contents.put(bitDepthChromaMinus8);
+
+    // avgFrameRate; value 0 indicates an unspecified average frame rate.
+    contents.putShort((short) 0);
+
+    // constantFrameRate (2 bits) + numTemporalLayers (3 bits) + temporalIdNested (1 bit) +
+    // lengthSizeMinusOne (2 bits)
+    contents.put((byte) 0x0F);
+
+    // Put all NALUs.
+    contents.put((byte) nalusWithEmulationPrevention.size()); // numOfArrays
+
+    for (int i = 0; i < nalusWithEmulationPrevention.size(); i++) {
+      ByteBuffer nalu = nalusWithEmulationPrevention.get(i);
+
+      // array_completeness (1 bit) + reserved (1 bit) + NAL_unit_type (6 bits)
+      byte naluType = (byte) ((nalu.get(0) >> 1) & 0x3F);
+      contents.put(naluType);
+
+      contents.putShort((short) 1); // numNalus; number of NALUs in array
+      contents.putShort((short) nalu.limit()); // nalUnitLength
+      contents.put(nalu);
+    }
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("hvcC", contents);
+  }
+
+  /** Returns the av1C box. */
+  private static ByteBuffer av1CBox(Format format) {
+    // For AV1, the entire codec-specific box is packed into csd-0.
+    checkArgument(!format.initializationData.isEmpty(), "csd-0 is not found in the format");
+    ByteBuffer csd0 = ByteBuffer.wrap(format.initializationData.get(0));
+    return BoxUtils.wrapIntoBox("av1C", csd0.duplicate());
+  }
+
+  /** Returns the pasp box. */
+  private static ByteBuffer paspBox() {
+    ByteBuffer contents = ByteBuffer.allocate(8);
+
+    contents.putInt(1 << 16); // hspacing
+    contents.putInt(1 << 16); // vspacing
+
+    contents.rewind();
+    return BoxUtils.wrapIntoBox("pasp", contents);
+  }
+
+  /** Returns the colr box. */
+  @SuppressWarnings("InlinedApi")
+  private static ByteBuffer colrBox(ColorInfo colorInfo) {
+    ByteBuffer contents = ByteBuffer.allocate(20);
+    contents.put((byte) 'n');
+    contents.put((byte) 'c');
+    contents.put((byte) 'l');
+    contents.put((byte) 'x');
+
+    // Parameters going into the file.
+    short primaries = 0;
+    short transfer = 0;
+    short matrix = 0;
+    byte range = 0;
+
+    if (colorInfo.colorSpace != Format.NO_VALUE) {
+      int standard = colorInfo.colorSpace;
+      if (standard < 0 || standard >= MEDIAFORMAT_STANDARD_TO_PRIMARIES_AND_MATRIX.size()) {
+        throw new IllegalArgumentException("Color standard not implemented: " + standard);
+      }
+
+      primaries = MEDIAFORMAT_STANDARD_TO_PRIMARIES_AND_MATRIX.get(standard).get(0);
+      matrix = MEDIAFORMAT_STANDARD_TO_PRIMARIES_AND_MATRIX.get(standard).get(1);
+    }
+
+    if (colorInfo.colorTransfer != Format.NO_VALUE) {
+      int transferInFormat = colorInfo.colorTransfer;
+      if (transferInFormat < 0 || transferInFormat >= MEDIAFORMAT_TRANSFER_TO_MP4_TRANSFER.size()) {
+        throw new IllegalArgumentException("Color transfer not implemented: " + transferInFormat);
+      }
+
+      transfer = MEDIAFORMAT_TRANSFER_TO_MP4_TRANSFER.get(transferInFormat);
+    }
+
+    if (colorInfo.colorRange != Format.NO_VALUE) {
+      int rangeInFormat = colorInfo.colorRange;
+      // Handled values are 0 (unknown), 1 (full) and 2 (limited).
+      if (rangeInFormat < 0 || rangeInFormat > 2) {
+        throw new IllegalArgumentException("Color range not implemented: " + rangeInFormat);
+      }
+
+      // Set this to 0x80 only for full range, 0 otherwise.
+      range = rangeInFormat == C.COLOR_RANGE_FULL ? (byte) 0x80 : 0;
+    }
+
+    contents.putShort(primaries);
+    contents.putShort(transfer);
+    contents.putShort(matrix);
+    contents.put(range);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("colr", contents);
+  }
+
+  /** Returns video codec specific fourcc. */
+  private static String codecSpecificFourcc(Format format) {
+    String mimeType = checkNotNull(format.sampleMimeType);
+    switch (mimeType) {
+      case "video/avc":
+        return "avc1";
+      case "video/hevc":
+        return "hvc1";
+      case "video/av01":
+        return "av01";
+      default:
+        throw new IllegalArgumentException("Unsupported video format: " + mimeType);
+    }
+  }
+
+  /** Returns the esds box. */
+  private static ByteBuffer audioEsdsBox(Format format) {
+    checkArgument(!format.initializationData.isEmpty(), "csd-0 is not found in the format.");
+    ByteBuffer csd0 = ByteBuffer.wrap(format.initializationData.get(0));
+    int csd0Size = csd0.limit();
+
+    ByteBuffer contents = ByteBuffer.allocate(csd0Size + Mp4Utils.MAX_FIXED_LEAF_BOX_SIZE);
+    contents.putInt(0x0); // version and flags.
+    contents.put((byte) 0x03); // ES_DescrTag
+
+    // We're normally using a variable-length encoding for the length of various sub-packages (esds
+    // etc.), in a nested way, so outer lengths need to account for variable-length inner lengths
+    // too (to save ~10 bytes per video file). Meanwhile, AAC codec-specific
+    // data is typically just 2 bytes, so every length actually fits into a byte. Here, we're just
+    // skipping the entire complex story by asserting that we won't ever need variable-length sizes.
+    checkArgument(csd0Size + 21 < 127, "CSD too long; we might need variable-length encoding?");
+
+    contents.put((byte) (23 + csd0Size));
+
+    contents.putShort((short) 0x0000); // ES_ID
+    contents.put((byte) 0x00);
+
+    contents.put((byte) 0x04); // DecoderConfigDescrTag
+    contents.put((byte) (15 + csd0Size));
+    contents.put((byte) 0x40); // objectTypeIndication
+    contents.put((byte) 0x15); // streamType AudioStream
+
+    contents.putShort((short) 0x03);
+    contents.put((byte) 0x00); // 24-bit buffer size (0x300)
+
+    contents.putInt(format.peakBitrate != Format.NO_VALUE ? format.peakBitrate : 0);
+    contents.putInt(format.averageBitrate != Format.NO_VALUE ? format.bitrate : 0);
+
+    contents.put((byte) 0x05); // DecoderSpecificInfoTag
+    contents.put((byte) csd0Size);
+    contents.put(csd0);
+    csd0.rewind();
+
+    contents.put((byte) 0x06); // SLConfigDescriptorTag
+    contents.put((byte) 0x01);
+    contents.put((byte) 0x02);
+
+    contents.flip();
+    return BoxUtils.wrapIntoBox("esds", contents);
+  }
+
+  /** Convert UNIX timestamps to the format used by MP4 files. */
+  private static int toMp4Time(long unixTimeMs) {
+    // Jan 1, 1904, including leap years.
+    long delta = (66 * 365 + 17) * (24 * 60 * 60);
+    return (int) (unixTimeMs / 1000L + delta);
+  }
+
+  /** Packs a three-letter language code into a short, packing 3x5 bits. */
+  private static short languageCodeFromString(@Nullable String code) {
+    if (code == null) {
+      return 0;
+    }
+
+    byte[] bytes = Util.getUtf8Bytes(code);
+
+    if (bytes.length != 3) {
+      throw new IllegalArgumentException("Non-length-3 language code: " + code);
+    }
+
+    // Use an int so that we don't bump into the issue of Java not having unsigned types. We take
+    // the last 5 bits of each letter to supply 5 bits each of the eventual code.
+
+    int value = (bytes[2] & 0x1F);
+    value += (bytes[1] & 0x1F) << 5;
+    value += (bytes[0] & 0x1F) << 10;
+
+    // This adds up to 15 bits; the 16th one is really supposed to be 0.
+    checkState((value & 0x8000) == 0);
+    return (short) (value & 0xFFFF);
+  }
+
+  /**
+   * Generates an orientation matrix, to be included in the MP4 header.
+   *
+   * <p>The supported values are 0, 90, 180 and 270 (degrees).
+   */
+  private static byte[] rotationMatrixFromOrientation(int orientation) {
+    // The transformation matrix is defined as below:
+    // | a b u |
+    // | c d v |
+    // | x y w |
+    // To specify the orientation (u, v, w) are restricted to (0, 0, 0x40000000).
+    // Reference: ISO/IEC 14496-12: 8.2.2.3.
+    int fixedOne = 65536;
+    switch (orientation) {
+      case 0:
+        return Util.toByteArray(fixedOne, 0, 0, 0, fixedOne, 0, 0, 0, 0x40000000);
+      case 90:
+        return Util.toByteArray(0, fixedOne, 0, -fixedOne, 0, 0, 0, 0, 0x40000000);
+      case 180:
+        return Util.toByteArray(-fixedOne, 0, 0, 0, -fixedOne, 0, 0, 0, 0x40000000);
+      case 270:
+        return Util.toByteArray(0, -fixedOne, 0, fixedOne, 0, 0, 0, 0, 0x40000000);
+      default:
+        throw new IllegalArgumentException("invalid orientation " + orientation);
+    }
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/ColorUtils.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import android.media.MediaFormat;
+import com.google.common.collect.ImmutableList;
+
+/** Utilities for color information. */
+/* package */ final class ColorUtils {
+  // The constants are defined as per ISO/IEC 29199-2 (mentioned in MP4 spec ISO/IEC 14496-12:
+  // 8.5.2.3).
+
+  private static final short TRANSFER_SMPTE170_M = 1; // Main; also 6, 14 and 15
+  private static final short TRANSFER_UNSPECIFIED = 2;
+  private static final short TRANSFER_GAMMA22 = 4;
+  private static final short TRANSFER_GAMMA28 = 5;
+  private static final short TRANSFER_SMPTE240_M = 7;
+  private static final short TRANSFER_LINEAR = 8;
+  private static final short TRANSFER_OTHER = 9; // Also 10
+  private static final short TRANSFER_XV_YCC = 11;
+  private static final short TRANSFER_BT1361 = 12;
+  private static final short TRANSFER_SRGB = 13;
+  private static final short TRANSFER_ST2084 = 16;
+  private static final short TRANSFER_ST428 = 17;
+  private static final short TRANSFER_HLG = 18;
+
+  // MediaFormat contains three color-related fields: "standard", "transfer" and "range". The color
+  // standard maps to "primaries" and "matrix" in the "colr" box, while "transfer" and "range" are
+  // mapped to a single value each (although for "transfer", it's still not the same enum values).
+  private static final short PRIMARIES_BT709_5 = 1;
+  private static final short PRIMARIES_UNSPECIFIED = 2;
+  private static final short PRIMARIES_BT601_6_625 = 5;
+  private static final short PRIMARIES_BT601_6_525 = 6; // It's also 7?
+  private static final short PRIMARIES_GENERIC_FILM = 8;
+  private static final short PRIMARIES_BT2020 = 9;
+  private static final short PRIMARIES_BT470_6_M = 4;
+
+  private static final short MATRIX_UNSPECIFIED = 2;
+  private static final short MATRIX_BT709_5 = 1;
+  private static final short MATRIX_BT601_6 = 6;
+  private static final short MATRIX_SMPTE240_M = 7;
+  private static final short MATRIX_BT2020 = 9;
+  private static final short MATRIX_BT2020_CONSTANT = 10;
+  private static final short MATRIX_BT470_6_M = 4;
+
+  /**
+   * Map from {@link MediaFormat} standards to MP4 primaries and matrix indices.
+   *
+   * <p>The i-th element corresponds to a {@link MediaFormat} value of i.
+   */
+  public static final ImmutableList<ImmutableList<Short>>
+      MEDIAFORMAT_STANDARD_TO_PRIMARIES_AND_MATRIX =
+          ImmutableList.of(
+              ImmutableList.of(PRIMARIES_UNSPECIFIED, MATRIX_UNSPECIFIED), // Unspecified
+              ImmutableList.of(PRIMARIES_BT709_5, MATRIX_BT709_5), // BT709
+              ImmutableList.of(PRIMARIES_BT601_6_625, MATRIX_BT601_6), // BT601_625
+              ImmutableList.of(PRIMARIES_BT601_6_625, MATRIX_BT709_5), // BT601_625_Unadjusted
+              ImmutableList.of(PRIMARIES_BT601_6_525, MATRIX_BT601_6), // BT601_525
+              ImmutableList.of(PRIMARIES_BT601_6_525, MATRIX_SMPTE240_M), // BT601_525_Unadjusted
+              ImmutableList.of(PRIMARIES_BT2020, MATRIX_BT2020), // BT2020
+              ImmutableList.of(PRIMARIES_BT2020, MATRIX_BT2020_CONSTANT), // BT2020Constant
+              ImmutableList.of(PRIMARIES_BT470_6_M, MATRIX_BT470_6_M), // BT470M
+              ImmutableList.of(PRIMARIES_GENERIC_FILM, MATRIX_BT2020) // Film
+              );
+
+  /**
+   * Map from {@link MediaFormat} standards to MP4 transfer indices.
+   *
+   * <p>The i-th element corresponds to a {@link MediaFormat} value of i.
+   */
+  public static final ImmutableList<Short> MEDIAFORMAT_TRANSFER_TO_MP4_TRANSFER =
+      ImmutableList.of(
+          TRANSFER_UNSPECIFIED, // Unspecified
+          TRANSFER_LINEAR, // Linear
+          TRANSFER_SRGB, // SRGB
+          TRANSFER_SMPTE170_M, // SMPTE_170M
+          TRANSFER_GAMMA22, // Gamma22
+          TRANSFER_GAMMA28, // Gamma28
+          TRANSFER_ST2084, // ST2084
+          TRANSFER_HLG // HLG
+          );
+
+  private ColorUtils() {}
+}

library/muxer/src/main/java/androidx/media3/muxer/MetadataCollector.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.android.exoplayer2.util.Assertions.checkState;
+
+import java.nio.ByteBuffer;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
+
+/** Collects and provides metadata: location, FPS, XMP data, etc. */
+/* package */ final class MetadataCollector {
+  public int orientation;
+  public @MonotonicNonNull Mp4Location location;
+  public Map<String, Object> metadataPairs;
+  public long modificationDateUnixMs;
+  public @MonotonicNonNull ByteBuffer xmpData;
+
+  public MetadataCollector() {
+    orientation = 0;
+    metadataPairs = new LinkedHashMap<>();
+    modificationDateUnixMs = System.currentTimeMillis();
+  }
+
+  public void addXmp(ByteBuffer xmpData) {
+    checkState(this.xmpData == null);
+    this.xmpData = xmpData;
+  }
+
+  public void setOrientation(int orientation) {
+    this.orientation = orientation;
+  }
+
+  public void setLocation(float latitude, float longitude) {
+    location = new Mp4Location(latitude, longitude);
+  }
+
+  public void setCaptureFps(float captureFps) {
+    metadataPairs.put("com.android.capture.fps", captureFps);
+  }
+
+  public void addMetadata(String key, Object value) {
+    metadataPairs.put(key, value);
+  }
+
+  public void setModificationTime(long modificationDateUnixMs) {
+    this.modificationDateUnixMs = modificationDateUnixMs;
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Mp4Location.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+/** Stores location data. */
+/* package */ final class Mp4Location {
+  public final float latitude;
+  public final float longitude;
+
+  public Mp4Location(float latitude, float longitude) {
+    this.latitude = latitude;
+    this.longitude = longitude;
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Mp4MoovStructure.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static androidx.media3.muxer.Mp4Utils.MVHD_TIMEBASE;
+import static java.lang.Math.max;
+
+import android.media.MediaCodec.BufferInfo;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.exoplayer2.util.Util;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import org.checkerframework.checker.nullness.qual.PolyNull;
+
+/** Builds the moov box structure of an MP4 file. */
+/* package */ class Mp4MoovStructure {
+  /** Provides track's metadata like media format, written samples. */
+  public interface TrackMetadataProvider {
+    Format format();
+
+    int sortKey();
+
+    int videoUnitTimebase();
+
+    ImmutableList<BufferInfo> writtenSamples();
+
+    ImmutableList<Long> writtenChunkOffsets();
+
+    ImmutableList<Integer> writtenChunkSampleCounts();
+  }
+
+  private final MetadataCollector metadataCollector;
+  private final @Mp4Muxer.LastFrameDurationBehavior int lastFrameDurationBehavior;
+
+  public Mp4MoovStructure(
+      MetadataCollector metadataCollector,
+      @Mp4Muxer.LastFrameDurationBehavior int lastFrameDurationBehavior) {
+    this.metadataCollector = metadataCollector;
+    this.lastFrameDurationBehavior = lastFrameDurationBehavior;
+  }
+
+  /** Generates a mdat header. */
+  @SuppressWarnings("InlinedApi")
+  public ByteBuffer moovMetadataHeader(
+      List<? extends TrackMetadataProvider> tracks, long minInputPtsUs) {
+    List<ByteBuffer> trakBoxes = new ArrayList<>();
+
+    int nextTrackId = 1;
+    long videoDurationUs = 0L;
+    for (int i = 0; i < tracks.size(); i++) {
+      TrackMetadataProvider track = tracks.get(i);
+      if (!track.writtenSamples().isEmpty()) {
+        Format format = track.format();
+        String languageCode = bcp47LanguageTagToIso3(format.language);
+
+        boolean isVideo = MimeTypes.isVideo(format.sampleMimeType);
+        boolean isAudio = MimeTypes.isAudio(format.sampleMimeType);
+
+        // Generate the sample durations to calculate the total duration for tkhd box.
+        List<Long> sampleDurationsVu =
+            Boxes.durationsVuForStts(
+                track.writtenSamples(),
+                minInputPtsUs,
+                track.videoUnitTimebase(),
+                lastFrameDurationBehavior);
+
+        long trackDurationInTrackUnitsVu = 0;
+        for (int j = 0; j < sampleDurationsVu.size(); j++) {
+          trackDurationInTrackUnitsVu += sampleDurationsVu.get(j);
+        }
+
+        long trackDurationUs =
+            Mp4Utils.usFromVu(trackDurationInTrackUnitsVu, track.videoUnitTimebase());
+
+        String handlerType = isVideo ? "vide" : (isAudio ? "soun" : "meta");
+        String handlerName = isVideo ? "VideoHandle" : (isAudio ? "SoundHandle" : "MetaHandle");
+
+        ByteBuffer stsd =
+            Boxes.stsd(
+                isVideo
+                    ? Boxes.videoSampleEntry(format)
+                    : (isAudio
+                        ? Boxes.audioSampleEntry(format)
+                        : Boxes.metadataSampleEntry(format)));
+        ByteBuffer stts = Boxes.stts(sampleDurationsVu);
+        ByteBuffer stsz = Boxes.stsz(track.writtenSamples());
+        ByteBuffer stsc = Boxes.stsc(track.writtenChunkSampleCounts());
+        ByteBuffer co64 = Boxes.co64(track.writtenChunkOffsets());
+
+        // The below statement is also a description of how a mdat box looks like, with all the
+        // inner boxes and what they actually store. Although they're technically instance methods,
+        // everything that is written to a box is visible in the argument list.
+        ByteBuffer trakBox =
+            Boxes.trak(
+                Boxes.tkhd(
+                    nextTrackId,
+                    // Using the time base of the entire file, not that of the track; otherwise,
+                    // Quicktime will stretch the audio accordingly, see b/158120042.
+                    (int) Mp4Utils.vuFromUs(trackDurationUs, MVHD_TIMEBASE),
+                    metadataCollector.modificationDateUnixMs,
+                    metadataCollector.orientation,
+                    format),
+                Boxes.mdia(
+                    Boxes.mdhd(
+                        trackDurationInTrackUnitsVu,
+                        track.videoUnitTimebase(),
+                        metadataCollector.modificationDateUnixMs,
+                        languageCode),
+                    Boxes.hdlr(handlerType, handlerName),
+                    Boxes.minf(
+                        isVideo ? Boxes.vmhd() : (isAudio ? Boxes.smhd() : Boxes.nmhd()),
+                        Boxes.dinf(Boxes.dref(Boxes.localUrl())),
+                        isVideo
+                            ? Boxes.stbl(
+                                stsd, stts, stsz, stsc, co64, Boxes.stss(track.writtenSamples()))
+                            : Boxes.stbl(stsd, stts, stsz, stsc, co64))));
+
+        trakBoxes.add(trakBox);
+        videoDurationUs = max(videoDurationUs, trackDurationUs);
+        nextTrackId++;
+      }
+    }
+
+    ByteBuffer mvhdBox =
+        Boxes.mvhd(nextTrackId, metadataCollector.modificationDateUnixMs, videoDurationUs);
+    ByteBuffer udtaBox = Boxes.udta(metadataCollector.location);
+    ByteBuffer metaBox =
+        metadataCollector.metadataPairs.isEmpty()
+            ? ByteBuffer.allocate(0)
+            : Boxes.meta(
+                Boxes.hdlr(/* handlerType= */ "mdta", /* handlerName= */ ""),
+                Boxes.keys(Lists.newArrayList(metadataCollector.metadataPairs.keySet())),
+                Boxes.ilst(Lists.newArrayList(metadataCollector.metadataPairs.values())));
+
+    ByteBuffer moovBox;
+    moovBox =
+        Boxes.moov(mvhdBox, udtaBox, metaBox, trakBoxes, /* mvexBox= */ ByteBuffer.allocate(0));
+
+    // Also add XMP if needed
+    if (metadataCollector.xmpData != null) {
+      return BoxUtils.concatenateBuffers(
+          moovBox, Boxes.uuid(Boxes.XMP_UUID, metadataCollector.xmpData.duplicate()));
+    } else {
+      // No need for another copy if there is no XMP to be appended.
+      return moovBox;
+    }
+  }
+
+  /** Returns an ISO 639-2/T (ISO3) language code for the IETF BCP 47 language tag. */
+  private static @PolyNull String bcp47LanguageTagToIso3(@PolyNull String languageTag) {
+    if (languageTag == null) {
+      return null;
+    }
+
+    Locale locale =
+        Util.SDK_INT >= 21 ? Locale.forLanguageTag(languageTag) : new Locale(languageTag);
+
+    return locale.getISO3Language().isEmpty() ? languageTag : locale.getISO3Language();
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Mp4Muxer.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.android.exoplayer2.util.Assertions.checkNotNull;
+import static java.lang.annotation.ElementType.TYPE_USE;
+
+import android.media.MediaCodec.BufferInfo;
+import androidx.annotation.FloatRange;
+import androidx.annotation.IntDef;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.Format;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.nio.ByteBuffer;
+
+/**
+ * A muxer for creating an MP4 container file.
+ *
+ * <p>The muxer supports writing H264, H265 and AV1 video, AAC audio and metadata.
+ *
+ * <p>All the operations are performed on the caller thread.
+ *
+ * <p>To create an MP4 container file, the caller must:
+ *
+ * <ul>
+ *   <li>Add tracks using {@link #addTrack(int, Format)} which will return a {@link TrackToken}.
+ *   <li>Use the associated {@link TrackToken} when {@linkplain #writeSampleData(TrackToken,
+ *       ByteBuffer, BufferInfo) writing samples} for that track.
+ *   <li>{@link #close} the muxer when all data has been written.
+ * </ul>
+ *
+ * <p>Some key points:
+ *
+ * <ul>
+ *   <li>Tracks can be added at any point, even after writing some samples to other tracks.
+ *   <li>The caller is responsible for ensuring that samples of different track types are well
+ *       interleaved by calling {@link #writeSampleData(TrackToken, ByteBuffer, BufferInfo)} in an
+ *       order that interleaves samples from different tracks.
+ *   <li>When writing a file, if an error occurs and the muxer is not closed, then the output MP4
+ *       file may still have some partial data.
+ * </ul>
+ */
+public final class Mp4Muxer {
+  /** A token representing an added track. */
+  public interface TrackToken {}
+
+  /** Behavior for the last sample duration. */
+  @Documented
+  @Retention(RetentionPolicy.SOURCE)
+  @Target(TYPE_USE)
+  @IntDef({
+    LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION,
+    LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME
+  })
+  public @interface LastFrameDurationBehavior {}
+  /** Insert a zero-length last sample. */
+  public static final int LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME = 0;
+  /**
+   * Use the difference between the last timestamp and the one before that as the duration of the
+   * last sample.
+   */
+  public static final int LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION = 1;
+
+  /** A builder for {@link Mp4Muxer} instances. */
+  public static final class Builder {
+    private final FileOutputStream fileOutputStream;
+    private @LastFrameDurationBehavior int lastFrameDurationBehavior;
+    @Nullable private AnnexBToAvccConverter annexBToAvccConverter;
+
+    /**
+     * Creates a {@link Builder} instance with default values.
+     *
+     * @param fileOutputStream The {@link FileOutputStream} to write the media data to.
+     */
+    public Builder(FileOutputStream fileOutputStream) {
+      this.fileOutputStream = checkNotNull(fileOutputStream);
+      lastFrameDurationBehavior = LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME;
+    }
+
+    /**
+     * Sets the {@link LastFrameDurationBehavior} for the video track.
+     *
+     * <p>The default value is {@link #LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME}.
+     */
+    @CanIgnoreReturnValue
+    public Mp4Muxer.Builder setLastFrameDurationBehavior(
+        @LastFrameDurationBehavior int lastFrameDurationBehavior) {
+      this.lastFrameDurationBehavior = lastFrameDurationBehavior;
+      return this;
+    }
+
+    /**
+     * Sets the {@link AnnexBToAvccConverter} to be used by the muxer to convert H.264 and H.265 NAL
+     * units from the Annex-B format (using start codes to delineate NAL units) to the AVCC format
+     * (which uses length prefixes).
+     *
+     * <p>The default value is {@link AnnexBToAvccConverter#DEFAULT}.
+     */
+    @CanIgnoreReturnValue
+    public Mp4Muxer.Builder setAnnexBToAvccConverter(AnnexBToAvccConverter annexBToAvccConverter) {
+      this.annexBToAvccConverter = annexBToAvccConverter;
+      return this;
+    }
+
+    /** Builds an {@link Mp4Muxer} instance. */
+    public Mp4Muxer build() {
+      MetadataCollector metadataCollector = new MetadataCollector();
+      Mp4MoovStructure moovStructure =
+          new Mp4MoovStructure(metadataCollector, lastFrameDurationBehavior);
+      Mp4Writer mp4Writer =
+          new Mp4Writer(
+              fileOutputStream,
+              moovStructure,
+              annexBToAvccConverter == null
+                  ? AnnexBToAvccConverter.DEFAULT
+                  : annexBToAvccConverter);
+
+      return new Mp4Muxer(mp4Writer, metadataCollector);
+    }
+  }
+
+  private final Mp4Writer mp4Writer;
+  private final MetadataCollector metadataCollector;
+
+  private Mp4Muxer(Mp4Writer mp4Writer, MetadataCollector metadataCollector) {
+    this.mp4Writer = mp4Writer;
+    this.metadataCollector = metadataCollector;
+  }
+
+  /**
+   * Sets the orientation hint for the video playback.
+   *
+   * @param orientation The orientation, in degrees.
+   */
+  public void setOrientation(int orientation) {
+    metadataCollector.setOrientation(orientation);
+  }
+
+  /**
+   * Sets the location.
+   *
+   * @param latitude The latitude, in degrees. Its value must be in the range [-90, 90].
+   * @param longitude The longitude, in degrees. Its value must be in the range [-180, 180].
+   */
+  public void setLocation(
+      @FloatRange(from = -90.0, to = 90.0) float latitude,
+      @FloatRange(from = -180.0, to = 180.0) float longitude) {
+    metadataCollector.setLocation(latitude, longitude);
+  }
+
+  /**
+   * Sets the capture frame rate.
+   *
+   * @param captureFps The frame rate.
+   */
+  public void setCaptureFps(float captureFps) {
+    metadataCollector.setCaptureFps(captureFps);
+  }
+
+  /**
+   * Sets the file modification time.
+   *
+   * @param modificationDateUnixMs The modification time, in milliseconds since epoch.
+   */
+  public void setModificationTime(long modificationDateUnixMs) {
+    metadataCollector.setModificationTime(modificationDateUnixMs);
+  }
+
+  /**
+   * Adds custom metadata.
+   *
+   * @param key The metadata key in {@link String} format.
+   * @param value The metadata value in {@link String} or {@link Float} format.
+   */
+  public void addMetadata(String key, Object value) {
+    metadataCollector.addMetadata(key, value);
+  }
+
+  /**
+   * Adds xmp data.
+   *
+   * @param xmp The xmp {@link ByteBuffer}.
+   */
+  public void addXmp(ByteBuffer xmp) {
+    metadataCollector.addXmp(xmp);
+  }
+
+  /**
+   * Adds a track of the given media format.
+   *
+   * <p>Tracks can be added at any point before the muxer is closed, even after writing samples to
+   * other tracks.
+   *
+   * <p>The final order of tracks is determined by the provided sort key. Tracks with a lower sort
+   * key will always have a lower track id than tracks with a higher sort key. Ordering between
+   * tracks with the same sort key is not specified.
+   *
+   * @param sortKey The key used for sorting the track list.
+   * @param format The {@link Format} for the track.
+   * @return A unique {@link TrackToken}. It should be used in {@link #writeSampleData}.
+   */
+  public TrackToken addTrack(int sortKey, Format format) {
+    return mp4Writer.addTrack(sortKey, format);
+  }
+
+  /**
+   * Writes encoded sample data.
+   *
+   * @param trackToken The {@link TrackToken} for which this sample is being written.
+   * @param byteBuffer The encoded sample.
+   * @param bufferInfo The {@link BufferInfo} related to this sample.
+   * @throws IOException If there is any error while writing data to the disk.
+   */
+  public void writeSampleData(TrackToken trackToken, ByteBuffer byteBuffer, BufferInfo bufferInfo)
+      throws IOException {
+    mp4Writer.writeSampleData(trackToken, byteBuffer, bufferInfo);
+  }
+
+  /** Closes the MP4 file. */
+  public void close() throws IOException {
+    mp4Writer.close();
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Mp4Utils.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+/** Utilities for MP4 files. */
+/* package */ final class Mp4Utils {
+  /**
+   * The maximum length of boxes which have fixed sizes.
+   *
+   * <p>Technically, we'd know how long they actually are; this upper bound is much simpler to
+   * produce though and we'll throw if we overflow anyway.
+   */
+  public static final int MAX_FIXED_LEAF_BOX_SIZE = 200;
+
+  /**
+   * The per-video timebase, used for durations in MVHD and TKHD even if the per-track timebase is
+   * different (e.g. typically the sample rate for audio).
+   */
+  public static final long MVHD_TIMEBASE = 10_000L;
+
+  private Mp4Utils() {}
+
+  /** Converts microseconds to video units, using the provided timebase. */
+  public static long vuFromUs(long timestampUs, long videoUnitTimebase) {
+    return timestampUs * videoUnitTimebase / 1_000_000L; // (division for us to s conversion)
+  }
+
+  /** Converts video units to microseconds, using the provided timebase. */
+  public static long usFromVu(long timestampVu, long videoUnitTimebase) {
+    return timestampVu * 1_000_000L / videoUnitTimebase;
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/Mp4Writer.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.android.exoplayer2.util.Assertions.checkNotNull;
+import static com.google.android.exoplayer2.util.Assertions.checkState;
+import static java.lang.Math.max;
+
+import android.media.MediaCodec;
+import android.media.MediaCodec.BufferInfo;
+import android.util.Pair;
+import androidx.media3.muxer.Mp4Muxer.TrackToken;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.exoplayer2.util.Util;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Range;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** Writes MP4 data to the disk. */
+/* package */ final class Mp4Writer {
+  private static final long INTERLEAVE_DURATION_US = 1_000_000L;
+
+  private final AtomicBoolean hasWrittenSamples;
+  private final Mp4MoovStructure moovGenerator;
+  private final List<Track> tracks;
+  private final AnnexBToAvccConverter annexBToAvccConverter;
+  private final FileOutputStream outputStream;
+  private final FileChannel output;
+  private long mdatStart;
+  private long mdatEnd;
+  private long mdatDataEnd; // Always <= mdatEnd
+
+  // Typically written from the end of the mdat box to the end of the file.
+  private Range<Long> lastMoovWritten;
+
+  /**
+   * Creates an instance.
+   *
+   * @param outputStream The {@link FileOutputStream} to write the data to.
+   * @param moovGenerator An {@link Mp4MoovStructure} instance to generate the moov box.
+   * @param annexBToAvccConverter The {@link AnnexBToAvccConverter} to be used to convert H.264 and
+   *     H.265 NAL units from the Annex-B format (using start codes to delineate NAL units) to the
+   *     AVCC format (which uses length prefixes).
+   */
+  public Mp4Writer(
+      FileOutputStream outputStream,
+      Mp4MoovStructure moovGenerator,
+      AnnexBToAvccConverter annexBToAvccConverter) {
+    this.moovGenerator = moovGenerator;
+    this.outputStream = outputStream;
+    this.output = outputStream.getChannel();
+    this.annexBToAvccConverter = annexBToAvccConverter;
+    hasWrittenSamples = new AtomicBoolean(false);
+    tracks = new ArrayList<>();
+    lastMoovWritten = Range.closed(0L, 0L);
+  }
+
+  public TrackToken addTrack(int sortKey, Format format) {
+    Track track = new Track(format, sortKey);
+    tracks.add(track);
+    Collections.sort(tracks, (a, b) -> Integer.compare(a.sortKey, b.sortKey));
+    return track;
+  }
+
+  public void writeSampleData(TrackToken token, ByteBuffer byteBuf, BufferInfo bufferInfo)
+      throws IOException {
+    checkState(token instanceof Track);
+    ((Track) token).writeSampleData(byteBuf, bufferInfo);
+  }
+
+  public void close() throws IOException {
+    try {
+      for (int i = 0; i < tracks.size(); i++) {
+        flushPending(tracks.get(i));
+      }
+
+      // Leave the file empty if no samples are written.
+      if (hasWrittenSamples.get()) {
+        writeMoovAndTrim();
+      }
+    } finally {
+      output.close();
+      outputStream.close();
+    }
+  }
+
+  private void writeHeader() throws IOException {
+    output.position(0L);
+    output.write(Boxes.ftyp());
+
+    // Start with an empty mdat box.
+    mdatStart = output.position();
+
+    ByteBuffer header = ByteBuffer.allocate(4 + 4 + 8);
+    header.putInt(1); // 4 bytes, indicating a 64-bit length field
+    header.put(Util.getUtf8Bytes("mdat")); // 4 bytes
+    header.putLong(16); // 8 bytes (the actual length)
+    header.flip();
+    output.write(header);
+
+    // The box includes only its type and length.
+    mdatDataEnd = mdatStart + 16;
+    mdatEnd = mdatDataEnd;
+  }
+
+  private ByteBuffer assembleCurrentMoovData() {
+    long minInputPtsUs = Long.MAX_VALUE;
+
+    // Recalculate the min timestamp every time, in case some new samples have smaller timestamps.
+    for (int i = 0; i < tracks.size(); i++) {
+      Track track = tracks.get(i);
+      if (!track.writtenSamples.isEmpty()) {
+        minInputPtsUs = Math.min(track.writtenSamples.get(0).presentationTimeUs, minInputPtsUs);
+      }
+    }
+
+    ByteBuffer moovHeader;
+    if (minInputPtsUs != Long.MAX_VALUE) {
+      moovHeader = moovGenerator.moovMetadataHeader(tracks, minInputPtsUs);
+    } else {
+      // Skip moov box, if there are no samples.
+      moovHeader = ByteBuffer.allocate(0);
+    }
+
+    return moovHeader;
+  }
+
+  /**
+   * Replaces old moov box with the new one.
+   *
+   * <p>It doesn't really replace the existing moov box, rather it adds a new moov box at the end of
+   * the file. Even if this operation fails, the output MP4 file still has a valid moov box.
+   *
+   * <p>After this operation, the mdat box might have some extra space containing garbage value of
+   * the old moov box. This extra space gets trimmed before closing the file (in {@link
+   * #writeMoovAndTrim()}).
+   *
+   * @param newMoovBoxPosition The new position for the moov box.
+   * @param newMoovBoxData The new moov box data.
+   * @throws IOException If there is any error while writing data to the disk.
+   */
+  private void safelyReplaceMoov(long newMoovBoxPosition, ByteBuffer newMoovBoxData)
+      throws IOException {
+    checkState(newMoovBoxPosition >= lastMoovWritten.upperEndpoint());
+    checkState(newMoovBoxPosition >= mdatEnd);
+
+    // Write a free box to the end of the file, with the new moov box wrapped into it.
+    output.position(newMoovBoxPosition);
+    output.write(BoxUtils.wrapIntoBox("free", newMoovBoxData.duplicate()));
+
+    // The current state is:
+    // | ftyp | mdat .. .. .. | previous moov | free (new moov)|
+
+    // Increase the length of the mdat box so that it now extends to
+    // the previous moov box and the header of the free box.
+    mdatEnd = newMoovBoxPosition + 8;
+    updateMdatSize();
+
+    lastMoovWritten =
+        Range.closed(newMoovBoxPosition, newMoovBoxPosition + newMoovBoxData.remaining());
+  }
+
+  /**
+   * Writes the final moov box and trims extra space from the mdat box.
+   *
+   * <p>This is done right before closing the file.
+   *
+   * @throws IOException If there is any error while writing data to the disk.
+   */
+  private void writeMoovAndTrim() throws IOException {
+    // The current state is:
+    // | ftyp | mdat .. .. .. (00 00 00) | moov |
+
+    // To keep the trimming safe, first write the final moov box into the gap at the end of the mdat
+    // box, and only then trim the extra space.
+    ByteBuffer currentMoovData = assembleCurrentMoovData();
+
+    int moovBytesNeeded = currentMoovData.remaining();
+
+    // Write a temporary free box wrapping the new moov box.
+    int moovAndFreeBytesNeeded = moovBytesNeeded + 8;
+
+    if (mdatEnd - mdatDataEnd < moovAndFreeBytesNeeded) {
+      // If the gap is not big enough for the moov box, then extend the mdat box once again. This
+      // involves writing moov box farther away one more time.
+      safelyReplaceMoov(lastMoovWritten.upperEndpoint() + moovAndFreeBytesNeeded, currentMoovData);
+      checkState(mdatEnd - mdatDataEnd >= moovAndFreeBytesNeeded);
+    }
+
+    // Write out the new moov box into the gap.
+    long newMoovLocation = mdatDataEnd;
+    output.position(mdatDataEnd);
+    output.write(currentMoovData);
+
+    // Add a free box to account for the actual remaining length of the file.
+    long remainingLength = lastMoovWritten.upperEndpoint() - (newMoovLocation + moovBytesNeeded);
+
+    // Moov boxes shouldn't be too long; they can fit into a free box with a 32-bit length field.
+    checkState(remainingLength < Integer.MAX_VALUE);
+
+    ByteBuffer freeHeader = ByteBuffer.allocate(4 + 4);
+    freeHeader.putInt((int) remainingLength);
+    freeHeader.put((byte) 'f');
+    freeHeader.put((byte) 'r');
+    freeHeader.put((byte) 'e');
+    freeHeader.put((byte) 'e');
+    freeHeader.flip();
+    output.write(freeHeader);
+
+    // The moov box is actually written inside mdat box so the current state is:
+    // | ftyp | mdat .. .. .. (new moov) (free header ) (00 00 00) | old moov |
+
+    // Now change this to:
+    // | ftyp | mdat .. .. .. | new moov | free (00 00 00) (old moov) |
+    mdatEnd = newMoovLocation;
+    updateMdatSize();
+    lastMoovWritten = Range.closed(newMoovLocation, newMoovLocation + currentMoovData.limit());
+
+    // Remove the free box.
+    output.truncate(newMoovLocation + moovBytesNeeded);
+  }
+
+  /**
+   * Rewrites the moov box after accommodating extra bytes needed for the mdat box.
+   *
+   * @param bytesNeeded The extra bytes needed for the mdat box.
+   * @throws IOException If there is any error while writing data to the disk.
+   */
+  private void rewriteMoovWithMdatEmptySpace(long bytesNeeded) throws IOException {
+    long newMoovStart = Math.max(mdatEnd + bytesNeeded, lastMoovWritten.upperEndpoint());
+
+    ByteBuffer currentMoovData = assembleCurrentMoovData();
+
+    safelyReplaceMoov(newMoovStart, currentMoovData);
+  }
+
+  /** Writes out any pending samples to the file. */
+  private void flushPending(Track track) throws IOException {
+    if (track.pendingSamples.isEmpty()) {
+      return;
+    }
+
+    if (!hasWrittenSamples.getAndSet(true)) {
+      writeHeader();
+    }
+
+    // Calculate the additional space required.
+    long bytesNeededInMdat = 0L;
+    for (Pair<BufferInfo, ByteBuffer> sample : track.pendingSamples) {
+      bytesNeededInMdat += sample.second.limit();
+    }
+
+    // Drop all zero-length samples.
+    checkState(bytesNeededInMdat > 0);
+
+    // If the required number of bytes doesn't fit in the gap between the actual data and the moov
+    // box, extend the file and write out the moov box to the end again.
+    if (mdatDataEnd + bytesNeededInMdat >= mdatEnd) {
+      // Reserve some extra space than required, so that mdat box extension is less frequent.
+      rewriteMoovWithMdatEmptySpace(
+          /* bytesNeeded= */ getMdatExtensionAmount(mdatDataEnd) + bytesNeededInMdat);
+    }
+
+    track.writtenChunkOffsets.add(mdatDataEnd);
+    track.writtenChunkSampleCounts.add(track.pendingSamples.size());
+
+    do {
+      Pair<BufferInfo, ByteBuffer> pendingPacket = track.pendingSamples.removeFirst();
+      BufferInfo info = pendingPacket.first;
+      ByteBuffer buffer = pendingPacket.second;
+
+      track.writtenSamples.add(info);
+
+      // Convert the H.264/H.265 samples from Annex-B format (output by MediaCodec) to
+      // Avcc format (required by MP4 container).
+      if (MimeTypes.isVideo(track.format.sampleMimeType)) {
+        annexBToAvccConverter.process(buffer);
+      }
+
+      buffer.rewind();
+
+      mdatDataEnd += output.write(buffer, mdatDataEnd);
+    } while (!track.pendingSamples.isEmpty());
+
+    checkState(mdatDataEnd <= mdatEnd);
+  }
+
+  private void updateMdatSize() throws IOException {
+    // Assuming that the mdat box has a 64-bit length, skip the box type (4 bytes) and
+    // the 32-bit box length field (4 bytes).
+    output.position(mdatStart + 8);
+
+    ByteBuffer mdatSize = ByteBuffer.allocate(8); // one long
+    mdatSize.putLong(mdatEnd - mdatStart);
+    mdatSize.flip();
+    output.write(mdatSize);
+  }
+
+  private void doInterleave() throws IOException {
+    for (int i = 0; i < tracks.size(); i++) {
+      Track track = tracks.get(i);
+      // TODO(b/270583563): check if we need to consider the global timestamp instead.
+      if (track.pendingSamples.size() > 2) {
+        BufferInfo firstSampleInfo = checkNotNull(track.pendingSamples.peekFirst()).first;
+        BufferInfo lastSampleInfo = checkNotNull(track.pendingSamples.peekLast()).first;
+
+        if (lastSampleInfo.presentationTimeUs - firstSampleInfo.presentationTimeUs
+            > INTERLEAVE_DURATION_US) {
+          flushPending(track);
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns the number of bytes by which to extend the mdat box.
+   *
+   * @param currentFileLength The length of current file in bytes (except moov box).
+   * @return The mdat box extension amount in bytes.
+   */
+  private long getMdatExtensionAmount(long currentFileLength) {
+    long minBytesToExtend = 500_000L;
+    float extensionRatio = 0.2f;
+    return max(minBytesToExtend, (long) (extensionRatio * currentFileLength));
+  }
+
+  private class Track implements TrackToken, Mp4MoovStructure.TrackMetadataProvider {
+    private final Format format;
+    private final int sortKey;
+    private final List<BufferInfo> writtenSamples;
+    private final List<Long> writtenChunkOffsets;
+    private final List<Integer> writtenChunkSampleCounts;
+    private final Deque<Pair<BufferInfo, ByteBuffer>> pendingSamples;
+
+    private boolean hadKeyframe = false;
+
+    private Track(Format format, int sortKey) {
+      this.format = format;
+      this.sortKey = sortKey;
+      writtenSamples = new ArrayList<>();
+      writtenChunkOffsets = new ArrayList<>();
+      writtenChunkSampleCounts = new ArrayList<>();
+      pendingSamples = new ArrayDeque<>();
+    }
+
+    public void writeSampleData(ByteBuffer byteBuf, BufferInfo bufferInfo) throws IOException {
+      if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) > 0) {
+        hadKeyframe = true;
+      }
+
+      if (!hadKeyframe && MimeTypes.isVideo(format.sampleMimeType)) {
+        return;
+      }
+
+      if (bufferInfo.size == 0) {
+        return;
+      }
+
+      pendingSamples.addLast(Pair.create(bufferInfo, byteBuf));
+      doInterleave();
+    }
+
+    @Override
+    public int videoUnitTimebase() {
+      return MimeTypes.isAudio(format.sampleMimeType)
+          ? 48_000 // TODO(b/270583563): Update these with actual values from mediaFormat.
+          : 90_000;
+    }
+
+    @Override
+    public int sortKey() {
+      return sortKey;
+    }
+
+    @Override
+    public ImmutableList<BufferInfo> writtenSamples() {
+      return ImmutableList.copyOf(writtenSamples);
+    }
+
+    @Override
+    public ImmutableList<Long> writtenChunkOffsets() {
+      return ImmutableList.copyOf(writtenChunkOffsets);
+    }
+
+    @Override
+    public ImmutableList<Integer> writtenChunkSampleCounts() {
+      return ImmutableList.copyOf(writtenChunkSampleCounts);
+    }
+
+    @Override
+    public Format format() {
+      return format;
+    }
+  }
+}

library/muxer/src/main/java/androidx/media3/muxer/package-info.java

+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@NonNullApi
+package androidx.media3.muxer;
+
+import com.google.android.exoplayer2.util.NonNullApi;

library/muxer/src/test/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright 2022 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest package="androidx.media3.muxer.test">
+  <uses-sdk/>
+</manifest>

library/muxer/src/test/java/androidx/media3/muxer/AnnexBUtilsTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.android.exoplayer2.util.Util.getBytesFromHexString;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link AnnexBUtils}. */
+@RunWith(AndroidJUnit4.class)
+public class AnnexBUtilsTest {
+  @Test
+  public void findNalUnits_emptyBuffer_returnsEmptyList() {
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString(""));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).isEmpty();
+  }
+
+  @Test
+  public void findNalUnits_noNalUnit_returnsEmptyList() {
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("ABCDEFABC"));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).isEmpty();
+  }
+
+  @Test
+  public void findNalUnits_singleNalUnit_returnsSingleElement() {
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF"));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).hasSize(1);
+    assertThat(components.get(0)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEF")));
+  }
+
+  @Test
+  public void findNalUnits_multipleNalUnits_allReturned() {
+    ByteBuffer buf =
+        ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF00000001DDCC00000001BBAA"));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).hasSize(3);
+    assertThat(components.get(0)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEF")));
+    assertThat(components.get(1)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("DDCC")));
+    assertThat(components.get(2)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("BBAA")));
+  }
+
+  @Test
+  public void findNalUnits_partialStartCodes_ignored() {
+    // The NAL unit has lots of zeros but no start code.
+    ByteBuffer buf =
+        ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF0000AB0000CDEF00000000AB"));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).hasSize(1);
+    assertThat(components.get(0))
+        .isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEF0000AB0000CDEF00000000AB")));
+  }
+
+  @Test
+  public void findNalUnits_startCodeWithManyZeros_stillSplits() {
+    // The NAL unit has a start code that starts with more than 3 zeros (although too many zeros
+    // aren't allowed).
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF000000000001AB"));
+
+    ImmutableList<ByteBuffer> components = AnnexBUtils.findNalUnits(buf);
+
+    assertThat(components).hasSize(2);
+    assertThat(components.get(0)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEF0000")));
+    assertThat(components.get(1)).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("AB")));
+  }
+
+  @Test
+  public void stripEmulationPrevention_noEmulationPreventionBytes_copiesInput() {
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF000000000001AB"));
+
+    ByteBuffer output = AnnexBUtils.stripEmulationPrevention(buf);
+
+    assertThat(output)
+        .isEqualTo(ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF000000000001AB")));
+  }
+
+  @Test
+  public void stripEmulationPrevention_emulationPreventionPresent_bytesStripped() {
+    // The NAL unit has a 00 00 03 * sequence.
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF00000300000001AB"));
+
+    ByteBuffer output = AnnexBUtils.stripEmulationPrevention(buf);
+
+    assertThat(output)
+        .isEqualTo(ByteBuffer.wrap(getBytesFromHexString("00000001ABCDEF000000000001AB")));
+  }
+
+  @Test
+  public void stripEmulationPrevention_03WithoutEnoughZeros_notStripped() {
+    // The NAL unit has a 03 byte around, but not preceded by enough zeros.
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("ABCDEFABCD0003EFABCD03ABCD"));
+
+    ByteBuffer output = AnnexBUtils.stripEmulationPrevention(buf);
+
+    assertThat(output)
+        .isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEFABCD0003EFABCD03ABCD")));
+  }
+
+  @Test
+  public void stripEmulationPrevention_03AtEnd_stripped() {
+    // The NAL unit has a 03 byte at the very end of the input.
+    ByteBuffer buf = ByteBuffer.wrap(getBytesFromHexString("ABCDEF000003"));
+
+    ByteBuffer output = AnnexBUtils.stripEmulationPrevention(buf);
+
+    assertThat(output).isEqualTo(ByteBuffer.wrap(getBytesFromHexString("ABCDEF0000")));
+  }
+}

library/muxer/src/test/java/androidx/media3/muxer/BoxesTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static androidx.media3.muxer.Mp4Muxer.LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION;
+import static androidx.media3.muxer.Mp4Muxer.LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME;
+import static androidx.media3.muxer.MuxerTestUtil.getExpectedDumpFilePath;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import android.content.Context;
+import android.media.MediaCodec;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.testutil.DumpFileAsserts;
+import com.google.android.exoplayer2.testutil.DumpableMp4Box;
+import com.google.android.exoplayer2.testutil.TestUtil;
+import com.google.android.exoplayer2.video.ColorInfo;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.BaseEncoding;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link Boxes}. */
+@RunWith(AndroidJUnit4.class)
+public class BoxesTest {
+  // A typical timescale is ~90_000. We're using 100_000 here to simplify calculations.
+  // This makes one time unit equal to 10 microseconds.
+  private static final int VU_TIMEBASE = 100_000;
+
+  private Context context;
+
+  @Before
+  public void setUp() {
+    context = ApplicationProvider.getApplicationContext();
+  }
+
+  @Test
+  public void createTkhdBox_forVideoTrack_matchesExpected() throws IOException {
+    Format videoFormat = MuxerTestUtil.getFakeVideoFormat();
+
+    ByteBuffer tkhdBox =
+        Boxes.tkhd(
+            /* trackId= */ 1,
+            /* trackDurationVu= */ 5_000_000,
+            /* modificationDateUnixMs= */ 1_000_000_000,
+            /* orientation= */ 90,
+            videoFormat);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(tkhdBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, getExpectedDumpFilePath("video_track_tkhd_box"));
+  }
+
+  @Test
+  public void createTkhdBox_forAudioTrack_matchesExpected() throws IOException {
+    Format audioFormat = MuxerTestUtil.getFakeAudioFormat();
+
+    ByteBuffer tkhdBox =
+        Boxes.tkhd(
+            /* trackId= */ 1,
+            /* trackDurationVu= */ 5_000_000,
+            /* modificationDateUnixMs= */ 1_000_000_000,
+            /* orientation= */ 90,
+            audioFormat);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(tkhdBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, getExpectedDumpFilePath("audio_track_tkhd_box"));
+  }
+
+  @Test
+  public void createMvhdBox_matchesExpected() throws IOException {
+    ByteBuffer mvhdBox =
+        Boxes.mvhd(
+            /* nextEmptyTrackId= */ 3,
+            /* modificationDateUnixMs= */ 1_000_000_000,
+            /* videoDurationUs= */ 5_000_000);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(mvhdBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("mvhd_box"));
+  }
+
+  @Test
+  public void createMdhdBox_matchesExpected() throws IOException {
+    ByteBuffer mdhdBox =
+        Boxes.mdhd(
+            /* trackDurationVu= */ 5_000_000,
+            VU_TIMEBASE,
+            /* modificationDateUnixMs= */ 1_000_000_000,
+            /* languageCode= */ "und");
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(mdhdBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("mdhd_box"));
+  }
+
+  @Test
+  public void createVmhdBox_matchesExpected() throws IOException {
+    ByteBuffer vmhdBox = Boxes.vmhd();
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(vmhdBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("vmhd_box"));
+  }
+
+  @Test
+  public void createSmhdBox_matchesExpected() throws IOException {
+    ByteBuffer smhdBox = Boxes.smhd();
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(smhdBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("smhd_box"));
+  }
+
+  @Test
+  public void createNmhdBox_matchesExpected() throws IOException {
+    ByteBuffer nmhdBox = Boxes.nmhd();
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(nmhdBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("nmhd_box"));
+  }
+
+  @Test
+  public void createEmptyDinfBox_matchesExpected() throws IOException {
+    ByteBuffer dinfBox = Boxes.dinf(Boxes.dref(Boxes.localUrl()));
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(dinfBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("dinf_box_empty"));
+  }
+
+  @Test
+  public void createHdlrBox_matchesExpected() throws IOException {
+    // Create hdlr box for video track.
+    ByteBuffer hdlrBox = Boxes.hdlr(/* handlerType= */ "vide", /* handlerName= */ "VideoHandle");
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(hdlrBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("hdlr_box"));
+  }
+
+  @Test
+  public void createUdtaBox_matchesExpected() throws IOException {
+    Mp4Location mp4Location = new Mp4Location(33.0f, -120f);
+
+    ByteBuffer udtaBox = Boxes.udta(mp4Location);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(udtaBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("udta_box"));
+  }
+
+  @Test
+  public void createKeysBox_matchesExpected() throws Exception {
+    List<String> keyNames = ImmutableList.of("com.android.version", "com.android.capture.fps");
+
+    ByteBuffer keysBox = Boxes.keys(keyNames);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(keysBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("keys_box"));
+  }
+
+  @Test
+  public void createIlstBox_matchesExpected() throws Exception {
+    List<Object> values = ImmutableList.of("11", 120.0f);
+
+    ByteBuffer ilstBox = Boxes.ilst(values);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(ilstBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("ilst_box"));
+  }
+
+  @Test
+  public void createUuidBox_forXmpData_matchesExpected() throws Exception {
+    ByteBuffer xmpData =
+        ByteBuffer.wrap(TestUtil.getByteArray(context, "media/xmp/sample_datetime_xmp.xmp"));
+
+    ByteBuffer xmpUuidBox = Boxes.uuid(Boxes.XMP_UUID, xmpData);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(xmpUuidBox);
+    DumpFileAsserts.assertOutput(context, dumpableBox, getExpectedDumpFilePath("uuid_box_XMP"));
+  }
+
+  @Test
+  public void createuuidBox_withEmptyXmpData_throws() {
+    ByteBuffer xmpData = ByteBuffer.allocate(0);
+
+    assertThrows(IllegalArgumentException.class, () -> Boxes.uuid(Boxes.XMP_UUID, xmpData));
+  }
+
+  @Test
+  public void createAudioSampleEntryBox_forMp4a_matchesExpected() throws Exception {
+    Format format =
+        new Format.Builder()
+            .setPeakBitrate(128000)
+            .setSampleRate(48000)
+            .setId(3)
+            .setSampleMimeType("audio/mp4a-latm")
+            .setChannelCount(2)
+            .setAverageBitrate(128000)
+            .setLanguage("```")
+            .setMaxInputSize(502)
+            .setInitializationData(ImmutableList.of(BaseEncoding.base16().decode("1190")))
+            .build();
+
+    ByteBuffer audioSampleEntryBox = Boxes.audioSampleEntry(format);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(audioSampleEntryBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, getExpectedDumpFilePath("audio_sample_entry_box_mp4a"));
+  }
+
+  @Test
+  public void createAudioSampleEntryBox_withUnknownAudioFormat_throws() {
+    // The audio format contains an unknown MIME type.
+    Format format =
+        new Format.Builder()
+            .setPeakBitrate(128000)
+            .setSampleRate(48000)
+            .setId(3)
+            .setSampleMimeType("audio/mp4a-unknown")
+            .setChannelCount(2)
+            .setAverageBitrate(128000)
+            .setLanguage("```")
+            .setMaxInputSize(502)
+            .setInitializationData(ImmutableList.of(BaseEncoding.base16().decode("1190")))
+            .build();
+
+    assertThrows(IllegalArgumentException.class, () -> Boxes.audioSampleEntry(format));
+  }
+
+  @Test
+  public void createVideoSampleEntryBox_forH265_matchesExpected() throws Exception {
+    Format format =
+        new Format.Builder()
+            .setId(1)
+            .setSampleMimeType("video/hevc")
+            .setWidth(48)
+            .setLanguage("und")
+            .setMaxInputSize(114)
+            .setFrameRate(25)
+            .setHeight(32)
+            .setInitializationData(
+                ImmutableList.of(
+                    BaseEncoding.base16()
+                        .decode(
+                            "0000000140010C01FFFF0408000003009FC800000300001E959809000000014201010408000003009FC800000300001EC1882165959AE4CAE68080000003008000000C84000000014401C173D089")))
+            .build();
+
+    ByteBuffer videoSampleEntryBox = Boxes.videoSampleEntry(format);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(videoSampleEntryBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("video_sample_entry_box_h265"));
+  }
+
+  @Test
+  public void createVideoSampleEntryBox_forH265_hdr10_matchesExpected() throws Exception {
+    Format format =
+        new Format.Builder()
+            .setPeakBitrate(9200)
+            .setId(1)
+            .setSampleMimeType("video/hevc")
+            .setAverageBitrate(9200)
+            .setLanguage("und")
+            .setWidth(256)
+            .setMaxInputSize(66)
+            .setFrameRate(25)
+            .setHeight(256)
+            .setColorInfo(
+                new ColorInfo.Builder()
+                    .setColorSpace(C.COLOR_SPACE_BT2020)
+                    .setColorTransfer(C.COLOR_TRANSFER_ST2084)
+                    .setColorRange(C.COLOR_RANGE_LIMITED)
+                    .build())
+            .setInitializationData(
+                ImmutableList.of(
+                    BaseEncoding.base16()
+                        .decode(
+                            "0000000140010C01FFFF02200000030090000003000003003C9598090000000142010102200000030090000003000003003CA008080404D96566924CAE69C20000030002000003003210000000014401C172B46240")))
+            .build();
+
+    ByteBuffer videoSampleEntryBox = Boxes.videoSampleEntry(format);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(videoSampleEntryBox);
+    DumpFileAsserts.assertOutput(
+        context,
+        dumpableBox,
+        MuxerTestUtil.getExpectedDumpFilePath("video_sample_entry_box_h265_hdr10"));
+  }
+
+  @Test
+  public void createVideoSampleEntryBox_forH264_matchesExpected() throws Exception {
+    Format format =
+        new Format.Builder()
+            .setId(1)
+            .setSampleMimeType("video/avc")
+            .setLanguage("und")
+            .setWidth(10)
+            .setMaxInputSize(39)
+            .setFrameRate(25)
+            .setHeight(12)
+            .setInitializationData(
+                ImmutableList.of(
+                    BaseEncoding.base16()
+                        .decode("0000000167F4000A919B2BF3CB3640000003004000000C83C4896580"),
+                    BaseEncoding.base16().decode("0000000168EBE3C448")))
+            .build();
+
+    ByteBuffer videoSampleEntryBox = Boxes.videoSampleEntry(format);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(videoSampleEntryBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("video_sample_entry_box_h264"));
+  }
+
+  @Test
+  public void createVideoSampleEntryBox_forAv1_matchesExpected() throws IOException {
+    Format format =
+        new Format.Builder()
+            .setId(1)
+            .setSampleMimeType("video/av01")
+            .setLanguage("und")
+            .setWidth(10)
+            .setMaxInputSize(49)
+            .setFrameRate(25)
+            .setHeight(12)
+            .setInitializationData(
+                ImmutableList.of(BaseEncoding.base16().decode("812000000A09200000019CDBFFF304")))
+            .build();
+
+    ByteBuffer videoSampleEntryBox = Boxes.videoSampleEntry(format);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(videoSampleEntryBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("video_sample_entry_box_av1"));
+  }
+
+  @Test
+  public void createVideoSampleEntryBox_withUnknownVideoFormat_throws() {
+    // The video format contains an unknown MIME type.
+    Format format =
+        new Format.Builder()
+            .setId(1)
+            .setSampleMimeType("video/someweirdvideoformat")
+            .setWidth(48)
+            .setLanguage("und")
+            .setMaxInputSize(114)
+            .setFrameRate(25)
+            .setHeight(32)
+            .setInitializationData(
+                ImmutableList.of(
+                    BaseEncoding.base16()
+                        .decode(
+                            "0000000140010C01FFFF0408000003009FC800000300001E959809000000014201010408000003009FC800000300001EC1882165959AE4CAE68080000003008000000C84000000014401C173D089")))
+            .build();
+
+    assertThrows(IllegalArgumentException.class, () -> Boxes.videoSampleEntry(format));
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_singleSampleAtZeroTimestamp_lastFrameDurationShort_returnsSingleZeroLengthSample() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(0L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME);
+
+    assertThat(durationsVu).containsExactly(0L);
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_singleSampleAtZeroTimestamp_lastFrameDurationDuplicate_returnsSingleZeroLengthSample() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(0L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION);
+
+    assertThat(durationsVu).containsExactly(0L);
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_singleSampleAtNonZeroTimestamp_lastFrameDurationShort_returnsSampleLengthEqualsTimestamp() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(5_000L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME);
+
+    assertThat(durationsVu).containsExactly(500L);
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_singleSampleAtNonZeroTimestamp_lastFrameDurationDuplicate_returnsSampleLengthEqualsTimestamp() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(5_000L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION);
+
+    assertThat(durationsVu).containsExactly(500L);
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_differentSampleDurations_lastFrameDurationShort_returnsLastSampleOfZeroDuration() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(0L, 30_000L, 80_000L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_INSERT_SHORT_FRAME);
+
+    assertThat(durationsVu).containsExactly(3_000L, 5_000L, 0L);
+  }
+
+  @Test
+  public void
+      getDurationsVuForStts_differentSampleDurations_lastFrameDurationDuplicate_returnsLastSampleOfDuplicateDuration() {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSamplePresentationTimestamps(0L, 30_000L, 80_000L);
+
+    List<Long> durationsVu =
+        Boxes.durationsVuForStts(
+            sampleBufferInfos,
+            /* minInputPresentationTimestampUs= */ 0L,
+            VU_TIMEBASE,
+            LAST_FRAME_DURATION_BEHAVIOR_DUPLICATE_PREV_DURATION);
+
+    assertThat(durationsVu).containsExactly(3_000L, 5_000L, 5_000L);
+  }
+
+  @Test
+  public void createSttsBox_withSingleSampleDuration_matchesExpected() throws IOException {
+    ImmutableList<Long> sampleDurations = ImmutableList.of(500L);
+
+    ByteBuffer sttsBox = Boxes.stts(sampleDurations);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(sttsBox);
+    DumpFileAsserts.assertOutput(
+        context,
+        dumpableBox,
+        MuxerTestUtil.getExpectedDumpFilePath("stts_box_single_sample_duration"));
+  }
+
+  @Test
+  public void createSttsBox_withAllDifferentSampleDurations_matchesExpected() throws IOException {
+    ImmutableList<Long> sampleDurations = ImmutableList.of(1_000L, 2_000L, 3_000L, 5_000L);
+
+    ByteBuffer sttsBox = Boxes.stts(sampleDurations);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(sttsBox);
+    DumpFileAsserts.assertOutput(
+        context,
+        dumpableBox,
+        MuxerTestUtil.getExpectedDumpFilePath("stts_box_all_different_sample_durations"));
+  }
+
+  @Test
+  public void createSttsBox_withFewConsecutiveSameSampleDurations_matchesExpected()
+      throws IOException {
+    ImmutableList<Long> sampleDurations = ImmutableList.of(1_000L, 2_000L, 2_000L, 2_000L);
+
+    ByteBuffer sttsBox = Boxes.stts(sampleDurations);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(sttsBox);
+    DumpFileAsserts.assertOutput(
+        context,
+        dumpableBox,
+        MuxerTestUtil.getExpectedDumpFilePath("stts_box_few_same_sample_durations"));
+  }
+
+  @Test
+  public void createStszBox_matchesExpected() throws IOException {
+    List<MediaCodec.BufferInfo> sampleBufferInfos =
+        createBufferInfoListWithSampleSizes(100, 200, 150, 200);
+
+    ByteBuffer stszBox = Boxes.stsz(sampleBufferInfos);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(stszBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("stsz_box"));
+  }
+
+  @Test
+  public void createStscBox_matchesExpected() throws IOException {
+    ImmutableList<Integer> chunkSampleCounts = ImmutableList.of(100, 500, 200, 100);
+
+    ByteBuffer stscBox = Boxes.stsc(chunkSampleCounts);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(stscBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("stsc_box"));
+  }
+
+  @Test
+  public void createCo64Box_matchesExpected() throws IOException {
+    ImmutableList<Long> chunkOffsets = ImmutableList.of(1_000L, 5_000L, 7_000L, 10_000L);
+
+    ByteBuffer co64Box = Boxes.co64(chunkOffsets);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(co64Box);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("co64_box"));
+  }
+
+  @Test
+  public void createStssBox_matchesExpected() throws IOException {
+    List<MediaCodec.BufferInfo> sampleBufferInfos = createBufferInfoListWithSomeKeyFrames();
+
+    ByteBuffer stssBox = Boxes.stss(sampleBufferInfos);
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(stssBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("stss_box"));
+  }
+
+  @Test
+  public void createFtypBox_matchesExpected() throws IOException {
+    ByteBuffer ftypBox = Boxes.ftyp();
+
+    DumpableMp4Box dumpableBox = new DumpableMp4Box(ftypBox);
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("ftyp_box"));
+  }
+
+  private static List<MediaCodec.BufferInfo> createBufferInfoListWithSamplePresentationTimestamps(
+      long... timestampsUs) {
+    List<MediaCodec.BufferInfo> bufferInfoList = new ArrayList<>();
+    for (long timestampUs : timestampsUs) {
+      MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+      bufferInfo.presentationTimeUs = timestampUs;
+      bufferInfoList.add(bufferInfo);
+    }
+
+    return bufferInfoList;
+  }
+
+  private static List<MediaCodec.BufferInfo> createBufferInfoListWithSampleSizes(int... sizes) {
+    List<MediaCodec.BufferInfo> bufferInfoList = new ArrayList<>();
+    for (int size : sizes) {
+      MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+      bufferInfo.size = size;
+      bufferInfoList.add(bufferInfo);
+    }
+
+    return bufferInfoList;
+  }
+
+  private static List<MediaCodec.BufferInfo> createBufferInfoListWithSomeKeyFrames() {
+    List<MediaCodec.BufferInfo> bufferInfoList = new ArrayList<>();
+    for (int i = 0; i < 30; i++) {
+      MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+      if (i % 5 == 0) { // Make every 5th frame as key frame.
+        bufferInfo.flags = MediaCodec.BUFFER_FLAG_KEY_FRAME;
+      }
+      bufferInfoList.add(bufferInfo);
+    }
+
+    return bufferInfoList;
+  }
+}

library/muxer/src/test/java/androidx/media3/muxer/DefaultAnnexBToAvccConverterTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import java.nio.ByteBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link AnnexBToAvccConverter#DEFAULT}. */
+@RunWith(AndroidJUnit4.class)
+public final class DefaultAnnexBToAvccConverterTest {
+  @Test
+  public void convertAnnexBToAvcc_singleNalUnit() {
+    ByteBuffer in = generateFakeNalUnitData(1000);
+    // Add start code for the NAL unit.
+    in.put(0, (byte) 0);
+    in.put(1, (byte) 0);
+    in.put(2, (byte) 0);
+    in.put(3, (byte) 1);
+
+    AnnexBToAvccConverter annexBToAvccConverter = AnnexBToAvccConverter.DEFAULT;
+    annexBToAvccConverter.process(in);
+
+    // The start code should get replaced with the length of the NAL unit.
+    assertThat(in.getInt(0)).isEqualTo(996);
+  }
+
+  @Test
+  public void convertAnnexBToAvcc_twoNalUnits() {
+    ByteBuffer in = generateFakeNalUnitData(1000);
+    // Add start code for the first NAL unit.
+    in.put(0, (byte) 0);
+    in.put(1, (byte) 0);
+    in.put(2, (byte) 0);
+    in.put(3, (byte) 1);
+
+    // Add start code for the second NAL unit.
+    in.put(600, (byte) 0);
+    in.put(601, (byte) 0);
+    in.put(602, (byte) 0);
+    in.put(603, (byte) 1);
+
+    AnnexBToAvccConverter annexBToAvccConverter = AnnexBToAvccConverter.DEFAULT;
+    annexBToAvccConverter.process(in);
+
+    // Both the NAL units should have length headers.
+    assertThat(in.getInt(0)).isEqualTo(596);
+    assertThat(in.getInt(600)).isEqualTo(396);
+  }
+
+  @Test
+  public void convertAnnexBToAvcc_noNalUnit_outputSameAsInput() {
+    ByteBuffer input = generateFakeNalUnitData(1000);
+    ByteBuffer inputCopy = ByteBuffer.allocate(input.limit());
+    inputCopy.put(input);
+    input.rewind();
+    inputCopy.rewind();
+
+    AnnexBToAvccConverter annexBToAvccConverter = AnnexBToAvccConverter.DEFAULT;
+    annexBToAvccConverter.process(input);
+
+    assertThat(input).isEqualTo(inputCopy);
+  }
+
+  /** Returns {@link ByteBuffer} filled with random NAL unit data without start code. */
+  private static ByteBuffer generateFakeNalUnitData(int length) {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(length);
+    for (int i = 0; i < length; i++) {
+      // Avoid anything resembling start codes (0x00000001) or emulation prevention byte (0x03).
+      buffer.put((byte) ((i % 250) + 5));
+    }
+
+    buffer.rewind();
+    return buffer;
+  }
+}

library/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.media.MediaCodec.BufferInfo;
+import android.util.Pair;
+import androidx.media3.muxer.Mp4Muxer.TrackToken;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.extractor.mp4.Mp4Extractor;
+import com.google.android.exoplayer2.testutil.DumpFileAsserts;
+import com.google.android.exoplayer2.testutil.FakeExtractorOutput;
+import com.google.android.exoplayer2.testutil.TestUtil;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+
+/** End to end tests for {@link Mp4Muxer}. */
+@RunWith(AndroidJUnit4.class)
+public class Mp4MuxerEndToEndTest {
+  @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  private Format format;
+  private String outputFilePath;
+  private FileOutputStream outputFileStream;
+
+  @Before
+  public void setUp() throws IOException {
+    outputFilePath = temporaryFolder.newFile("output.mp4").getPath();
+    outputFileStream = new FileOutputStream(outputFilePath);
+
+    format = MuxerTestUtil.getFakeVideoFormat();
+  }
+
+  @Test
+  public void createMp4File_addTrackAndMetadataButNoSamples_createsEmptyFile() throws IOException {
+    Mp4Muxer mp4Muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      mp4Muxer.addTrack(/* sortKey= */ 0, format);
+      mp4Muxer.setOrientation(90);
+      mp4Muxer.addMetadata("key", "value");
+    } finally {
+      mp4Muxer.close();
+    }
+
+    byte[] outputFileBytes = TestUtil.getByteArrayFromFilePath(outputFilePath);
+    assertThat(outputFileBytes).isEmpty();
+  }
+
+  @Test
+  public void createMp4File_withSameTracksOffset_matchesExpected() throws IOException {
+    Context context = ApplicationProvider.getApplicationContext();
+    Mp4Muxer mp4Muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    Pair<ByteBuffer, BufferInfo> track1Sample1 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 100L);
+    Pair<ByteBuffer, BufferInfo> track1Sample2 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 200L);
+
+    Pair<ByteBuffer, BufferInfo> track2Sample1 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 100L);
+    Pair<ByteBuffer, BufferInfo> track2Sample2 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 300L);
+
+    try {
+      TrackToken track1 = mp4Muxer.addTrack(/* sortKey= */ 0, format);
+      mp4Muxer.writeSampleData(track1, track1Sample1.first, track1Sample1.second);
+      mp4Muxer.writeSampleData(track1, track1Sample2.first, track1Sample2.second);
+
+      // Add same track again but with different samples.
+      TrackToken track2 = mp4Muxer.addTrack(/* sortKey= */ 1, format);
+      mp4Muxer.writeSampleData(track2, track2Sample1.first, track2Sample1.second);
+      mp4Muxer.writeSampleData(track2, track2Sample2.first, track2Sample2.second);
+    } finally {
+      mp4Muxer.close();
+    }
+
+    // Presentation timestamps in dump file are:
+    // Track 1 Sample 1 = 0L
+    // Track 1 Sample 2 = 100L
+    // Track 2 Sample 1 = 0L
+    // Track 2 Sample 2 = 200L
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_same_tracks_offset.mp4"));
+  }
+
+  @Test
+  public void createMp4File_withDifferentTracksOffset_matchesExpected() throws IOException {
+    Context context = ApplicationProvider.getApplicationContext();
+    Mp4Muxer mp4Muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    Pair<ByteBuffer, BufferInfo> track1Sample1 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 0L);
+    Pair<ByteBuffer, BufferInfo> track1Sample2 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 100L);
+
+    Pair<ByteBuffer, BufferInfo> track2Sample1 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 100L);
+    Pair<ByteBuffer, BufferInfo> track2Sample2 =
+        MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 200L);
+
+    try {
+      TrackToken track1 = mp4Muxer.addTrack(/* sortKey= */ 0, format);
+      mp4Muxer.writeSampleData(track1, track1Sample1.first, track1Sample1.second);
+      mp4Muxer.writeSampleData(track1, track1Sample2.first, track1Sample2.second);
+
+      // Add same track again but with different samples.
+      TrackToken track2 = mp4Muxer.addTrack(/* sortKey= */ 1, format);
+      mp4Muxer.writeSampleData(track2, track2Sample1.first, track2Sample1.second);
+      mp4Muxer.writeSampleData(track2, track2Sample2.first, track2Sample2.second);
+    } finally {
+      mp4Muxer.close();
+    }
+
+    // The presentation time of second track's first sample is forcefully changed to 0L.
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_different_tracks_offset.mp4"));
+  }
+}

library/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerMetadataTest.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import android.content.Context;
+import android.media.MediaCodec.BufferInfo;
+import android.util.Pair;
+import androidx.media3.muxer.Mp4Muxer.TrackToken;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.extractor.mp4.Mp4Extractor;
+import com.google.android.exoplayer2.testutil.DumpFileAsserts;
+import com.google.android.exoplayer2.testutil.DumpableMp4Box;
+import com.google.android.exoplayer2.testutil.FakeExtractorOutput;
+import com.google.android.exoplayer2.testutil.TestUtil;
+import java.io.FileOutputStream;
+import java.nio.ByteBuffer;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+
+/** Tests for metadata written by {@link Mp4Muxer}. */
+@RunWith(AndroidJUnit4.class)
+public class Mp4MuxerMetadataTest {
+  @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  // Input files.
+  private static final String XMP_SAMPLE_DATA = "media/xmp/sample_datetime_xmp.xmp";
+
+  private Context context;
+  private String outputFilePath;
+  private FileOutputStream outputFileStream;
+  private Format format;
+  private Pair<ByteBuffer, BufferInfo> sampleAndSampleInfo;
+
+  @Before
+  public void setUp() throws Exception {
+    context = ApplicationProvider.getApplicationContext();
+
+    outputFilePath = temporaryFolder.newFile("output.mp4").getPath();
+    outputFileStream = new FileOutputStream(outputFilePath);
+
+    format = MuxerTestUtil.getFakeVideoFormat();
+    sampleAndSampleInfo = MuxerTestUtil.getFakeSampleAndSampleInfo(/* presentationTimeUs= */ 0L);
+  }
+
+  @Test
+  public void writeMp4File_orientationNotSet_setsOrientationTo0() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // No rotationDegrees field in output dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_0_orientation.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_setOrientationTo90_setsOrientationTo90() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+
+      muxer.setOrientation(90);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // rotationDegrees = 90 in the output dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_90_orientation.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_setOrientationTo180_setsOrientationTo180() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+
+      muxer.setOrientation(180);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // rotationDegrees = 180 in the output dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_180_orientation.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_setOrientationTo270_setsOrientationTo270() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+
+      muxer.setOrientation(270);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // rotationDegrees = 270 in the output dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_270_orientation.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_setLocation_setsSameLocation() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+      muxer.setLocation(33.0f, -120f);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // Xyz data in track metadata dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_location.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_locationNotSet_setsLocationToNull() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // No xyz data in track metadata dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_null_location.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_setFrameRate_setsSameFrameRate() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      muxer.setCaptureFps(120.0f);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    FakeExtractorOutput fakeExtractorOutput =
+        TestUtil.extractAllSamplesFromFilePath(new Mp4Extractor(), outputFilePath);
+    // android.capture.fps data in the track metadata dump.
+    DumpFileAsserts.assertOutput(
+        context,
+        fakeExtractorOutput,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_frame_rate.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_addStringMetadata_matchesExpected() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      muxer.addMetadata("SomeStringKey", "Some Random String");
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    // TODO(b/270956881): Use FakeExtractorOutput once it starts dumping custom metadata from the
+    //  meta box.
+    DumpableMp4Box dumpableBox =
+        new DumpableMp4Box(ByteBuffer.wrap(TestUtil.getByteArrayFromFilePath(outputFilePath)));
+    // The meta box should be present in the output MP4.
+    DumpFileAsserts.assertOutput(
+        context,
+        dumpableBox,
+        MuxerTestUtil.getExpectedDumpFilePath("mp4_with_string_metadata.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_addFloatMetadata_matchesExpected() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      muxer.addMetadata("SomeStringKey", 10.0f);
+      TrackToken token = muxer.addTrack(/* sortKey= */ 0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    // TODO(b/270956881): Use FakeExtractorOutput once it starts dumping custom metadata from the
+    //  meta box.
+    DumpableMp4Box dumpableBox =
+        new DumpableMp4Box(ByteBuffer.wrap(TestUtil.getByteArrayFromFilePath(outputFilePath)));
+    // The meta box should be present in the output MP4.
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("mp4_with_float_metadata.mp4"));
+  }
+
+  @Test
+  public void writeMp4File_addXmp_matchesExpected() throws Exception {
+    Mp4Muxer muxer = new Mp4Muxer.Builder(outputFileStream).build();
+
+    try {
+      muxer.setModificationTime(5000000);
+      Context context = ApplicationProvider.getApplicationContext();
+      byte[] xmpBytes = TestUtil.getByteArray(context, XMP_SAMPLE_DATA);
+      ByteBuffer xmp = ByteBuffer.wrap(xmpBytes);
+      muxer.addXmp(xmp);
+      xmp.rewind();
+      TrackToken token = muxer.addTrack(0, format);
+      muxer.writeSampleData(token, sampleAndSampleInfo.first, sampleAndSampleInfo.second);
+    } finally {
+      muxer.close();
+    }
+
+    // TODO(b/270956881): Use FakeExtractorOutput once it starts dumping uuid box.
+    DumpableMp4Box dumpableBox =
+        new DumpableMp4Box(ByteBuffer.wrap(TestUtil.getByteArrayFromFilePath(outputFilePath)));
+    // The uuid box should be present in the output MP4.
+    DumpFileAsserts.assertOutput(
+        context, dumpableBox, MuxerTestUtil.getExpectedDumpFilePath("mp4_with_xmp.mp4"));
+  }
+}

library/muxer/src/test/java/androidx/media3/muxer/MuxerTestUtil.java

+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.muxer;
+
+import android.media.MediaCodec;
+import android.media.MediaCodec.BufferInfo;
+import android.util.Pair;
+import com.google.android.exoplayer2.Format;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.BaseEncoding;
+import java.nio.ByteBuffer;
+
+/** Utilities for muxer test cases. */
+/* package */ class MuxerTestUtil {
+  private static final byte[] FAKE_CSD_0 =
+      BaseEncoding.base16().decode("0000000167F4000A919B2BF3CB3640000003004000000C83C4896580");
+  private static final byte[] FAKE_CSD_1 = BaseEncoding.base16().decode("0000000168EBE3C448");
+  private static final byte[] FAKE_H264_SAMPLE =
+      BaseEncoding.base16()
+          .decode(
+              "0000000167F4000A919B2BF3CB3640000003004000000C83C48965800000000168EBE3C448000001658884002BFFFEF5DBF32CAE4A43FF");
+
+  private static final String DUMP_FILE_OUTPUT_DIRECTORY = "muxerdumps";
+  private static final String DUMP_FILE_EXTENSION = "dump";
+
+  public static String getExpectedDumpFilePath(String originalFileName) {
+    return DUMP_FILE_OUTPUT_DIRECTORY + '/' + originalFileName + '.' + DUMP_FILE_EXTENSION;
+  }
+
+  public static Format getFakeVideoFormat() {
+    return new Format.Builder()
+        .setSampleMimeType("video/avc")
+        .setWidth(12)
+        .setHeight(10)
+        .setInitializationData(ImmutableList.of(FAKE_CSD_0, FAKE_CSD_1))
+        .build();
+  }
+
+  public static Format getFakeAudioFormat() {
+    return new Format.Builder()
+        .setSampleMimeType("audio/mp4a-latm")
+        .setSampleRate(40000)
+        .setChannelCount(2)
+        .build();
+  }
+
+  public static Pair<ByteBuffer, BufferInfo> getFakeSampleAndSampleInfo(long presentationTimeUs) {
+    ByteBuffer sampleDirectBuffer = ByteBuffer.allocateDirect(FAKE_H264_SAMPLE.length);
+    sampleDirectBuffer.put(FAKE_H264_SAMPLE);
+    sampleDirectBuffer.rewind();
+
+    BufferInfo bufferInfo = new BufferInfo();
+    bufferInfo.presentationTimeUs = presentationTimeUs;
+    bufferInfo.flags = MediaCodec.BUFFER_FLAG_KEY_FRAME;
+    bufferInfo.size = FAKE_H264_SAMPLE.length;
+
+    return new Pair<>(sampleDirectBuffer, bufferInfo);
+  }
+
+  private MuxerTestUtil() {}
+}