dmabuf: Some debugging infrastructure

Add some helpers to print dmabuf formats.

gdk/gdkdisplay.c

@@ -1866,12 +1866,12 @@ gdk_display_add_dmabuf_downloader (GdkDisplay                *display,
  * 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)
+void
+gdk_display_init_dmabuf (GdkDisplay *self)
 {
   GdkDmabufFormatsBuilder *builder;
 
-  if (display->dmabuf_formats != NULL)
+  if (self->dmabuf_formats != NULL)
     return;
 
   builder = gdk_dmabuf_formats_builder_new ();
@@ -1879,13 +1879,13 @@ init_dmabuf_formats (GdkDisplay *display)
 #ifdef HAVE_LINUX_DMA_BUF_H
   if (!GDK_DEBUG_CHECK (DMABUF_DISABLE))
     {
-      gdk_display_prepare_gl (display, NULL);
+      gdk_display_prepare_gl (self, NULL);
 
-      gdk_display_add_dmabuf_downloader (display, gdk_dmabuf_get_direct_downloader (), builder);
+      gdk_display_add_dmabuf_downloader (self, gdk_dmabuf_get_direct_downloader (), builder);
     }
 #endif
 
-  display->dmabuf_formats = gdk_dmabuf_formats_builder_free_to_formats (builder);
+  self->dmabuf_formats = gdk_dmabuf_formats_builder_free_to_formats (builder);
 } 
 
 /**
@@ -1904,7 +1904,7 @@ init_dmabuf_formats (GdkDisplay *display)
 GdkDmabufFormats *
 gdk_display_get_dmabuf_formats (GdkDisplay *display)
 {
-  init_dmabuf_formats (display);
+  gdk_display_init_dmabuf (display);
 
   return display->dmabuf_formats;
 }

gdk/gdkdisplayprivate.h

@@ -211,6 +211,8 @@ gulong              _gdk_display_get_next_serial      (GdkDisplay       *display
 void                _gdk_display_pause_events         (GdkDisplay       *display);
 void                _gdk_display_unpause_events       (GdkDisplay       *display);
 
+void                gdk_display_init_dmabuf           (GdkDisplay       *self);
+
 GdkVulkanContext *  gdk_display_create_vulkan_context (GdkDisplay       *self,
                                                        GError          **error);
 

gdk/gdkdmabuf.c

@@ -32,23 +32,227 @@
 #include <epoxy/egl.h>
 
 typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
+
 struct _GdkDrmFormatInfo
 {
   guint32 fourcc;
   GdkMemoryFormat premultiplied_memory_format;
   GdkMemoryFormat unpremultiplied_memory_format;
+  void (* download) (guchar          *dst_data,
+                     gsize            dst_stride,
+                     GdkMemoryFormat  dst_format,
+                     gsize            width,
+                     gsize            height,
+                     const GdkDmabuf *dmabuf,
+                     const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+                     gsize            sizes[GDK_DMABUF_MAX_PLANES]);
 };
 
-static 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 void
+download_memcpy (guchar          *dst_data,
+                 gsize            dst_stride,
+                 GdkMemoryFormat  dst_format,
+                 gsize            width,
+                 gsize            height,
+                 const GdkDmabuf *dmabuf,
+                 const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+                 gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *src_data;
+  gsize src_stride;
+  guint bpp;
+
+  bpp = gdk_memory_format_bytes_per_pixel (dst_format);
+  src_stride = dmabuf->planes[0].stride;
+  src_data = src_datas[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + (height - 1) * dst_stride + width * bpp);
+
+  if (dst_stride == src_stride)
+    memcpy (dst_data, src_data, (height - 1) * dst_stride + width * bpp);
+  else
+    {
+      gsize i;
+
+      for (i = 0; i < height; i++)
+        memcpy (dst_data + i * dst_stride, src_data + i * src_stride, width * bpp);
+    }
+}
+
+typedef struct _YUVCoefficients YUVCoefficients;
+
+struct _YUVCoefficients
+{
+  int v_to_r;
+  int u_to_g;
+  int v_to_g;
+  int u_to_b;
 };
 
-static GdkDrmFormatInfo *
+/* multiplied by 65536 */
+//static const YUVCoefficients itu601_narrow = { 104597, -25675, -53279, 132201 };
+static const YUVCoefficients itu601_wide = { 74711, -25864, -38050, 133176 };
+
+static inline void
+get_uv_values (const YUVCoefficients *coeffs,
+               guint8                 u,
+               guint8                 v,
+               int                   *out_r,
+               int                   *out_g,
+               int                   *out_b)
+{
+  int u2 = (int) u - 127;
+  int v2 = (int) v - 127;
+  *out_r = coeffs->v_to_r * v2;
+  *out_g = coeffs->u_to_g * u2 + coeffs->v_to_g * v2;
+  *out_b = coeffs->u_to_b * u2;
+}
+
+static inline void
+set_rgb_values (guint8 rgb[3],
+                guint8 y,
+                int    r,
+                int    g,
+                int    b)
+{
+  int y2 = y * 65536;
+
+  rgb[0] = CLAMP ((y2 + r) >> 16, 0, 255);
+  rgb[1] = CLAMP ((y2 + g) >> 16, 0, 255);
+  rgb[2] = CLAMP ((y2 + b) >> 16, 0, 255);
+}
+
+static void
+download_nv12 (guchar          *dst_data,
+               gsize            dst_stride,
+               GdkMemoryFormat  dst_format,
+               gsize            width,
+               gsize            height,
+               const GdkDmabuf *dmabuf,
+               const guchar    *src_data[GDK_DMABUF_MAX_PLANES],
+               gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *y_data, *uv_data;
+  gsize x, y, y_stride, uv_stride;
+  gsize U, V;
+
+  if (dmabuf->fourcc == DRM_FORMAT_NV21)
+    {
+      U = 1; V = 0;
+    }
+  else
+    {
+      U = 0; V = 1;
+    }
+
+  y_stride = dmabuf->planes[0].stride;
+  y_data = src_data[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * y_stride);
+  uv_stride = dmabuf->planes[1].stride;
+  uv_data = src_data[1] + dmabuf->planes[1].offset;
+  g_return_if_fail (sizes[1] >= dmabuf->planes[1].offset + (height + 1) / 2 * uv_stride);
+
+  for (y = 0; y < height; y += 2)
+    {
+      guchar *dst2_data = dst_data + dst_stride;
+      const guchar *y2_data = y_data + y_stride;
+
+      for (x = 0; x < width; x += 2)
+        {
+          int r, g, b;
+
+          get_uv_values (&itu601_wide, uv_data[x + U], uv_data[x + V], &r, &g, &b);
+
+          set_rgb_values (&dst_data[3 * x], y_data[x], r, g, b);
+          if (x + 1 < width)
+            set_rgb_values (&dst_data[3 * (x + 1)], y_data[x], r, g, b);
+          if (y + 1 < height)
+            {
+              set_rgb_values (&dst2_data[3 * x], y2_data[x], r, g, b);
+              if (x + 1 < width)
+                set_rgb_values (&dst2_data[3 * (x + 1)], y2_data[x], r, g, b);
+            }
+        }
+      dst_data += 2 * dst_stride;
+      y_data += 2 * y_stride;
+      uv_data += uv_stride;
+    }
+}
+
+static void
+download_yuyv (guchar          *dst_data,
+               gsize            dst_stride,
+               GdkMemoryFormat  dst_format,
+               gsize            width,
+               gsize            height,
+               const GdkDmabuf *dmabuf,
+               const guchar    *src_datas[GDK_DMABUF_MAX_PLANES],
+               gsize            sizes[GDK_DMABUF_MAX_PLANES])
+{
+  const guchar *src_data;
+  gsize x, y, src_stride;
+  gsize Y1, Y2, U, V;
+
+  switch (dmabuf->fourcc)
+    {
+    case DRM_FORMAT_YUYV:
+      Y1 = 0; U = 1; Y2 = 2; V = 3;
+      break;
+    case DRM_FORMAT_YVYU:
+      Y1 = 0; V = 1; Y2 = 2; U = 3;
+      break;
+    case DRM_FORMAT_UYVY:
+      U = 0; Y1 = 1; V = 2; Y2 = 3;
+      break;
+    case DRM_FORMAT_VYUY:
+      V = 0; Y1 = 1; U = 2; Y2 = 3;
+      break;
+    default:
+      g_assert_not_reached ();
+      return;
+    }
+
+  src_stride = dmabuf->planes[0].stride;
+  src_data = src_datas[0] + dmabuf->planes[0].offset;
+  g_return_if_fail (sizes[0] >= dmabuf->planes[0].offset + height * src_stride);
+
+  for (y = 0; y < height; y ++)
+    {
+      for (x = 0; x < width; x += 2)
+        {
+          int r, g, b;
+
+          get_uv_values (&itu601_wide, src_data[2 * x + U], src_data[2 * x + V], &r, &g, &b);
+          set_rgb_values (&dst_data[3 * x], src_data[2 * x + Y1], r, g, b);
+          if (x + 1 < width)
+            set_rgb_values (&dst_data[3 * (x + 1)], src_data[2 * x + Y2], r, g, b);
+        }
+      dst_data += dst_stride;
+      src_data += src_stride;
+    }
+}
+
+static const GdkDrmFormatInfo supported_formats[] = {
+  { DRM_FORMAT_BGRA8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, GDK_MEMORY_A8R8G8B8, download_memcpy },
+  { DRM_FORMAT_ABGR8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, GDK_MEMORY_R8G8B8A8, download_memcpy },
+  { DRM_FORMAT_ARGB8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, GDK_MEMORY_B8G8R8A8, download_memcpy },
+  { DRM_FORMAT_RGBA8888, GDK_MEMORY_A8B8G8R8_PREMULTIPLIED, GDK_MEMORY_A8B8G8R8, download_memcpy },
+  { DRM_FORMAT_BGRX8888, GDK_MEMORY_X8R8G8B8, GDK_MEMORY_X8R8G8B8, download_memcpy },
+  { DRM_FORMAT_XBGR8888, GDK_MEMORY_R8G8B8X8, GDK_MEMORY_R8G8B8X8, download_memcpy },
+  { DRM_FORMAT_XRGB8888, GDK_MEMORY_B8G8R8X8, GDK_MEMORY_B8G8R8X8, download_memcpy },
+  { DRM_FORMAT_RGBX8888, GDK_MEMORY_X8B8G8R8, GDK_MEMORY_X8B8G8R8, download_memcpy },
+  { DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, GDK_MEMORY_R16G16B16A16_FLOAT, download_memcpy },
+  { DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_memcpy },
+  { DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, GDK_MEMORY_B8G8R8, download_memcpy },
+  /* YUV formats */
+  { DRM_FORMAT_NV12, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_NV21, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_nv12 },
+  { DRM_FORMAT_YUYV, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_YVYU, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_VYUY, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+  { DRM_FORMAT_UYVY, GDK_MEMORY_R8G8B8, GDK_MEMORY_R8G8B8, download_yuyv },
+};
+
+static const GdkDrmFormatInfo *
 get_drm_format_info (guint32 fourcc)
 {
   for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
@@ -83,7 +287,8 @@ gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader  *downloader,
                                        GdkMemoryFormat            *out_format,
                                        GError                    **error)
 {
-  GdkDrmFormatInfo *info;
+  const GdkDrmFormatInfo *info;
+  char buf[36];
 
   info = get_drm_format_info (dmabuf->fourcc);
 
@@ -91,8 +296,8 @@ gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader  *downloader,
     {
       g_set_error (error,
                    GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
-                   "Unsupported dmabuf format %.4s",
-                   (char *) &dmabuf->fourcc);
+                   "Unsupported dmabuf format %s",
+                   gdk_dmabuf_fourcc_print (buf, sizeof (buf), dmabuf->fourcc));
       return FALSE;
     }
 
@@ -100,16 +305,8 @@ gdk_dmabuf_direct_downloader_supports (const GdkDmabufDownloader  *downloader,
     {
       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");
+                   "Unsupported dmabuf modifier %s (only linear buffers are supported)",
+                   gdk_dmabuf_modifier_print (buf, sizeof (buf), dmabuf->modifier));
       return FALSE;
     }
 
@@ -124,39 +321,74 @@ gdk_dmabuf_direct_downloader_do_download (GdkTexture *texture,
                                           guchar     *data,
                                           gsize       stride)
 {
+  const GdkDrmFormatInfo *info;
   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");
+  const guchar *src_data[GDK_DMABUF_MAX_PLANES];
+  gsize sizes[GDK_DMABUF_MAX_PLANES];
+  gsize needs_unmap[GDK_DMABUF_MAX_PLANES] = { FALSE, };
+  gsize i, j;
+  gchar buf[64];
 
   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));
+  info = get_drm_format_info (dmabuf->fourcc);
 
-  src_stride = dmabuf->planes[0].stride;
-  size = dmabuf->planes[0].stride * height;
+  GDK_DEBUG (DMABUF,
+             "Using mmap() and memcpy() for downloading a dmabuf (format %s)",
+             gdk_dmabuf_format_print (buf, sizeof (buf), dmabuf->fourcc, dmabuf->modifier));
 
-  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 (i = 0; i < dmabuf->n_planes; i++)
     {
-      for (unsigned int i = 0; i < height; i++)
-        memcpy (data + i * stride, src_data + i * src_stride, height * bpp);
+      for (j = 0; j < i; j++)
+        {
+          if (dmabuf->planes[i].fd == dmabuf->planes[j].fd)
+            break;
+        }
+      if (j < i)
+        {
+          src_data[i] = src_data[j];
+          sizes[i] = sizes[j];
+          continue;
+        }
+
+      sizes[i] = lseek (dmabuf->planes[i].fd, 0, SEEK_END);
+      if (sizes[i] == (off_t) -1)
+        {
+          g_warning ("Failed to seek dmabuf: %s", g_strerror (errno));
+          goto out;
+        }
+
+      if (ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_START|DMA_BUF_SYNC_READ }) < 0)
+        g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
+
+      src_data[i] = mmap (NULL, sizes[i], PROT_READ, MAP_SHARED, dmabuf->planes[i].fd, dmabuf->planes[i].offset);
+      if (src_data[i] == NULL)
+        {
+          g_warning ("Failed to mmap dmabuf: %s", g_strerror (errno));
+          goto out;
+        }
+      needs_unmap[i] = TRUE;
     }
 
-  munmap (src_data, size);
+    info->download (data,
+                    stride,
+                    gdk_texture_get_format (texture),
+                    gdk_texture_get_width (texture),
+                    gdk_texture_get_height (texture),
+                    dmabuf,
+                    src_data,
+                    sizes);
 
-  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));
+out:
+  for (i = 0; i < dmabuf->n_planes; i++)
+    {
+      if (!needs_unmap[i])
+        continue;
+
+      munmap ((void *)src_data[i], sizes[i]);
+
+      if (ioctl (dmabuf->planes[i].fd, DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_END|DMA_BUF_SYNC_READ }) < 0)
+        g_warning ("Failed to sync dmabuf: %s", g_strerror (errno));
+    }
 }
 
 static void
@@ -172,16 +404,14 @@ gdk_dmabuf_direct_downloader_download (const GdkDmabufDownloader *downloader,
     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_stride = width * gdk_memory_format_bytes_per_pixel (src_format);
       src_data = g_new (guchar, src_stride * height);
 
       gdk_dmabuf_direct_downloader_do_download (texture, src_data, src_stride);
@@ -198,6 +428,7 @@ const GdkDmabufDownloader *
 gdk_dmabuf_get_direct_downloader (void)
 {
   static const GdkDmabufDownloader downloader = {
+    "mmap",
     gdk_dmabuf_direct_downloader_add_formats,
     gdk_dmabuf_direct_downloader_supports,
     gdk_dmabuf_direct_downloader_download,
@@ -206,4 +437,166 @@ gdk_dmabuf_get_direct_downloader (void)
   return &downloader;
 }
 
+/* 
+ * Tries to sanitize the dmabuf to conform to the values expected
+ * by Vulkan/EGL which should also be the values expected by
+ * Wayland compositors
+ *
+ * We put these sanitized values into the GdkDmabufTexture, by
+ * sanitizing the input from GdkDmabufTextureBuilder, which are
+ * controlled by the callers.
+ *
+ * Things we do here:
+ * 
+ * 1. Disallow any dmabuf format that we do not know.
+ *
+ * 1. Treat the INVALID modifier the same as LINEAR.
+ *
+ * 2. Ignore all other modifiers.
+ *
+ * 3. Try and fix various inconsistencies between V4L and Mesa,
+ *    like NV12.
+ *
+ * *** WARNING ***
+ *
+ * This function is not absolutely perfect, you do not have a
+ * perfect dmabuf afterwards.
+ *
+ * In particular, it doesn't check sizes.
+ *
+ * *** WARNING ***
+ */
+gboolean
+gdk_dmabuf_sanitize (GdkDmabuf        *dest,
+                     gsize             width,
+                     gsize             height,
+                     const GdkDmabuf  *src,
+                     GError          **error)
+{
+  const GdkDrmFormatInfo *info;
+
+  if (src->n_planes > GDK_DMABUF_MAX_PLANES)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "GTK only support dmabufs with %u planes, not %u",
+                   GDK_DMABUF_MAX_PLANES, src->n_planes);
+      return FALSE;
+    }
+
+  info = get_drm_format_info (src->fourcc);
+
+  if (info == NULL)
+    {
+      g_set_error (error,
+                   GDK_DMABUF_ERROR, GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
+                   "Unsupported dmabuf format %.4s",
+                   (char *) &src->fourcc);
+      return FALSE;
+    }
+
+  *dest = *src;
+
+  if (src->modifier && src->modifier != DRM_FORMAT_MOD_INVALID)
+    return TRUE;
+
+  switch (dest->fourcc)
+    {
+      case DRM_FORMAT_NV12:
+        if (dest->n_planes == 1)
+          {
+            dest->n_planes = 2;
+            dest->planes[1].fd = dest->planes[0].fd;
+            dest->planes[1].stride = dest->planes[0].stride;
+            dest->planes[1].offset = dest->planes[0].offset + dest->planes[0].stride * height;
+          }
+        break;
+
+      default:
+        break;
+    }
+
+  return TRUE;
+}
+
+const char *
+gdk_dmabuf_fourcc_print (char    *buf,
+                         gsize    size,
+                         guint32  fourcc)
+{
+  snprintf (buf, size, "%.4s", (char *)&fourcc);
+  return buf;
+}
+
+static const char *
+get_modifier_name (char    *buf,
+                   gsize    size,
+                   guint64  modifier)
+{
+  static struct {
+    guchar id;
+    const char *name;
+  } vendors[] = {
+    { DRM_FORMAT_MOD_VENDOR_NONE, "NONE" },
+    { DRM_FORMAT_MOD_VENDOR_INTEL, "Intel" },
+    { DRM_FORMAT_MOD_VENDOR_AMD, "AMD" },
+    { DRM_FORMAT_MOD_VENDOR_NVIDIA, "NVidia" },
+    { DRM_FORMAT_MOD_VENDOR_SAMSUNG, "Samsung" },
+    { DRM_FORMAT_MOD_VENDOR_QCOM, "Qualcomm" },
+    { DRM_FORMAT_MOD_VENDOR_VIVANTE, "Vivante" },
+    { DRM_FORMAT_MOD_VENDOR_BROADCOM, "Broadcom" },
+    { DRM_FORMAT_MOD_VENDOR_ARM, "Arm" },
+    { DRM_FORMAT_MOD_VENDOR_ALLWINNER, "Allwinner" },
+    { DRM_FORMAT_MOD_VENDOR_AMLOGIC, "Amlogic" },
+  };
+
+  if (modifier == DRM_FORMAT_MOD_INVALID)
+    return "INVALID";
+  else if (modifier == DRM_FORMAT_MOD_LINEAR)
+    return "LINEAR";
+
+  for (int i = 0; i < G_N_ELEMENTS (vendors); i++)
+    {
+      if (vendors[i].id == fourcc_mod_get_vendor (modifier))
+        {
+          snprintf (buf, size, "%s,%" G_GINT64_MODIFIER "u", vendors[i].name, modifier & 0x00ffffffffffffffUL);
+
+          return buf;
+        }
+    }
+
+  snprintf (buf, size, "%#" G_GINT64_MODIFIER "x", modifier);
+
+  return buf;
+}
+
+const char *
+gdk_dmabuf_modifier_print (char    *buf,
+                           gsize    size,
+                           guint64  modifier)
+{
+  char buf2[64];
+
+  snprintf (buf, size, "%s", get_modifier_name (buf2, sizeof (buf2), modifier));
+
+  return buf;
+}
+
+const char *
+gdk_dmabuf_format_print (char    *buf,
+                         gsize    size,
+                         guint32  fourcc,
+                         guint64  modifier)
+{
+  gsize len;
+  char buf2[64];
+
+  gdk_dmabuf_fourcc_print (buf, size, fourcc);
+  len = strlen (buf);
+
+  snprintf (buf + len, size - len, ":%s", get_modifier_name (buf2, sizeof (buf2), modifier));
+
+  return buf;
+}
+
 #endif  /* HAVE_LINUX_DMA_BUF_H */

gdk/gdkdmabufprivate.h

@@ -21,6 +21,7 @@ struct _GdkDmabuf
 
 struct _GdkDmabufDownloader
 {
+  const char *name;
   void                  (* add_formats)                         (const GdkDmabufDownloader      *downloader,
                                                                  GdkDisplay                     *display,
                                                                  GdkDmabufFormatsBuilder        *builder);
@@ -41,4 +42,22 @@ struct _GdkDmabufDownloader
 #ifdef HAVE_LINUX_DMA_BUF_H
 const GdkDmabufDownloader *
                         gdk_dmabuf_get_direct_downloader        (void) G_GNUC_CONST;
+
+gboolean                gdk_dmabuf_sanitize                     (GdkDmabuf                      *dest,
+                                                                 gsize                           width,
+                                                                 gsize                           height,
+                                                                 const GdkDmabuf                *src,
+                                                                 GError                        **error);
+
+const char *            gdk_dmabuf_fourcc_print   (char    *str,
+                                                   gsize    size,
+                                                   guint32  fourcc);
+const char *            gdk_dmabuf_modifier_print (char    *str,
+                                                   gsize    size,
+                                                   guint64  modifier);
+const char *            gdk_dmabuf_format_print   (char    *str,
+                                                   gsize    size,
+                                                   guint32  fourcc,
+                                                   guint64  modifier);
+
 #endif

gdk/gdkdmabuftexture.c

@@ -22,6 +22,7 @@
 
 #include "gdkdisplayprivate.h"
 #include "gdkdmabufformatsbuilderprivate.h"
+#include "gdkdmabufprivate.h"
 #include "gdktextureprivate.h"
 #include <gdk/gdkglcontext.h>
 #include <gdk/gdkgltexturebuilder.h>
@@ -132,13 +133,24 @@ gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
   GdkDmabufTexture *self;
   GdkTexture *update_texture;
   GdkDisplay *display;
-  const GdkDmabuf *dmabuf;
+  GdkDmabuf dmabuf;
   GdkMemoryFormat format;
   GError *local_error = NULL;
+  int width, height;
   gsize i;
 
   display = gdk_dmabuf_texture_builder_get_display (builder);
-  dmabuf = gdk_dmabuf_texture_builder_get_dmabuf (builder);
+  width = gdk_dmabuf_texture_builder_get_width (builder);
+  height = gdk_dmabuf_texture_builder_get_height (builder);
+
+  if (!gdk_dmabuf_sanitize (&dmabuf,
+                            width,
+                            height,
+                            gdk_dmabuf_texture_builder_get_dmabuf (builder),
+                            error))
+    return NULL;
+
+  gdk_display_init_dmabuf (display);
 
   for (i = 0; display->dmabuf_downloaders[i] != NULL; i++)
     {
@@ -147,7 +159,7 @@ gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
 
       if (display->dmabuf_downloaders[i]->supports (display->dmabuf_downloaders[i],
                                                     display,
-                                                    dmabuf,
+                                                    &dmabuf,
                                                     gdk_dmabuf_texture_builder_get_premultiplied (builder),
                                                     &format,
                                                     local_error ? NULL : &local_error))
@@ -160,15 +172,23 @@ gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
       return NULL;
     }
 
+  GDK_DEBUG (DMABUF,
+             "Dmabuf texture, format %.4s:%#lx, %s%u planes, memory format %u, downloader %s",
+             (char *) &dmabuf.fourcc, dmabuf.modifier,
+             gdk_dmabuf_texture_builder_get_premultiplied (builder) ? " premultiplied, " : "",
+             dmabuf.n_planes,
+             format,
+             display->dmabuf_downloaders[i]->name);
+
   self = g_object_new (GDK_TYPE_DMABUF_TEXTURE,
-                       "width", gdk_dmabuf_texture_builder_get_width (builder),
-                       "height", gdk_dmabuf_texture_builder_get_height (builder),
+                       "width", width,
+                       "height", height,
                        NULL);
 
   GDK_TEXTURE (self)->format = format;
   g_set_object (&self->display, display);
   self->downloader = display->dmabuf_downloaders[i];
-  self->dmabuf = *dmabuf;
+  self->dmabuf = dmabuf;
   self->destroy = destroy;
   self->data = data;
 

gdk/gdkdmabuftexturebuilder.c

@@ -331,7 +331,7 @@ gdk_dmabuf_texture_builder_class_init (GdkDmabufTextureBuilderClass *klass)
    */
   properties[PROP_N_PLANES] =
     g_param_spec_uint ("n-planes", NULL, NULL,
-                       0, 4, 0,
+                       1, GDK_DMABUF_MAX_PLANES, 1,
                        G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
   /**
@@ -365,6 +365,9 @@ static void
 gdk_dmabuf_texture_builder_init (GdkDmabufTextureBuilder *self)
 {
   self->premultiplied = TRUE;
+  self->display = gdk_display_get_default ();
+  self->dmabuf.n_planes = 1;
+
   for (int i = 0; i < GDK_DMABUF_MAX_PLANES; i++)
     self->dmabuf.planes[i].fd = -1;
 }
@@ -391,7 +394,7 @@ gdk_dmabuf_texture_builder_new (void)
  * Returns the display that this texture builder is
  * associated with.
  *
- * Returns: (transfer none) (nullable): the display
+ * Returns: (transfer none): the display
  *
  * Since: 4.14
  */
@@ -421,6 +424,7 @@ gdk_dmabuf_texture_builder_set_display (GdkDmabufTextureBuilder *self,
                                         GdkDisplay              *display)
 {
   g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (GDK_IS_DISPLAY (display));
 
   if (g_set_object (&self->display, display))
     g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DISPLAY]);
@@ -679,6 +683,7 @@ gdk_dmabuf_texture_builder_set_n_planes (GdkDmabufTextureBuilder *self,
                                          unsigned int             n_planes)
 {
   g_return_if_fail (GDK_IS_DMABUF_TEXTURE_BUILDER (self));
+  g_return_if_fail (n_planes > 0 && n_planes <= GDK_DMABUF_MAX_PLANES);
 
   if (self->dmabuf.n_planes == n_planes)
     return;
@@ -959,16 +964,17 @@ gdk_dmabuf_texture_builder_build (GdkDmabufTextureBuilder *self,
                                   gpointer                 data,
                                   GError                 **error)
 {
+  unsigned i;
+
   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);
+  for (i = 0; i < self->dmabuf.n_planes; i++)
+    g_return_val_if_fail (self->dmabuf.planes[i].fd != -1, NULL);
 
   if (GDK_DEBUG_CHECK (DMABUF_DISABLE))
     {

gdk/gdkdrop.c

@@ -684,7 +684,7 @@ gdk_drop_read_async (GdkDrop             *self,
  * gdk_drop_read_finish:
  * @self: a `GdkDrop`
  * @result: a `GAsyncResult`
- * @out_mime_type: (out) (type utf8): return location for the used mime type
+ * @out_mime_type: (out) (type utf8) (transfer none): return location for the used mime type
  * @error: (nullable): location to store error information on failure
  *
  * Finishes an async drop read operation.

gdk/gdkenums.h

@@ -298,10 +298,16 @@ typedef enum
  *   The color values are premultiplied with the alpha value.
  * @GDK_MEMORY_R8G8B8A8_PREMULTIPLIED: 4 bytes; for red, green, blue, alpha
  *   The color values are premultiplied with the alpha value.
+ * @GDK_MEMORY_A8B8G8R8_PREMULTIPLIED: 4 bytes; for alpha, blue, green, red,
+ *   The color values are premultiplied with the alpha value. Since 4.14
  * @GDK_MEMORY_B8G8R8A8: 4 bytes; for blue, green, red, alpha.
  * @GDK_MEMORY_A8R8G8B8: 4 bytes; for alpha, red, green, blue.
  * @GDK_MEMORY_R8G8B8A8: 4 bytes; for red, green, blue, alpha.
  * @GDK_MEMORY_A8B8G8R8: 4 bytes; for alpha, blue, green, red.
+ * @GDK_MEMORY_B8G8R8X8: 4 bytes; for blue, green, red, unused. Since 4.14
+ * @GDK_MEMORY_X8R8G8B8: 4 bytes; for unused, red, green, blue. Since 4.14
+ * @GDK_MEMORY_R8G8B8X8: 4 bytes; for red, green, blue, unused. Since 4.14
+ * @GDK_MEMORY_X8B8G8R8: 4 bytes; for unused, blue, green, red. Since 4.14
  * @GDK_MEMORY_R8G8B8: 3 bytes; for red, green, blue. The data is opaque.
  * @GDK_MEMORY_B8G8R8: 3 bytes; for blue, green, red. The data is opaque.
  * @GDK_MEMORY_R16G16B16: 3 guint16 values; for red, green, blue. Since: 4.6
@@ -382,6 +388,11 @@ typedef enum {
   GDK_MEMORY_A16 GDK_AVAILABLE_ENUMERATOR_IN_4_12,
   GDK_MEMORY_A16_FLOAT GDK_AVAILABLE_ENUMERATOR_IN_4_12,
   GDK_MEMORY_A32_FLOAT GDK_AVAILABLE_ENUMERATOR_IN_4_12,
+  GDK_MEMORY_A8B8G8R8_PREMULTIPLIED GDK_AVAILABLE_ENUMERATOR_IN_4_14,
+  GDK_MEMORY_B8G8R8X8 GDK_AVAILABLE_ENUMERATOR_IN_4_14,
+  GDK_MEMORY_X8R8G8B8 GDK_AVAILABLE_ENUMERATOR_IN_4_14,
+  GDK_MEMORY_R8G8B8X8 GDK_AVAILABLE_ENUMERATOR_IN_4_14,
+  GDK_MEMORY_X8B8G8R8 GDK_AVAILABLE_ENUMERATOR_IN_4_14,
 
   GDK_MEMORY_N_FORMATS
 } GdkMemoryFormat;

gdk/gdkglcontext.c

@@ -109,6 +109,7 @@ typedef struct {
   guint has_sync : 1;
   guint has_unpack_subimage : 1;
   guint has_debug_output : 1;
+  guint has_bgra : 1;
   guint extensions_checked : 1;
   guint debug_enabled : 1;
   guint forward_compatible : 1;
@@ -1531,11 +1532,13 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
       priv->has_unpack_subimage = gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)) ||
                                   epoxy_has_gl_extension ("GL_EXT_unpack_subimage");
       priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
+      priv->has_bgra = epoxy_has_gl_extension ("GL_EXT_texture_format_BGRA8888");
     }
   else
     {
       priv->has_unpack_subimage = TRUE;
       priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
+      priv->has_bgra = TRUE;
 
       /* We asked for a core profile, but we didn't get one, so we're in legacy mode */
       if (!gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
@@ -1567,7 +1570,8 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
                        " - GL_KHR_debug: %s\n"
                        " - GL_EXT_unpack_subimage: %s\n"
                        " - half float: %s\n"
-                       " - sync: %s",
+                       " - sync: %s\n"
+                       " - bgra: %s",
                        gdk_gl_context_get_use_es (context) ? "OpenGL ES" : "OpenGL",
                        gdk_gl_version_get_major (&priv->gl_version), gdk_gl_version_get_minor (&priv->gl_version),
                        priv->is_legacy ? "legacy" : "core",
@@ -1576,7 +1580,8 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
                        priv->has_khr_debug ? "yes" : "no",
                        priv->has_unpack_subimage ? "yes" : "no",
                        priv->has_half_float ? "yes" : "no",
-                       priv->has_sync ? "yes" : "no");
+                       priv->has_sync ? "yes" : "no",
+                       priv->has_bgra ? "yes" : "no");
   }
 #endif
 
@@ -1862,6 +1867,36 @@ gdk_gl_context_has_sync (GdkGLContext *self)
   return priv->has_sync;
 }
 
+/* Return if GL_BGRA works with glTexImage2D */
+gboolean
+gdk_gl_context_has_bgra (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  return priv->has_bgra;
+}
+
+/* Return if glGenVertexArrays, glBindVertexArray and glDeleteVertexArrays
+ * can be used
+ */
+gboolean
+gdk_gl_context_has_vertex_arrays (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  switch (priv->api)
+    {
+    case GDK_GL_API_GL:
+      return TRUE;
+
+    case GDK_GL_API_GLES:
+      return gdk_gl_version_get_major (&priv->gl_version) >= 3;
+
+    default:
+      g_return_val_if_reached (FALSE);
+    }
+}
+
 /* This is currently private! */
 /* When using GL/ES, don't flip the 'R' and 'B' bits on Windows/ANGLE for glReadPixels() */
 gboolean

gdk/gdkglcontextprivate.h

@@ -157,6 +157,10 @@ gboolean                gdk_gl_context_has_vertex_half_float    (GdkGLContext
 
 gboolean                gdk_gl_context_has_sync                 (GdkGLContext    *self) G_GNUC_PURE;
 
+gboolean                gdk_gl_context_has_bgra                 (GdkGLContext    *self) G_GNUC_PURE;
+
+gboolean                gdk_gl_context_has_vertex_arrays        (GdkGLContext    *self) G_GNUC_PURE;
+
 double                  gdk_gl_context_get_scale                (GdkGLContext    *self);
 
 G_END_DECLS

gdk/gdkgltexture.c

@@ -141,9 +141,7 @@ struct _Download
 };
 
 static gboolean
-gdk_gl_texture_find_format (gboolean         use_es,
-                            guint            gl_major,
-                            guint            gl_minor,
+gdk_gl_texture_find_format (GdkGLContext    *context,
                             GdkMemoryAlpha   alpha,
                             GLint            gl_format,
                             GLint            gl_type,
@@ -159,7 +157,7 @@ gdk_gl_texture_find_format (gboolean         use_es,
       if (gdk_memory_format_alpha (format) != alpha)
         continue;
 
-      if (!gdk_memory_format_gl_format (format, use_es, gl_major, gl_minor, &q_internal_format, &q_format, &q_type, q_swizzle))
+      if (!gdk_memory_format_gl_format (format, context, &q_internal_format, &q_format, &q_type, q_swizzle))
         continue;
 
       if (q_format != gl_format || q_type != gl_type)
@@ -183,16 +181,13 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
   Download *download = download_;
   GLenum gl_internal_format, gl_format, gl_type;
   GLint gl_swizzle[4];
-  int major, minor;
 
   format = gdk_texture_get_format (texture),
   expected_stride = texture->width * gdk_memory_format_bytes_per_pixel (download->format);
-  gdk_gl_context_get_version (context, &major, &minor);
 
   if (!gdk_gl_context_get_use_es (context) &&
       gdk_memory_format_gl_format (format,
-                                   FALSE,
-                                   major, minor,
+                                   context,
                                    &gl_internal_format,
                                    &gl_format, &gl_type, gl_swizzle))
     {
@@ -243,7 +238,7 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
         {
           glGetFramebufferParameteriv (GL_FRAMEBUFFER, GL_IMPLEMENTATION_COLOR_READ_FORMAT, &gl_read_format);
           glGetFramebufferParameteriv (GL_FRAMEBUFFER, GL_IMPLEMENTATION_COLOR_READ_TYPE, &gl_read_type);
-          if (!gdk_gl_texture_find_format (TRUE, major, minor, gdk_memory_format_alpha (format), gl_read_format, gl_read_type, &actual_format))
+          if (!gdk_gl_texture_find_format (context, gdk_memory_format_alpha (format), gl_read_format, gl_read_type, &actual_format))
             {
               gl_read_format = GL_RGBA;
               gl_read_type = GL_UNSIGNED_BYTE;

gdk/gdkmemoryformat.c

@@ -20,6 +20,7 @@
 #include "config.h"
 
 #include "gdkmemoryformatprivate.h"
+#include "gdkglcontextprivate.h"
 
 #include "gsk/gl/fp16private.h"
 
@@ -93,10 +94,17 @@ name ## _from_float (guchar      *dest_data, \
 TYPED_FUNCS (b8g8r8a8_premultiplied, guchar, 2, 1, 0, 3, 4, 255)
 TYPED_FUNCS (a8r8g8b8_premultiplied, guchar, 1, 2, 3, 0, 4, 255)
 TYPED_FUNCS (r8g8b8a8_premultiplied, guchar, 0, 1, 2, 3, 4, 255)
+TYPED_FUNCS (a8b8g8r8_premultiplied, guchar, 3, 2, 1, 0, 4, 255)
 TYPED_FUNCS (b8g8r8a8, guchar, 2, 1, 0, 3, 4, 255)
 TYPED_FUNCS (a8r8g8b8, guchar, 1, 2, 3, 0, 4, 255)
 TYPED_FUNCS (r8g8b8a8, guchar, 0, 1, 2, 3, 4, 255)
 TYPED_FUNCS (a8b8g8r8, guchar, 3, 2, 1, 0, 4, 255)
+
+TYPED_FUNCS (r8g8b8x8, guchar, 0, 1, 2, -1, 4, 255)
+TYPED_FUNCS (x8r8g8b8, guchar, 1, 2, 3, -1, 4, 255)
+TYPED_FUNCS (b8g8r8x8, guchar, 2, 1, 0, -1, 4, 255)
+TYPED_FUNCS (x8b8g8r8, guchar, 3, 2, 1, -1, 4, 255)
+
 TYPED_FUNCS (r8g8b8, guchar, 0, 1, 2, -1, 3, 255)
 TYPED_FUNCS (b8g8r8, guchar, 2, 1, 0, -1, 3, 255)
 TYPED_FUNCS (r16g16b16, guint16, 0, 1, 2, -1, 6, 65535)
@@ -352,7 +360,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     4,
     G_ALIGNOF (guchar),
     GDK_MEMORY_U8,
-    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { 0, 0, 0, 0 },
     { GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA } },
     b8g8r8a8_premultiplied_to_float,
     b8g8r8a8_premultiplied_from_float,
@@ -377,12 +385,22 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     r8g8b8a8_premultiplied_to_float,
     r8g8b8a8_premultiplied_from_float,
   },
+  [GDK_MEMORY_A8B8G8R8_PREMULTIPLIED] = {
+    GDK_MEMORY_ALPHA_PREMULTIPLIED,
+    4,
+    G_ALIGNOF (guchar),
+    GDK_MEMORY_U8,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { GL_RGBA8, GL_RGBA, GDK_GL_UNSIGNED_BYTE_FLIPPED, { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA } },
+    a8b8g8r8_premultiplied_to_float,
+    a8b8g8r8_premultiplied_from_float,
+  },
   [GDK_MEMORY_B8G8R8A8] = {
     GDK_MEMORY_ALPHA_STRAIGHT,
     4,
     G_ALIGNOF (guchar),
     GDK_MEMORY_U8,
-    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { 0, 0, 0, 0 },
     { GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA } },
     b8g8r8a8_to_float,
     b8g8r8a8_from_float,
@@ -417,6 +435,46 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     a8b8g8r8_to_float,
     a8b8g8r8_from_float,
   },
+  [GDK_MEMORY_B8G8R8X8] = {
+    GDK_MEMORY_ALPHA_OPAQUE,
+    4,
+    G_ALIGNOF (guchar),
+    GDK_MEMORY_U8,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, { GL_RED, GL_GREEN, GL_BLUE, GL_ONE } },
+    b8g8r8x8_to_float,
+    b8g8r8x8_from_float,
+  },
+  [GDK_MEMORY_X8R8G8B8] = {
+    GDK_MEMORY_ALPHA_OPAQUE,
+    4,
+    G_ALIGNOF (guchar),
+    GDK_MEMORY_U8,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { GL_RGBA8, GL_BGRA, GDK_GL_UNSIGNED_BYTE_FLIPPED, { GL_RED, GL_GREEN, GL_BLUE, GL_ONE } },
+    x8r8g8b8_to_float,
+    x8r8g8b8_from_float,
+  },
+  [GDK_MEMORY_R8G8B8X8] = {
+    GDK_MEMORY_ALPHA_OPAQUE,
+    4,
+    G_ALIGNOF (guchar),
+    GDK_MEMORY_U8,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
+    { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, { GL_RED, GL_GREEN, GL_BLUE, GL_ONE } },
+    r8g8b8x8_to_float,
+    r8g8b8x8_from_float,
+  },
+  [GDK_MEMORY_X8B8G8R8] = {
+    GDK_MEMORY_ALPHA_OPAQUE,
+    4,
+    G_ALIGNOF (guchar),
+    GDK_MEMORY_U8,
+    { G_MAXUINT, G_MAXUINT, G_MAXUINT, G_MAXUINT },
+    { GL_RGBA8, GL_RGBA, GDK_GL_UNSIGNED_BYTE_FLIPPED, { GL_RED, GL_GREEN, GL_BLUE, GL_ONE } },
+    x8b8g8r8_to_float,
+    x8b8g8r8_from_float,
+  },
   [GDK_MEMORY_R8G8B8] = {
     GDK_MEMORY_ALPHA_OPAQUE,
     3,
@@ -733,14 +791,19 @@ gdk_memory_depth_get_alpha_format (GdkMemoryDepth depth)
 
 gboolean
 gdk_memory_format_gl_format (GdkMemoryFormat  format,
-                             gboolean         gles,
-                             guint            gl_major,
-                             guint            gl_minor,
+                             GdkGLContext    *context,
                              guint           *out_internal_format,
                              guint           *out_format,
                              guint           *out_type,
                              GLint            out_swizzle[4])
 {
+  int gl_major;
+  int gl_minor;
+  gboolean gles;
+
+  gdk_gl_context_get_version (context, &gl_major, &gl_minor);
+  gles = gdk_gl_context_get_use_es (context);
+
   *out_internal_format = memory_formats[format].gl.internal_format;
   *out_format = memory_formats[format].gl.format;
   *out_type = memory_formats[format].gl.type;
@@ -752,6 +815,9 @@ gdk_memory_format_gl_format (GdkMemoryFormat  format,
           (memory_formats[format].min_gl_version.gles_major == gl_major &&
            memory_formats[format].min_gl_version.gles_minor > gl_minor))
         return FALSE;
+
+      if (*out_format == GL_BGRA && !gdk_gl_context_has_bgra (context))
+        return FALSE;
     }
   else
     {

gdk/gdkmemoryformatprivate.h

@@ -20,6 +20,7 @@
 #pragma once
 
 #include "gdkenums.h"
+#include "gdktypes.h"
 
 #include <epoxy/gl.h>
 
@@ -46,9 +47,7 @@ GdkMemoryDepth          gdk_memory_depth_merge              (GdkMemoryDepth
                                                              GdkMemoryDepth              depth2) G_GNUC_CONST;
 GdkMemoryFormat         gdk_memory_depth_get_alpha_format   (GdkMemoryDepth              depth) G_GNUC_CONST;
 gboolean                gdk_memory_format_gl_format         (GdkMemoryFormat             format,
-                                                             gboolean                    gles,
-                                                             guint                       gl_major,
-                                                             guint                       gl_minor,
+                                                             GdkGLContext               *context,
                                                              guint                      *out_internal_format,
                                                              guint                      *out_format,
                                                              guint                      *out_type,

gdk/gdkvulkancontext.c

@@ -1475,6 +1475,13 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
   gboolean validate = FALSE, have_debug_report = FALSE;
   VkResult res;
 
+  if (gdk_display_get_debug_flags (display) & GDK_DEBUG_VULKAN_DISABLE)
+    {
+      g_set_error_literal (error, GDK_VULKAN_ERROR, GDK_VULKAN_ERROR_NOT_AVAILABLE,
+                           _("Vulkan support disabled via GDK_DEBUG"));
+      return FALSE;
+    }
+
   if (GDK_DISPLAY_GET_CLASS (display)->vk_extension_name == NULL)
     {
       g_set_error (error, GDK_VULKAN_ERROR, GDK_VULKAN_ERROR_UNSUPPORTED,

gdk/loaders/gdkpng.c

@@ -329,6 +329,7 @@ gdk_save_png (GdkTexture *texture)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
@@ -340,6 +341,10 @@ gdk_save_png (GdkTexture *texture)
 
     case GDK_MEMORY_R8G8B8:
     case GDK_MEMORY_B8G8R8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8B8G8R8:
       format = GDK_MEMORY_R8G8B8;
       png_format = PNG_COLOR_TYPE_RGB;
       depth = 8;

gdk/loaders/gdktiff.c

@@ -236,12 +236,17 @@ static const FormatData format_data[] = {
   [GDK_MEMORY_B8G8R8A8_PREMULTIPLIED]           = { GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,            8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_A8R8G8B8_PREMULTIPLIED]           = { GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,            8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_R8G8B8A8_PREMULTIPLIED]           = { GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,            8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA, PHOTOMETRIC_RGB },
+  [GDK_MEMORY_A8B8G8R8_PREMULTIPLIED]           = { GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,            8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_B8G8R8A8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_A8R8G8B8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_R8G8B8A8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_A8B8G8R8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_R8G8B8]                           = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
   [GDK_MEMORY_B8G8R8]                           = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
+  [GDK_MEMORY_R8G8B8X8]                         = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
+  [GDK_MEMORY_X8R8G8B8]                         = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
+  [GDK_MEMORY_B8G8R8X8]                         = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
+  [GDK_MEMORY_X8B8G8R8]                         = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
   [GDK_MEMORY_R16G16B16]                        = { GDK_MEMORY_R16G16B16,                        16, 3, SAMPLEFORMAT_UINT,   0,                      PHOTOMETRIC_RGB },
   [GDK_MEMORY_R16G16B16A16_PREMULTIPLIED]       = { GDK_MEMORY_R16G16B16A16_PREMULTIPLIED,       16, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA, PHOTOMETRIC_RGB },
   [GDK_MEMORY_R16G16B16A16]                     = { GDK_MEMORY_R16G16B16A16,                     16, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA, PHOTOMETRIC_RGB },

gsk/gl/gskglcommandqueue.c

@@ -1070,7 +1070,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
   glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
   glBlendEquation (GL_FUNC_ADD);
 
-  if (!gdk_gl_context_get_use_es (self->context))
+  if (gdk_gl_context_has_vertex_arrays (self->context))
     {
       glGenVertexArrays (1, &vao_id);
       glBindVertexArray (vao_id);
@@ -1257,7 +1257,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
     }
 
   glDeleteBuffers (1, &vbo_id);
-  if (!gdk_gl_context_get_use_es (self->context))
+  if (gdk_gl_context_has_vertex_arrays (self->context))
     glDeleteVertexArrays (1, &vao_id);
 
   gdk_profiler_set_int_counter (self->metrics.n_binds, n_binds);
@@ -1450,9 +1450,7 @@ gsk_gl_command_queue_create_framebuffer (GskGLCommandQueue *self)
 
 static GdkMemoryFormat
 memory_format_gl_format (GdkMemoryFormat  data_format,
-                         gboolean         use_es,
-                         guint            major,
-                         guint            minor,
+                         GdkGLContext    *context,
                          guint           *gl_internalformat,
                          guint           *gl_format,
                          guint           *gl_type,
@@ -1462,9 +1460,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
 
   /* First, try the format itself */
   if (gdk_memory_format_gl_format (data_format,
-                                   use_es,
-                                   major,
-                                   minor,
+                                   context,
                                    gl_internalformat,
                                    gl_format,
                                    gl_type,
@@ -1480,9 +1476,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
       case GDK_MEMORY_FLOAT16:
         data_format = GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED;
         if (gdk_memory_format_gl_format (data_format,
-                                         use_es,
-                                         major,
-                                         minor,
+                                         context,
                                          gl_internalformat,
                                          gl_format,
                                          gl_type,
@@ -1493,9 +1487,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
       case GDK_MEMORY_U16:
         data_format = GDK_MEMORY_R16G16B16A16_PREMULTIPLIED;
         if (gdk_memory_format_gl_format (data_format,
-                                         use_es,
-                                         major,
-                                         minor,
+                                         context,
                                          gl_internalformat,
                                          gl_format,
                                          gl_type,
@@ -1517,9 +1509,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
     {
       data_format = GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED;
       if (gdk_memory_format_gl_format (data_format,
-                                       use_es,
-                                       major,
-                                       minor,
+                                       context,
                                        gl_internalformat,
                                        gl_format,
                                        gl_type,
@@ -1530,9 +1520,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
   /* If all else fails, pick the one format that's always supported */
   data_format = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
   if (!gdk_memory_format_gl_format (data_format,
-                                    use_es,
-                                    major,
-                                    minor,
+                                    context,
                                     gl_internalformat,
                                     gl_format,
                                     gl_type,
@@ -1561,19 +1549,13 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
   GLenum gl_type;
   GLint gl_swizzle[4];
   gsize bpp;
-  gboolean use_es;
-  int major, minor;
 
-  use_es = gdk_gl_context_get_use_es (self->context);
-  gdk_gl_context_get_version (self->context, &major, &minor);
   data_format = gdk_texture_get_format (texture);
   width = gdk_texture_get_width (texture);
   height = gdk_texture_get_height (texture);
 
   data_format = memory_format_gl_format (data_format,
-                                         use_es,
-                                         major,
-                                         minor,
+                                         self->context,
                                          &gl_internalformat,
                                          &gl_format,
                                          &gl_type,
@@ -1638,9 +1620,7 @@ gsk_gl_command_queue_upload_texture_chunks (GskGLCommandQueue    *self,
   GLenum gl_format;
   GLenum gl_type;
   GLint gl_swizzle[4];
-  gboolean use_es;
   int texture_id;
-  int major, minor;
 
   g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
 
@@ -1673,13 +1653,9 @@ gsk_gl_command_queue_upload_texture_chunks (GskGLCommandQueue    *self,
   glBindTexture (GL_TEXTURE_2D, texture_id);
 
   /* Initialize the texture */
-  use_es = gdk_gl_context_get_use_es (self->context);
-  gdk_gl_context_get_version (self->context, &major, &minor);
   data_format = gdk_texture_get_format (chunks[0].texture);
   data_format = memory_format_gl_format (data_format,
-                                         use_es,
-                                         major,
-                                         minor,
+                                         self->context,
                                          &gl_internalformat,
                                          &gl_format,
                                          &gl_type,

gsk/gl/gskglglyphlibrary.c

@@ -119,7 +119,7 @@ gsk_gl_glyph_library_init_atlas (GskGLTextureLibrary *self,
 
   memset (pixel_data, 255, sizeof pixel_data);
 
-  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
+  if (!gdk_gl_context_has_bgra (gdk_gl_context_get_current ()))
     {
       gl_format = GL_RGBA;
       gl_type = GL_UNSIGNED_BYTE;
@@ -127,9 +127,8 @@ gsk_gl_glyph_library_init_atlas (GskGLTextureLibrary *self,
   else
     {
       gl_format = GL_BGRA;
-      gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+      gl_type = GL_UNSIGNED_BYTE;
     }
-
   glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
 
   glTexSubImage2D (GL_TEXTURE_2D, 0,
@@ -277,7 +276,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary     *self,
 
   g_assert (texture_id > 0);
 
-  if G_UNLIKELY (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
+  if (G_UNLIKELY (!gdk_gl_context_has_bgra (gdk_gl_context_get_current ())))
     {
       pixel_data = free_data = g_malloc (width * height * 4);
       gdk_memory_convert (pixel_data, width * 4,
@@ -294,7 +293,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary     *self,
     {
       pixel_data = cairo_image_surface_get_data (surface);
       gl_format = GL_BGRA;
-      gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+      gl_type = GL_UNSIGNED_BYTE;
     }
 
   glPixelStorei (GL_UNPACK_ROW_LENGTH, stride / 4);

gsk/gl/gskgliconlibrary.c

@@ -111,7 +111,7 @@ gsk_gl_icon_library_add (GskGLIconLibrary     *self,
   gdk_gl_context_push_debug_group_printf (gdk_gl_context_get_current (),
                                           "Uploading texture");
 
-  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
+  if (!gdk_gl_context_has_bgra (gdk_gl_context_get_current ()))
     {
       pixel_data = free_data = g_malloc (width * height * 4);
       gdk_memory_convert (pixel_data, width * 4,
@@ -125,7 +125,7 @@ gsk_gl_icon_library_add (GskGLIconLibrary     *self,
     {
       pixel_data = surface_data;
       gl_format = GL_BGRA;
-      gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+      gl_type = GL_UNSIGNED_BYTE;
     }
 
   texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);

gsk/gskrendernodeparser.c

@@ -33,6 +33,7 @@
 
 #include "gdk/gdkrgbaprivate.h"
 #include "gdk/gdktextureprivate.h"
+#include "gdk/gdkmemoryformatprivate.h"
 #include <gtk/css/gtkcss.h>
 #include "gtk/css/gtkcssdataurlprivate.h"
 #include "gtk/css/gtkcssparserprivate.h"
@@ -3169,45 +3170,20 @@ append_texture_param (Printer    *p,
       g_hash_table_insert (p->named_textures, texture, new_name);
     }
 
-  switch (gdk_texture_get_format (texture))
+  switch (gdk_memory_format_get_depth (gdk_texture_get_format (texture)))
     {
-    case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
-    case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
-    case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
-    case GDK_MEMORY_B8G8R8A8:
-    case GDK_MEMORY_A8R8G8B8:
-    case GDK_MEMORY_R8G8B8A8:
-    case GDK_MEMORY_A8B8G8R8:
-    case GDK_MEMORY_R8G8B8:
-    case GDK_MEMORY_B8G8R8:
-    case GDK_MEMORY_R16G16B16:
-    case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
-    case GDK_MEMORY_R16G16B16A16:
-    case GDK_MEMORY_G8A8_PREMULTIPLIED:
-    case GDK_MEMORY_G8A8:
-    case GDK_MEMORY_G8:
-    case GDK_MEMORY_G16A16_PREMULTIPLIED:
-    case GDK_MEMORY_G16A16:
-    case GDK_MEMORY_G16:
-    case GDK_MEMORY_A8:
-    case GDK_MEMORY_A16:
+    case GDK_MEMORY_U8:
+    case GDK_MEMORY_U16:
       bytes = gdk_texture_save_to_png_bytes (texture);
       g_string_append (p->str, "url(\"data:image/png;base64,");
       break;
 
-    case GDK_MEMORY_R16G16B16_FLOAT:
-    case GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED:
-    case GDK_MEMORY_R16G16B16A16_FLOAT:
-    case GDK_MEMORY_A16_FLOAT:
-    case GDK_MEMORY_R32G32B32_FLOAT:
-    case GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED:
-    case GDK_MEMORY_R32G32B32A32_FLOAT:
-    case GDK_MEMORY_A32_FLOAT:
+    case GDK_MEMORY_FLOAT16:
+    case GDK_MEMORY_FLOAT32:
       bytes = gdk_texture_save_to_tiff_bytes (texture);
       g_string_append (p->str, "url(\"data:image/tiff;base64,");
       break;
 
-    case GDK_MEMORY_N_FORMATS:
     default:
       g_assert_not_reached ();
     }

gsk/vulkan/gskvulkanimage.c

@@ -80,6 +80,15 @@ gsk_memory_format_get_vk_format_infos (GdkMemoryFormat format)
         return info;
       }
 
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
+      {
+        static const GskMemoryFormatInfo info[] = {
+          { VK_FORMAT_R8G8B8A8_UNORM, SWIZZLE(A, B, G, R), 0 },
+          { VK_FORMAT_UNDEFINED }
+        };
+        return info;
+      }
+
     case GDK_MEMORY_B8G8R8A8:
       {
         static const GskMemoryFormatInfo info[] = {
@@ -117,6 +126,17 @@ gsk_memory_format_get_vk_format_infos (GdkMemoryFormat format)
         return info;
       }
 
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
+      {
+        static const GskMemoryFormatInfo info[] = {
+          { VK_FORMAT_UNDEFINED }
+        };
+        return info;
+      }
+
     case GDK_MEMORY_R8G8B8:
       {
         static const GskMemoryFormatInfo info[] = {
@@ -324,6 +344,7 @@ gsk_memory_format_get_fallback (GdkMemoryFormat format)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
@@ -331,6 +352,10 @@ gsk_memory_format_get_fallback (GdkMemoryFormat format)
     case GDK_MEMORY_R8G8B8:
       return GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
 
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
     case GDK_MEMORY_B8G8R8:
       return GDK_MEMORY_R8G8B8;
 

po/POTFILES.in

@@ -23,6 +23,7 @@ gdk/gdkseat.c
 gdk/gdksurface.c
 gdk/gdktexture.c
 gdk/gdktoplevel.c
+gdk/gdkvulkancontext.c
 gdk/keynamesprivate.h
 gdk/loaders/gdkjpeg.c
 gdk/loaders/gdkpng.c

po/tr.po

@@ -22,9 +22,9 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gtk\n"
 "Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/gtk/-/issues/\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"
+"POT-Creation-Date: 2023-10-16 11:58+0000\n"
+"PO-Revision-Date: 2023-10-17 18:20+0300\n"
+"Last-Translator: Sabri Ünal <libreajans@gmail.com>\n"
 "Language-Team: Türkçe <takim@gnome.org.tr>\n"
 "Language: tr\n"
 "MIME-Version: 1.0\n"
@@ -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:163 gdk/gdkglcontext.c:442
+#: gdk/gdkdisplay.c:164 gdk/gdkglcontext.c:442
 msgid "The current backend does not support OpenGL"
 msgstr "Şimdiki arka uç OpenGL’i desteklemiyor"
 
-#: gdk/gdkdisplay.c:1258 gdk/gdksurface.c:1252
+#: gdk/gdkdisplay.c:1259 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:1290
+#: gdk/gdkdisplay.c:1291
 msgid "GL support disabled via GDK_DEBUG"
 msgstr "GL desteği, GDK_DEBUG yoluyla devre dışı bırakılmış"
 
-#: gdk/gdkdisplay.c:1588
+#: gdk/gdkdisplay.c:1589
 msgid "No EGL configuration available"
 msgstr "Kullanılabilir EGL yapılandırması yok"
 
-#: gdk/gdkdisplay.c:1596
+#: gdk/gdkdisplay.c:1597
 msgid "Failed to get EGL configurations"
 msgstr "EGL yapılandırmaları alınamadı"
 
-#: gdk/gdkdisplay.c:1626
+#: gdk/gdkdisplay.c:1627
 msgid "No EGL configuration with required features found"
 msgstr "Gerekli özellikleri olan EGL yapılandırması bulunamadı"
 
-#: gdk/gdkdisplay.c:1633
+#: gdk/gdkdisplay.c:1634
 msgid "No perfect EGL configuration found"
 msgstr "Kusursuz EGL yapılandırması bulunamadı"
 
-#: gdk/gdkdisplay.c:1675
+#: gdk/gdkdisplay.c:1676
 #, 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:1708
+#: gdk/gdkdisplay.c:1709
 msgid "libEGL not available in this sandbox"
 msgstr "libEGL bu kum havuzunda kullanılamıyor"
 
-#: gdk/gdkdisplay.c:1709
+#: gdk/gdkdisplay.c:1710
 msgid "libEGL not available"
 msgstr "libEGL kullanılamıyor"
 
-#: gdk/gdkdisplay.c:1719
+#: gdk/gdkdisplay.c:1720
 msgid "Failed to create EGL display"
 msgstr "EGL ekranı oluşturulamadı"
 
-#: gdk/gdkdisplay.c:1729
+#: gdk/gdkdisplay.c:1730
 msgid "Could not initialize EGL display"
 msgstr "EGL ekranı ilklendirilemedi"
 
-#: gdk/gdkdisplay.c:1740
+#: gdk/gdkdisplay.c:1741
 #, 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"
@@ -3154,7 +3154,7 @@ msgstr "Birim ayrılamadı"
 #. Allow to cancel the operation
 #: gtk/gtkplacesview.c:1445
 msgid "Cance_l"
-msgstr "İpta_l"
+msgstr "İ_ptal"
 
 #: gtk/gtkplacesview.c:1592
 msgid "AppleTalk"

tests/meson.build

@@ -125,7 +125,10 @@ gtk_tests = [
 ]
 
 if os_unix
-  gtk_tests += [['testfontchooserdialog']]
+  gtk_tests += [
+    ['testfontchooserdialog'],
+    ['testdmabuf'],
+  ]
 endif
 
 if x11_enabled

tests/testdmabuf.c

@@ -0,0 +1,495 @@
+#include <gtk/gtk.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-heap.h>
+#include <drm/drm_fourcc.h>
+
+/* For this to work, you may need to give /dev/dma_heap/system
+ * lax permissions.
+ */
+
+static int
+allocate_dma_buf (gsize size)
+{
+  static int fd = -1;
+  struct dma_heap_allocation_data heap_data;
+  int ret;
+
+  if (fd == -1)
+    {
+      fd = open ("/dev/dma_heap/system", O_RDONLY | O_CLOEXEC);
+      if (fd == -1)
+        g_error ("Failed to open /dev/dma_heap/system");
+    }
+
+  heap_data.len = size;
+  heap_data.fd = 0;
+  heap_data.fd_flags = O_RDWR | O_CLOEXEC;
+  heap_data.heap_flags = 0;
+
+  ret = ioctl (fd, DMA_HEAP_IOCTL_ALLOC, &heap_data);
+  if (ret)
+    g_error ("dma-buf allocation failed");
+
+  return heap_data.fd;
+}
+
+static void
+populate_dma_buf (int           fd,
+                  const guchar *data,
+                  gsize         size)
+{
+  guchar *buf;
+
+  buf = mmap (NULL, size, PROT_WRITE, MAP_SHARED, fd, 0);
+  memcpy (buf, data, size);
+  munmap (buf, size);
+}
+
+
+/* The YUV conversion code is adapted from weston/tests/yuv-buffer-test.c */
+
+/*
+ * Based on Rec. ITU-R BT.601-7
+ *
+ * This is intended to be obvious and accurate, not fast.
+ */
+static void
+x8r8g8b8_to_ycbcr8_bt601 (guint32 xrgb,
+                          guchar *y_out,
+                          guchar *cb_out,
+                          guchar *cr_out)
+{
+  double y, cb, cr;
+  double r = (xrgb >> 16) & 0xff;
+  double g = (xrgb >> 8) & 0xff;
+  double b = (xrgb >> 0) & 0xff;
+
+  /* normalize to [0.0, 1.0] */
+  r /= 255.0;
+  g /= 255.0;
+  b /= 255.0;
+
+  /* Y normalized to [0.0, 1.0], Cb and Cr [-0.5, 0.5] */
+  y = 0.299 * r + 0.587 * g + 0.114 * b;
+  cr = (r - y) / 1.402;
+  cb = (b - y) / 1.772;
+
+  /* limited range quantization to 8 bit */
+  *y_out = round(219.0 * y + 16.0);
+  if (cr_out)
+    *cr_out = round(224.0 * cr + 128.0);
+  if (cb_out)
+    *cb_out = round(224.0 * cb + 128.0);
+}
+
+/*
+ * 3 plane YCbCr
+ * plane 0: Y plane, [7:0] Y
+ * plane 1: Cb plane, [7:0] Cb
+ * plane 2: Cr plane, [7:0] Cr
+ * YUV420: 2x2 subsampled Cb (1) and Cr (2) planes
+ * YUV444: no subsampling
+ */
+static guchar *
+y_u_v_create_buffer (uint32_t  drm_format,
+                     guchar   *rgb_data,
+                     int       rgb_width,
+                     int       rgb_height,
+                     int      *size,
+                     int      *u_offset,
+                     int      *v_offset)
+{
+  gsize bytes;
+  int x, y;
+  guint32 *rgb_row;
+  guchar *y_base;
+  guchar *u_base;
+  guchar *v_base;
+  guchar *y_row;
+  guchar *u_row;
+  guchar *v_row;
+  guint32 argb;
+  int sub = (drm_format == DRM_FORMAT_YUV420) ? 2 : 1;
+  guchar *buf;
+
+  g_assert (drm_format == DRM_FORMAT_YUV420 ||
+            drm_format == DRM_FORMAT_YUV444);
+
+  /* Full size Y plus quarter U and V */
+  bytes = rgb_width * rgb_height +
+          (rgb_width / sub) * (rgb_height / sub) * 2;
+
+  buf = g_new (guchar, bytes);
+
+  *size = bytes;
+  *u_offset = rgb_width * rgb_height;
+  *v_offset = *u_offset + (rgb_width / sub) * (rgb_height / sub);
+
+  y_base = buf;
+  u_base = y_base + rgb_width * rgb_height;
+  v_base = u_base + (rgb_width / sub) * (rgb_height / sub);
+
+  for (y = 0; y < rgb_height; y++)
+    {
+      rgb_row = (guint32 *) (rgb_data + y * 4 * rgb_width);
+      y_row = y_base + y * rgb_width;
+      u_row = u_base + (y / sub) * (rgb_width / sub);
+      v_row = v_base + (y / sub) * (rgb_width / sub);
+
+      for (x = 0; x < rgb_width; x++)
+        {
+          /*
+           * Sub-sample the source image instead, so that U and V
+           * sub-sampling does not require proper
+           * filtering/averaging/siting.
+           */
+          argb = rgb_row[x];
+
+          /*
+           * A stupid way of "sub-sampling" chroma. This does not
+           * do the necessary filtering/averaging/siting or
+           * alternate Cb/Cr rows.
+           */
+          if ((y & (sub - 1)) == 0 && (x & (sub - 1)) == 0)
+            x8r8g8b8_to_ycbcr8_bt601 (argb, y_row + x, u_row + x / sub, v_row + x / sub);
+          else
+            x8r8g8b8_to_ycbcr8_bt601 (argb, y_row + x, NULL, NULL);
+        }
+    }
+
+  return buf;
+}
+
+/*
+ * 2 plane YCbCr
+ * plane 0 = Y plane, [7:0] Y
+ * plane 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
+ * 2x2 subsampled Cr:Cb plane
+ */
+static guchar *
+nv12_create_buffer (uint32_t drm_format,
+                    guchar   *rgb_data,
+                    int       rgb_width,
+                    int       rgb_height,
+                    int      *size,
+                    int      *uv_offset)
+{
+  size_t bytes;
+  int x, y;
+  uint32_t *rgb_row;
+  uint8_t *y_base;
+  uint8_t *uv_base;
+  uint8_t *y_row;
+  uint16_t *uv_row;
+  uint32_t argb;
+  uint8_t cr;
+  uint8_t cb;
+  guchar *buf;
+
+  g_assert (drm_format == DRM_FORMAT_NV12);
+
+  /* Full size Y plane, half size UV plane */
+  bytes = rgb_width * rgb_height +
+          rgb_width * (rgb_height / 2);
+  *size = bytes;
+
+  buf = g_new0 (guchar, bytes);
+
+  *uv_offset = rgb_width * rgb_height;
+  y_base = buf;
+  uv_base = y_base + rgb_width * rgb_height;
+
+  for (y = 0; y < rgb_height; y++)
+    {
+      rgb_row = (uint32_t *) (rgb_data + y * 4 * rgb_width);
+      y_row = y_base + y * rgb_width;
+      uv_row = (uint16_t *) (uv_base + (y / 2) * rgb_width);
+
+      for (x = 0; x < rgb_width; x++)
+        {
+          /*
+           * Sub-sample the source image instead, so that U and V
+           * sub-sampling does not require proper
+           * filtering/averaging/siting.
+           */
+          argb = rgb_row[x];
+
+          /*
+           * A stupid way of "sub-sampling" chroma. This does not
+           * do the necessary filtering/averaging/siting.
+           */
+          if ((y & 1) == 0 && (x & 1) == 0)
+            {
+              x8r8g8b8_to_ycbcr8_bt601(argb, y_row + x, &cb, &cr);
+              *(uv_row + x / 2) = ((uint16_t)cr << 8) | cb;
+            }
+          else
+            {
+              x8r8g8b8_to_ycbcr8_bt601(argb, y_row + x, NULL, NULL);
+            }
+        }
+    }
+
+  return buf;
+}
+
+static void
+texture_builder_set_planes (GdkDmabufTextureBuilder *builder,
+                            gboolean                 disjoint,
+                            const guchar            *buf,
+                            unsigned                 size,
+                            unsigned                 n_planes,
+                            unsigned                 strides[4],
+                            unsigned                 sizes[4])
+{
+  gdk_dmabuf_texture_builder_set_n_planes (builder, n_planes);
+
+  if (disjoint)
+    {
+      unsigned offset = 0;
+      unsigned i;
+
+      for (i = 0; i < n_planes; i++)
+        {
+          int fd = allocate_dma_buf (sizes[i]);
+          populate_dma_buf (fd, buf + offset, sizes[i]);
+
+          gdk_dmabuf_texture_builder_set_fd (builder, i, fd);
+          gdk_dmabuf_texture_builder_set_stride (builder, i, strides[i]);
+          gdk_dmabuf_texture_builder_set_offset (builder, i, 0);
+          offset += sizes[i];
+        }
+    }
+  else
+    {
+      unsigned offset = 0;
+      unsigned i;
+      int fd = allocate_dma_buf (size);
+      populate_dma_buf (fd, buf, size);
+
+      for (i = 0; i < n_planes; i++)
+        {
+          gdk_dmabuf_texture_builder_set_fd (builder, i, fd);
+          gdk_dmabuf_texture_builder_set_stride (builder, i, strides[i]);
+          gdk_dmabuf_texture_builder_set_offset (builder, i, offset);
+          offset += sizes[i];
+        }
+    }
+}
+
+static GdkTexture *
+make_dmabuf_texture (const char *filename,
+                     guint32     format,
+                     gboolean    disjoint)
+{
+  GdkTexture *texture;
+  int width, height;
+  gsize rgb_stride, rgb_size;
+  guchar *rgb_data;
+  int fd;
+  GdkDmabufTextureBuilder *builder;
+  GError *error = NULL;
+
+  texture = gdk_texture_new_from_filename (filename, NULL);
+
+  width = gdk_texture_get_width (texture);
+  height = gdk_texture_get_height (texture);
+  rgb_stride = 4 * width;
+  rgb_size = rgb_stride * height;
+
+  rgb_data = g_new0 (guchar, rgb_size);
+
+  gdk_texture_download (texture, rgb_data, rgb_stride);
+
+  g_object_unref (texture);
+
+  builder = gdk_dmabuf_texture_builder_new ();
+
+  gdk_dmabuf_texture_builder_set_display (builder, gdk_display_get_default ());
+  gdk_dmabuf_texture_builder_set_width (builder, width);
+  gdk_dmabuf_texture_builder_set_height (builder, height);
+  gdk_dmabuf_texture_builder_set_fourcc (builder, format);
+  gdk_dmabuf_texture_builder_set_modifier (builder, DRM_FORMAT_MOD_LINEAR);
+
+  if (format == DRM_FORMAT_XRGB8888 ||
+      format == DRM_FORMAT_ARGB8888)
+    {
+      gdk_dmabuf_texture_builder_set_n_planes (builder, 1);
+
+      fd = allocate_dma_buf (rgb_size);
+      populate_dma_buf (fd, rgb_data, rgb_size);
+
+      gdk_dmabuf_texture_builder_set_fd (builder, 0, fd);
+      gdk_dmabuf_texture_builder_set_stride (builder, 0, rgb_stride);
+    }
+  else if (format == DRM_FORMAT_YUV420)
+    {
+      guchar *buf;
+      int size, u_offset, v_offset;
+
+      buf = y_u_v_create_buffer (format, rgb_data, width, height, &size, &u_offset, &v_offset);
+
+      texture_builder_set_planes (builder,
+                                  disjoint,
+                                  buf,
+                                  size,
+                                  3,
+                                  (unsigned[4]) { width, width / 2, width / 2 }, 
+                                  (unsigned[4]) { width * height, width * height / 4, width * height / 4 });
+
+      g_free (buf);
+    }
+  else if (format == DRM_FORMAT_NV12)
+    {
+      guchar *buf;
+      int size, uv_offset;
+
+      buf = nv12_create_buffer (format, rgb_data, width, height, &size, &uv_offset);
+
+      texture_builder_set_planes (builder,
+                                  disjoint,
+                                  buf,
+                                  size,
+                                  2,
+                                  (unsigned[4]) { width, width, }, 
+                                  (unsigned[4]) { width * height, width * height / 2 });
+
+      g_free (buf);
+    }
+
+  g_free (rgb_data);
+
+  texture = gdk_dmabuf_texture_builder_build (builder, NULL, NULL, &error);
+  if (!texture)
+    g_error ("Failed to create dmabuf texture: %s", error->message);
+
+  g_object_unref (builder);
+
+  return texture;
+}
+
+static guint32 supported_formats[] = {
+  DRM_FORMAT_ARGB8888,
+  DRM_FORMAT_XRGB8888,
+  DRM_FORMAT_YUV420,
+  DRM_FORMAT_NV12,
+};
+
+static gboolean
+format_is_supported (guint32 fmt)
+{
+  for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      if (supported_formats[i] == fmt)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+static char *
+supported_formats_to_string (void)
+{
+  GString *s;
+
+  s = g_string_new ("");
+  for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      if (s->len)
+        g_string_append (s, ", ");
+      g_string_append_printf (s, "%.4s", (char *)&supported_formats[i]);
+    }
+
+  return g_string_free (s, FALSE);
+}
+
+G_GNUC_NORETURN
+static void
+usage (void)
+{
+  char *formats = supported_formats_to_string ();
+  g_print ("Usage: testdmabuf [--undecorated] [--disjoint][--download-to FILE] FORMAT FILE\n"
+           "Supported formats: %s\n", formats);
+  g_free (formats);
+  exit (1);
+}
+
+static guint32
+parse_format (const char *a)
+{
+  if (strlen (a) == 4)
+    {
+      guint32 format = fourcc_code (a[0], a[1], a[2], a[3]);
+      if (format_is_supported (format))
+        return format;
+    }
+
+  usage ();
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  GdkTexture *texture;
+  GtkWidget *window, *picture;
+  char *filename;
+  guint32 format;
+  gboolean disjoint = FALSE;
+  gboolean decorated = TRUE;
+  unsigned int i;
+  const char *save_filename = NULL;
+
+  for (i = 1; i < argc; i++)
+    {
+      if (g_str_equal (argv[i], "--disjoint"))
+        disjoint = TRUE;
+      else if (g_str_equal (argv[i], "--undecorated"))
+        decorated = FALSE;
+      else if (g_str_equal (argv[i], "--download-to"))
+        {
+          i++;
+          if (i == argc)
+            usage ();
+
+          save_filename = argv[i];
+        }
+      else
+        break;
+    }
+
+  if (argc - i != 2)
+    {
+      usage ();
+      return 1;
+    }
+
+  format = parse_format (argv[argc - 2]);
+  filename = argv[argc - 1];
+
+  gtk_init ();
+
+  /* Get the list of supported formats with GDK_DEBUG=opengl */
+  gdk_display_get_dmabuf_formats (gdk_display_get_default ());
+
+  texture = make_dmabuf_texture (filename, format, disjoint);
+
+  if (save_filename)
+    gdk_texture_save_to_png (texture, save_filename);
+
+  window = gtk_window_new ();
+  gtk_window_set_decorated (GTK_WINDOW (window), decorated);
+
+  picture = gtk_picture_new_for_paintable (GDK_PAINTABLE (texture));
+
+  gtk_window_set_child (GTK_WINDOW (window), picture);
+
+  gtk_window_present (GTK_WINDOW (window));
+
+  while (g_list_model_get_n_items (gtk_window_get_toplevels ()) > 0)
+    g_main_context_iteration (NULL, TRUE);
+
+  return 0;
+}

testsuite/gdk/memorytexture.c

@@ -102,10 +102,15 @@ gdk_memory_format_bytes_per_pixel (GdkMemoryFormat format)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
     case GDK_MEMORY_A8B8G8R8:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
     case GDK_MEMORY_G16A16_PREMULTIPLIED:
     case GDK_MEMORY_G16A16:
     case GDK_MEMORY_A32_FLOAT:
@@ -145,10 +150,15 @@ gdk_memory_format_get_channel_type (GdkMemoryFormat format)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
     case GDK_MEMORY_A8B8G8R8:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
     case GDK_MEMORY_G8:
     case GDK_MEMORY_G8A8:
     case GDK_MEMORY_G8A8_PREMULTIPLIED:
@@ -197,10 +207,15 @@ gdk_memory_format_n_colors (GdkMemoryFormat format)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
     case GDK_MEMORY_A8B8G8R8:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
     case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
     case GDK_MEMORY_R16G16B16A16:
     case GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED:
@@ -242,11 +257,16 @@ gdk_memory_format_has_alpha (GdkMemoryFormat format)
     case GDK_MEMORY_R32G32B32_FLOAT:
     case GDK_MEMORY_G8:
     case GDK_MEMORY_G16:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
       return FALSE;
 
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_B8G8R8A8:
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
@@ -282,6 +302,7 @@ gdk_memory_format_is_premultiplied (GdkMemoryFormat format)
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
     case GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED:
     case GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED:
@@ -302,6 +323,10 @@ gdk_memory_format_is_premultiplied (GdkMemoryFormat format)
     case GDK_MEMORY_A8R8G8B8:
     case GDK_MEMORY_R8G8B8A8:
     case GDK_MEMORY_A8B8G8R8:
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_R8G8B8X8:
+    case GDK_MEMORY_X8B8G8R8:
     case GDK_MEMORY_R16G16B16A16:
     case GDK_MEMORY_R16G16B16A16_FLOAT:
     case GDK_MEMORY_R32G32B32A32_FLOAT:
@@ -321,45 +346,7 @@ gdk_memory_format_is_premultiplied (GdkMemoryFormat format)
 static gboolean
 gdk_memory_format_is_deep (GdkMemoryFormat format)
 {
-  switch (format)
-    {
-    case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
-    case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
-    case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
-    case GDK_MEMORY_G8A8_PREMULTIPLIED:
-    case GDK_MEMORY_R8G8B8:
-    case GDK_MEMORY_B8G8R8:
-    case GDK_MEMORY_B8G8R8A8:
-    case GDK_MEMORY_A8R8G8B8:
-    case GDK_MEMORY_R8G8B8A8:
-    case GDK_MEMORY_A8B8G8R8:
-    case GDK_MEMORY_G8:
-    case GDK_MEMORY_G8A8:
-    case GDK_MEMORY_A8:
-      return FALSE;
-
-    case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
-    case GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED:
-    case GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED:
-    case GDK_MEMORY_G16A16_PREMULTIPLIED:
-    case GDK_MEMORY_R16G16B16:
-    case GDK_MEMORY_R16G16B16_FLOAT:
-    case GDK_MEMORY_R32G32B32_FLOAT:
-    case GDK_MEMORY_R16G16B16A16:
-    case GDK_MEMORY_R16G16B16A16_FLOAT:
-    case GDK_MEMORY_R32G32B32A32_FLOAT:
-    case GDK_MEMORY_G16:
-    case GDK_MEMORY_G16A16:
-    case GDK_MEMORY_A16:
-    case GDK_MEMORY_A16_FLOAT:
-    case GDK_MEMORY_A32_FLOAT:
-      return TRUE;
-
-    case GDK_MEMORY_N_FORMATS:
-    default:
-      g_assert_not_reached ();
-      return FALSE;
-    }
+  return gdk_memory_format_get_channel_type (format) != CHANNEL_UINT_8;
 }
 
 static gboolean
@@ -373,6 +360,7 @@ gdk_memory_format_pixel_equal (GdkMemoryFormat  format,
     case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
     case GDK_MEMORY_A8R8G8B8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
     case GDK_MEMORY_R8G8B8:
     case GDK_MEMORY_B8G8R8:
     case GDK_MEMORY_B8G8R8A8:
@@ -385,6 +373,14 @@ gdk_memory_format_pixel_equal (GdkMemoryFormat  format,
     case GDK_MEMORY_G8A8_PREMULTIPLIED:
       return memcmp (pixel1, pixel2, gdk_memory_format_bytes_per_pixel (format)) == 0;
 
+    case GDK_MEMORY_B8G8R8X8:
+    case GDK_MEMORY_R8G8B8X8:
+      return memcmp (pixel1, pixel2, 3) == 0;
+
+    case GDK_MEMORY_X8R8G8B8:
+    case GDK_MEMORY_X8B8G8R8:
+      return memcmp (pixel1 + 1, pixel2 + 1, 3) == 0;
+
     case GDK_MEMORY_R16G16B16:
     case GDK_MEMORY_R16G16B16A16:
     case GDK_MEMORY_R16G16B16A16_PREMULTIPLIED:
@@ -581,6 +577,9 @@ texture_builder_set_pixel (TextureBuilder  *builder,
     case GDK_MEMORY_R8G8B8A8_PREMULTIPLIED:
       set_pixel_u8 (data, 0, 1, 2, 3, TRUE, color);
       break;
+    case GDK_MEMORY_A8B8G8R8_PREMULTIPLIED:
+      set_pixel_u8 (data, 3, 2, 1, 0, TRUE, color);
+      break;
     case GDK_MEMORY_B8G8R8A8:
       set_pixel_u8 (data, 2, 1, 0, 3, FALSE, color);
       break;
@@ -593,6 +592,18 @@ texture_builder_set_pixel (TextureBuilder  *builder,
     case GDK_MEMORY_A8B8G8R8:
       set_pixel_u8 (data, 3, 2, 1, 0, FALSE, color);
       break;
+    case GDK_MEMORY_B8G8R8X8:
+      set_pixel_u8 (data, 2, 1, 0, -1, TRUE, color);
+      break;
+    case GDK_MEMORY_X8R8G8B8:
+      set_pixel_u8 (data, 1, 2, 3, -1, TRUE, color);
+      break;
+    case GDK_MEMORY_R8G8B8X8:
+      set_pixel_u8 (data, 0, 1, 2, -1, TRUE, color);
+      break;
+    case GDK_MEMORY_X8B8G8R8:
+      set_pixel_u8 (data, 3, 2, 1, -1, TRUE, color);
+      break;
     case GDK_MEMORY_R8G8B8:
       set_pixel_u8 (data, 0, 1, 2, -1, TRUE, color);
       break;

testsuite/gsk/compare/empty-linear-gradient.node

@@ -1 +1,10 @@
-linear-gradient { }
+linear-gradient {
+  stops: 0.2 red,
+         0.2 blue,
+         0.4 blue,
+         0.4 yellow,
+         0.6 yellow,
+         0.6 lime,
+         0.8 lime,
+         0.8 teal;
+}

testsuite/gsk/compare/opacity-overdraw.node

@@ -1,4 +1,5 @@
 opacity {
+  opacity: 0.6;
   child: transform {
     transform: translate(15, 15);
     child: container {

testsuite/gtk/defaultvalue.c

@@ -182,6 +182,10 @@ test_type (gconstpointer data)
 	  strcmp (pspec->name, "storable-formats") == 0)
 	check = FALSE;
 
+      if (g_type_is_a (type, GDK_TYPE_DMABUF_TEXTURE_BUILDER) &&
+	  strcmp (pspec->name, "display") == 0)
+	check = FALSE;
+
       /* set in the constructor */
       if (g_type_is_a (type, GSK_TYPE_GL_SHADER) &&
 	  strcmp (pspec->name, "source") == 0)