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

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,114 @@
+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;
+  private final Runnable reclaim;
+  /** Collections asked for when the native budget refuses a reservation. */
+  static final int RECLAIM_ATTEMPTS = 3;
+  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, reserve, release, allocateBacking, alias, checkHeap, () -> {});
+  }
+  RgbaBufferAllocator(BufferLifetime lifetimes, IntToLongFunction reserve, LongConsumer release,
+      IntFunction<ByteBuffer> allocateBacking, Function<ByteBuffer, ByteBuffer> alias, IntConsumer checkHeap,
+      Runnable reclaim) {
+    this.lifetimes = lifetimes; this.reserve = reserve; this.release = release;
+    this.allocateBacking = allocateBacking; this.alias = alias; this.checkHeap = checkHeap;
+    this.reclaim = reclaim;
+  }
+
+  /** 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 = reserveReclaiming(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;
+  }
+  /** A buffer holds its reservation until the GC finds it unreachable. A fast
+   * decode drops a frame per vsync, 8 MB each in 1080p, and those dead buffers
+   * filled the native budget before the Java heap asked for a collection: the
+   * budget refused frames nobody held. Refused while buffers are tracked, the
+   * reservation is retried after a collection has returned theirs. */
+  private long reserveReclaiming(int size) {
+    try {
+      return reserve.applyAsLong(size);
+    } catch (RuntimeException refused) {
+      RuntimeException last = refused;
+      for (int attempt = 0; attempt < RECLAIM_ATTEMPTS && lifetimes.trackedCount() > 0; attempt++) {
+        reclaim.run();
+        lifetimes.drain();
+        try {
+          return reserve.applyAsLong(size);
+        } catch (RuntimeException again) {
+          last = again;
+        }
+      }
+      throw last;
+    }
+  }
+  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);
+  }
+}