Minor style and formatting fixes

This change is in preparation of github.com//pull/2259.

Author: ivanbuper

RELEASENOTES.md

@@ -11,6 +11,8 @@
 *   Extractors:
 *   DataSource:
 *   Audio:
+    *   Add support for all linear PCM sample formats in
+        `ChannelMappingAudioProcessor` and `TrimmingAudioProcessor`.
 *   Video:
     *   Improve smooth video frame release at startup when audio samples don't
         start at exactly the requested position.
@@ -112,8 +114,6 @@ This release includes the following changes since [1.6.1](#161-2025-04-14):
     *   Fix bug that `AnalyticsListener.onAudioPositionAdvancing` was not
         reporting the time when the audio started advancing but the time of the
         first measurement.
-    *   Add support for all linear PCM sample formats in
-        `ChannelMappingAudioProcessor` and `TrimmingAudioProcessor`.
 *   Video:
     *   Add experimental `ExoPlayer` API to include the
         `MediaCodec.BUFFER_FLAG_DECODE_ONLY` flag when queuing decode-only input

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

@@ -118,10 +118,8 @@
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
-import java.nio.ReadOnlyBufferException;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -3462,51 +3460,47 @@ public static long getNowUnixTimeMs(long elapsedRealtimeEpochOffsetMs) {
   }
 
   /**
-   * Absolute <i>get</i> method for reading a sign-extended 24-bit integer value.
+   * Returns the sign-extended 24-bit integer value at {@code index}.
    *
-   * <p>Reads three bytes at the given index, composing them into a 24-bit integer value according
-   * to the current byte order.
-   *
-   * @param buf The buffer to operate on
-   * @param index The index from which the bytes will be read
-   * @return The 24-bit integer value at the given index
-   * @throws IndexOutOfBoundsException If {@code index} is negative or not smaller than the buffer's
-   *     limit, minus two
+   * @param buffer The buffer from which to read the 24-bit integer.
+   * @param index The index of the 24-bit integer.
    */
-  public static int getInt24(ByteBuffer buf, int index) {
-    byte component1 = buf.get(buf.order() == ByteOrder.BIG_ENDIAN ? index : index + 2);
-    byte component2 = buf.get(index + 1);
-    byte component3 = buf.get(buf.order() == ByteOrder.BIG_ENDIAN ? index + 2 : index);
+  @UnstableApi
+  public static int getInt24(ByteBuffer buffer, int index) {
+    byte component1 = buffer.get(buffer.order() == ByteOrder.BIG_ENDIAN ? index : index + 2);
+    byte component2 = buffer.get(index + 1);
+    byte component3 = buffer.get(buffer.order() == ByteOrder.BIG_ENDIAN ? index + 2 : index);
     return ((component1 << 24) & 0xff000000
             | (component2 << 16) & 0xff0000
             | (component3 << 8) & 0xff00)
         >> 8;
   }
 
   /**
-   * Relative <i>put</i> method for writing a 24-bit integer value.
+   * Writes a 24-bit integer value to a buffer at its current {@link ByteBuffer#position()}.
    *
-   * <p>Writes three bytes containing the given int value, in the current byte order, into this
-   * buffer at the current position, and then increments the position by three.
+   * <p>This is a relative operation that affects the buffer's position.
    *
-   * @param val The short value to be written
-   * @param buf The buffer to operate on
-   * @throws BufferOverflowException If there are fewer than two bytes remaining in this buffer
-   * @throws ReadOnlyBufferException If this buffer is read-only
-   * @throws IllegalArgumentException If the value is out of range for a 24-bit integer
+   * @param buffer The buffer on which to write the integer.
+   * @param value The integer value to write.
+   * @throws IllegalArgumentException If {@code value} is out of range for a 24-bit integer.
    */
-  public static void putInt24(ByteBuffer buf, int val) {
-    if ((val & ~0xffffff) != 0 && (val & ~0x7fffff) != 0xff800000) {
-      throw new IllegalArgumentException("value out of range: " + Integer.toHexString(val));
-    }
+  @UnstableApi
+  public static void putInt24(ByteBuffer buffer, int value) {
+    checkArgument(
+        (value & ~0xffffff) == 0 || (value & ~0x7fffff) == 0xff800000,
+        "Value out of range of 24-bit integer: " + Integer.toHexString(value));
+    checkArgument(buffer.remaining() >= 3);
     byte component1 =
-        buf.order() == ByteOrder.BIG_ENDIAN ? (byte) ((val & 0xFF0000) >> 16) : (byte) (val & 0xFF);
-    byte component2 = (byte) ((val & 0xFF00) >> 8);
+        buffer.order() == ByteOrder.BIG_ENDIAN
+            ? (byte) ((value & 0xFF0000) >> 16)
+            : (byte) (value & 0xFF);
+    byte component2 = (byte) ((value & 0xFF00) >> 8);
     byte component3 =
-        buf.order() == ByteOrder.BIG_ENDIAN ? (byte) (val & 0xFF) : (byte) ((val & 0xFF0000) >> 16);
-    buf.put(component1);
-    buf.put(component2);
-    buf.put(component3);
+        buffer.order() == ByteOrder.BIG_ENDIAN
+            ? (byte) (value & 0xFF)
+            : (byte) ((value & 0xFF0000) >> 16);
+    buffer.put(component1).put(component2).put(component3);
   }
 
   /**

libraries/common/src/test/java/androidx/media3/common/util/UtilTest.java

@@ -1680,49 +1680,55 @@ public void contentHashCode_sparseArraysWithDifferentContent_returnsDifferentCon
   }
 
   @Test
-  public void putInt24_littleEndian() {
-    ByteBuffer buf = ByteBuffer.allocateDirect(2 * 3).order(ByteOrder.LITTLE_ENDIAN);
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0xFF000000));
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0x8FFFFFFF));
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0x01FFFFFF));
-    putInt24(buf, -1);
-    putInt24(buf, 0x123456);
-    buf.rewind();
-    assertThat(createByteArray(buf))
+  public void putInt24_withOutOfRangeInts_throws() {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(6).order(ByteOrder.LITTLE_ENDIAN);
+    assertThrows(IllegalArgumentException.class, () -> putInt24(buffer, 0xFF000000));
+    assertThrows(IllegalArgumentException.class, () -> putInt24(buffer, 0x8FFFFFFF));
+    assertThrows(IllegalArgumentException.class, () -> putInt24(buffer, 0x01FFFFFF));
+  }
+
+  @Test
+  public void putInt24_littleEndianBuffer_respectsOrdering() {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(6).order(ByteOrder.LITTLE_ENDIAN);
+    putInt24(buffer, -1);
+    putInt24(buffer, 0x123456);
+    buffer.rewind();
+    assertThat(createByteArray(buffer))
         .isEqualTo(new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, 0x56, 0x34, 0x12});
-    assertThat(getInt24(buf, 0)).isEqualTo(0xffffffff);
-    assertThat(getInt24(buf, 0) & 0xffffff).isEqualTo(0xffffff);
-    assertThat(getInt24(buf, 0)).isEqualTo(-1);
-    assertThat(getInt24(buf, 3)).isEqualTo(0x00123456);
-
-    buf.rewind();
-    putInt24(buf, 0xff0001);
-    putInt24(buf, 0x00ff02);
-    assertThat(getInt24(buf, 0) & 0xffffff).isEqualTo(0xff0001);
-    assertThat(getInt24(buf, 3) & 0xffffff).isEqualTo(0x00ff02);
-  }
-
-  @Test
-  public void putInt24_bigEndian() {
-    ByteBuffer buf = ByteBuffer.allocateDirect(2 * 3).order(ByteOrder.BIG_ENDIAN);
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0xFF000000));
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0x8FFFFFFF));
-    assertThrows(IllegalArgumentException.class, () -> putInt24(buf, 0x01FFFFFF));
-    putInt24(buf, -1);
-    putInt24(buf, 0x123456);
-    buf.rewind();
-    assertThat(createByteArray(buf))
+  }
+
+  @Test
+  public void getInt24_littleEndianBuffer_returnsExpectedValues() {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(9).order(ByteOrder.LITTLE_ENDIAN);
+    buffer.put(
+        new byte[] {
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, 0x56, 0x34, 0x12, 0x01, 0x00, (byte) 0xFF
+        });
+    assertThat(getInt24(buffer, 0)).isEqualTo(-1);
+    assertThat(getInt24(buffer, 3)).isEqualTo(0x00123456);
+    assertThat(getInt24(buffer, 6)).isEqualTo(0xFFFF0001);
+  }
+
+  @Test
+  public void putInt24_bigEndianBuffer_respectsOrdering() {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(6).order(ByteOrder.BIG_ENDIAN);
+    putInt24(buffer, -1);
+    putInt24(buffer, 0x123456);
+    buffer.rewind();
+    assertThat(createByteArray(buffer))
         .isEqualTo(new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, 0x12, 0x34, 0x56});
-    assertThat(getInt24(buf, 0)).isEqualTo(0xffffffff);
-    assertThat(getInt24(buf, 0) & 0xffffff).isEqualTo(0xffffff);
-    assertThat(getInt24(buf, 0)).isEqualTo(-1);
-    assertThat(getInt24(buf, 3)).isEqualTo(0x00123456);
-
-    buf.rewind();
-    putInt24(buf, 0xff0001);
-    putInt24(buf, 0x00ff02);
-    assertThat(getInt24(buf, 0) & 0xffffff).isEqualTo(0xff0001);
-    assertThat(getInt24(buf, 3) & 0xffffff).isEqualTo(0x00ff02);
+  }
+
+  @Test
+  public void getInt24_bigEndianBuffer_returnsExpectedValues() {
+    ByteBuffer buffer = ByteBuffer.allocateDirect(9).order(ByteOrder.BIG_ENDIAN);
+    buffer.put(
+        new byte[] {
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, 0x12, 0x34, 0x56, (byte) 0xFF, 0x00, 0x01
+        });
+    assertThat(getInt24(buffer, 0)).isEqualTo(-1);
+    assertThat(getInt24(buffer, 3)).isEqualTo(0x00123456);
+    assertThat(getInt24(buffer, 6)).isEqualTo(0xFFFF0001);
   }
 
   private static void assertEscapeUnescapeFileName(String fileName, String escapedFileName) {

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

@@ -16,6 +16,9 @@
 package androidx.media3.exoplayer.audio;
 
 import static androidx.media3.common.util.Util.getByteDepth;
+import static androidx.media3.common.util.Util.getInt24;
+import static androidx.media3.common.util.Util.isEncodingLinearPcm;
+import static androidx.media3.common.util.Util.putInt24;
 
 import androidx.annotation.Nullable;
 import androidx.media3.common.C;
@@ -24,7 +27,6 @@
 import androidx.media3.common.audio.BaseAudioProcessor;
 import androidx.media3.common.util.Assertions;
 import androidx.media3.common.util.UnstableApi;
-import androidx.media3.common.util.Util;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 
@@ -59,7 +61,7 @@ public AudioFormat onConfigure(AudioFormat inputAudioFormat)
       return AudioFormat.NOT_SET;
     }
 
-    if (!Util.isEncodingLinearPcm(inputAudioFormat.encoding)) {
+    if (!isEncodingLinearPcm(inputAudioFormat.encoding)) {
       throw new UnhandledAudioFormatException(inputAudioFormat);
     }
 
@@ -102,7 +104,7 @@ public void queueInput(ByteBuffer inputBuffer) {
             break;
           case C.ENCODING_PCM_24BIT:
           case C.ENCODING_PCM_24BIT_BIG_ENDIAN:
-            Util.putInt24(buffer, Util.getInt24(inputBuffer, inputIndex));
+            putInt24(buffer, getInt24(inputBuffer, inputIndex));
             break;
           case C.ENCODING_PCM_32BIT:
           case C.ENCODING_PCM_32BIT_BIG_ENDIAN:

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

@@ -538,9 +538,9 @@ public DefaultAudioSink build() {
   private final boolean enableFloatOutput;
   private final ChannelMappingAudioProcessor channelMappingAudioProcessor;
   private final TrimmingAudioProcessor trimmingAudioProcessor;
-  private final ImmutableList<AudioProcessor> toIntPcmAvailableAudioProcessors;
-  private final ImmutableList<AudioProcessor> toFloatPcmAvailableAudioProcessors;
-  private final ImmutableList<AudioProcessor> forPreProcessingAvailableAudioProcessors;
+  private final ToInt16PcmAudioProcessor toInt16PcmAudioProcessor;
+  private final ToFloatPcmAudioProcessor toFloatPcmAudioProcessor;
+  private final ImmutableList<AudioProcessor> availableAudioProcessors;
   private final AudioTrackPositionTracker audioTrackPositionTracker;
   private final ArrayDeque<MediaPositionParameters> mediaPositionParametersCheckpoints;
   private final boolean preferAudioTrackPlaybackParams;
@@ -621,9 +621,9 @@ private DefaultAudioSink(Builder builder) {
     audioTrackPositionTracker = new AudioTrackPositionTracker(new PositionTrackerListener());
     channelMappingAudioProcessor = new ChannelMappingAudioProcessor();
     trimmingAudioProcessor = new TrimmingAudioProcessor();
-    toIntPcmAvailableAudioProcessors = ImmutableList.of(new ToInt16PcmAudioProcessor());
-    toFloatPcmAvailableAudioProcessors = ImmutableList.of(new ToFloatPcmAudioProcessor());
-    forPreProcessingAvailableAudioProcessors =
+    toInt16PcmAudioProcessor = new ToInt16PcmAudioProcessor();
+    toFloatPcmAudioProcessor = new ToFloatPcmAudioProcessor();
+    availableAudioProcessors =
         ImmutableList.of(trimmingAudioProcessor, channelMappingAudioProcessor);
     volume = 1f;
     audioSessionId = C.AUDIO_SESSION_ID_UNSET;
@@ -726,11 +726,11 @@ public void configure(Format inputFormat, int specifiedBufferSize, @Nullable int
       inputPcmFrameSize = Util.getPcmFrameSize(inputFormat.pcmEncoding, inputFormat.channelCount);
 
       ImmutableList.Builder<AudioProcessor> pipelineProcessors = new ImmutableList.Builder<>();
-      pipelineProcessors.addAll(forPreProcessingAvailableAudioProcessors);
+      pipelineProcessors.addAll(availableAudioProcessors);
       if (shouldUseFloatOutput(inputFormat.pcmEncoding)) {
-        pipelineProcessors.addAll(toFloatPcmAvailableAudioProcessors);
+        pipelineProcessors.add(toFloatPcmAudioProcessor);
       } else {
-        pipelineProcessors.addAll(toIntPcmAvailableAudioProcessors);
+        pipelineProcessors.add(toInt16PcmAudioProcessor);
         pipelineProcessors.add(audioProcessorChain.getAudioProcessors());
       }
       audioProcessingPipeline = new AudioProcessingPipeline(pipelineProcessors.build());
@@ -1619,12 +1619,12 @@ public void flush() {
   @Override
   public void reset() {
     flush();
-    for (AudioProcessor audioProcessor : toIntPcmAvailableAudioProcessors) {
-      audioProcessor.reset();
-    }
-    for (AudioProcessor audioProcessor : toFloatPcmAvailableAudioProcessors) {
+    for (AudioProcessor audioProcessor : availableAudioProcessors) {
       audioProcessor.reset();
     }
+    toInt16PcmAudioProcessor.reset();
+    toFloatPcmAudioProcessor.reset();
+
     if (audioProcessingPipeline != null) {
       audioProcessingPipeline.reset();
     }

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

@@ -15,6 +15,7 @@
  */
 package androidx.media3.exoplayer.audio;
 
+import static androidx.media3.common.util.Util.isEncodingLinearPcm;
 import static java.lang.Math.min;
 
 import androidx.media3.common.Format;
@@ -79,7 +80,7 @@ public long getDurationAfterProcessorApplied(long durationUs) {
   @Override
   public AudioFormat onConfigure(AudioFormat inputAudioFormat)
       throws UnhandledAudioFormatException {
-    if (!Util.isEncodingLinearPcm(inputAudioFormat.encoding)) {
+    if (!isEncodingLinearPcm(inputAudioFormat.encoding)) {
       throw new UnhandledAudioFormatException(inputAudioFormat);
     }
     reconfigurationPending = true;

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/ChannelMappingAudioProcessorTest.java

@@ -92,7 +92,7 @@ public void channelMap_withPcm24Samples_mapsOutputCorrectly()
 
     processor.queueInput(createInt24ByteBuffer(new int[] {0xff0001, 0x00ff02, 0x0300ff, 0x40ff00}));
     int[] output = createInt24Array(processor.getOutput());
-    assertThat(output).isEqualTo(new int[] {0x00ff02, 0xff0001, 0x40ff00, 0x0300ff});
+    assertThat(output).isEqualTo(new int[] {0x00ff02, 0xffff0001, 0x40ff00, 0x0300ff});
   }
 
   @Test