+ phase->glsl_program_num = resource_pool->compile_glsl_program(read_file("vs.vert"), frag_shader);
+}
+
+// Construct GLSL programs, starting at the given effect and following
+// the chain from there. We end a program every time we come to an effect
+// marked as "needs texture bounce", one that is used by multiple other
+// effects, every time an effect wants to change the output size,
+// and of course at the end.
+//
+// We follow a quite simple depth-first search from the output, although
+// without recursing explicitly within each phase.
+Phase *EffectChain::construct_phase(Node *output, map<Node *, Phase *> *completed_effects)
+{
+ if (completed_effects->count(output)) {
+ return (*completed_effects)[output];
+ }
+
+ Phase *phase = new Phase;
+ phase->output_node = output;
+
+ // Effects that we have yet to calculate, but that we know should
+ // be in the current phase.
+ stack<Node *> effects_todo_this_phase;
+ effects_todo_this_phase.push(output);
+
+ while (!effects_todo_this_phase.empty()) {
+ Node *node = effects_todo_this_phase.top();
+ effects_todo_this_phase.pop();
+
+ // 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 below.
+ if (node->effect->num_inputs() == 0) {
+ if (find(phase->effects.begin(), phase->effects.end(), node) != phase->effects.end()) {
+ continue;
+ }
+ } else {
+ assert(completed_effects->count(node) == 0);
+ }
+
+ phase->effects.push_back(node);
+
+ // Find all the dependencies of this effect, and add them to the stack.
+ vector<Node *> deps = node->incoming_links;
+ assert(node->effect->num_inputs() == deps.size());
+ for (unsigned i = 0; i < deps.size(); ++i) {
+ bool start_new_phase = false;
+
+ if (node->effect->needs_texture_bounce() &&
+ !deps[i]->effect->is_single_texture()) {
+ start_new_phase = true;
+ }
+
+ if (deps[i]->outgoing_links.size() > 1) {
+ if (!deps[i]->effect->is_single_texture()) {
+ // More than one effect uses this as the input,
+ // and it is not a texture itself.
+ // The easiest thing to do (and probably also the safest
+ // performance-wise in most cases) is to bounce it to a texture
+ // and then let the next passes read from that.
+ start_new_phase = true;
+ } else {
+ assert(deps[i]->effect->num_inputs() == 0);
+
+ // For textures, we try to be slightly more clever;
+ // if none of our outputs need a bounce, we don't bounce
+ // but instead simply use the effect many times.
+ //
+ // Strictly speaking, we could bounce it for some outputs
+ // and use it directly for others, but the processing becomes
+ // somewhat simpler if the effect is only used in one such way.
+ for (unsigned j = 0; j < deps[i]->outgoing_links.size(); ++j) {
+ Node *rdep = deps[i]->outgoing_links[j];
+ start_new_phase |= rdep->effect->needs_texture_bounce();
+ }
+ }
+ }
+
+ if (deps[i]->effect->changes_output_size()) {
+ start_new_phase = true;
+ }
+
+ if (start_new_phase) {
+ phase->inputs.push_back(construct_phase(deps[i], completed_effects));
+ } else {
+ effects_todo_this_phase.push(deps[i]);
+ }
+ }
+ }
+
+ // No more effects to do this phase. Take all the ones we have,
+ // and create a GLSL program for it.
+ assert(!phase->effects.empty());
+
+ // Deduplicate the inputs.
+ sort(phase->inputs.begin(), phase->inputs.end());
+ phase->inputs.erase(unique(phase->inputs.begin(), phase->inputs.end()), phase->inputs.end());
+
+ // We added the effects from the output and back, but we need to output
+ // them in topological sort order in the shader.
+ phase->effects = topological_sort(phase->effects);
+
+ // Figure out if we need mipmaps or not, and if so, tell the inputs that.
+ phase->input_needs_mipmaps = false;
+ for (unsigned i = 0; i < phase->effects.size(); ++i) {
+ Node *node = phase->effects[i];
+ phase->input_needs_mipmaps |= node->effect->needs_mipmaps();
+ }
+ for (unsigned i = 0; i < phase->effects.size(); ++i) {
+ Node *node = phase->effects[i];
+ if (node->effect->num_inputs() == 0) {
+ CHECK(node->effect->set_int("needs_mipmaps", phase->input_needs_mipmaps));
+ }
+ }
+
+ // Actually make the shader for this phase.
+ compile_glsl_program(phase);
+
+ assert(completed_effects->count(output) == 0);
+ completed_effects->insert(make_pair(output, phase));
+ phases.push_back(phase);
+ return phase;
+}
+
+void EffectChain::output_dot(const char *filename)
+{
+ if (movit_debug_level != MOVIT_DEBUG_ON) {
+ return;
+ }
+
+ FILE *fp = fopen(filename, "w");
+ if (fp == NULL) {
+ perror(filename);
+ exit(1);
+ }
+
+ 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.
+ vector<int> in_phases;
+ for (unsigned j = 0; j < phases.size(); ++j) {
+ const Phase* p = phases[j];
+ if (find(p->effects.begin(), p->effects.end(), nodes[i]) != p->effects.end()) {
+ in_phases.push_back(j);
+ }
+ }
+
+ if (in_phases.empty()) {
+ fprintf(fp, " n%ld [label=\"%s\"];\n", (long)nodes[i], nodes[i]->effect->effect_type_id().c_str());
+ } else if (in_phases.size() == 1) {
+ fprintf(fp, " n%ld [label=\"%s\" style=\"filled\" fillcolor=\"/accent8/%d\"];\n",
+ (long)nodes[i], nodes[i]->effect->effect_type_id().c_str(),
+ (in_phases[0] % 8) + 1);
+ } else {
+ // If we had new enough Graphviz, style="wedged" would probably be ideal here.
+ // But alas.
+ fprintf(fp, " n%ld [label=\"%s [in multiple phases]\" style=\"filled\" fillcolor=\"/accent8/%d\"];\n",
+ (long)nodes[i], nodes[i]->effect->effect_type_id().c_str(),
+ (in_phases[0] % 8) + 1);
+ }
+
+ char from_node_id[256];
+ snprintf(from_node_id, 256, "n%ld", (long)nodes[i]);
+
+ 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]);
+
+ vector<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 (nodes[i]->outgoing_links.empty() && !nodes[i]->disabled) {
+ // Output node.
+ vector<string> labels = get_labels_for_edge(nodes[i], NULL);
+ output_dot_edge(fp, from_node_id, "output", labels);
+ }
+ }
+ fprintf(fp, "}\n");
+
+ fclose(fp);
+}
+
+vector<string> EffectChain::get_labels_for_edge(const Node *from, const Node *to)
+{
+ vector<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 string &from_node_id,
+ const string &to_node_id,
+ const vector<string> &labels)
+{
+ if (labels.empty()) {
+ fprintf(fp, " %s -> %s;\n", from_node_id.c_str(), to_node_id.c_str());