testsubsurface: Add dmabuf support

Allow attaching dmabuf textures without downloading.

Currently, this is using create_immed, so failure to import a
dmabuf will be deadly.

.gitlab-ci.yml

@@ -217,25 +217,32 @@ macos-x86_64:
     MESON_FORCE_BACKTRACKE: 1
     TMPDIR: /Users/Shared/work/tmp
     SDKROOT: /opt/sdks/MacOSX10.13.4.sdk
-    CCACHE_DIR: /Users/Shared/work/ccache
     PIP_CACHE_DIR: /Users/Shared/build/cache
     PIPENV_CACHE_DIR: $PIP_CACHE_DIR
     PYTHONPYCACHEPREFIX: $PIP_CACHE_DIR
+    EXTRA_MESON_FLAGS: "-Dgobject-introspection:werror=false"
   before_script:
+    # Not using ccache on purpose as it accelerates the build so much that it
+    # can trigger race conditions in the gobject-introspection subproject.
     - bash .gitlab-ci/show-info-osx.sh
-    - python3 -m venv .venv
+    - /opt/macports/bin/python3.10 -m venv .venv
     - ln -s /opt/cmake/CMake.app/Contents/bin/cmake .venv/bin
-    - ln -s /opt/ccache/ccache .venv/bin
+    - ln -s /opt/pkg-config/bin/pkg-config .venv/bin
+    - ln -s /opt/bison/bin/bison .venv/bin
     - source .venv/bin/activate
     - pip3 install meson==1.2.0
     - pip3 install ninja==1.11.1
+    - pip3 install /Users/Shared/build/pkgs/PyGObject-3.44.0-cp310-cp310-macosx_10_13_x86_64.whl
+                   /Users/Shared/build/pkgs/pycairo-1.23.0-cp310-cp310-macosx_10_13_x86_64.whl
   script:
-    - meson setup ${COMMON_MESON_FLAGS}
+    - meson setup
+            ${COMMON_MESON_FLAGS}
+            ${EXTRA_MESON_FLAGS}
             -Dx11-backend=false
             -Dbroadway-backend=true
             -Dmacos-backend=true
             -Dmedia-gstreamer=disabled
-            -Dintrospection=disabled
+            -Dintrospection=enabled
             -Dcpp_std=c++11
             -Dpixman:tests=disabled
             -Dlibjpeg-turbo:simd=disabled

.gitlab-ci/run-tests.sh

@@ -23,6 +23,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=gsk-compare-broadway
 
     # Store the exit code for the CI run, but always
@@ -45,6 +46,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=${backend}_failing \
                 --no-suite=gsk-compare-broadway
     exit_code=$?
@@ -67,6 +69,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=gsk-compare-opengl
 
     kill ${server}

CONTRIBUTING.md

@@ -35,8 +35,7 @@ The issue tracker is meant to be used for actionable issues only.
 
 You should not open a new issue for security related questions.
 
-When in doubt, send an email to the [security](mailto:security@gnome.org)
-mailing list.
+When in doubt, follow [security](https://security.gnome.org/).
 
 ### Bug reports
 
@@ -244,13 +243,11 @@ people committing to GTK to follow a few rules:
    code, you should always ask. If your change is minor and you've been
    working on GTK for a while it probably isn't necessary to ask. But when
    in doubt, ask. Even if your change is correct, somebody may know a
-   better way to do things. If you are making changes to GTK, you should
-   be subscribed to the [gtk-devel](https://mail.gnome.org/mailman/listinfo/gtk-devel-list)
-   mailing list; this is a good place to ask about intended changes.
-   The `#gtk` IRC channel on irc.gnome.org is also a good place to find GTK
-   developers to discuss changes, but if you live outside of the EU/US time
-   zones, an email to the gtk-devel mailing list is the most certain and
-   preferred method.
+   better way to do things.
+   The `gtk` [room on matrix](https://matrix.to/#/#gtk:gnome.org) is also a
+   good place to find GTK developers to discuss changes, but if you live
+   outside of the EU/US time zones, the [gtk tag on the GNOME Discourse instance](https://discourse.gnome.org/tag/gtk)
+   is the most certain and preferred method.
 
 0. Ask _first_.
 

NEWS

@@ -1,6 +1,123 @@
-Overview of Changes in 4.13.1, xx-xx-xxxx
+Overview of Changes in 4.13.3, xx-xx-xxxx
 =========================================
 
+Overview of Changes in 4.13.2, 22-10-2023
+=========================================
+
+* GtkPrintdialog:
+ - New async-style api to replace GtkPrintOperation
+
+* GtkEmojiChooser:
+ - Add more languages: Bengali, Hindi, Japanese, Finnish,
+   Thai and Norwegian bokmål
+
+* Accessibility:
+ - Fix some utf8 handling issues
+
+* GDK:
+ - Add support for dmabuf textures, with GdkDmabufTextureBuilder
+ - Add a few more supported memory formats for textures
+
+* GSK:
+ - Add a fast-path for masking color
+ - Add support for importing dmabuf textures
+ - Handle GLES better by using some extensions
+
+* Translation updates:
+ Catalan
+ Russian
+ Turkish
+
+
+Overview of Changes in 4.13.1, 28-09-2023
+=========================================
+
+* GtkTooltip:
+ - Don't cross native boundaries when looking for tooltips
+
+* GtkCenterLayout, GtkEntry, GtkSearchEntry:
+ - Fix some issues with baseline handling
+
+* GtkColorButton, GtkFontButton:
+ - Propagate focus-on-click
+
+* GtkFileChooser:
+ - Make "Visit file" scroll to the file
+
+* GtkSwitch:
+ - Respect text direction
+
+* GtkWindow:
+ - Don't assume titlebars are GtkHeaderBars
+
+* Printing:
+ - Fix some problems with the portal implementation
+ - Add a new simple print API: GtkPrintDialog
+
+* Paths:
+ - GskPathMeasure performance has been improved
+ - Add custom contours for circles, rounded rectangles and rectangles
+ - Simplify GskPathPoint handling
+ - gsk_path_point_get_closest_point now returns the distance as well
+ - Make GskPathBuilder simplify curves
+
+* Input:
+ - Handle (some) single-key compose sequences
+ - Fix active state tracking with sensitivity changes and grabs
+
+* GSK:
+ - Make the repeated gradients match between GL and cairo
+ - Make rounded rect shrinking match between Vulkan, GL and cairo
+ - Fix parsing of text nodes with color glyphs
+ - Restrict an optimization to the cases where it is crrect
+ - Fix rendering of shadows with opacity
+ - The Vulkan renderer now requires Vulkan 1.2
+ - GL: Transition gradients unpremultiplied
+ - GL: Fix clipping of shadows
+ - GL: Some optimizations
+ - Broadway: Fix memory leaks in the renderer
+
+* Wayland:
+ - Make activation more reliable
+
+* macOS:
+ - Clamp damage regions to the surface size
+
+* Tools:
+ - gtk4-path-tool gained restrict and reverse commands
+ - gtk4-path-tool show and render can show control points
+
+* Demos:
+ - Add a demo for hit testing with paths
+
+* Build:
+ - Fix build problems with C++ compilers
+
+* Deprecations:
+ - gtk_window_present_with_time
+
+* Translation updates
+ Brazilian Portuguese
+ British English
+ Catalan
+ Chinese (China)
+ Czech
+ Danish
+ Dutch
+ Esperanto
+ Galician
+ Georgian
+ Italian
+ Korean
+ Latvian
+ Lithuanian
+ Persian
+ Polish
+ Punjabi
+ Slovenian
+ Turkish
+
+
 Overview of Changes in 4.13.0, 25-08-2023
 =========================================
 

demos/gtk-demo/application.c

@@ -223,7 +223,7 @@ delete_messages (gpointer data)
 static void
 pop_message (GtkWidget *status)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");
 
   if (messages)
     {
@@ -241,7 +241,7 @@ static void
 push_message (GtkWidget  *status,
               const char *message)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");
 
   gtk_label_set_label (GTK_LABEL (status), message);
   messages = g_list_prepend (messages, g_strdup (message));

demos/gtk-demo/demowidget.c

@@ -34,7 +34,7 @@ transition (GtkWidget     *widget,
 {
   DemoWidget *self = DEMO_WIDGET (widget);
   DemoLayout *demo_layout = DEMO_LAYOUT (gtk_widget_get_layout_manager (widget));
-  gint64 now = g_get_monotonic_time ();
+  gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
 
   gtk_widget_queue_allocate (widget);
 
@@ -66,11 +66,13 @@ clicked (GtkGestureClick *gesture,
          gpointer         data)
 {
   DemoWidget *self = data;
+  GdkFrameClock *frame_clock;
 
   if (self->tick_id != 0)
     return;
 
-  self->start_time = g_get_monotonic_time ();
+  frame_clock = gtk_widget_get_frame_clock (GTK_WIDGET (self));
+  self->start_time = gdk_frame_clock_get_frame_time (frame_clock);
   self->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (self), transition, NULL, NULL);
 }
 

demos/gtk-demo/fishbowl.c

@@ -74,14 +74,7 @@ create_blurred_button (void)
 static GtkWidget *
 create_font_button (void)
 {
-  GtkFontDialog *dialog;
-  GtkWidget *button;
-
-  dialog = gtk_font_dialog_new ();
-  button = gtk_font_dialog_button_new (dialog);
-  g_object_unref (dialog);
-
-  return button;
+  return gtk_font_dialog_button_new (gtk_font_dialog_new ());
 }
 
 static GtkWidget *

demos/gtk-demo/path_fill.c

@@ -2,10 +2,13 @@
  *
  * This demo shows how to use GskPath to draw shapes that are (a bit)
  * more complex than a rounded rectangle.
+ *
+ * It also demonstrates printing to a stream with GtkPrintDialog.
  */
 
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
+#include <cairo-pdf.h>
 
 #include "paintable.h"
 
@@ -165,6 +168,89 @@ gtk_logo_paintable_new (void)
   return GDK_PAINTABLE (self);
 }
 
+static cairo_status_t
+write_cairo (void                *closure,
+             const unsigned char *data,
+             unsigned int         length)
+{
+  GOutputStream *stream = closure;
+  gsize written;
+  GError *error = NULL;
+
+  if (!g_output_stream_write_all (stream, data, length, &written, NULL, &error))
+    {
+      g_print ("Error writing pdf stream: %s\n", error->message);
+      g_error_free (error);
+      return CAIRO_STATUS_WRITE_ERROR;
+    }
+
+  return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+print_ready (GObject      *source,
+             GAsyncResult *result,
+             gpointer      data)
+{
+  GtkPrintDialog *dialog = GTK_PRINT_DIALOG (source);
+  GError *error = NULL;
+  GOutputStream *stream;
+  GtkSnapshot *snapshot;
+  GdkPaintable *paintable;
+  GskRenderNode *node;
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  stream = gtk_print_dialog_print_finish (dialog, result, &error);
+  if (stream == NULL)
+    {
+      g_print ("Failed to get output stream: %s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  snapshot = gtk_snapshot_new ();
+  paintable = gtk_picture_get_paintable (GTK_PICTURE (data));
+  gdk_paintable_snapshot (paintable, snapshot, 100, 100);
+  node = gtk_snapshot_free_to_node (snapshot);
+
+  surface = cairo_pdf_surface_create_for_stream (write_cairo, stream, 100, 100);
+  cr = cairo_create (surface);
+
+  gsk_render_node_draw (node, cr);
+
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+  gsk_render_node_unref (node);
+
+  if (!g_output_stream_close (stream, NULL, &error))
+    {
+      g_print ("Error from close: %s\n", error->message);
+      g_error_free (error);
+    }
+
+  g_object_unref (stream);
+}
+
+static void
+print (GtkButton *button,
+       gpointer   data)
+{
+  GtkWidget *picture = data;
+  GtkPrintDialog *dialog;
+
+  dialog = gtk_print_dialog_new ();
+
+  gtk_print_dialog_print (dialog,
+                          GTK_WINDOW (gtk_widget_get_root (picture)),
+                          NULL,
+                          NULL,
+                          print_ready,
+                          picture);
+
+  g_object_unref (dialog);
+}
+
 GtkWidget *
 do_path_fill (GtkWidget *do_widget)
 {
@@ -172,12 +258,21 @@ do_path_fill (GtkWidget *do_widget)
 
   if (!window)
     {
+      GtkWidget *header, *button, *label;
       GtkWidget *picture;
       GdkPaintable *paintable;
 
       window = gtk_window_new ();
-      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+      gtk_window_set_default_size (GTK_WINDOW (window), 100, 100);
       gtk_window_set_title (GTK_WINDOW (window), "Fill and Stroke");
+      header = gtk_header_bar_new ();
+      button = gtk_button_new_from_icon_name ("printer-symbolic");
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
+      label = gtk_label_new ("Fill and Stroke");
+      gtk_widget_add_css_class (label, "title");
+      gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header), label);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
       g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
       paintable = gtk_logo_paintable_new ();
@@ -186,6 +281,8 @@ do_path_fill (GtkWidget *do_widget)
       gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
       g_object_unref (paintable);
 
+      g_signal_connect (button, "clicked", G_CALLBACK (print), picture);
+
       gtk_window_set_child (GTK_WINDOW (window), picture);
     }
 

demos/gtk-demo/path_maze.c

@@ -8,6 +8,7 @@
  * is a rather complex path.
  */
 
+#include "config.h"
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
@@ -131,6 +132,24 @@ gtk_maze_class_init (GtkMazeClass *klass)
   widget_class->snapshot = gtk_maze_snapshot;
 }
 
+static void
+celebrate (gboolean win)
+{
+  char *path;
+  GtkMediaStream *stream;
+
+  if (win)
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "complete.oga", NULL);
+  else
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "suspend-error.oga", NULL);
+  stream = gtk_media_file_new_for_filename (path);
+  gtk_media_stream_set_volume (stream, 1.0);
+  gtk_media_stream_play (stream);
+
+  g_signal_connect (stream, "notify::ended", G_CALLBACK (g_object_unref), NULL);
+  g_free (path);
+}
+
 static void
 pointer_motion (GtkEventControllerMotion *controller,
                 double                    x,
@@ -153,6 +172,8 @@ pointer_motion (GtkEventControllerMotion *controller,
         return;
     }
 
+  celebrate (FALSE);
+
   self->active = FALSE;
   gtk_widget_queue_draw (GTK_WIDGET (self));
 }

demos/gtk-demo/path_spinner.c

@@ -9,6 +9,8 @@
 
 #include "paintable.h"
 
+#undef SHOW_CONTROLS
+
 #define GTK_TYPE_SPINNER_PAINTABLE (gtk_spinner_paintable_get_type ())
 G_DECLARE_FINAL_TYPE (GtkSpinnerPaintable, gtk_spinner_paintable, GTK, SPINNER_PAINTABLE, GObject)
 
@@ -150,6 +152,7 @@ static gboolean
 add_controls (GskPathOperation        op,
               const graphene_point_t *pts,
               gsize                   n_pts,
+              float                   weight,
               gpointer                data)
 {
   GskPathBuilder *builder = data;
@@ -166,7 +169,7 @@ add_controls (GskPathOperation        op,
       break;
 
     case GSK_PATH_QUAD:
-    case GSK_PATH_ARC:
+    case GSK_PATH_CONIC:
       gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
       gsk_path_builder_line_to (builder, pts[2].x, pts[2].y);
       break;

demos/gtk-demo/path_walk.ui

@@ -11,6 +11,8 @@
                 <property name="lower">0</property>
                 <property name="upper">5000</property>
                 <property name="value">500</property>
+                <property name="step-increment">1</property>
+                <property name="page-increment">10</property>
               </object>
             </property>
           </object>

demos/gtk-demo/pickers.c

@@ -1,8 +1,9 @@
 /* Pickers and Launchers
- * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkFileLauncher, GtkUriLauncher
+ * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkPrintDialog, GtkFileLauncher, GtkUriLauncher
  *
  * The dialogs are mainly intended for use in preference dialogs.
- * They allow to select colors, fonts and applications.
+ * They allow to select colors, fonts and files. There is also a
+ * print dialog.
  *
  * The launchers let you open files or URIs in applications that
  * can handle them.
@@ -11,11 +12,13 @@
 #include <gtk/gtk.h>
 
 static GtkWidget *app_picker;
+static GtkWidget *print_button;
 
 static void
 set_file (GFile    *file,
           gpointer  data)
 {
+  GFileInfo *info;
   char *name;
 
   if (!file)
@@ -31,6 +34,13 @@ set_file (GFile    *file,
 
   gtk_widget_set_sensitive (app_picker, TRUE);
   g_object_set_data_full (G_OBJECT (app_picker), "file", g_object_ref (file), g_object_unref);
+
+  info = g_file_query_info (file, "standard::content-type", 0, NULL, NULL);
+  if (strcmp (g_file_info_get_content_type (info), "application/pdf") == 0)
+    {
+      gtk_widget_set_sensitive (print_button, TRUE);
+      g_object_set_data_full (G_OBJECT (print_button), "file", g_object_ref (file), g_object_unref);
+    }
 }
 
 static void
@@ -47,6 +57,10 @@ file_opened (GObject *source,
     {
       g_print ("%s\n", error->message);
       g_error_free (error);
+      gtk_widget_set_sensitive (app_picker, FALSE);
+      g_object_set_data (G_OBJECT (app_picker), "file", NULL);
+      gtk_widget_set_sensitive (print_button, FALSE);
+      g_object_set_data (G_OBJECT (print_button), "file", NULL);
     }
 
   set_file (file, data);
@@ -114,6 +128,53 @@ open_app (GtkButton *picker)
   g_object_unref (launcher);
 }
 
+static void
+print_file_done (GObject      *source,
+                 GAsyncResult *result,
+                 gpointer      data)
+{
+  GtkPrintDialog *dialog = GTK_PRINT_DIALOG (source);
+  GError *error = NULL;
+  GCancellable *cancellable;
+  unsigned int id;
+
+  cancellable = g_task_get_cancellable (G_TASK (result));
+  id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cancellable), "timeout"));
+  if (id)
+    g_source_remove (id);
+
+  if (!gtk_print_dialog_print_file_finish (dialog, result, &error))
+    {
+      g_print ("%s\n", error->message);
+      g_error_free (error);
+    }
+}
+
+static void
+print_file (GtkButton *picker)
+{
+  GtkWindow *parent = GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (picker)));
+  GtkPrintDialog *dialog;
+  GCancellable *cancellable;
+  GFile *file;
+  unsigned int id;
+
+  file = G_FILE (g_object_get_data (G_OBJECT (picker), "file"));
+  dialog = gtk_print_dialog_new ();
+
+  cancellable = g_cancellable_new ();
+
+  id = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+                                   20,
+                                   abort_mission, g_object_ref (cancellable), g_object_unref);
+  g_object_set_data (G_OBJECT (cancellable), "timeout", GUINT_TO_POINTER (id));
+
+  gtk_print_dialog_print_file (dialog, parent, NULL, file, cancellable, print_file_done, NULL);
+
+  g_object_unref (cancellable);
+  g_object_unref (dialog);
+}
+
 static void
 open_uri_done (GObject      *source,
                GAsyncResult *result,
@@ -234,8 +295,14 @@ do_pickers (GtkWidget *do_widget)
     gtk_widget_set_sensitive (app_picker, FALSE);
     g_signal_connect (app_picker, "clicked", G_CALLBACK (open_app), NULL);
     gtk_box_append (GTK_BOX (picker), app_picker);
-    gtk_grid_attach (GTK_GRID (table), picker, 1, 2, 1, 1);
 
+    print_button = gtk_button_new_from_icon_name ("printer-symbolic");
+    gtk_widget_set_tooltip_text (print_button, "Print file");
+    gtk_widget_set_sensitive (print_button, FALSE);
+    g_signal_connect (print_button, "clicked", G_CALLBACK (print_file), NULL);
+    gtk_box_append (GTK_BOX (picker), print_button);
+
+    gtk_grid_attach (GTK_GRID (table), picker, 1, 2, 1, 1);
 
     label = gtk_label_new ("URI:");
     gtk_widget_set_halign (label, GTK_ALIGN_START);

docs/reference/gtk/gtk4-path-tool.rst

@@ -55,6 +55,22 @@ Showing
 The ``show`` command displays the given path in a window. The interior
 of the path is filled.
 
+``--fill``
+
+  Fill the path (this is the default).
+
+``--stroke``
+
+  Stroke the path instead of filling it.
+
+``--points``
+
+  Show points on the path.
+
+``--controls``
+
+  Show control points.
+
 ``--fill-rule=VALUE``
 
   The fill rule that is used to determine what areas are inside the path.
@@ -70,13 +86,10 @@ of the path is filled.
   The color that is used to render the background behind the path.
   If not specified, white is used.
 
-``--fill``
+``--point-color=COLOR``
 
-  Fill the path (this is the default).
-
-``--stroke``
-
-  Stroke the path instead of filling it.
+  The color that is used to render the points.
+  If not specified, red is used.
 
 ``--line-width=VALUE``
 
@@ -119,6 +132,22 @@ Rendering
 The ``render`` command renders the given path as a PNG image.
 The interior of the path is filled.
 
+``--fill``
+
+  Fill the path (this is the default).
+
+``--stroke``
+
+  Stroke the path instead of filling it.
+
+``--points``
+
+  Show points on the path.
+
+``--controls``
+
+  Show control points.
+
 ``--fill-rule=VALUE``
 
   The fill rule that is used to determine what areas are inside the path.
@@ -134,19 +163,16 @@ The interior of the path is filled.
   The color that is used to render the background behind the path.
   If not specified, white is used.
 
+``--point-color=COLOR``
+
+  The color that is used to render the points.
+  If not specified, red is used.
+
 ``--output-file=FILE``
 
   The file to save the PNG image to.
   If not specified, "path.png" is used.
 
-``--fill``
-
-  Fill the path (this is the default).
-
-``--stroke``
-
-  Stroke the path instead of filling it.
-
 ``--line-width=VALUE``
 
   The line width to use for the stroke. ``VALUE`` must be a positive number.

docs/reference/gtk/running.md

@@ -170,35 +170,41 @@ This variable can be set to a list of debug options, which cause GDK to
 print out different types of debugging information. Some of these options
 are only available when GTK has been configured with `-Ddebug=true`.
 
-`cursor`
-: Information about cursor objects (only win32)
+`misc`
+: Miscellaneous information
+
+`events`
+: Information about events
+
+`dnd`
+: Information about drag-and-drop
+
+`input`
+: Information about input (mostly Windows)
 
 `eventloop`
 : Information about event loop operation (mostly macOS)
 
-`misc`
-: Miscellaneous information
-
 `frames`
 : Information about the frame clock
 
 `settings`
 : Information about xsettings
 
+`opengl`
+: Information about OpenGL
+
+`vulkan`
+: Information about Vulkan
+
 `selection`
 : Information about selections
 
 `clipboard`
 : Information about clipboards
 
-`dnd`
-: Information about drag-and-drop
-
-`opengl`
-: Information about OpenGL
-
-`vulkan`
-: Information about Vulkan
+`dmabuf`
+: Information about dmabuf handling (Linux-only)
 
 A number of options affect behavior instead of logging:
 
@@ -217,6 +223,9 @@ A number of options affect behavior instead of logging:
 `gl-fractional`
 : Enable fractional scaling for OpenGL. This is experimental
 
+`gl-debug`
+: Insert debugging information in OpenGL
+
 `gl-legacy`
 : Use a legacy OpenGL context
 
@@ -244,6 +253,12 @@ A number of options affect behavior instead of logging:
 `high-depth`
 : Use high bit depth rendering if possible
 
+`no-vsync`
+: Repaint instantly (uses 100% CPU with animations)
+
+`dmabuf-disable`
+: Disable dmabuf support
+
 The special value `all` can be used to turn on all debug options. The special
 value `help` can be used to obtain a list of all supported debug options.
 

gdk/gdk.c

@@ -117,6 +117,8 @@ static const GdkDebugKey gdk_debug_keys[] = {
   { "vulkan",          GDK_DEBUG_VULKAN, "Information about Vulkan" },
   { "selection",       GDK_DEBUG_SELECTION, "Information about selections" },
   { "clipboard",       GDK_DEBUG_CLIPBOARD, "Information about clipboards" },
+  { "dmabuf",          GDK_DEBUG_DMABUF, "Information about dmabuf buffers" },
+
   { "nograbs",         GDK_DEBUG_NOGRABS, "Disable pointer and keyboard grabs (X11)", TRUE },
   { "portals",         GDK_DEBUG_PORTALS, "Force use of portals", TRUE },
   { "no-portals",      GDK_DEBUG_NO_PORTALS, "Disable use of portals", TRUE },
@@ -133,6 +135,7 @@ static const GdkDebugKey gdk_debug_keys[] = {
   { "default-settings",GDK_DEBUG_DEFAULT_SETTINGS, "Force default values for xsettings", TRUE },
   { "high-depth",      GDK_DEBUG_HIGH_DEPTH, "Use high bit depth rendering if possible", TRUE },
   { "no-vsync",        GDK_DEBUG_NO_VSYNC, "Repaint instantly (uses 100% CPU with animations)", TRUE },
+  { "dmabuf-disable",  GDK_DEBUG_DMABUF_DISABLE, "Disable dmabuf support", TRUE },
 };
 
 
@@ -263,7 +266,7 @@ gdk_parse_debug_var (const char        *variable,
         if (debug_enabled || keys[i].always_enabled)
           fprintf (stderr, "  %s%*s%s\n", keys[i].key, (int)(max_width - strlen (keys[i].key)), " ", keys[i].help);
       }
-      fprintf (stderr, "  %s%*s%s\n", "all", max_width - 3, " ", "Enable all values");
+      fprintf (stderr, "  %s%*s%s\n", "all", max_width - 3, " ", "Enable all values. Other given values are subtracted");
       fprintf (stderr, "  %s%*s%s\n", "help", max_width - 4, " ", "Print this help");
       fprintf (stderr, "\nMultiple values can be given, separated by : or space.\n");
     }

gdk/gdk.h

@@ -42,6 +42,9 @@
 #include <gdk/gdkdevicetool.h>
 #include <gdk/gdkdisplay.h>
 #include <gdk/gdkdisplaymanager.h>
+#include <gdk/gdkdmabufformats.h>
+#include <gdk/gdkdmabuftexture.h>
+#include <gdk/gdkdmabuftexturebuilder.h>
 #include <gdk/gdkdrag.h>
 #include <gdk/gdkdragsurface.h>
 #include <gdk/gdkdragsurfacesize.h>

gdk/gdkarrayimpl.c

@@ -82,6 +82,18 @@ gdk_array(init) (GdkArray *self)
 #endif
 }
 
+G_GNUC_UNUSED static inline gsize
+gdk_array(get_capacity) (const GdkArray *self)
+{
+  return self->end_allocation - self->start;
+}
+
+G_GNUC_UNUSED static inline gsize
+gdk_array(get_size) (const GdkArray *self)
+{
+  return self->end - self->start;
+}
+
 static inline void
 gdk_array(free_elements) (_T_ *start,
                           _T_ *end)
@@ -110,6 +122,38 @@ gdk_array(clear) (GdkArray *self)
   gdk_array(init) (self);
 }
 
+/*
+ * gdk_array_steal:
+ * @self: the array
+ *
+ * Steals all data in the array and clears the array.
+ *
+ * If you need to know the size of the data, you should query it
+ * beforehand.
+ *
+ * Returns: The array's data
+ **/
+G_GNUC_UNUSED static inline _T_ *
+gdk_array(steal) (GdkArray *self)
+{
+  _T_ *result;
+
+#ifdef GDK_ARRAY_PREALLOC
+  if (self->start == self->preallocated)
+    {
+      gsize size = GDK_ARRAY_REAL_SIZE (gdk_array(get_size) (self));
+      result = g_new (_T_, size);
+      memcpy (result, self->preallocated, sizeof (_T_) * size);
+    }
+  else
+#endif
+    result = self->start;
+
+  gdk_array(init) (self);
+
+  return result;
+}
+
 G_GNUC_UNUSED static inline _T_ *
 gdk_array(get_data) (const GdkArray *self)
 {
@@ -123,18 +167,6 @@ gdk_array(index) (const GdkArray *self,
   return self->start + pos;
 }
 
-G_GNUC_UNUSED static inline gsize
-gdk_array(get_capacity) (const GdkArray *self)
-{
-  return self->end_allocation - self->start;
-}
-
-G_GNUC_UNUSED static inline gsize
-gdk_array(get_size) (const GdkArray *self)
-{
-  return self->end - self->start;
-}
-
 G_GNUC_UNUSED static inline gboolean
 gdk_array(is_empty) (const GdkArray *self)
 {
@@ -151,7 +183,7 @@ gdk_array(reserve) (GdkArray *self,
     return;
 
   size = gdk_array(get_size) (self);
-  new_size = 1 << g_bit_storage (MAX (GDK_ARRAY_REAL_SIZE (n), 16) - 1);
+  new_size = ((gsize) 1) << g_bit_storage (MAX (GDK_ARRAY_REAL_SIZE (n), 16) - 1);
 
 #ifdef GDK_ARRAY_PREALLOC
   if (self->start == self->preallocated)
@@ -183,7 +215,11 @@ gdk_array(splice) (GdkArray *self,
                    gsize      pos,
                    gsize      removed,
                    gboolean   stolen,
+#ifdef GDK_ARRAY_BY_VALUE
+                   const _T_ *additions,
+#else
                    _T_       *additions,
+#endif
                    gsize      added)
 {
   gsize size;
@@ -286,3 +322,5 @@ gdk_array(get) (const GdkArray *self,
 #undef GDK_ARRAY_TYPE_NAME
 #undef GDK_ARRAY_NO_MEMSET
 #endif
+
+G_END_DECLS

gdk/gdkdebugprivate.h

@@ -36,23 +36,26 @@ typedef enum {
   GDK_DEBUG_VULKAN          = 1 <<  8,
   GDK_DEBUG_SELECTION       = 1 <<  9,
   GDK_DEBUG_CLIPBOARD       = 1 << 10,
+  GDK_DEBUG_DMABUF          = 1 << 11,
+
   /* flags below are influencing behavior */
-  GDK_DEBUG_NOGRABS         = 1 << 11,
-  GDK_DEBUG_PORTALS         = 1 << 12,
-  GDK_DEBUG_NO_PORTALS      = 1 << 13,
-  GDK_DEBUG_GL_DISABLE      = 1 << 14,
-  GDK_DEBUG_GL_FRACTIONAL   = 1 << 15,
-  GDK_DEBUG_GL_LEGACY       = 1 << 16,
-  GDK_DEBUG_GL_GLES         = 1 << 17,
-  GDK_DEBUG_GL_DEBUG        = 1 << 18,
-  GDK_DEBUG_GL_EGL          = 1 << 19,
-  GDK_DEBUG_GL_GLX          = 1 << 20,
-  GDK_DEBUG_GL_WGL          = 1 << 21,
-  GDK_DEBUG_VULKAN_DISABLE  = 1 << 22,
-  GDK_DEBUG_VULKAN_VALIDATE = 1 << 23,
-  GDK_DEBUG_DEFAULT_SETTINGS= 1 << 24,
-  GDK_DEBUG_HIGH_DEPTH      = 1 << 25,
-  GDK_DEBUG_NO_VSYNC        = 1 << 26,
+  GDK_DEBUG_NOGRABS         = 1 << 12,
+  GDK_DEBUG_PORTALS         = 1 << 13,
+  GDK_DEBUG_NO_PORTALS      = 1 << 14,
+  GDK_DEBUG_GL_DISABLE      = 1 << 15,
+  GDK_DEBUG_GL_FRACTIONAL   = 1 << 16,
+  GDK_DEBUG_GL_LEGACY       = 1 << 17,
+  GDK_DEBUG_GL_GLES         = 1 << 18,
+  GDK_DEBUG_GL_DEBUG        = 1 << 19,
+  GDK_DEBUG_GL_EGL          = 1 << 20,
+  GDK_DEBUG_GL_GLX          = 1 << 21,
+  GDK_DEBUG_GL_WGL          = 1 << 22,
+  GDK_DEBUG_VULKAN_DISABLE  = 1 << 23,
+  GDK_DEBUG_VULKAN_VALIDATE = 1 << 24,
+  GDK_DEBUG_DEFAULT_SETTINGS= 1 << 25,
+  GDK_DEBUG_HIGH_DEPTH      = 1 << 26,
+  GDK_DEBUG_NO_VSYNC        = 1 << 27,
+  GDK_DEBUG_DMABUF_DISABLE  = 1 << 28,
 } GdkDebugFlags;
 
 extern guint _gdk_debug_flags;

gdk/gdkdisplay.c

@@ -31,6 +31,9 @@
 #include "gdkclipboardprivate.h"
 #include "gdkdeviceprivate.h"
 #include "gdkdisplaymanagerprivate.h"
+#include "gdkdmabufformatsbuilderprivate.h"
+#include "gdkdmabufformatsprivate.h"
+#include "gdkdmabuftextureprivate.h"
 #include "gdkeventsprivate.h"
 #include "gdkframeclockidleprivate.h"
 #include "gdkglcontextprivate.h"
@@ -69,6 +72,7 @@ enum
   PROP_COMPOSITED,
   PROP_RGBA,
   PROP_INPUT_SHAPES,
+  PROP_DMABUF_FORMATS,
   LAST_PROP
 };
 
@@ -138,6 +142,10 @@ gdk_display_get_property (GObject    *object,
       g_value_set_boolean (value, gdk_display_supports_input_shapes (display));
       break;
 
+    case PROP_DMABUF_FORMATS:
+      g_value_set_boxed (value, gdk_display_get_dmabuf_formats (display));
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -239,6 +247,11 @@ gdk_display_class_init (GdkDisplayClass *class)
                           TRUE,
                           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 
+  props[PROP_DMABUF_FORMATS] =
+    g_param_spec_boxed ("dmabuf-formats", NULL, NULL,
+                        GDK_TYPE_DMABUF_FORMATS,
+                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
   g_object_class_install_properties (object_class, LAST_PROP, props);
 
   /**
@@ -378,6 +391,9 @@ gdk_display_dispose (GObject *object)
 
   g_queue_clear (&display->queued_events);
 
+  g_clear_object (&display->egl_gsk_renderer);
+  g_clear_pointer (&display->egl_external_formats, gdk_dmabuf_formats_unref);
+
   g_clear_object (&priv->gl_context);
 #ifdef HAVE_EGL
   g_clear_pointer (&priv->egl_display, eglTerminate);
@@ -404,6 +420,8 @@ gdk_display_finalize (GObject *object)
 
   g_list_free_full (display->seats, g_object_unref);
 
+  g_clear_pointer (&display->dmabuf_formats, gdk_dmabuf_formats_unref);
+
   G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
 }
 
@@ -473,8 +491,7 @@ gdk_display_get_event (GdkDisplay *display)
  * @display: a `GdkDisplay`
  * @event: (transfer none): a `GdkEvent`
  *
- * Appends the given event onto the front of the event
- * queue for @display.
+ * Adds the given event to the event queue for @display.
  *
  * Deprecated: 4.10: This function is only useful in very
  * special situations and should not be used by applications.
@@ -1756,6 +1773,10 @@ gdk_display_init_egl (GdkDisplay  *self,
     epoxy_has_egl_extension (priv->egl_display, "EGL_KHR_no_config_context");
   self->have_egl_pixel_format_float =
     epoxy_has_egl_extension (priv->egl_display, "EGL_EXT_pixel_format_float");
+  self->have_egl_dma_buf_import =
+    epoxy_has_egl_extension (priv->egl_display, "EGL_EXT_image_dma_buf_import_modifiers");
+  self->have_egl_dma_buf_export =
+    epoxy_has_egl_extension (priv->egl_display, "EGL_MESA_image_dma_buf_export");
 
   if (self->have_egl_no_config_context)
     priv->egl_config_high_depth = gdk_display_create_egl_config (self,
@@ -1825,6 +1846,92 @@ gdk_display_get_egl_display (GdkDisplay *self)
 #endif
 }
 
+#ifdef HAVE_DMABUF
+static void
+gdk_display_add_dmabuf_downloader (GdkDisplay                *display,
+                                   const GdkDmabufDownloader *downloader,
+                                   GdkDmabufFormatsBuilder   *builder)
+{
+  gsize i;
+
+  if (!downloader->add_formats (downloader, display, builder))
+    return;
+
+  /* dmabuf_downloaders is NULL-terminated */
+  for (i = 0; i < G_N_ELEMENTS (display->dmabuf_downloaders) - 1; i++)
+    {
+      if (display->dmabuf_downloaders[i] == NULL)
+        break;
+    }
+
+  g_assert (i < G_N_ELEMENTS (display->dmabuf_downloaders));
+
+  display->dmabuf_downloaders[i] = downloader;
+}
+#endif
+
+/* To support a drm format, we must be able to import it into GL
+ * using the relevant EGL extensions, and download it into a memory
+ * texture, possibly doing format conversion with shaders (in GSK).
+ */
+void
+gdk_display_init_dmabuf (GdkDisplay *self)
+{
+  GdkDmabufFormatsBuilder *builder;
+
+  if (self->dmabuf_formats != NULL)
+    return;
+
+  GDK_DISPLAY_DEBUG (self, DMABUF,
+                     "Beginning initialization of dmabuf support");
+
+  builder = gdk_dmabuf_formats_builder_new ();
+
+#ifdef HAVE_DMABUF
+  if (!GDK_DEBUG_CHECK (DMABUF_DISABLE))
+    {
+      gdk_display_prepare_gl (self, NULL);
+
+      gdk_display_add_dmabuf_downloader (self, gdk_dmabuf_get_direct_downloader (), builder);
+
+#ifdef HAVE_EGL
+      if (gdk_display_prepare_gl (self, NULL))
+        gdk_display_add_dmabuf_downloader (self, gdk_dmabuf_get_egl_downloader (), builder);
+#endif
+    }
+#endif
+
+  self->dmabuf_formats = gdk_dmabuf_formats_builder_free_to_formats (builder);
+
+  GDK_DISPLAY_DEBUG (self, DMABUF,
+                     "Initialized support for %zu dmabuf formats",
+                     gdk_dmabuf_formats_get_n_formats (self->dmabuf_formats));
+}
+
+/**
+ * gdk_display_get_dmabuf_formats:
+ * @display: a `GdkDisplay`
+ *
+ * Returns the dma-buf formats that are supported on this display.
+ *
+ * GTK may use OpenGL or Vulkan to support some formats.
+ * Calling this function will then initialize them if they aren't yet.
+ *
+ * The formats returned by this function can be used for negotiating
+ * buffer formats with producers such as v4l, pipewire or GStreamer.
+ *
+ * Returns: (transfer none): a `GdkDmabufFormats` object
+ *
+ * Since: 4.14
+ */
+GdkDmabufFormats *
+gdk_display_get_dmabuf_formats (GdkDisplay *display)
+{
+  gdk_display_init_dmabuf (display);
+
+  return display->dmabuf_formats;
+}
+
 GdkDebugFlags
 gdk_display_get_debug_flags (GdkDisplay *display)
 {

gdk/gdkdisplay.h

@@ -134,6 +134,10 @@ gboolean     gdk_display_get_setting (GdkDisplay *display,
                                       const char *name,
                                       GValue     *value);
 
+GDK_AVAILABLE_IN_4_14
+GdkDmabufFormats *
+             gdk_display_get_dmabuf_formats (GdkDisplay *display);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDisplay, g_object_unref)
 
 G_END_DECLS

gdk/gdkdisplayprivate.h

@@ -25,6 +25,7 @@
 #include "gdksurfaceprivate.h"
 #include "gdkkeysprivate.h"
 #include "gdkdeviceprivate.h"
+#include "gdkdmabufprivate.h"
 
 #ifdef GDK_RENDERING_VULKAN
 #include <vulkan/vulkan.h>
@@ -113,6 +114,15 @@ struct _GdkDisplay
   guint have_egl_buffer_age : 1;
   guint have_egl_no_config_context : 1;
   guint have_egl_pixel_format_float : 1;
+  guint have_egl_dma_buf_import : 1;
+  guint have_egl_dma_buf_export : 1;
+
+  GdkDmabufFormats *dmabuf_formats;
+  const GdkDmabufDownloader *dmabuf_downloaders[4];
+
+   /* Cached data the EGL dmabuf downloader */
+  gpointer egl_gsk_renderer;
+  GdkDmabufFormats *egl_external_formats;
 };
 
 struct _GdkDisplayClass
@@ -207,6 +217,8 @@ gulong              _gdk_display_get_next_serial      (GdkDisplay       *display
 void                _gdk_display_pause_events         (GdkDisplay       *display);
 void                _gdk_display_unpause_events       (GdkDisplay       *display);
 
+void                gdk_display_init_dmabuf           (GdkDisplay       *self);
+
 GdkVulkanContext *  gdk_display_create_vulkan_context (GdkDisplay       *self,
                                                        GError          **error);
 

gdk/gdkdmabuf.c

@@ -0,0 +1,745 @@
+/* gdkdmabuf.c
+ *
+ * Copyright 2023  Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gdkdmabufprivate.h"
+
+#include "gdkdebugprivate.h"
+#include "gdkdmabuftextureprivate.h"
+#include "gdkmemoryformatprivate.h"
+
+#ifdef HAVE_DMABUF
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-buf.h>
+#include <drm_fourcc.h>
+#include <epoxy/egl.h>
+
+typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
+
+struct _GdkDrmFormatInfo
+{
+  guint32 fourcc;
+  GdkMemoryFormat premultiplied_memory_format;
+  GdkMemoryFormat unpremultiplied_memory_format;
+  void (* download) (guchar          *dst_data,
+                     gsize            dst_stride,
+                     GdkMemoryFormat  dst_format,
+                     gsize            width,
+                     gsize            height,
+                     const GdkDmabuf *dmabuf,
+                     const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+                     gsize            sizes[GDK_DMABUF_MAX_PLANES]);
+};
+
+static void
+download_memcpy (guchar          *dst_data,
+                 gsize            dst_stride,
+                 GdkMemoryFormat  dst_format,
+                 gsize            width,
+                 gsize            height,
+                 const GdkDmabuf *dmabuf,
+                 const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+                 gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *src_data;
+  gsize src_stride;
+  guint bpp;
+
+  bpp = gdk_memory_format_bytes_per_pixel (dst_format);
+  src_stride = dmabuf->planes[0].stride;
+  src_data = src_datas[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + (height - 1) * dst_stride + width * bpp);
+
+  if (dst_stride == src_stride)
+    memcpy (dst_data, src_data, (height - 1) * dst_stride + width * bpp);
+  else
+    {
+      gsize i;
+
+      for (i = 0; i < height; i++)
+        memcpy (dst_data + i * dst_stride, src_data + i * src_stride, width * bpp);
+    }
+}
+
+typedef struct _YUVCoefficients YUVCoefficients;
+
+struct _YUVCoefficients
+{
+  int v_to_r;
+  int u_to_g;
+  int v_to_g;
+  int u_to_b;
+};
+
+/* multiplied by 65536 */
+//static const YUVCoefficients itu601_narrow = { 104597, -25675, -53279, 132201 };
+static const YUVCoefficients itu601_wide = { 74711, -25864, -38050, 133176 };
+
+static inline void
+get_uv_values (const YUVCoefficients *coeffs,
+               guint8                 u,
+               guint8                 v,
+               int                   *out_r,
+               int                   *out_g,
+               int                   *out_b)
+{
+  int u2 = (int) u - 127;
+  int v2 = (int) v - 127;
+  *out_r = coeffs->v_to_r * v2;
+  *out_g = coeffs->u_to_g * u2 + coeffs->v_to_g * v2;
+  *out_b = coeffs->u_to_b * u2;
+}
+
+static inline void
+set_rgb_values (guint8 rgb[3],
+                guint8 y,
+                int    r,
+                int    g,
+                int    b)
+{
+  int y2 = y * 65536;
+
+  rgb[0] = CLAMP ((y2 + r) >> 16, 0, 255);
+  rgb[1] = CLAMP ((y2 + g) >> 16, 0, 255);
+  rgb[2] = CLAMP ((y2 + b) >> 16, 0, 255);
+}
+
+static void
+download_nv12 (guchar          *dst_data,
+               gsize            dst_stride,
+               GdkMemoryFormat  dst_format,
+               gsize            width,
+               gsize            height,
+               const GdkDmabuf *dmabuf,
+               const guchar    *src_data[GDK_DMABUF_MAX_PLANES],
+               gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *y_data, *uv_data;
+  gsize x, y, y_stride, uv_stride;
+  gsize U, V, X_SUB, Y_SUB;
+
+  switch (dmabuf->fourcc)
+    {
+    case DRM_FORMAT_NV12:
+      U = 0; V = 1; X_SUB = 2; Y_SUB = 2;
+      break;
+    case DRM_FORMAT_NV21:
+      U = 1; V = 0; X_SUB = 2; Y_SUB = 2;
+      break;
+    case DRM_FORMAT_NV16:
+      U = 0; V = 1; X_SUB = 2; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_NV61:
+      U = 1; V = 0; X_SUB = 2; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_NV24:
+      U = 0; V = 1; X_SUB = 1; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_NV42:
+      U = 1; V = 0; X_SUB = 1; Y_SUB = 1;
+      break;
+    default:
+      g_assert_not_reached ();
+      return;
+    }
+
+  y_stride = dmabuf->planes[0].stride;
+  y_data = src_data[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * y_stride);
+  uv_stride = dmabuf->planes[1].stride;
+  uv_data = src_data[1] + dmabuf->planes[1].offset;
+  g_return_if_fail (sizes[1] >= dmabuf->planes[1].offset + (height + Y_SUB - 1) / Y_SUB * uv_stride);
+
+  for (y = 0; y < height; y += Y_SUB)
+    {
+      for (x = 0; x < width; x += X_SUB)
+        {
+          int r, g, b;
+          gsize xs, ys;
+
+          get_uv_values (&itu601_wide, uv_data[x / X_SUB * 2 + U], uv_data[x / X_SUB * 2 + V], &r, &g, &b);
+
+          for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
+            for (xs = 0; xs < X_SUB && x + xs < width; xs++)
+              set_rgb_values (&dst_data[3 * (x + xs) + dst_stride * ys], y_data[x + xs + y_stride * ys], r, g, b);
+        }
+      dst_data += Y_SUB * dst_stride;
+      y_data += Y_SUB * y_stride;
+      uv_data += uv_stride;
+    }
+}
+
+static void
+download_yuv_3 (guchar          *dst_data,
+                gsize            dst_stride,
+                GdkMemoryFormat  dst_format,
+                gsize            width,
+                gsize            height,
+                const GdkDmabuf *dmabuf,
+                const guchar    *src_data[GDK_DMABUF_MAX_PLANES],
+                gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *y_data, *u_data, *v_data;
+  gsize x, y, y_stride, u_stride, v_stride;
+  gsize U, V, X_SUB, Y_SUB;
+
+  switch (dmabuf->fourcc)
+    {
+    case DRM_FORMAT_YUV410:
+      U = 1; V = 2; X_SUB = 4; Y_SUB = 4;
+      break;
+    case DRM_FORMAT_YVU410:
+      U = 2; V = 1; X_SUB = 4; Y_SUB = 4;
+      break;
+    case DRM_FORMAT_YUV411:
+      U = 1; V = 2; X_SUB = 4; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_YVU411:
+      U = 2; V = 1; X_SUB = 4; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_YUV420:
+      U = 1; V = 2; X_SUB = 2; Y_SUB = 2;
+      break;
+    case DRM_FORMAT_YVU420:
+      U = 2; V = 1; X_SUB = 2; Y_SUB = 2;
+      break;
+    case DRM_FORMAT_YUV422:
+      U = 1; V = 2; X_SUB = 2; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_YVU422:
+      U = 2; V = 1; X_SUB = 2; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_YUV444:
+      U = 1; V = 2; X_SUB = 1; Y_SUB = 1;
+      break;
+    case DRM_FORMAT_YVU444:
+      U = 2; V = 1; X_SUB = 1; Y_SUB = 1;
+      break;
+    default:
+      g_assert_not_reached ();
+      return;
+    }
+
+  y_stride = dmabuf->planes[0].stride;
+  y_data = src_data[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * y_stride);
+  u_stride = dmabuf->planes[U].stride;
+  u_data = src_data[U] + dmabuf->planes[U].offset;
+  g_return_if_fail (sizes[U] >= dmabuf->planes[U].offset + (height + Y_SUB - 1) / Y_SUB * u_stride);
+  v_stride = dmabuf->planes[V].stride;
+  v_data = src_data[V] + dmabuf->planes[V].offset;
+  g_return_if_fail (sizes[V] >= dmabuf->planes[V].offset + (height + Y_SUB - 1) / Y_SUB * v_stride);
+
+  for (y = 0; y < height; y += Y_SUB)
+    {
+      for (x = 0; x < width; x += X_SUB)
+        {
+          int r, g, b;
+          gsize xs, ys;
+
+          get_uv_values (&itu601_wide, u_data[x / X_SUB], v_data[x / X_SUB], &r, &g, &b);
+
+          for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
+            for (xs = 0; xs < X_SUB && x + xs < width; xs++)
+              set_rgb_values (&dst_data[3 * (x + xs) + dst_stride * ys], y_data[x + xs + y_stride * ys], r, g, b);
+        }
+      dst_data += Y_SUB * dst_stride;
+      y_data += Y_SUB * y_stride;
+      u_data += u_stride;
+      v_data += v_stride;
+    }
+}
+
+static void
+download_yuyv (guchar          *dst_data,
+               gsize            dst_stride,
+               GdkMemoryFormat  dst_format,
+               gsize            width,
+               gsize            height,
+               const GdkDmabuf *dmabuf,
+               const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+               gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *src_data;
+  gsize x, y, src_stride;
+  gsize Y1, Y2, U, V;
+
+  switch (dmabuf->fourcc)
+    {
+    case DRM_FORMAT_YUYV:
+      Y1 = 0; U = 1; Y2 = 2; V = 3;
+      break;
+    case DRM_FORMAT_YVYU:
+      Y1 = 0; V = 1; Y2 = 2; U = 3;
+      break;
+    case DRM_FORMAT_UYVY:
+      U = 0; Y1 = 1; V = 2; Y2 = 3;
+      break;
+    case DRM_FORMAT_VYUY:
+      V = 0; Y1 = 1; U = 2; Y2 = 3;
+      break;
+    default:
+      g_assert_not_reached ();
+      return;
+    }
+
+  src_stride = dmabuf->planes[0].stride;
+  src_data = src_datas[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * src_stride);
+
+  for (y = 0; y < height; y ++)
+    {
+      for (x = 0; x < width; x += 2)
+        {
+          int r, g, b;
+
+          get_uv_values (&itu601_wide, src_data[2 * x + U], src_data[2 * x + V], &r, &g, &b);
+          set_rgb_values (&dst_data[3 * x], src_data[2 * x + Y1], r, g, b);
+          if (x + 1 < width)
+            set_rgb_values (&dst_data[3 * (x + 1)], src_data[2 * x + Y2], r, g, b);
+        }
+      dst_data += dst_stride;
+      src_data += src_stride;
+    }
+}
+
+static const GdkDrmFormatInfo supported_formats[] = {
+  { DRM_FORMAT_BGRA8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, GDK_MEMORY_A8R8G8B8, download_memcpy },
+  { DRM_FORMAT_ABGR8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, GDK_MEMORY_R8G8B8A8, download_memcpy },
+  { DRM_FORMAT_ARGB8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, GDK_MEMORY_B8G8R8A8, download_memcpy },
+  { DRM_FORMAT_RGBA8888, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, GDK_MEMORY_A8B8G8R8, download_memcpy },
+  { DRM_FORMAT_BGRX8888, GDK_MEMORY_X8R8G8B8, GDK_MEMORY_X8R8G8B8, download_memcpy },
+  { DRM_FORMAT_XBGR8888, GDK_MEMORY_R8G8B8X8, GDK_MEMORY_R8G8B8X8, download_memcpy },
+  { DRM_FORMAT_XRGB8888, GDK_MEMORY_B8G8R8X8, GDK_MEMORY_B8G8R8X8, download_memcpy },
+  { DRM_FORMAT_RGBX8888, GDK_MEMORY_X8B8G8R8, GDK_MEMORY_X8B8G8R8, download_memcpy },
+  { DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, GDK_MEMORY_R16G16B16A16_FLOAT, download_memcpy },
+  { DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_memcpy },
+  { DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, GDK_MEMORY_B8G8R8, download_memcpy },
+  /* YUV formats */
+  { DRM_FORMAT_NV12, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV21, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV16, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV61, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV24, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV42, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_YUYV, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_YVYU, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_VYUY, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_UYVY, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_YUV410, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YVU410, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YUV411, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YVU411, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YUV420, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YVU420, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YUV422, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YVU422, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YUV444, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+  { DRM_FORMAT_YVU444, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuv_3 },
+};
+
+static const GdkDrmFormatInfo *
+get_drm_format_info (guint32 fourcc)
+{
+  for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      if (supported_formats[i].fourcc == fourcc)
+        return &supported_formats[i];
+    }
+
+  return NULL;
+}
+
+static gboolean
+gdk_dmabuf_direct_downloader_add_formats (const GdkDmabufDownloader *downloader,
+                                          GdkDisplay                *display,
+                                          GdkDmabufFormatsBuilder   *builder)
+{
+  gsize i;
+
+  for (i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      GDK_DEBUG (DMABUF, "%s dmabuf format %.4s:%#" G_GINT64_MODIFIER "x",
+                 downloader->name,
+                 (char *) &supported_formats[i].fourcc, (guint64) DRM_FORMAT_MOD_LINEAR);
+
+      gdk_dmabuf_formats_builder_add_format (builder,
+                                             supported_formats[i].fourcc,
+                                             DRM_FORMAT_MOD_LINEAR);
+    }
+
+  return TRUE;
+}
+
+static gboolean
+gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader  *downloader,
+                                       GdkDisplay                 *display,
+                                       const GdkDmabuf            *dmabuf,
+                                       gboolean                    premultiplied,
+                                       GdkMemoryFormat            *out_format,
+                                       GError                    **error)
+{
+  const GdkDrmFormatInfo *info;
+
+  info = get_drm_format_info (dmabuf->fourcc);
+
+  if (!info)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "Unsupported dmabuf format %.4s",
+                   (char *) &dmabuf->fourcc);
+      return FALSE;
+    }
+
+  if (dmabuf->modifier != DRM_FORMAT_MOD_LINEAR)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "Unsupported dmabuf modifier %#lx (only linear buffers are supported)",
+                   dmabuf->modifier);
+      return FALSE;
+    }
+
+  *out_format = premultiplied ? info->premultiplied_memory_format
+                              : info->unpremultiplied_memory_format;
+
+  return TRUE;
+}
+
+static void
+gdk_dmabuf_direct_downloader_do_download (GdkTexture *texture,
+                                          guchar     *data,
+                                          gsize       stride)
+{
+  const GdkDrmFormatInfo *info;
+  const GdkDmabuf *dmabuf;
+  const guchar *src_data[GDK_DMABUF_MAX_PLANES];
+  gsize sizes[GDK_DMABUF_MAX_PLANES];
+  gsize needs_unmap[GDK_DMABUF_MAX_PLANES] = { FALSE, };
+  gsize i, j;
+
+  dmabuf = gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (texture));
+  info = get_drm_format_info (dmabuf->fourcc);
+
+  GDK_DEBUG (DMABUF,
+             "Using mmap() and memcpy() for downloading a dmabuf (format %.4s:%#lx)",
+             (char *)&dmabuf->fourcc, dmabuf->modifier);
+
+  for (i = 0; i < dmabuf->n_planes; i++)
+    {
+      for (j = 0; j < i; j++)
+        {
+          if (dmabuf->planes[i].fd == dmabuf->planes[j].fd)
+            break;
+        }
+      if (j < i)
+        {
+          src_data[i] = src_data[j];
+          sizes[i] = sizes[j];
+          continue;
+        }
+
+      sizes[i] = lseek (dmabuf->planes[i].fd, 0, SEEK_END);
+      if (sizes[i] == (off_t) -1)
+        {
+          g_warning ("Failed to seek dmabuf: %s", g_strerror (errno));
+          goto out;
+        }
+      /* be a good citizen and seek back to the start, as the dos recommend */
+      lseek (dmabuf->planes[i].fd, 0, SEEK_SET);
+
+      if (ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_START|DMA_BUF_SYNC_READ }) < 0)
+        g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
+
+      src_data[i] = mmap (NULL, sizes[i], PROT_READ, MAP_SHARED, dmabuf->planes[i].fd, dmabuf->planes[i].offset);
+      if (src_data[i] == NULL)
+        {
+          g_warning ("Failed to mmap dmabuf: %s", g_strerror (errno));
+          goto out;
+        }
+      needs_unmap[i] = TRUE;
+    }
+
+    info->download (data,
+                    stride,
+                    gdk_texture_get_format (texture),
+                    gdk_texture_get_width (texture),
+                    gdk_texture_get_height (texture),
+                    dmabuf,
+                    src_data,
+                    sizes);
+
+out:
+  for (i = 0; i < dmabuf->n_planes; i++)
+    {
+      if (!needs_unmap[i])
+        continue;
+
+      munmap ((void *)src_data[i], sizes[i]);
+
+      if (ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_END|DMA_BUF_SYNC_READ }) < 0)
+        g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
+    }
+}
+
+static void
+gdk_dmabuf_direct_downloader_download (const GdkDmabufDownloader *downloader,
+                                       GdkTexture                *texture,
+                                       GdkMemoryFormat            format,
+                                       guchar                    *data,
+                                       gsize                      stride)
+{
+  GdkMemoryFormat src_format = gdk_texture_get_format (texture);
+
+  if (format == src_format)
+    gdk_dmabuf_direct_downloader_do_download (texture, data, stride);
+  else
+    {
+      unsigned int width, height;
+      guchar *src_data;
+      gsize src_stride;
+
+      width = gdk_texture_get_width (texture);
+      height = gdk_texture_get_height (texture);
+
+      src_stride = width * gdk_memory_format_bytes_per_pixel (src_format);
+      src_data = g_new (guchar, src_stride * height);
+
+      gdk_dmabuf_direct_downloader_do_download (texture, src_data, src_stride);
+
+      gdk_memory_convert (data, stride, format,
+                          src_data, src_stride, src_format,
+                          width, height);
+
+      g_free (src_data);
+    }
+}
+
+const GdkDmabufDownloader *
+gdk_dmabuf_get_direct_downloader (void)
+{
+  static const GdkDmabufDownloader downloader = {
+    "mmap",
+    gdk_dmabuf_direct_downloader_add_formats,
+    gdk_dmabuf_direct_downloader_supports,
+    gdk_dmabuf_direct_downloader_download,
+  };
+
+  return &downloader;
+}
+
+/* 
+ * Tries to sanitize the dmabuf to conform to the values expected
+ * by Vulkan/EGL which should also be the values expected by
+ * Wayland compositors
+ *
+ * We put these sanitized values into the GdkDmabufTexture, by
+ * sanitizing the input from GdkDmabufTextureBuilder, which are
+ * controlled by the callers.
+ *
+ * Things we do here:
+ *
+ * 1. Disallow any dmabuf format that we do not know.
+ *
+ * 1. Reject the INVALID modifier, accept the LINEAR one.
+ *
+ * 2. Ignore all other modifiers.
+ *
+ * 3. Try and fix various inconsistencies between V4L and Mesa, like NV12.
+ *
+ * *** WARNING ***
+ *
+ * This function is not absolutely perfect, you do not have a
+ * perfect dmabuf afterwards.
+ *
+ * In particular, it doesn't check sizes.
+ *
+ * *** WARNING ***
+ */
+gboolean
+gdk_dmabuf_sanitize (GdkDmabuf        *dest,
+                     gsize             width,
+                     gsize             height,
+                     const GdkDmabuf  *src,
+                     GError          **error)
+{
+  const GdkDrmFormatInfo *info;
+
+  if (src->n_planes > GDK_DMABUF_MAX_PLANES)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "GTK only support dmabufs with %u planes, not %u",
+                   GDK_DMABUF_MAX_PLANES, src->n_planes);
+      return FALSE;
+    }
+
+  if (src->modifier == DRM_FORMAT_MOD_INVALID)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "GTK does not support the INVALID modifier.");
+      return FALSE;
+    }
+
+  info = get_drm_format_info (src->fourcc);
+
+  if (info == NULL)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "Unsupported dmabuf format %.4s",
+                   (char *) &src->fourcc);
+      return FALSE;
+    }
+
+  *dest = *src;
+
+  if (src->modifier)
+    return TRUE;
+
+  switch (dest->fourcc)
+    {
+      case DRM_FORMAT_NV12:
+      case DRM_FORMAT_NV21:
+      case DRM_FORMAT_NV16:
+      case DRM_FORMAT_NV61:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 2;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = dest->planes[0].stride;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+          }
+        break;
+
+      case DRM_FORMAT_NV24:
+      case DRM_FORMAT_NV42:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 2;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = dest->planes[0].stride * 2;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+          }
+        break;
+
+      case DRM_FORMAT_YUV410:
+      case DRM_FORMAT_YVU410:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 3;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = (dest->planes[0].stride + 3) / 4;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+            dest->planes[2].fd = dest->planes[1].fd;
+            dest->planes[2].stride = dest->planes[1].stride;
+            dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * ((height + 3) / 4);
+          }
+        break;
+
+      case DRM_FORMAT_YUV411:
+      case DRM_FORMAT_YVU411:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 3;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = (dest->planes[0].stride + 3) / 4;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+            dest->planes[2].fd = dest->planes[1].fd;
+            dest->planes[2].stride = dest->planes[1].stride;
+            dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
+          }
+        break;
+
+      case DRM_FORMAT_YUV420:
+      case DRM_FORMAT_YVU420:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 3;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = (dest->planes[0].stride + 1) / 2;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+            dest->planes[2].fd = dest->planes[1].fd;
+            dest->planes[2].stride = dest->planes[1].stride;
+            dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * ((height + 1) / 2);
+          }
+        break;
+
+      case DRM_FORMAT_YUV422:
+      case DRM_FORMAT_YVU422:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 3;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = (dest->planes[0].stride + 1) / 2;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+            dest->planes[2].fd = dest->planes[1].fd;
+            dest->planes[2].stride = dest->planes[1].stride;
+            dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
+          }
+        break;
+
+      case DRM_FORMAT_YUV444:
+      case DRM_FORMAT_YVU444:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 3;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = dest->planes[0].stride;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+            dest->planes[2].fd = dest->planes[1].fd;
+            dest->planes[2].stride = dest->planes[1].stride;
+            dest->planes[2].offset = dest->planes[1].offset + dest->planes[1].stride * height;
+          }
+        break;
+
+      default:
+        break;
+    }
+
+  return TRUE;
+}
+
+/*
+ * gdk_dmabuf_is_disjoint:
+ * @dmabuf: a sanitized GdkDmabuf
+ *
+ * A dmabuf is considered disjoint if it uses more than
+ * 1 file descriptor.
+ *
+ * Returns: %TRUE if the dmabuf is disjoint
+ **/
+gboolean
+gdk_dmabuf_is_disjoint (const GdkDmabuf *dmabuf)
+{
+  unsigned i;
+
+  for (i = 1; i < dmabuf->n_planes; i++)
+    {
+      if (dmabuf->planes[0].fd != dmabuf->planes[i].fd)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+#endif  /* HAVE_DMABUF */

gdk/gdkdmabufegl.c

@@ -0,0 +1,413 @@
+/* gdkdmabufegl.c
+ *
+ * Copyright 2023  Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#if defined(HAVE_DMABUF) && defined (HAVE_EGL)
+#include "gdkdmabufprivate.h"
+
+#include "gdkdmabufformatsbuilderprivate.h"
+#include "gdkdebugprivate.h"
+#include "gdkdmabuftextureprivate.h"
+#include "gdkmemoryformatprivate.h"
+#include "gdkdisplayprivate.h"
+#include "gdkglcontextprivate.h"
+#include "gdktexturedownloader.h"
+
+#include <graphene.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-buf.h>
+#include <drm_fourcc.h>
+#include <epoxy/egl.h>
+
+/* A dmabuf downloader implementation that downloads buffers via
+ * gsk_renderer_render_texture + GL texture download.
+ */
+
+static gboolean
+gdk_dmabuf_egl_downloader_add_formats (const GdkDmabufDownloader *downloader,
+                                       GdkDisplay                *display,
+                                       GdkDmabufFormatsBuilder   *builder)
+{
+  GdkGLContext *context = gdk_display_get_gl_context (display);
+  EGLDisplay egl_display = gdk_display_get_egl_display (display);
+  GdkDmabufFormatsBuilder *external;
+  gboolean retval = FALSE;
+
+  g_assert (display->egl_external_formats == NULL);
+
+  external = gdk_dmabuf_formats_builder_new ();
+
+  gdk_gl_context_make_current (context);
+
+  if (egl_display != EGL_NO_DISPLAY &&
+      display->have_egl_dma_buf_import &&
+      gdk_gl_context_has_image_storage (context))
+    {
+      int num_fourccs;
+      int *fourccs;
+      guint64 *modifiers;
+      unsigned int *external_only;
+      int n_mods;
+
+      eglQueryDmaBufFormatsEXT (egl_display, 0, NULL, &num_fourccs);
+      fourccs = g_new (int, num_fourccs);
+      eglQueryDmaBufFormatsEXT (egl_display, num_fourccs, fourccs, &num_fourccs);
+
+      n_mods = 80;
+      modifiers = g_new (guint64, n_mods);
+      external_only = g_new (unsigned int, n_mods);
+
+      for (int i = 0; i < num_fourccs; i++)
+        {
+          int num_modifiers;
+
+          eglQueryDmaBufModifiersEXT (egl_display,
+                                      fourccs[i],
+                                      0,
+                                      NULL,
+                                      NULL,
+                                      &num_modifiers);
+
+          if (num_modifiers > n_mods)
+            {
+              n_mods = num_modifiers;
+              modifiers = g_renew (guint64, modifiers, n_mods);
+              external_only = g_renew (unsigned int, external_only, n_mods);
+            }
+
+          eglQueryDmaBufModifiersEXT (egl_display,
+                                      fourccs[i],
+                                      num_modifiers,
+                                      modifiers,
+                                      external_only,
+                                      &num_modifiers);
+
+          for (int j = 0; j < num_modifiers; j++)
+            {
+              /* All linear formats we support are already added my the mmap downloader.
+               * We don't add external formats, unless we can use them (via GLES)
+               */
+              if (modifiers[j] != DRM_FORMAT_MOD_LINEAR &&
+                  (!external_only[j] || gdk_gl_context_get_use_es (context)))
+                {
+                  GDK_DEBUG (DMABUF, "%s%s dmabuf format %.4s:%#" G_GINT64_MODIFIER "x",
+                             external_only[j] ? "external " : "",
+                             downloader->name,
+                             (char *) &fourccs[i],
+                             modifiers[j]);
+
+                  gdk_dmabuf_formats_builder_add_format (builder, fourccs[i], modifiers[j]);
+                }
+              if (external_only[j])
+                gdk_dmabuf_formats_builder_add_format (external, fourccs[i], modifiers[j]);
+            }
+        }
+
+      g_free (modifiers);
+      g_free (external_only);
+      g_free (fourccs);
+
+      retval = TRUE;
+    }
+
+  display->egl_external_formats = gdk_dmabuf_formats_builder_free_to_formats (external);
+
+  return retval;
+}
+
+static GdkMemoryFormat
+get_memory_format (guint32  fourcc,
+                   gboolean premultiplied)
+{
+  switch (fourcc)
+    {
+    case DRM_FORMAT_ARGB8888:
+    case DRM_FORMAT_ABGR8888:
+    case DRM_FORMAT_XRGB8888_A8:
+    case DRM_FORMAT_XBGR8888_A8:
+      return premultiplied ? GDK_MEMORY_A8R8G8B8_PREMULTIPLIED : GDK_MEMORY_A8R8G8B8;
+
+    case DRM_FORMAT_RGBA8888:
+    case DRM_FORMAT_RGBX8888_A8:
+      return premultiplied ? GDK_MEMORY_R8G8B8A8_PREMULTIPLIED : GDK_MEMORY_R8G8B8A8;
+
+    case DRM_FORMAT_BGRA8888:
+      return premultiplied ? GDK_MEMORY_B8G8R8A8_PREMULTIPLIED : GDK_MEMORY_B8G8R8A8;
+
+    case DRM_FORMAT_RGB888:
+    case DRM_FORMAT_XRGB8888:
+    case DRM_FORMAT_XBGR8888:
+    case DRM_FORMAT_RGBX8888:
+    case DRM_FORMAT_BGRX8888:
+      return GDK_MEMORY_R8G8B8;
+
+    case DRM_FORMAT_BGR888:
+      return GDK_MEMORY_B8G8R8;
+
+    case DRM_FORMAT_XRGB2101010:
+    case DRM_FORMAT_XBGR2101010:
+    case DRM_FORMAT_RGBX1010102:
+    case DRM_FORMAT_BGRX1010102:
+    case DRM_FORMAT_XRGB16161616:
+    case DRM_FORMAT_XBGR16161616:
+      return GDK_MEMORY_R16G16B16;
+
+    case DRM_FORMAT_ARGB2101010:
+    case DRM_FORMAT_ABGR2101010:
+    case DRM_FORMAT_RGBA1010102:
+    case DRM_FORMAT_BGRA1010102:
+    case DRM_FORMAT_ARGB16161616:
+    case DRM_FORMAT_ABGR16161616:
+      return premultiplied ? GDK_MEMORY_R16G16B16A16_PREMULTIPLIED : GDK_MEMORY_R16G16B16A16;
+
+    case DRM_FORMAT_ARGB16161616F:
+    case DRM_FORMAT_ABGR16161616F:
+      return premultiplied ? GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED : GDK_MEMORY_R16G16B16A16_FLOAT;
+
+    case DRM_FORMAT_XRGB16161616F:
+    case DRM_FORMAT_XBGR16161616F:
+      return GDK_MEMORY_R16G16B16_FLOAT;
+
+    case DRM_FORMAT_YUYV:
+    case DRM_FORMAT_YVYU:
+    case DRM_FORMAT_UYVY:
+    case DRM_FORMAT_VYUY:
+    case DRM_FORMAT_XYUV8888:
+#ifdef DRM_FORMAT_XVUY8888
+    case DRM_FORMAT_XVUY8888:
+#endif
+    case DRM_FORMAT_VUY888:
+      return GDK_MEMORY_R8G8B8;
+
+    /* Add more formats here */
+    default:
+      return premultiplied ? GDK_MEMORY_A8R8G8B8_PREMULTIPLIED : GDK_MEMORY_A8R8G8B8;
+    }
+}
+
+static gboolean
+gdk_dmabuf_egl_downloader_supports (const GdkDmabufDownloader  *downloader,
+                                    GdkDisplay                 *display,
+                                    const GdkDmabuf            *dmabuf,
+                                    gboolean                    premultiplied,
+                                    GdkMemoryFormat            *out_format,
+                                    GError                    **error)
+{
+  EGLDisplay egl_display;
+  GdkGLContext *context;
+  int num_modifiers;
+  guint64 *modifiers;
+  unsigned int *external_only;
+
+  egl_display = gdk_display_get_egl_display (display);
+  if (egl_display == EGL_NO_DISPLAY)
+    {
+      g_set_error_literal (error,
+                           GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                           "EGL not available");
+      return FALSE;
+    }
+
+  context = gdk_display_get_gl_context (display);
+
+  gdk_gl_context_make_current (context);
+
+  eglQueryDmaBufModifiersEXT (egl_display,
+                              dmabuf->fourcc,
+                              0,
+                              NULL,
+                              NULL,
+                              &num_modifiers);
+
+  modifiers = g_newa (uint64_t, num_modifiers);
+  external_only = g_newa (unsigned int, num_modifiers);
+
+  eglQueryDmaBufModifiersEXT (egl_display,
+                              dmabuf->fourcc,
+                              num_modifiers,
+                              modifiers,
+                              external_only,
+                              &num_modifiers);
+
+  for (int i = 0; i < num_modifiers; i++)
+    {
+      if (modifiers[i] == dmabuf->modifier)
+        {
+          *out_format = get_memory_format (dmabuf->fourcc, premultiplied);
+          return TRUE;
+        }
+    }
+
+  g_set_error (error,
+               GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+               "Unsupported dmabuf format: %.4s:%#" G_GINT64_MODIFIER "x",
+               (char *) &dmabuf->fourcc, dmabuf->modifier);
+
+  return FALSE;
+}
+
+/* Hack. We don't include gsk/gsk.h here to avoid a build order problem
+ * with the generated header gskenumtypes.h, so we need to hack around
+ * a bit to access the gsk api we need.
+ */
+
+typedef gpointer GskRenderer;
+
+extern GskRenderer *   gsk_gl_renderer_new          (void);
+extern gboolean        gsk_renderer_realize         (GskRenderer  *renderer,
+                                                     GdkSurface   *surface,
+                                                     GError      **error);
+extern GdkTexture *    gsk_renderer_convert_texture (GskRenderer  *renderer,
+                                                     GdkTexture   *texture);
+
+typedef void (* InvokeFunc) (gpointer data);
+
+typedef struct _InvokeData
+{
+  volatile int spinlock;
+  InvokeFunc func;
+  gpointer data;
+} InvokeData;
+
+static gboolean
+gdk_dmabuf_egl_downloader_invoke_callback (gpointer data)
+{
+  InvokeData *invoke = data;
+  GdkGLContext *previous;
+
+  previous = gdk_gl_context_get_current ();
+
+  invoke->func (invoke->data);
+
+  if (previous)
+    gdk_gl_context_make_current (previous);
+  else
+    gdk_gl_context_clear_current ();
+
+  g_atomic_int_set (&invoke->spinlock, 1);
+
+  return FALSE;
+}
+
+/* Run func in the main thread, taking care not to disturb
+ * the current GL context of the caller.
+ */
+static void
+gdk_dmabuf_egl_downloader_run (InvokeFunc func,
+                               gpointer   data)
+{
+  InvokeData invoke = { 0, func, data };
+
+  g_main_context_invoke (NULL, gdk_dmabuf_egl_downloader_invoke_callback, &invoke);
+
+  while (g_atomic_int_get (&invoke.spinlock) == 0) ;
+}
+
+typedef struct _Download Download;
+
+struct _Download
+{
+  GdkDmabufTexture *texture;
+  GdkMemoryFormat format;
+  guchar *data;
+  gsize stride;
+};
+
+static GskRenderer *
+get_gsk_renderer (GdkDisplay *display)
+{
+  if (!display->egl_gsk_renderer)
+    {
+      GskRenderer *renderer;
+      GError *error = NULL;
+
+      renderer = gsk_gl_renderer_new ();
+
+      if (!gsk_renderer_realize (renderer, NULL, &error))
+        {
+          g_warning ("Failed to realize GL renderer: %s", error->message);
+          g_error_free (error);
+          g_object_unref (renderer);
+
+          return NULL;
+        }
+
+      display->egl_gsk_renderer = renderer;
+    }
+
+  return display->egl_gsk_renderer;
+}
+
+static void
+gdk_dmabuf_egl_downloader_do_download (gpointer data)
+{
+  Download *download = data;
+  GdkDisplay *display;
+  GskRenderer *renderer;
+  GdkTexture *native;
+  GdkTextureDownloader *downloader;
+
+  display = gdk_dmabuf_texture_get_display (download->texture);
+
+  renderer = get_gsk_renderer (display);
+
+  native = gsk_renderer_convert_texture (renderer, GDK_TEXTURE (download->texture));
+
+  downloader = gdk_texture_downloader_new (native);
+  gdk_texture_downloader_set_format (downloader, download->format);
+  gdk_texture_downloader_download_into (downloader, download->data, download->stride);
+  gdk_texture_downloader_free (downloader);
+
+  g_object_unref (native);
+}
+
+static void
+gdk_dmabuf_egl_downloader_download (const GdkDmabufDownloader *downloader,
+                                    GdkTexture                *texture,
+                                    GdkMemoryFormat            format,
+                                    guchar                    *data,
+                                    gsize                      stride)
+{
+  Download download;
+
+  GDK_DEBUG (DMABUF, "Using %s for downloading a dmabuf", downloader->name);
+
+  download.texture = GDK_DMABUF_TEXTURE (texture);
+  download.format = format;
+  download.data = data;
+  download.stride = stride;
+
+  gdk_dmabuf_egl_downloader_run (gdk_dmabuf_egl_downloader_do_download, &download);
+}
+
+const GdkDmabufDownloader *
+gdk_dmabuf_get_egl_downloader (void)
+{
+  static const GdkDmabufDownloader downloader = {
+    "egl",
+    gdk_dmabuf_egl_downloader_add_formats,
+    gdk_dmabuf_egl_downloader_supports,
+    gdk_dmabuf_egl_downloader_download,
+  };
+
+  return &downloader;
+}
+
+#endif  /* HAVE_DMABUF && HAVE_EGL */

gdk/gdkdmabufformats.c

@@ -0,0 +1,215 @@
+/* gdkdmabufformats.c
+ *
+ * Copyright 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include <glib-object.h>
+#include "gdkdmabufformatsprivate.h"
+
+
+/**
+ * GdkDmabufFormats:
+ *
+ * The `GdkDmabufFormats struct provides information about
+ * supported DMA buffer formats.
+ *
+ * You can query whether a given format is supported with
+ * [method@Gdk.DmabufFormats.contains] and you can iterate
+ * over the list of all supported formats with
+ * [method@Gdk.DmabufFormats.get_n_formats] and
+ * [method@Gdk.DmabufFormats.get_format].
+ *
+ * The list of supported formats is sorted by preference,
+ * with the best formats coming first.
+ *
+ * See [class@Gdk.DmabufTextureBuilder] for more information
+ * about DMA buffers.
+ *
+ * Note that DMA buffers only exist on Linux.
+ *
+ * Since: 4.14
+ */
+
+struct _GdkDmabufFormats
+{
+  int ref_count;
+
+  gsize n_formats;
+  GdkDmabufFormat *formats;
+};
+
+G_DEFINE_BOXED_TYPE (GdkDmabufFormats, gdk_dmabuf_formats, gdk_dmabuf_formats_ref, gdk_dmabuf_formats_unref)
+
+/**
+ * gdk_dmabuf_formats_ref:
+ * @formats: a `GdkDmabufFormats`
+ *
+ * Increases the reference count of @formats.
+ *
+ * Returns: the passed-in object
+ *
+ * Since: 4.14
+ */
+GdkDmabufFormats *
+gdk_dmabuf_formats_ref (GdkDmabufFormats *formats)
+{
+  formats->ref_count++;
+
+  return formats;
+}
+
+/**
+ * gdk_dmabuf_formats_unref:
+ * @formats: a `GdkDmabufFormats`
+ *
+ * Decreases the reference count of @formats.
+ *
+ * When the reference count reaches zero,
+ * the object is freed.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_formats_unref (GdkDmabufFormats *formats)
+{
+  formats->ref_count--;
+
+  if (formats->ref_count > 0)
+    return;
+
+   g_free (formats->formats);
+   g_free (formats);
+}
+
+/**
+ * gdk_dmabuf_formats_get_n_formats:
+ * @formats: a `GdkDmabufFormats`
+ *
+ * Returns the number of formats that the @formats object
+ * contains.
+ *
+ * Note that DMA buffers are a Linux concept, so on other
+ * platforms, [method@Gdk.DmabufFormats.get_n_formats] will
+ * always return zero.
+ *
+ * Returns: the number of formats
+ *
+ * Since: 4.14
+ */
+gsize
+gdk_dmabuf_formats_get_n_formats (GdkDmabufFormats *formats)
+{
+  return formats->n_formats;
+}
+
+/**
+ * gdk_dmabuf_formats_get_format:
+ * @formats: a `GdkDmabufFormats`
+ * @idx: the index of the format to return
+ * @fourcc: (out): return location for the format code
+ * @modifier: (out): return location for the format modifier
+ *
+ * Gets the fourcc code and modifier for a format
+ * that is contained in @formats.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_formats_get_format (GdkDmabufFormats *formats,
+                               gsize             idx,
+                               guint32          *fourcc,
+                               guint64          *modifier)
+{
+  GdkDmabufFormat *format;
+
+  g_return_if_fail (idx < formats->n_formats);
+  g_return_if_fail (fourcc != NULL);
+  g_return_if_fail (modifier != NULL);
+
+  format = &formats->formats[idx];
+
+  *fourcc = format->fourcc;
+  *modifier = format->modifier;
+}
+
+/**
+ * gdk_dmabuf_format_contains:
+ * @formats: a `GdkDmabufFormats`
+ * @fourcc: a format code
+ * @modfier: a format modifier
+ *
+ * Returns whether a given format is contained in @formats.
+ *
+ * Returns: `TRUE` if the format specified by the arguments
+ *   is part of @formats
+ *
+ * Since: 4.14
+ */
+gboolean
+gdk_dmabuf_formats_contains (GdkDmabufFormats *formats,
+                             guint32           fourcc,
+                             guint64           modifier)
+{
+  for (gsize i = 0; i < formats->n_formats; i++)
+    {
+      GdkDmabufFormat *format = &formats->formats[i];
+
+      if (format->fourcc == fourcc && format->modifier == modifier)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+/*< private >
+ * gdk_dmabuf_formats_new:
+ * @formats: the formats
+ * @n_formats: the length of @formats
+ *
+ * Creates a new `GdkDmabufFormats struct for
+ * the given formats.
+ *
+ * The @formats array is expected to be sorted
+ * by preference.
+ *
+ * Returns: (transfer full): the new `GdkDmabufFormats`
+ *
+ * Since: 4.14
+ */
+GdkDmabufFormats *
+gdk_dmabuf_formats_new (GdkDmabufFormat *formats,
+                        gsize            n_formats)
+{
+  GdkDmabufFormats *self;
+
+  self = g_new0 (GdkDmabufFormats, 1);
+
+  self->ref_count = 1;
+  self->n_formats = n_formats;
+  self->formats = g_new (GdkDmabufFormat, n_formats);
+
+  memcpy (self->formats, formats, n_formats * sizeof (GdkDmabufFormat));
+
+  return self;
+}
+
+const GdkDmabufFormat *
+gdk_dmabuf_formats_peek_formats (GdkDmabufFormats *self)
+{
+  return self->formats;
+}

gdk/gdkdmabufformats.h

@@ -0,0 +1,54 @@
+/* gdkdmabufformats.h
+ *
+ * Copyright 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#include <gdk/gdktypes.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DMABUF_FORMATS (gdk_dmabuf_formats_get_type ())
+
+GDK_AVAILABLE_IN_4_14
+GType              gdk_dmabuf_formats_get_type        (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_4_14
+GdkDmabufFormats * gdk_dmabuf_formats_ref             (GdkDmabufFormats *formats);
+
+GDK_AVAILABLE_IN_4_14
+void               gdk_dmabuf_formats_unref           (GdkDmabufFormats *formats);
+
+GDK_AVAILABLE_IN_4_14
+gsize              gdk_dmabuf_formats_get_n_formats   (GdkDmabufFormats *formats) G_GNUC_PURE;
+
+GDK_AVAILABLE_IN_4_14
+void               gdk_dmabuf_formats_get_format      (GdkDmabufFormats *formats,
+                                                       gsize             idx,
+                                                       guint32          *fourcc,
+                                                       guint64          *modifier);
+
+GDK_AVAILABLE_IN_4_14
+gboolean           gdk_dmabuf_formats_contains        (GdkDmabufFormats *formats,
+                                                       guint32           fourcc,
+                                                       guint64           modifier) G_GNUC_PURE;
+
+G_END_DECLS

gdk/gdkdmabufformatsbuilder.c

@@ -0,0 +1,143 @@
+/* gdkdmabufformats.c
+ *
+ * Copyright 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include "gdkdmabufformatsbuilderprivate.h"
+
+#include "gdkdmabufformatsprivate.h"
+
+#ifdef HAVE_DMABUF
+#include <drm_fourcc.h>
+#endif
+
+#define GDK_ARRAY_NAME gdk_dmabuf_formats_builder
+#define GDK_ARRAY_TYPE_NAME GdkDmabufFormatsBuilder
+#define GDK_ARRAY_ELEMENT_TYPE GdkDmabufFormat
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 1024
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+/* NB: We keep duplicates in the list for ease of use. Only when creating the final
+ * GdkDmabufFormats do we actually remove duplicates.
+ */
+
+GdkDmabufFormatsBuilder *
+gdk_dmabuf_formats_builder_new (void)
+{
+  GdkDmabufFormatsBuilder *result = g_new (GdkDmabufFormatsBuilder, 1);
+
+  gdk_dmabuf_formats_builder_init (result);
+
+  return result;
+}
+
+static int
+gdk_dmabuf_format_compare (gconstpointer data_a,
+                           gconstpointer data_b)
+{
+  const GdkDmabufFormat *a = data_a;
+  const GdkDmabufFormat *b = data_b;
+
+  if (a->fourcc == b->fourcc)
+    return (a->modifier - b->modifier) >> 8 * (sizeof (gint64) - sizeof (gint));
+  else
+    return a->fourcc - b->fourcc;
+
+}
+
+static gboolean
+gdk_dmabuf_format_equal (gconstpointer data_a,
+                         gconstpointer data_b)
+{
+  const GdkDmabufFormat *a = data_a;
+  const GdkDmabufFormat *b = data_b;
+
+  return a->fourcc == b->fourcc &&
+         a->modifier == b->modifier;
+}
+
+static void
+gdk_dmabuf_formats_builder_sort (GdkDmabufFormatsBuilder *self)
+{
+  qsort (gdk_dmabuf_formats_builder_get_data (self),
+         gdk_dmabuf_formats_builder_get_size (self),
+         sizeof (GdkDmabufFormat),
+         gdk_dmabuf_format_compare);
+}
+
+/* list must be sorted */
+static void
+gdk_dmabuf_formats_builder_remove_duplicates (GdkDmabufFormatsBuilder *self)
+{
+  gsize i, j;
+
+  for (i = 1, j = 0; i < gdk_dmabuf_formats_builder_get_size (self); i++)
+    {
+      if (gdk_dmabuf_format_equal (gdk_dmabuf_formats_builder_get (self, i),
+                                   gdk_dmabuf_formats_builder_get (self, j)))
+        continue;
+
+      j++;
+      if (i != j)
+        *gdk_dmabuf_formats_builder_index (self, j) = *gdk_dmabuf_formats_builder_index (self, i);
+    }
+}
+
+GdkDmabufFormats *
+gdk_dmabuf_formats_builder_free_to_formats (GdkDmabufFormatsBuilder *self)
+{
+  GdkDmabufFormats *formats;
+
+  gdk_dmabuf_formats_builder_sort (self);
+  gdk_dmabuf_formats_builder_remove_duplicates (self);
+
+  formats = gdk_dmabuf_formats_new (gdk_dmabuf_formats_builder_get_data (self),
+                                    gdk_dmabuf_formats_builder_get_size (self));
+  gdk_dmabuf_formats_builder_clear (self);
+  g_free (self);
+
+  return formats;
+}
+
+void
+gdk_dmabuf_formats_builder_add_format (GdkDmabufFormatsBuilder *self,
+                                       guint32                  fourcc,
+                                       guint64                  modifier)
+{
+#ifdef HAVE_DMABUF
+  g_return_if_fail (modifier != DRM_FORMAT_MOD_INVALID);
+#else
+  g_return_if_reached ();
+#endif
+
+  gdk_dmabuf_formats_builder_append (self, &(GdkDmabufFormat) { fourcc, modifier });
+}
+
+void
+gdk_dmabuf_formats_builder_add_formats (GdkDmabufFormatsBuilder *self,
+                                        GdkDmabufFormats        *formats)
+{
+  gdk_dmabuf_formats_builder_splice (self,
+                                     gdk_dmabuf_formats_builder_get_size (self),
+                                     0,
+                                     FALSE,
+                                     gdk_dmabuf_formats_peek_formats (formats),
+                                     gdk_dmabuf_formats_get_n_formats (formats));
+}

gdk/gdkdmabufformatsbuilderprivate.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "gdkdmabufformats.h"
+
+typedef struct GdkDmabufFormatsBuilder GdkDmabufFormatsBuilder;
+
+GdkDmabufFormatsBuilder *       gdk_dmabuf_formats_builder_new                  (void);
+GdkDmabufFormats *              gdk_dmabuf_formats_builder_free_to_formats      (GdkDmabufFormatsBuilder        *self);
+
+void                            gdk_dmabuf_formats_builder_add_format           (GdkDmabufFormatsBuilder        *self,
+                                                                                 guint32                         fourcc,
+                                                                                 guint64                         modifier);
+void                            gdk_dmabuf_formats_builder_add_formats          (GdkDmabufFormatsBuilder        *self,
+                                                                                 GdkDmabufFormats               *formats);

gdk/gdkdmabufformatsprivate.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "gdkdmabufformats.h"
+
+typedef struct _GdkDmabufFormat GdkDmabufFormat;
+struct _GdkDmabufFormat
+{
+  guint32 fourcc;
+  guint64 modifier;
+};
+
+GdkDmabufFormats *      gdk_dmabuf_formats_new                  (GdkDmabufFormat  *formats,
+                                                                 gsize             n_formats);
+
+const GdkDmabufFormat * gdk_dmabuf_formats_peek_formats         (GdkDmabufFormats *self);

gdk/gdkdmabufprivate.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "gdkdmabufformatsbuilderprivate.h"
+
+#define GDK_DMABUF_MAX_PLANES 4
+
+typedef struct _GdkDmabuf GdkDmabuf;
+typedef struct _GdkDmabufDownloader GdkDmabufDownloader;
+
+struct _GdkDmabuf
+{
+  guint32 fourcc;
+  guint64 modifier;
+  unsigned int n_planes;
+  struct {
+    int fd;
+    unsigned int stride;
+    unsigned int offset;
+  } planes[GDK_DMABUF_MAX_PLANES];
+};
+
+struct _GdkDmabufDownloader
+{
+  const char *name;
+  gboolean              (* add_formats)                         (const GdkDmabufDownloader      *downloader,
+                                                                 GdkDisplay                     *display,
+                                                                 GdkDmabufFormatsBuilder        *builder);
+  gboolean              (* supports)                            (const GdkDmabufDownloader      *downloader,
+                                                                 GdkDisplay                     *display,
+                                                                 const GdkDmabuf                *dmabuf,
+                                                                 gboolean                        premultiplied,
+                                                                 GdkMemoryFormat                *out_format,
+                                                                 GError                        **error);
+  void                  (* download)                            (const GdkDmabufDownloader      *downloader,
+                                                                 GdkTexture                     *texture,
+                                                                 GdkMemoryFormat                 format,
+                                                                 guchar                         *data,
+                                                                 gsize                           stride);
+};
+
+#ifdef HAVE_DMABUF
+
+const GdkDmabufDownloader * gdk_dmabuf_get_direct_downloader    (void) G_GNUC_CONST;
+const GdkDmabufDownloader * gdk_dmabuf_get_egl_downloader       (void) G_GNUC_CONST;
+
+gboolean                    gdk_dmabuf_sanitize                 (GdkDmabuf                      *dest,
+                                                                 gsize                           width,
+                                                                 gsize                           height,
+                                                                 const GdkDmabuf                *src,
+                                                                 GError                        **error);
+
+gboolean                    gdk_dmabuf_is_disjoint              (const GdkDmabuf                *dmabuf);
+
+#endif

gdk/gdkdmabuftexture.c

@@ -0,0 +1,219 @@
+/* gdkdmabuftexture.c
+ *
+ * Copyright 2023  Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gdkdmabuftextureprivate.h"
+
+#include "gdkdisplayprivate.h"
+#include "gdkdmabufformatsbuilderprivate.h"
+#include "gdkdmabufprivate.h"
+#include "gdktextureprivate.h"
+#include <gdk/gdkglcontext.h>
+#include <gdk/gdkgltexturebuilder.h>
+#include <gdk/gdktexturedownloader.h>
+
+#ifdef HAVE_DMABUF
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-buf.h>
+#include <drm_fourcc.h>
+#include <epoxy/egl.h>
+#endif
+
+/**
+ * GdkDmabufTexture:
+ *
+ * A `GdkTexture` representing a dma-buf object.
+ *
+ * To create a `GdkDmabufTexture`, use the auxiliary
+ * [class@Gdk.DmabufTextureBuilder] object.
+ *
+ * Dma-buf textures can only be created on Linux.
+ */
+
+struct _GdkDmabufTexture
+{
+  GdkTexture parent_instance;
+
+  GdkDisplay *display;
+  const GdkDmabufDownloader *downloader;
+
+  GdkDmabuf dmabuf;
+
+  GDestroyNotify destroy;
+  gpointer data;
+};
+
+struct _GdkDmabufTextureClass
+{
+  GdkTextureClass parent_class;
+};
+
+G_DEFINE_QUARK (gdk-dmabuf-error-quark, gdk_dmabuf_error)
+
+G_DEFINE_TYPE (GdkDmabufTexture, gdk_dmabuf_texture, GDK_TYPE_TEXTURE)
+
+static void
+gdk_dmabuf_texture_init (GdkDmabufTexture *self)
+{
+}
+
+static void
+gdk_dmabuf_texture_dispose (GObject *object)
+{
+  GdkDmabufTexture *self = GDK_DMABUF_TEXTURE (object);
+
+  if (self->destroy)
+    self->destroy (self->data);
+
+  G_OBJECT_CLASS (gdk_dmabuf_texture_parent_class)->dispose (object);
+}
+
+static void
+gdk_dmabuf_texture_download (GdkTexture      *texture,
+                             GdkMemoryFormat  format,
+                             guchar          *data,
+                             gsize            stride)
+{
+  GdkDmabufTexture *self = GDK_DMABUF_TEXTURE (texture);
+
+  self->downloader->download (self->downloader,
+                              texture,
+                              format,
+                              data,
+                              stride);
+}
+
+static void
+gdk_dmabuf_texture_class_init (GdkDmabufTextureClass *klass)
+{
+  GdkTextureClass *texture_class = GDK_TEXTURE_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  texture_class->download = gdk_dmabuf_texture_download;
+
+  gobject_class->dispose = gdk_dmabuf_texture_dispose;
+}
+
+GdkDisplay *
+gdk_dmabuf_texture_get_display (GdkDmabufTexture *self)
+{
+  return self->display;
+}
+
+const GdkDmabuf *
+gdk_dmabuf_texture_get_dmabuf (GdkDmabufTexture *self)
+{
+  return &self->dmabuf;
+}
+
+GdkTexture *
+gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                     GDestroyNotify           destroy,
+                                     gpointer                 data,
+                                     GError                 **error)
+{
+#ifdef HAVE_DMABUF
+  GdkDmabufTexture *self;
+  GdkTexture *update_texture;
+  GdkDisplay *display;
+  GdkDmabuf dmabuf;
+  GdkMemoryFormat format;
+  GError *local_error = NULL;
+  int width, height;
+  gsize i;
+
+  display = gdk_dmabuf_texture_builder_get_display (builder);
+  width = gdk_dmabuf_texture_builder_get_width (builder);
+  height = gdk_dmabuf_texture_builder_get_height (builder);
+
+  if (!gdk_dmabuf_sanitize (&dmabuf,
+                            width,
+                            height,
+                            gdk_dmabuf_texture_builder_get_dmabuf (builder),
+                            error))
+    return NULL;
+
+  gdk_display_init_dmabuf (display);
+
+  for (i = 0; display->dmabuf_downloaders[i] != NULL; i++)
+    {
+      if (local_error && g_error_matches (local_error, GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT))
+        g_clear_error (&local_error);
+
+      if (display->dmabuf_downloaders[i]->supports (display->dmabuf_downloaders[i],
+                                                    display,
+                                                    &dmabuf,
+                                                    gdk_dmabuf_texture_builder_get_premultiplied (builder),
+                                                    &format,
+                                                    local_error ? NULL : &local_error))
+        break;
+    }
+
+  if (display->dmabuf_downloaders[i] == NULL)
+    {
+      g_propagate_error (error, local_error);
+      return NULL;
+    }
+
+  GDK_DEBUG (DMABUF,
+             "Dmabuf texture, format %.4s:%#lx, %s%u planes, memory format %u, downloader %s",
+             (char *) &dmabuf.fourcc, dmabuf.modifier,
+             gdk_dmabuf_texture_builder_get_premultiplied (builder) ? " premultiplied, " : "",
+             dmabuf.n_planes,
+             format,
+             display->dmabuf_downloaders[i]->name);
+
+  self = g_object_new (GDK_TYPE_DMABUF_TEXTURE,
+                       "width", width,
+                       "height", height,
+                       NULL);
+
+  GDK_TEXTURE (self)->format = format;
+  g_set_object (&self->display, display);
+  self->downloader = display->dmabuf_downloaders[i];
+  self->dmabuf = dmabuf;
+  self->destroy = destroy;
+  self->data = data;
+
+  update_texture = gdk_dmabuf_texture_builder_get_update_texture (builder);
+  if (update_texture)
+    {
+      cairo_region_t *update_region = gdk_dmabuf_texture_builder_get_update_region (builder);
+      if (update_region)
+        {
+          update_region = cairo_region_copy (update_region);
+          cairo_region_intersect_rectangle (update_region,
+                                            &(cairo_rectangle_int_t) {
+                                              0, 0,
+                                              update_texture->width, update_texture->height
+                                            });
+          gdk_texture_set_diff (GDK_TEXTURE (self), update_texture, update_region);
+        }
+    }
+
+  return GDK_TEXTURE (self);
+
+#else /* !HAVE_DMABUF */
+  g_set_error_literal (error, GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_NOT_AVAILABLE,
+                       "dmabuf support disabled at compile-time.");
+  return NULL;
+#endif
+}
+