X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=d1654e50a05adae169fea1c9bc7955834625a734;hp=4eda18d7afc166eddb0f126f921b3a98ce215d3e;hb=b16d7433b249c5381fa137d3ac3ef7867ae2eae4;hpb=048e90293b5f5ed4b922d60c4cb47c4b5d24b85e diff --git a/effect_chain.cpp b/effect_chain.cpp index 4eda18d..d1654e5 100644 --- a/effect_chain.cpp +++ b/effect_chain.cpp @@ -21,8 +21,29 @@ EffectChain::EffectChain(float aspect_nom, float aspect_denom) : aspect_nom(aspect_nom), aspect_denom(aspect_denom), + fbo(0), finalized(false) {} +EffectChain::~EffectChain() +{ + for (unsigned i = 0; i < nodes.size(); ++i) { + if (nodes[i]->output_texture != 0) { + glDeleteTextures(1, &nodes[i]->output_texture); + } + delete nodes[i]->effect; + delete nodes[i]; + } + for (unsigned i = 0; i < phases.size(); ++i) { + glDeleteProgram(phases[i]->glsl_program_num); + glDeleteShader(phases[i]->vertex_shader); + glDeleteShader(phases[i]->fragment_shader); + delete phases[i]; + } + if (fbo != 0) { + glDeleteFramebuffers(1, &fbo); + } +} + Input *EffectChain::add_input(Input *input) { inputs.push_back(input); @@ -49,6 +70,7 @@ Node *EffectChain::add_node(Effect *effect) node->effect_id = effect_id; node->output_color_space = COLORSPACE_INVALID; node->output_gamma_curve = GAMMA_INVALID; + node->output_texture = 0; nodes.push_back(node); node_map[effect] = node; @@ -111,7 +133,8 @@ void EffectChain::insert_node_between(Node *sender, Node *middle, Node *receiver void EffectChain::find_all_nonlinear_inputs(Node *node, std::vector *nonlinear_inputs) { - if (node->output_gamma_curve == GAMMA_LINEAR) { + if (node->output_gamma_curve == GAMMA_LINEAR && + node->effect->effect_type_id() != "GammaCompressionEffect") { return; } if (node->effect->num_inputs() == 0) { @@ -241,7 +264,18 @@ Phase *EffectChain::compile_glsl_program( } frag_shader += std::string("#define INPUT ") + effects.back()->effect_id + "\n"; frag_shader.append(read_file("footer.frag")); - printf("%s\n", frag_shader.c_str()); + + // Output shader to a temporary file, for easier debugging. + static int compiled_shader_num = 0; + char filename[256]; + sprintf(filename, "chain-%03d.frag", compiled_shader_num++); + FILE *fp = fopen(filename, "w"); + if (fp == NULL) { + perror(filename); + exit(1); + } + fprintf(fp, "%s\n", frag_shader.c_str()); + fclose(fp); GLuint glsl_program_num = glCreateProgram(); GLuint vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER); @@ -255,6 +289,8 @@ Phase *EffectChain::compile_glsl_program( Phase *phase = new Phase; phase->glsl_program_num = glsl_program_num; + phase->vertex_shader = vs_obj; + phase->fragment_shader = fs_obj; phase->input_needs_mipmaps = input_needs_mipmaps; phase->inputs = true_inputs; phase->effects = effects; @@ -318,13 +354,27 @@ void EffectChain::construct_glsl_programs(Node *output) start_new_phase = true; } - if (deps[i]->outgoing_links.size() > 1 && deps[i]->effect->num_inputs() > 0) { - // 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; + if (deps[i]->outgoing_links.size() > 1) { + if (deps[i]->effect->num_inputs() > 0) { + // 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 { + // 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()) { @@ -382,7 +432,23 @@ void EffectChain::output_dot(const char *filename) fprintf(fp, "digraph G {\n"); for (unsigned i = 0; i < nodes.size(); ++i) { - fprintf(fp, " n%ld [label=\"%s\"];\n", (long)nodes[i], nodes[i]->effect->effect_type_id().c_str()); + // Find out which phase this event belongs to. + int in_phase = -1; + for (unsigned j = 0; j < phases.size(); ++j) { + const Phase* p = phases[j]; + if (std::find(p->effects.begin(), p->effects.end(), nodes[i]) != p->effects.end()) { + assert(in_phase == -1); + in_phase = j; + } + } + + if (in_phase == -1) { + fprintf(fp, " n%ld [label=\"%s\"];\n", (long)nodes[i], nodes[i]->effect->effect_type_id().c_str()); + } else { + fprintf(fp, " n%ld [label=\"%s\" style=\"filled\" fillcolor=\"/accent8/%d\"];\n", + (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 labels; @@ -592,7 +658,7 @@ void EffectChain::propagate_gamma_and_color_space() continue; } - ColorSpace color_space = node->incoming_links[0]->output_color_space; + Colorspace color_space = node->incoming_links[0]->output_color_space; GammaCurve gamma_curve = node->incoming_links[0]->output_gamma_curve; for (unsigned j = 1; j < node->incoming_links.size(); ++j) { if (node->incoming_links[j]->output_color_space != color_space) { @@ -605,7 +671,7 @@ void EffectChain::propagate_gamma_and_color_space() // The conversion effects already have their outputs set correctly, // so leave them alone. - if (node->effect->effect_type_id() != "ColorSpaceConversionEffect") { + if (node->effect->effect_type_id() != "ColorspaceConversionEffect") { node->output_color_space = color_space; } if (node->effect->effect_type_id() != "GammaCompressionEffect" && @@ -659,7 +725,7 @@ void EffectChain::fix_internal_color_spaces() if (input->output_color_space == COLORSPACE_sRGB) { continue; } - Node *conversion = add_node(new ColorSpaceConversionEffect()); + Node *conversion = add_node(new ColorspaceConversionEffect()); conversion->effect->set_int("source_space", input->output_color_space); conversion->effect->set_int("destination_space", COLORSPACE_sRGB); conversion->output_color_space = COLORSPACE_sRGB; @@ -693,11 +759,12 @@ void EffectChain::fix_output_color_space() { Node *output = find_output_node(); if (output->output_color_space != output_format.color_space) { - Node *conversion = add_node(new ColorSpaceConversionEffect()); + Node *conversion = add_node(new ColorspaceConversionEffect()); conversion->effect->set_int("source_space", output->output_color_space); conversion->effect->set_int("destination_space", output_format.color_space); conversion->output_color_space = output_format.color_space; connect_nodes(output, conversion); + propagate_gamma_and_color_space(); } } @@ -706,6 +773,22 @@ bool EffectChain::node_needs_gamma_fix(Node *node) if (node->disabled) { return false; } + + // Small hack since the output is not an explicit node: + // If we are the last node and our output is in the wrong + // space compared to EffectChain's output, we need to fix it. + // This will only take us to linear, but fix_output_gamma() + // will come and take us to the desired output gamma + // if it is needed. + // + // This needs to be before everything else, since it could + // even apply to inputs (if they are the only effect). + if (node->outgoing_links.empty() && + node->output_gamma_curve != output_format.gamma_curve && + node->output_gamma_curve != GAMMA_LINEAR) { + return true; + } + if (node->effect->num_inputs() == 0) { return false; } @@ -720,6 +803,7 @@ bool EffectChain::node_needs_gamma_fix(Node *node) assert(node->incoming_links.size() == 1); return node->incoming_links[0]->output_gamma_curve != GAMMA_LINEAR; } + return (node->effect->needs_linear_light() && node->output_gamma_curve != GAMMA_LINEAR); } @@ -744,6 +828,7 @@ void EffectChain::fix_internal_gamma_by_asking_inputs(unsigned step) // See if all inputs can give us linear gamma. If not, leave it. std::vector nonlinear_inputs; find_all_nonlinear_inputs(node, &nonlinear_inputs); + assert(!nonlinear_inputs.empty()); bool all_ok = true; for (unsigned i = 0; i < nonlinear_inputs.size(); ++i) { @@ -786,8 +871,21 @@ void EffectChain::fix_internal_gamma_by_inserting_nodes(unsigned step) continue; } - // Go through each input that is not linear gamma, and insert - // a gamma conversion before it. + // Special case: We could be an input and still be asked to + // fix our gamma; if so, we should be the only node + // (as node_needs_gamma_fix() would only return true in + // for an input in that case). That means we should insert + // a conversion node _after_ ourselves. + if (node->incoming_links.empty()) { + assert(node->outgoing_links.empty()); + Node *conversion = add_node(new GammaExpansionEffect()); + conversion->effect->set_int("source_curve", node->output_gamma_curve); + conversion->output_gamma_curve = GAMMA_LINEAR; + connect_nodes(node, conversion); + } + + // If not, go through each input that is not linear gamma, + // and insert a gamma conversion before it. for (unsigned j = 0; j < node->incoming_links.size(); ++j) { Node *input = node->incoming_links[j]; assert(input->output_gamma_curve != GAMMA_INVALID); @@ -795,7 +893,7 @@ void EffectChain::fix_internal_gamma_by_inserting_nodes(unsigned step) continue; } Node *conversion = add_node(new GammaExpansionEffect()); - conversion->effect->set_int("destination_curve", GAMMA_LINEAR); + conversion->effect->set_int("source_curve", input->output_gamma_curve); conversion->output_gamma_curve = GAMMA_LINEAR; insert_node_between(input, conversion, node); } @@ -882,15 +980,17 @@ void EffectChain::finalize() fix_internal_gamma_by_asking_inputs(5); fix_internal_gamma_by_inserting_nodes(6); fix_output_gamma(); - output_dot("step8-output-gammafix.dot"); - fix_internal_gamma_by_asking_inputs(9); - fix_internal_gamma_by_inserting_nodes(10); + output_dot("step7-output-gammafix.dot"); + fix_internal_gamma_by_asking_inputs(8); + fix_internal_gamma_by_inserting_nodes(9); - output_dot("step11-final.dot"); + output_dot("step10-final.dot"); // Construct all needed GLSL programs, starting at the output. construct_glsl_programs(find_output_node()); + output_dot("step11-split-to-phases.dot"); + // If we have more than one phase, we need intermediate render-to-texture. // Construct an FBO, and then as many textures as we need. // We choose the simplest option of having one texture per output, @@ -918,6 +1018,7 @@ void EffectChain::finalize() output_node->output_texture_width = phases[i]->output_width; output_node->output_texture_height = phases[i]->output_height; } + inform_input_sizes(phases.back()); } for (unsigned i = 0; i < inputs.size(); ++i) { @@ -929,13 +1030,21 @@ void EffectChain::finalize() finalized = true; } -void EffectChain::render_to_screen() +void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height) { assert(finalized); // Save original viewport. - GLint viewport[4]; - glGetIntegerv(GL_VIEWPORT, viewport); + GLuint x = 0, y = 0; + + if (width == 0 && height == 0) { + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + x = viewport[0]; + y = viewport[1]; + width = viewport[2]; + height = viewport[3]; + } // Basic state. glDisable(GL_BLEND); @@ -962,8 +1071,8 @@ void EffectChain::render_to_screen() for (unsigned phase = 0; phase < phases.size(); ++phase) { // See if the requested output size has changed. If so, we need to recreate // the texture (and before we start setting up inputs). + inform_input_sizes(phases[phase]); if (phase != phases.size() - 1) { - inform_input_sizes(phases[phase]); find_output_size(phases[phase]); Node *output_node = phases[phase]->effects.back(); @@ -1013,10 +1122,10 @@ void EffectChain::render_to_screen() // And now the output. if (phase == phases.size() - 1) { - // Last phase goes directly to the screen. - glBindFramebuffer(GL_FRAMEBUFFER, 0); + // Last phase goes to the output the user specified. + glBindFramebuffer(GL_FRAMEBUFFER, dest_fbo); check_error(); - glViewport(viewport[0], viewport[1], viewport[2], viewport[3]); + glViewport(x, y, width, height); } else { Node *output_node = phases[phase]->effects.back(); glFramebufferTexture2D(