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

package/android/cpp/NativeHardwareBuffer.cpp

@@ -0,0 +1,397 @@
+#include "NativeHardwareBuffer.h"
+#include "RNSVMemoryBudget.h"
+#include <fbjni/ByteBuffer.h>
+#include <android/hardware_buffer_jni.h>
+#include <android/log.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <atomic>
+#include <cerrno>
+#include <cstring>
+#include <limits>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+
+namespace RNSkiaVideo {
+using namespace facebook::jni;
+namespace {
+std::atomic<bool> interopEnabled{false};
+std::atomic<uint64_t> nextHandle{1};
+std::mutex registryMutex;
+std::unordered_map<uint64_t, std::shared_ptr<HardwareFrameStorage>> frames;
+
+struct Unsupported final : std::runtime_error {
+  explicit Unsupported(const std::string& detail)
+      : std::runtime_error("Android native buffer interop unavailable: " + detail) {}
+};
+bool extension(const char* values, const char* name) {
+  if (!values) return false;
+  const size_t length = std::strlen(name);
+  for (const char* p = values; (p = std::strstr(p, name)); p += length)
+    if ((p == values || p[-1] == ' ') && (p[length] == 0 || p[length] == ' ')) return true;
+  return false;
+}
+void checkGl(const char* operation) {
+  const auto error = glGetError();
+  if (error != GL_NO_ERROR)
+    throw std::runtime_error(std::string(operation) + " failed: GL error " + std::to_string(error));
+}
+uint64_t newId() {
+  const auto id = nextHandle.fetch_add(1);
+  if (id == 0 || id > static_cast<uint64_t>(std::numeric_limits<jlong>::max()))
+    throw std::runtime_error("Hardware buffer lease identifiers exhausted");
+  return id;
+}
+uint64_t addFrame(const std::shared_ptr<HardwareFrameStorage>& owner) {
+  const auto id = newId();
+  std::lock_guard<std::mutex> lock(registryMutex);
+  frames.emplace(id, owner);
+  return id;
+}
+void releaseFrame(uint64_t handle) {
+  std::shared_ptr<HardwareFrameStorage> released;
+  {
+    std::lock_guard<std::mutex> lock(registryMutex);
+    auto found = frames.find(handle);
+    if (found == frames.end()) return;
+    released = std::move(found->second);
+    frames.erase(found);
+  }
+}
+
+struct RenderTarget final {
+  std::shared_ptr<HardwareFrameStorage> owner;
+  EGLDisplay display = EGL_NO_DISPLAY;
+  EGLContext context = EGL_NO_CONTEXT;
+  EGLImageKHR image = EGL_NO_IMAGE_KHR;
+  GLuint texture = 0;
+  uint64_t id = 0;
+  RenderTarget* quarantineNext = nullptr;
+  PFNEGLDESTROYIMAGEKHRPROC destroyImage = nullptr;
+  ~RenderTarget() {
+    if (texture) glDeleteTextures(1, &texture);
+    if (image != EGL_NO_IMAGE_KHR && destroyImage) destroyImage(display, image);
+  }
+};
+std::unordered_map<uint64_t, std::unique_ptr<RenderTarget>> writers;
+RenderTarget* quarantinedWriters = nullptr;
+
+void quarantineWriter(std::unique_ptr<RenderTarget> writer) {
+  // Intrusive storage: uncertain GPU completion must not require a successful
+  // heap allocation to keep its backing and reservation alive.
+  std::lock_guard<std::mutex> lock(registryMutex);
+  writer->quarantineNext = quarantinedWriters;
+  quarantinedWriters = writer.release();
+}
+
+std::unique_ptr<RenderTarget> makeTarget(int width, int height) {
+  if (width <= 0 || height <= 0 || width > 16384 || height > 16384)
+    throw std::invalid_argument("Invalid hardware video frame dimensions");
+  auto display = eglGetCurrentDisplay();
+  auto context = eglGetCurrentContext();
+  if (display == EGL_NO_DISPLAY || context == EGL_NO_CONTEXT)
+    throw std::runtime_error("Hardware frame producer has no current EGL context");
+  const auto* eglExtensions = eglQueryString(display, EGL_EXTENSIONS);
+  const auto* glExtensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+  if (!extension(eglExtensions, "EGL_ANDROID_get_native_client_buffer") ||
+      !extension(eglExtensions, "EGL_ANDROID_image_native_buffer") ||
+      !extension(eglExtensions, "EGL_KHR_image_base") ||
+      !extension(glExtensions, "GL_OES_EGL_image"))
+    throw Unsupported("required EGLImage/AHardwareBuffer extensions are absent");
+  auto getClientBuffer = reinterpret_cast<PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC>(
+      eglGetProcAddress("eglGetNativeClientBufferANDROID"));
+  auto createImage = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR"));
+  auto destroyImage = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR"));
+  auto imageTarget = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(
+      eglGetProcAddress("glEGLImageTargetTexture2DOES"));
+  if (!getClientBuffer || !createImage || !destroyImage || !imageTarget)
+    throw Unsupported("required EGLImage entry points are absent");
+
+  auto target = std::make_unique<RenderTarget>();
+  target->owner = std::make_shared<HardwareFrameStorage>();
+  auto& owner = *target->owner;
+  owner.reservation = MemoryBudget::instance().reserve(
+      static_cast<uint64_t>(width) * height * 4, "android-frame-ahardwarebuffer");
+  AHardwareBuffer_Desc descriptor{};
+  descriptor.width = width; descriptor.height = height; descriptor.layers = 1;
+  descriptor.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+  descriptor.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+      AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT | AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
+  const int result = AHardwareBuffer_allocate(&descriptor, &owner.buffer);
+  if (result != 0) {
+    if (result == -EINVAL || result == EINVAL)
+      throw Unsupported("RGBA GPU color/sample buffer allocation is unsupported");
+    throw std::runtime_error("AHardwareBuffer allocation failed: " + std::to_string(result));
+  }
+  AHardwareBuffer_describe(owner.buffer, &owner.description);
+  if (owner.description.format != descriptor.format || owner.description.layers != 1 ||
+      owner.description.width != descriptor.width || owner.description.height != descriptor.height ||
+      owner.description.stride < descriptor.width ||
+      (owner.description.usage & descriptor.usage) != descriptor.usage)
+    throw std::runtime_error("Invalid allocated RGBA hardware buffer layout");
+  MemoryBudget::instance().resize(owner.reservation,
+      static_cast<uint64_t>(owner.description.stride) * height * 4,
+      "android-frame-ahardwarebuffer padded stride");
+  target->display = display; target->context = context; target->destroyImage = destroyImage;
+  const EGLint attributes[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+  target->image = createImage(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
+      getClientBuffer(owner.buffer), attributes);
+  if (target->image == EGL_NO_IMAGE_KHR)
+    throw std::runtime_error("Cannot import hardware producer EGLImage: " + std::to_string(eglGetError()));
+  GLint previousTexture = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &previousTexture);
+  glGenTextures(1, &target->texture);
+  glBindTexture(GL_TEXTURE_2D, target->texture);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  imageTarget(GL_TEXTURE_2D, target->image);
+  glBindTexture(GL_TEXTURE_2D, previousTexture);
+  checkGl("Hardware frame EGLImage binding");
+  return target;
+}
+
+jlong create(alias_ref<jclass>, jint width, jint height) {
+  auto writer = makeTarget(width, height);
+  const auto id = newId();
+  writer->id = id;
+  std::lock_guard<std::mutex> lock(registryMutex);
+  writers.emplace(id, std::move(writer));
+  return static_cast<jlong>(id);
+}
+jint texture(alias_ref<jclass>, jlong id) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  auto found = writers.find(id);
+  if (found == writers.end()) throw std::runtime_error("Hardware render target is closed");
+  if (found->second->context != eglGetCurrentContext())
+    throw std::runtime_error("Hardware render target has a different EGL context");
+  return found->second->texture;
+}
+std::unique_ptr<RenderTarget> removeWriter(uint64_t id) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  auto found = writers.find(id);
+  if (found == writers.end()) {
+    for (auto** previous = &quarantinedWriters; *previous; previous = &(*previous)->quarantineNext) {
+      auto* writer = *previous;
+      if (writer->id != id) continue;
+      if (writer->context != eglGetCurrentContext())
+        throw std::runtime_error("Hardware render target has a different EGL context");
+      *previous = writer->quarantineNext;
+      writer->quarantineNext = nullptr;
+      return std::unique_ptr<RenderTarget>(writer);
+    }
+    return nullptr;
+  }
+  if (found->second->context != eglGetCurrentContext())
+    throw std::runtime_error("Hardware render target has a different EGL context");
+  auto writer = std::move(found->second);
+  writers.erase(found);
+  return writer;
+}
+jlong finish(alias_ref<jclass>, jlong id) {
+  auto writer = removeWriter(id);
+  if (!writer) throw std::runtime_error("Hardware render target is closed");
+  // RN WebGPU's native-buffer wrapper accepts no incoming producer fence.
+  // Finish and validate our isolated EGL work before making the pointer visible.
+  try {
+    glFinish();
+    checkGl("Hardware frame producer completion");
+  } catch (...) {
+    // Keep the allocation and budget live while producer completion is unknown.
+    quarantineWriter(std::move(writer));
+    throw;
+  }
+  return static_cast<jlong>(addFrame(writer->owner));
+}
+void abort(alias_ref<jclass>, jlong id) {
+  auto writer = removeWriter(id);
+  if (!writer) return;
+  try {
+    glFinish();
+    checkGl("Abandoned hardware frame producer completion");
+  } catch (...) {
+    quarantineWriter(std::move(writer));
+    throw;
+  }
+}
+/** Whether Dawn imports this format as OpaqueYCbCrAndroid: the public YUV
+ * formats and the driver-defined ones decoders use (Tensor: 0x123), unlike
+ * the color/depth formats with a WebGPU equivalent. Mirrors RN WebGPU's
+ * GPUExternalTexture::isOpaqueYCbCrFormat. */
+bool isYuvFormat(uint32_t format) {
+  switch (format) {
+  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+  case AHARDWAREBUFFER_FORMAT_BLOB:
+  case AHARDWAREBUFFER_FORMAT_D16_UNORM:
+  case AHARDWAREBUFFER_FORMAT_D24_UNORM:
+  case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
+  case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
+  case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
+  case AHARDWAREBUFFER_FORMAT_S8_UINT:
+  case 0x38: case 0x39: case 0x3a: case 0x3b:  // R8, R16, R16G16, R10G10B10A10
+    return false;
+  }
+  return true;
+}
+
+/** Takes over an ImageReader Image and its YUV hardware buffer. On failure the
+ * caller still owns the Image; on success, the last lease closes it. */
+jlong wrapImage(alias_ref<jclass>, alias_ref<jobject> hardwareBuffer, alias_ref<jobject> image,
+                jint cropX, jint cropY, jint cropWidth, jint cropHeight, jint rotation) {
+  auto* buffer = AHardwareBuffer_fromHardwareBuffer(Environment::current(), hardwareBuffer.get());
+  if (!buffer) throw std::runtime_error("Decoded image has no hardware buffer");
+  auto owner = std::make_shared<HardwareFrameStorage>();
+  AHardwareBuffer_acquire(buffer);
+  owner->buffer = buffer;
+  AHardwareBuffer_describe(buffer, &owner->description);
+  const auto& description = owner->description;
+  if (!isYuvFormat(description.format) || description.layers != 1 ||
+      (description.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) == 0)
+    throw std::runtime_error("Decoded image is not a GPU-sampled YUV 4:2:0 buffer (format " +
+        std::to_string(description.format) + ", usage " + std::to_string(description.usage) +
+        ", layers " + std::to_string(description.layers) + ")");
+  if (cropX < 0 || cropY < 0 || cropWidth <= 0 || cropHeight <= 0 ||
+      static_cast<uint64_t>(cropX) + cropWidth > description.width ||
+      static_cast<uint64_t>(cropY) + cropHeight > description.height ||
+      (rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270))
+    throw std::runtime_error("Invalid decoded image crop or rotation");
+  // Luma plus half-size chroma at the buffer's stride; driver formats may
+  // compress, so this is an estimate.
+  owner->reservation = MemoryBudget::instance().reserve(
+      static_cast<uint64_t>(description.stride) * description.height * 3 / 2,
+      "android-frame-imagereader");
+  owner->cropX = cropX; owner->cropY = cropY;
+  owner->cropWidth = cropWidth; owner->cropHeight = cropHeight;
+  owner->rotation = rotation;
+  owner->image = make_global(image);
+  return static_cast<jlong>(addFrame(owner));
+}
+jlong retain(alias_ref<jclass>, jlong id) {
+  return static_cast<jlong>(addFrame(acquireHardwareFrame(id)));
+}
+void release(alias_ref<jclass>, jlong id) { releaseFrame(id); }
+jboolean enabled(alias_ref<jclass>) { return interopEnabled.load(); }
+void read(alias_ref<jclass>, jlong id, alias_ref<JByteBuffer> destination) {
+  auto owner = acquireHardwareFrame(id);
+  if (owner->description.format != AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM)
+    throw std::runtime_error("CPU readback of a YUV hardware frame is unsupported");
+  auto* env = Environment::current();
+  auto* bytes = static_cast<uint8_t*>(env->GetDirectBufferAddress(destination.get()));
+  const auto capacity = env->GetDirectBufferCapacity(destination.get());
+  const size_t row = static_cast<size_t>(owner->description.width) * 4;
+  if (!bytes || capacity < 0 || static_cast<uint64_t>(capacity) < row * owner->description.height)
+    throw std::invalid_argument("Hardware frame readback destination is too small");
+  void* source = nullptr;
+  const int result = AHardwareBuffer_lock(owner->buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY,
+      -1, nullptr, &source);
+  if (result != 0 || !source) throw std::runtime_error("Hardware frame diagnostic CPU lock failed");
+  for (size_t y = 0; y < owner->description.height; ++y)
+    std::memcpy(bytes + y * row, static_cast<uint8_t*>(source) +
+        y * owner->description.stride * 4, row);
+  if (AHardwareBuffer_unlock(owner->buffer, nullptr) != 0)
+    throw std::runtime_error("Hardware frame diagnostic CPU unlock failed");
+}
+
+void probe() {
+  const auto previousDisplay = eglGetCurrentDisplay();
+  const auto previousContext = eglGetCurrentContext();
+  const auto previousDraw = eglGetCurrentSurface(EGL_DRAW);
+  const auto previousRead = eglGetCurrentSurface(EGL_READ);
+  auto display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  if (display == EGL_NO_DISPLAY || !eglInitialize(display, nullptr, nullptr))
+    throw std::runtime_error("Cannot initialize hardware-frame probe EGL display");
+  EGLContext context = EGL_NO_CONTEXT;
+  EGLSurface surface = EGL_NO_SURFACE;
+  const auto cleanup = [&] {
+    bool restored = false;
+    if (previousContext != EGL_NO_CONTEXT) {
+      restored = eglMakeCurrent(previousDisplay, previousDraw, previousRead, previousContext);
+    } else restored = eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (!restored) eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (surface != EGL_NO_SURFACE) eglDestroySurface(display, surface);
+    if (context != EGL_NO_CONTEXT) eglDestroyContext(display, context);
+    // The initialized default display is process-owned; never eglTerminate it.
+    if (!restored) throw std::runtime_error("Cannot restore caller EGL context after hardware-frame probe");
+  };
+  std::exception_ptr failure;
+  try {
+    const EGLint attributes[] = {EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+      EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8,
+      EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_NONE};
+    EGLConfig config; EGLint count = 0;
+    if (!eglChooseConfig(display, attributes, &config, 1, &count) || count == 0)
+      throw Unsupported("no RGBA EGL producer configuration");
+    const EGLint contextAttributes[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+    context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttributes);
+    const EGLint surfaceAttributes[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
+    surface = eglCreatePbufferSurface(display, config, surfaceAttributes);
+    if (context == EGL_NO_CONTEXT || surface == EGL_NO_SURFACE ||
+        !eglMakeCurrent(display, surface, surface, context))
+      throw std::runtime_error("Cannot create hardware-frame probe EGL context");
+    {
+      auto target = makeTarget(4, 4);
+      GLuint framebuffer = 0;
+      glGenFramebuffers(1, &framebuffer);
+      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, target->texture, 0);
+      const auto complete = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+      glBindFramebuffer(GL_FRAMEBUFFER, 0);
+      glDeleteFramebuffers(1, &framebuffer);
+      if (complete != GL_FRAMEBUFFER_COMPLETE)
+        throw Unsupported("RGBA hardware buffer is not an EGL color render target");
+      checkGl("Hardware-frame probe");
+    }
+  } catch (...) { failure = std::current_exception(); }
+  cleanup();
+  if (failure) std::rethrow_exception(failure);
+}
+} // namespace
+
+HardwareFrameStorage::~HardwareFrameStorage() {
+  if (image) {
+    // The last lease may go on any thread (JS, GC reaper): attach it.
+    ThreadScope attached;
+    try {
+      static const auto close =
+          findClassStatic("android/media/Image")->getMethod<void()>("close");
+      close(image);
+    } catch (...) {
+      // A closed reader already closed its images.
+    }
+    image.reset();
+  }
+  if (buffer) AHardwareBuffer_release(buffer);
+  if (reservation) MemoryBudget::instance().release(reservation);
+}
+std::shared_ptr<HardwareFrameStorage> acquireHardwareFrame(uint64_t handle) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  auto found = frames.find(handle);
+  if (found == frames.end()) throw std::runtime_error("Hardware video frame is disposed");
+  return found->second;
+}
+bool NativeHardwareBuffer::isEnabled() { return interopEnabled.load(); }
+void NativeHardwareBuffer::configure(bool value) {
+  if (!value) { interopEnabled.store(false); return; }
+  if (!interopEnabled.load()) probe();
+  interopEnabled.store(true);
+}
+void NativeHardwareBuffer::registerNatives() {
+  javaClassStatic()->registerNatives({makeNativeMethod("nativeCreateRenderTarget", create),
+    makeNativeMethod("nativeRenderTargetTexture", texture), makeNativeMethod("nativeFinishRenderTarget", finish),
+    makeNativeMethod("nativeAbortRenderTarget", abort), makeNativeMethod("nativeRetain", retain),
+    makeNativeMethod("nativeRelease", release), makeNativeMethod("nativeReadPixels", read),
+    makeNativeMethod("nativeWrapImage", wrapImage),
+    makeNativeMethod("nativeIsEnabled", enabled)});
+}
+} // namespace RNSkiaVideo

package/android/cpp/NativeHardwareBuffer.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <android/hardware_buffer.h>
+#include <fbjni/fbjni.h>
+#include <cstdint>
+#include <memory>
+
+namespace RNSkiaVideo {
+
+struct HardwareFrameStorage final {
+  AHardwareBuffer* buffer = nullptr;
+  AHardwareBuffer_Desc description{};
+  uint64_t reservation = 0;
+  // ImageReader frames: the codec's YUV buffer, owned until the last lease
+  // closes its android.media.Image (returning the slot to the codec). The
+  // picture is the crop rectangle, turned clockwise by `rotation` for display.
+  facebook::jni::global_ref<jobject> image;
+  int cropX = 0;
+  int cropY = 0;
+  int cropWidth = 0;
+  int cropHeight = 0;
+  int rotation = 0;
+  ~HardwareFrameStorage();
+};
+
+std::shared_ptr<HardwareFrameStorage> acquireHardwareFrame(uint64_t handle);
+
+struct NativeHardwareBuffer : facebook::jni::JavaClass<NativeHardwareBuffer> {
+  static constexpr auto kJavaDescriptor = "Lcom/azzapp/rnskv/NativeHardwareBuffer;";
+  static void registerNatives();
+  static bool isEnabled();
+  static void configure(bool enabled);
+};
+
+} // namespace RNSkiaVideo

package/android/cpp/NativeRgbaBuffer.cpp

@@ -0,0 +1,45 @@
+#include "NativeRgbaBuffer.h"
+#include "RNSVMemoryBudget.h"
+#include <limits>
+
+namespace RNSkiaVideo {
+using namespace facebook::jni;
+namespace {
+jlong reserve(alias_ref<jclass>, jint size) {
+  if (size <= 0) throw std::invalid_argument("Invalid Android RGBA allocation size");
+  return static_cast<jlong>(MemoryBudget::instance().reserve(static_cast<uint64_t>(size) + 7, "android-frame-rgba"));
+}
+local_ref<JByteBuffer> alias(alias_ref<jclass>, alias_ref<JByteBuffer> backing) {
+  auto* env = Environment::current();
+  const auto size = env->GetDirectBufferCapacity(backing.get());
+  auto* bytes = env->GetDirectBufferAddress(backing.get());
+  if (!bytes || size <= 0 || size > std::numeric_limits<jint>::max())
+    throw std::invalid_argument("Invalid Android direct pixel buffer");
+  auto buffer = env->NewDirectByteBuffer(bytes, size);
+  if (env->ExceptionCheck()) throwPendingJniExceptionAsCppException();
+  if (!buffer) throw std::bad_alloc();
+  return adopt_local(static_cast<JByteBuffer::javaobject>(buffer));
+}
+void release(alias_ref<jclass>, jlong token) {
+  MemoryBudget::instance().release(static_cast<uint64_t>(token));
+}
+local_ref<JArrayLong> stats(alias_ref<jclass>) {
+  const auto snapshot = MemoryBudget::instance().snapshot();
+  auto result = JArrayLong::newArray(4);
+  const jlong values[] = {static_cast<jlong>(snapshot.currentBytes),
+    static_cast<jlong>(snapshot.peakBytes), static_cast<jlong>(snapshot.allocations),
+    static_cast<jlong>(snapshot.maxBytes)};
+  result->setRegion(0, 4, values);
+  return result;
+}
+void configure(alias_ref<jclass>, jlong bytes) {
+  if (bytes <= 0) throw std::invalid_argument("Invalid Android memory limit");
+  MemoryBudget::instance().configure(bytes);
+}
+}
+void NativeRgbaBuffer::registerNatives() {
+  javaClassStatic()->registerNatives({makeNativeMethod("nativeReserve", reserve),
+    makeNativeMethod("nativeAlias", alias), makeNativeMethod("nativeRelease", release),
+    makeNativeMethod("nativeBudgetStats", stats), makeNativeMethod("nativeConfigureBudget", configure)});
+}
+}

package/android/cpp/NativeRgbaBuffer.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <fbjni/fbjni.h>
+#include <fbjni/ByteBuffer.h>
+namespace RNSkiaVideo {
+struct NativeRgbaBuffer : facebook::jni::JavaClass<NativeRgbaBuffer> {
+  static constexpr auto kJavaDescriptor = "Lcom/azzapp/rnskv/NativeRgbaBuffer;";
+  static void registerNatives();
+};
+}

package/android/cpp/ReturnedVideoFrames.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "VideoFrame.h"
+#include <android/log.h>
+#include <exception>
+
+namespace RNSkiaVideo {
+
+// Every Java public map owns independent wrapper leases, including cache hits.
+// Keep cleanup tied to the whole map, not only frames converted successfully.
+class ReturnedVideoFrames final {
+ public:
+  explicit ReturnedVideoFrames(alias_ref<JMap<JString, VideoFrame>> frames) : frames_(frames) {}
+  ~ReturnedVideoFrames() {
+    if (!closed_) {
+      try { close(); }
+      catch (const std::exception& error) {
+        __android_log_print(ANDROID_LOG_ERROR, "SkiaVideo", "Returned-frame cleanup failed: %s", error.what());
+      } catch (...) {
+        __android_log_print(ANDROID_LOG_ERROR, "SkiaVideo", "Returned-frame cleanup failed");
+      }
+    }
+  }
+  void close() {
+    if (closed_) return;
+    std::exception_ptr failure;
+    for (auto& entry : *frames_) {
+      try { auto frame = entry.second; frame->close(); }
+      catch (...) { if (!failure) failure = std::current_exception(); }
+    }
+    closed_ = true;
+    if (failure) std::rethrow_exception(failure);
+  }
+ private:
+  alias_ref<JMap<JString, VideoFrame>> frames_;
+  bool closed_ = false;
+};
+} // namespace RNSkiaVideo

package/android/cpp/RgbaFrameLease.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+
+namespace RNSkiaVideo {
+
+struct RgbaFrameStorage {
+  virtual ~RgbaFrameStorage() = default;
+  virtual size_t size() const = 0;
+  virtual uint8_t* data() = 0;
+};
+
+// Closing a frame drops its own storage root. Explicit external aliases may
+// still hold the same immutable allocation, and keep it alive independently.
+class RgbaFrameLease final {
+ public:
+  explicit RgbaFrameLease(std::shared_ptr<RgbaFrameStorage> storage)
+      : storage_(std::move(storage)) {
+    if (!storage_ || !storage_->data() || storage_->size() == 0)
+      throw std::invalid_argument("Invalid RGBA frame storage");
+  }
+
+  std::shared_ptr<RgbaFrameStorage> storage() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return storage_;
+  }
+
+  void copyTo(uint8_t* destination, size_t capacity) const {
+    auto source = storage();
+    if (!source) throw std::runtime_error("RGBA video frame is disposed");
+    if (!destination || capacity < source->size())
+      throw std::invalid_argument("RGBA copy destination is too small");
+    // An explicit consumer may pass a retained source alias as destination.
+    // memmove also handles that overlap without undefined behavior.
+    std::memmove(destination, source->data(), source->size());
+  }
+
+  void dispose() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    storage_.reset();
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  std::shared_ptr<RgbaFrameStorage> storage_;
+};
+
+} // namespace RNSkiaVideo

package/android/cpp/VideoCapabilities.cpp

@@ -0,0 +1,87 @@
+//
+// Created by François de Campredon on 11/06/2024.
+//
+
+#include "VideoCapabilities.h"
+
+namespace RNSkiaVideo {
+jint DecoderInfo::getMaxInstances() const {
+  static const auto getMaxInstancesMethod =
+      getClass()->getMethod<jint()>("getMaxInstances");
+  return getMaxInstancesMethod(self());
+}
+
+jint DecoderInfo::getMaxWidth() const {
+  static const auto getMaxWidthMethod =
+      getClass()->getMethod<jint()>("getMaxWidth");
+  return getMaxWidthMethod(self());
+}
+
+jint DecoderInfo::getMaxHeight() const {
+  static const auto getMaxHeightMethod =
+      getClass()->getMethod<jint()>("getMaxHeight");
+  return getMaxHeightMethod(self());
+}
+
+std::string EncoderInfo::getEncoderName() const {
+  static const auto getEncoderNameMethod =
+      getClass()->getMethod<jstring()>("getEncoderName");
+  return getEncoderNameMethod(self())->toStdString();
+}
+
+jboolean EncoderInfo::getHardwareAccelerated() const {
+  static const auto getHardwareAcceleratedMethod =
+      getClass()->getMethod<jboolean()>("getHardwareAccelerated");
+  return getHardwareAcceleratedMethod(self());
+}
+
+jint EncoderInfo::getWidth() const {
+  static const auto getWidthMethod = getClass()->getMethod<jint()>("getWidth");
+  return getWidthMethod(self());
+}
+
+jint EncoderInfo::getHeight() const {
+  static const auto getHeightMethod =
+      getClass()->getMethod<jint()>("getHeight");
+  return getHeightMethod(self());
+}
+
+jint EncoderInfo::getFrameRate() const {
+  static const auto getFrameRateMethod =
+      getClass()->getMethod<jint()>("getFrameRate");
+  return getFrameRateMethod(self());
+}
+
+jint EncoderInfo::getBitrate() const {
+  static const auto getBitrateMethod =
+      getClass()->getMethod<jint()>("getBitrate");
+  return getBitrateMethod(self());
+}
+
+jni::local_ref<DecoderInfo>
+VideoCapabilities::getDecodingCapabilitiesFor(std::string mimeType) {
+  static const auto cls = javaClassStatic();
+  static const auto getDecodingCapabilitiesForMethod =
+      cls->getStaticMethod<jni::local_ref<DecoderInfo>(
+          jni::alias_ref<JString>)>("getDecodingCapabilitiesFor");
+  return getDecodingCapabilitiesForMethod(cls, jni::make_jstring(mimeType));
+}
+
+jni::local_ref<JList<EncoderInfo>>
+VideoCapabilities::getValidEncoderConfigurations(
+    int width, int height, int framerate, int bitrate,
+    std::optional<std::string> codec) {
+  static const auto cls = javaClassStatic();
+
+  static const auto getValidEncoderConfigurationsMethod =
+      cls->getStaticMethod<jni::local_ref<JList<EncoderInfo>>(
+          jint, jint, jint, jint, jstring)>("getValidEncoderConfigurations");
+  // Nullable on the Java side, so built as a jstring ref: handing over a
+  // std::string built from nullptr would call strlen(nullptr).
+  auto codecRef = codec.has_value() ? make_jstring(codec.value())
+                                    : local_ref<JString>(nullptr);
+  return getValidEncoderConfigurationsMethod(cls, width, height, framerate,
+                                             bitrate, codecRef.get());
+}
+
+} // namespace RNSkiaVideo