feat: dmabuf planes

Author: 1zun4

java/org/cef/handler/CefAcceleratedPaintInfo.java

@@ -11,8 +11,8 @@ public class CefAcceleratedPaintInfo {
     /**
      * Shared texture handle. The meaning depends on the platform:
      * - Windows: HANDLE to a texture that can be opened with D3D11 OpenSharedResource
-     * - macOS: IOSurface pointer that can be opened with Metal or OpenGL
-     * - Linux: Contains several planes, each with an fd to the underlying system native buffer
+     * - macOS: Not used; todo: IOSurface pointer that can be opened with Metal or OpenGL
+     * - Linux: Not used; dmabuf planes are exposed via the plane_* fields
      */
     public long shared_texture_handle = 0;
 
@@ -26,6 +26,36 @@ public class CefAcceleratedPaintInfo {
      */
     public int width = 0;
     public int height = 0;
+
+    /**
+     * Linux-only dmabuf plane count.
+     */
+    public int plane_count = 0;
+
+    /**
+     * Linux-only dmabuf plane file descriptors.
+     */
+    public int[] plane_fds = null;
+
+    /**
+     * Linux-only dmabuf plane strides (bytes per row).
+     */
+    public int[] plane_strides = null;
+
+    /**
+     * Linux-only dmabuf plane offsets.
+     */
+    public long[] plane_offsets = null;
+
+    /**
+     * Linux-only dmabuf plane sizes.
+     */
+    public long[] plane_sizes = null;
+
+    /**
+     * Linux-only dmabuf modifier.
+     */
+    public long modifier = 0;
 
     public CefAcceleratedPaintInfo() {}
 
@@ -35,9 +65,20 @@ public CefAcceleratedPaintInfo(long shared_texture_handle, int format, int width
         this.width = width;
         this.height = height;
     }
+
+    public boolean hasDmaBufPlanes() {
+        return plane_count > 0 && plane_fds != null && plane_strides != null && plane_offsets != null;
+    }
 
     @Override
     public CefAcceleratedPaintInfo clone() {
-        return new CefAcceleratedPaintInfo(shared_texture_handle, format, width, height);
+        CefAcceleratedPaintInfo clone = new CefAcceleratedPaintInfo(shared_texture_handle, format, width, height);
+        clone.plane_count = plane_count;
+        clone.modifier = modifier;
+        clone.plane_fds = plane_fds != null ? plane_fds.clone() : null;
+        clone.plane_strides = plane_strides != null ? plane_strides.clone() : null;
+        clone.plane_offsets = plane_offsets != null ? plane_offsets.clone() : null;
+        clone.plane_sizes = plane_sizes != null ? plane_sizes.clone() : null;
+        return clone;
     }
 }

native/render_handler.cpp

@@ -4,6 +4,8 @@
 
 #include "render_handler.h"
 
+#include <vector>
+
 #include "client_handler.h"
 #include "jni_util.h"
 
@@ -305,6 +307,55 @@ void RenderHandler::OnAcceleratedPaint(CefRefPtr<CefBrowser> browser,
   SetJNIFieldInt(env, cls, jpaintInfo, "width", viewRect.width);
   SetJNIFieldInt(env, cls, jpaintInfo, "height", viewRect.height);
 
+#if defined(OS_LINUX)
+  SetJNIFieldInt(env, cls, jpaintInfo, "plane_count", info.plane_count);
+  SetJNIFieldLong(env, cls, jpaintInfo, "modifier",
+                  static_cast<jlong>(info.modifier));
+
+  const int plane_count = info.plane_count;
+  if (plane_count > 0) {
+    std::vector<jint> fds(plane_count);
+    std::vector<jint> strides(plane_count);
+    std::vector<jlong> offsets(plane_count);
+    std::vector<jlong> sizes(plane_count);
+
+    for (int i = 0; i < plane_count; ++i) {
+      fds[i] = info.planes[i].fd;
+      strides[i] = static_cast<jint>(info.planes[i].stride);
+      offsets[i] = static_cast<jlong>(info.planes[i].offset);
+      sizes[i] = static_cast<jlong>(info.planes[i].size);
+    }
+
+    jclass paintInfoClass = cls.get();
+    jfieldID fdsField = env->GetFieldID(paintInfoClass, "plane_fds", "[I");
+    jfieldID stridesField = env->GetFieldID(paintInfoClass, "plane_strides", "[I");
+    jfieldID offsetsField = env->GetFieldID(paintInfoClass, "plane_offsets", "[J");
+    jfieldID sizesField = env->GetFieldID(paintInfoClass, "plane_sizes", "[J");
+
+    if (fdsField && stridesField && offsetsField && sizesField) {
+      jintArray fdsArray = env->NewIntArray(plane_count);
+      jintArray stridesArray = env->NewIntArray(plane_count);
+      jlongArray offsetsArray = env->NewLongArray(plane_count);
+      jlongArray sizesArray = env->NewLongArray(plane_count);
+
+      if (fdsArray && stridesArray && offsetsArray && sizesArray) {
+        env->SetIntArrayRegion(fdsArray, 0, plane_count, fds.data());
+        env->SetIntArrayRegion(stridesArray, 0, plane_count, strides.data());
+        env->SetLongArrayRegion(offsetsArray, 0, plane_count, offsets.data());
+        env->SetLongArrayRegion(sizesArray, 0, plane_count, sizes.data());
+
+        env->SetObjectField(jpaintInfo.get(), fdsField, fdsArray);
+        env->SetObjectField(jpaintInfo.get(), stridesField, stridesArray);
+        env->SetObjectField(jpaintInfo.get(), offsetsField, offsetsArray);
+        env->SetObjectField(jpaintInfo.get(), sizesField, sizesArray);
+      }
+    }
+  }
+#else
+  SetJNIFieldInt(env, cls, jpaintInfo, "plane_count", 0);
+  SetJNIFieldLong(env, cls, jpaintInfo, "modifier", 0);
+#endif
+
   JNI_CALL_VOID_METHOD(env, handle_, "onAcceleratedPaint",
                        "(Lorg/cef/browser/CefBrowser;Z[Ljava/awt/"
                        "Rectangle;Lorg/cef/handler/CefAcceleratedPaintInfo;)V",