Support chaining certain effects after compute shaders.
authorSteinar H. Gunderson <sgunderson@bigfoot.com>
Fri, 24 Nov 2017 21:11:08 +0000 (22:11 +0100)
committerSteinar H. Gunderson <sgunderson@bigfoot.com>
Fri, 24 Nov 2017 21:12:15 +0000 (22:12 +0100)
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).

24 files changed:
alpha_division_effect.h
alpha_multiplication_effect.h
colorspace_conversion_effect.h
diffusion_effect.h
dither_effect.h
effect.h
effect_chain.cpp
effect_chain.h
effect_chain_test.cpp
footer.comp
gamma_compression_effect.h
gamma_expansion_effect.h
glow_effect.h
header.comp
lift_gamma_gain_effect.h
luma_mix_effect.h
mix_effect.h
multiply_effect.h
overlay_effect.h
saturation_effect.h
version.h
vignette_effect.h
white_balance_effect.h
ycbcr_conversion_effect.h

index 9258171..554a186 100644 (file)
@@ -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
index 85f08f8..50333cb 100644 (file)
@@ -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
index d875465..a59d476 100644 (file)
@@ -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);
index 253126e..a8babd0 100644 (file)
@@ -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;
index 71bb6d3..b1bbbff 100644 (file)
@@ -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;
 
index afac5dc..ba39d6a 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
index 23156cb..c6bac80 100644 (file)
@@ -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.
index 716a970..793bf7b 100644 (file)
@@ -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.
index 92fe52b..551cdbc 100644 (file)
@@ -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,
index 16197a6..a28014d 100644 (file)
@@ -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));
index f9c3297..9094f19 100644 (file)
@@ -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.
index c4968b2..9565a3b 100644 (file)
@@ -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.
index e159999..340cf3d 100644 (file)
@@ -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;
index d922e33..3c07007 100644 (file)
@@ -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)
index 19d9b20..6e2ea19 100644 (file)
@@ -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;
index fec402f..1272731 100644 (file)
@@ -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:
index 1305433..850baae 100644 (file)
@@ -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
index 9e3542d..40a7a72 100644 (file)
@@ -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;
index 2f88d12..29c0941 100644 (file)
@@ -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_
index 7e108e8..8a3aece 100644 (file)
@@ -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:
index e73f188..da4b1ee 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)
index 8a2229c..2239f96 100644 (file)
@@ -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;
index cf2c58b..01dcc7e 100644 (file)
@@ -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;
index ce456ce..752eb43 100644 (file)
@@ -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.