From: Steinar H. Gunderson <sgunderson@bigfoot.com>
Date: Fri, 24 Nov 2017 21:11:08 +0000 (+0100)
Subject: Support chaining certain effects after compute shaders.
X-Git-Tag: 1.6.0~32
X-Git-Url: https://git.sesse.net/?p=movit;a=commitdiff_plain;h=e683d4e49549b2d4c6906d2ebc4184904f4fe9f8

Support chaining certain effects after compute shaders.

This rests on the notion of “strong one-to-one” that's very similar
to the older “one-to-one“ concept, yet a bit stricter (in particular,
PaddingEffect is not strong one-to-one).
---

diff --git a/alpha_division_effect.h b/alpha_division_effect.h
index 9258171..554a186 100644
--- a/alpha_division_effect.h
+++ b/alpha_division_effect.h
@@ -14,7 +14,7 @@ public:
 	AlphaDivisionEffect() {}
 	std::string effect_type_id() const override { return "AlphaDivisionEffect"; }
 	std::string output_fragment_shader() override;
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 };
 
 }  // namespace movit
diff --git a/alpha_multiplication_effect.h b/alpha_multiplication_effect.h
index 85f08f8..50333cb 100644
--- a/alpha_multiplication_effect.h
+++ b/alpha_multiplication_effect.h
@@ -14,7 +14,7 @@ public:
 	AlphaMultiplicationEffect() {}
 	std::string effect_type_id() const override { return "AlphaMultiplicationEffect"; }
 	std::string output_fragment_shader() override;
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 };
 
 }  // namespace movit
diff --git a/colorspace_conversion_effect.h b/colorspace_conversion_effect.h
index d875465..a59d476 100644
--- a/colorspace_conversion_effect.h
+++ b/colorspace_conversion_effect.h
@@ -28,7 +28,7 @@ public:
 
 	bool needs_srgb_primaries() const override { return false; }
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// Get a conversion matrix from the given color space to XYZ.
 	static Eigen::Matrix3d get_xyz_matrix(Colorspace space);
diff --git a/diffusion_effect.h b/diffusion_effect.h
index 253126e..a8babd0 100644
--- a/diffusion_effect.h
+++ b/diffusion_effect.h
@@ -57,7 +57,7 @@ public:
 	AlphaHandling alpha_handling() const override { return INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK; }
 
 	unsigned num_inputs() const override { return 2; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 private:
 	float blurred_mix_amount;
diff --git a/dither_effect.h b/dither_effect.h
index 71bb6d3..b1bbbff 100644
--- a/dither_effect.h
+++ b/dither_effect.h
@@ -66,7 +66,7 @@ public:
 	// premultiplied error. However, we need to do dithering in the same
 	// space as quantization, whether that be pre- or postmultiply.
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
 
diff --git a/effect.h b/effect.h
index afac5dc..ba39d6a 100644
--- a/effect.h
+++ b/effect.h
@@ -196,7 +196,16 @@ public:
 	// set sets_virtual_output_size(), though.
 	//
 	// Does not make a lot of sense together with needs_texture_bounce().
-	virtual bool one_to_one_sampling() const { return false; }
+	// Cannot be set for compute shaders.
+	virtual bool one_to_one_sampling() const { return strong_one_to_one_sampling(); }
+
+	// Similar in use to one_to_one_sampling(), but even stricter:
+	// The effect must not use texture coordinate in any way beyond
+	// giving it unmodified to its (single) input. This allows it to
+	// also be used after a compute shader, in the same phase.
+	//
+	// An effect that it strong one-to-one must also be one-to-one.
+	virtual bool strong_one_to_one_sampling() const { return false; }
 
 	// Whether this effect wants to output to a different size than
 	// its input(s) (see inform_input_size(), below). See also
diff --git a/effect_chain.cpp b/effect_chain.cpp
index 23156cb..c6bac80 100644
--- a/effect_chain.cpp
+++ b/effect_chain.cpp
@@ -34,12 +34,15 @@ namespace movit {
 
 namespace {
 
-// An effect that does nothing.
-class IdentityEffect : public Effect {
+// An effect whose only purpose is to sit in a phase on its own and take the
+// texture output from a compute shader and display it to the normal backbuffer
+// (or any FBO). That phase can be skipped when rendering using render_to_textures().
+class ComputeShaderOutputDisplayEffect : public Effect {
 public:
-	IdentityEffect() {}
-	string effect_type_id() const override { return "IdentityEffect"; }
+	ComputeShaderOutputDisplayEffect() {}
+	string effect_type_id() const override { return "ComputeShaderOutputDisplayEffect"; }
 	string output_fragment_shader() override { return read_file("identity.frag"); }
+	bool needs_texture_bounce() const override { return true; }
 };
 
 }  // namespace
@@ -162,6 +165,7 @@ Node *EffectChain::add_node(Effect *effect)
 	node->output_alpha_type = ALPHA_INVALID;
 	node->needs_mipmaps = false;
 	node->one_to_one_sampling = false;
+	node->strong_one_to_one_sampling = false;
 
 	nodes.push_back(node);
 	node_map[effect] = node;
@@ -408,9 +412,17 @@ void EffectChain::compile_glsl_program(Phase *phase)
 		Node *node = phase->effects[i];
 		const string effect_id = phase->effect_ids[node];
 		if (node->incoming_links.size() == 1) {
-			frag_shader += string("#define INPUT ") + phase->effect_ids[node->incoming_links[0]] + "\n";
+			Node *input = node->incoming_links[0];
+			if (i != 0 && input->effect->is_compute_shader()) {
+				// First effect after the compute shader reads the value
+				// that cs_output() wrote to a global variable.
+				frag_shader += string("#define INPUT(tc) CS_OUTPUT_VAL\n");
+			} else {
+				frag_shader += string("#define INPUT ") + phase->effect_ids[input] + "\n";
+			}
 		} else {
 			for (unsigned j = 0; j < node->incoming_links.size(); ++j) {
+				assert(!node->incoming_links[j]->effect->is_compute_shader());
 				char buf[256];
 				sprintf(buf, "#define INPUT%d %s\n", j + 1, phase->effect_ids[node->incoming_links[j]].c_str());
 				frag_shader += buf;
@@ -435,7 +447,17 @@ void EffectChain::compile_glsl_program(Phase *phase)
 		}
 		frag_shader += "\n";
 	}
-	frag_shader += string("#define INPUT ") + phase->effect_ids[phase->effects.back()] + "\n";
+	if (phase->is_compute_shader) {
+		frag_shader += string("#define INPUT ") + phase->effect_ids[phase->compute_shader_node] + "\n";
+		if (phase->compute_shader_node == phase->effects.back()) {
+			// No postprocessing.
+			frag_shader += "#define CS_POSTPROC(tc) CS_OUTPUT_VAL\n";
+		} else {
+			frag_shader += string("#define CS_POSTPROC ") + phase->effect_ids[phase->effects.back()] + "\n";
+		}
+	} else {
+		frag_shader += string("#define INPUT ") + phase->effect_ids[phase->effects.back()] + "\n";
+	}
 
 	// If we're the last phase, add the right #defines for Y'CbCr multi-output as needed.
 	vector<string> frag_shader_outputs;  // In order.
@@ -501,8 +523,8 @@ void EffectChain::compile_glsl_program(Phase *phase)
 
 	if (phase->is_compute_shader) {
 		frag_shader.append(read_file("footer.comp"));
-		phase->output_node->effect->register_uniform_vec2("inv_output_size", (float *)&phase->inv_output_size);
-		phase->output_node->effect->register_uniform_vec2("output_texcoord_adjust", (float *)&phase->output_texcoord_adjust);
+		phase->compute_shader_node->effect->register_uniform_vec2("inv_output_size", (float *)&phase->inv_output_size);
+		phase->compute_shader_node->effect->register_uniform_vec2("output_texcoord_adjust", (float *)&phase->output_texcoord_adjust);
 	} else {
 		frag_shader.append(read_file("footer.frag"));
 	}
@@ -597,7 +619,8 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 
 	Phase *phase = new Phase;
 	phase->output_node = output;
-	phase->is_compute_shader = output->effect->is_compute_shader();
+	phase->is_compute_shader = false;
+	phase->compute_shader_node = nullptr;
 
 	// If the output effect has one-to-one sampling, we try to trace this
 	// status down through the dependency chain. This is important in case
@@ -605,6 +628,7 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 	// output size); if we have one-to-one sampling, we don't have to break
 	// the phase.
 	output->one_to_one_sampling = output->effect->one_to_one_sampling();
+	output->strong_one_to_one_sampling = output->effect->strong_one_to_one_sampling();
 
 	// Effects that we have yet to calculate, but that we know should
 	// be in the current phase.
@@ -615,6 +639,8 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 		Node *node = effects_todo_this_phase.top();
 		effects_todo_this_phase.pop();
 
+		assert(node->effect->one_to_one_sampling() >= node->effect->strong_one_to_one_sampling());
+
 		if (node->effect->needs_mipmaps()) {
 			node->needs_mipmaps = true;
 		}
@@ -631,6 +657,10 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 		}
 
 		phase->effects.push_back(node);
+		if (node->effect->is_compute_shader()) {
+			phase->is_compute_shader = true;
+			phase->compute_shader_node = node;
+		}
 
 		// Find all the dependencies of this effect, and add them to the stack.
 		vector<Node *> deps = node->incoming_links;
@@ -644,12 +674,6 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 				start_new_phase = true;
 			}
 
-			// Compute shaders currently always end phases.
-			// (We might loosen this up in some cases in the future.)
-			if (deps[i]->effect->is_compute_shader()) {
-				start_new_phase = true;
-			}
-
 			// Propagate information about needing mipmaps down the chain,
 			// breaking the phase if we notice an incompatibility.
 			//
@@ -690,7 +714,15 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 				}
 			}
 
-			if (deps[i]->effect->sets_virtual_output_size()) {
+			if (deps[i]->effect->is_compute_shader()) {
+				// Only one compute shader per phase; we should have been stopped
+				// already due to the fact that compute shaders are not one-to-one.
+				assert(!phase->is_compute_shader);
+
+				// If all nodes so far are strong one-to-one, we can put them after
+				// the compute shader (ie., process them on the output).
+				start_new_phase = !node->strong_one_to_one_sampling;
+			} else if (deps[i]->effect->sets_virtual_output_size()) {
 				assert(deps[i]->effect->changes_output_size());
 				// If the next effect sets a virtual size to rely on OpenGL's
 				// bilinear sampling, we'll really need to break the phase here.
@@ -709,6 +741,8 @@ Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *complete
 				// Propagate the one-to-one status down through the dependency.
 				deps[i]->one_to_one_sampling = node->one_to_one_sampling &&
 					deps[i]->effect->one_to_one_sampling();
+				deps[i]->strong_one_to_one_sampling = node->strong_one_to_one_sampling &&
+					deps[i]->effect->strong_one_to_one_sampling();
 			}
 		}
 	}
@@ -1722,8 +1756,15 @@ void EffectChain::add_dither_if_needed()
 void EffectChain::add_dummy_effect_if_needed()
 {
 	Node *output = find_output_node();
-	if (output->effect->is_compute_shader()) {
-		Node *dummy = add_node(new IdentityEffect());
+
+	// See if the last effect that's not strong one-to-one is a compute shader.
+	Node *last_effect = output;
+	while (last_effect->effect->num_inputs() == 1 &&
+	       last_effect->effect->strong_one_to_one_sampling()) {
+		last_effect = last_effect->incoming_links[0];
+	}
+	if (last_effect->effect->is_compute_shader()) {
+		Node *dummy = add_node(new ComputeShaderOutputDisplayEffect());
 		connect_nodes(output, dummy);
 		has_dummy_effect = true;
 	}
@@ -1905,7 +1946,7 @@ void EffectChain::render(GLuint dest_fbo, const vector<DestinationTexture> &dest
 		assert(num_phases >= 2);
 		assert(!phases.back()->is_compute_shader);
 		assert(phases.back()->effects.size() == 1);
-		assert(phases.back()->effects[0]->effect->effect_type_id() == "IdentityEffect");
+		assert(phases.back()->effects[0]->effect->effect_type_id() == "ComputeShaderOutputDisplayEffect");
 
 		// We are rendering to a set of textures, so we can run the compute shader
 		// directly and skip the dummy phase.
diff --git a/effect_chain.h b/effect_chain.h
index 716a970..793bf7b 100644
--- a/effect_chain.h
+++ b/effect_chain.h
@@ -153,6 +153,9 @@ private:
 	// (in the same phase) have one_to_one_sampling() set.
 	bool one_to_one_sampling;
 
+	// Same, for strong_one_to_one_sampling().
+	bool strong_one_to_one_sampling;
+
 	friend class EffectChain;
 };
 
@@ -181,6 +184,7 @@ struct Phase {
 	// Whether this phase is compiled as a compute shader, ie., the last effect is
 	// marked as one.
 	bool is_compute_shader;
+	Node *compute_shader_node;
 
 	// If <is_compute_shader>, which image unit the output buffer is bound to.
 	// This is used as source for a Uniform<int> below.
diff --git a/effect_chain_test.cpp b/effect_chain_test.cpp
index 92fe52b..551cdbc 100644
--- a/effect_chain_test.cpp
+++ b/effect_chain_test.cpp
@@ -1113,16 +1113,31 @@ public:
 	bool sets_virtual_output_size() const override { return false; }
 };
 
+class WithAndWithoutComputeShaderTest : public testing::TestWithParam<string> {
+};
+INSTANTIATE_TEST_CASE_P(WithAndWithoutComputeShaderTest,
+                        WithAndWithoutComputeShaderTest,
+                        testing::Values("fragment", "compute"));
+
+// An effect that does nothing, but as a compute shader.
+class IdentityComputeEffect : public Effect {
+public:
+	IdentityComputeEffect() {}
+	virtual string effect_type_id() const { return "IdentityComputeEffect"; }
+	virtual bool is_compute_shader() const { return true; }
+	string output_fragment_shader() { return read_file("identity.comp"); }
+};
+
 // An effect that promises one-to-one sampling (unlike IdentityEffect).
 class OneToOneEffect : public Effect {
 public:
 	OneToOneEffect() {}
 	string effect_type_id() const override { return "OneToOneEffect"; }
 	string output_fragment_shader() override { return read_file("identity.frag"); }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 };
 
-TEST(EffectChainTest, NoBounceWithOneToOneSampling) {
+TEST_P(WithAndWithoutComputeShaderTest, NoBounceWithOneToOneSampling) {
 	const int size = 2;
 	float data[size * size] = {
 		1.0f, 0.0f,
@@ -1135,7 +1150,11 @@ TEST(EffectChainTest, NoBounceWithOneToOneSampling) {
 	RewritingEffect<OneToOneEffect> *effect1 = new RewritingEffect<OneToOneEffect>();
 	RewritingEffect<OneToOneEffect> *effect2 = new RewritingEffect<OneToOneEffect>();
 
-	tester.get_chain()->add_effect(new NonVirtualResizeEffect(size, size));
+	if (GetParam() == "compute") {
+		tester.get_chain()->add_effect(new IdentityComputeEffect());
+	} else {
+		tester.get_chain()->add_effect(new NonVirtualResizeEffect(size, size));
+	}
 	tester.get_chain()->add_effect(effect1);
 	tester.get_chain()->add_effect(effect2);
 	tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
@@ -1302,21 +1321,6 @@ TEST(EffectChainTest, StringStreamLocalesWork) {
 	free(saved_locale);
 }
 
-// An effect that does nothing, but as a compute shader.
-class IdentityComputeEffect : public Effect {
-public:
-	IdentityComputeEffect() {}
-	string effect_type_id() const override { return "IdentityComputeEffect"; }
-	bool is_compute_shader() const override { return true; }
-	string output_fragment_shader() override { return read_file("identity.comp"); }
-};
-
-class WithAndWithoutComputeShaderTest : public testing::TestWithParam<string> {
-};
-INSTANTIATE_TEST_CASE_P(WithAndWithoutComputeShaderTest,
-                        WithAndWithoutComputeShaderTest,
-                        testing::Values("fragment", "compute"));
-
 TEST(EffectChainTest, sRGBIntermediate) {
 	float data[] = {
 		0.0f, 0.5f, 0.0f, 1.0f,
diff --git a/footer.comp b/footer.comp
index 16197a6..a28014d 100644
--- a/footer.comp
+++ b/footer.comp
@@ -22,6 +22,10 @@ void cs_output(uvec2 coord, vec4 val)
 
 void cs_output(ivec2 coord, vec4 val)
 {
+	// Run the value through any preprocessing steps we might have.
+	CS_OUTPUT_VAL = val;
+	val = CS_POSTPROC(vec2(0.0, 0.0));
+
 #if SQUARE_ROOT_TRANSFORMATION
 	// Make sure we don't give negative values to sqrt.
 	val.rgb = sqrt(max(val.rgb, 0.0));
diff --git a/gamma_compression_effect.h b/gamma_compression_effect.h
index f9c3297..9094f19 100644
--- a/gamma_compression_effect.h
+++ b/gamma_compression_effect.h
@@ -29,7 +29,7 @@ public:
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
 
 	bool needs_srgb_primaries() const override { return false; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// Actually needs postmultiplied input as well as outputting it.
 	// EffectChain will take care of that.
diff --git a/gamma_expansion_effect.h b/gamma_expansion_effect.h
index c4968b2..9565a3b 100644
--- a/gamma_expansion_effect.h
+++ b/gamma_expansion_effect.h
@@ -30,7 +30,7 @@ public:
 
 	bool needs_linear_light() const override { return false; }
 	bool needs_srgb_primaries() const override { return false; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// Actually processes its input in a nonlinear fashion,
 	// but does not touch alpha, and we are a special case anyway.
diff --git a/glow_effect.h b/glow_effect.h
index e159999..340cf3d 100644
--- a/glow_effect.h
+++ b/glow_effect.h
@@ -52,7 +52,7 @@ public:
 	std::string output_fragment_shader() override;
 	
 	AlphaHandling alpha_handling() const override { return INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 private:
 	float cutoff;
diff --git a/header.comp b/header.comp
index d922e33..3c07007 100644
--- a/header.comp
+++ b/header.comp
@@ -10,4 +10,8 @@ vec4 tex2D(sampler2D s, vec2 coord);
 void cs_output(uvec2 coord, vec4 val);
 void cs_output(ivec2 coord, vec4 val);
 
+// Used if there are any steps used to postprocess compute shader output.
+// Initialized due to https://bugs.freedesktop.org/show_bug.cgi?id=103895.
+vec4 CS_OUTPUT_VAL = vec4(0.0);
+
 #define OUTPUT(tc, val) cs_output(tc, val)
diff --git a/lift_gamma_gain_effect.h b/lift_gamma_gain_effect.h
index 19d9b20..6e2ea19 100644
--- a/lift_gamma_gain_effect.h
+++ b/lift_gamma_gain_effect.h
@@ -32,7 +32,7 @@ public:
 	LiftGammaGainEffect();
 	std::string effect_type_id() const override { return "LiftGammaGainEffect"; }
 	AlphaHandling alpha_handling() const override { return INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 	std::string output_fragment_shader() override;
 
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
diff --git a/luma_mix_effect.h b/luma_mix_effect.h
index fec402f..1272731 100644
--- a/luma_mix_effect.h
+++ b/luma_mix_effect.h
@@ -26,7 +26,7 @@ public:
 
 	bool needs_srgb_primaries() const override { return false; }
 	unsigned num_inputs() const override { return 3; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 	AlphaHandling alpha_handling() const override { return INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK; }
 
 private:
diff --git a/mix_effect.h b/mix_effect.h
index 1305433..850baae 100644
--- a/mix_effect.h
+++ b/mix_effect.h
@@ -18,7 +18,7 @@ public:
 
 	bool needs_srgb_primaries() const override { return false; }
 	unsigned num_inputs() const override { return 2; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// TODO: In the common case where a+b=1, it would be useful to be able to set
 	// alpha_handling() to INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK. However, right now
diff --git a/multiply_effect.h b/multiply_effect.h
index 9e3542d..40a7a72 100644
--- a/multiply_effect.h
+++ b/multiply_effect.h
@@ -18,7 +18,7 @@ public:
 	MultiplyEffect();
 	std::string effect_type_id() const override { return "MultiplyEffect"; }
 	std::string output_fragment_shader() override;
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 private:
 	RGBATuple factor;
diff --git a/overlay_effect.h b/overlay_effect.h
index 2f88d12..29c0941 100644
--- a/overlay_effect.h
+++ b/overlay_effect.h
@@ -24,7 +24,7 @@ public:
 
 	bool needs_srgb_primaries() const override { return false; }
 	unsigned num_inputs() const override { return 2; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// Actually, if _either_ image has blank alpha, our output will have
 	// blank alpha, too (this only tells the framework that having _both_
diff --git a/saturation_effect.h b/saturation_effect.h
index 7e108e8..8a3aece 100644
--- a/saturation_effect.h
+++ b/saturation_effect.h
@@ -18,7 +18,7 @@ public:
 	SaturationEffect();
 	std::string effect_type_id() const override { return "SaturationEffect"; }
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 	std::string output_fragment_shader() override;
 
 private:
diff --git a/version.h b/version.h
index e73f188..da4b1ee 100644
--- a/version.h
+++ b/version.h
@@ -5,6 +5,6 @@
 // changes, even within git versions. There is no specific version
 // documentation outside the regular changelogs, though.
 
-#define MOVIT_VERSION 33
+#define MOVIT_VERSION 34
 
 #endif // !defined(_MOVIT_VERSION_H)
diff --git a/vignette_effect.h b/vignette_effect.h
index 8a2229c..2239f96 100644
--- a/vignette_effect.h
+++ b/vignette_effect.h
@@ -19,7 +19,7 @@ public:
 
 	bool needs_srgb_primaries() const override { return false; }
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	void inform_input_size(unsigned input_num, unsigned width, unsigned height) override;
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
diff --git a/white_balance_effect.h b/white_balance_effect.h
index cf2c58b..01dcc7e 100644
--- a/white_balance_effect.h
+++ b/white_balance_effect.h
@@ -16,7 +16,7 @@ public:
 	WhiteBalanceEffect();
 	std::string effect_type_id() const override { return "WhiteBalanceEffect"; }
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 	std::string output_fragment_shader() override;
 
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
diff --git a/ycbcr_conversion_effect.h b/ycbcr_conversion_effect.h
index ce456ce..752eb43 100644
--- a/ycbcr_conversion_effect.h
+++ b/ycbcr_conversion_effect.h
@@ -26,7 +26,7 @@ public:
 	std::string output_fragment_shader() override;
 	void set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) override;
 	AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
-	bool one_to_one_sampling() const override { return true; }
+	bool strong_one_to_one_sampling() const override { return true; }
 
 	// Should not be called by end users; call
 	// EffectChain::change_ycbcr_output_format() instead.