Update CODEOWNERS file

GitLab has standardised the CODEOWNERS file and made it available on
self-hosted instances.

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);
 }
 

docs/CODEOWNERS

@@ -2,8 +2,9 @@
 # a merge request for files listed here, please add the following people to
 # the list of reviewers
 
-# The syntax of this file is similar to the GitHub CODEOWNERS file:
-#   https://help.github.com/articles/about-codeowners/
+# The syntax of this file is defined in the GitLab documentation:
+#   https://docs.gitlab.com/ee/user/project/codeowners/reference.html
+#
 # Which, in turn, is similar to the .gitignore and .gitattributes files:
 #
 #  - comments start with `#`
@@ -14,64 +15,61 @@
 # If you want to be responsible for code reviews in specific sections of
 # the GTK code base, add yourself here.
 
-# Maintainer
-*                       @matthiasc
+[Maintainer]
+*                        @matthiasc
 
-# Build system
-meson.build             @ebassi @nirbheek
-*.py                    @ebassi
+[Build system]
+meson.build              @ebassi @nirbheek @xclaesse
+*.py                     @ebassi
 
-# CSS
-gtk/gtkcss*.[ch]        @otte @baedert
-gtk/gtkstyle*.[ch]      @otte @baedert
+[CSS]
+/gtk/gtkcss*.[ch]        @otte @matthiasc
+/gtk/gtkstyle*.[ch]      @otte @matthiasc
 
-# Gestures
-gtk/gtkeventcontroller* @carlosg
-gtk/gtkgesture*.[ch]    @carlosg
+[Gestures]
+/gtk/gtkeventcontroller* @carlosg
+/gtk/gtkgesture*.[ch]    @carlosg
 
-# GtkFileChooser
-gtk/gtkfilechooser*     @federico @ebassi
-gtk/gtkfilesystem*      @federico @ebassi
-gtk/gtkfilefilter*      @federico @ebassi
+[Input methods]
+/gtk/gtkimcontext*       @carlosg
 
-# GtkFontChooser
-gtk/gtkfontchooser*     @matthiasc
+[Media]
+/gtk/gtkmedia*           @otte
 
-# Input methods
-gtk/gtkimcontext*       @carlosg
+[GSK]
+/gsk/                    @otte @chergert @ebassi
 
-# Media
-gtk/gtkmedia*           @otte
+[GL rendering]
+/gsk/gl/                 @otte @chergert
 
-# GSK
-gsk                     @otte @baedert @ebassi
+[Vulkan rendering]
+/gsk/vulkan              @otte
 
-# GL rendering
-gsk/gl                  @baedert @ebassi
+[Documentation]
+/docs/                   @ebassi @dboles
+README.md                @ebassi
+CONTRIBUTING.md          @ebassi @matthiasc
 
-# Vulkan rendering
-gsk/vulkan
+[Wayland]
+/gdk/wayland             @jadahl
 
-# Documentation
-docs/                   @ebassi @dboles
+[X11]
+/gdk/x11                 @ofourdan @matthiasc @carlosg
 
-# Wayland
-gdk/wayland             @jadahl
+[macOS]
+/gdk/macos               @chergert
 
-# X11
-gdk/x11                 @ofourdan @matthiasc
+[Themes]
+/gtk/themes              @lapoc @jimmac
 
-# Themes
-gtk/themes              @lapoc @jimmac
+[Inspector]
+/gtk/inspector           @otte @matthiasc
 
-# Inspector
-gtk/inspector           @otte @matthiasc
+[Layout managers]
+/gtk/gtklayout*          @ebassi
+/gtk/gtkconstraint*      @ebassi
 
-# Layout managers
-gtk/gtklayout*          @ebassi
-gtk/gtkconstraint*      @ebassi
-
-# Accessibility
-gtk/gtkaccessible*.[ch] @ebassi
-gtk/gtkatcontext*.[ch]  @ebassi
-gtk/a11y                @ebassi
+[Accessibility]
+/gtk/gtkaccessible*.[ch] @ebassi @tyrylu @matthiasc
+/gtk/gtkatcontext*.[ch]  @ebassi @tyrylu @matthiasc
+/gtk/a11y                @ebassi @tyrylu

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 },
 };
 
 

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

@@ -215,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;

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);
 
   /**
@@ -404,6 +417,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);
 }
 
@@ -1824,6 +1839,76 @@ gdk_display_get_egl_display (GdkDisplay *self)
 #endif
 }
 
+#ifdef HAVE_LINUX_DMA_BUF_H
+static void
+gdk_display_add_dmabuf_downloader (GdkDisplay                *display,
+                                   const GdkDmabufDownloader *downloader,
+                                   GdkDmabufFormatsBuilder   *builder)
+{
+  gsize i;
+
+  downloader->add_formats (downloader, display, builder);
+
+  /* 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).
+ */
+static void
+init_dmabuf_formats (GdkDisplay *display)
+{
+  GdkDmabufFormatsBuilder *builder;
+
+  if (display->dmabuf_formats != NULL)
+    return;
+
+  builder = gdk_dmabuf_formats_builder_new ();
+
+#ifdef HAVE_LINUX_DMA_BUF_H
+  if (!GDK_DEBUG_CHECK (DMABUF_DISABLE))
+    {
+      gdk_display_prepare_gl (display, NULL);
+
+      gdk_display_add_dmabuf_downloader (display, gdk_dmabuf_get_direct_downloader (), builder);
+    }
+#endif
+
+  display->dmabuf_formats = gdk_dmabuf_formats_builder_free_to_formats (builder);
+} 
+
+/**
+ * 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 "gdkdmabufprivate.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;
+
+  GdkDmabufFormats *dmabuf_formats;
+  const GdkDmabufDownloader *dmabuf_downloaders[4];
 };
 
 struct _GdkDisplayClass

gdk/gdkdmabuf.c

@@ -0,0 +1,209 @@
+/* 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_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>
+
+typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
+struct _GdkDrmFormatInfo
+{
+  guint32 fourcc;
+  GdkMemoryFormat premultiplied_memory_format;
+  GdkMemoryFormat unpremultiplied_memory_format;
+};
+
+static GdkDrmFormatInfo supported_formats[] = {
+  { DRM_FORMAT_ARGB8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, GDK_MEMORY_A8R8G8B8 },
+  { DRM_FORMAT_RGBA8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, GDK_MEMORY_R8G8B8A8 },
+  { DRM_FORMAT_BGRA8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, GDK_MEMORY_B8G8R8A8 },
+  { DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, GDK_MEMORY_R16G16B16A16_FLOAT },
+  { DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8 },
+  { DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, GDK_MEMORY_B8G8R8 },
+};
+
+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
+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_dmabuf_formats_builder_add_format (builder,
+                                             supported_formats[i].fourcc,
+                                             DRM_FORMAT_MOD_LINEAR);
+    }
+}
+
+static gboolean
+gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader  *downloader,
+                                       GdkDisplay                 *display,
+                                       const GdkDmabuf            *dmabuf,
+                                       gboolean                    premultiplied,
+                                       GdkMemoryFormat            *out_format,
+                                       GError                    **error)
+{
+  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;
+    }
+
+  if (dmabuf->n_planes > 1)
+    {
+      g_set_error_literal (error,
+                           GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_CREATION_FAILED,
+                           "Multiplanar dmabufs are not supported");
+      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 GdkDmabuf *dmabuf;
+  gsize size;
+  unsigned int height;
+  gsize src_stride;
+  guchar *src_data;
+  int bpp;
+
+  GDK_DEBUG (DMABUF, "Using mmap() and memcpy() for downloading a dmabuf");
+
+  dmabuf = gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (texture));
+  height = gdk_texture_get_height (texture);
+  bpp = gdk_memory_format_bytes_per_pixel (gdk_texture_get_format (texture));
+
+  src_stride = dmabuf->planes[0].stride;
+  size = dmabuf->planes[0].stride * height;
+
+  if (ioctl (dmabuf->planes[0].fd, 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, dmabuf->planes[0].fd, dmabuf->planes[0].offset);
+
+  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 (dmabuf->planes[0].fd, 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));
+}
+
+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
+    {
+      const GdkDmabuf *dmabuf;
+      unsigned int width, height;
+      guchar *src_data;
+      gsize src_stride;
+
+      dmabuf = gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (texture));
+      width = gdk_texture_get_width (texture);
+      height = gdk_texture_get_height (texture);
+
+      src_stride = dmabuf->planes[0].stride;
+      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 = {
+    gdk_dmabuf_direct_downloader_add_formats,
+    gdk_dmabuf_direct_downloader_supports,
+    gdk_dmabuf_direct_downloader_download,
+  };
+
+  return &downloader;
+}
+
+#endif  /* HAVE_LINUX_DMA_BUF_H */

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,133 @@
+/* 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"
+
+#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)
+{
+  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,44 @@
+#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
+{
+  void                  (* 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_LINUX_DMA_BUF_H
+const GdkDmabufDownloader *
+                        gdk_dmabuf_get_direct_downloader        (void) G_GNUC_CONST;
+#endif

gdk/gdkdmabuftexture.c

@@ -0,0 +1,199 @@
+/* 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 "gdktextureprivate.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
+
+/**
+ * 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_LINUX_DMA_BUF_H
+  GdkDmabufTexture *self;
+  GdkTexture *update_texture;
+  GdkDisplay *display;
+  const GdkDmabuf *dmabuf;
+  GdkMemoryFormat format;
+  GError *local_error = NULL;
+  gsize i;
+
+  display = gdk_dmabuf_texture_builder_get_display (builder);
+  dmabuf = gdk_dmabuf_texture_builder_get_dmabuf (builder);
+
+  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;
+    }
+
+  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);
+
+  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_LINUX_DMA_BUF_H */
+  g_set_error_literal (error, GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_NOT_AVAILABLE,
+                       "dmabuf support disabled at compile-time.");
+  return NULL;
+#endif
+}
+

gdk/gdkdmabuftexture.h

@@ -0,0 +1,48 @@
+/* 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))
+
+#define GDK_DMABUF_ERROR       (gdk_dmabuf_error_quark ())
+
+typedef struct _GdkDmabufTexture            GdkDmabufTexture;
+typedef struct _GdkDmabufTextureClass       GdkDmabufTextureClass;
+
+GDK_AVAILABLE_IN_4_14
+GType                   gdk_dmabuf_texture_get_type                (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_4_14
+GQuark                  gdk_dmabuf_error_quark                     (void) G_GNUC_CONST;
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDmabufTexture, g_object_unref)
+
+G_END_DECLS

gdk/gdkdmabuftexturebuilder.c

@@ -0,0 +1,987 @@
+/*
+ * 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 "gdkdebugprivate.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;
+  gboolean premultiplied;
+
+  GdkDmabuf dmabuf;
+
+  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->dmabuf.fourcc);
+      break;
+
+    case PROP_MODIFIER:
+      g_value_set_uint64 (value, self->dmabuf.modifier);
+      break;
+
+    case PROP_PREMULTIPLIED:
+      g_value_set_boolean (value, self->premultiplied);
+      break;
+
+    case PROP_N_PLANES:
+      g_value_set_uint (value, self->dmabuf.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->premultiplied = TRUE;
+  for (int i = 0; i < GDK_DMABUF_MAX_PLANES; i++)
+    self->dmabuf.planes[i].fd = -1;
+}
+
+/**
+ * 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->dmabuf.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->dmabuf.fourcc == fourcc)
+    return;
+
+  self->dmabuf.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->dmabuf.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->dmabuf.modifier == modifier)
+    return;
+
+  self->dmabuf.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->dmabuf.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->dmabuf.n_planes == n_planes)
+    return;
+
+  self->dmabuf.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 < GDK_DMABUF_MAX_PLANES, 0);
+
+  return self->dmabuf.planes[plane].fd;
+}
+
+/**
+ * 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 < GDK_DMABUF_MAX_PLANES);
+
+  if (self->dmabuf.planes[plane].fd == fd)
+    return;
+
+  self->dmabuf.planes[plane].fd = 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 < GDK_DMABUF_MAX_PLANES, 0);
+
+  return self->dmabuf.planes[plane].stride;
+}
+
+/**
+ * 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 < GDK_DMABUF_MAX_PLANES);
+
+  if (self->dmabuf.planes[plane].stride == stride)
+    return;
+
+  self->dmabuf.planes[plane].stride = 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 < GDK_DMABUF_MAX_PLANES, 0);
+
+  return self->dmabuf.planes[plane].offset;
+}
+
+/**
+ * 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 < GDK_DMABUF_MAX_PLANES);
+
+  if (self->dmabuf.planes[plane].offset == offset)
+    return;
+
+  self->dmabuf.planes[plane].offset = 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
+ * @error: Return location for an error
+ *
+ * Builds a new `GdkTexture` with the values set up in the builder.
+ *
+ * It is a programming error to call this function if any mandatory
+ * property has not been set.
+ *
+ * If the dmabuf is not supported by GTK, %NULL will be returned and @error will be set.
+ *
+ * The `destroy` function gets called when the returned texture gets released.
+ *
+ * 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,
+                                  GError                 **error)
+{
+  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 (error == NULL || *error == 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->dmabuf.fourcc != 0, NULL);
+  g_return_val_if_fail (self->dmabuf.n_planes > 0, NULL);
+
+  for (int i = 0; i < self->dmabuf.n_planes; i++)
+    g_return_val_if_fail (self->dmabuf.planes[i].fd != -1 || self->dmabuf.planes[i].offset != 0, NULL);
+
+  if (GDK_DEBUG_CHECK (DMABUF_DISABLE))
+    {
+      g_set_error_literal (error, GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_NOT_AVAILABLE,
+                           "dmabuf support disabled via GDK_DEBUG environment variable");
+      return NULL;
+    }
+
+  return gdk_dmabuf_texture_new_from_builder (self, destroy, data, error);
+}
+
+const GdkDmabuf *
+gdk_dmabuf_texture_builder_get_dmabuf (GdkDmabufTextureBuilder *self)
+{
+  return &self->dmabuf;
+}

gdk/gdkdmabuftexturebuilder.h

@@ -0,0 +1,122 @@
+/*
+ * 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,
+                                                                      GError                    **error);
+
+G_END_DECLS
+

gdk/gdkdmabuftextureprivate.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "gdkdmabuftexture.h"
+
+#include "gdkdmabuftexturebuilder.h"
+#include "gdkdmabufprivate.h"
+
+G_BEGIN_DECLS
+
+const GdkDmabuf *       gdk_dmabuf_texture_builder_get_dmabuf   (GdkDmabufTextureBuilder *builder);
+
+GdkTexture *            gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                                             GDestroyNotify           destroy,
+                                                             gpointer                 data,
+                                                             GError                 **error);
+
+GdkDisplay *            gdk_dmabuf_texture_get_display      (GdkDmabufTexture        *self);
+const GdkDmabuf *       gdk_dmabuf_texture_get_dmabuf       (GdkDmabufTexture        *self);
+
+G_END_DECLS
+

gdk/gdkenums.h

@@ -142,6 +142,22 @@ typedef enum
                            GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
 
 
+/**
+ * GdkDmabufError:
+ * @GDK_DMABUF_ERROR_NOT_AVAILABLE: Dmabuf support is not available, because the OS
+ *   is not Linux, or it was explicitly disabled at compile- or runtime
+ * @GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT: The requested format is not supported
+ * @GDK_DMABUF_ERROR_CREATION_FAILED: GTK failed to create the resource for other
+ *   reasons
+ *
+ * Error enumeration for `GdkDmabufTexture`.
+ */
+typedef enum {
+  GDK_DMABUF_ERROR_NOT_AVAILABLE,
+  GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+  GDK_DMABUF_ERROR_CREATION_FAILED,
+} GdkDmabufError;
+
 /**
  * GdkGLError:
  * @GDK_GL_ERROR_NOT_AVAILABLE: OpenGL support is not available

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,11 @@ gdk_public_sources = files([
   'gdkdevicetool.c',
   'gdkdisplay.c',
   'gdkdisplaymanager.c',
+  'gdkdmabuf.c',
+  'gdkdmabufformats.c',
+  'gdkdmabufformatsbuilder.c',
+  'gdkdmabuftexture.c',
+  'gdkdmabuftexturebuilder.c',
   'gdkdrag.c',
   'gdkdragsurface.c',
   'gdkdragsurfacesize.c',
@@ -79,6 +84,9 @@ gdk_public_headers = files([
   'gdkdisplay.h',
   'gdkdisplaymanager.h',
   'gdkdrag.h',
+  'gdkdmabufformats.h',
+  'gdkdmabuftexture.h',
+  'gdkdmabuftexturebuilder.h',
   'gdkdragsurfacesize.h',
   'gdkdrawcontext.h',
   'gdkdrop.h',

gsk/gl/gskgldriver.c

@@ -399,7 +399,6 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
          g_steal_pointer (&program);                                                            \
   } G_STMT_END;
 # include "gskglprograms.defs"
-#undef GSK_GL_DEFINE_PROGRAM_CLIP
 #undef GSK_GL_DEFINE_PROGRAM
 #undef GSK_GL_ADD_UNIFORM
 #undef GSK_GL_SHADER_SINGLE
@@ -1004,9 +1003,9 @@ gsk_gl_driver_release_render_target (GskGLDriver       *self,
       texture_id = render_target->texture_id;
 
       texture = gsk_gl_texture_new (render_target->texture_id,
-                                     render_target->width,
-                                     render_target->height,
-                                     self->current_frame_id);
+                                    render_target->width,
+                                    render_target->height,
+                                    self->current_frame_id);
       g_hash_table_insert (self->textures,
                            GUINT_TO_POINTER (texture_id),
                            g_steal_pointer (&texture));

gsk/gl/stb_rect_pack.c

@@ -19,8 +19,10 @@
 
 #ifdef _MSC_VER
 #define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL       __cdecl
 #else
 #define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
 #endif
 
 enum
@@ -63,9 +65,6 @@ STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_ou
 STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
 {
    int i;
-#ifndef STBRP_LARGE_RECTS
-   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
-#endif
 
    for (i=0; i < num_nodes-1; ++i)
       nodes[i].next = &nodes[i+1];
@@ -84,11 +83,7 @@ STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height,
    context->extra[0].y = 0;
    context->extra[0].next = &context->extra[1];
    context->extra[1].x = (stbrp_coord) width;
-#ifdef STBRP_LARGE_RECTS
    context->extra[1].y = (1<<30);
-#else
-   context->extra[1].y = 65535;
-#endif
    context->extra[1].next = NULL;
 }
 
@@ -160,6 +155,13 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt
    width -= width % c->align;
    STBRP_ASSERT(width % c->align == 0);
 
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
    node = c->active_head;
    prev = &c->active_head;
    while (node->x + width <= c->width) {
@@ -223,7 +225,7 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt
          }
          STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
          y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
-         if (y + height < c->height) {
+         if (y + height <= c->height) {
             if (y <= best_y) {
                if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
                   best_x = xpos;
@@ -323,7 +325,7 @@ static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, i
    return res;
 }
 
-static int rect_height_compare(const void *a, const void *b)
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
 {
    const stbrp_rect *p = (const stbrp_rect *) a;
    const stbrp_rect *q = (const stbrp_rect *) b;
@@ -334,19 +336,13 @@ static int rect_height_compare(const void *a, const void *b)
    return (p->w > q->w) ? -1 : (p->w < q->w);
 }
 
-static int rect_original_order(const void *a, const void *b)
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
 {
    const stbrp_rect *p = (const stbrp_rect *) a;
    const stbrp_rect *q = (const stbrp_rect *) b;
    return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
 }
 
-#ifdef STBRP_LARGE_RECTS
-#define STBRP__MAXVAL  0xffffffff
-#else
-#define STBRP__MAXVAL  0xffff
-#endif
-
 STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
 {
    int i, all_rects_packed = 1;

gsk/gl/stb_rect_pack.h

@@ -1,9 +1,15 @@
-// stb_rect_pack.h - v0.99 - public domain - rectangle packing
+// stb_rect_pack.h - v1.01 - public domain - rectangle packing
 // Sean Barrett 2014
 //
 // Useful for e.g. packing rectangular textures into an atlas.
 // Does not do rotation.
 //
+// Before #including,
+//
+//    #define STB_RECT_PACK_IMPLEMENTATION
+//
+// in the file that you want to have the implementation.
+//
 // Not necessarily the awesomest packing method, but better than
 // the totally naive one in stb_truetype (which is primarily what
 // this is meant to replace).
@@ -31,9 +37,12 @@
 //
 //  Bugfixes / warning fixes
 //    Jeremy Jaussaud
+//    Fabian Giesen
 //
 // Version history:
 //
+//     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
 //     0.99  (2019-02-07)  warning fixes
 //     0.11  (2017-03-03)  return packing success/fail result
 //     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
@@ -72,11 +81,10 @@ typedef struct stbrp_context stbrp_context;
 typedef struct stbrp_node    stbrp_node;
 typedef struct stbrp_rect    stbrp_rect;
 
-#ifdef STBRP_LARGE_RECTS
 typedef int            stbrp_coord;
-#else
-typedef unsigned short stbrp_coord;
-#endif
+
+#define STBRP__MAXVAL  0x7fffffff
+// Mostly for internal use, but this is the maximum supported coordinate value.
 
 STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
 // Assign packed locations to rectangles. The rectangles are of type

gtk/a11y/gtkatspicontext.c

@@ -715,7 +715,7 @@ emit_text_changed (GtkAtSpiContext *self,
                                  "TextChanged",
                                  g_variant_new ("(siiva{sv})",
                                                 kind, start, end,
-                                                g_variant_new_take_string (g_strndup (text, end)),
+                                                g_variant_new_string (text),
                                                 NULL),
                                  NULL);
 }

gtk/a11y/gtkatspitext.c

@@ -1614,7 +1614,10 @@ insert_text_cb (GtkEditable *editable,
     return;
 
   length = g_utf8_strlen (new_text, new_text_length);
-  changed->text_changed (changed->data, "insert", *position - length, length, new_text);
+
+  char *inserted_text = g_utf8_substring (new_text, 0, length);
+  changed->text_changed (changed->data, "insert", *position - length, length, inserted_text);
+  g_free (inserted_text);
 }
 
 static void
@@ -1629,6 +1632,10 @@ delete_text_cb (GtkEditable *editable,
     return;
 
   text = gtk_editable_get_chars (editable, start, end);
+
+  if (end < 0)
+    end = g_utf8_strlen(text, -1);
+
   changed->text_changed (changed->data, "delete", start, end - start, text);
   g_free (text);
 }
@@ -1707,7 +1714,9 @@ insert_range_cb (GtkTextBuffer *buffer,
   position = gtk_text_iter_get_offset (iter);
   length = g_utf8_strlen (text, len);
 
-  changed->text_changed (changed->data, "insert", position - length, length, text);
+  char *inserted_text = g_utf8_substring (text, 0, length);
+  changed->text_changed (changed->data, "insert", position - length, length, inserted_text);
+  g_free (inserted_text);
 
   update_cursor (buffer, changed);
 }

gtk/gtkaccessiblerange.c

@@ -46,7 +46,7 @@ static gboolean
 gtk_accessible_range_default_set_current_value (GtkAccessibleRange *accessible_range,
                                                 double              value)
 {
-  return FALSE;
+  return TRUE;
 }
 
 static void

gtk/gtkcolordialogbutton.c

@@ -511,7 +511,7 @@ gtk_color_dialog_button_set_dialog (GtkColorDialogButton *self,
  *
  * This function is what should be used to obtain
  * the color that was chosen by the user. To get
- * informed about changes, listen to "notify::color".
+ * informed about changes, listen to "notify::rgba".
  *
  * Returns: the color
  *

gtk/gtkfilechoosernativeportal.c

@@ -177,6 +177,7 @@ response_cb (GDBusConnection  *connection,
   self->custom_files = NULL;
   for (i = 0; uris[i]; i++)
     self->custom_files = g_slist_prepend (self->custom_files, g_file_new_for_uri (uris[i]));
+  self->custom_files = g_slist_reverse (self->custom_files);
 
   g_free (uris);
   g_variant_unref (response_data);

gtk/gtkfilechooserwidget.c

@@ -4772,7 +4772,7 @@ gtk_file_chooser_widget_add_filter (GtkFileChooser *chooser,
       return;
     }
 
-  g_object_ref_sink (filter);
+  g_object_ref (filter);
 
   g_list_store_append (impl->filters, filter);
   g_object_unref (filter);
@@ -6000,7 +6000,7 @@ set_current_filter (GtkFileChooserWidget *impl,
         g_object_unref (impl->current_filter);
       impl->current_filter = filter;
       if (impl->current_filter)
-        g_object_ref_sink (impl->current_filter);
+        g_object_ref (impl->current_filter);
 
       gtk_drop_down_set_selected (GTK_DROP_DOWN (impl->filter_combo), filter_index);
 

gtk/gtkwidget.c

@@ -6536,7 +6536,7 @@ gtk_widget_update_default_pango_context (GtkWidget *widget)
     return;
 
   if (gtk_widget_update_pango_context (widget, context, _gtk_widget_get_direction (widget)))
-    gtk_widget_queue_draw (widget);
+    gtk_widget_queue_resize (widget);
 }
 
 /**

gtk/meson.build

@@ -860,16 +860,22 @@ foreach lang : [
     'da',
     'fr',
     'es',
+    'et',
+    'fi',
+    'hi',
     'hu',
     'it',
+    'ja',
     'ko',
     'lt',
     'ms',
+    'nb',
     'nl',
     'pl',
     'pt',
     'ru',
     'sv',
+    'th',
     'uk',
     'zh'
   ]

meson.build

@@ -162,6 +162,7 @@ check_headers = [
   'inttypes.h',
   'linux/input.h',
   'linux/memfd.h',
+  'linux/dma-buf.h',
   'locale.h',
   'memory.h',
   'stdint.h',
@@ -185,6 +186,10 @@ foreach h : check_headers
   endif
 endforeach
 
+if os_linux and not cc.has_header('linux/dma-buf.h')
+  error('OS is Linux, but linux/dma-buf.h not found.')
+endif
+
 # Maths functions might be implemented in libm
 libm = cc.find_library('m', required: false)
 

po/tr.po

@@ -22,16 +22,16 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gtk\n"
 "Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/gtk/-/issues/\n"
-"POT-Creation-Date: 2023-09-19 12:32+0000\n"
-"PO-Revision-Date: 2023-09-19 18:25+0300\n"
-"Last-Translator: Sabri Ünal <libreajans@gmail.com>\n"
+"POT-Creation-Date: 2023-10-13 09:55+0000\n"
+"PO-Revision-Date: 2023-10-14 08:00+0300\n"
+"Last-Translator: Emin Tufan Çetin <etcetin@gmail.com>\n"
 "Language-Team: Türkçe <takim@gnome.org.tr>\n"
 "Language: tr\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=1; plural=0;\n"
-"X-Generator: Poedit 3.2.2\n"
+"X-Generator: Poedit 3.4\n"
 
 #: gdk/broadway/gdkbroadway-server.c:135
 #, c-format
@@ -61,58 +61,58 @@ msgstr "İçerikler “%s” olarak sağlanamıyor"
 msgid "Cannot provide contents as %s"
 msgstr "İçerikler %s olarak sağlanamıyor"
 
-#: gdk/gdkdisplay.c:156 gdk/gdkglcontext.c:442
+#: gdk/gdkdisplay.c:163 gdk/gdkglcontext.c:442
 msgid "The current backend does not support OpenGL"
 msgstr "Şimdiki arka uç OpenGL’i desteklemiyor"
 
-#: gdk/gdkdisplay.c:1244 gdk/gdksurface.c:1252
+#: gdk/gdkdisplay.c:1258 gdk/gdksurface.c:1252
 msgid "Vulkan support disabled via GDK_DEBUG"
 msgstr "Vulkan desteği GDK_DEBUG yoluyla devre dışı bırakılmış"
 
-#: gdk/gdkdisplay.c:1276
+#: gdk/gdkdisplay.c:1290
 msgid "GL support disabled via GDK_DEBUG"
 msgstr "GL desteği, GDK_DEBUG yoluyla devre dışı bırakılmış"
 
-#: gdk/gdkdisplay.c:1574
+#: gdk/gdkdisplay.c:1588
 msgid "No EGL configuration available"
 msgstr "Kullanılabilir EGL yapılandırması yok"
 
-#: gdk/gdkdisplay.c:1582
+#: gdk/gdkdisplay.c:1596
 msgid "Failed to get EGL configurations"
 msgstr "EGL yapılandırmaları alınamadı"
 
-#: gdk/gdkdisplay.c:1612
+#: gdk/gdkdisplay.c:1626
 msgid "No EGL configuration with required features found"
 msgstr "Gerekli özellikleri olan EGL yapılandırması bulunamadı"
 
-#: gdk/gdkdisplay.c:1619
+#: gdk/gdkdisplay.c:1633
 msgid "No perfect EGL configuration found"
 msgstr "Kusursuz EGL yapılandırması bulunamadı"
 
-#: gdk/gdkdisplay.c:1661
+#: gdk/gdkdisplay.c:1675
 #, c-format
 msgid "EGL implementation is missing extension %s"
 msgid_plural "EGL implementation is missing %2$d extensions: %1$s"
 msgstr[0] "EGL uygulamasında %2$d eksik uzantı: %1$s"
 
 # https://twitter.com/mserdark/status/932936929213079559
-#: gdk/gdkdisplay.c:1694
+#: gdk/gdkdisplay.c:1708
 msgid "libEGL not available in this sandbox"
 msgstr "libEGL bu kum havuzunda kullanılamıyor"
 
-#: gdk/gdkdisplay.c:1695
+#: gdk/gdkdisplay.c:1709
 msgid "libEGL not available"
 msgstr "libEGL kullanılamıyor"
 
-#: gdk/gdkdisplay.c:1705
+#: gdk/gdkdisplay.c:1719
 msgid "Failed to create EGL display"
 msgstr "EGL ekranı oluşturulamadı"
 
-#: gdk/gdkdisplay.c:1715
+#: gdk/gdkdisplay.c:1729
 msgid "Could not initialize EGL display"
 msgstr "EGL ekranı ilklendirilemedi"
 
-#: gdk/gdkdisplay.c:1726
+#: gdk/gdkdisplay.c:1740
 #, c-format
 msgid "EGL version %d.%d is too old. GTK requires %d.%d"
 msgstr "EGL sürümü %d.%d çok eski. GTK, %d.%d gerektiriyor"
@@ -147,12 +147,12 @@ msgstr "Uygulama %s APIsini desteklemiyor"
 
 #. translators: This is about OpenGL backend names, like
 #. * "Trying to use X11 GLX, but EGL is already in use"
-#: gdk/gdkglcontext.c:1864
+#: gdk/gdkglcontext.c:1914
 #, c-format
 msgid "Trying to use %s, but %s is already in use"
 msgstr "%s kullanılmaya çalışılıyor ancak şu anda %s kullanılıyor"
 
-#: gdk/gdktexture.c:528
+#: gdk/gdktexture.c:530
 msgid "Unknown image format."
 msgstr "Bilinmeyen resim biçimi."
 
@@ -1719,6 +1719,11 @@ msgctxt "accessibility"
 msgid "toggle button"
 msgstr "aç/kapat düğmesi"
 
+#: gtk/gtkaccessible.c:835
+msgctxt "accessibility"
+msgid "paragraph"
+msgstr "paragraf"
+
 #: gtk/gtkalertdialog.c:668 gtk/print/gtkcustompaperunixdialog.c:322
 #: gtk/gtkmessagedialog.c:166 gtk/ui/gtkassistant.ui:40
 msgid "_Close"
@@ -2204,11 +2209,11 @@ msgstr "Bu adda dosya zaten var"
 #: gtk/gtkmessagedialog.c:179 gtk/gtkmountoperation.c:608
 #: gtk/print/gtkpagesetupunixdialog.c:282 gtk/print/gtkprintbackend.c:638
 #: gtk/print/gtkprintunixdialog.c:682 gtk/print/gtkprintunixdialog.c:839
-#: gtk/gtkwindow.c:6242 gtk/ui/gtkappchooserdialog.ui:48
+#: gtk/gtkwindow.c:6243 gtk/ui/gtkappchooserdialog.ui:48
 #: gtk/ui/gtkassistant.ui:52 gtk/ui/gtkcolorchooserdialog.ui:36
 #: gtk/ui/gtkfontchooserdialog.ui:27
 msgid "_Cancel"
-msgstr "_İptal Et"
+msgstr "İ_ptal"
 
 #: gtk/gtkfilechoosernative.c:521 gtk/gtkfilechoosernative.c:594
 #: gtk/gtkfiledialog.c:815 gtk/gtkplacessidebar.c:3149
@@ -2728,7 +2733,7 @@ msgid "Play"
 msgstr "Oynat"
 
 #: gtk/gtkmessagedialog.c:162 gtk/gtkmessagedialog.c:180
-#: gtk/print/gtkprintbackend.c:639 gtk/gtkwindow.c:6243
+#: gtk/print/gtkprintbackend.c:639 gtk/gtkwindow.c:6244
 msgid "_OK"
 msgstr "_Tamam"
 
@@ -3144,7 +3149,7 @@ msgstr "Ba_ğlan"
 #. if it wasn't cancelled show a dialog
 #: gtk/gtkplacesview.c:1353
 msgid "Unable to unmount volume"
-msgstr "Birim ayrılamıyor"
+msgstr "Birim ayrılamadı"
 
 #. Allow to cancel the operation
 #: gtk/gtkplacesview.c:1445
@@ -3200,7 +3205,7 @@ msgstr "_Bağlan"
 
 #: gtk/gtkplacesview.c:1894
 msgid "Unable to get remote server location"
-msgstr "Uzak sunucu konumu alınamıyor"
+msgstr "Uzak sunucu konumu alınamadı"
 
 #: gtk/gtkplacesview.c:2038 gtk/gtkplacesview.c:2047
 msgid "Networks"
@@ -3326,8 +3331,8 @@ msgstr "En olası nedeni geçici dosyanın oluşturulamamasıdır."
 
 #. window
 #: gtk/print/gtkprintoperation-portal.c:264
-#: gtk/print/gtkprintoperation-portal.c:584
-#: gtk/print/gtkprintoperation-portal.c:653 gtk/print/gtkprintunixdialog.c:3008
+#: gtk/print/gtkprintoperation-portal.c:594
+#: gtk/print/gtkprintoperation-portal.c:663 gtk/print/gtkprintunixdialog.c:3008
 msgid "Print"
 msgstr "Yazdır"
 
@@ -3602,12 +3607,12 @@ msgstr "_Geri Al"
 msgid "_Redo"
 msgstr "_Yinele"
 
-#: gtk/gtkwindow.c:6231
+#: gtk/gtkwindow.c:6232
 #, c-format
 msgid "Do you want to use GTK Inspector?"
 msgstr "GTK Denetleyicisi kullanmak istiyor musunuz?"
 
-#: gtk/gtkwindow.c:6233
+#: gtk/gtkwindow.c:6234
 #, c-format
 msgid ""
 "GTK Inspector is an interactive debugger that lets you explore and modify "
@@ -3618,7 +3623,7 @@ msgstr ""
 "izin veren etkileşimli hata ayıklayıcıdır. Bunun kullanılması uygulamanın "
 "kesilmesine ya da çökmesine neden olabilir."
 
-#: gtk/gtkwindow.c:6238
+#: gtk/gtkwindow.c:6239
 msgid "Don’t show this message again"
 msgstr "Bu iletiyi yeniden gösterme"
 
@@ -7533,7 +7538,6 @@ msgstr "%d kübik"
 
 #: tools/gtk-path-tool-info.c:159
 #, c-format
-#| msgid "%d cubics"
 msgid "%d conics"
 msgstr "%d konik"
 
@@ -7843,7 +7847,6 @@ msgstr "%s. satırda hata: %s\n"
 
 #: tools/gtk-rendernode-tool-utils.c:69
 #, c-format
-#| msgid "Failed to open file %s : %s\n"
 msgid "Failed to load node file: %s\n"
 msgstr "Düğüm dosyası yüklenemedi: %s\n"
 

testsuite/gtk/defaultvalue.c

@@ -217,6 +217,10 @@ test_type (gconstpointer data)
 	  (strcmp (pspec->name, "default-display") == 0))
 	check = FALSE;
 
+      if (g_type_is_a (type, GDK_TYPE_DISPLAY) &&
+	  (strcmp (pspec->name, "dmabuf-formats") == 0))
+	check = FALSE;
+
       if (g_type_is_a (type, GDK_TYPE_MONITOR) &&
           (strcmp (pspec->name, "geometry") == 0))
         check = FALSE;