renderer: Make hdr textures if necessary

Take the preferred color state of the content into account
when deciding what color state to use for the texture we
generate.

gdk/gdkcolorstateprivate.h

@@ -78,15 +78,8 @@ GdkColorState * gdk_color_state_new_for_cicp            (const GdkCicp
                                                          GError                **error);
 
 static inline GdkColorState *
-gdk_color_state_get_rendering_color_state (GdkColorState *self,
-                                           gboolean       srgb)
+gdk_color_state_get_rendering_color_state (GdkColorState *self)
 {
-  if (srgb)
-    {
-      self = gdk_color_state_get_no_srgb_tf (self);
-      g_assert (self);
-    }
-
   if (GDK_DEBUG_CHECK (HDR))
     self = GDK_COLOR_STATE_REC2100_PQ;
 

gdk/gdkglcontext.c

@@ -637,7 +637,10 @@ gdk_gl_context_real_begin_frame (GdkDrawContext  *draw_context,
   else
     *out_depth = GDK_MEMORY_U8;
 
-  *out_color_state = color_state;
+  if (*out_depth == GDK_MEMORY_U8_SRGB)
+    *out_color_state = gdk_color_state_get_no_srgb_tf (color_state);
+  else
+    *out_color_state = color_state;
 #else
   *out_color_state = gdk_color_state_get_srgb ();
   *out_depth = GDK_MEMORY_U8;

gdk/gdkmemoryformat.c

@@ -358,7 +358,7 @@ struct _GdkMemoryFormatDescription
 
 static const GdkMemoryFormatDescription memory_formats[] = {
   [GDK_MEMORY_B8G8R8A8_PREMULTIPLIED] = {
-    .name = "BGRA8(p)",
+    .name = "*BGRA8",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
     .straight = GDK_MEMORY_B8G8R8A8,
@@ -389,7 +389,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = b8g8r8a8_premultiplied_from_float,
   },
   [GDK_MEMORY_A8R8G8B8_PREMULTIPLIED] = {
-    .name = "ARGB8(p)",
+    .name = "*ARGB8",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
     .straight = GDK_MEMORY_A8R8G8B8,
@@ -420,7 +420,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = a8r8g8b8_premultiplied_from_float,
   },
   [GDK_MEMORY_R8G8B8A8_PREMULTIPLIED] = {
-    .name = "RGBA8(p)",
+    .name = "*RGBA8",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
     .straight = GDK_MEMORY_R8G8B8A8,
@@ -450,7 +450,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = r8g8b8a8_premultiplied_from_float,
   },
   [GDK_MEMORY_A8B8G8R8_PREMULTIPLIED] = {
-    .name = "ABGR8(p)",
+    .name = "*ABGR8",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_A8B8G8R8_PREMULTIPLIED,
     .straight = GDK_MEMORY_A8B8G8R8,
@@ -828,7 +828,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = r16g16b16_from_float,
   },
   [GDK_MEMORY_R16G16B16A16_PREMULTIPLIED] = {
-    .name = "RGBA16(p)",
+    .name = "*RGBA16",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_R16G16B16A16_PREMULTIPLIED,
     .straight = GDK_MEMORY_R16G16B16A16,
@@ -927,7 +927,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = r16g16b16_float_from_float,
   },
   [GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED] = {
-    .name = "RGBA16f(p)",
+    .name = "*RGBA16f",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED,
     .straight = GDK_MEMORY_R16G16B16A16_FLOAT,
@@ -1024,7 +1024,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = r32g32b32_float_from_float,
   },
   [GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED] = {
-    .name = "RGBA32f(p)",
+    .name = "*RGBA32f",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED,
     .straight = GDK_MEMORY_R32G32B32A32_FLOAT,
@@ -1088,7 +1088,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = r32g32b32a32_float_from_float,
   },
   [GDK_MEMORY_G8A8_PREMULTIPLIED] = {
-    .name = "GA8(p)",
+    .name = "*GA8",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_G8A8_PREMULTIPLIED,
     .straight = GDK_MEMORY_G8A8,
@@ -1181,7 +1181,7 @@ static const GdkMemoryFormatDescription memory_formats[] = {
     .from_float = g8_from_float,
   },
   [GDK_MEMORY_G16A16_PREMULTIPLIED] = {
-    .name = "GA16(p)",
+    .name = "*GA16",
     .alpha = GDK_MEMORY_ALPHA_PREMULTIPLIED,
     .premultiplied = GDK_MEMORY_G16A16_PREMULTIPLIED,
     .straight = GDK_MEMORY_G16A16,
@@ -1524,14 +1524,6 @@ gdk_memory_format_get_depth (GdkMemoryFormat format,
   return depth;
 }
 
-const char *
-gdk_memory_depth_get_name (GdkMemoryDepth depth)
-{
-  const char *names[] = { "none", "u8", "u8-srgb", "u16", "f16", "f32" };
-
-  return names[depth];
-}
-
 /*<private>
  * gdk_memory_depth_merge:
  * @depth1: the first depth
@@ -1879,12 +1871,6 @@ gdk_memory_convert (guchar              *dest_data,
   g_assert (dest_data + gdk_memory_format_min_buffer_size (dest_format, dest_stride, width, height) <= src_data ||
             src_data + gdk_memory_format_min_buffer_size (src_format, src_stride, width, height) <= dest_data);
 
-  g_print ("memory convert %s %s -> %s %s\n",
-           gdk_memory_format_get_name (src_format),
-           gdk_color_state_get_name (src_cs),
-           gdk_memory_format_get_name (dest_format),
-           gdk_color_state_get_name (dest_cs));
-
   if (src_format == dest_format && gdk_color_state_equal (dest_cs, src_cs))
     {
       gsize bytes_per_row = src_desc->bytes_per_pixel * width;
@@ -1958,7 +1944,6 @@ gdk_memory_convert (guchar              *dest_data,
 
   if (func != NULL)
     {
-      g_print ("convert format\n");
       for (y = 0; y < height; y++)
         {
           func (dest_data, src_data, width);
@@ -1981,13 +1966,10 @@ gdk_memory_convert (guchar              *dest_data,
       needs_premultiply = src_desc->alpha == GDK_MEMORY_ALPHA_STRAIGHT && dest_desc->alpha != GDK_MEMORY_ALPHA_STRAIGHT;
     }
 
-  g_print ("convert color %lu %lu\n", width, height);
   for (y = 0; y < height; y++)
     {
       src_desc->to_float (tmp, src_data, width);
 
-      g_print ("after to_float: %f %f %f %f\n", tmp[0][0], tmp[0][1], tmp[0][2], tmp[0][3]);
-
       if (needs_unpremultiply)
         unpremultiply (tmp, width);
 
@@ -2169,10 +2151,6 @@ gdk_memory_convert_color_state (guchar          *data,
   if (gdk_color_state_equal (src_cs, dest_cs))
     return;
 
-  g_print ("memory convert color state %s -> %s\n",
-           gdk_color_state_get_name (src_cs),
-           gdk_color_state_get_name (dest_cs));
-
   if (format == GDK_MEMORY_B8G8R8A8_PREMULTIPLIED &&
       src_cs == GDK_COLOR_STATE_SRGB &&
       dest_cs == GDK_COLOR_STATE_SRGB_LINEAR)

gdk/gdkmemoryformatprivate.h

@@ -66,7 +66,6 @@ GdkMemoryDepth          gdk_memory_depth_merge              (GdkMemoryDepth
                                                              GdkMemoryDepth              depth2) G_GNUC_CONST;
 GdkMemoryFormat         gdk_memory_depth_get_format         (GdkMemoryDepth              depth) G_GNUC_CONST;
 GdkMemoryFormat         gdk_memory_depth_get_alpha_format   (GdkMemoryDepth              depth) G_GNUC_CONST;
-const char *            gdk_memory_depth_get_name           (GdkMemoryDepth              depth);
 void                    gdk_memory_format_gl_format         (GdkMemoryFormat             format,
                                                              gboolean                    gles,
                                                              GLint                      *out_internal_format,

gdk/gdksurface.c

@@ -1132,10 +1132,8 @@ gdk_surface_set_egl_native_window (GdkSurface *self,
 
   if (priv->egl_surface != NULL)
     {
-      GdkDisplay *display = gdk_surface_get_display (self);
-
       gdk_gl_context_clear_current_if_surface (self);
-      eglDestroySurface (gdk_display_get_egl_display (display), priv->egl_surface);
+      eglDestroySurface (gdk_surface_get_display (self), priv->egl_surface);
       priv->egl_surface = NULL;
     }
 

gdk/gdkvulkancontext.c

@@ -678,7 +678,10 @@ gdk_vulkan_context_begin_frame (GdkDrawContext  *draw_context,
 
   cairo_region_union (region, priv->regions[priv->draw_index]);
 
-  *out_color_state = color_state;
+  if (priv->current_depth == GDK_MEMORY_U8_SRGB)
+    *out_color_state = gdk_color_state_get_no_srgb_tf (color_state);
+  else
+    *out_color_state = color_state;
   *out_depth = priv->current_depth;
 }
 

gdk/wayland/gdkclipboard-wayland.c

@@ -236,7 +236,6 @@ gdk_wayland_clipboard_read_async (GdkClipboard        *clipboard,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
   /* offer formats should be empty if we have no offer */
@@ -247,7 +246,6 @@ gdk_wayland_clipboard_read_async (GdkClipboard        *clipboard,
   if (!g_unix_open_pipe (pipe_fd, O_CLOEXEC, &error))
     {
       g_task_return_error (task, error);
-      g_object_unref (task);
       return;
     }
 
@@ -255,7 +253,6 @@ gdk_wayland_clipboard_read_async (GdkClipboard        *clipboard,
   stream = g_unix_input_stream_new (pipe_fd[0], TRUE);
   close (pipe_fd[1]);
   g_task_return_pointer (task, stream, g_object_unref);
-  g_object_unref (task);
 }
 
 static GInputStream *

gdk/wayland/gdkdrop-wayland.c

@@ -203,7 +203,6 @@ gdk_wayland_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
 
@@ -212,7 +211,6 @@ gdk_wayland_drop_read_async (GdkDrop             *drop,
   if (!g_unix_open_pipe (pipe_fd, O_CLOEXEC, &error))
     {
       g_task_return_error (task, error);
-      g_object_unref (task);
       return;
     }
 
@@ -220,7 +218,6 @@ gdk_wayland_drop_read_async (GdkDrop             *drop,
   stream = g_unix_input_stream_new (pipe_fd[0], TRUE);
   close (pipe_fd[1]);
   g_task_return_pointer (task, stream, g_object_unref);
-  g_object_unref (task);
 }
 
 static GInputStream *

gdk/wayland/gdkprimary-wayland.c

@@ -335,7 +335,6 @@ gdk_wayland_primary_read_async (GdkClipboard        *clipboard,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
   /* offer formats should be empty if we have no offer */
@@ -346,7 +345,6 @@ gdk_wayland_primary_read_async (GdkClipboard        *clipboard,
   if (!g_unix_open_pipe (pipe_fd, O_CLOEXEC, &error))
     {
       g_task_return_error (task, error);
-      g_object_unref (task);
       return;
     }
 
@@ -354,7 +352,6 @@ gdk_wayland_primary_read_async (GdkClipboard        *clipboard,
   stream = g_unix_input_stream_new (pipe_fd[0], TRUE);
   close (pipe_fd[1]);
   g_task_return_pointer (task, stream, g_object_unref);
-  g_object_unref (task);
 }
 
 static GInputStream *

gdk/win32/gdkdrop-win32.c

@@ -1016,7 +1016,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
         {
           g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                    _("No compatible transfer format found"));
-          g_object_unref (task);
           g_clear_pointer (&drop_win32->dropfiles_list, g_free);
 
           return;
@@ -1026,7 +1025,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
       drop_win32->dropfiles_list = NULL;
       g_object_set_data (G_OBJECT (stream), "gdk-dnd-stream-contenttype", (gpointer) "text/uri-list");
       g_task_return_pointer (task, stream, g_object_unref);
-      g_object_unref (task);
 
       return;
     }
@@ -1037,7 +1035,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                _("GDK surface 0x%p is not registered as a drop target"), gdk_drop_get_surface (drop));
-      g_object_unref (task);
       return;
     }
 
@@ -1045,7 +1042,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                _("Target context record 0x%p has no data object"), tctx);
-      g_object_unref (task);
       return;
     }
 
@@ -1065,7 +1061,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
 
@@ -1085,7 +1080,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                _("IDataObject_GetData (0x%x) failed, returning 0x%lx"), fmt.cfFormat, hr);
-      g_object_unref (task);
       return;
     }
 
@@ -1098,7 +1092,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
           if (data == NULL)
             {
               ReleaseStgMedium (&storage);
-              g_object_unref (task);
 
               return;
             }
@@ -1119,14 +1112,12 @@ gdk_win32_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                _("Failed to transmute DnD data W32 format 0x%x to %p (%s)"), pair->w32format, pair->contentformat, pair->contentformat);
-      g_object_unref (task);
       return;
     }
 
   stream = g_memory_input_stream_new_from_data (data, data_len, g_free);
   g_object_set_data (G_OBJECT (stream), "gdk-dnd-stream-contenttype", (gpointer) pair->contentformat);
   g_task_return_pointer (task, stream, g_object_unref);
-  g_object_unref (task);
 }
 
 static GInputStream *

gdk/x11/gdkclipboard-x11.c

@@ -797,7 +797,6 @@ gdk_x11_clipboard_read_async (GdkClipboard        *clipboard,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
 

gdk/x11/gdkdrop-x11.c

@@ -233,7 +233,6 @@ gdk_x11_drop_read_async (GdkDrop             *drop,
     {
       g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                                _("No compatible transfer format found"));
-      g_object_unref (task);
       return;
     }
 

gsk/gpu/gskgpudownloadop.c

@@ -20,7 +20,6 @@
 #include "gdk/gdkglcontextprivate.h"
 
 #ifdef HAVE_DMABUF
-#include <glib-unix.h>
 #include <linux/dma-buf.h>
 #endif
 
@@ -33,9 +32,8 @@ struct _GskGpuDownloadOp
   GskGpuOp op;
 
   GskGpuImage *image;
-  GdkColorState *image_cs;
-  GdkColorState *download_cs;
   gboolean allow_dmabuf;
+  GdkColorState *color_state;
   GdkGpuDownloadOpCreateFunc create_func;
   GskGpuDownloadFunc func;
   gpointer user_data;
@@ -55,60 +53,9 @@ gsk_gpu_download_op_finish (GskGpuOp *op)
   if (self->create_func)
     self->create_func (self);
 
-  g_print ("downloaded texture: %s %.4s depth %s format %s color state %s\n",
-           GDK_IS_DMABUF_TEXTURE (self->texture)
-             ? "dmabuf"
-             : (GDK_IS_GL_TEXTURE (self->texture)
-               ? "gl"
-               : "memory"),
-           GDK_IS_DMABUF_TEXTURE (self->texture)
-             ?  (char *) &gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (self->texture))->fourcc
-             : "",
-          gdk_memory_depth_get_name (gdk_memory_format_get_depth (gdk_texture_get_format (self->texture), FALSE)),
-          gdk_memory_format_get_name (gdk_texture_get_format (self->texture)),
-          gdk_color_state_get_name (gdk_texture_get_color_state (self->texture)));
-
-  if (!gdk_color_state_equal (gdk_texture_get_color_state (self->texture), self->download_cs))
-    {
-      GdkTextureDownloader *downloader;
-      GdkMemoryTextureBuilder *builder;
-      GBytes *bytes;
-      gsize stride;
-      GdkTexture *texture;
-
-      g_print ("converting rendered %s texture after download: %s -> %s\n",
-               GDK_IS_DMABUF_TEXTURE (self->texture) ? "dmabuf" :
-                 (GDK_IS_GL_TEXTURE (self->texture) ? "gl" : "memory"),
-               gdk_color_state_get_name (gdk_texture_get_color_state (self->texture)),
-               gdk_color_state_get_name (self->download_cs));
-      downloader = gdk_texture_downloader_new (self->texture);
-      gdk_texture_downloader_set_format (downloader, gdk_texture_get_format (self->texture));
-      gdk_texture_downloader_set_color_state (downloader, self->download_cs);
-      bytes = gdk_texture_downloader_download_bytes (downloader, &stride);
-
-      gdk_texture_downloader_free (downloader);
-
-      builder = gdk_memory_texture_builder_new ();
-      gdk_memory_texture_builder_set_bytes (builder, bytes);
-      gdk_memory_texture_builder_set_stride (builder, stride);
-      gdk_memory_texture_builder_set_width (builder, gdk_texture_get_width (self->texture));
-      gdk_memory_texture_builder_set_height (builder, gdk_texture_get_height (self->texture));
-      gdk_memory_texture_builder_set_format (builder, gdk_texture_get_format (self->texture));
-      gdk_memory_texture_builder_set_color_state (builder, self->download_cs);
-
-      texture = gdk_memory_texture_builder_build (builder);
-      g_object_unref (builder);
-
-      g_set_object (&self->texture, texture);
-
-      g_bytes_unref (bytes);
-      g_object_unref (texture);
-    }
-
   self->func (self->user_data, self->texture);
 
-  gdk_color_state_unref (self->image_cs);
-  gdk_color_state_unref (self->download_cs);
+  gdk_color_state_unref (self->color_state);
   g_object_unref (self->texture);
   g_object_unref (self->image);
   g_clear_object (&self->buffer);
@@ -124,7 +71,7 @@ gsk_gpu_download_op_print (GskGpuOp    *op,
 
   gsk_gpu_print_op (string, indent, "download");
   gsk_gpu_print_image (string, self->image);
-  gsk_gpu_print_string (string, gdk_color_state_get_name (self->download_cs));
+  gsk_gpu_print_string (string, gdk_color_state_get_name (self->color_state));
   gsk_gpu_print_newline (string);
 }
 
@@ -188,7 +135,7 @@ gsk_gpu_download_op_vk_create (GskGpuDownloadOp *self)
   gdk_memory_texture_builder_set_width (builder, width);
   gdk_memory_texture_builder_set_height (builder, height);
   gdk_memory_texture_builder_set_format (builder, format);
-  gdk_memory_texture_builder_set_color_state (builder, self->image_cs);
+  gdk_memory_texture_builder_set_color_state (builder, self->color_state);
 
   self->texture = gdk_memory_texture_builder_build (builder);
 
@@ -207,17 +154,7 @@ gsk_gpu_download_op_vk_command (GskGpuOp              *op,
 
 #ifdef HAVE_DMABUF
   if (self->allow_dmabuf)
-    {
-      GdkColorState *cs;
-
-      if (gsk_gpu_image_get_flags (self->image) & GSK_GPU_IMAGE_SRGB)
-        cs = GDK_COLOR_STATE_SRGB;
-      else
-        cs = self->image_cs;
-
-      self->texture = gsk_vulkan_image_to_dmabuf_texture (GSK_VULKAN_IMAGE (self->image), cs);
-    }
-
+    self->texture = gsk_vulkan_image_to_dmabuf_texture (GSK_VULKAN_IMAGE (self->image), self->color_state);
   if (self->texture)
     {
       GskGpuDevice *device = gsk_gpu_frame_get_device (frame);
@@ -368,16 +305,10 @@ gsk_gpu_download_op_gl_command (GskGpuOp          *op,
   GskGLTextureData *data;
   GdkGLContext *context;
   guint texture_id;
-  GdkColorState *cs;
 
   context = GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame));
   texture_id = gsk_gl_image_steal_texture (GSK_GL_IMAGE (self->image));
 
-  if (gsk_gpu_image_get_flags (self->image) & GSK_GPU_IMAGE_SRGB)
-    cs = GDK_COLOR_STATE_SRGB_LINEAR;
-  else
-    cs = self->image_cs;
-
 #ifdef HAVE_DMABUF
   if (self->allow_dmabuf)
     {
@@ -395,21 +326,14 @@ gsk_gpu_download_op_gl_command (GskGpuOp          *op,
           gdk_dmabuf_texture_builder_set_premultiplied (db, gdk_memory_format_get_premultiplied (gsk_gpu_image_get_format (self->image)));
           gdk_dmabuf_texture_builder_set_width (db, gsk_gpu_image_get_width (self->image));
           gdk_dmabuf_texture_builder_set_height (db, gsk_gpu_image_get_height (self->image));
+          gdk_dmabuf_texture_builder_set_color_state (db, self->color_state);
 
-          gdk_dmabuf_texture_builder_set_color_state (db, cs);
-          g_print ("dmabuf downloader color state: %s\n", gdk_color_state_get_name (gdk_dmabuf_texture_builder_get_color_state (db)));
-
-          self->texture = gdk_dmabuf_texture_builder_build (db,
-                                                            release_dmabuf_texture,
-                                                            texture,
-                                                            NULL);
+          self->texture = gdk_dmabuf_texture_builder_build (db, release_dmabuf_texture, texture, NULL);
 
           g_object_unref (db);
 
           if (self->texture)
             return op->next;
-          else
-            g_print ("failed to build dmabuf texture\n");
         }
 
       g_free (texture);
@@ -429,8 +353,8 @@ gsk_gpu_download_op_gl_command (GskGpuOp          *op,
   gdk_gl_texture_builder_set_format (builder, gsk_gpu_image_get_format (self->image));
   gdk_gl_texture_builder_set_width (builder, gsk_gpu_image_get_width (self->image));
   gdk_gl_texture_builder_set_height (builder, gsk_gpu_image_get_height (self->image));
+  gdk_gl_texture_builder_set_color_state (builder, self->color_state);
   gdk_gl_texture_builder_set_sync (builder, data->sync);
-  gdk_gl_texture_builder_set_color_state (builder, cs);
 
   self->texture = gdk_gl_texture_builder_build (builder,
                                                 gsk_gl_texture_data_free,
@@ -455,9 +379,8 @@ static const GskGpuOpClass GSK_GPU_DOWNLOAD_OP_CLASS = {
 void
 gsk_gpu_download_op (GskGpuFrame        *frame,
                      GskGpuImage        *image,
-                     GdkColorState      *image_cs,
-                     GdkColorState      *download_cs,
                      gboolean            allow_dmabuf,
+                     GdkColorState      *color_state,
                      GskGpuDownloadFunc  func,
                      gpointer            user_data)
 {
@@ -467,10 +390,37 @@ gsk_gpu_download_op (GskGpuFrame        *frame,
 
   self->image = g_object_ref (image);
   self->allow_dmabuf = allow_dmabuf;
-
-  self->image_cs = gdk_color_state_ref (image_cs);
-  self->download_cs = gdk_color_state_ref (download_cs);
-
+  self->color_state = gdk_color_state_ref (color_state);
   self->func = func,
   self->user_data = user_data;
 }
+
+static void
+gsk_gpu_download_save_png_cb (gpointer    filename,
+                              GdkTexture *texture)
+{
+  gdk_texture_save_to_png (texture, filename);
+
+  g_free (filename);
+}
+
+void
+gsk_gpu_download_png_op (GskGpuFrame *frame,
+                         GskGpuImage *image,
+                         const char  *filename_format,
+                         ...)
+{
+  va_list args;
+  char *filename;
+
+  va_start (args, filename_format);
+  filename = g_strdup_vprintf (filename_format, args);
+  va_end (args);
+
+  gsk_gpu_download_op (frame,
+                       image,
+                       FALSE,
+                       GDK_COLOR_STATE_SRGB,
+                       gsk_gpu_download_save_png_cb,
+                       filename);
+}

gsk/gpu/gskgpudownloadopprivate.h

@@ -9,11 +9,15 @@ typedef void            (* GskGpuDownloadFunc)                          (gpointe
 
 void                    gsk_gpu_download_op                             (GskGpuFrame                    *frame,
                                                                          GskGpuImage                    *image,
-                                                                         GdkColorState                  *image_cs,
-                                                                         GdkColorState                  *download_cs,
                                                                          gboolean                        allow_dmabuf,
+                                                                         GdkColorState                  *color_state,
                                                                          GskGpuDownloadFunc              func,
                                                                          gpointer                        user_data);
 
+void                    gsk_gpu_download_png_op                         (GskGpuFrame                    *frame,
+                                                                         GskGpuImage                    *image,
+                                                                         const char                     *filename_format,
+                                                                         ...) G_GNUC_PRINTF(3, 4);
+
 G_END_DECLS
 

gsk/gpu/gskgpuframe.c

@@ -671,20 +671,7 @@ gsk_gpu_frame_record (GskGpuFrame            *self,
     }
 
   if (texture)
-    {
-      GdkColorState *image_cs;
-      GdkColorState *download_cs;
-
-      image_cs = gdk_color_state_get_rendering_color_state (target_color_state,
-                                                            gsk_gpu_image_get_flags (target) & GSK_GPU_IMAGE_SRGB);
-
-      if (image_cs == GDK_COLOR_STATE_SRGB_LINEAR)
-        download_cs = GDK_COLOR_STATE_SRGB;
-      else
-        download_cs = image_cs;
-
-      gsk_gpu_download_op (self, target, target_color_state, download_cs, TRUE, copy_texture, texture);
-    }
+    gsk_gpu_download_op (self, target, TRUE, target_color_state, copy_texture, texture);
 }
 
 static void
@@ -791,9 +778,8 @@ gsk_gpu_frame_download_texture (GskGpuFrame     *self,
 
   gsk_gpu_download_op (self,
                        image,
-                       gdk_texture_get_color_state (texture),
-                       color_state,
                        FALSE,
+                       color_state,
                        do_download,
                        g_memdup (&(Download) {
                            .format = format,

gsk/gpu/gskgpunodeprocessor.c

@@ -620,18 +620,15 @@ gsk_gpu_copy_image (GskGpuFrame   *frame,
   GskGpuImage *copy;
   gsize width, height;
   GskGpuImageFlags flags;
-  GdkMemoryDepth depth;
 
   width = gsk_gpu_image_get_width (image);
   height = gsk_gpu_image_get_height (image);
   flags = gsk_gpu_image_get_flags (image);
-  depth = gdk_memory_format_get_depth (gsk_gpu_image_get_format (image),
-                                       flags & GSK_GPU_IMAGE_SRGB);
-  depth = gdk_memory_depth_merge (depth, gdk_color_state_get_depth (ccs));
 
   copy = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                 prepare_mipmap,
-                                                depth,
+                                                gdk_memory_format_get_depth (gsk_gpu_image_get_format (image),
+                                                                             flags & GSK_GPU_IMAGE_SRGB),
                                                 width, height);
 
   if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_BLIT) &&
@@ -1584,18 +1581,10 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
         }
 
       gdk_color_to_float (gsk_color_node_get_color2 (node), self->ccs, clear_color);
-      g_print ("node processor: add color via clear %s -> %s %f %f %f %f\n",
-               gdk_color_to_string (gsk_color_node_get_color2 (node)),
-               gdk_color_state_get_name (self->ccs),
-               clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
       gsk_gpu_clear_op (self->frame, &int_clipped, clear_color);
       return;
     }
 
-  g_print ("node processor: add color %s -> %s\n",
-           gdk_color_to_string (gsk_color_node_get_color2 (node)),
-           gdk_color_state_get_name (self->ccs));
-
   gsk_gpu_color_op (self->frame,
                     gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
                     self->ccs,
@@ -1623,10 +1612,6 @@ gsk_gpu_node_processor_add_first_color_node (GskGpuNodeProcessor         *self,
     return FALSE;
 
   gdk_color_to_float (gsk_color_node_get_color2 (node), self->ccs, clear_color);
-  g_print ("node processor: add first color %s -> %s %f %f %f %f\n",
-           gdk_color_to_string (gsk_color_node_get_color2 (node)),
-           gdk_color_state_get_name (self->ccs),
-           clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
   gsk_gpu_render_pass_begin_op (self->frame,
                                 target,
                                 clip,
@@ -3917,9 +3902,7 @@ gsk_gpu_node_processor_process (GskGpuFrame                 *frame,
                                clip,
                                viewport);
 
-  ccs = gdk_color_state_get_rendering_color_state (target_color_state, gsk_gpu_image_get_flags (target) & GSK_GPU_IMAGE_SRGB);
-
-  g_print ("node processor: rendering color state %s\n", gdk_color_state_get_name (ccs));
+  ccs = gdk_color_state_get_rendering_color_state (target_color_state);
 
   if (gdk_color_state_equal (ccs, target_color_state))
     {

gsk/gpu/gskgpurenderer.c

@@ -299,7 +299,10 @@ gsk_gpu_renderer_fallback_render_texture (GskGpuRenderer        *self,
                                                           MIN (image_width, width - x),
                                                           MIN (image_height, height - y));
 
-          color_state = GDK_COLOR_STATE_SRGB;
+          if (gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB)
+            color_state = GDK_COLOR_STATE_SRGB_LINEAR;
+          else
+            color_state = GDK_COLOR_STATE_SRGB;
 
           frame = gsk_gpu_renderer_create_frame (self);
           gsk_gpu_frame_render (frame,
@@ -376,8 +379,11 @@ gsk_gpu_renderer_render_texture (GskRenderer           *renderer,
   if (image == NULL)
     return gsk_gpu_renderer_fallback_render_texture (self, root, &rounded_viewport);
 
-  g_print ("render_texture: image depth %s, target color state %s\n",
-           gdk_memory_depth_get_name (depth), gdk_color_state_get_name (color_state));
+  if (gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB)
+    {
+      g_assert (gdk_color_state_equal (color_state, GDK_COLOR_STATE_SRGB));
+      color_state = GDK_COLOR_STATE_SRGB_LINEAR;
+    }
 
   frame = gsk_gpu_renderer_create_frame (self);
 

gsk/gpu/gskvulkanimage.c

@@ -1227,12 +1227,11 @@ gsk_vulkan_image_to_dmabuf_texture (GskVulkanImage *self,
   gdk_dmabuf_texture_builder_set_display (builder, gsk_gpu_device_get_display (GSK_GPU_DEVICE (self->device)));
   gdk_dmabuf_texture_builder_set_width (builder, gsk_gpu_image_get_width (image));
   gdk_dmabuf_texture_builder_set_height (builder, gsk_gpu_image_get_height (image));
-  gdk_dmabuf_texture_builder_set_color_state (builder, color_state);
   gdk_dmabuf_texture_builder_set_fourcc (builder, fourcc);
   gdk_dmabuf_texture_builder_set_modifier (builder, properties.drmFormatModifier);
   gdk_dmabuf_texture_builder_set_premultiplied (builder, !(gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_STRAIGHT_ALPHA));
   gdk_dmabuf_texture_builder_set_n_planes (builder, n_planes);
-  
+
   for (plane = 0; plane < n_planes; plane++)
     {
       static const VkImageAspectFlagBits aspect[GDK_DMABUF_MAX_PLANES] = {
@@ -1254,6 +1253,9 @@ gsk_vulkan_image_to_dmabuf_texture (GskVulkanImage *self,
       gdk_dmabuf_texture_builder_set_offset (builder, plane, layout.offset);
     }
 
+  if (color_state)
+    gdk_dmabuf_texture_builder_set_color_state (builder, color_state);
+
   texture = gdk_dmabuf_texture_builder_build (builder, close_the_fd, GINT_TO_POINTER (fd), &error);
   g_object_unref (builder);
   if (texture == NULL)

gsk/gskrendernode.c

@@ -380,7 +380,7 @@ gsk_render_node_draw_ccs (GskRenderNode *node,
                           GdkColorState *ccs)
 {
   /* Check that the calling function did pass a correct color state */
-  g_assert (ccs == gdk_color_state_get_rendering_color_state (ccs, FALSE));
+  g_assert (ccs == gdk_color_state_get_rendering_color_state (ccs));
 
   cairo_save (cr);
 
@@ -413,7 +413,7 @@ gsk_render_node_draw_with_color_state (GskRenderNode *node,
 {
   GdkColorState *ccs;
 
-  ccs = gdk_color_state_get_rendering_color_state (color_state, FALSE);
+  ccs = gdk_color_state_get_rendering_color_state (color_state);
 
   if (gdk_color_state_equal (color_state, ccs))
     {

gsk/gskrendernodeimpl.c

@@ -94,12 +94,8 @@ my_color_stops_get_depth (const GskColorStop *stops,
 static inline gboolean
 color_state_is_hdr (GdkColorState *color_state)
 {
-  GdkColorState *rendering_cs;
-
-  rendering_cs = gdk_color_state_get_rendering_color_state (color_state, FALSE);
-
-  return rendering_cs != GDK_COLOR_STATE_SRGB &&
-         rendering_cs != GDK_COLOR_STATE_SRGB_LINEAR;
+  return color_state != GDK_COLOR_STATE_SRGB &&
+         color_state != GDK_COLOR_STATE_SRGB_LINEAR;
 }
 
 /* apply a rectangle that bounds @rect in

gtk/gtkcolorpickerwin32.c

@@ -222,7 +222,6 @@ gtk_color_picker_win32_pick (GtkColorPicker      *cp,
                                G_IO_ERROR,
                                G_IO_ERROR_FAILED,
                                "Cannot capture the mouse pointer");
-      g_object_unref (picker->task);
       return;
     }
 

gtk/gtkfilelauncher.c

@@ -485,7 +485,6 @@ gtk_file_launcher_launch (GtkFileLauncher     *self,
       g_task_return_new_error (task,
                                GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_FAILED,
                                "No file to launch");
-      g_object_unref (task);
       return;
     }
 
@@ -577,7 +576,6 @@ gtk_file_launcher_open_containing_folder (GtkFileLauncher     *self,
       g_task_return_new_error (task,
                                GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_FAILED,
                                "No file to open");
-      g_object_unref (task);
       return;
     }
 
@@ -586,7 +584,6 @@ gtk_file_launcher_open_containing_folder (GtkFileLauncher     *self,
       g_task_return_new_error (task,
                                GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_FAILED,
                                "Operation not supported on non-native files");
-      g_object_unref (task);
       return;
     }
 

gtk/gtkurilauncher.c

@@ -292,7 +292,6 @@ gtk_uri_launcher_launch (GtkUriLauncher      *self,
       g_task_return_new_error (task,
                                GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_FAILED,
                                "No uri to launch");
-      g_object_unref (task);
       return;
     }
 
@@ -302,7 +301,6 @@ gtk_uri_launcher_launch (GtkUriLauncher      *self,
                                GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_FAILED,
                                "%s is not a valid uri: %s", self->uri, error->message);
       g_error_free (error);
-      g_object_unref (task);
       return;
     }
 

testsuite/css/parser/meson.build

@@ -128,7 +128,6 @@ test_data = [
   'at-valid-16.errors',
   'at-valid-16.ref.css',
   'at-valid-17.css',
-  'at-valid-17.errors',
   'at-valid-18.css',
   'at-valid-18.ref.css',
   'background-blend-mode.css',
@@ -148,7 +147,6 @@ test_data = [
   'background-repeat.css',
   'background-repeat.ref.css',
   'background-shorthand.css',
-  'background-shorthand.errors',
   'background-shorthand.ref.css',
   'background-shorthand-single.css',
   'background-shorthand-single.ref.css',
@@ -209,7 +207,6 @@ test_data = [
   'close-at-end-of-file.errors',
   'close-at-end-of-file.ref.css',
   'color.css',
-  'color.errors',
   'color.ref.css',
   'colors-errors.css',
   'colors-errors.errors',
@@ -232,8 +229,6 @@ test_data = [
   'css-21-malformed-statements.errors',
   'css-21-malformed-statements.ref.css',
   'currentcolor-everywhere.css',
-  'currentcolor-everywhere.ref.css',
-  'currentcolor-everywhere.errors',
   'dash-backslash-eof-is-identifier.ref.css',
   'dash-backslash-eof-is-identifier.css',
   'dash-backslash-eof-is-identifier.errors',
@@ -291,7 +286,6 @@ test_data = [
   'declarations-valid-08.css',
   'declarations-valid-08.ref.css',
   'declarations-valid-09.css',
-  'declarations-valid-09.errors',
   'declarations-valid-09.ref.css',
   'declarations-valid-10.css',
   'declarations-valid-10.ref.css',
@@ -499,7 +493,6 @@ test_data = [
   'selector-original.css',
   'selector-original.ref.css',
   'shadow.css',
-  'shadow.errors',
   'shadow.ref.css',
   'shadow-ordering.css',
   'shadow-ordering.ref.css',

testsuite/gdk/colorstate-internal.c

@@ -1,7 +1,6 @@
-#include <gtk.h>
+#include <gdk/gdk.h>
 #include "gdkcolorstateprivate.h"
 #include "gdkcolorprivate.h"
-#include "gdkdebugprivate.h"
 #include <math.h>
 
 #include "gdkcolordefs.h"
@@ -159,88 +158,9 @@ test_color_mislabel (void)
   g_assert_true (red1 != red2);
 }
 
-static void
-test_rendering_colorstate (void)
-{
-  struct {
-    GdkColorState *surface;
-    gboolean srgb;
-    GdkColorState *rendering;
-  } tests[] = {
-    { GDK_COLOR_STATE_SRGB,           0, GDK_COLOR_STATE_SRGB           },
-    { GDK_COLOR_STATE_SRGB,           1, GDK_COLOR_STATE_SRGB_LINEAR    },
-    { GDK_COLOR_STATE_SRGB_LINEAR,    0, GDK_COLOR_STATE_SRGB_LINEAR    },
-    { GDK_COLOR_STATE_SRGB_LINEAR,    1, GDK_COLOR_STATE_SRGB_LINEAR    },
-    { GDK_COLOR_STATE_REC2100_PQ,     0, GDK_COLOR_STATE_REC2100_PQ     },
-    { GDK_COLOR_STATE_REC2100_PQ,     1, GDK_COLOR_STATE_SRGB_LINEAR    },
-    { GDK_COLOR_STATE_REC2100_LINEAR, 0, GDK_COLOR_STATE_REC2100_LINEAR },
-    { GDK_COLOR_STATE_REC2100_LINEAR, 1, GDK_COLOR_STATE_SRGB_LINEAR    },
-  };
-
-  if (GDK_DEBUG_CHECK (HDR) || GDK_DEBUG_CHECK (LINEAR))
-    {
-      g_test_skip ("Skip because GDK_DEBUG flags hdr or linear are set");
-      return;
-    }
-
-  for (int i = 0; i < G_N_ELEMENTS (tests); i++)
-    {
-      GdkColorState *res = gdk_color_state_get_rendering_color_state (tests[i].surface, tests[i].srgb);
-
-      g_assert_true (gdk_color_state_equal (res, tests[i].rendering));
-    }
-}
-
-static void
-test_color_conversion (void)
-{
-  GdkColor color;
-  GdkColor color2;
-  GdkColor color3;
-
-  gdk_color_init (&color, GDK_COLOR_STATE_REC2100_PQ, (float[4]) { 0, 0.5, 1, 1 });
-  gdk_color_convert (&color2, GDK_COLOR_STATE_REC2100_LINEAR, &color);
-
-  g_assert_cmpfloat_with_epsilon (0,     color2.values[0], 0.005);
-  g_assert_cmpfloat_with_epsilon (0.45,  color2.values[1], 0.005);
-  g_assert_cmpfloat_with_epsilon (49.26, color2.values[2], 0.005);
-  g_assert_cmpfloat_with_epsilon (1,     color2.values[3], 0.005);
-
-  gdk_color_convert (&color3, GDK_COLOR_STATE_REC2100_PQ, &color2);
-
-  g_assert_cmpfloat_with_epsilon (color3.values[0], color.values[0], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[1], color.values[1], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[2], color.values[2], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[3], color.values[3], 0.005);
-
-  gdk_color_finish (&color);
-  gdk_color_finish (&color2);
-  gdk_color_finish (&color3);
-
-  gdk_color_init (&color, GDK_COLOR_STATE_SRGB, (float[4]) { 0, 0.5, 1, 1 });
-  gdk_color_convert (&color2, GDK_COLOR_STATE_REC2100_LINEAR, &color);
-
-  g_assert_cmpfloat_with_epsilon (0.114, color2.values[0], 0.005);
-  g_assert_cmpfloat_with_epsilon (0.208, color2.values[1], 0.005);
-  g_assert_cmpfloat_with_epsilon (0.914, color2.values[2], 0.005);
-  g_assert_cmpfloat_with_epsilon (1,     color2.values[3], 0.005);
-
-  gdk_color_convert (&color3, GDK_COLOR_STATE_SRGB, &color2);
-
-  g_assert_cmpfloat_with_epsilon (color3.values[0], color.values[0], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[1], color.values[1], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[2], color.values[2], 0.005);
-  g_assert_cmpfloat_with_epsilon (color3.values[3], color.values[3], 0.005);
-
-  gdk_color_finish (&color);
-  gdk_color_finish (&color2);
-  gdk_color_finish (&color3);
-}
-
 int
 main (int argc, char *argv[])
 {
-  gtk_init ();
   (g_test_init) (&argc, &argv, NULL);
 
   for (guint i = 0; i < G_N_ELEMENTS (transfers); i++)
@@ -261,10 +181,7 @@ main (int argc, char *argv[])
 
   g_test_add_func ("/colorstate/matrix/srgb_to_rec2020", test_srgb_to_rec2020);
   g_test_add_func ("/colorstate/matrix/rec2020_to_srgb", test_rec2020_to_srgb);
-  g_test_add_func ("/colorstate/rendering", test_rendering_colorstate);
   g_test_add_func ("/color/mislabel", test_color_mislabel);
-  g_test_add_func ("/color/conversion", test_color_conversion);
 
   return g_test_run ();
 }
-

testsuite/gsk/compare/color-pq-transparency.node

@@ -1,4 +0,0 @@
-color {
-  bounds: 0 0 50 50;
-  color: color(rec2100-pq 1 0 0 / 0.2);
-}

testsuite/gsk/meson.build

@@ -46,7 +46,6 @@ compare_render_tests = [
   'color-matrix-identity',
   'color-matrix-merge',
   'color-matrix-parsing',
-  'color-pq-transparency',
   'color-states',
   'conic-gradient-with-64-colorstops',
   'container-single-child-offscreen-for-opacity',
@@ -531,7 +530,6 @@ tests = [
   [ 'path', [ 'path-utils.c' ], [ 'flaky'] ],
   [ 'path-special-cases' ],
   [ 'scaling' ],
-  [ 'rendertexture' ],
 ]
 
 test_cargs = []

testsuite/gsk/rendertexture.c

@@ -1,191 +0,0 @@
-#include <gtk/gtk.h>
-
-enum {
-  GDK_COLOR_STATE_SRGB,
-  GDK_COLOR_STATE_SRGB_LINEAR,
-  GDK_COLOR_STATE_REC2100_PQ,
-  GDK_COLOR_STATE_REC2100_LINEAR,
-};
-
-typedef struct {
-  const char *renderer;
-  const char *debug;
-  gboolean hdr_content;
-  guint expected;
-} TextureTest;
-
-static TextureTest tests[] = {
-  { "ngl",    "",           0, GDK_COLOR_STATE_SRGB           },
-  { "ngl",    "",           1, GDK_COLOR_STATE_REC2100_PQ     },
-  { "ngl",    "linear",     0, GDK_COLOR_STATE_SRGB           },
-  { "ngl",    "linear",     1, GDK_COLOR_STATE_REC2100_LINEAR },
-  { "ngl",    "hdr",        0, GDK_COLOR_STATE_REC2100_PQ     },
-  { "ngl",    "hdr",        1, GDK_COLOR_STATE_REC2100_PQ     },
-  { "ngl",    "hdr:linear", 0, GDK_COLOR_STATE_REC2100_LINEAR },
-  { "ngl",    "hdr:linear", 1, GDK_COLOR_STATE_REC2100_LINEAR },
-  { "vulkan", "",           0, GDK_COLOR_STATE_SRGB           },
-  { "vulkan", "",           1, GDK_COLOR_STATE_REC2100_PQ     },
-  { "vulkan", "linear",     0, GDK_COLOR_STATE_SRGB           },
-  { "vulkan", "linear",     1, GDK_COLOR_STATE_REC2100_LINEAR },
-  { "vulkan", "hdr",        0, GDK_COLOR_STATE_REC2100_PQ     },
-  { "vulkan", "hdr",        1, GDK_COLOR_STATE_REC2100_PQ     },
-  { "vulkan", "hdr:linear", 0, GDK_COLOR_STATE_REC2100_LINEAR },
-  { "vulkan", "hdr:linear", 1, GDK_COLOR_STATE_REC2100_LINEAR },
-};
-
-static GdkColorState *
-get_color_state (guint id)
-{
-  switch (id)
-    {
-    case GDK_COLOR_STATE_SRGB:           return gdk_color_state_get_srgb ();
-    case GDK_COLOR_STATE_SRGB_LINEAR:    return gdk_color_state_get_srgb_linear ();
-    case GDK_COLOR_STATE_REC2100_PQ:     return gdk_color_state_get_rec2100_pq ();
-    case GDK_COLOR_STATE_REC2100_LINEAR: return gdk_color_state_get_rec2100_linear ();
-    default:                             g_assert_not_reached ();
-    }
-}
-
-static const char *
-color_state_name (GdkColorState *cs)
-{
-  if (cs == gdk_color_state_get_srgb ())
-    return "srgb";
-  else if (cs == gdk_color_state_get_srgb_linear ())
-    return "srgb-linear";
-  else if (cs == gdk_color_state_get_rec2100_pq ())
-    return "rec2100-pq";
-  else if (cs == gdk_color_state_get_rec2100_linear ())
-    return "rec2100-linear";
-  else
-    return "???";
-}
-
-static void
-test_render_texture (gconstpointer testdata)
-{
-  const TextureTest *test = testdata;
-
-  if (g_test_subprocess ())
-    {
-      GError *error = NULL;
-      const char *text;
-      GBytes *bytes;
-      GskRenderNode *node;
-      GskRenderer *renderer;
-      GdkTexture *texture;
-      GdkTextureDownloader *downloader;
-      GdkColorState *expected = get_color_state (test->expected);
-
-      gtk_init ();
-
-      text = test->hdr_content
-             ? "color { color: color(rec2100-pq 1 0.5 0); }"
-             : "color { color: color(srgb 0 0.5 1); }";
-
-      bytes = g_bytes_new_static (text, strlen (text));
-      node = gsk_render_node_deserialize (bytes, NULL, NULL);
-      g_bytes_unref (bytes);
-
-      g_assert_nonnull (node);
-
-      if (strcmp (test->renderer, "ngl") == 0)
-        renderer = gsk_ngl_renderer_new ();
-      else if (strcmp (test->renderer, "vulkan") == 0)
-        renderer = gsk_vulkan_renderer_new ();
-      else
-        g_assert_not_reached ();
-
-      gsk_renderer_realize_for_display (renderer, gdk_display_get_default (), &error);
-      g_assert_no_error (error);
-
-      texture = gsk_renderer_render_texture (renderer, node, &GRAPHENE_RECT_INIT (0, 0, 1, 1));
-
-      if (!gdk_color_state_equal (expected, gdk_texture_get_color_state (texture)))
-        {
-          g_print ("test: expected %s, got %s\n",
-                    color_state_name (expected),
-                    color_state_name (gdk_texture_get_color_state (texture)));
-          exit (1);
-        }
-      else
-        {
-          g_print ("test: got color state %s\n",
-                   color_state_name (gdk_texture_get_color_state (texture)));
-        }
-
-      g_assert_true (gdk_texture_get_width (texture) == 1);
-      g_assert_true (gdk_texture_get_height (texture) == 1);
-
-      downloader = gdk_texture_downloader_new (texture);
-      gdk_texture_downloader_set_format (downloader, GDK_MEMORY_R32G32B32A32_FLOAT);
-
-       /* Convert the data to the colorstate we used in the node */
-      if (test->hdr_content)
-        gdk_texture_downloader_set_color_state (downloader, gdk_color_state_get_rec2100_pq ());
-      else
-        gdk_texture_downloader_set_color_state (downloader, gdk_color_state_get_srgb ());
-
-      float data[4];
-      gdk_texture_downloader_download_into (downloader, (guchar *) data, 4 * sizeof (float));
-
-      gdk_texture_downloader_free (downloader);
-
-      g_print ("test: got %s content: %f %f %f %f\n",
-               test->hdr_content ? "rec2100-pq" : "srgb",
-               data[0], data[1], data[2], data[3]);
-
-      if (test->hdr_content)
-        {
-          g_assert_cmpfloat_with_epsilon (data[0], 1, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[1], 0.5, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[2], 0, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[3], 1, 0.005);
-        }
-      else
-        {
-          g_assert_cmpfloat_with_epsilon (data[0], 0, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[1], 0.5, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[2], 1, 0.005);
-          g_assert_cmpfloat_with_epsilon (data[3], 1, 0.005);
-        }
-
-      gsk_render_node_unref (node);
-      gsk_renderer_unrealize (renderer);
-      g_object_unref (renderer);
-
-      return;
-   }
-
-  char **envp = g_get_environ ();
-  const char *str = g_getenv ("GDK_DEBUG") ? g_getenv ("GDK_DEBUG") : "";
-  char *str2 = g_strconcat (test->debug, test->debug[0] && str[0] ? ":" : "", str, NULL);
-  envp = g_environ_setenv (g_steal_pointer (&envp), "GDK_DEBUG", str2, TRUE);
-  g_free (str2);
-
-  g_test_trap_subprocess_with_envp (NULL, (const char * const *) envp, 0, G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR);
-  if (!g_test_trap_has_passed ())
-    g_test_fail ();
-}
-
-int
-main (int argc, char *argv[])
-{
-  gtk_init ();
-  g_test_init (&argc, &argv, NULL);
-
-  for (int i = 0; i < G_N_ELEMENTS (tests); i++)
-    {
-      TextureTest *test = &tests[i];
-      char *path;
-
-      path = g_strconcat ("/rendertexture",
-                          "/renderer:", test->renderer,
-                          "/content:", test->hdr_content ? "hdr" : "sdr",
-                          "/flags:", test->debug[0] ? test->debug : "none", NULL);
-      g_test_add_data_func (path, test, test_render_texture);
-      g_free (path);
-    }
-
-  return g_test_run ();
-}