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

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

@@ -0,0 +1,132 @@
+package com.azzapp.rnskv;
+
+import android.opengl.EGL14;
+import android.opengl.EGLExt;
+import android.view.Surface;
+
+import java.util.function.Supplier;
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.egl.EGLSurface;
+
+/** A session-owned EGL context. The display is process-owned and is never terminated here. */
+public final class EGLResourcesHolder {
+  private final EGL10 egl;
+  private final EGLDisplay display;
+  private final EGLContext context;
+  private final EGLSurface surface;
+  private boolean released;
+
+  public static EGLResourcesHolder createWithWindowedSurface(EGLContext sharedContext, Surface surface) {
+    return create(sharedContext, surface);
+  }
+
+  public static EGLResourcesHolder createWithPBBufferSurface(EGLContext sharedContext) {
+    return create(sharedContext, null);
+  }
+
+  private static EGLResourcesHolder create(EGLContext sharedContext, Surface window) {
+    EGL10 egl = (EGL10) EGLContext.getEGL();
+    EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+    if (display == EGL10.EGL_NO_DISPLAY || !egl.eglInitialize(display, new int[2])) {
+      throw new IllegalStateException("Could not initialize the video EGL display");
+    }
+    EGLContext context = EGL10.EGL_NO_CONTEXT;
+    EGLSurface surface = EGL10.EGL_NO_SURFACE;
+    try {
+      int[] attributes = window == null ? new int[]{
+        EGL10.EGL_RED_SIZE, 8, EGL10.EGL_GREEN_SIZE, 8, EGL10.EGL_BLUE_SIZE, 8,
+        EGL10.EGL_ALPHA_SIZE, 8, EGL10.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
+        EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT, EGL10.EGL_NONE
+      } : new int[]{
+        EGL10.EGL_RED_SIZE, 8, EGL10.EGL_GREEN_SIZE, 8, EGL10.EGL_BLUE_SIZE, 8,
+        EGL10.EGL_ALPHA_SIZE, 8, EGL10.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
+        EGL10.EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT,
+        EGLUtils.EGL_RECORDABLE_ANDROID, 1, EGL10.EGL_NONE
+      };
+      EGLConfig[] configs = new EGLConfig[1];
+      int[] count = new int[1];
+      if (!egl.eglChooseConfig(display, attributes, configs, 1, count) || count[0] == 0) {
+        throw new IllegalStateException("No video EGL config found");
+      }
+      context = egl.eglCreateContext(display, configs[0], sharedContext,
+        new int[]{EGLUtils.EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE});
+      if (context == EGL10.EGL_NO_CONTEXT) {
+        throw new IllegalStateException("Could not create video EGL context");
+      }
+      surface = window == null
+        ? egl.eglCreatePbufferSurface(display, configs[0],
+          new int[]{EGL10.EGL_WIDTH, 1, EGL10.EGL_HEIGHT, 1, EGL10.EGL_NONE})
+        : egl.eglCreateWindowSurface(display, configs[0], window, new int[]{EGL10.EGL_NONE});
+      if (surface == EGL10.EGL_NO_SURFACE) {
+        throw new IllegalStateException("Could not create video EGL surface");
+      }
+      return new EGLResourcesHolder(egl, display, context, surface);
+    } catch (RuntimeException error) {
+      if (surface != EGL10.EGL_NO_SURFACE) egl.eglDestroySurface(display, surface);
+      if (context != EGL10.EGL_NO_CONTEXT) egl.eglDestroyContext(display, context);
+      throw error;
+    }
+  }
+
+  private EGLResourcesHolder(EGL10 egl, EGLDisplay display, EGLContext context, EGLSurface surface) {
+    this.egl = egl;
+    this.display = display;
+    this.context = context;
+    this.surface = surface;
+  }
+
+  public boolean makeCurrent() {
+    if (released || !egl.eglMakeCurrent(display, surface, surface, context)) {
+      throw new IllegalStateException("Could not bind video EGL context");
+    }
+    return true;
+  }
+
+  /** Always detach our context before returning, including when the caller has no EGL context. */
+  public <T> T withContextCurrent(Supplier<T> action) {
+    android.opengl.EGLDisplay previousDisplay = EGL14.eglGetCurrentDisplay();
+    android.opengl.EGLContext previousContext = EGL14.eglGetCurrentContext();
+    android.opengl.EGLSurface previousDraw = EGL14.eglGetCurrentSurface(EGL14.EGL_DRAW);
+    android.opengl.EGLSurface previousRead = EGL14.eglGetCurrentSurface(EGL14.EGL_READ);
+    makeCurrent();
+    try {
+      return action.get();
+    } finally {
+      if (!EGL14.EGL_NO_CONTEXT.equals(previousContext)) {
+        if (!EGL14.eglMakeCurrent(previousDisplay, previousDraw, previousRead, previousContext)) {
+          throw new IllegalStateException("Could not restore the caller's EGL context");
+        }
+      } else if (!egl.eglMakeCurrent(display, EGL10.EGL_NO_SURFACE,
+          EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT)) {
+        throw new IllegalStateException("Could not detach video EGL context");
+      }
+    }
+  }
+
+  public void runWithContextCurrent(Runnable action) {
+    withContextCurrent(() -> { action.run(); return null; });
+  }
+
+  public boolean swapBuffers() { return egl.eglSwapBuffers(display, surface); }
+
+  public void setPresentationTime(long nanoseconds) {
+    if (!EGLExt.eglPresentationTimeANDROID(EGL14.eglGetCurrentDisplay(),
+        EGL14.eglGetCurrentSurface(EGL14.EGL_DRAW), nanoseconds)) {
+      throw new IllegalStateException("Could not timestamp video encoder surface");
+    }
+  }
+
+  public void release() {
+    if (released) return;
+    if (egl.eglGetCurrentContext().equals(context)) {
+      egl.eglMakeCurrent(display, EGL10.EGL_NO_SURFACE,
+        EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
+    }
+    egl.eglDestroySurface(display, surface);
+    egl.eglDestroyContext(display, context);
+    released = true;
+  }
+}

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

@@ -0,0 +1,225 @@
+package com.azzapp.rnskv;
+
+import android.graphics.Bitmap;
+import android.opengl.GLES20;
+import android.opengl.GLU;
+import android.opengl.Matrix;
+import android.util.Log;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLContext;
+
+public class EGLUtils {
+
+  /**
+   * The EGL constant for the client version of the context.
+   */
+  public static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+
+  /**
+   * The EGL constant for the recordable attribute.
+   */
+  public static final int EGL_RECORDABLE_ANDROID = 0x3142;
+
+
+  public static final float[] IDENTITY_MATRIX = new float[16];
+
+  static {
+    Matrix.setIdentityM(IDENTITY_MATRIX, 0);
+  }
+
+  static public EGLContext getCurrentContextOrThrows() {
+    EGLContext context = ((EGL10) EGLContext.getEGL()).eglGetCurrentContext();
+    if (context == EGL10.EGL_NO_CONTEXT) {
+      throw new RuntimeException("Skia context is not initialized");
+    }
+    return context;
+  }
+
+  /**
+   * Create an OpenGL program from the given vertex and fragment shaders.
+   *
+   * @param vertexSource   the vertex shader source code
+   * @param fragmentSource the fragment shader source code
+   * @return the program identifier
+   */
+  public static int createProgram(String vertexSource, String fragmentSource) {
+    int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
+    if (vertexShader == 0) {
+      return 0;
+    }
+    int fragmentShared = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
+    if (fragmentShared == 0) {
+      GLES20.glDeleteShader(vertexShader);
+      return 0;
+    }
+    int program = GLES20.glCreateProgram();
+    try {
+      if (program == 0) {
+        throw new IllegalStateException("Could not allocate GL program");
+      }
+      GLES20.glAttachShader(program, vertexShader);
+      GLES20.glAttachShader(program, fragmentShared);
+      GLES20.glLinkProgram(program);
+      int[] linkStatus = new int[1];
+      GLES20.glGetProgramiv(
+        program, GLES20.GL_LINK_STATUS, linkStatus,
+        0
+      );
+      if (linkStatus[0] != GLES20.GL_TRUE) {
+        String info = GLES20.glGetProgramInfoLog(program);
+        GLES20.glDeleteProgram(program);
+        throw new RuntimeException("Could not link program: " + info);
+      }
+      return program;
+    } finally {
+      // Linked programs retain their compiled code. The shader objects are
+      // independent allocations and must not accumulate over mount cycles.
+      GLES20.glDeleteShader(vertexShader);
+      GLES20.glDeleteShader(fragmentShared);
+    }
+  }
+
+  /**
+   * Load a shader from the given source code.
+   *
+   * @param shaderType the type of the shader, e.g. {@link GLES20#GL_VERTEX_SHADER} or
+   *                   {@link GLES20#GL_FRAGMENT_SHADER}
+   * @param source     the source code of the shader
+   * @return the shader identifier
+   */
+  public static int loadShader(int shaderType, String source) {
+    int shader = GLES20.glCreateShader(shaderType);
+    if (shader != 0) {
+      GLES20.glShaderSource(shader, source);
+      GLES20.glCompileShader(shader);
+      int[] compiled = new int[1];
+      GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
+      if (compiled[0] == 0) {
+        String info = GLES20.glGetShaderInfoLog(shader);
+        GLES20.glDeleteShader(shader);
+        throw new RuntimeException("Could not compile shader " + shaderType + ":" + info);
+      }
+    }
+    return shader;
+  }
+
+  /**
+   * Create a float buffer from the given values.
+   *
+   * @param values the values to put in the buffer
+   * @return the float buffer
+   */
+  public static FloatBuffer createFloatBuffer(float... values) {
+    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(
+      values.length * 4
+    );
+    byteBuffer.order(ByteOrder.nativeOrder());
+    FloatBuffer floatBuffer = byteBuffer.asFloatBuffer();
+    floatBuffer.put(values);
+    floatBuffer.position(0);
+    return floatBuffer;
+  }
+
+
+  /**
+   * Purge all OpenGL errors.
+   * Useful to call this method before starting a new OpenGL operation.
+   * Especially since react-native-skia seems to leave some errors behind.
+   */
+  public static void purgeOpenGLError() {
+    int i = 0;
+    while (true) {
+      if (GLES20.glGetError() == GLES20.GL_NO_ERROR || i >= 9) {
+        break;
+      }
+      i++;
+    }
+  }
+
+  /**
+   * Check for OpenGL errors and throw an exception if an error is found.
+   *
+   * @param prefix the prefix to add to the error message
+   */
+  public static void checkGlError(String prefix) {
+    StringBuilder errorMessageBuilder = new StringBuilder();
+    boolean foundError = false;
+    int error;
+    if (prefix != null) {
+      errorMessageBuilder.append(prefix).append(": ");
+    }
+    while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
+      if (foundError) {
+        errorMessageBuilder.append('\n');
+      }
+      String errorString = GLU.gluErrorString(error);
+      if (errorString == null) {
+        errorString = "error code: 0x" + Integer.toHexString(error);
+      } else {
+        errorString = "error code: 0x" + Integer.toHexString(error) + " " + errorString;
+      }
+      errorMessageBuilder.append("glError: ").append(errorString);
+      foundError = true;
+    }
+    if (foundError) {
+      if (BuildConfig.DEBUG) {
+        throw new RuntimeException(errorMessageBuilder.toString());
+      } else {
+        Log.e("RNSkiaVideo", errorMessageBuilder.toString());
+      }
+    }
+  }
+
+  /**
+   * Binds the texture of the given type with default configuration of GL_LINEAR filtering and
+   * GL_CLAMP_TO_EDGE wrapping.
+   *
+   * @param target The target to which the texture is bound, e.g. {@link GLES20#GL_TEXTURE_2D}
+   *               for a two-dimensional texture or {@link android.opengl.GLES11Ext#GL_TEXTURE_EXTERNAL_OES}
+   *               for an external texture.
+   * @param texId The texture identifier.
+   */
+  public static void configureTexture(int target, int texId) {
+    GLES20.glBindTexture(target, texId);
+    GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+    GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+    GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+    GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+  }
+
+  /**
+   * Save the texture to a bitmap. (Useful for debugging purposes)
+   *
+   * @param texture the texture identifier
+   * @param width   the width of the texture
+   * @param height  the height of the texture
+   */
+  public static Bitmap saveTexture(int texture, int width, int height) {
+    int[] frame = new int[1];
+    GLES20.glGenFramebuffers(1, frame, 0);
+    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, frame[0]);
+    GLES20.glFramebufferTexture2D(
+      GLES20.GL_FRAMEBUFFER,
+      GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, texture,
+      0
+    );
+    ByteBuffer buffer = ByteBuffer.allocate(width * height * 4);
+    GLES20.glReadPixels(
+      0, 0, width, height, GLES20.GL_RGBA,
+      GLES20.GL_UNSIGNED_BYTE, buffer
+    );
+    Bitmap bitmap = Bitmap.createBitmap(
+      width, height,
+      Bitmap.Config.ARGB_8888
+    );
+    bitmap.copyPixelsFromBuffer(buffer);
+    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+    GLES20.glDeleteFramebuffers(1, frame, 0);
+    return bitmap;
+  }
+}

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

@@ -0,0 +1,50 @@
+package com.azzapp.rnskv;
+
+/**
+ * The size an item's frames are drawn out at, in display orientation.
+ * Pure arithmetic, apart from the GL work that uses it.
+ */
+final class FrameSize {
+
+  private FrameSize() {
+  }
+
+  /**
+   * @param width       an explicit width in the file's encoded orientation, or 0
+   * @param height      an explicit height in the file's encoded orientation, or 0
+   * @param maxLongSide a cap on the longest side, or 0; ignored when a size is
+   *                    given, and never upscales
+   * @param videoWidth  the decoder's encoded width
+   * @param videoHeight the decoder's encoded height
+   * @param rotation    the file's rotation in degrees
+   * @return {width, height}, swapped for a file turned by 90 or 270 degrees
+   */
+  static int[] of(
+    int width,
+    int height,
+    int maxLongSide,
+    int videoWidth,
+    int videoHeight,
+    int rotation
+  ) {
+    int w = videoWidth;
+    int h = videoHeight;
+    if (width > 0 && height > 0) {
+      w = width;
+      h = height;
+    } else if (maxLongSide > 0 && Math.max(w, h) > maxLongSide) {
+      double scale = (double) maxLongSide / Math.max(w, h);
+      // Even, as on iOS: hardware scalers dislike odd sizes.
+      w = even(w * scale);
+      h = even(h * scale);
+    }
+    if (rotation == 90 || rotation == 270) {
+      return new int[]{h, w};
+    }
+    return new int[]{w, h};
+  }
+
+  private static int even(double value) {
+    return Math.max(2, (int) Math.round(value / 2) * 2);
+  }
+}