Fix colorspace+range of cached images in qimage/pixbuf

See https://forum.shotcut.org/t/processing-mode-native-8-bit-cpu-color-shift-below-transparent-clip/51827/

Author: ddennedy

src/modules/gdk/producer_pixbuf.c

@@ -75,6 +75,8 @@ struct producer_pixbuf_s
     mlt_cache_item pixbuf_cache;
     GdkPixbuf *pixbuf;
     mlt_image_format format;
+    int full_range;
+    int colorspace;
 };
 
 static void load_filenames(producer_pixbuf self, mlt_properties producer_properties);
@@ -583,10 +585,18 @@ static void refresh_image(
                   self->pixbuf_idx,
                   width);
 
+    // Y'CbCr formats are ambiguous without a color range, so a cached image must be
+    // regenerated if the requested range changes even when the format does not.
+    int dst_full_range = mlt_properties_get_int(properties, "full_range");
+    int format_is_yuv = format == mlt_image_yuv422 || format == mlt_image_yuv420p
+                        || format == mlt_image_yuv422p16 || format == mlt_image_yuv420p10
+                        || format == mlt_image_yuv444p10;
+
     // If we have a pixbuf and we need an image
     if (self->pixbuf
         && (!self->image
-            || (format != mlt_image_none && format != mlt_image_movit && format != self->format))) {
+            || (format != mlt_image_none && format != mlt_image_movit && format != self->format)
+            || (format_is_yuv && format == self->format && dst_full_range != self->full_range))) {
         char *interps = mlt_properties_get(properties, "consumer.rescale");
         if (interps)
             interps = strdup(interps);
@@ -615,6 +625,9 @@ static void refresh_image(
         int src_stride = gdk_pixbuf_get_rowstride(pixbuf);
         int dst_stride = self->width * (has_alpha ? 4 : 3);
         self->format = has_alpha ? mlt_image_rgba : mlt_image_rgb;
+        // RGB(A) is inherently full range.
+        self->full_range = 1;
+        self->colorspace = mlt_colorspace_rgb;
         int image_size = mlt_image_format_size(self->format, width, height, NULL);
         self->image = mlt_pool_alloc(image_size);
         self->alpha = NULL;
@@ -645,6 +658,13 @@ static void refresh_image(
                 mlt_properties_set_int(properties, "format", self->format);
 
                 if (!mlt_frame_convert_image(frame, &self->image, &self->format, format)) {
+                    self->full_range = self->format == mlt_image_rgb
+                                               || self->format == mlt_image_rgba
+                                               || self->format == mlt_image_rgba64
+                                           ? 1
+                                           : dst_full_range;
+                    // The converter records the colorspace it produced.
+                    self->colorspace = mlt_properties_get_int(properties, "colorspace");
                     buffer = self->image;
                     image_size
                         = mlt_image_format_size(self->format, self->width, self->height, NULL);
@@ -719,13 +739,19 @@ static int producer_get_image(mlt_frame frame,
     self->alpha_cache = mlt_service_cache_get(MLT_PRODUCER_SERVICE(producer), "pixbuf.alpha");
     self->alpha = mlt_cache_item_data(self->alpha_cache, NULL);
 
+    const char *dst_color_range = mlt_properties_get(properties, "consumer.color_range");
+    mlt_properties_set_int(properties, "full_range", mlt_image_full_range(dst_color_range));
+
     // Refresh the image
     refresh_image(self, frame, *format, *width, *height);
 
     // Get width and height (may have changed during the refresh)
     *width = self->width;
     *height = self->height;
     *format = self->format;
+    // A reused image may hold a different color range than the consumer asked for.
+    mlt_properties_set_int(properties, "full_range", self->full_range);
+    mlt_properties_set_int(properties, "colorspace", self->colorspace);
 
     // NB: Cloning is necessary with this producer (due to processing of images ahead of use)
     // The fault is not in the design of mlt, but in the implementation of the pixbuf producer...

src/modules/qt/producer_qimage.c

@@ -232,15 +232,17 @@ static int producer_get_image(mlt_frame frame,
         self->current_alpha = mlt_cache_item_data(self->alpha_cache, &self->alpha_size);
 
         const char *dst_color_range = mlt_properties_get(properties, "consumer.color_range");
-        if (mlt_image_full_range(dst_color_range))
-            mlt_properties_set_int(properties, "full_range", 1);
+        mlt_properties_set_int(properties, "full_range", mlt_image_full_range(dst_color_range));
     }
     refresh_image(self, frame, *format, *width, *height, enable_caching);
 
     // Get width and height (may have changed during the refresh)
     *width = mlt_properties_get_int(properties, "width");
     *height = mlt_properties_get_int(properties, "height");
     *format = self->format;
+    // A reused image may hold a different color range than the consumer asked for.
+    mlt_properties_set_int(properties, "full_range", self->full_range);
+    mlt_properties_set_int(properties, "colorspace", self->colorspace);
 
     // NB: Cloning is necessary with this producer (due to processing of images ahead of use)
     // The fault is not in the design of mlt, but in the implementation of the qimage producer...

src/modules/qt/qimage_wrapper.cpp

@@ -223,10 +223,18 @@ void refresh_image(producer_qimage self,
         || height != self->current_height)
         self->current_image = NULL;
 
+    // Y'CbCr formats are ambiguous without a color range, so a cached image must be
+    // regenerated if the requested range changes even when the format does not.
+    int dst_full_range = mlt_properties_get_int(properties, "full_range");
+    bool format_is_yuv = format == mlt_image_yuv422 || format == mlt_image_yuv420p
+                         || format == mlt_image_yuv422p16 || format == mlt_image_yuv420p10
+                         || format == mlt_image_yuv444p10;
+
     // If we have a qimage and need a new scaled image
     if (self->qimage
         && (!self->current_image
-            || (format != mlt_image_none && format != mlt_image_movit && format != self->format))) {
+            || (format != mlt_image_none && format != mlt_image_movit && format != self->format)
+            || (format_is_yuv && format == self->format && dst_full_range != self->full_range))) {
         QString interps = mlt_properties_get(properties, "consumer.rescale");
         bool interp = (interps != "nearest") && (interps != "none");
         QImage *qimage = static_cast<QImage *>(self->qimage);
@@ -265,6 +273,9 @@ void refresh_image(producer_qimage self,
 
         // Copy the image
         int image_size;
+        // RGB(A) is inherently full range.
+        self->full_range = 1;
+        self->colorspace = mlt_colorspace_rgb;
         if (has_alpha) {
             self->format = mlt_image_rgba;
             scaled = scaled.convertToFormat(QImage::Format_RGBA8888);
@@ -298,6 +309,12 @@ void refresh_image(producer_qimage self,
                 self->current_width = width;
                 self->current_height = height;
                 self->format = format;
+                self->full_range = format == mlt_image_rgb || format == mlt_image_rgba
+                                           || format == mlt_image_rgba64
+                                       ? 1
+                                       : dst_full_range;
+                // The converter records the colorspace it produced.
+                self->colorspace = mlt_properties_get_int(properties, "colorspace");
                 image_size = mlt_image_format_size(format, width, height, NULL);
                 self->current_image = (uint8_t *) mlt_pool_alloc(image_size);
                 memcpy(self->current_image, buffer, image_size);

src/modules/qt/qimage_wrapper.h

@@ -45,6 +45,8 @@ struct producer_qimage_s
     mlt_cache_item qimage_cache;
     void *qimage;
     mlt_image_format format;
+    int full_range;
+    int colorspace;
 };
 
 typedef struct producer_qimage_s *producer_qimage;