Adding upscaling for crop effect + resize property - so cropping into higher resolution content does not become blurry.

Author: jonoomph

src/CMakeLists.txt

@@ -115,6 +115,7 @@ set(EFFECTS_SOURCES
   effects/ColorMap.cpp
   effects/ColorShift.cpp
   effects/Crop.cpp
+  effects/CropHelpers.cpp
   effects/Deinterlace.cpp
   effects/Hue.cpp
   effects/LensFlare.cpp

src/FFmpegReader.cpp

@@ -20,6 +20,7 @@
 #include <unistd.h>
 
 #include "FFmpegUtilities.h"
+#include "effects/CropHelpers.h"
 
 #include "FFmpegReader.h"
 #include "Exceptions.h"
@@ -1594,6 +1595,9 @@ void FFmpegReader::ProcessVideoPacket(int64_t requested_frame) {
 			max_width = info.width * max_scale_x * preview_ratio;
 			max_height = info.height * max_scale_y * preview_ratio;
 		}
+
+		// If a crop effect is resizing the image, request enough pixels to preserve detail
+		ApplyCropResizeScale(parent, info.width, info.height, max_width, max_height);
 	}
 
 	// Determine if image needs to be scaled (for performance reasons)

src/QtImageReader.cpp

@@ -16,7 +16,9 @@
 #include "CacheMemory.h"
 #include "Exceptions.h"
 #include "Timeline.h"
+#include "effects/CropHelpers.h"
 
+#include <algorithm>
 #include <QString>
 #include <QImage>
 #include <QPainter>
@@ -244,6 +246,9 @@ QSize QtImageReader::calculate_max_size() {
             max_width = info.width * max_scale_x * preview_ratio;
             max_height = info.height * max_scale_y * preview_ratio;
         }
+
+        // If a crop effect is resizing the image, request enough pixels to preserve detail
+        ApplyCropResizeScale(parent, info.width, info.height, max_width, max_height);
     }
 
     // Return new QSize of the current max size

src/effects/CropHelpers.cpp

@@ -0,0 +1,64 @@
+/**
+ * @file
+ * @brief Shared helpers for Crop effect scaling logic
+ * @author Jonathan Thomas <jonathan@openshot.org>
+ *
+ * @ref License
+ */
+
+// Copyright (c) 2008-2025 OpenShot Studios, LLC
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "CropHelpers.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "../Clip.h"
+#include "Crop.h"
+
+namespace openshot {
+
+const Crop* FindResizingCropEffect(Clip* clip) {
+	if (!clip) {
+		return nullptr;
+	}
+
+	for (auto effect : clip->Effects()) {
+		if (auto crop_effect = dynamic_cast<Crop*>(effect)) {
+			if (crop_effect->resize) {
+				return crop_effect;
+			}
+		}
+	}
+
+	return nullptr;
+}
+
+void ApplyCropResizeScale(Clip* clip, int source_width, int source_height, int& max_width, int& max_height) {
+	const Crop* crop_effect = FindResizingCropEffect(clip);
+	if (!crop_effect) {
+		return;
+	}
+
+	const float max_left = crop_effect->left.GetMaxPoint().co.Y;
+	const float max_right = crop_effect->right.GetMaxPoint().co.Y;
+	const float max_top = crop_effect->top.GetMaxPoint().co.Y;
+	const float max_bottom = crop_effect->bottom.GetMaxPoint().co.Y;
+
+	const float visible_width = std::max(0.01f, 1.0f - max_left - max_right);
+	const float visible_height = std::max(0.01f, 1.0f - max_top - max_bottom);
+
+	const double scaled_width = std::ceil(max_width / visible_width);
+	const double scaled_height = std::ceil(max_height / visible_height);
+
+	const double clamped_width = std::min<double>(source_width, scaled_width);
+	const double clamped_height = std::min<double>(source_height, scaled_height);
+
+	max_width = static_cast<int>(std::min<double>(std::numeric_limits<int>::max(), clamped_width));
+	max_height = static_cast<int>(std::min<double>(std::numeric_limits<int>::max(), clamped_height));
+}
+
+} // namespace openshot

src/effects/CropHelpers.h

@@ -0,0 +1,29 @@
+/**
+ * @file
+ * @brief Shared helpers for Crop effect scaling logic
+ * @author Jonathan Thomas <jonathan@openshot.org>
+ *
+ * @ref License
+ */
+
+// Copyright (c) 2008-2025 OpenShot Studios, LLC
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#ifndef OPENSHOT_CROP_HELPERS_H
+#define OPENSHOT_CROP_HELPERS_H
+
+namespace openshot {
+
+class Clip;
+class Crop;
+
+/// Return the first Crop effect on this clip that has resize enabled (if any)
+const Crop* FindResizingCropEffect(Clip* clip);
+
+/// Scale the requested max_width / max_height based on the Crop resize amount, capped by source size
+void ApplyCropResizeScale(Clip* clip, int source_width, int source_height, int& max_width, int& max_height);
+
+} // namespace openshot
+
+#endif // OPENSHOT_CROP_HELPERS_H

tests/Crop.cpp

@@ -7,7 +7,7 @@
  * @ref License
  */
 
-// Copyright (c) 2008-2021 OpenShot Studios, LLC
+// Copyright (c) 2008-2025 OpenShot Studios, LLC
 //
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
@@ -16,7 +16,9 @@
 #include "openshot_catch.h"
 
 #include "Frame.h"
+#include "Clip.h"
 #include "effects/Crop.h"
+#include "effects/CropHelpers.h"
 
 #include <QColor>
 #include <QImage>
@@ -144,3 +146,29 @@ TEST_CASE( "x/y offsets", "[libopenshot][effect][crop]" )
     // so it becomes a transparent pixel
     CHECK(i->pixelColor(900, 360) == trans);
 }
+
+TEST_CASE( "crop resize scaling helper", "[libopenshot][effect][crop][scaling]" )
+{
+    // Build a clip with a resizing crop effect
+    auto clip = std::make_unique<openshot::Clip>();
+    auto crop = new openshot::Crop(openshot::Keyframe(0.0), openshot::Keyframe(0.0),
+                                   openshot::Keyframe(0.0), openshot::Keyframe(0.75));
+    crop->resize = true;
+    clip->AddEffect(crop);
+
+    int max_width = 900;
+    int max_height = 500;
+
+    // 25% of the height is visible, so request 4x height (capped at source size)
+    openshot::ApplyCropResizeScale(clip.get(), 3840, 2160, max_width, max_height);
+    CHECK(max_width == 900);
+    CHECK(max_height == 2000);
+
+    // If scaling would exceed source, it should clamp at source dimensions
+    crop->bottom = openshot::Keyframe(0.9); // visible height = 10%
+    max_width = 900;
+    max_height = 500;
+    openshot::ApplyCropResizeScale(clip.get(), 1920, 1080, max_width, max_height);
+    CHECK(max_width == 900);   // width unchanged (no horizontal crop)
+    CHECK(max_height == 1080); // scaled height would be 5000, so it clamps
+}