Add AVI extraction support

library/common/src/main/java/com/google/android/exoplayer2/util/FileTypes.java

@@ -38,7 +38,7 @@ public final class FileTypes {
   @Documented
   @Retention(RetentionPolicy.SOURCE)
   @IntDef({
-    UNKNOWN, AC3, AC4, ADTS, AMR, FLAC, FLV, MATROSKA, MP3, MP4, OGG, PS, TS, WAV, WEBVTT, JPEG
+    UNKNOWN, AC3, AC4, ADTS, AMR, FLAC, FLV, MATROSKA, MP3, MP4, OGG, PS, TS, WAV, WEBVTT, JPEG, AVI
   })
   public @interface Type {}
   /** Unknown file type. */
@@ -73,6 +73,8 @@ public final class FileTypes {
   public static final int WEBVTT = 13;
   /** File type for the JPEG format. */
   public static final int JPEG = 14;
+  /** File type for the AVI format. */
+  public static final int AVI = 15;
 
   @VisibleForTesting /* package */ static final String HEADER_CONTENT_TYPE = "Content-Type";
 
@@ -105,6 +107,7 @@ public final class FileTypes {
   private static final String EXTENSION_WEBVTT = ".webvtt";
   private static final String EXTENSION_JPG = ".jpg";
   private static final String EXTENSION_JPEG = ".jpeg";
+  private static final String EXTENSION_AVI = ".avi";
 
   private FileTypes() {}
 
@@ -167,6 +170,8 @@ public static int inferFileTypeFromMimeType(@Nullable String mimeType) {
         return FileTypes.WEBVTT;
       case MimeTypes.IMAGE_JPEG:
         return FileTypes.JPEG;
+      case MimeTypes.VIDEO_AVI:
+        return FileTypes.AVI;
       default:
         return FileTypes.UNKNOWN;
     }
@@ -229,6 +234,8 @@ public static int inferFileTypeFromUri(Uri uri) {
       return FileTypes.WEBVTT;
     } else if (filename.endsWith(EXTENSION_JPG) || filename.endsWith(EXTENSION_JPEG)) {
       return FileTypes.JPEG;
+    } else if (filename.endsWith(EXTENSION_AVI)) {
+      return FileTypes.AVI;
     } else {
       return FileTypes.UNKNOWN;
     }

library/common/src/main/java/com/google/android/exoplayer2/util/MimeTypes.java

@@ -54,6 +54,10 @@ public final class MimeTypes {
   public static final String VIDEO_FLV = BASE_TYPE_VIDEO + "/x-flv";
   public static final String VIDEO_DOLBY_VISION = BASE_TYPE_VIDEO + "/dolby-vision";
   public static final String VIDEO_OGG = BASE_TYPE_VIDEO + "/ogg";
+  public static final String VIDEO_AVI = BASE_TYPE_VIDEO + "/x-msvideo";
+  public static final String VIDEO_MJPEG = BASE_TYPE_VIDEO + "/mjpeg";
+  public static final String VIDEO_MP42 = BASE_TYPE_VIDEO + "/mp42";
+  public static final String VIDEO_MP43 = BASE_TYPE_VIDEO + "/mp43";
   public static final String VIDEO_UNKNOWN = BASE_TYPE_VIDEO + "/x-unknown";
 
   // audio/ MIME types

library/extractor/build.gradle

@@ -19,7 +19,6 @@ android {
             testCoverageEnabled = true
         }
     }
-
     sourceSets.test.assets.srcDir '../../testdata/src/test/assets/'
 }
 

library/extractor/src/main/java/com/google/android/exoplayer2/extractor/DefaultExtractorsFactory.java

@@ -24,6 +24,7 @@
 import com.google.android.exoplayer2.PlaybackException;
 import com.google.android.exoplayer2.Player;
 import com.google.android.exoplayer2.extractor.amr.AmrExtractor;
+import com.google.android.exoplayer2.extractor.avi.AviExtractor;
 import com.google.android.exoplayer2.extractor.flac.FlacExtractor;
 import com.google.android.exoplayer2.extractor.flv.FlvExtractor;
 import com.google.android.exoplayer2.extractor.jpeg.JpegExtractor;
@@ -97,6 +98,7 @@ public final class DefaultExtractorsFactory implements ExtractorsFactory {
         FileTypes.ADTS,
         FileTypes.AC3,
         FileTypes.AC4,
+        FileTypes.AVI,
         FileTypes.MP3,
         FileTypes.JPEG,
       };
@@ -300,7 +302,7 @@ public synchronized Extractor[] createExtractors() {
   @Override
   public synchronized Extractor[] createExtractors(
       Uri uri, Map<String, List<String>> responseHeaders) {
-    List<Extractor> extractors = new ArrayList<>(/* initialCapacity= */ 14);
+    List<Extractor> extractors = new ArrayList<>(/* initialCapacity= */ 15);
 
     @FileTypes.Type
     int responseHeadersInferredFileType = inferFileTypeFromResponseHeaders(responseHeaders);
@@ -397,6 +399,9 @@ private void addExtractorsForFileType(@FileTypes.Type int fileType, List<Extract
       case FileTypes.JPEG:
         extractors.add(new JpegExtractor());
         break;
+      case FileTypes.AVI:
+        extractors.add(new AviExtractor());
+        break;
       case FileTypes.WEBVTT:
       case FileTypes.UNKNOWN:
       default:

library/extractor/src/main/java/com/google/android/exoplayer2/extractor/avi/AudioFormat.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 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 com.google.android.exoplayer2.extractor.avi;
+
+import android.util.SparseArray;
+import com.google.android.exoplayer2.util.MimeTypes;
+import java.nio.ByteBuffer;
+
+/**
+ * Wrapper for the WAVEFORMATEX structure
+ */
+public class AudioFormat {
+  private static final SparseArray<String> FORMAT_MAP = new SparseArray<>();
+  static {
+    FORMAT_MAP.put(0x1, MimeTypes.AUDIO_RAW);    // WAVE_FORMAT_PCM
+    FORMAT_MAP.put(0x55, MimeTypes.AUDIO_MPEG);  // WAVE_FORMAT_MPEGLAYER3
+    FORMAT_MAP.put(0xff, MimeTypes.AUDIO_AAC);   // WAVE_FORMAT_AAC
+    FORMAT_MAP.put(0x2000, MimeTypes.AUDIO_AC3); // WAVE_FORMAT_DVM - AC3
+    FORMAT_MAP.put(0x2001, MimeTypes.AUDIO_DTS); // WAVE_FORMAT_DTS2
+  }
+
+  private final ByteBuffer byteBuffer;
+
+  public AudioFormat(ByteBuffer byteBuffer) {
+    this.byteBuffer = byteBuffer;
+  }
+
+  public String getMimeType() {
+    return FORMAT_MAP.get(getFormatTag() & 0xffff);
+  }
+
+  public short getFormatTag() {
+    return byteBuffer.getShort(0);
+  }
+  public short getChannels() {
+    return byteBuffer.getShort(2);
+  }
+  public int getSamplesPerSecond() {
+    return byteBuffer.getInt(4);
+  }
+  public int getAvgBytesPerSec() {
+    return byteBuffer.getInt(8);
+  }
+  // 12 - nBlockAlign
+  public short getBitsPerSample() {
+    return byteBuffer.getShort(14);
+  }
+  public int getCbSize() {
+    return byteBuffer.getShort(16) & 0xffff;
+  }
+  public byte[] getCodecData() {
+    final int size = getCbSize();
+    final ByteBuffer temp = byteBuffer.duplicate();
+    temp.clear();
+    temp.position(18);
+    temp.limit(18 + size);
+    final byte[] data = new byte[size];
+    temp.get(data);
+    return data;
+  }
+}

library/extractor/src/main/java/com/google/android/exoplayer2/extractor/avi/AvcChunkHandler.java

@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 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 com.google.android.exoplayer2.extractor.avi;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.exoplayer2.Format;
+import com.google.android.exoplayer2.extractor.ExtractorInput;
+import com.google.android.exoplayer2.extractor.TrackOutput;
+import com.google.android.exoplayer2.util.NalUnitUtil;
+import com.google.android.exoplayer2.util.ParsableNalUnitBitArray;
+import java.io.IOException;
+
+/**
+ * Corrects the time and PAR for H264 streams
+ * AVC is very rare in AVI due to the rise of the mp4 container
+ */
+public class AvcChunkHandler extends NalChunkHandler {
+  private static final int NAL_TYPE_MASK = 0x1f;
+  private static final int NAL_TYPE_IDR = 5; //I Frame
+  private static final int NAL_TYPE_SEI = 6;
+  private static final int NAL_TYPE_SPS = 7;
+  private static final int NAL_TYPE_PPS = 8;
+  private static final int NAL_TYPE_AUD = 9;
+
+  private final Format.Builder formatBuilder;
+
+  private float pixelWidthHeightRatio = 1f;
+  private NalUnitUtil.SpsData spsData;
+
+  public AvcChunkHandler(int id, @NonNull TrackOutput trackOutput,
+      @NonNull ChunkClock clock, Format.Builder formatBuilder) {
+    super(id, trackOutput, clock, 16);
+    this.formatBuilder = formatBuilder;
+  }
+
+  @Nullable
+  @VisibleForTesting
+  PicCountClock getPicCountClock() {
+    if (clock instanceof PicCountClock) {
+      return (PicCountClock)clock;
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  boolean skip(byte nalType) {
+    if (clock instanceof PicCountClock) {
+      return false;
+    } else {
+      //If the clock is ChunkClock, skip "normal" frames
+      return nalType >= 0 && nalType <= NAL_TYPE_IDR;
+    }
+  }
+
+  /**
+   * Greatly simplified way to calculate the picOrder
+   * Full logic is here
+   * https://chromium.googlesource.com/chromium/src/media/+/refs/heads/main/video/h264_poc.cc
+   */
+  void updatePicCountClock(final int nalTypeOffset, final PicCountClock picCountClock) {
+    final ParsableNalUnitBitArray in = new ParsableNalUnitBitArray(buffer, nalTypeOffset + 1, buffer.length);
+    //slide_header()
+    in.readUnsignedExpGolombCodedInt(); //first_mb_in_slice
+    in.readUnsignedExpGolombCodedInt(); //slice_type
+    in.readUnsignedExpGolombCodedInt(); //pic_parameter_set_id
+    if (spsData.separateColorPlaneFlag) {
+      in.skipBits(2); //colour_plane_id
+    }
+    final int frameNum = in.readBits(spsData.frameNumLength); //frame_num
+    if (!spsData.frameMbsOnlyFlag) {
+      boolean field_pic_flag = in.readBit(); // field_pic_flag
+      if (field_pic_flag) {
+        in.readBit(); // bottom_field_flag
+      }
+    }
+    //We skip IDR in the switch
+    if (spsData.picOrderCountType == 0) {
+      int picOrderCountLsb = in.readBits(spsData.picOrderCntLsbLength);
+      picCountClock.setPicCount(picOrderCountLsb);
+      return;
+    } else if (spsData.picOrderCountType == 2) {
+      picCountClock.setPicCount(frameNum);
+      return;
+    }
+    clock.setIndex(clock.getIndex());
+  }
+
+  @VisibleForTesting
+  int readSps(ExtractorInput input, int nalTypeOffset) throws IOException {
+    final int spsStart = nalTypeOffset + 1;
+    nalTypeOffset = seekNextNal(input, spsStart);
+    spsData = NalUnitUtil.parseSpsNalUnitPayload(buffer, spsStart, pos);
+    //If we can have B Frames, upgrade to PicCountClock
+    final PicCountClock picCountClock;
+    if (spsData.maxNumRefFrames > 1 && !(clock instanceof PicCountClock)) {
+      picCountClock = new PicCountClock(clock.durationUs, clock.chunks);
+      picCountClock.setIndex(clock.getIndex());
+      clock = picCountClock;
+    } else {
+      picCountClock = getPicCountClock();
+    }
+    if (picCountClock != null) {
+      if (spsData.picOrderCountType == 0) {
+        picCountClock.setMaxPicCount(1 << spsData.picOrderCntLsbLength, 2);
+      } else if (spsData.picOrderCountType == 2) {
+        //Plus one because we double the frame number
+        picCountClock.setMaxPicCount(1 << spsData.frameNumLength, 1);
+      }
+    }
+    if (spsData.pixelWidthHeightRatio != pixelWidthHeightRatio) {
+      pixelWidthHeightRatio = spsData.pixelWidthHeightRatio;
+      formatBuilder.setPixelWidthHeightRatio(pixelWidthHeightRatio);
+      trackOutput.format(formatBuilder.build());
+    }
+    return nalTypeOffset;
+  }
+
+  @Override
+  void processChunk(ExtractorInput input, int nalTypeOffset) throws IOException {
+    while (true) {
+      final int nalType = buffer[nalTypeOffset] & NAL_TYPE_MASK;
+      switch (nalType) {
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+          if (clock instanceof PicCountClock) {
+            updatePicCountClock(nalTypeOffset, (PicCountClock)clock);
+          }
+          return;
+        case NAL_TYPE_IDR: {
+          final PicCountClock picCountClock = getPicCountClock();
+          if (picCountClock != null) {
+            picCountClock.syncIndexes();
+          }
+          return;
+        }
+        case NAL_TYPE_AUD:
+        case NAL_TYPE_SEI:
+        case NAL_TYPE_PPS: {
+          nalTypeOffset = seekNextNal(input, nalTypeOffset);
+          //Usually chunks have other NALs after these, so just continue
+          break;
+        }
+        case NAL_TYPE_SPS:
+          nalTypeOffset = readSps(input, nalTypeOffset);
+          //Sometimes video frames lurk after these
+          break;
+        default:
+          return;
+      }
+      if (nalTypeOffset < 0) {
+        return;
+      }
+      compact();
+    }
+  }
+
+  @VisibleForTesting(otherwise = VisibleForTesting.NONE)
+  public NalUnitUtil.SpsData getSpsData() {
+    return spsData;
+  }
+}