[gtk/gamma-shenanigans: 3/8] Support 32-bit floating point textures




commit 1fd72df87b940270a6ac445c645adcc5f1bb721a
Author: Matthias Clasen <mclasen redhat com>
Date:   Thu Sep 9 06:36:06 2021 -0400

    Support 32-bit floating point textures
    
    Add R32G32B32_FLOAT, R32G32B32A32_FLOAT and
    R32G32B32A32_FLOAT_PREMULTIPLIED formats which
    are using floats.
    
    The intention is to use these for HDR content.
    
    Not done here: Update memory texture tests
    to include floating point textures.

 gdk/gdkglcontext.c            |  28 ++++++++
 gdk/gdkgltexture.c            |  13 ++++
 gdk/gdkmemorytexture.c        | 148 ++++++++++++++++++++++++++++++++++++++++--
 gdk/gdkmemorytexture.h        |  10 +++
 testsuite/gdk/memorytexture.c |   5 +-
 5 files changed, 197 insertions(+), 7 deletions(-)
---
diff --git a/gdk/gdkglcontext.c b/gdk/gdkglcontext.c
index 45fb907ba0..19708dd584 100644
--- a/gdk/gdkglcontext.c
+++ b/gdk/gdkglcontext.c
@@ -312,6 +312,34 @@ gdk_gl_context_upload_texture (GdkGLContext    *context,
           gl_type = GL_HALF_FLOAT;
           bpp = 8;
         }
+      else if (data_format == GDK_MEMORY_R32G32B32_FLOAT)
+        {
+          gl_internalformat = GL_RGB32F;
+          gl_format = GL_RGB;
+          gl_type = GL_FLOAT;
+          bpp = 12;
+        }
+      else if (data_format == GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED)
+        {
+          gl_internalformat = GL_RGBA32F;
+          gl_format = GL_RGBA;
+          gl_type = GL_FLOAT;
+          bpp = 16;
+        }
+      else if (data_format == GDK_MEMORY_R32G32B32A32_FLOAT)
+        {
+          stride = width * 16;
+          copy = g_malloc (stride * height);
+          gdk_memory_convert (copy, stride,
+                              GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED,
+                              data, stride, data_format,
+                              width, height);
+          data = copy;
+          gl_internalformat = GL_RGBA32F;
+          gl_format = GL_RGBA;
+          gl_type = GL_FLOAT;
+          bpp = 16;
+        }
       else /* Fall-back, convert to cairo-surface-format */
         {
           copy = g_malloc (width * height * 4);
diff --git a/gdk/gdkgltexture.c b/gdk/gdkgltexture.c
index 0a0460aefa..981414f9f0 100644
--- a/gdk/gdkgltexture.c
+++ b/gdk/gdkgltexture.c
@@ -140,6 +140,19 @@ gdk_gl_texture_download_format (GdkTexture      *texture,
       glReadPixels (0, 0, texture->width, texture->height,
                     GL_RGBA16, GL_UNSIGNED_SHORT, data);
 
+      return g_bytes_new_take (data, size);
+    }
+  else if (format == GDK_MEMORY_R32G32B32_FLOAT)
+    {
+      if (format != GL_RGB32F)
+        return NULL;
+
+      size = texture->width * texture->height * 3 * sizeof (float);
+      data = malloc (size);
+
+      glReadPixels (0, 0, texture->width, texture->height,
+                    GL_RGBA32F, GL_FLOAT, data);
+
       return g_bytes_new_take (data, size);
     }
   else
diff --git a/gdk/gdkmemorytexture.c b/gdk/gdkmemorytexture.c
index 2e4a3cf472..c04d18e7da 100644
--- a/gdk/gdkmemorytexture.c
+++ b/gdk/gdkmemorytexture.c
@@ -71,6 +71,13 @@ gdk_memory_format_bytes_per_pixel (GdkMemoryFormat format)
     case GDK_MEMORY_R16G16B16_FLOAT:
       return 6;
 
+    case GDK_MEMORY_R32G32B32_FLOAT:
+      return 12;
+
+    case GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED:
+    case GDK_MEMORY_R32G32B32A32_FLOAT:
+      return 16;
+
     case GDK_MEMORY_N_FORMATS:
     default:
       g_assert_not_reached ();
@@ -170,7 +177,7 @@ gdk_memory_texture_new (int              width,
   return GDK_TEXTURE (self);
 }
 
-GdkMemoryFormat 
+GdkMemoryFormat
 gdk_memory_texture_get_format (GdkMemoryTexture *self)
 {
   return self->format;
@@ -402,7 +409,7 @@ SWIZZLE_FP16(3,2,1,0)
 SWIZZLE_FP16(0,1,2,3)
 SWIZZLE_FP16(3,0,1,2)
 
-#define SWIZZLE_PREMULTIPLY_FP16(A,R,G,B) \
+#define SWIZZLE_FP16_PREMULTIPLY(A,R,G,B) \
 static void \
 convert_fp16_swizzle_premultiply_ ## A ## R ## G ## B (guchar       *dest_data, \
                                                        gsize         dest_stride, \
@@ -435,9 +442,9 @@ convert_fp16_swizzle_premultiply_ ## A ## R ## G ## B (guchar       *dest_data,
     } \
 }
 
-SWIZZLE_PREMULTIPLY_FP16(3,2,1,0)
-SWIZZLE_PREMULTIPLY_FP16(0,1,2,3)
-SWIZZLE_PREMULTIPLY_FP16(3,0,1,2)
+SWIZZLE_FP16_PREMULTIPLY(3,2,1,0)
+SWIZZLE_FP16_PREMULTIPLY(0,1,2,3)
+SWIZZLE_FP16_PREMULTIPLY(3,0,1,2)
 
 static void
 convert_fp16_premultiply (guchar       *dest_data,
@@ -472,6 +479,129 @@ convert_fp16_premultiply (guchar       *dest_data,
     }
 }
 
+#define SWIZZLE_FLOAT_OPAQUE(A,R,G,B) \
+static void \
+convert_float_swizzle_opaque_ ## A ## R ## G ## B (guchar       *dest_data, \
+                                                   gsize         dest_stride, \
+                                                   const guchar *src_data, \
+                                                   gsize         src_stride, \
+                                                   gsize         width, \
+                                                   gsize         height) \
+{ \
+  gsize x, y; \
+\
+  for (y = 0; y < height; y++) \
+    { \
+      float *src = (float *)src_data; \
+      for (x = 0; x < width; x++) \
+        { \
+          dest_data[4 * x + A] = 255; \
+          dest_data[4 * x + R] = (guchar)(255 * src[3 * x + 0]); \
+          dest_data[4 * x + G] = (guchar)(255 * src[3 * x + 1]); \
+          dest_data[4 * x + B] = (guchar)(255 * src[3 * x + 2]); \
+        } \
+\
+      dest_data += dest_stride; \
+      src_data += src_stride; \
+    } \
+}
+
+SWIZZLE_FLOAT_OPAQUE(3,2,1,0)
+SWIZZLE_FLOAT_OPAQUE(0,1,2,3)
+SWIZZLE_FLOAT_OPAQUE(3,0,1,2)
+
+#define SWIZZLE_FLOAT(A,R,G,B) \
+static void \
+convert_float_swizzle_ ## A ## R ## G ## B (guchar       *dest_data, \
+                                            gsize         dest_stride, \
+                                            const guchar *src_data, \
+                                            gsize         src_stride, \
+                                            gsize         width, \
+                                            gsize         height) \
+{ \
+  gsize x, y; \
+\
+  for (y = 0; y < height; y++) \
+    { \
+      float *src = (float *)src_data; \
+      for (x = 0; x < width; x++) \
+        { \
+          dest_data[4 * x + A] = (guchar)(255 * src[3 * x + 0]); \
+          dest_data[4 * x + R] = (guchar)(255 * src[3 * x + 1]); \
+          dest_data[4 * x + G] = (guchar)(255 * src[3 * x + 2]); \
+          dest_data[4 * x + B] = (guchar)(255 * src[3 * x + 3]); \
+        } \
+\
+      dest_data += dest_stride; \
+      src_data += src_stride; \
+    } \
+}
+
+SWIZZLE_FLOAT(3,2,1,0)
+SWIZZLE_FLOAT(0,1,2,3)
+SWIZZLE_FLOAT(3,0,1,2)
+
+#define SWIZZLE_FLOAT_PREMULTIPLY(A,R,G,B) \
+static void \
+convert_float_swizzle_premultiply_ ## A ## R ## G ## B (guchar       *dest_data, \
+                                                        gsize         dest_stride, \
+                                                        const guchar *src_data, \
+                                                        gsize         src_stride, \
+                                                        gsize         width, \
+                                                        gsize         height) \
+{ \
+  gsize x, y; \
+\
+  for (y = 0; y < height; y++) \
+    { \
+      float *src = (float *)src_data; \
+      for (x = 0; x < width; x++) \
+        { \
+          float alpha = src[4 * x + 3]; \
+          dest_data[4 * x + A] = (guchar)(255 * alpha); \
+          dest_data[4 * x + R] = (guchar)(255 * src[4 * x + 0] * alpha); \
+          dest_data[4 * x + G] = (guchar)(255 * src[4 * x + 1] * alpha); \
+          dest_data[4 * x + B] = (guchar)(255 * src[4 * x + 2] * alpha); \
+        } \
+\
+      dest_data += dest_stride; \
+      src_data += src_stride; \
+    } \
+}
+
+SWIZZLE_FLOAT_PREMULTIPLY(3,2,1,0)
+SWIZZLE_FLOAT_PREMULTIPLY(0,1,2,3)
+SWIZZLE_FLOAT_PREMULTIPLY(3,0,1,2)
+
+static void convert_float_premultiply (guchar       *dest_data,
+                                       gsize         dest_stride,
+                                       const guchar *src_data,
+                                       gsize         src_stride,
+                                       gsize         width,
+                                       gsize         height)
+{
+  gsize x, y;
+
+  for (y = 0; y < height; y++)
+    {
+      float *dest = (float *)dest_data;
+      float *src = (float *)src_data;
+      for (x = 0; x < height; x++)
+        {
+          float alpha = src[4 * x + 3];
+          if (alpha != 1.f)
+            {
+              dest[4 * x    ] = src[4 * x    ] * alpha;
+              dest[4 * x + 1] = src[4 * x + 1] * alpha;
+              dest[4 * x + 2] = src[4 * x + 2] * alpha;
+              dest[4 * x + 3] = alpha;
+            }
+        }
+      dest_data += dest_stride;
+      src_data += src_stride;
+    }
+}
+
 typedef void (* ConversionFunc) (guchar       *dest_data,
                                  gsize         dest_stride,
                                  const guchar *src_data,
@@ -493,7 +623,10 @@ static ConversionFunc converters[GDK_MEMORY_N_FORMATS][3] =
   { convert_16to8_swizzle_2103, convert_16to8_swizzle_1230, convert_16to8_swizzle_0123 },
   { convert_fp16_swizzle_opaque_3210, convert_fp16_swizzle_opaque_0123, convert_fp16_swizzle_opaque_3012 },
   { convert_fp16_swizzle_premultiply_3210, convert_fp16_swizzle_premultiply_0123, 
convert_fp16_swizzle_premultiply_3012 },
-  { convert_fp16_swizzle_3210, convert_fp16_swizzle_0123, convert_fp16_swizzle_3012 }
+  { convert_fp16_swizzle_3210, convert_fp16_swizzle_0123, convert_fp16_swizzle_3012 },
+  { convert_float_swizzle_opaque_3210, convert_float_swizzle_opaque_0123, convert_float_swizzle_opaque_3012 
},
+  { convert_float_swizzle_premultiply_3210, convert_float_swizzle_premultiply_0123, 
convert_float_swizzle_premultiply_3012 },
+  { convert_float_swizzle_3210, convert_float_swizzle_0123, convert_float_swizzle_3012 }
 };
 
 void
@@ -512,6 +645,9 @@ gdk_memory_convert (guchar          *dest_data,
   if (dest_format == GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED &&
       src_format == GDK_MEMORY_R16G16B16A16_FLOAT)
     convert_fp16_premultiply (dest_data, dest_stride, src_data, src_stride, width, height);
+  else if (src_format == GDK_MEMORY_R32G32B32A32_FLOAT &&
+           dest_format == GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED)
+    convert_float_premultiply (dest_data, dest_stride, src_data, src_stride, width, height);
   else
     converters[src_format][dest_format] (dest_data, dest_stride, src_data, src_stride, width, height);
 }
diff --git a/gdk/gdkmemorytexture.h b/gdk/gdkmemorytexture.h
index 933bd2f112..fc1bb57f9f 100644
--- a/gdk/gdkmemorytexture.h
+++ b/gdk/gdkmemorytexture.h
@@ -52,6 +52,13 @@ G_BEGIN_DECLS
  * @GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED: 4 half-float values; for
  *   red, green, blue and alpha. The color values are premultiplied with
  *   the alpha value. Since 4.6
+ * @GDK_MEMORY_B32G32R32_FLOAT: 3 float values; for blue, green, red.
+ *   The data is opaque. Since 4.6
+ * @GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED: 4 float values; for
+ *   red, green, blue and alpha. The color values are premultiplied with
+ *   the alpha value. Since 4.6
+ * @GDK_MEMORY_R32G32B32A32_FLOAT: 4 float values; for red, green, blue and
+ * alpha. Since 4.6
  * @GDK_MEMORY_N_FORMATS: The number of formats. This value will change as
  *   more formats get added, so do not rely on its concrete integer.
  *
@@ -83,6 +90,9 @@ typedef enum {
   GDK_MEMORY_R16G16B16_FLOAT,
   GDK_MEMORY_R16G16B16A16_FLOAT,
   GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED,
+  GDK_MEMORY_R32G32B32_FLOAT,
+  GDK_MEMORY_R32G32B32A32_FLOAT,
+  GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED,
 
   GDK_MEMORY_N_FORMATS
 } GdkMemoryFormat;
diff --git a/testsuite/gdk/memorytexture.c b/testsuite/gdk/memorytexture.c
index e2b9846c23..f7153bcdad 100644
--- a/testsuite/gdk/memorytexture.c
+++ b/testsuite/gdk/memorytexture.c
@@ -191,7 +191,10 @@ main (int argc, char *argv[])
     {
       if (format == GDK_MEMORY_R16G16B16_FLOAT ||
           format == GDK_MEMORY_R16G16B16A16_FLOAT ||
-          format == GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED)
+          format == GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED ||
+          format == GDK_MEMORY_R32G32B32_FLOAT ||
+          format == GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED ||
+          format == GDK_MEMORY_R32G32B32A32_FLOAT)
         continue;
 
       for (color = 0; color < N_COLORS; color++)


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]