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 92581710c0c739c418dbc342683f85be10b4e03a..554a1868751c969c4688bab4464b26f276fbdef1 100644 (file)
--- 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 85f08f87d1fac288ee87c2371579e2c38137671b..50333cbcf7b42f87b346c19a253f3d6babc6aa1d 100644 (file)
--- 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 d8754654d6d2b5023fa669197c617389cb40933a..a59d4766a8ba3699b23723d6b87fd64cab4dc6c4 100644 (file)
--- 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 253126eb9f78b298d2691f128111a4763d3f4ff7..a8babd0e92a518f0ee58542c6e8d7e63ae2be6a6 100644 (file)
--- 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 71bb6d35723d3a19b3ca91be4175f5af5bcb0e1b..b1bbbff4168cec94708557c32c2f2f1d93dcef9a 100644 (file)
--- 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 afac5dc91c840ad6f273786498c1233547927343..ba39d6a3cf5bbdc88503214062fd6e075c3da48e 100644 (file)
--- 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 23156cb2db604422a7b3ecf66f24f345cac36a8c..c6bac8078e13b10ed9af621e9b00e80f9cfa8361 100644 (file)
--- 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 716a970a3ab59748e99d94da43b2a9239fdca871..793bf7b0b2f2ddce1bf7fe02e0532989c3c78995 100644 (file)
--- 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 92fe52b1ecfcd0974ecf5e252f0de6b538b5beaf..551cdbcaabd607d1cc50f762f00190e1b99a3816 100644 (file)
--- 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 16197a63200019396c20661bc0edbb8128fad206..a28014d684b69af8985b9fe911b2db400c089a6c 100644 (file)
--- 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 f9c329728aee33cdcaed457aad2c19d92c69d662..9094f1964acfd9e10e7fb9844b07965b5564c1be 100644 (file)
--- 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 c4968b2f27cee43e6a5ffd579d2ff06c968199df..9565a3b0e4d5d0654bb1d6f197067e4a6d88af3e 100644 (file)
--- 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 e1599998f74503feda82170eb505fe13e636bb11..340cf3d76888950ee3c536794c1bb32f1b360595 100644 (file)
--- 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 d922e33efedaaf511f61a9406a1b6bf6a8db7a51..3c07007c5f3c8fe2b0524ac3049b379866b3fb06 100644 (file)
--- 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 19d9b2020af943a3f9eb3d90577a315e9de31e46..6e2ea19a4d54231620d6eb6039e67571a98e5c16 100644 (file)
--- 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 fec402fd89dd53048844ec9f70b4358d80ed6772..1272731b34fc9bef5367332cac92d0e0658b1482 100644 (file)
--- 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 1305433d096a758bc701c5d233d855706dc170dd..850baae6c333f5b2c3a09a61ebe6635fc5495598 100644 (file)
--- 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 9e3542de65969fbbc084da7b267747d9b4132ea9..40a7a72791b8a332e3eda52d00b85ba5c86e6d1e 100644 (file)
--- 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 2f88d12caa3b1aa2cb6c3cdff9c6754bc08b1d77..29c09416ddea3f79aaf3ee733870ff66468f0b1f 100644 (file)
--- 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 7e108e8db48362528eb7f275f02cc026b1ebbd27..8a3aece844aa45b9cce0d0d36e0fb4231189c33d 100644 (file)
--- 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 e73f188ebd4665e4d74153c53386983e2b55f687..da4b1ee03086a1ec3a5fc5fc77df9e22d66cfe54 100644 (file)
--- 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 8a2229cfd0ffb8f502c4b7c3ead5638dc7718a0a..2239f969b536d6500fc1cf097b02a9cfcdf7127f 100644 (file)
--- 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 cf2c58bce8a1f5a4f54f9f0596c2eaf9bece3ac6..01dcc7e24d18a902eec255fb7f056dfbb43d303d 100644 (file)
--- 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 ce456ceda7ebe06b0653bbbd341ad245be5865b4..752eb43934d5682f00651dc8ededb5626f07432c 100644 (file)
--- 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.