Switch the shader to version 300

Still works!

.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}

NEWS

@@ -1,4 +1,7 @@
-Overview of Changes in 4.13.1, xx-xx-xxxx
+Overview of Changes in 4.13.2, xx-xx-xxxx
+=========================================
+
+Overview of Changes in 4.13.1, 28-09-2023
 =========================================
 
 * GtkTooltip:
@@ -7,20 +10,32 @@ Overview of Changes in 4.13.1, xx-xx-xxxx
 * 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
@@ -29,6 +44,13 @@ Overview of Changes in 4.13.1, xx-xx-xxxx
  - 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
@@ -43,20 +65,29 @@ Overview of Changes in 4.13.1, xx-xx-xxxx
 * 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/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/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);

gdk/gdk.c

@@ -263,7 +263,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

@@ -183,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)
@@ -318,3 +318,5 @@ gdk_array(get) (const GdkArray *self,
 #undef GDK_ARRAY_TYPE_NAME
 #undef GDK_ARRAY_NO_MEMSET
 #endif
+
+G_END_DECLS

gdk/gdkdisplay.c

@@ -37,10 +37,17 @@
 #include "gdkmonitorprivate.h"
 #include "gdkrectangle.h"
 #include "gdkvulkancontext.h"
+#include "gdkdmabuftextureprivate.h"
+#include "gdkdmabufformatsprivate.h"
 
 #ifdef HAVE_EGL
 #include <epoxy/egl.h>
 #endif
+
+#ifdef HAVE_LINUX_DMA_BUF_H
+#include <drm/drm_fourcc.h>
+#endif
+
 #include <math.h>
 #include <stdlib.h>
 
@@ -69,6 +76,7 @@ enum
   PROP_COMPOSITED,
   PROP_RGBA,
   PROP_INPUT_SHAPES,
+  PROP_DMABUF_FORMATS,
   LAST_PROP
 };
 
@@ -138,6 +146,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 +251,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);
 
   /**
@@ -404,6 +421,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);
 }
 
@@ -1755,6 +1774,8 @@ 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");
 
   if (self->have_egl_no_config_context)
     priv->egl_config_high_depth = gdk_display_create_egl_config (self,
@@ -1824,6 +1845,118 @@ gdk_display_get_egl_display (GdkDisplay *self)
 #endif
 }
 
+/**
+ * GdkDmabufFormat:
+ * @fourcc: the format code
+ * @modifiers: the format modifier
+ *
+ * The `GdkDmabufFormat` struct represents a dma-buf format
+ * as defined in the `drm_fourcc.h` header.
+ *
+ * Since: 4.14
+ */
+
+/* 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).
+ */
+static void
+init_dmabuf_formats (GdkDisplay *display)
+{
+  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
+
+  if (display->dmabuf_formats != NULL)
+    return;
+
+  gdk_display_prepare_gl (display, NULL);
+
+  gdk_gl_context_make_current (priv->gl_context);
+
+#ifdef HAVE_EGL
+  if (priv->egl_display != EGL_NO_DISPLAY &&
+      display->have_egl_dma_buf_import)
+    {
+      int num_formats;
+      int *formats;
+      GArray *array;
+
+      eglQueryDmaBufFormatsEXT (priv->egl_display, 0, NULL, &num_formats);
+      formats = g_new (int, num_formats);
+      eglQueryDmaBufFormatsEXT (priv->egl_display, num_formats, formats, &num_formats);
+
+      array = g_array_new (FALSE, FALSE, sizeof (GdkDmabufFormat));
+
+      for (int i = 0; i < num_formats; i++)
+        {
+          int num_modifiers;
+          uint64_t *modifiers;
+          unsigned int *external_only;
+
+//          if (!gdk_dmabuf_texture_may_support ((unsigned int)formats[i]))
+//            continue;
+
+          eglQueryDmaBufModifiersEXT (priv->egl_display, formats[i], 0, NULL, NULL, &num_modifiers);
+          modifiers = g_new (uint64_t, num_modifiers);
+          external_only = g_new (unsigned int, num_modifiers);
+          eglQueryDmaBufModifiersEXT (priv->egl_display, formats[i], num_modifiers, modifiers, external_only, &num_modifiers);
+
+          for (int j = 0; j < num_modifiers; j++)
+            {
+              if (1 || !external_only[j])
+                {
+                  GDK_DEBUG (MISC, "supported EGL dmabuf format %c%c%c%c:%#lx %s",
+                             formats[i] & 0xff,
+                             (formats[i] >> 8) & 0xff,
+                             (formats[i] >> 16) & 0xff,
+                             (formats[i] >> 24) & 0xff,
+                             modifiers[j],
+                             external_only[j] ? "EXT" : "");
+                  g_array_append_val (array, ((GdkDmabufFormat){ formats[i], modifiers[j] }));
+                }
+            }
+          g_array_append_val (array, ((GdkDmabufFormat){ formats[i], DRM_FORMAT_MOD_INVALID }));
+
+          g_free (modifiers);
+       }
+
+      g_free (formats);
+
+      display->dmabuf_formats = gdk_dmabuf_formats_new ((GdkDmabufFormat *)array->data, array->len);
+      g_array_free (array, TRUE);
+    }
+  else
+#endif
+    {
+      GdkDmabufFormat *formats;
+      gsize n_formats;
+
+      formats = gdk_dmabuf_texture_get_supported_formats (&n_formats);
+      display->dmabuf_formats = gdk_dmabuf_formats_new (formats, n_formats);
+      g_free (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.
+ *
+ * Returns: (transfer none): a `GdkDmabufFormats` object
+ *
+ * Since: 4.14
+ */
+GdkDmabufFormats *
+gdk_display_get_dmabuf_formats (GdkDisplay *display)
+{
+  init_dmabuf_formats (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 "gdkdmabufformats.h"
 
 #ifdef GDK_RENDERING_VULKAN
 #include <vulkan/vulkan.h>
@@ -113,6 +114,9 @@ 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;
+
+  GdkDmabufFormats *dmabuf_formats;
 };
 
 struct _GdkDisplayClass

gdk/gdkdmabufformats.c

@@ -0,0 +1,209 @@
+/* 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;
+}

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);
+
+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_END_DECLS

gdk/gdkdmabufformatsprivate.h

@@ -0,0 +1,13 @@
+#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);

gdk/gdkdmabuftexture.c

@@ -0,0 +1,444 @@
+/* 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 "gdkmemoryformatprivate.h"
+#include "gdkmemorytextureprivate.h"
+#include <gdk/gdkglcontext.h>
+#include <gdk/gdkgltexturebuilder.h>
+#include <gdk/gdktexturedownloader.h>
+
+#ifdef HAVE_LINUX_DMA_BUF_H
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-buf.h>
+#include <drm/drm_fourcc.h>
+#include <epoxy/egl.h>
+#endif
+
+/* We don't include gsk/gsk.h here to avoid a build order problem
+ * with the generated header gskenumtypes.h
+ */
+#include <gsk/gskenums.h>
+#include <gsk/gsktypes.h>
+#include <gsk/gskrenderer.h>
+#include <gsk/gskrendernode.h>
+#include <gsk/gl/gskglrenderer.h>
+
+/**
+ * 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;
+
+  guint32 fourcc;
+  guint64 modifier;
+
+  unsigned int n_planes;
+
+  /* Per-plane properties */
+  int fds[MAX_DMABUF_PLANES];
+  unsigned int strides[MAX_DMABUF_PLANES];
+  unsigned int offsets[MAX_DMABUF_PLANES];
+
+  GDestroyNotify destroy;
+  gpointer data;
+};
+
+struct _GdkDmabufTextureClass
+{
+  GdkTextureClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkDmabufTexture, gdk_dmabuf_texture, GDK_TYPE_TEXTURE)
+
+static void
+gdk_dmabuf_texture_init (GdkDmabufTexture *self)
+{
+  self->fds[0] = self->fds[1] = self->fds[2] = self->fds[3] = -1;
+}
+
+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);
+
+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;
+}
+
+guint32
+gdk_dmabuf_texture_get_fourcc (GdkDmabufTexture *texture)
+{
+  return texture->fourcc;
+}
+
+guint64
+gdk_dmabuf_texture_get_modifier (GdkDmabufTexture *texture)
+{
+  return texture->modifier;
+}
+
+unsigned int
+gdk_dmabuf_texture_get_n_planes (GdkDmabufTexture *texture)
+{
+  return texture->n_planes;
+}
+
+int *
+gdk_dmabuf_texture_get_fds (GdkDmabufTexture *texture)
+{
+  return texture->fds;
+}
+
+unsigned int *
+gdk_dmabuf_texture_get_strides (GdkDmabufTexture *texture)
+{
+  return texture->strides;
+}
+
+unsigned int *
+gdk_dmabuf_texture_get_offsets (GdkDmabufTexture *texture)
+{
+  return texture->offsets;
+}
+
+#ifdef HAVE_LINUX_DMA_BUF_H
+
+typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
+struct _GdkDrmFormatInfo
+{
+  guint32 fourcc;
+  GdkMemoryFormat premultiplied_memory_format;
+  GdkMemoryFormat unpremultiplied_memory_format;
+  gboolean requires_gl;
+};
+
+static GdkDrmFormatInfo supported_formats[] = {
+  { DRM_FORMAT_ARGB8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, GDK_MEMORY_A8R8G8B8, FALSE },
+  { DRM_FORMAT_RGBA8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, GDK_MEMORY_R8G8B8A8, FALSE },
+  { DRM_FORMAT_BGRA8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, GDK_MEMORY_B8G8R8A8, FALSE },
+  { DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, GDK_MEMORY_R16G16B16A16_FLOAT, FALSE },
+  { DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, FALSE },
+  { DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, GDK_MEMORY_B8G8R8, FALSE },
+};
+
+static 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 void
+do_indirect_download (GdkDmabufTexture *self,
+                      GdkMemoryFormat  format,
+                      guchar          *data,
+                      gsize            stride)
+{
+  GskRenderer *renderer;
+  int width, height;
+  GskRenderNode *node;
+  GdkTexture *gl_texture;
+  GdkTextureDownloader *downloader;
+  GError *error = NULL;
+
+  GDK_DEBUG (MISC, "Using gsk_renderer_render_texture import for downloading a dmabuf");
+
+  g_assert (GDK_IS_DISPLAY (self->display));
+  g_assert (GDK_IS_GL_CONTEXT (gdk_display_get_gl_context (self->display)));
+
+  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;
+    }
+
+  width = gdk_texture_get_width (GDK_TEXTURE (self));
+  height = gdk_texture_get_height (GDK_TEXTURE (self));
+
+  node = gsk_texture_node_new (GDK_TEXTURE (self), &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gl_texture = gsk_renderer_render_texture (renderer, node, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gsk_render_node_unref (node);
+
+  gsk_renderer_unrealize (renderer);
+  g_object_unref (renderer);
+
+  downloader = gdk_texture_downloader_new (gl_texture);
+
+  gdk_texture_downloader_set_format (downloader, format);
+
+  gdk_texture_downloader_download_into (downloader, data, stride);
+
+  gdk_texture_downloader_free (downloader);
+  g_object_unref (gl_texture);
+}
+
+static void
+do_direct_download (GdkDmabufTexture *self,
+                    guchar           *data,
+                    gsize             stride)
+{
+  gsize size;
+  unsigned int height;
+  gsize src_stride;
+  guchar *src_data;
+  int bpp;
+
+  GDK_DEBUG (MISC, "Using mmap() and memcpy() for downloading a dmabuf");
+
+  height = gdk_texture_get_height (GDK_TEXTURE (self));
+  bpp = gdk_memory_format_bytes_per_pixel (gdk_texture_get_format (GDK_TEXTURE (self)));
+
+  src_stride = self->strides[0];
+  size = self->strides[0] * height;
+
+  if (ioctl (self->fds[0], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_START|DMA_BUF_SYNC_READ }) < 0)
+    g_warning ("Failed to sync dma-buf: %s", g_strerror (errno));
+
+  src_data = mmap (NULL, size, PROT_READ, MAP_SHARED, self->fds[0], self->offsets[0]);
+
+  if (stride == src_stride)
+    memcpy (data, src_data, size);
+  else
+    {
+      for (unsigned int i = 0; i < height; i++)
+        memcpy (data + i * stride, src_data + i * src_stride, height * bpp);
+    }
+
+  munmap (src_data, size);
+
+  if (ioctl (self->fds[0], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_END|DMA_BUF_SYNC_READ }) < 0)
+    g_warning ("Failed to sync dma-buf: %s", g_strerror (errno));
+}
+
+#endif  /* HAVE_LINUX_DMA_BUF_H */
+
+GdkDmabufFormat *
+gdk_dmabuf_texture_get_supported_formats (gsize *n_formats)
+{
+#ifdef HAVE_LINUX_DMA_BUF_H
+
+  GdkDmabufFormat *formats;
+
+  *n_formats = G_N_ELEMENTS (supported_formats);
+  formats = g_new (GdkDmabufFormat, sizeof (GdkDmabufFormat) * *n_formats);
+
+  for (gsize i = 0; i < *n_formats; i++)
+    {
+      formats[i].fourcc = supported_formats[i].fourcc;
+      formats[i].modifier = DRM_FORMAT_MOD_LINEAR;
+    }
+
+  return formats;
+
+#else
+
+  *n_formats = 0;
+  return NULL;
+
+#endif
+}
+
+gboolean
+gdk_dmabuf_texture_may_support (guint32 fourcc)
+{
+#ifdef HAVE_LINUX_DMA_BUF_H
+
+  for (gsize i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      if (supported_formats[i].fourcc == fourcc)
+        return TRUE;
+    }
+
+#endif
+
+  return FALSE;
+}
+
+static void
+gdk_dmabuf_texture_download (GdkTexture      *texture,
+                             GdkMemoryFormat  format,
+                             guchar          *data,
+                             gsize            stride)
+{
+#ifdef HAVE_LINUX_DMA_BUF_H
+  GdkDmabufTexture *self = GDK_DMABUF_TEXTURE (texture);
+  GdkMemoryFormat src_format = gdk_texture_get_format (texture);
+  GdkDrmFormatInfo *info;
+
+  info = get_drm_format_info (self->fourcc);
+
+  g_assert (info != NULL);
+
+  if (info->requires_gl || self->n_planes > 1 || self->modifier != DRM_FORMAT_MOD_LINEAR)
+    do_indirect_download (self, format, data, stride);
+  else if (format == src_format)
+    do_direct_download (self, 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 = self->strides[0];
+      src_data = g_new (guchar, src_stride * height);
+
+      do_direct_download (self, src_data, src_stride);
+
+      gdk_memory_convert (data, stride, format,
+                          src_data, src_stride, src_format,
+                          width, height);
+
+      g_free (src_data);
+    }
+#endif  /* HAVE_LINUX_DMA_BUF_H */
+}
+
+static gboolean
+display_supports_format (GdkDisplay *display,
+                         guint32     fourcc,
+                         guint64     modifier)
+{
+  GdkDmabufFormats *formats;
+
+  if (!display)
+    return FALSE;
+
+  formats = gdk_display_get_dmabuf_formats (display);
+
+  return gdk_dmabuf_formats_contains (formats, fourcc, modifier);
+}
+
+GdkTexture *
+gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                     GDestroyNotify           destroy,
+                                     gpointer                 data)
+{
+#ifdef HAVE_LINUX_DMA_BUF_H
+  GdkDmabufTexture *self;
+  GdkTexture *update_texture;
+  GdkDisplay *display = gdk_dmabuf_texture_builder_get_display (builder);
+  guint32 fourcc = gdk_dmabuf_texture_builder_get_fourcc (builder);
+  guint64 modifier = gdk_dmabuf_texture_builder_get_modifier (builder);
+  gboolean premultiplied = gdk_dmabuf_texture_builder_get_premultiplied (builder);
+  unsigned int n_planes = gdk_dmabuf_texture_builder_get_n_planes (builder);
+  GdkDrmFormatInfo *info;
+
+  info = get_drm_format_info (fourcc);
+
+  if ((!info || info->requires_gl || n_planes > 1 || modifier != DRM_FORMAT_MOD_LINEAR) && !display_supports_format (display, fourcc, modifier))
+    {
+      g_warning ("Unsupported dmabuf format %c%c%c%c:%#lx",
+                 fourcc & 0xff, (fourcc >> 8) & 0xff, (fourcc >> 16) & 0xff, (fourcc >> 24) & 0xff, modifier);
+      return NULL;
+    }
+
+  GDK_DEBUG (MISC, "Dmabuf texture in format %c%c%c%c:%#lx",
+             fourcc & 0xff, (fourcc >> 8) & 0xff, (fourcc >> 16) & 0xff, (fourcc >> 24) & 0xff, modifier);
+
+  self = g_object_new (GDK_TYPE_DMABUF_TEXTURE,
+                       "width", gdk_dmabuf_texture_builder_get_width (builder),
+                       "height", gdk_dmabuf_texture_builder_get_height (builder),
+                       NULL);
+
+  self->destroy = destroy;
+  self->data = data;
+
+  if (info)
+    GDK_TEXTURE (self)->format = premultiplied ? info->premultiplied_memory_format
+                                               : info->unpremultiplied_memory_format;
+  else
+    GDK_TEXTURE (self)->format = premultiplied ? GDK_MEMORY_A8R8G8B8_PREMULTIPLIED : GDK_MEMORY_A8R8G8B8;
+
+  g_set_object (&self->display, display);
+
+  self->fourcc = fourcc;
+  self->modifier = modifier;
+  self->n_planes = n_planes;
+
+  memcpy (self->fds, gdk_dmabuf_texture_builder_get_fds (builder), sizeof (int) * MAX_DMABUF_PLANES);
+  memcpy (self->strides, gdk_dmabuf_texture_builder_get_strides (builder), sizeof (unsigned int) * MAX_DMABUF_PLANES);
+  memcpy (self->offsets, gdk_dmabuf_texture_builder_get_offsets (builder), sizeof (unsigned int) * MAX_DMABUF_PLANES);
+
+  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_LINUX_DMA_BUF_H */
+  return NULL;
+#endif
+}

gdk/gdkdmabuftexture.h

@@ -0,0 +1,43 @@
+/* gdkdmabuftexture.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>
+#include <gdk/gdktexture.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DMABUF_TEXTURE (gdk_dmabuf_texture_get_type ())
+
+#define GDK_DMABUF_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_DMABUF_TEXTURE, GdkDmabufTexture))
+#define GDK_IS_DMABUF_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_DMABUF_TEXTURE))
+
+typedef struct _GdkDmabufTexture            GdkDmabufTexture;
+typedef struct _GdkDmabufTextureClass       GdkDmabufTextureClass;
+
+GDK_AVAILABLE_IN_4_14
+GType                   gdk_dmabuf_texture_get_type                (void) G_GNUC_CONST;
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDmabufTexture, g_object_unref)
+
+G_END_DECLS

gdk/gdkdmabuftexturebuilder.c

@@ -0,0 +1,992 @@
+/*
+ * 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.1 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/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include "gdkdmabuftexturebuilder.h"
+
+#include "gdkdisplay.h"
+#include "gdkenumtypes.h"
+#include "gdkdmabuftextureprivate.h"
+
+#include <cairo-gobject.h>
+
+
+struct _GdkDmabufTextureBuilder
+{
+  GObject parent_instance;
+
+  GdkDisplay *display;
+  unsigned int width;
+  unsigned int height;
+  guint32 fourcc;
+  guint64 modifier;
+  gboolean premultiplied;
+
+  unsigned int n_planes;
+
+  /* per-plane properties */
+  int fds[MAX_DMABUF_PLANES];
+  unsigned int strides[MAX_DMABUF_PLANES];
+  unsigned int offsets[MAX_DMABUF_PLANES];
+
+  GdkTexture *update_texture;
+  cairo_region_t *update_region;
+};
+
+struct _GdkDmabufTextureBuilderClass
+{
+  GObjectClass parent_class;
+};
+
+/**
+ * GdkDmabufTextureBuilder:
+ *
+ * `GdkDmabufTextureBuilder` is a builder used to construct [class@Gdk.Texture]
+ * objects from DMA buffers.
+ *
+ * DMA buffers are commonly called **_dma-bufs_**.
+ *
+ * DMA buffers a feature of the Linux kernel to enable efficient buffer and
+ * memory sharing between hardware such as codecs, GPUs, displays, cameras and the
+ * kernel drivers controlling them. For example, a decoder may want its output to
+ * be directly shared with the display server for rendering without a copy.
+ *
+ * Any device driver which participates in DMA buffer sharing, can do so as either
+ * the exporter or importer of buffers (or both).
+ *
+ * The memory that is shared via DMA buffers is usually stored in non-system memory
+ * (maybe in device's local memory or something else not directly accessible by the
+ * CPU), and accessing this memory from the CPU may have higher than usual overhead.
+ *
+ * In particular for graphics data, it is not uncommon that data consists of multiple
+ * separate blocks of memory, for example one block for each of the red, green and
+ * blue channels. These blocks are called **_planes_**. DMA buffers can have up to
+ * four planes. Even if the memory is a single block, the data can be organized in
+ * multiple planes, by specifying offsets from the beginning of the data.
+ *
+ * DMA buffers are exposed to user-space as file descriptors allowing to pass them
+ * between processes. If a DMA buffer has multiple planes, there is one file
+ * descriptor per plane.
+ *
+ * The format of the data (for graphics data, essentially its colorspace) is described
+ * by a 32-bit integer. These format identifiers are defined in the header file
+ * [drm/drm_fourcc.h](https://github.com/torvalds/linux/blob/master/include/uapi/drm/drm_fourcc.h)
+ * and commonly referred to as **_fourcc_** values, since they are identified by 4 ASCII
+ * characters. Additionally, each DMA buffer has a **_modifier_**, which is a 64-bit integer
+ * that describes driver-specific details of the memory layout, such as tiling or compression.
+ *
+ * The operation of `GdkDmabufTextureBuilder` is quite simple: Create a texture builder,
+ * set all the necessary properties, and then call [method@Gdk.DmabufTextureBuilder.build]
+ * to create the new texture.
+ *
+ * The required properties for a dma-buf texture are
+ *  - The width and height in pixels
+ *  - The `fourcc` code and `modifier` which identify the format and memory layout of the dma-buf
+ *  - The file descriptor, offset and stride for each of the planes
+ *
+ * `GdkDmabufTextureBuilder` can be used for quick one-shot construction of
+ * textures as well as kept around and reused to construct multiple textures.
+ *
+ * Since: 4.14
+ */
+
+enum
+{
+  PROP_0,
+  PROP_DISPLAY,
+  PROP_WIDTH,
+  PROP_HEIGHT,
+  PROP_FOURCC,
+  PROP_MODIFIER,
+  PROP_PREMULTIPLIED,
+  PROP_N_PLANES,
+  PROP_UPDATE_REGION,
+  PROP_UPDATE_TEXTURE,
+
+  N_PROPS
+};
+
+G_DEFINE_TYPE (GdkDmabufTextureBuilder, gdk_dmabuf_texture_builder, G_TYPE_OBJECT)
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gdk_dmabuf_texture_builder_dispose (GObject *object)
+{
+  GdkDmabufTextureBuilder *self = GDK_DMABUF_TEXTURE_BUILDER (object);
+
+  g_clear_object (&self->update_texture);
+  g_clear_pointer (&self->update_region, cairo_region_destroy);
+
+  G_OBJECT_CLASS (gdk_dmabuf_texture_builder_parent_class)->dispose (object);
+}
+
+static void
+gdk_dmabuf_texture_builder_get_property (GObject    *object,
+                                         guint       property_id,
+                                         GValue     *value,
+                                         GParamSpec *pspec)
+{
+  GdkDmabufTextureBuilder *self = GDK_DMABUF_TEXTURE_BUILDER (object);
+
+  switch (property_id)
+    {
+    case PROP_DISPLAY:
+      g_value_set_object (value, self->display);
+      break;
+
+    case PROP_WIDTH:
+      g_value_set_uint (value, self->width);
+      break;
+
+    case PROP_HEIGHT:
+      g_value_set_uint (value, self->height);
+      break;
+
+    case PROP_FOURCC:
+      g_value_set_uint (value, self->fourcc);
+      break;
+
+    case PROP_MODIFIER:
+      g_value_set_uint64 (value, self->modifier);
+      break;
+
+    case PROP_PREMULTIPLIED:
+      g_value_set_boolean (value, self->premultiplied);
+      break;
+
+    case PROP_N_PLANES:
+      g_value_set_uint (value, self->n_planes);
+      break;
+
+    case PROP_UPDATE_REGION:
+      g_value_set_boxed (value, self->update_region);
+      break;
+
+    case PROP_UPDATE_TEXTURE:
+      g_value_set_object (value, self->update_texture);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gdk_dmabuf_texture_builder_set_property (GObject      *object,
+                                         guint         property_id,
+                                         const GValue *value,
+                                         GParamSpec   *pspec)
+{
+  GdkDmabufTextureBuilder *self = GDK_DMABUF_TEXTURE_BUILDER (object);
+
+  switch (property_id)
+    {
+    case PROP_DISPLAY:
+      gdk_dmabuf_texture_builder_set_display (self, g_value_get_object (value));
+      break;
+
+    case PROP_WIDTH:
+      gdk_dmabuf_texture_builder_set_width (self, g_value_get_uint (value));
+      break;
+
+    case PROP_HEIGHT:
+      gdk_dmabuf_texture_builder_set_height (self, g_value_get_uint (value));
+      break;
+
+    case PROP_FOURCC:
+      gdk_dmabuf_texture_builder_set_fourcc (self, g_value_get_uint (value));
+      break;
+
+    case PROP_MODIFIER:
+      gdk_dmabuf_texture_builder_set_modifier (self, g_value_get_uint64 (value));
+      break;
+
+    case PROP_PREMULTIPLIED:
+      gdk_dmabuf_texture_builder_set_premultiplied (self, g_value_get_boolean (value));
+      break;
+
+    case PROP_N_PLANES:
+      gdk_dmabuf_texture_builder_set_n_planes (self, g_value_get_uint (value));
+      break;
+
+    case PROP_UPDATE_REGION:
+      gdk_dmabuf_texture_builder_set_update_region (self, g_value_get_boxed (value));
+      break;
+
+    case PROP_UPDATE_TEXTURE:
+      gdk_dmabuf_texture_builder_set_update_texture (self, g_value_get_object (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gdk_dmabuf_texture_builder_class_init (GdkDmabufTextureBuilderClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->dispose = gdk_dmabuf_texture_builder_dispose;
+  gobject_class->get_property = gdk_dmabuf_texture_builder_get_property;
+  gobject_class->set_property = gdk_dmabuf_texture_builder_set_property;
+
+  /**
+   * GdkDmabufTextureBuilder:display: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_display org.gdk.Property.set=gdk_dmabuf_texture_builder_set_display)
+   *
+   * The display that this texture will be used on.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_DISPLAY] =
+    g_param_spec_object ("display", NULL, NULL,
+                         GDK_TYPE_DISPLAY,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:width: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_width org.gdk.Property.set=gdk_dmabuf_texture_builder_set_width)
+   *
+   * The width of the texture.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_WIDTH] =
+    g_param_spec_uint ("width", NULL, NULL,
+                       0, G_MAXUINT, 0,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:height: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_height org.gdk.Property.set=gdk_dmabuf_texture_builder_set_height)
+   *
+   * The height of the texture.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_HEIGHT] =
+    g_param_spec_uint ("height", NULL, NULL,
+                       0, G_MAXUINT, 0,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:fourcc: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_fourcc org.gdk.Property.set=gdk_dmabuf_texture_builder_set_fourcc)
+   *
+   * The format of the texture, as a fourcc value.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_FOURCC] =
+    g_param_spec_uint ("fourcc", NULL, NULL,
+                       0, 0xffffffff, 0,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:modifier:
+   *
+   * The modifier.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_MODIFIER] =
+    g_param_spec_uint64 ("modifier", NULL, NULL,
+                         0, G_MAXUINT, 0,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:premultiplied:
+   *
+   * Whether the alpha channel is premultiplied into the others.
+   *
+   * Only relevant if the format has alpha.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_PREMULTIPLIED] =
+    g_param_spec_boolean ("premultiplied", NULL, NULL,
+                          TRUE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:n-planes: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_n_planes org.gdk.Property.set=gdk_dmabuf_texture_builder_set_n_planes)
+   *
+   * The number of planes of the texture.
+   *
+   * Note that you can set properties for other planes,
+   * but they will be ignored when constructing the texture.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_N_PLANES] =
+    g_param_spec_uint ("n-planes", NULL, NULL,
+                       0, 4, 0,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:update-region: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_update_region org.gdk.Property.set=gdk_dmabuf_texture_builder_set_update_region)
+   *
+   * The update region for [property@Gdk.GLTextureBuilder:update-texture].
+   *
+   * Since: 4.14
+   */
+  properties[PROP_UPDATE_REGION] =
+    g_param_spec_boxed ("update-region", NULL, NULL,
+                        CAIRO_GOBJECT_TYPE_REGION,
+                        G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkDmabufTextureBuilder:update-texture: (attributes org.gdk.Property.get=gdk_dmabuf_texture_builder_get_update_texture org.gdk.Property.set=gdk_dmabuf_texture_builder_set_update_texture)
+   *
+   * The texture [property@Gdk.GLTextureBuilder:update-region] is an update for.
+   *
+   * Since: 4.14
+   */
+  properties[PROP_UPDATE_TEXTURE] =
+    g_param_spec_object ("update-texture", NULL, NULL,
+                         GDK_TYPE_TEXTURE,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gdk_dmabuf_texture_builder_init (GdkDmabufTextureBuilder *self)
+{
+  self->fds[0] = self->fds[1] = self->fds[2] = self->fds[3] = -1;
+  self->premultiplied = TRUE;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_new: (constructor):
+ *
+ * Creates a new texture builder.
+ *
+ * Returns: the new `GdkTextureBuilder`
+ *
+ * Since: 4.14
+ **/
+GdkDmabufTextureBuilder *
+gdk_dmabuf_texture_builder_new (void)
+{
+  return g_object_new (GDK_TYPE_DMABUF_TEXTURE_BUILDER, NULL);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_display:
+ * @self: a `GdkDmabufTextureBuilder
+ *
+ * Returns the display that this texture builder is
+ * associated with.
+ *
+ * Returns: (transfer none) (nullable): the display
+ *
+ * Since: 4.14
+ */
+GdkDisplay *
+gdk_dmabuf_texture_builder_get_display (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), NULL);
+
+  return self->display;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_display:
+ * @self: a `GdkDmabufTextureBuilder
+ * @display: the display
+ *
+ * Sets the display that this texture builder is
+ * associated with.
+ *
+ * The display is used to determine the supported
+ * dma-buf formats.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_display (GdkDmabufTextureBuilder *self,
+                                        GdkDisplay              *display)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (g_set_object (&self->display, display))
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DISPLAY]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_width: (attributes org.gdk.Method.get_property=width)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the width previously set via gdk_dmabuf_texture_builder_set_width() or
+ * 0 if the width wasn't set.
+ *
+ * Returns: The width
+ *
+ * Since: 4.14
+ */
+unsigned int
+gdk_dmabuf_texture_builder_get_width (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+
+  return self->width;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_width: (attributes org.gdk.Method.set_property=width)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @width: The texture's width or 0 to unset
+ *
+ * Sets the width of the texture.
+ *
+ * The width must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_width (GdkDmabufTextureBuilder *self,
+                                      unsigned int             width)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->width == width)
+    return;
+
+  self->width = width;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_WIDTH]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_height: (attributes org.gdk.Method.get_property=height)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the height previously set via gdk_dmabuf_texture_builder_set_height() or
+ * 0 if the height wasn't set.
+ *
+ * Returns: The height
+ *
+ * Since: 4.14
+ */
+unsigned int
+gdk_dmabuf_texture_builder_get_height (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+
+  return self->height;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_height: (attributes org.gdk.Method.set_property=height)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @height: the texture's height or 0 to unset
+ *
+ * Sets the height of the texture.
+ *
+ * The height must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_height (GdkDmabufTextureBuilder *self,
+                                       unsigned int             height)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->height == height)
+    return;
+
+  self->height = height;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HEIGHT]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_fourcc: (attributes org.gdk.Method.get_property=fourcc)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the format previously set via gdk_dmabuf_texture_builder_set_fourcc()
+ * or 0 if the format wasn't set.
+ *
+ * The format is specified as a fourcc code.
+ *
+ * Returns: The format
+ *
+ * Since: 4.14
+ */
+guint32
+gdk_dmabuf_texture_builder_get_fourcc (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+
+  return self->fourcc;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_fourcc: (attributes org.gdk.Method.set_property=fourcc)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @fourcc: the texture's format or 0 to unset
+ *
+ * Sets the format of the texture.
+ *
+ * The format is specified as a fourcc code.
+ *
+ * The format must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_fourcc (GdkDmabufTextureBuilder *self,
+                                       guint32                  fourcc)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->fourcc == fourcc)
+    return;
+
+  self->fourcc = fourcc;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FOURCC]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_modifier:
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the modifier value.
+ *
+ * Returns: the modifier
+ *
+ * Since: 4.14
+ */
+guint64
+gdk_dmabuf_texture_builder_get_modifier (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+
+  return self->modifier;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_modifier:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @modifier: the modifier value
+ *
+ * Sets the modifier.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_modifier (GdkDmabufTextureBuilder *self,
+                                         guint64                  modifier)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->modifier == modifier)
+    return;
+
+  self->modifier = modifier;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODIFIER]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_n_planes: (attributes org.gdk.Method.get_property=n-planes)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the number of planes.
+ *
+ * Returns: The number of planes
+ *
+ * Since: 4.14
+ */
+unsigned int
+gdk_dmabuf_texture_builder_get_n_planes (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+
+  return self->n_planes;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_premultiplied:
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Whether the data is premultiplied.
+ *
+ * Returns: whether the data is premultiplied
+ *
+ * Since: 4.14
+ */
+gboolean
+gdk_dmabuf_texture_builder_get_premultiplied (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), TRUE);
+
+  return self->premultiplied;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_premultiplied:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @premultiplied: whether the data is premultiplied
+ *
+ * Sets whether the data is premultiplied.
+ *
+ * Unless otherwise specified, all formats including alpha channels are assumed
+ * to be premultiplied.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_premultiplied (GdkDmabufTextureBuilder *self,
+                                              gboolean                 premultiplied)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->premultiplied == premultiplied)
+    return;
+
+  self->premultiplied = premultiplied;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PREMULTIPLIED]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_n_planes: (attributes org.gdk.Method.set_property=n-planes)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @n_planes: the number of planes
+ *
+ * Sets the number of planes of the texture.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_n_planes (GdkDmabufTextureBuilder *self,
+                                         unsigned int             n_planes)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->n_planes == n_planes)
+    return;
+
+  self->n_planes = n_planes;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_N_PLANES]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_fd:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to get the fd for
+ *
+ * Gets the file descriptor for a plane.
+ *
+ * Returns: the file descriptor
+ *
+ * Since: 4.14
+ */
+int
+gdk_dmabuf_texture_builder_get_fd (GdkDmabufTextureBuilder *self,
+                                   unsigned int             plane)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+  g_return_val_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES, 0);
+
+  return self->fds[plane];
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_fd:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to set the fd for
+ * @fd: the file descriptor
+ *
+ * Sets the file descriptor for a plane.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_fd (GdkDmabufTextureBuilder *self,
+                                   unsigned int             plane,
+                                   int                      fd)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES);
+
+  if (self->fds[plane] == fd)
+    return;
+
+  self->fds[plane] = fd;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_stride:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to get the stride for
+ *
+ * Gets the stride value for a plane.
+ *
+ * Returns: the stride
+ *
+ * Since: 4.14
+ */
+unsigned int
+gdk_dmabuf_texture_builder_get_stride (GdkDmabufTextureBuilder *self,
+                                       unsigned int             plane)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+  g_return_val_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES, 0);
+
+  return self->strides[plane];
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_stride:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to set the stride for
+ * @stride: the stride value
+ *
+ * Sets the stride for a plane.
+ *
+ * The stride must be set for all planes before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_stride (GdkDmabufTextureBuilder *self,
+                                       unsigned int             plane,
+                                       unsigned int             stride)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES);
+
+  if (self->strides[plane] == stride)
+    return;
+
+  self->strides[plane] = stride;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_offset:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to get the offset for
+ *
+ * Gets the offset value for a plane.
+ *
+ * Returns: the offset
+ *
+ * Since: 4.14
+ */
+unsigned int
+gdk_dmabuf_texture_builder_get_offset (GdkDmabufTextureBuilder *self,
+                                       unsigned int             plane)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), 0);
+  g_return_val_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES, 0);
+
+  return self->offsets[plane];
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_offset:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @plane: the plane to set the offset for
+ * @offset: the offset value
+ *
+ * Sets the offset for a plane.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_offset (GdkDmabufTextureBuilder *self,
+                                       unsigned int             plane,
+                                       unsigned int             offset)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (0 <= plane && plane < MAX_DMABUF_PLANES);
+
+  if (self->offsets[plane] == offset)
+    return;
+
+  self->offsets[plane] = offset;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_update_texture: (attributes org.gdk.Method.get_property=update_texture)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the texture previously set via gdk_dmabuf_texture_builder_set_update_texture() or
+ * %NULL if none was set.
+ *
+ * Returns: (transfer none) (nullable): The texture
+ *
+ * Since: 4.14
+ */
+GdkTexture *
+gdk_dmabuf_texture_builder_get_update_texture (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), NULL);
+
+  return self->update_texture;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_update_texture: (attributes org.gdk.Method.set_property=update_texture)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @texture: (nullable): the texture to update
+ *
+ * Sets the texture to be updated by this texture. See
+ * [method@Gdk.DmabufTextureBuilder.set_update_region] for an explanation.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_update_texture (GdkDmabufTextureBuilder *self,
+                                               GdkTexture          *texture)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (texture == NULL || GDK_IS_TEXTURE (texture));
+
+  if (!g_set_object (&self->update_texture, texture))
+    return;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_UPDATE_TEXTURE]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_get_update_region: (attributes org.gdk.Method.get_property=update_region)
+ * @self: a `GdkDmabufTextureBuilder`
+ *
+ * Gets the region previously set via gdk_dmabuf_texture_builder_set_update_region() or
+ * %NULL if none was set.
+ *
+ * Returns: (transfer none) (nullable): The region
+ *
+ * Since: 4.14
+ */
+cairo_region_t *
+gdk_dmabuf_texture_builder_get_update_region (GdkDmabufTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), NULL);
+
+  return self->update_region;
+}
+
+/**
+ * gdk_dmabuf_texture_builder_set_update_region: (attributes org.gdk.Method.set_property=update_region)
+ * @self: a `GdkDmabufTextureBuilder`
+ * @region: (nullable): the region to update
+ *
+ * Sets the region to be updated by this texture. Together with
+ * [property@Gdk.DmabufTextureBuilder:update-texture] this describes an
+ * update of a previous texture.
+ *
+ * When rendering animations of large textures, it is possible that
+ * consecutive textures are only updating contents in parts of the texture.
+ * It is then possible to describe this update via these two properties,
+ * so that GTK can avoid rerendering parts that did not change.
+ *
+ * An example would be a screen recording where only the mouse pointer moves.
+ *
+ * Since: 4.14
+ */
+void
+gdk_dmabuf_texture_builder_set_update_region (GdkDmabufTextureBuilder *self,
+                                              cairo_region_t      *region)
+{
+  g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+
+  if (self->update_region == region)
+    return;
+
+  g_clear_pointer (&self->update_region, cairo_region_destroy);
+
+  if (region)
+    self->update_region = cairo_region_reference (region);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_UPDATE_REGION]);
+}
+
+/**
+ * gdk_dmabuf_texture_builder_build:
+ * @self: a `GdkDmabufTextureBuilder`
+ * @destroy: (nullable): destroy function to be called when the texture is
+ *   released
+ * @data: user data to pass to the destroy function
+ *
+ * Builds a new `GdkTexture` with the values set up in the builder.
+ *
+ * The `destroy` function gets called when the returned texture gets released.
+ *
+ * Note that it is a programming error to call this function if any mandatory
+ * property has not been set.
+ *
+ * It is possible to call this function multiple times to create multiple textures,
+ * possibly with changing properties in between.
+ *
+ * It is the responsibility of the caller to keep the file descriptors for the planes
+ * open until the created texture is no longer used, and close them afterwards (possibly
+ * using the @destroy notify).
+ *
+ * Not all formats defined in the `drm_fourcc.h` header are supported. You can use
+ * [method@Gdk.Display.get_dmabuf_formats] to get a list of supported formats.
+ *
+ * Returns: (transfer full) (nullable): a newly built `GdkTexture` or `NULL`
+ *   if the format is not supported
+ *
+ * Since: 4.14
+ */
+GdkTexture *
+gdk_dmabuf_texture_builder_build (GdkDmabufTextureBuilder *self,
+                                  GDestroyNotify       destroy,
+                                  gpointer             data)
+{
+  g_return_val_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self), NULL);
+  g_return_val_if_fail (destroy == NULL || data != NULL, NULL);
+  g_return_val_if_fail (self->width > 0, NULL);
+  g_return_val_if_fail (self->height > 0, NULL);
+  g_return_val_if_fail (self->fourcc != 0, NULL);
+  g_return_val_if_fail (self->n_planes > 0, NULL);
+
+  for (int i = 0; i < self->n_planes; i++)
+    g_return_val_if_fail (self->fds[i] != -1 || self->offsets[i] != 0, NULL);
+
+  return gdk_dmabuf_texture_new_from_builder (self, destroy, data);
+}
+
+int *
+gdk_dmabuf_texture_builder_get_fds (GdkDmabufTextureBuilder *self)
+{
+  return self->fds;
+}
+
+unsigned int *
+gdk_dmabuf_texture_builder_get_strides (GdkDmabufTextureBuilder *self)
+{
+  return self->strides;
+}
+
+unsigned int *
+gdk_dmabuf_texture_builder_get_offsets (GdkDmabufTextureBuilder *self)
+{
+  return self->offsets;
+}

gdk/gdkdmabuftexturebuilder.h

@@ -0,0 +1,121 @@
+/*
+ * 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.1 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/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#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_TEXTURE_BUILDER (gdk_dmabuf_texture_builder_get_type ())
+GDK_AVAILABLE_IN_4_14
+GDK_DECLARE_INTERNAL_TYPE (GdkDmabufTextureBuilder, gdk_dmabuf_texture_builder, GDK, DMABUF_TEXTURE_BUILDER, GObject)
+
+GDK_AVAILABLE_IN_4_14
+GdkDmabufTextureBuilder *gdk_dmabuf_texture_builder_new              (void);
+
+GDK_AVAILABLE_IN_4_14
+GdkDisplay *             gdk_dmabuf_texture_builder_get_display      (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_display      (GdkDmabufTextureBuilder    *self,
+                                                                      GdkDisplay                 *display);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_width        (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_width        (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                width);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_height       (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_height       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                height);
+
+GDK_AVAILABLE_IN_4_14
+guint32                  gdk_dmabuf_texture_builder_get_fourcc       (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_fourcc       (GdkDmabufTextureBuilder    *self,
+                                                                      guint32                     fourcc);
+
+GDK_AVAILABLE_IN_4_14
+guint64                  gdk_dmabuf_texture_builder_get_modifier     (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_modifier     (GdkDmabufTextureBuilder    *self,
+                                                                      guint64                     modifier);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                 gdk_dmabuf_texture_builder_get_premultiplied (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_premultiplied (GdkDmabufTextureBuilder    *self,
+                                                                       gboolean                    premultiplied);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_n_planes     (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_n_planes     (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                n_planes);
+
+GDK_AVAILABLE_IN_4_14
+int                      gdk_dmabuf_texture_builder_get_fd           (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_fd           (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane,
+                                                                      int                         fd);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_stride       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_stride       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane,
+                                                                      unsigned int                stride);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_offset       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_offset       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                plane,
+                                                                      unsigned int                offset);
+
+GDK_AVAILABLE_IN_4_14
+GdkTexture *             gdk_dmabuf_texture_builder_get_update_texture (GdkDmabufTextureBuilder  *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_update_texture (GdkDmabufTextureBuilder  *self,
+                                                                        GdkTexture               *texture);
+
+GDK_AVAILABLE_IN_4_14
+cairo_region_t *         gdk_dmabuf_texture_builder_get_update_region (GdkDmabufTextureBuilder   *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_update_region (GdkDmabufTextureBuilder   *self,
+                                                                       cairo_region_t            *region);
+
+GDK_AVAILABLE_IN_4_14
+GdkTexture *             gdk_dmabuf_texture_builder_build            (GdkDmabufTextureBuilder    *self,
+                                                                      GDestroyNotify              destroy,
+                                                                      gpointer                    data);
+
+G_END_DECLS
+

gdk/gdkdmabuftextureprivate.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "gdkdmabuftexture.h"
+
+#include "gdkdmabuftexturebuilder.h"
+#include "gdkdmabufformatsprivate.h"
+#include "gdktextureprivate.h"
+#include "gdkdisplay.h"
+
+G_BEGIN_DECLS
+
+#define MAX_DMABUF_PLANES 4
+
+int *                   gdk_dmabuf_texture_builder_get_fds      (GdkDmabufTextureBuilder *builder);
+unsigned int *          gdk_dmabuf_texture_builder_get_offsets  (GdkDmabufTextureBuilder *builder);
+unsigned int *          gdk_dmabuf_texture_builder_get_strides  (GdkDmabufTextureBuilder *builder);
+
+GdkTexture *            gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                                             GDestroyNotify           destroy,
+                                                             gpointer                 data);
+
+guint32                 gdk_dmabuf_texture_get_fourcc   (GdkDmabufTexture *texture);
+guint64                 gdk_dmabuf_texture_get_modifier (GdkDmabufTexture *texture);
+unsigned int            gdk_dmabuf_texture_get_n_planes (GdkDmabufTexture *texture);
+int *                   gdk_dmabuf_texture_get_fds      (GdkDmabufTexture *texture);
+unsigned int *          gdk_dmabuf_texture_get_offsets  (GdkDmabufTexture *texture);
+unsigned int *          gdk_dmabuf_texture_get_strides  (GdkDmabufTexture *texture);
+
+GdkDmabufFormat *       gdk_dmabuf_texture_get_supported_formats (gsize   *n_formats);
+gboolean                gdk_dmabuf_texture_may_support           (guint32  fourcc);
+
+
+G_END_DECLS
+

gdk/gdkglcontext.c

@@ -1715,6 +1715,56 @@ gdk_gl_context_get_version (GdkGLContext *context,
     *minor = gdk_gl_version_get_minor (&priv->gl_version);
 }
 
+const char *
+gdk_gl_context_get_glsl_version_string (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  if (priv->api == GDK_GL_API_GL)
+    {
+      if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 6)))
+        return "#version 460";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 5)))
+        return "#version 450";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 4)))
+        return "#version 440";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 3)))
+        return "#version 430";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 2)))
+        return "#version 420";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 1)))
+        return "#version 410";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 0)))
+        return "#version 400";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 3)))
+        return "#version 330";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
+        return "#version 150";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
+        return "#version 140";
+      else
+        return "#version 130";
+    }
+  else if (priv->api == GDK_GL_API_GLES)
+    {
+      if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
+        return "#version 320 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
+        return "#version 310 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
+        return "#version 300 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
+        return "#version 300 es";
+      else
+        return "#version 100";
+    }
+  else
+    {
+      /* must be realized to be called */
+      g_assert_not_reached ();
+    }
+}
+
 /**
  * gdk_gl_context_clear_current:
  *

gdk/gdkglcontextprivate.h

@@ -147,6 +147,8 @@ void                    gdk_gl_context_label_object_printf      (GdkGLContext
                                                                  const char      *format,
                                                                 ...)  G_GNUC_PRINTF (4, 5);
 
+const char *            gdk_gl_context_get_glsl_version_string  (GdkGLContext    *self);
+
 gboolean                gdk_gl_context_has_debug                (GdkGLContext    *self) G_GNUC_PURE;
 
 gboolean                gdk_gl_context_use_es_bgra              (GdkGLContext    *context);

gdk/gdkpaintable.c

@@ -24,13 +24,16 @@
 #include "gdksnapshotprivate.h"
 #include "gdkprivate.h"
 
+#include <graphene.h>
+
 /* HACK: So we don't need to include any (not-yet-created) GSK or GTK headers */
 GdkSnapshot *   gtk_snapshot_new                        (void);
 void            gtk_snapshot_push_debug                 (GdkSnapshot            *snapshot,
                                                          const char             *message,
                                                          ...) G_GNUC_PRINTF (2, 3);
 void            gtk_snapshot_pop                        (GdkSnapshot            *snapshot);
-GdkPaintable *  gtk_snapshot_free_to_paintable          (GdkSnapshot            *snapshot);
+GdkPaintable *  gtk_snapshot_free_to_paintable          (GdkSnapshot            *snapshot,
+                                                         const graphene_size_t  *size);
 
 /**
  * GdkPaintable:
@@ -118,7 +121,7 @@ gdk_paintable_default_get_current_image (GdkPaintable *paintable)
 
   snapshot = gtk_snapshot_new ();
   gdk_paintable_snapshot (paintable, snapshot, width, height);
-  return gtk_snapshot_free_to_paintable (snapshot);
+  return gtk_snapshot_free_to_paintable (snapshot, NULL);
 }
 
 static GdkPaintableFlags

gdk/gdkpipeiostream.c

@@ -40,7 +40,7 @@ struct _GdkIOPipe
   GCond cond;
   guchar *buffer;
   gsize size;
-  GdkIOPipeState state : 2;
+  guint state : 2; /* GdkIOPipeState */
   guint input_closed : 1;
   guint output_closed : 1;
 };

gdk/gdksurface.c

@@ -254,7 +254,7 @@ maybe_flip_position (int       bounds_pos,
   *flipped = TRUE;
   secondary = rect_pos + (1 - rect_sign) * rect_size / 2 - offset - (1 - surface_sign) * surface_size / 2;
 
-  if (secondary >= bounds_pos && secondary + surface_size <= bounds_pos + bounds_size)
+  if ((secondary >= bounds_pos && secondary + surface_size <= bounds_pos + bounds_size) || primary > bounds_pos + bounds_size)
     return secondary;
 
   *flipped = FALSE;

gdk/gdktexture.c

@@ -345,7 +345,9 @@ gdk_texture_init (GdkTexture *self)
  *
  * Creates a new texture object representing the surface.
  *
- * @surface must be an image surface with format `CAIRO_FORMAT_ARGB32`.
+ * The @surface must be an image surface with format `CAIRO_FORMAT_ARGB32`.
+ *
+ * The newly created texture will acquire a reference on the @surface.
  *
  * Returns: a new `GdkTexture`
  */
@@ -364,7 +366,7 @@ gdk_texture_new_for_surface (cairo_surface_t *surface)
                                       * cairo_image_surface_get_stride (surface),
                                       (GDestroyNotify) cairo_surface_destroy,
                                       cairo_surface_reference (surface));
-  
+
   texture = gdk_memory_texture_new (cairo_image_surface_get_width (surface),
                                     cairo_image_surface_get_height (surface),
                                     GDK_MEMORY_DEFAULT,
@@ -819,7 +821,7 @@ gdk_texture_set_render_data (GdkTexture     *self,
                              GDestroyNotify  notify)
 {
   g_return_val_if_fail (data != NULL, FALSE);
- 
+
   if (self->render_key != NULL)
     return FALSE;
 

gdk/gdktypes.h

@@ -96,6 +96,8 @@ typedef struct _GdkCairoContext       GdkCairoContext;
 typedef struct _GdkGLContext          GdkGLContext;
 typedef struct _GdkVulkanContext      GdkVulkanContext;
 
+typedef struct _GdkDmabufFormats      GdkDmabufFormats;
+
 /*
  * GDK_DECLARE_INTERNAL_TYPE:
  * @ModuleObjName: The name of the new type, in camel case (like GtkWidget)

gdk/meson.build

@@ -17,6 +17,9 @@ gdk_public_sources = files([
   'gdkdevicetool.c',
   'gdkdisplay.c',
   'gdkdisplaymanager.c',
+  'gdkdmabufformats.c',
+  'gdkdmabuftexture.c',
+  'gdkdmabuftexturebuilder.c',
   'gdkdrag.c',
   'gdkdragsurface.c',
   'gdkdragsurfacesize.c',
@@ -79,6 +82,9 @@ gdk_public_headers = files([
   'gdkdisplay.h',
   'gdkdisplaymanager.h',
   'gdkdrag.h',
+  'gdkdmabufformats.h',
+  'gdkdmabuftexture.h',
+  'gdkdmabuftexturebuilder.h',
   'gdkdragsurfacesize.h',
   'gdkdrawcontext.h',
   'gdkdrop.h',

gdk/win32/gdkdisplay-win32.c

@@ -286,15 +286,16 @@ _gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
       GdkMonitor *ex_monitor;
 
       w32_ex_monitor = GDK_WIN32_MONITOR (g_list_model_get_item (win32_display->monitors, i));
-      g_object_unref (w32_ex_monitor);
       ex_monitor = GDK_MONITOR (w32_ex_monitor);
 
-      if (!w32_ex_monitor->remove)
-        continue;
+      if (w32_ex_monitor->remove)
+        {
+          w32_ex_monitor->hmonitor = NULL;
+          g_list_store_remove (G_LIST_STORE (win32_display->monitors), i);
+          gdk_monitor_invalidate (ex_monitor);
+        }
 
-      w32_ex_monitor->hmonitor = NULL;
-      g_list_store_remove (G_LIST_STORE (win32_display->monitors), i);
-      gdk_monitor_invalidate (ex_monitor);
+      g_object_unref (w32_ex_monitor);
     }
 
   for (i = 0; i < new_monitors->len; i++)