Method GetFrame

src/effects/Mask.cpp:57–165

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> Mask::GetFrame(std::shared_ptr<openshot::Frame> frame, int64_t frame_number) {
	// Get frame image first
	std::shared_ptr<QImage> frame_image = frame->GetImage();
	if (!frame_image || frame_image->isNull())
		return frame;

	// No reader (bail on applying the mask)
	auto original_mask = ResolveMaskImage(frame_image, frame_number);
	if (!original_mask || original_mask->isNull())
		return frame;

	// Grab raw pointers and dimensions one time
	unsigned char* pixels      = reinterpret_cast<unsigned char*>(frame_image->bits());
	unsigned char* mask_pixels = reinterpret_cast<unsigned char*>(original_mask->bits());
	const int num_pixels        = original_mask->width() * original_mask->height();

	// Evaluate brightness and contrast keyframes just once
	double contrast_value   = contrast.GetValue(frame_number);
	double brightness_value = brightness.GetValue(frame_number);

	int brightness_adj = static_cast<int>(255 * brightness_value);
	float contrast_factor = 20.0f / std::max(0.00001f, 20.0f - static_cast<float>(contrast_value));
	const bool output_mask = replace_image;
	const auto clamp_u8 = [](int value) -> unsigned char {
		if (value < 0) return 0;
		if (value > 255) return 255;
		return static_cast<unsigned char>(value);
	};
	// Precompute gray->adjusted-gray mapping for this frame's brightness/contrast.
	std::array<unsigned char, 256> adjusted_gray{};
	for (int gray = 0; gray < 256; ++gray) {
		const int adjusted = static_cast<int>(contrast_factor * ((gray + brightness_adj) - 128) + 128);
		adjusted_gray[gray] = clamp_u8(adjusted);
	}
	// 8-bit multiply lookup for premultiplied alpha channel scaling.
	static const std::array<std::array<unsigned char, 256>, 256> mul_lut = [] {
		std::array<std::array<unsigned char, 256>, 256> lut{};
		for (int alpha = 0; alpha < 256; ++alpha) {
			for (int value = 0; value < 256; ++value) {
				lut[alpha][value] = static_cast<unsigned char>((value * alpha) / 255);
			}
		}
		return lut;
	}();

	// Separate loops keep the hot path branch-free per pixel.
	if (output_mask) {
		#pragma omp parallel for if(num_pixels >= 16384) schedule(static)
		for (int i = 0; i < num_pixels; ++i) {
			const int idx = i * 4;
			const int R = mask_pixels[idx + 0];
			const int G = mask_pixels[idx + 1];
			const int B = mask_pixels[idx + 2];
			const int A = mask_pixels[idx + 3];

			const int gray = ((R * 11) + (G * 16) + (B * 5)) >> 5;
			const int diff = A - adjusted_gray[gray];
			const unsigned char new_val = clamp_u8(diff);