Fix scaler not re-applied to final image when preview and final image source (x,y) are identical. Move source (x,y) into image_info.

Author: bbbbbr

src/filter_dialog.c

@@ -497,7 +497,6 @@ static void dialog_scaled_preview_check_resize(GtkWidget * preview_scaled, gint
 void pixel_art_scalers_run(GimpDrawable *drawable, GimpPreview  *preview)
 {
     GimpPixelRgn src_rgn;
-    gint         x, y;
     gint         original_bpp;
     guint        scale_factor;
     image_info   source_image;
@@ -511,19 +510,20 @@ void pixel_art_scalers_run(GimpDrawable *drawable, GimpPreview  *preview)
 
     // Get the working image area for either the preview sub-window or the entire image
     if (preview) {
-        gimp_preview_get_position (preview, &x, &y);
+        gimp_preview_get_position (preview, &source_image.x, &source_image.y);
         gimp_preview_get_size (preview, &source_image.width, &source_image.height);
     }
     else if (! gimp_drawable_mask_intersect (drawable->drawable_id,
-                                             &x, &y, &source_image.width, &source_image.height)) {
+                                             &source_image.x, &source_image.y,
+                                             &source_image.width, &source_image.height)) {
         return;
     }
 
     // Get bit depth and alpha mask status
     source_image.bpp = drawable->bpp;
     original_bpp = source_image.bpp;
 
-    if (scaled_output_check_reapply_scalers(scaler_mode_get(), x, y)) {
+    if (scaled_output_check_reapply_scalers(scaler_mode_get(), source_image)) {
 
         // ====== GET THE SOURCE IMAGE ======
 
@@ -536,14 +536,15 @@ void pixel_art_scalers_run(GimpDrawable *drawable, GimpPreview  *preview)
         // Initialize source pixel region with drawable
         gimp_pixel_rgn_init (&src_rgn,
                              drawable,
-                             x, y,
+                             source_image.x, source_image.y,
                              source_image.width, source_image.height,
                              FALSE, FALSE);
 
         // Copy source image to working buffer
         gimp_pixel_rgn_get_rect (&src_rgn,
                                  (guchar *) source_image.p_imagebuf,
-                                 x, y, source_image.width, source_image.height);
+                                 source_image.x, source_image.y,
+                                 source_image.width, source_image.height);
 
         // Add alpha channel byte to source buffer if needed (scalers expect 4BPP RGBA)
         if (source_image.bpp == BYTE_SIZE_RGB_3BPP) { // i.e. !has_alpha
@@ -582,7 +583,7 @@ void pixel_art_scalers_run(GimpDrawable *drawable, GimpPreview  *preview)
         // ====== APPLY THE SCALER ======
 
         // Allocate output buffer for upscaled image
-        scaled_output_check_reallocate(scale_factor, source_image.width, source_image.height);
+        scaled_output_check_reallocate(scale_factor, source_image);
 
         // Expects 4BPP RGBA in source_image.p_imagebuf, outputs same to scaled_output->p_imagebuf
         scaler_apply(scaler_mode_get(),

src/filter_scalers.c

@@ -150,36 +150,42 @@ void scaled_output_invalidate(void) {
 //
 // Used to assist with output caching
 //
-gint scaled_output_check_reapply_scalers(gint scaler_mode_new, gint x_new, gint y_new) {
+gint scaled_output_check_reapply_scalers(gint scaler_mode_new, image_info src_image) {
 
-  gint result;
+    gint result;
+    gint scale_factor_new = scaler_scale_factor_get( scaler_mode_new );
 
-  result = ((scaled_output.scaler_mode != scaler_mode_new) ||
-            (scaled_output.x != x_new) ||
-            (scaled_output.y != y_new) ||
-            (scaled_output.valid_image == FALSE));
+    result = ((scaled_output.scaler_mode != scaler_mode_new) ||
+             (scaled_output.x != src_image.x) ||
+             (scaled_output.y != src_image.y) ||
+             (scaled_output.width  != (src_image.width  * scale_factor_new)) ||
+             (scaled_output.height != (src_image.height * scale_factor_new)) ||
+             (scaled_output.valid_image == FALSE));
 
-  scaled_output.x = x_new;
-  scaled_output.y = y_new;
+    scaled_output.x = src_image.x;
+    scaled_output.y = src_image.y;
 
-  return (result);
+    if (result)
+        scaled_output_invalidate();
+
+    return (result);
 }
 
 
 // scaled_output_check_reallocate
 //
 // Update output buffer size and re-allocate if needed
 //
-void scaled_output_check_reallocate(gint scale_factor_new, gint width_new, gint height_new)
+void scaled_output_check_reallocate(gint scale_factor_new, image_info src_image)
 {
     if ((scale_factor_new != scaled_output.scale_factor) ||
-        ((width_new  * scale_factor_new) != scaled_output.width) ||
-        ((height_new * scale_factor_new) != scaled_output.height) ||
+        ((src_image.width  * scale_factor_new) != scaled_output.width) ||
+        ((src_image.height * scale_factor_new) != scaled_output.height) ||
         (scaled_output.p_imagebuf == NULL)) {
 
         // Update the buffer size and re-allocate. The x uint32_t is for RGBA buffer size
-        scaled_output.width        = width_new  * scale_factor_new;
-        scaled_output.height       = height_new * scale_factor_new;
+        scaled_output.width        = src_image.width  * scale_factor_new;
+        scaled_output.height       = src_image.height * scale_factor_new;
         scaled_output.scale_factor = scale_factor_new;
         scaled_output.size_bytes = scaled_output.width * scaled_output.height * BYTE_SIZE_RGBA_4BPP;
 

src/filter_scalers.h

@@ -126,8 +126,8 @@
     void scaler_apply(int, uint32_t *, uint32_t *, int, int);
 
     void scaled_output_invalidate(void);
-    gint scaled_output_check_reapply_scalers(gint, gint, gint);
-    void scaled_output_check_reallocate(gint, gint, gint);
+    gint scaled_output_check_reapply_scalers(gint, image_info);
+    void scaled_output_check_reallocate(gint, image_info);
 
     void image_info_init(image_info *);