X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=a9b892725358039173725feea5306692f3432988;hp=8db5376bd333794a2dcaa3f4cdca55324b8b8d46;hb=7221906173f1cf1ce6913cbe9d62d5ca11e9ee0d;hpb=b10c546f579c7ccb5939161e61a71cd18a3f9bbd

diff --git a/effect_chain.cpp b/effect_chain.cpp
index 8db5376..a9b8927 100644
--- a/effect_chain.cpp
+++ b/effect_chain.cpp
@@ -229,8 +229,10 @@ Phase *EffectChain::compile_glsl_program(
 		frag_shader += "\n";
 	}
 
-	for (unsigned i = 0; i < effects.size(); ++i) {
-		Node *node = effects[i];
+	std::vector<Node *> sorted_effects = topological_sort(effects);
+
+	for (unsigned i = 0; i < sorted_effects.size(); ++i) {
+		Node *node = sorted_effects[i];
 
 		if (node->incoming_links.size() == 1) {
 			frag_shader += std::string("#define INPUT ") + node->incoming_links[0]->effect_id + "\n";
@@ -261,13 +263,13 @@ Phase *EffectChain::compile_glsl_program(
 
 		input_needs_mipmaps |= node->effect->needs_mipmaps();
 	}
-	for (unsigned i = 0; i < effects.size(); ++i) {
-		Node *node = effects[i];
+	for (unsigned i = 0; i < sorted_effects.size(); ++i) {
+		Node *node = sorted_effects[i];
 		if (node->effect->num_inputs() == 0) {
 			CHECK(node->effect->set_int("needs_mipmaps", input_needs_mipmaps));
 		}
 	}
-	frag_shader += std::string("#define INPUT ") + effects.back()->effect_id + "\n";
+	frag_shader += std::string("#define INPUT ") + sorted_effects.back()->effect_id + "\n";
 	frag_shader.append(read_file("footer.frag"));
 
 	if (movit_debug_level == MOVIT_DEBUG_ON) {
@@ -300,7 +302,7 @@ Phase *EffectChain::compile_glsl_program(
 	phase->fragment_shader = fs_obj;
 	phase->input_needs_mipmaps = input_needs_mipmaps;
 	phase->inputs = true_inputs;
-	phase->effects = effects;
+	phase->effects = sorted_effects;
 
 	return phase;
 }
@@ -317,7 +319,7 @@ void EffectChain::construct_glsl_programs(Node *output)
 {
 	// Which effects have already been completed in this phase?
 	// We need to keep track of it, as an effect with multiple outputs
-	// could otherwise be calculate multiple times.
+	// could otherwise be calculated multiple times.
 	std::set<Node *> completed_effects;
 
 	// Effects in the current phase, as well as inputs (outputs from other phases
@@ -343,8 +345,12 @@ void EffectChain::construct_glsl_programs(Node *output)
 			Node *node = effects_todo_this_phase.top();
 			effects_todo_this_phase.pop();
 
-			// This should currently only happen for effects that are phase outputs,
-			// and we throw those out separately below.
+			// This should currently only happen for effects that are inputs
+			// (either true inputs or phase outputs). We special-case inputs,
+			// and then deduplicate phase outputs in compile_glsl_program().
+			if (node->effect->num_inputs() == 0 && completed_effects.count(node)) {
+				continue;
+			}
 			assert(completed_effects.count(node) == 0);
 
 			this_phase_effects.push_back(node);
@@ -442,6 +448,7 @@ void EffectChain::output_dot(const char *filename)
 	}
 
 	fprintf(fp, "digraph G {\n");
+	fprintf(fp, "  output [shape=box label=\"(output)\"];\n");
 	for (unsigned i = 0; i < nodes.size(); ++i) {
 		// Find out which phase this event belongs to.
 		int in_phase = -1;
@@ -460,67 +467,22 @@ void EffectChain::output_dot(const char *filename)
 				(long)nodes[i], nodes[i]->effect->effect_type_id().c_str(),
 				(in_phase % 8) + 1);
 		}
-		for (unsigned j = 0; j < nodes[i]->outgoing_links.size(); ++j) {
-			std::vector<std::string> labels;
 
-			if (nodes[i]->outgoing_links[j]->effect->needs_texture_bounce()) {
-				labels.push_back("needs_bounce");
-			}
-			if (nodes[i]->effect->changes_output_size()) {
-				labels.push_back("resize");
-			}
+		char from_node_id[256];
+		snprintf(from_node_id, 256, "n%ld", (long)nodes[i]);
 
-			switch (nodes[i]->output_color_space) {
-			case COLORSPACE_INVALID:
-				labels.push_back("spc[invalid]");
-				break;
-			case COLORSPACE_REC_601_525:
-				labels.push_back("spc[rec601-525]");
-				break;
-			case COLORSPACE_REC_601_625:
-				labels.push_back("spc[rec601-625]");
-				break;
-			default:
-				break;
-			}
-
-			switch (nodes[i]->output_gamma_curve) {
-			case GAMMA_INVALID:
-				labels.push_back("gamma[invalid]");
-				break;
-			case GAMMA_sRGB:
-				labels.push_back("gamma[sRGB]");
-				break;
-			case GAMMA_REC_601:  // and GAMMA_REC_709
-				labels.push_back("gamma[rec601/709]");
-				break;
-			default:
-				break;
-			}
+		for (unsigned j = 0; j < nodes[i]->outgoing_links.size(); ++j) {
+			char to_node_id[256];
+			snprintf(to_node_id, 256, "n%ld", (long)nodes[i]->outgoing_links[j]);
 
-			switch (nodes[i]->output_alpha_type) {
-			case ALPHA_INVALID:
-				labels.push_back("alpha[invalid]");
-				break;
-			case ALPHA_BLANK:
-				labels.push_back("alpha[blank]");
-				break;
-			case ALPHA_POSTMULTIPLIED:
-				labels.push_back("alpha[postmult]");
-				break;
-			default:
-				break;
-			}
+			std::vector<std::string> labels = get_labels_for_edge(nodes[i], nodes[i]->outgoing_links[j]);
+			output_dot_edge(fp, from_node_id, to_node_id, labels);
+		}
 
-			if (labels.empty()) {
-				fprintf(fp, "  n%ld -> n%ld;\n", (long)nodes[i], (long)nodes[i]->outgoing_links[j]);
-			} else {
-				std::string label = labels[0];
-				for (unsigned k = 1; k < labels.size(); ++k) {
-					label += ", " + labels[k];
-				}
-				fprintf(fp, "  n%ld -> n%ld [label=\"%s\"];\n", (long)nodes[i], (long)nodes[i]->outgoing_links[j], label.c_str());
-			}
+		if (nodes[i]->outgoing_links.empty() && !nodes[i]->disabled) {
+			// Output node.
+			std::vector<std::string> labels = get_labels_for_edge(nodes[i], NULL);
+			output_dot_edge(fp, from_node_id, "output", labels);
 		}
 	}
 	fprintf(fp, "}\n");
@@ -528,6 +490,78 @@ void EffectChain::output_dot(const char *filename)
 	fclose(fp);
 }
 
+std::vector<std::string> EffectChain::get_labels_for_edge(const Node *from, const Node *to)
+{
+	std::vector<std::string> labels;
+
+	if (to != NULL && to->effect->needs_texture_bounce()) {
+		labels.push_back("needs_bounce");
+	}
+	if (from->effect->changes_output_size()) {
+		labels.push_back("resize");
+	}
+
+	switch (from->output_color_space) {
+	case COLORSPACE_INVALID:
+		labels.push_back("spc[invalid]");
+		break;
+	case COLORSPACE_REC_601_525:
+		labels.push_back("spc[rec601-525]");
+		break;
+	case COLORSPACE_REC_601_625:
+		labels.push_back("spc[rec601-625]");
+		break;
+	default:
+		break;
+	}
+
+	switch (from->output_gamma_curve) {
+	case GAMMA_INVALID:
+		labels.push_back("gamma[invalid]");
+		break;
+	case GAMMA_sRGB:
+		labels.push_back("gamma[sRGB]");
+		break;
+	case GAMMA_REC_601:  // and GAMMA_REC_709
+		labels.push_back("gamma[rec601/709]");
+		break;
+	default:
+		break;
+	}
+
+	switch (from->output_alpha_type) {
+	case ALPHA_INVALID:
+		labels.push_back("alpha[invalid]");
+		break;
+	case ALPHA_BLANK:
+		labels.push_back("alpha[blank]");
+		break;
+	case ALPHA_POSTMULTIPLIED:
+		labels.push_back("alpha[postmult]");
+		break;
+	default:
+		break;
+	}
+
+	return labels;
+}
+
+void EffectChain::output_dot_edge(FILE *fp,
+                                  const std::string &from_node_id,
+                                  const std::string &to_node_id,
+                                  const std::vector<std::string> &labels)
+{
+	if (labels.empty()) {
+		fprintf(fp, "  %s -> %s;\n", from_node_id.c_str(), to_node_id.c_str());
+	} else {
+		std::string label = labels[0];
+		for (unsigned k = 1; k < labels.size(); ++k) {
+			label += ", " + labels[k];
+		}
+		fprintf(fp, "  %s -> %s [label=\"%s\"];\n", from_node_id.c_str(), to_node_id.c_str(), label.c_str());
+	}
+}
+
 unsigned EffectChain::fit_rectangle_to_aspect(unsigned width, unsigned height)
 {
 	if (float(width) * aspect_denom >= float(height) * aspect_nom) {
@@ -638,27 +672,30 @@ void EffectChain::find_output_size(Phase *phase)
 	phase->output_height = best_width * aspect_denom / aspect_nom;
 }
 
-void EffectChain::sort_nodes_topologically()
+void EffectChain::sort_all_nodes_topologically()
+{
+	nodes = topological_sort(nodes);
+}
+
+std::vector<Node *> EffectChain::topological_sort(const std::vector<Node *> &nodes)
 {
-	std::set<Node *> visited_nodes;
+	std::set<Node *> nodes_left_to_visit(nodes.begin(), nodes.end());
 	std::vector<Node *> sorted_list;
 	for (unsigned i = 0; i < nodes.size(); ++i) {
-		if (nodes[i]->incoming_links.size() == 0) {
-			topological_sort_visit_node(nodes[i], &visited_nodes, &sorted_list);
-		}
+		topological_sort_visit_node(nodes[i], &nodes_left_to_visit, &sorted_list);
 	}
 	reverse(sorted_list.begin(), sorted_list.end());
-	nodes = sorted_list;
+	return sorted_list;
 }
 
-void EffectChain::topological_sort_visit_node(Node *node, std::set<Node *> *visited_nodes, std::vector<Node *> *sorted_list)
+void EffectChain::topological_sort_visit_node(Node *node, std::set<Node *> *nodes_left_to_visit, std::vector<Node *> *sorted_list)
 {
-	if (visited_nodes->count(node) != 0) {
+	if (nodes_left_to_visit->count(node) == 0) {
 		return;
 	}
-	visited_nodes->insert(node);
+	nodes_left_to_visit->erase(node);
 	for (unsigned i = 0; i < node->outgoing_links.size(); ++i) {
-		topological_sort_visit_node(node->outgoing_links[i], visited_nodes, sorted_list);
+		topological_sort_visit_node(node->outgoing_links[i], nodes_left_to_visit, sorted_list);
 	}
 	sorted_list->push_back(node);
 }
@@ -690,6 +727,10 @@ void EffectChain::find_color_spaces_for_inputs()
 			default:
 				assert(false);
 			}
+
+			if (node->output_alpha_type == ALPHA_PREMULTIPLIED) {
+				assert(node->output_gamma_curve == GAMMA_LINEAR);
+			}
 		}
 	}
 }
@@ -700,7 +741,7 @@ void EffectChain::find_color_spaces_for_inputs()
 void EffectChain::propagate_gamma_and_color_space()
 {
 	// We depend on going through the nodes in order.
-	sort_nodes_topologically();
+	sort_all_nodes_topologically();
 
 	for (unsigned i = 0; i < nodes.size(); ++i) {
 		Node *node = nodes[i];
@@ -742,7 +783,7 @@ void EffectChain::propagate_gamma_and_color_space()
 void EffectChain::propagate_alpha()
 {
 	// We depend on going through the nodes in order.
-	sort_nodes_topologically();
+	sort_all_nodes_topologically();
 
 	for (unsigned i = 0; i < nodes.size(); ++i) {
 		Node *node = nodes[i];