Method GetFrame

src/effects/Saturation.cpp:110–232

This method is required for all derived classes of EffectBase, and returns a modified openshot::Frame object

// This method is required for all derived classes of EffectBase, and returns a
// modified openshot::Frame object
std::shared_ptr<openshot::Frame> Saturation::GetFrame(std::shared_ptr<openshot::Frame> frame, int64_t frame_number)
{
	// Get the frame's image
	std::shared_ptr<QImage> frame_image = frame->GetImage();

	if (!frame_image)
		return frame;

	const int pixel_count = frame_image->width() * frame_image->height();

	// Get keyframe values for this frame
	const float saturation_value = saturation.GetValue(frame_number);
	const float saturation_value_R = saturation_R.GetValue(frame_number);
	const float saturation_value_G = saturation_G.GetValue(frame_number);
	const float saturation_value_B = saturation_B.GetValue(frame_number);

	// Constants used for color saturation formula
	const float pR = 0.299f;
	const float pG = 0.587f;
	const float pB = 0.114f;
	const float sqrt_pR = std::sqrt(pR);
	const float sqrt_pG = std::sqrt(pG);
	const float sqrt_pB = std::sqrt(pB);
	// Rec.601 fixed-point luma weights used in many image/video pipelines.
	// This avoids per-pixel sqrt() while keeping output stable.
	static const std::array<float, 65026> sqrt_lut = [] {
		std::array<float, 65026> lut{};
		for (int i = 0; i <= 65025; ++i)
			lut[i] = std::sqrt(static_cast<float>(i));
		return lut;
	}();

	// Loop through pixels
	unsigned char *pixels = reinterpret_cast<unsigned char *>(frame_image->bits());
	// LUT for undoing premultiplication without a per-pixel divide.
	static const std::array<float, 256> inv_alpha = [] {
		std::array<float, 256> lut{};
		lut[0] = 0.0f;
		for (int i = 1; i < 256; ++i)
			lut[i] = 255.0f / static_cast<float>(i);
		return lut;
	}();
	const auto clamp_i = [](int value) -> int {
		if (value < 0) return 0;
		if (value > 255) return 255;
		return value;
	};

	const auto apply_saturation = [&](int &R, int &G, int &B) {
		// Approximate sqrt(R^2*pR + G^2*pG + B^2*pB) with fixed-point weighted
		// intensity and lookup table. 77/150/29 ~= 0.299/0.587/0.114.
		const int weighted_sq = (77 * R * R + 150 * G * G + 29 * B * B + 128) >> 8;
		const float p = sqrt_lut[weighted_sq];

		// Adjust common saturation
		R = clamp_i(static_cast<int>(p + (R - p) * saturation_value));
		G = clamp_i(static_cast<int>(p + (G - p) * saturation_value));
		B = clamp_i(static_cast<int>(p + (B - p) * saturation_value));