+ IdentityEffect() {}
+ virtual string effect_type_id() const { return "IdentityEffect"; }
+ string output_fragment_shader() { 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() {}
+ virtual string effect_type_id() const { return "IdentityEffect"; }
+ string output_fragment_shader() { return read_file("identity.frag"); }
+ bool needs_texture_bounce() const { return true; }
+ AlphaHandling alpha_handling() const { 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);
+}
+
+// A dummy effect that inverts its input.
+class InvertEffect : public Effect {
+public:
+ InvertEffect() {}
+ virtual string effect_type_id() const { return "InvertEffect"; }
+ string output_fragment_shader() { return read_file("invert_effect.frag"); }
+
+ // A real invert would actually care about its alpha,
+ // but in this unit test, it only complicates things.
+ virtual AlphaHandling alpha_handling() const { 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:
+ RewritingEffect() : effect(new T()), replaced_node(NULL) {}
+ virtual string effect_type_id() const { return "RewritingEffect[" + effect->effect_type_id() + "]"; }
+ string output_fragment_shader() { EXPECT_TRUE(false); return read_file("identity.frag"); }
+ virtual void rewrite_graph(EffectChain *graph, Node *self) {
+ 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(1, node->incoming_links.size());
+ ASSERT_EQ(1, 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(NULL, 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(1, node->incoming_links.size());
+ ASSERT_EQ(1, 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(1, node->incoming_links.size());
+ ASSERT_EQ(1, 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) {}
+ virtual string effect_type_id() const { 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 { return overridden_color_space; }
+ GammaCurve get_gamma_curve() const { 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(NULL, 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(1, node->incoming_links.size());
+ EXPECT_EQ(0, 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(1, node->incoming_links.size());
+ EXPECT_EQ(0, 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(NULL, 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(1, node->incoming_links.size());
+ EXPECT_EQ(0, 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); }
+ virtual string effect_type_id() const { return "IdentityEffect"; }
+ string output_fragment_shader() { return read_file("blue.frag"); }
+ virtual AlphaHandling alpha_handling() const { return OUTPUT_BLANK_ALPHA; }
+ virtual void finalize() {}
+ virtual bool can_output_linear_gamma() const { return true; }
+ virtual unsigned get_width() const { return 1; }
+ virtual unsigned get_height() const { return 1; }
+ virtual Colorspace get_color_space() const { return COLORSPACE_sRGB; }
+ virtual GammaCurve get_gamma_curve() const { 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(NULL) { register_int("needs_mipmaps", &needs_mipmaps); }
+ virtual string effect_type_id() const { return "RewritingToBlueInput"; }
+ string output_fragment_shader() { EXPECT_TRUE(false); return read_file("identity.frag"); }
+ virtual void rewrite_graph(EffectChain *graph, Node *self) {
+ 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;