react-native-skia-webgpu-video 0.0.0-stage → 0.1.0-beta.0

package/android/src/main/java/com/azzapp/rnskv/ReactNativeSkiaVideoPackage.java

@@ -0,0 +1,43 @@
+package com.azzapp.rnskv;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.BaseReactPackage;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ReactNativeSkiaVideoPackage extends BaseReactPackage {
+
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(ReactNativeSkiaVideoModule.NAME)) {
+      return new ReactNativeSkiaVideoModule(reactContext);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+        ReactNativeSkiaVideoModule.NAME,
+        new ReactModuleInfo(
+          ReactNativeSkiaVideoModule.NAME,
+          ReactNativeSkiaVideoModule.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          true // isTurboModule
+        ));
+      return moduleInfos;
+    };
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/ReactNativeSkiaVideoSpec.java

@@ -0,0 +1,9 @@
+package com.azzapp.rnskv;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+abstract class ReactNativeSkiaVideoSpec extends NativeReactNativeSkiaVideoSpec {
+  ReactNativeSkiaVideoSpec(ReactApplicationContext context) {
+    super(context);
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/RgbaBufferAllocator.java

@@ -0,0 +1,83 @@
+package com.azzapp.rnskv;
+import java.nio.ByteBuffer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.IntConsumer;
+import java.util.function.IntToLongFunction;
+import java.util.function.LongConsumer;
+
+/** Allocation transaction registers its budget owner before allocating any pixel storage. */
+final class RgbaBufferAllocator {
+  private final BufferLifetime lifetimes;
+  private final IntToLongFunction reserve;
+  private final LongConsumer release;
+  private final IntFunction<ByteBuffer> allocateBacking;
+  private final Function<ByteBuffer, ByteBuffer> alias;
+  private final IntConsumer checkHeap;
+  RgbaBufferAllocator(BufferLifetime lifetimes, IntToLongFunction reserve, LongConsumer release,
+      IntFunction<ByteBuffer> allocateBacking, Function<ByteBuffer, ByteBuffer> alias) {
+    this(lifetimes, reserve, release, allocateBacking, alias, size -> {});
+  }
+  RgbaBufferAllocator(BufferLifetime lifetimes, IntToLongFunction reserve, LongConsumer release,
+      IntFunction<ByteBuffer> allocateBacking, Function<ByteBuffer, ByteBuffer> alias, IntConsumer checkHeap) {
+    this.lifetimes = lifetimes; this.reserve = reserve; this.release = release;
+    this.allocateBacking = allocateBacking; this.alias = alias; this.checkHeap = checkHeap;
+  }
+
+  /** Refuse a single backing too large for ART's heap and cleanup headroom.
+   * Do not subtract currently occupied heap: allocateDirect must be allowed to
+   * trigger ART's natural GC and reclaim unreachable backing owners. A free-heap
+   * precheck would stop streaming before that GC, leaving reclaimable buffers live.
+   * The native quota and narrow allocation-OOM catch remain the actual limits. */
+  static void checkAllocationCapacity(int size, long maxHeap) {
+    if (size <= 0) throw new IllegalArgumentException("Invalid RGBA allocation size");
+    if (maxHeap <= 0) throw new IllegalStateException("Android heap capacity is unavailable");
+    long headroom = Math.min(16L * 1024 * 1024, maxHeap / 16);
+    long available = Math.max(0, maxHeap - headroom);
+    if ((long) size + 7 > available) {
+      throw new IllegalStateException("Android RGBA memory budget exceeds single-allocation Java heap capacity; "
+        + "reduce maxLongSide or use lazyDecoders (requested=" + ((long) size + 7)
+        + ", available=" + available + ", headroom=" + headroom + ")");
+    }
+  }
+
+  ByteBuffer allocate(int size) {
+    lifetimes.drain();
+    checkHeap.accept(size);
+    long token = reserve.applyAsLong(size);
+    Allocation owner;
+    try {
+      owner = new Allocation();
+      // Pre-register before the large allocation. Alias/registration failures
+      // remain accounted until this owner and its backing have been collected.
+      lifetimes.track(owner, null, token);
+    } catch (Throwable error) {
+      // No pixel backing has been allocated at this point.
+      release.accept(token);
+      throw error;
+    }
+    // Re-check any injected capacity policy after the reservation; concurrent heap
+    // use itself is handled by ART allocation/GC and the narrow OOM catch below.
+    checkHeap.accept(size);
+    try {
+      owner.backing = allocateBacking.apply(size);
+    } catch (OutOfMemoryError firstError) {
+      // ART may have queued dead JNI roots during its allocation GC. Drain them
+      // before one retry, so their backing owners can be reclaimed by that next
+      // natural allocation GC. Live aliases are not queued and remain untouched.
+      lifetimes.drain();
+      try {
+        owner.backing = allocateBacking.apply(size);
+      } catch (OutOfMemoryError finalError) {
+        // Retry only the backing allocation, once, with the same reserved owner.
+        // No alias escaped. Never return its token early while storage might live.
+        throw new IllegalStateException("Android RGBA memory budget exhausted during allocation; "
+          + "reduce maxLongSide or use lazyDecoders (requested=" + size + ", attempts=2)", finalError);
+      }
+    }
+    ByteBuffer exposed = alias.apply(owner.backing);
+    lifetimes.track(exposed, owner, 0);
+    return exposed;
+  }
+  private static final class Allocation { ByteBuffer backing; }
+}

package/android/src/main/java/com/azzapp/rnskv/RgbaLayout.java

@@ -0,0 +1,33 @@
+package com.azzapp.rnskv;
+
+/** Checked byte arithmetic shared by readback and encoder upload. */
+final class RgbaLayout {
+  private RgbaLayout() {}
+
+  static int bytesPerRow(int width) {
+    if (width <= 0 || width > Integer.MAX_VALUE / 4) {
+      throw new IllegalArgumentException("Invalid RGBA width: " + width);
+    }
+    return width * 4;
+  }
+
+  static int byteSize(int width, int height) {
+    int stride = bytesPerRow(width);
+    if (height <= 0 || height > Integer.MAX_VALUE / stride) {
+      throw new IllegalArgumentException("Invalid RGBA height: " + height);
+    }
+    return stride * height;
+  }
+
+  static int requiredBytes(int width, int height, int stride) {
+    int packedStride = bytesPerRow(width);
+    if (stride < packedStride || height <= 0) {
+      throw new IllegalArgumentException("Invalid RGBA stride or height");
+    }
+    long bytes = (long) stride * (height - 1) + packedStride;
+    if (bytes > Integer.MAX_VALUE) {
+      throw new IllegalArgumentException("RGBA upload exceeds Android ByteBuffer limits");
+    }
+    return (int) bytes;
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/SurfaceOutputPolicy.java

@@ -0,0 +1,13 @@
+package com.azzapp.rnskv;
+
+import android.media.MediaCodec;
+
+/** Surface frames can have no byte payload; an empty EOS is only a stream marker. */
+final class SurfaceOutputPolicy {
+  private SurfaceOutputPolicy() { }
+
+  static boolean hasFrame(int size, int flags) {
+    return (flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0
+      && (size > 0 || (flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) == 0);
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/TextureRenderer.java

@@ -0,0 +1,150 @@
+package com.azzapp.rnskv;
+
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+
+import java.nio.FloatBuffer;
+
+/**
+ * A class that renders a texture.
+ */
+public class TextureRenderer {
+
+  private static final String VERTEX_SHADER =
+    """
+      attribute vec4 aFramePosition;
+      attribute vec4 aTexCoords;
+      uniform mat4 uTexTransform;
+      varying vec2 vTexCoords;
+      void main() {
+      gl_Position = aFramePosition;
+        vTexCoords = (uTexTransform * aTexCoords).xy;
+      }
+    """;
+
+  private static final String FRAGMENT_SHADER =
+    """
+      precision highp float;
+      uniform sampler2D uTexSampler;
+      varying vec2 vTexCoords;
+      void main() {
+        gl_FragColor = texture2D(uTexSampler, vTexCoords);
+      }
+    """;
+
+  private static final String FRAGMENT_SHADER_EXTERNAL =
+    """
+      #extension GL_OES_EGL_image_external : require
+      precision highp float;
+      uniform samplerExternalOES uTexSampler;
+      varying vec2 vTexCoords;
+      void main() {
+        gl_FragColor = texture2D(uTexSampler, vTexCoords);
+      }
+    """;
+
+  private static final FloatBuffer POS_VERTICES = EGLUtils.createFloatBuffer(
+    -1f, -1f, 0f, 1f,
+    1f, -1f, 0f, 1f,
+    -1f, 1f, 0f, 1f,
+    1f, 1f, 0f, 1f
+  );
+
+  private static final FloatBuffer TEX_VERTICES = EGLUtils.createFloatBuffer(
+    0f, 1f, 0f, 1f,
+    1f, 1f, 0f, 1f,
+    0f, 0f, 0f, 1f,
+    1f, 0f, 0f, 1f
+  );
+
+  private final int program;
+
+  private final int aFramePositionLoc;
+
+  private final int aTexCoordsLoc;
+
+  private final int uTexTransformLoc;
+
+  private final int uTexSamplerLoc;
+
+  boolean external = false;
+
+
+  public TextureRenderer() {
+    this(false);
+  }
+
+  /**
+   * Create a new TextureRenderer.
+   */
+  public TextureRenderer(boolean external) {
+    this.external = external;
+    program = EGLUtils.createProgram(
+      VERTEX_SHADER,
+      external ? FRAGMENT_SHADER_EXTERNAL : FRAGMENT_SHADER
+    );
+
+    aFramePositionLoc = GLES20.glGetAttribLocation(
+      program,
+      "aFramePosition"
+    );
+    aTexCoordsLoc = GLES20.glGetAttribLocation(
+      program,
+      "aTexCoords"
+    );
+    uTexTransformLoc = GLES20.glGetUniformLocation(
+      program,
+      "uTexTransform"
+    );
+
+    uTexSamplerLoc = GLES20.glGetUniformLocation(
+      program,
+      "uTexSampler"
+    );
+  }
+
+  /**
+   * Draw the texture.
+   *
+   * @param textureId       the texture to draw
+   * @param transformMatrix the texture transform matrix to apply
+   *                        (usually the texture matrix from a SurfaceTexture)
+   */
+  public void draw(
+    int textureId,
+    float[] transformMatrix
+  ) {
+    GLES20.glUseProgram(program);
+
+    GLES20.glEnableVertexAttribArray(aFramePositionLoc);
+    GLES20.glVertexAttribPointer(
+      aFramePositionLoc, 4, GLES20.GL_FLOAT, false, 0,
+      POS_VERTICES
+    );
+
+    GLES20.glEnableVertexAttribArray(aTexCoordsLoc);
+    GLES20.glVertexAttribPointer(
+      aTexCoordsLoc, 4, GLES20.GL_FLOAT, false, 0,
+      TEX_VERTICES
+    );
+
+    GLES20.glUniformMatrix4fv(uTexTransformLoc, 1, false, transformMatrix, 0);
+
+    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+    GLES20.glBindTexture(
+      external ? GLES11Ext.GL_TEXTURE_EXTERNAL_OES : GLES20.GL_TEXTURE_2D, textureId);
+    GLES20.glUniform1i(uTexSamplerLoc, 0);
+
+    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+    GLES20.glDisableVertexAttribArray(aFramePositionLoc);
+    GLES20.glDisableVertexAttribArray(aTexCoordsLoc);
+  }
+
+  /**
+   * Release the resources. (delete the program)
+   */
+  public void release() {
+    GLES20.glDeleteProgram(program);
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/TimeHelpers.java

@@ -0,0 +1,11 @@
+package com.azzapp.rnskv;
+
+public class TimeHelpers {
+  public static long secToUs(double sec) {
+    return Math.round(sec * 1000000);
+  }
+
+  public static long nsecToUs(long nsec) {
+    return Math.round(nsec / 1000);
+  }
+}

package/android/src/main/java/com/azzapp/rnskv/VideoCapabilities.java

@@ -0,0 +1,354 @@
+package com.azzapp.rnskv;
+
+import android.media.MediaCodec;
+import android.media.MediaCodecInfo;
+import android.media.MediaCodecList;
+import android.media.MediaFormat;
+import android.os.Build;
+import android.util.Log;
+import android.util.Range;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class VideoCapabilities {
+
+  public static class DecoderInfo {
+    private int maxInstances;
+    private int maxWidth;
+    private int maxHeight;
+
+    public DecoderInfo(int maxInstances, int maxWidth, int maxHeight) {
+      this.maxInstances = maxInstances;
+      this.maxWidth = maxWidth;
+      this.maxHeight = maxHeight;
+    }
+
+    public int getMaxInstances() {
+      return maxInstances;
+    }
+
+    public int getMaxWidth() {
+      return maxWidth;
+    }
+
+    public int getMaxHeight() {
+      return maxHeight;
+    }
+  }
+
+
+  public static DecoderInfo getDecodingCapabilitiesFor(String mimeType) {
+    MediaCodecList codecList = new MediaCodecList(MediaCodecList.ALL_CODECS);
+    MediaCodecInfo[] codecInfos = codecList.getCodecInfos();
+
+    for (MediaCodecInfo codecInfo : codecInfos) {
+      if (codecInfo.isEncoder()) {
+        // Decoding capabilities: only decoders are relevant here.
+        continue;
+      }
+      MediaCodecInfo.CodecCapabilities capabilities;
+      try {
+        capabilities = codecInfo.getCapabilitiesForType(mimeType);
+      } catch (IllegalArgumentException e) {
+        continue;
+      }
+      if (capabilities != null) {
+        MediaCodecInfo.VideoCapabilities videoCapabilities = capabilities.getVideoCapabilities();
+        if (videoCapabilities != null) {
+          int maxInstances = capabilities.getMaxSupportedInstances();
+          int maxWidth = videoCapabilities.getSupportedWidths().getUpper();
+          int maxHeight = videoCapabilities.getSupportedHeights().getUpper();
+          return new DecoderInfo(maxInstances, maxWidth, maxHeight);
+        }
+      }
+    }
+    return null;
+  }
+
+
+  public static class EncoderInfo {
+    private final String encoderName;
+
+    private final boolean hardwareAccelerated;
+
+    private final int width;
+
+    private final int height;
+
+    private final int frameRate;
+
+    private final int bitrate;
+
+    public EncoderInfo(
+      String encoderName,
+      boolean hardWareAccelerated,
+      int width,
+      int height,
+      int frameRate,
+      int bitrate
+    ) {
+      this.encoderName = encoderName;
+      this.hardwareAccelerated = hardWareAccelerated;
+      this.width = width;
+      this.height = height;
+      this.frameRate = frameRate;
+      this.bitrate = bitrate;
+    }
+
+    public String getEncoderName() {
+      return encoderName;
+    }
+
+    public boolean getHardwareAccelerated() {
+      return hardwareAccelerated;
+    }
+
+    public int getWidth() {
+      return width;
+    }
+
+    public int getHeight() {
+      return height;
+    }
+
+    public int getFrameRate() {
+      return frameRate;
+    }
+
+    public int getBitrate() {
+      return bitrate;
+    }
+  }
+
+  /**
+   * Returns the configurations the platform encoders will actually accept,
+   * closest to the requested one.
+   *
+   * @param width     the requested width
+   * @param height    the requested height
+   * @param frameRate the requested frame rate in frames per second
+   * @param bitRate   the requested bit rate in bits per second
+   * @param codec     the codec to probe encoders for, "h264" or "hevc"; null
+   *                  means H.264. A codec the device cannot encode falls back
+   *                  to H.264, so the answer always describes the codec an
+   *                  export with the same argument would really use.
+   * @return the valid configurations, empty if none were found
+   */
+  public static List<EncoderInfo> getValidEncoderConfigurations(
+    int width,
+    int height,
+    int frameRate,
+    int bitRate,
+    String codec
+  ) {
+    List<EncoderInfo> encoderInfos = new ArrayList<>();
+
+    // Probed with the mime type the export will encode with: sizes, frame rates
+    // and bitrates accepted by an H.264 encoder say nothing about what the HEVC
+    // one on the same chip will take.
+    String mimeType = VideoEncoder.resolveMimeType(codec);
+
+    boolean rotated = height > width;
+
+    List<MediaCodecInfoWithOverrides> mediaCodecInfoWithOverrides =
+      getPotentialEncoders(mimeType,
+        rotated ? height : width, rotated ? width : height,
+        frameRate, bitRate);
+
+    for (MediaCodecInfoWithOverrides codecInfoWithOverrides : mediaCodecInfoWithOverrides) {
+      MediaFormat format;
+      if (rotated) {
+        format = MediaFormat.createVideoFormat(mimeType,
+          codecInfoWithOverrides.height, codecInfoWithOverrides.width);
+      } else {
+        format = MediaFormat.createVideoFormat(mimeType,
+          codecInfoWithOverrides.width, codecInfoWithOverrides.height);
+      }
+      format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
+        MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
+      format.setInteger(MediaFormat.KEY_BIT_RATE, codecInfoWithOverrides.bitrate);
+      format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, VideoEncoder.DEFAULT_I_FRAME_INTERVAL_SECONDS);
+
+      // While framerate can be marked as supported it can in fact not be the case
+      // so we need to create the codec to see if there is no error and progressively decrease the frame rate
+      int foundFrameRate = codecInfoWithOverrides.frameRate;
+      while (true) {
+        MediaCodec encoder = null;
+        format.setInteger(MediaFormat.KEY_FRAME_RATE, foundFrameRate);
+        try {
+          encoder = MediaCodec.createByCodecName(codecInfoWithOverrides.codecInfo.getName());
+          encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+        } catch (Exception e) {
+          if (encoder != null) {
+            encoder = null;
+          }
+        }
+        if (encoder != null) {
+          encoder.release();
+          encoderInfos.add(new EncoderInfo(
+            codecInfoWithOverrides.codecInfo.getName(),
+            codecInfoWithOverrides.hardwareAccelerated == 1,
+            rotated ? codecInfoWithOverrides.height : codecInfoWithOverrides.width,
+            rotated ? codecInfoWithOverrides.width : codecInfoWithOverrides.height,
+            foundFrameRate,
+            codecInfoWithOverrides.bitrate
+          ));
+          break;
+        } else if (foundFrameRate > 45) {
+          foundFrameRate = 45;
+        } else if (foundFrameRate > 30) {
+          foundFrameRate = 30;
+        } else {
+          break;
+        }
+      }
+    }
+    return encoderInfos;
+  }
+
+  private record MediaCodecInfoWithOverrides(
+    MediaCodecInfo codecInfo,
+    int width,
+    int height,
+    int bitrate,
+    int frameRate,
+
+    int hardwareAccelerated,
+    int aspectRatioOverride,
+    int resolutionOverride,
+    int frameRateOverride,
+    int bitrateOverride
+  ) {
+  }
+
+
+  private static List<MediaCodecInfoWithOverrides> getPotentialEncoders(
+    String mimeType,
+    int width,
+    int height,
+    int frameRate,
+    int bitrate
+  ) {
+
+    MediaCodecList codecList = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+    MediaCodecInfo[] codecInfos = codecList.getCodecInfos();
+
+    List<MediaCodecInfoWithOverrides> codecInfoWithOverrides = new ArrayList<>();
+
+    for (MediaCodecInfo codecInfo : codecInfos) {
+      if (!codecInfo.isEncoder()) {
+        continue;
+      }
+
+      MediaCodecInfo.CodecCapabilities capabilities;
+      try {
+        capabilities = codecInfo.getCapabilitiesForType(mimeType);
+      } catch (IllegalArgumentException e) {
+        continue;
+      }
+
+      MediaCodecInfo.VideoCapabilities videoCapabilities = capabilities.getVideoCapabilities();
+
+      // Initialize with the original parameters
+      int currentWidth = width;
+      int currentHeight = height;
+      int currentBitrate = bitrate;
+      int currentFrameRate = frameRate;
+      int resolutionOverride = 0;
+      int aspectRatioOverride = 0;
+      int frameRateOverride = 0;
+      int bitrateOverride = 0;
+      int hardwareAccelerated = isHardwareAccelerated(codecInfo) ? 1 : 0;
+
+      float aspectRatio = (float) width / height;
+
+      if (!videoCapabilities.isSizeSupported(width, height)) {
+        Range<Integer> supportedWidths = videoCapabilities.getSupportedWidths();
+        int resizedWidth = supportedWidths.clamp(currentWidth);
+        int resizedWidthHeight = Math.round(resizedWidth / aspectRatio);
+        resizedWidthHeight = resizedWidthHeight - resizedWidthHeight % 2;
+        int potentialInvalidHeight = videoCapabilities.getSupportedHeightsFor(resizedWidth)
+          .clamp(resizedWidthHeight);
+        float potentialWidthBasedAspectRatioOverrides =
+          Math.abs(aspectRatio - (float) resizedWidth / potentialInvalidHeight);
+
+        Range<Integer> supportedHeights = videoCapabilities.getSupportedHeights();
+        int resizedHeight = supportedHeights.clamp(currentHeight);
+        int resizedHeightWidth = Math.round(resizedHeight * aspectRatio);
+        resizedHeightWidth = resizedHeightWidth - resizedHeightWidth % 2;
+        int potentialInvalidWidth = videoCapabilities.getSupportedWidthsFor(resizedHeight)
+          .clamp(resizedHeightWidth);
+        float potentialHeightBasedAspectRatioOverrides =
+          Math.abs(aspectRatio - (float) potentialInvalidWidth / resizedHeight);
+
+        if (videoCapabilities.isSizeSupported(resizedWidth, resizedWidthHeight)) {
+          currentWidth = resizedWidth;
+          currentHeight = resizedWidthHeight;
+        } else if (videoCapabilities.isSizeSupported(resizedHeightWidth, resizedHeight)) {
+          currentWidth = resizedHeightWidth;
+          currentHeight = resizedHeight;
+        } else if (potentialWidthBasedAspectRatioOverrides < 0.001 || potentialHeightBasedAspectRatioOverrides < 0.001) {
+          // Slight aspect ratio overrides might be acceptable in some cases
+          if (potentialWidthBasedAspectRatioOverrides < potentialHeightBasedAspectRatioOverrides) {
+            currentWidth = resizedWidth;
+            currentHeight = potentialInvalidHeight;
+          } else {
+            currentWidth = potentialInvalidWidth;
+            currentHeight = resizedHeight;
+          }
+          aspectRatioOverride = 1;
+        } else {
+          continue;
+        }
+        resolutionOverride = 1;
+      }
+
+      if (!videoCapabilities.areSizeAndRateSupported(currentWidth, currentHeight, currentFrameRate)) {
+        Range<Double> frameRateRange = videoCapabilities.getSupportedFrameRatesFor(currentWidth, currentHeight);
+        currentFrameRate = (int) Math.floor(frameRateRange.clamp((double) currentFrameRate));
+        frameRateOverride = 1;
+      }
+
+      if (!videoCapabilities.getBitrateRange().contains(currentBitrate)) {
+        Range<Integer> bitrateRange = videoCapabilities.getBitrateRange();
+        currentBitrate = bitrateRange.clamp(currentBitrate);
+        bitrateOverride = 1;
+      }
+
+      codecInfoWithOverrides.add(new MediaCodecInfoWithOverrides(
+        codecInfo,
+        currentWidth,
+        currentHeight,
+        currentBitrate,
+        currentFrameRate,
+        hardwareAccelerated,
+        aspectRatioOverride,
+        resolutionOverride,
+        frameRateOverride,
+        bitrateOverride
+      ));
+    }
+
+    // Sort the list based on resolution, frame rate, and bitrate overrides
+    codecInfoWithOverrides.sort(Comparator
+      .comparingInt(MediaCodecInfoWithOverrides::aspectRatioOverride)
+      .thenComparingInt(MediaCodecInfoWithOverrides::hardwareAccelerated).reversed()
+      .thenComparingInt(MediaCodecInfoWithOverrides::resolutionOverride)
+      .thenComparingInt(MediaCodecInfoWithOverrides::frameRateOverride)
+      .thenComparingInt(MediaCodecInfoWithOverrides::bitrateOverride));
+
+    return codecInfoWithOverrides;
+  }
+
+  private static boolean isHardwareAccelerated(MediaCodecInfo codecInfo) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      return codecInfo.isHardwareAccelerated();
+    } else {
+      // Use heuristics for older Android versions
+      String name = codecInfo.getName().toLowerCase();
+      return name.contains("qcom") || name.contains("intel") || name.contains("nvidia") || name.contains("mtk");
+    }
+  }
+}