+#include "init.h"
+#include "input.h"
+#include "mirror_effect.h"
+#include "multiply_effect.h"
+#include "resize_effect.h"
+#include "resource_pool.h"
+#include "test_util.h"
+#include "util.h"
+
+using namespace std;
+
+namespace movit {
+
+TEST(EffectChainTest, EmptyChain) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(data, out_data, 3, 2);
+}
+
+// An effect that does nothing.
+class IdentityEffect : public Effect {
+public:
+ IdentityEffect() {}
+ string effect_type_id() const override { return "IdentityEffect"; }
+ string output_fragment_shader() override { return read_file("identity.frag"); }
+};
+
+TEST(EffectChainTest, Identity) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(new IdentityEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(data, out_data, 3, 2);
+}
+
+// An effect that does nothing, but requests texture bounce.
+class BouncingIdentityEffect : public Effect {
+public:
+ BouncingIdentityEffect() {}
+ string effect_type_id() const override { return "IdentityEffect"; }
+ string output_fragment_shader() override { return read_file("identity.frag"); }
+ bool needs_texture_bounce() const override { return true; }
+ AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
+};
+
+TEST(EffectChainTest, TextureBouncePreservesIdentity) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(new BouncingIdentityEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(data, out_data, 3, 2);
+}
+
+TEST(MirrorTest, BasicTest) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float expected_data[6] = {
+ 0.3f, 0.25f, 0.0f,
+ 1.0f, 1.0f, 0.75f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(new MirrorEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+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"); }
+};
+
+TEST_P(WithAndWithoutComputeShaderTest, TopLeftOrigin) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ // Note that EffectChainTester assumes bottom-left origin, so by setting
+ // top-left, we will get flipped data back.
+ float expected_data[6] = {
+ 0.75f, 1.0f, 1.0f,
+ 0.0f, 0.25f, 0.3f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->set_output_origin(OUTPUT_ORIGIN_TOP_LEFT);
+ if (GetParam() == "compute") {
+ tester.get_chain()->add_effect(new IdentityComputeEffect());
+ }
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+// A dummy effect that inverts its input.
+class InvertEffect : public Effect {
+public:
+ InvertEffect() {}
+ string effect_type_id() const override { return "InvertEffect"; }
+ string output_fragment_shader() override { return read_file("invert_effect.frag"); }
+
+ // A real invert would actually care about its alpha,
+ // but in this unit test, it only complicates things.
+ AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
+};
+
+// Like IdentityEffect, but rewrites itself out of the loop,
+// splicing in a different effect instead. Also stores the new node,
+// so we later can check whatever properties we'd like about the graph.
+template<class T>
+class RewritingEffect : public Effect {
+public:
+ template<class... Args>
+ RewritingEffect(Args &&... args) : effect(new T(std::forward<Args>(args)...)), replaced_node(nullptr) {}
+ string effect_type_id() const override { return "RewritingEffect[" + effect->effect_type_id() + "]"; }
+ string output_fragment_shader() override { EXPECT_TRUE(false); return read_file("identity.frag"); }
+ void rewrite_graph(EffectChain *graph, Node *self) override {
+ replaced_node = graph->add_node(effect);
+ graph->replace_receiver(self, replaced_node);
+ graph->replace_sender(self, replaced_node);
+ self->disabled = true;
+ }
+
+ T *effect;
+ Node *replaced_node;
+};
+
+TEST(EffectChainTest, RewritingWorksAndGammaConversionsAreInserted) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float expected_data[6] = {
+ 1.0f, 0.9771f, 0.9673f,
+ 0.7192f, 0.0f, 0.0f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_sRGB);
+ RewritingEffect<InvertEffect> *effect = new RewritingEffect<InvertEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_sRGB);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ ASSERT_EQ(1u, node->outgoing_links.size());
+ EXPECT_EQ("GammaExpansionEffect", node->incoming_links[0]->effect->effect_type_id());
+ EXPECT_EQ("GammaCompressionEffect", node->outgoing_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+TEST(EffectChainTest, RewritingWorksAndTexturesAreAskedForsRGB) {
+ unsigned char data[] = {
+ 0, 0, 0, 255,
+ 64, 64, 64, 255,
+ 128, 128, 128, 255,
+ 255, 255, 255, 255,
+ };
+ float expected_data[] = {
+ 1.0000f, 1.0000f, 1.0000f, 1.0000f,
+ 0.9771f, 0.9771f, 0.9771f, 1.0000f,
+ 0.8983f, 0.8983f, 0.8983f, 1.0000f,
+ 0.0000f, 0.0000f, 0.0000f, 1.0000f
+ };
+ float out_data[4 * 4];
+ EffectChainTester tester(nullptr, 1, 4);
+ tester.add_input(data, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_sRGB);
+ RewritingEffect<InvertEffect> *effect = new RewritingEffect<InvertEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_sRGB);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ ASSERT_EQ(1u, node->outgoing_links.size());
+ EXPECT_EQ("FlatInput", node->incoming_links[0]->effect->effect_type_id());
+ EXPECT_EQ("GammaCompressionEffect", node->outgoing_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 4, 4);
+}
+
+TEST(EffectChainTest, RewritingWorksAndColorspaceConversionsAreInserted) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float expected_data[6] = {
+ 1.0f, 0.75f, 0.7f,
+ 0.25f, 0.0f, 0.0f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_REC_601_525, GAMMA_LINEAR);
+ RewritingEffect<InvertEffect> *effect = new RewritingEffect<InvertEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RED, COLORSPACE_REC_601_525, GAMMA_LINEAR);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ ASSERT_EQ(1u, node->outgoing_links.size());
+ EXPECT_EQ("ColorspaceConversionEffect", node->incoming_links[0]->effect->effect_type_id());
+ EXPECT_EQ("ColorspaceConversionEffect", node->outgoing_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+// A fake input that can change its output colorspace and gamma between instantiation
+// and finalize.
+class UnknownColorspaceInput : public FlatInput {
+public:
+ UnknownColorspaceInput(ImageFormat format, MovitPixelFormat pixel_format, GLenum type, unsigned width, unsigned height)
+ : FlatInput(format, pixel_format, type, width, height),
+ overridden_color_space(format.color_space),
+ overridden_gamma_curve(format.gamma_curve) {}
+ string effect_type_id() const override { return "UnknownColorspaceInput"; }
+
+ void set_color_space(Colorspace colorspace) {
+ overridden_color_space = colorspace;
+ }
+ void set_gamma_curve(GammaCurve gamma_curve) {
+ overridden_gamma_curve = gamma_curve;
+ }
+ Colorspace get_color_space() const override { return overridden_color_space; }
+ GammaCurve get_gamma_curve() const override { return overridden_gamma_curve; }
+
+private:
+ Colorspace overridden_color_space;
+ GammaCurve overridden_gamma_curve;
+};
+
+TEST(EffectChainTest, HandlesInputChangingColorspace) {
+ const int size = 4;
+
+ float data[size] = {
+ 0.0,
+ 0.5,
+ 0.7,
+ 1.0,
+ };
+ float out_data[size];
+
+ EffectChainTester tester(nullptr, 4, 1, FORMAT_GRAYSCALE);
+
+ // First say that we have sRGB, linear input.
+ ImageFormat format;
+ format.color_space = COLORSPACE_sRGB;
+ format.gamma_curve = GAMMA_LINEAR;
+
+ UnknownColorspaceInput *input = new UnknownColorspaceInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 4, 1);
+ input->set_pixel_data(data);
+ tester.get_chain()->add_input(input);
+
+ // Now we change to Rec. 601 input.
+ input->set_color_space(COLORSPACE_REC_601_625);
+ input->set_gamma_curve(GAMMA_REC_601);
+
+ // Now ask for Rec. 601 output. Thus, our chain should now be a no-op.
+ tester.run(out_data, GL_RED, COLORSPACE_REC_601_625, GAMMA_REC_601);
+ expect_equal(data, out_data, 4, 1);
+}
+
+TEST(EffectChainTest, NoGammaConversionsWhenLinearLightNotNeeded) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float expected_data[6] = {
+ 0.3f, 0.25f, 0.0f,
+ 1.0f, 1.0f, 0.75f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_sRGB);
+ RewritingEffect<MirrorEffect> *effect = new RewritingEffect<MirrorEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_sRGB);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ EXPECT_EQ(0u, node->outgoing_links.size());
+ EXPECT_EQ("FlatInput", node->incoming_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+TEST(EffectChainTest, NoColorspaceConversionsWhensRGBPrimariesNotNeeded) {
+ float data[] = {
+ 0.0f, 0.25f, 0.3f,
+ 0.75f, 1.0f, 1.0f,
+ };
+ float expected_data[6] = {
+ 0.3f, 0.25f, 0.0f,
+ 1.0f, 1.0f, 0.75f,
+ };
+ float out_data[6];
+ EffectChainTester tester(data, 3, 2, FORMAT_GRAYSCALE, COLORSPACE_REC_601_525, GAMMA_LINEAR);
+ RewritingEffect<MirrorEffect> *effect = new RewritingEffect<MirrorEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RED, COLORSPACE_REC_601_525, GAMMA_LINEAR);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ EXPECT_EQ(0u, node->outgoing_links.size());
+ EXPECT_EQ("FlatInput", node->incoming_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 3, 2);
+}
+
+// The identity effect needs linear light, and thus will get conversions on both sides.
+// Verify that sRGB data is properly converted to and from linear light for the entire ramp.
+TEST(EffectChainTest, IdentityThroughsRGBConversions) {
+ float data[256];
+ for (unsigned i = 0; i < 256; ++i) {
+ data[i] = i / 255.0;
+ };
+ float out_data[256];
+ EffectChainTester tester(data, 256, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_sRGB);
+ tester.get_chain()->add_effect(new IdentityEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_sRGB);
+
+ expect_equal(data, out_data, 256, 1);
+}
+
+// Same, but uses the forward sRGB table from the GPU.
+TEST(EffectChainTest, IdentityThroughGPUsRGBConversions) {
+ unsigned char data[256];
+ float expected_data[256];
+ for (unsigned i = 0; i < 256; ++i) {
+ data[i] = i;
+ expected_data[i] = i / 255.0;
+ };
+ float out_data[256];
+ EffectChainTester tester(nullptr, 256, 1);
+ tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_sRGB);
+ tester.get_chain()->add_effect(new IdentityEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_sRGB);
+
+ expect_equal(expected_data, out_data, 256, 1);
+}
+
+// Same, for the Rec. 601/709 gamma curve.
+TEST(EffectChainTest, IdentityThroughRec709) {
+ float data[256];
+ for (unsigned i = 0; i < 256; ++i) {
+ data[i] = i / 255.0;
+ };
+ float out_data[256];
+ EffectChainTester tester(data, 256, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_REC_709);
+ tester.get_chain()->add_effect(new IdentityEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_REC_709);
+
+ expect_equal(data, out_data, 256, 1);
+}
+
+// The identity effect needs premultiplied alpha, and thus will get conversions on both sides.
+TEST(EffectChainTest, IdentityThroughAlphaConversions) {
+ const int size = 3;
+ float data[4 * size] = {
+ 0.8f, 0.0f, 0.0f, 0.5f,
+ 0.0f, 0.2f, 0.2f, 0.3f,
+ 0.1f, 0.0f, 1.0f, 1.0f,
+ };
+ float out_data[4 * size];
+ EffectChainTester tester(data, size, 1, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(new IdentityEffect());
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(data, out_data, 4, size);
+}
+
+TEST(EffectChainTest, NoAlphaConversionsWhenPremultipliedAlphaNotNeeded) {
+ const int size = 3;
+ float data[4 * size] = {
+ 0.8f, 0.0f, 0.0f, 0.5f,
+ 0.0f, 0.2f, 0.2f, 0.3f,
+ 0.1f, 0.0f, 1.0f, 1.0f,
+ };
+ float expected_data[4 * size] = {
+ 0.1f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.2f, 0.2f, 0.3f,
+ 0.8f, 0.0f, 0.0f, 0.5f,
+ };
+ float out_data[4 * size];
+ EffectChainTester tester(data, size, 1, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, GAMMA_LINEAR);
+ RewritingEffect<MirrorEffect> *effect = new RewritingEffect<MirrorEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ Node *node = effect->replaced_node;
+ ASSERT_EQ(1u, node->incoming_links.size());
+ EXPECT_EQ(0u, node->outgoing_links.size());
+ EXPECT_EQ("FlatInput", node->incoming_links[0]->effect->effect_type_id());
+
+ expect_equal(expected_data, out_data, 4, size);
+}
+
+// An input that outputs only blue, which has blank alpha.
+class BlueInput : public Input {
+public:
+ BlueInput() { register_int("needs_mipmaps", &needs_mipmaps); }
+ string effect_type_id() const override { return "IdentityEffect"; }
+ string output_fragment_shader() override { return read_file("blue.frag"); }
+ AlphaHandling alpha_handling() const override { return OUTPUT_BLANK_ALPHA; }
+ bool can_output_linear_gamma() const override { return true; }
+ unsigned get_width() const override { return 1; }
+ unsigned get_height() const override { return 1; }
+ Colorspace get_color_space() const override { return COLORSPACE_sRGB; }
+ GammaCurve get_gamma_curve() const override { return GAMMA_LINEAR; }
+
+private:
+ int needs_mipmaps;
+};
+
+// Like RewritingEffect<InvertEffect>, but splicing in a BlueInput instead,
+// which outputs blank alpha.
+class RewritingToBlueInput : public Input {
+public:
+ RewritingToBlueInput() : blue_node(nullptr) { register_int("needs_mipmaps", &needs_mipmaps); }
+ string effect_type_id() const override { return "RewritingToBlueInput"; }
+ string output_fragment_shader() override { EXPECT_TRUE(false); return read_file("identity.frag"); }
+ void rewrite_graph(EffectChain *graph, Node *self) override {
+ Node *blue_node = graph->add_node(new BlueInput());
+ graph->replace_receiver(self, blue_node);
+ graph->replace_sender(self, blue_node);
+
+ self->disabled = true;
+ this->blue_node = blue_node;
+ }
+
+ // Dummy values that we need to implement because we inherit from Input.
+ // Same as BlueInput.
+ AlphaHandling alpha_handling() const override { return OUTPUT_BLANK_ALPHA; }
+ bool can_output_linear_gamma() const override { return true; }
+ unsigned get_width() const override { return 1; }
+ unsigned get_height() const override { return 1; }
+ Colorspace get_color_space() const override { return COLORSPACE_sRGB; }
+ GammaCurve get_gamma_curve() const override { return GAMMA_LINEAR; }
+
+ Node *blue_node;
+
+private:
+ int needs_mipmaps;
+};
+
+TEST(EffectChainTest, NoAlphaConversionsWithBlankAlpha) {
+ const int size = 3;
+ float data[4 * size] = {
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ };
+ float out_data[4 * size];
+ EffectChainTester tester(nullptr, size, 1);
+ RewritingToBlueInput *input = new RewritingToBlueInput();
+ tester.get_chain()->add_input(input);
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
+
+ Node *node = input->blue_node;
+ EXPECT_EQ(0u, node->incoming_links.size());
+ EXPECT_EQ(0u, node->outgoing_links.size());
+
+ expect_equal(data, out_data, 4, size);
+}
+
+// An effect that does nothing, and specifies that it preserves blank alpha.
+class BlankAlphaPreservingEffect : public Effect {
+public:
+ BlankAlphaPreservingEffect() {}
+ string effect_type_id() const override { return "BlankAlphaPreservingEffect"; }
+ string output_fragment_shader() override { return read_file("identity.frag"); }
+ AlphaHandling alpha_handling() const override { return INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK; }
+};
+
+TEST(EffectChainTest, NoAlphaConversionsWithBlankAlphaPreservingEffect) {
+ const int size = 3;
+ float data[4 * size] = {
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ };
+ float out_data[4 * size];
+ EffectChainTester tester(nullptr, size, 1);
+ tester.get_chain()->add_input(new BlueInput());
+ tester.get_chain()->add_effect(new BlankAlphaPreservingEffect());
+ RewritingEffect<MirrorEffect> *effect = new RewritingEffect<MirrorEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED);
+
+ Node *node = effect->replaced_node;
+ EXPECT_EQ(1u, node->incoming_links.size());
+ EXPECT_EQ(0u, node->outgoing_links.size());
+
+ expect_equal(data, out_data, 4, size);
+}
+
+// This is the counter-test to NoAlphaConversionsWithBlankAlphaPreservingEffect;
+// just to be sure that with a normal INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA effect,
+// an alpha conversion _should_ be inserted at the very end. (There is some overlap
+// with other tests.)
+TEST(EffectChainTest, AlphaConversionsWithNonBlankAlphaPreservingEffect) {
+ const int size = 3;
+ float data[4 * size] = {
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 1.0f,
+ };
+ float out_data[4 * size];
+ EffectChainTester tester(nullptr, size, 1);
+ tester.get_chain()->add_input(new BlueInput());
+ tester.get_chain()->add_effect(new IdentityEffect()); // Not BlankAlphaPreservingEffect.
+ RewritingEffect<MirrorEffect> *effect = new RewritingEffect<MirrorEffect>();
+ tester.get_chain()->add_effect(effect);
+ tester.run(out_data, GL_RGBA, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED);
+
+ Node *node = effect->replaced_node;
+ EXPECT_EQ(1u, node->incoming_links.size());
+ EXPECT_EQ(1u, node->outgoing_links.size());
+ EXPECT_EQ("AlphaDivisionEffect", node->outgoing_links[0]->effect->effect_type_id());
+
+ expect_equal(data, out_data, 4, size);
+}
+
+// Effectively scales down its input linearly by 4x (and repeating it),
+// which is not attainable without mipmaps.
+class MipmapNeedingEffect : public Effect {
+public:
+ MipmapNeedingEffect() {}
+ MipmapRequirements needs_mipmaps() const override { return NEEDS_MIPMAPS; }
+
+ // To be allowed to mess with the sampler state.
+ bool needs_texture_bounce() const override { return true; }
+
+ string effect_type_id() const override { return "MipmapNeedingEffect"; }
+ string output_fragment_shader() override { return read_file("mipmap_needing_effect.frag"); }
+ void inform_added(EffectChain *chain) override { this->chain = chain; }
+
+ void set_gl_state(GLuint glsl_program_num, const string& prefix, unsigned *sampler_num) override
+ {
+ Node *self = chain->find_node_for_effect(this);
+ glActiveTexture(chain->get_input_sampler(self, 0));
+ check_error();
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ check_error();
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ check_error();
+ }
+
+private:
+ EffectChain *chain;
+};
+
+TEST(EffectChainTest, MipmapGenerationWorks) {
+ float data[] = { // In 4x4 blocks.
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.5f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ };
+ float expected_data[] = { // Repeated four times each way.
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+ };
+ float out_data[4 * 16];
+ EffectChainTester tester(data, 4, 16, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(new MipmapNeedingEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 4, 16);
+}
+
+class NonMipmapCapableInput : public FlatInput {
+public:
+ NonMipmapCapableInput(ImageFormat format, MovitPixelFormat pixel_format, GLenum type, unsigned width, unsigned height)
+ : FlatInput(format, pixel_format, type, width, height) {}
+
+ bool can_supply_mipmaps() const override { return false; }
+ bool set_int(const std::string& key, int value) override {
+ if (key == "needs_mipmaps") {
+ assert(value == 0);
+ }
+ return FlatInput::set_int(key, value);
+ }
+};
+
+// The same test as MipmapGenerationWorks, but with an input that refuses
+// to supply mipmaps.
+TEST(EffectChainTest, MipmapsWithNonMipmapCapableInput) {
+ float data[] = { // In 4x4 blocks.
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.5f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ };
+ float expected_data[] = { // Repeated four times each way.
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.09375f, 0.09375f, 0.09375f, 0.09375f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 0.25f, 0.25f, 0.25f,
+ };
+ float out_data[4 * 16];
+ EffectChainTester tester(nullptr, 4, 16, FORMAT_GRAYSCALE);
+
+ ImageFormat format;
+ format.color_space = COLORSPACE_sRGB;
+ format.gamma_curve = GAMMA_LINEAR;
+
+ NonMipmapCapableInput *input = new NonMipmapCapableInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 4, 16);
+ input->set_pixel_data(data);
+ tester.get_chain()->add_input(input);
+ tester.get_chain()->add_effect(new MipmapNeedingEffect());
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 4, 16);
+}
+
+TEST(EffectChainTest, ResizeDownByFourThenUpByFour) {
+ float data[] = { // In 4x4 blocks.
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.5f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ };
+ float expected_data[] = { // Repeated four times horizontaly, interpolated vertically.
+ 0.1250f, 0.1250f, 0.1250f, 0.1250f,
+ 0.1250f, 0.1250f, 0.1250f, 0.1250f,
+ 0.1211f, 0.1211f, 0.1211f, 0.1211f,
+ 0.1133f, 0.1133f, 0.1133f, 0.1133f,
+ 0.1055f, 0.1055f, 0.1055f, 0.1055f,
+ 0.0977f, 0.0977f, 0.0977f, 0.0977f,
+ 0.2070f, 0.2070f, 0.2070f, 0.2070f,
+ 0.4336f, 0.4336f, 0.4336f, 0.4336f,
+ 0.6602f, 0.6602f, 0.6602f, 0.6602f,
+ 0.8867f, 0.8867f, 0.8867f, 0.8867f,
+ 0.9062f, 0.9062f, 0.9062f, 0.9062f,
+ 0.7188f, 0.7188f, 0.7188f, 0.7188f,
+ 0.5312f, 0.5312f, 0.5312f, 0.5312f,
+ 0.3438f, 0.3438f, 0.3438f, 0.3438f,
+ 0.2500f, 0.2500f, 0.2500f, 0.2500f,
+ 0.2500f, 0.2500f, 0.2500f, 0.2500f,
+ };
+ float out_data[4 * 16];
+
+ ResizeEffect *downscale = new ResizeEffect();
+ ASSERT_TRUE(downscale->set_int("width", 1));
+ ASSERT_TRUE(downscale->set_int("height", 4));
+
+ ResizeEffect *upscale = new ResizeEffect();
+ ASSERT_TRUE(upscale->set_int("width", 4));
+ ASSERT_TRUE(upscale->set_int("height", 16));
+
+ EffectChainTester tester(data, 4, 16, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(downscale);
+ tester.get_chain()->add_effect(upscale);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 4, 16);
+}
+
+// An effect to verify that you can turn off mipmaps; it downscales by two,
+// which gives blur with mipmaps and aliasing (picks out every other pixel)
+// without.
+class Downscale2xEffect : public Effect {
+public:
+ explicit Downscale2xEffect(MipmapRequirements mipmap_requirements)
+ : mipmap_requirements(mipmap_requirements)
+ {
+ register_vec2("offset", offset);
+ }
+ MipmapRequirements needs_mipmaps() const override { return mipmap_requirements; }
+
+ string effect_type_id() const override { return "Downscale2xEffect"; }
+ string output_fragment_shader() override { return read_file("downscale2x.frag"); }
+
+private:
+ const MipmapRequirements mipmap_requirements;
+ EffectChain *chain;
+ float offset[2] { 0.0f, 0.0f };
+};
+
+TEST(EffectChainTest, MipmapChainGetsSplit) {
+ float data[] = {
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 0.0f,
+ };
+
+ // The intermediate result after the first step looks like this,
+ // assuming there are no mipmaps (the zeros are due to border behavior):
+ //
+ // 0 0 0 0
+ // 0 0 0 0
+ // 1 1 0 0
+ // 1 1 0 0
+ //
+ // so another 2x downscale towards the bottom left will give
+ //
+ // 0 0
+ // 1 0
+ //
+ // with yet more zeros coming in on the top and the right from the border.
+ float expected_data[] = {
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ };
+ float out_data[4 * 4];
+
+ float offset[] = { -0.5f / 4.0f, -0.5f / 4.0f };
+ RewritingEffect<Downscale2xEffect> *pick_out_bottom_left = new RewritingEffect<Downscale2xEffect>(Effect::CANNOT_ACCEPT_MIPMAPS);
+ ASSERT_TRUE(pick_out_bottom_left->effect->set_vec2("offset", offset));
+
+ RewritingEffect<Downscale2xEffect> *downscale2x = new RewritingEffect<Downscale2xEffect>(Effect::NEEDS_MIPMAPS);
+
+ EffectChainTester tester(data, 4, 4, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
+ tester.get_chain()->add_effect(pick_out_bottom_left);
+ tester.get_chain()->add_effect(downscale2x);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ EXPECT_NE(pick_out_bottom_left->replaced_node->containing_phase,
+ downscale2x->replaced_node->containing_phase);
+
+ expect_equal(expected_data, out_data, 4, 4);
+}
+
+// An effect that adds its two inputs together. Used below.
+class AddEffect : public Effect {
+public:
+ AddEffect() {}
+ string effect_type_id() const override { return "AddEffect"; }
+ string output_fragment_shader() override { return read_file("add.frag"); }
+ unsigned num_inputs() const override { return 2; }
+ AlphaHandling alpha_handling() const override { return DONT_CARE_ALPHA_TYPE; }
+};
+
+// Constructs the graph
+//
+// FlatInput |
+// / \ |
+// MultiplyEffect MultiplyEffect |
+// \ / |
+// AddEffect |
+//
+// and verifies that it gives the correct output.
+TEST(EffectChainTest, DiamondGraph) {
+ float data[] = {
+ 1.0f, 1.0f,
+ 1.0f, 0.0f,
+ };
+ float expected_data[] = {
+ 2.5f, 2.5f,
+ 2.5f, 0.0f,
+ };
+ float out_data[2 * 2];
+
+ const float half[] = { 0.5f, 0.5f, 0.5f, 0.5f };
+ const float two[] = { 2.0f, 2.0f, 2.0f, 0.5f };
+
+ MultiplyEffect *mul_half = new MultiplyEffect();
+ ASSERT_TRUE(mul_half->set_vec4("factor", half));
+
+ MultiplyEffect *mul_two = new MultiplyEffect();
+ ASSERT_TRUE(mul_two->set_vec4("factor", two));
+
+ EffectChainTester tester(nullptr, 2, 2);
+
+ ImageFormat format;
+ format.color_space = COLORSPACE_sRGB;
+ format.gamma_curve = GAMMA_LINEAR;
+
+ FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 2, 2);
+ input->set_pixel_data(data);
+
+ tester.get_chain()->add_input(input);
+ tester.get_chain()->add_effect(mul_half, input);
+ tester.get_chain()->add_effect(mul_two, input);
+ tester.get_chain()->add_effect(new AddEffect(), mul_half, mul_two);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 2, 2);
+}
+
+// Constructs the graph
+//
+// FlatInput |
+// / \ |
+// MultiplyEffect MultiplyEffect |
+// \ | |
+// \ BouncingIdentityEffect |
+// \ / |
+// AddEffect |
+//
+// and verifies that it gives the correct output.
+TEST(EffectChainTest, DiamondGraphWithOneInputUsedInTwoPhases) {
+ float data[] = {
+ 1.0f, 1.0f,
+ 1.0f, 0.0f,
+ };
+ float expected_data[] = {
+ 2.5f, 2.5f,
+ 2.5f, 0.0f,
+ };
+ float out_data[2 * 2];
+
+ const float half[] = { 0.5f, 0.5f, 0.5f, 0.5f };
+ const float two[] = { 2.0f, 2.0f, 2.0f, 0.5f };
+
+ MultiplyEffect *mul_half = new MultiplyEffect();
+ ASSERT_TRUE(mul_half->set_vec4("factor", half));
+
+ MultiplyEffect *mul_two = new MultiplyEffect();
+ ASSERT_TRUE(mul_two->set_vec4("factor", two));
+
+ BouncingIdentityEffect *bounce = new BouncingIdentityEffect();
+
+ EffectChainTester tester(nullptr, 2, 2);
+
+ ImageFormat format;
+ format.color_space = COLORSPACE_sRGB;
+ format.gamma_curve = GAMMA_LINEAR;
+
+ FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 2, 2);
+ input->set_pixel_data(data);
+
+ tester.get_chain()->add_input(input);
+ tester.get_chain()->add_effect(mul_half, input);
+ tester.get_chain()->add_effect(mul_two, input);
+ tester.get_chain()->add_effect(bounce, mul_two);
+ tester.get_chain()->add_effect(new AddEffect(), mul_half, bounce);
+ tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
+
+ expect_equal(expected_data, out_data, 2, 2);
+}
+
+// Constructs the graph
+//
+// FlatInput |
+// / \ |
+// Downscale2xEffect (mipmaps) Downscale2xEffect (no mipmaps) |
+// | | |
+// Downscale2xEffect (mipmaps) Downscale2xEffect (no mipmaps) |
+// \ / |
+// AddEffect |
+//
+// and verifies that it gives the correct output. Due to the conflicting
+// mipmap demands, EffectChain needs to make two phases; exactly where it's
+// split is less important, though (this is a fairly obscure situation that
+// is unlikely to happen in practice).
+TEST(EffectChainTest, DiamondGraphWithConflictingMipmaps) {
+ float data[] = {
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 0.0f,
+ };
+
+ // Same situation as MipmapChainGetsSplit. The output of the two
+ // downscales with no mipmaps looks like this:
+ //
+ // 0 0 0 0
+ // 0 0 0 0
+ // 0 0 0 0
+ // 1 0 0 0
+ //
+ // and the one with mipmaps is 0.25 everywhere. Due to postmultiplied
+ // alpha, we get the average even though we are using AddEffect.
+ float expected_data[] = {
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.125f, 0.125f, 0.125f, 0.125f,
+ 0.625f, 0.125f, 0.125f, 0.125f,
+ };
+ float out_data[4 * 4];
+
+ float offset[] = { -0.5f / 4.0f, -0.5f / 4.0f };
+ Downscale2xEffect *nomipmap1 = new Downscale2xEffect(Effect::CANNOT_ACCEPT_MIPMAPS);
+ Downscale2xEffect *nomipmap2 = new Downscale2xEffect(Effect::CANNOT_ACCEPT_MIPMAPS);
+ ASSERT_TRUE(nomipmap1->set_vec2("offset", offset));
+ ASSERT_TRUE(nomipmap2->set_vec2("offset", offset));
+
+ Downscale2xEffect *mipmap1 = new Downscale2xEffect(Effect::NEEDS_MIPMAPS);
+ Downscale2xEffect *mipmap2 = new Downscale2xEffect(Effect::NEEDS_MIPMAPS);
+
+ EffectChainTester tester(nullptr, 4, 4);
+
+ ImageFormat format;
+ format.color_space = COLORSPACE_sRGB;
+ format.gamma_curve = GAMMA_LINEAR;
+
+ FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, 4, 4);
+ input->set_pixel_data(data);