Gamma corrected pipe input scaling

Non-raw images can have gamma corrected data as input possibly leading to bad results while
we do the initial scaling. This scaling happens when generating the mipmap via `_init_f` and
when inserting data into the pixelpipes.

What we do now:
- we test for the image having exif data as sRGB or AdobeRGB.
- the colorin module does a much better check than exif data and possibly sets the profile type
  to any RGB mode.
  We keep track on this when setting the input profile and possibly change the image->colorspace
  (making sure to leave the exif checked data as they are).
- dt_iop_clip_and_zoom() got an extra gboolean parameter `gamma`, if that is true the
  interpolation is encapsulated in rgb->linear and linear->rgb conversions.

This results in improved data visualizing for all pipes and data taken from the preview pipe.

Reminder:
1. As this is only effective for non-raw images we should likely stay in linear space and let
   colorin module handle this.
2. Should we avoid the conversions for upscaling?

Author: jenshannoschwalm

src/common/image.h

@@ -107,7 +107,8 @@ typedef enum dt_image_colorspace_t
 {
   DT_IMAGE_COLORSPACE_NONE,
   DT_IMAGE_COLORSPACE_SRGB,
-  DT_IMAGE_COLORSPACE_ADOBE_RGB
+  DT_IMAGE_COLORSPACE_ADOBE_RGB,
+  DT_IMAGE_COLORSPACE_USER_RGB
 } dt_image_colorspace_t;
 
 typedef struct dt_image_raw_parameters_t

src/common/iop_profile.c

@@ -22,6 +22,7 @@
 #include "common/debug.h"
 #include "common/imagebuf.h"
 #include "common/matrices.h"
+#include "common/image_cache.h"
 #include "control/control.h"
 #include "develop/imageop.h"
 #include "develop/imageop_math.h"
@@ -920,8 +921,25 @@ dt_ioppr_set_pipe_input_profile_info(struct dt_develop_t *dev,
     profile_info = dt_ioppr_add_profile_info_to_list(dev, DT_COLORSPACE_LIN_REC2020, "", intent);
   }
 
-  if(profile_info->type >= DT_COLORSPACE_EMBEDDED_ICC
-     && profile_info->type <= DT_COLORSPACE_ALTERNATE_MATRIX)
+  const dt_imgid_t imgid = dev->image_storage.id;
+  const dt_image_t *cimg = dt_image_cache_get(imgid, 'r');
+  const dt_image_colorspace_t ocsp = cimg->colorspace;
+  dt_image_cache_read_release(cimg);
+
+  const dt_colorspaces_color_profile_type_t ptype = profile_info->type;
+  const gboolean exif_rgb = ocsp == DT_IMAGE_COLORSPACE_SRGB || ocsp == DT_IMAGE_COLORSPACE_ADOBE_RGB;
+  const gboolean new_rgb = ptype == DT_COLORSPACE_SRGB || ptype == DT_COLORSPACE_ADOBERGB;
+  const gboolean user_rgb = ocsp == DT_IMAGE_COLORSPACE_USER_RGB;
+  if(!exif_rgb                       // don't fiddle with existing exif data
+      && ((new_rgb && !user_rgb) || (!new_rgb && user_rgb)))
+  {
+    dt_image_t *wimg = dt_image_cache_get(imgid, 'w');
+    wimg->colorspace = new_rgb ? DT_IMAGE_COLORSPACE_USER_RGB : DT_IMAGE_COLORSPACE_NONE;
+    dt_image_cache_write_release_info(wimg, DT_IMAGE_CACHE_RELAXED, NULL);
+  }
+
+  if(ptype >= DT_COLORSPACE_EMBEDDED_ICC
+     && ptype <= DT_COLORSPACE_ALTERNATE_MATRIX)
   {
     /* We have a camera input matrix, these are not generated from files but in colorin,
     * so we need to fetch and replace them from somewhere.

src/common/mipmap_cache.c

@@ -1379,10 +1379,12 @@ static void _init_f(dt_mipmap_buffer_t *mipmap_buf,
   }
   else
   {
-    // downsample
+    // scale
+    const gboolean gamma = image->colorspace != DT_IMAGE_COLORSPACE_NONE;
     dt_print_pipe(DT_DEBUG_PIPE,
-      "mipmap clip and zoom", NULL, NULL, DT_DEVICE_CPU, &roi_in, &roi_out);
-    dt_iop_clip_and_zoom(out, (const float *)buf.buf, &roi_out, &roi_in);
+      "mipmap clip&zoom", NULL, NULL, DT_DEVICE_NONE, &roi_in, &roi_out, "%s",
+          gamma ? "gamma corrected" : "");
+    dt_iop_clip_and_zoom(out, (const float *)buf.buf, &roi_out, &roi_in, gamma);
   }
 
   dt_mipmap_cache_release(&buf);

src/develop/imageop_math.c

@@ -144,15 +144,55 @@ void dt_iop_clip_and_zoom_8(const uint8_t *i,
   }
 }
 
-// apply clip and zoom on parts of a supplied full image.
-// roi_in and roi_out define which part to work on.
+/* apply clip and zoom on parts of a supplied full image, roi_in and roi_out define which part to work on.
+    gamma correction around scaling supported.
+    full RGB->linear and backwards transformation is provided with a performance
+    penalty without doing significant quality improvements as we only down/upscale.
+    To do so requires commenting the #define JUST_GAMMA
+*/
+#define JUST_GAMMA
 void dt_iop_clip_and_zoom(float *out,
                           const float *const in,
                           const dt_iop_roi_t *const roi_out,
-                          const dt_iop_roi_t *const roi_in)
+                          const dt_iop_roi_t *const roi_in,
+                          const gboolean gamma)
 {
   const dt_interpolation_t *itor = dt_interpolation_new(DT_INTERPOLATION_USERPREF);
-  dt_interpolation_resample(itor, out, roi_out, in, roi_in);
+  float *linear = gamma ? dt_alloc_align_float((size_t)roi_in->width * roi_in->height * 4) : NULL;
+  if(!linear)
+    return dt_interpolation_resample(itor, out, roi_out, in, roi_in);
+
+#ifdef JUST_GAMMA
+  static const dt_aligned_pixel_t two_point_four = { 2.4f, 2.4f, 2.4f, 2.4f };
+#endif
+  static const dt_aligned_pixel_t rev_two_point_four = { 1.0f / 2.4f, 1.0f / 2.4f, 1.0f / 2.4f, 1.0f / 2.4f };
+
+  DT_OMP_SIMD(aligned(in, linear : 16))
+  for(size_t k = 0; k < (size_t)roi_in->width * roi_in->height*4; k += 4)
+#ifdef JUST_GAMMA
+    dt_vector_powf(&in[k], two_point_four, &linear[k]);
+#else
+    dt_sRGB_to_linear_sRGB(&in[k], &linear[k]);
+#endif
+
+  dt_interpolation_resample(itor, out, roi_out, linear, roi_in);
+  dt_free_align(linear);
+
+  DT_OMP_SIMD(aligned(out : 16))
+  for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height * 4; k += 4)
+#ifdef JUST_GAMMA
+    dt_vector_powf(&out[k], rev_two_point_four, &out[k]);
+#else
+  {
+    dt_aligned_pixel_t toe;
+    dt_aligned_pixel_t curved;
+    for_each_channel(c)
+      toe[c] = 12.92f * out[k+c];
+    dt_vector_powf(&out[k], rev_two_point_four, curved);
+    for_each_channel(c)
+      out[k+c] = (out[k+c] <=  0.0031308f) ? toe[c] : (1.055f * curved[c] - 0.055f);
+  }
+#endif
 }
 
 // apply clip and zoom on the image region supplied in the input buffer.

src/develop/imageop_math.h

@@ -34,7 +34,7 @@ void dt_iop_flip_and_zoom_8(const uint8_t *in, int32_t iw, int32_t ih, uint8_t *
 
 /** for homebrew pixel pipe: zoom pixel array. */
 void dt_iop_clip_and_zoom(float *out, const float *const in, const struct dt_iop_roi_t *const roi_out,
-                          const struct dt_iop_roi_t *const roi_in);
+                          const struct dt_iop_roi_t *const roi_in, const gboolean gamma);
 
 /** zoom pixel array for roi buffers. */
 void dt_iop_clip_and_zoom_roi(float *out, const float *const in, const struct dt_iop_roi_t *const roi_out,

src/develop/pixelpipe_hb.c

@@ -1724,15 +1724,16 @@ static gboolean _dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe,
         roi_in.height = pipe->iheight;
         roi_in.scale = 1.0f;
         const gboolean valid_bpp = (bpp == 4 * sizeof(float));
-
+        const gboolean gamma = dev->image_storage.colorspace != DT_IMAGE_COLORSPACE_NONE;
         dt_print_pipe(DT_DEBUG_PIPE,
                       "pipe data: clip&zoom",
-                      pipe, module, DT_DEVICE_CPU, &roi_in, roi_out, "%s%s",
-                      valid_bpp ? "" : "requires 4 floats data",
-                      aligned_input ? "" : "non-aligned input buffer");
+                      pipe, module, DT_DEVICE_CPU, &roi_in, roi_out, "%s%s%s",
+                      valid_bpp ? "" : "requires 4 floats data ",
+                      aligned_input ? "" : "non-aligned input buffer ",
+                      gamma ? "gamma corrected" : "");
 
         if(valid_bpp && aligned_input)
-          dt_iop_clip_and_zoom(*output, pipe->input, roi_out, &roi_in);
+          dt_iop_clip_and_zoom(*output, pipe->input, roi_out, &roi_in, gamma);
         else
         {
           memset(*output, 0, (size_t)roi_out->width * roi_out->height * bpp);

src/iop/finalscale.c

@@ -186,7 +186,7 @@ void process(dt_iop_module_t *self,
   if(exporting)
     dt_iop_clip_and_zoom_roi((float *)ovoid, (float *)ivoid, roi_out, roi_in);
   else
-    dt_iop_clip_and_zoom((float *)ovoid, (float *)ivoid, roi_out, roi_in);
+    dt_iop_clip_and_zoom((float *)ovoid, (float *)ivoid, roi_out, roi_in, FALSE);
 }
 
 void commit_params(dt_iop_module_t *self,