X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=3d4fc6f8af6eaa0900bbfbf305b2cd4fb6adfbf0;hp=c2402daeaef400d9ded80dcbce3378be9f94ac42;hb=aa1fce6c5356faa368758b15b3ad257c0f7bda0b;hpb=825c90789c229f502520bf0b665596d473f2636d diff --git a/effect_chain.cpp b/effect_chain.cpp index c2402da..3d4fc6f 100644 --- a/effect_chain.cpp +++ b/effect_chain.cpp @@ -1,5 +1,3 @@ -#define GL_GLEXT_PROTOTYPES 1 - #include #include #include @@ -38,8 +36,11 @@ EffectChain::EffectChain(float aspect_nom, float aspect_denom, ResourcePool *res : aspect_nom(aspect_nom), aspect_denom(aspect_denom), output_color_rgba(false), - output_color_ycbcr(false), + num_output_color_ycbcr(0), dither_effect(NULL), + ycbcr_conversion_effect_node(NULL), + intermediate_format(GL_RGBA16F), + intermediate_transformation(NO_FRAMEBUFFER_TRANSFORMATION), num_dither_bits(0), output_origin(OUTPUT_ORIGIN_BOTTOM_LEFT), finalized(false), @@ -51,6 +52,14 @@ EffectChain::EffectChain(float aspect_nom, float aspect_denom, ResourcePool *res } else { owns_resource_pool = false; } + + // Generate a VBO with some data in (shared position and texture coordinate data). + float vertices[] = { + 0.0f, 2.0f, + 0.0f, 0.0f, + 2.0f, 0.0f + }; + vbo = generate_vbo(2, GL_FLOAT, sizeof(vertices), vertices); } EffectChain::~EffectChain() @@ -66,6 +75,8 @@ EffectChain::~EffectChain() if (owns_resource_pool) { delete resource_pool; } + glDeleteBuffers(1, &vbo); + check_error(); } Input *EffectChain::add_input(Input *input) @@ -89,17 +100,47 @@ void EffectChain::add_ycbcr_output(const ImageFormat &format, OutputAlphaFormat const YCbCrFormat &ycbcr_format, YCbCrOutputSplitting output_splitting) { assert(!finalized); - assert(!output_color_ycbcr); + assert(num_output_color_ycbcr < 2); output_format = format; output_alpha_format = alpha_format; - output_color_ycbcr = true; - output_ycbcr_format = ycbcr_format; - output_ycbcr_splitting = output_splitting; + + if (num_output_color_ycbcr == 1) { + // Check that the format is the same. + assert(output_ycbcr_format.luma_coefficients == ycbcr_format.luma_coefficients); + assert(output_ycbcr_format.full_range == ycbcr_format.full_range); + assert(output_ycbcr_format.num_levels == ycbcr_format.num_levels); + assert(output_ycbcr_format.chroma_subsampling_x == ycbcr_format.chroma_subsampling_x); + assert(output_ycbcr_format.chroma_subsampling_y == ycbcr_format.chroma_subsampling_y); + assert(fabs(output_ycbcr_format.cb_x_position - ycbcr_format.cb_x_position) < 1e-3); + assert(fabs(output_ycbcr_format.cb_y_position - ycbcr_format.cb_y_position) < 1e-3); + assert(fabs(output_ycbcr_format.cr_x_position - ycbcr_format.cr_x_position) < 1e-3); + assert(fabs(output_ycbcr_format.cr_y_position - ycbcr_format.cr_y_position) < 1e-3); + } else { + output_ycbcr_format = ycbcr_format; + } + output_ycbcr_splitting[num_output_color_ycbcr++] = output_splitting; assert(ycbcr_format.chroma_subsampling_x == 1); assert(ycbcr_format.chroma_subsampling_y == 1); } +void EffectChain::change_ycbcr_output_format(const YCbCrFormat &ycbcr_format) +{ + assert(num_output_color_ycbcr > 0); + assert(output_ycbcr_format.chroma_subsampling_x == ycbcr_format.chroma_subsampling_x); + assert(output_ycbcr_format.chroma_subsampling_y == ycbcr_format.chroma_subsampling_y); + assert(fabs(output_ycbcr_format.cb_x_position - ycbcr_format.cb_x_position) < 1e-3); + assert(fabs(output_ycbcr_format.cb_y_position - ycbcr_format.cb_y_position) < 1e-3); + assert(fabs(output_ycbcr_format.cr_x_position - ycbcr_format.cr_x_position) < 1e-3); + assert(fabs(output_ycbcr_format.cr_y_position - ycbcr_format.cr_y_position) < 1e-3); + + output_ycbcr_format = ycbcr_format; + if (finalized) { + YCbCrConversionEffect *effect = (YCbCrConversionEffect *)(ycbcr_conversion_effect_node->effect); + effect->change_output_format(ycbcr_format); + } +} + Node *EffectChain::add_node(Effect *effect) { for (unsigned i = 0; i < nodes.size(); ++i) { @@ -323,7 +364,14 @@ void EffectChain::compile_glsl_program(Phase *phase) frag_shader += string("uniform sampler2D tex_") + effect_id + ";\n"; frag_shader += string("vec4 ") + effect_id + "(vec2 tc) {\n"; - frag_shader += "\treturn tex2D(tex_" + string(effect_id) + ", tc);\n"; + frag_shader += "\tvec4 tmp = tex2D(tex_" + string(effect_id) + ", tc);\n"; + + if (intermediate_transformation == SQUARE_ROOT_FRAMEBUFFER_TRANSFORMATION && + phase->inputs[i]->output_node->output_gamma_curve == GAMMA_LINEAR) { + frag_shader += "\ttmp.rgb *= tmp.rgb;\n"; + } + + frag_shader += "\treturn tmp;\n"; frag_shader += "}\n"; frag_shader += "\n"; @@ -377,8 +425,8 @@ void EffectChain::compile_glsl_program(Phase *phase) // If we're the last phase, add the right #defines for Y'CbCr multi-output as needed. vector frag_shader_outputs; // In order. - if (phase->output_node->outgoing_links.empty() && output_color_ycbcr) { - switch (output_ycbcr_splitting) { + if (phase->output_node->outgoing_links.empty() && num_output_color_ycbcr > 0) { + switch (output_ycbcr_splitting[0]) { case YCBCR_OUTPUT_INTERLEAVED: // No #defines set. frag_shader_outputs.push_back("FragColor"); @@ -398,6 +446,28 @@ void EffectChain::compile_glsl_program(Phase *phase) assert(false); } + if (num_output_color_ycbcr > 1) { + switch (output_ycbcr_splitting[1]) { + case YCBCR_OUTPUT_INTERLEAVED: + frag_shader += "#define SECOND_YCBCR_OUTPUT_INTERLEAVED 1\n"; + frag_shader_outputs.push_back("YCbCr2"); + break; + case YCBCR_OUTPUT_SPLIT_Y_AND_CBCR: + frag_shader += "#define SECOND_YCBCR_OUTPUT_SPLIT_Y_AND_CBCR 1\n"; + frag_shader_outputs.push_back("Y2"); + frag_shader_outputs.push_back("Chroma2"); + break; + case YCBCR_OUTPUT_PLANAR: + frag_shader += "#define SECOND_YCBCR_OUTPUT_PLANAR 1\n"; + frag_shader_outputs.push_back("Y2"); + frag_shader_outputs.push_back("Cb2"); + frag_shader_outputs.push_back("Cr2"); + break; + default: + assert(false); + } + } + if (output_color_rgba) { // Note: Needs to come in the header, because not only the // output needs to see it (YCbCrConversionEffect and DitherEffect @@ -406,6 +476,15 @@ void EffectChain::compile_glsl_program(Phase *phase) frag_shader_outputs.push_back("RGBA"); } } + + // If we're bouncing to a temporary texture, signal transformation if desired. + if (!phase->output_node->outgoing_links.empty()) { + if (intermediate_transformation == SQUARE_ROOT_FRAMEBUFFER_TRANSFORMATION && + phase->output_node->output_gamma_curve == GAMMA_LINEAR) { + frag_shader += "#define SQUARE_ROOT_TRANSFORMATION 1\n"; + } + } + frag_shader.append(read_file("footer.frag")); // Collect uniforms from all effects and output them. Note that this needs @@ -448,6 +527,14 @@ void EffectChain::compile_glsl_program(Phase *phase) } phase->glsl_program_num = resource_pool->compile_glsl_program(vert_shader, frag_shader, frag_shader_outputs); + GLint position_attribute_index = glGetAttribLocation(phase->glsl_program_num, "position"); + GLint texcoord_attribute_index = glGetAttribLocation(phase->glsl_program_num, "texcoord"); + if (position_attribute_index != -1) { + phase->attribute_indexes.insert(position_attribute_index); + } + if (texcoord_attribute_index != -1) { + phase->attribute_indexes.insert(texcoord_attribute_index); + } // Collect the resulting location numbers for each uniform. collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_sampler2d); @@ -589,9 +676,17 @@ Phase *EffectChain::construct_phase(Node *output, map *complete // 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()); + // Deduplicate the inputs, but don't change the ordering e.g. by sorting; + // that would be nondeterministic and thus reduce cacheability. + // TODO: Make this even more deterministic. + vector dedup_inputs; + set seen_inputs; + for (size_t i = 0; i < phase->inputs.size(); ++i) { + if (seen_inputs.insert(phase->inputs[i]).second) { + dedup_inputs.push_back(phase->inputs[i]); + } + } + swap(phase->inputs, dedup_inputs); // Allocate samplers for each input. phase->input_samplers.resize(phase->inputs.size()); @@ -626,9 +721,8 @@ Phase *EffectChain::construct_phase(Node *output, map *complete // Actually make the shader for this phase. compile_glsl_program(phase); - // Initialize timer objects. + // Initialize timers. if (movit_timer_queries_supported) { - glGenQueries(1, &phase->timer_query_object); phase->time_elapsed_ns = 0; phase->num_measured_iterations = 0; } @@ -1152,6 +1246,11 @@ void EffectChain::propagate_alpha() if (alpha_handling == Effect::INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA || alpha_handling == Effect::INPUT_PREMULTIPLIED_ALPHA_KEEP_BLANK) { + // This combination (requiring premultiplied alpha, but _not_ requiring + // linear light) is illegal, since the combination of premultiplied alpha + // and nonlinear inputs is meaningless. + assert(node->effect->needs_linear_light()); + // If the effect has asked for premultiplied alpha, check that it has got it. if (any_postmultiplied) { node->output_alpha_type = ALPHA_INVALID; @@ -1548,13 +1647,13 @@ void EffectChain::fix_output_gamma() // gamma-encoded data. void EffectChain::add_ycbcr_conversion_if_needed() { - assert(output_color_rgba || output_color_ycbcr); - if (!output_color_ycbcr) { + assert(output_color_rgba || num_output_color_ycbcr > 0); + if (num_output_color_ycbcr == 0) { return; } Node *output = find_output_node(); - Node *ycbcr = add_node(new YCbCrConversionEffect(output_ycbcr_format)); - connect_nodes(output, ycbcr); + ycbcr_conversion_effect_node = add_node(new YCbCrConversionEffect(output_ycbcr_format)); + connect_nodes(output, ycbcr_conversion_effect_node); } // If the user has requested dither, add a DitherEffect right at the end @@ -1670,6 +1769,10 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height glDisable(GL_DITHER); check_error(); + const bool final_srgb = glIsEnabled(GL_FRAMEBUFFER_SRGB); + check_error(); + bool current_srgb = final_srgb; + // Save original viewport. GLuint x = 0, y = 0; @@ -1691,22 +1794,16 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height glDepthMask(GL_FALSE); check_error(); - // Generate a VAO. All the phases should have exactly the same vertex attributes, - // so it's safe to reuse this. - float vertices[] = { - 0.0f, 2.0f, - 0.0f, 0.0f, - 2.0f, 0.0f - }; - + // Generate a VAO that will be used during the entire execution, + // and bind the VBO, since it contains all the data. GLuint vao; glGenVertexArrays(1, &vao); check_error(); glBindVertexArray(vao); check_error(); - - GLuint position_vbo = fill_vertex_attribute(phases[0]->glsl_program_num, "position", 2, GL_FLOAT, sizeof(vertices), vertices); - GLuint texcoord_vbo = fill_vertex_attribute(phases[0]->glsl_program_num, "texcoord", 2, GL_FLOAT, sizeof(vertices), vertices); // Same as vertices. + glBindBuffer(GL_ARRAY_BUFFER, vbo); + check_error(); + set bound_attribute_indices; set generated_mipmaps; @@ -1718,7 +1815,15 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height Phase *phase = phases[phase_num]; if (do_phase_timing) { - glBeginQuery(GL_TIME_ELAPSED, phase->timer_query_object); + GLuint timer_query_object; + if (phase->timer_query_objects_free.empty()) { + glGenQueries(1, &timer_query_object); + } else { + timer_query_object = phase->timer_query_objects_free.front(); + phase->timer_query_objects_free.pop_front(); + } + glBeginQuery(GL_TIME_ELAPSED, timer_query_object); + phase->timer_query_objects_running.push_back(timer_query_object); } if (phase_num == phases.size() - 1) { // Last phase goes to the output the user specified. @@ -1732,7 +1837,22 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height CHECK(dither_effect->set_int("output_height", height)); } } - execute_phase(phase, phase_num == phases.size() - 1, &output_textures, &generated_mipmaps); + bool last_phase = (phase_num == phases.size() - 1); + + // Enable sRGB rendering for intermediates in case we are + // rendering to an sRGB format. + bool needs_srgb = last_phase ? final_srgb : true; + if (needs_srgb && !current_srgb) { + glEnable(GL_FRAMEBUFFER_SRGB); + check_error(); + current_srgb = true; + } else if (!needs_srgb && current_srgb) { + glDisable(GL_FRAMEBUFFER_SRGB); + check_error(); + current_srgb = true; + } + + execute_phase(phase, last_phase, &bound_attribute_indices, &output_textures, &generated_mipmaps); if (do_phase_timing) { glEndQuery(GL_TIME_ELAPSED); } @@ -1749,9 +1869,10 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height glUseProgram(0); check_error(); - cleanup_vertex_attribute(phases[0]->glsl_program_num, "position", position_vbo); - cleanup_vertex_attribute(phases[0]->glsl_program_num, "texcoord", texcoord_vbo); - + glBindBuffer(GL_ARRAY_BUFFER, 0); + check_error(); + glBindVertexArray(0); + check_error(); glDeleteVertexArrays(1, &vao); check_error(); @@ -1759,14 +1880,22 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height // Get back the timer queries. for (unsigned phase_num = 0; phase_num < phases.size(); ++phase_num) { Phase *phase = phases[phase_num]; - GLint available = 0; - while (!available) { - glGetQueryObjectiv(phase->timer_query_object, GL_QUERY_RESULT_AVAILABLE, &available); + for (std::list::iterator timer_it = phase->timer_query_objects_running.begin(); + timer_it != phase->timer_query_objects_running.end(); ) { + GLint timer_query_object = *timer_it; + GLint available; + glGetQueryObjectiv(timer_query_object, GL_QUERY_RESULT_AVAILABLE, &available); + if (available) { + GLuint64 time_elapsed; + glGetQueryObjectui64v(timer_query_object, GL_QUERY_RESULT, &time_elapsed); + phase->time_elapsed_ns += time_elapsed; + ++phase->num_measured_iterations; + phase->timer_query_objects_free.push_back(timer_query_object); + phase->timer_query_objects_running.erase(timer_it++); + } else { + ++timer_it; + } } - GLuint64 time_elapsed; - glGetQueryObjectui64v(phase->timer_query_object, GL_QUERY_RESULT, &time_elapsed); - phase->time_elapsed_ns += time_elapsed; - ++phase->num_measured_iterations; } } } @@ -1807,7 +1936,10 @@ void EffectChain::print_phase_timing() printf("Total: %5.1f ms\n", total_time_ms); } -void EffectChain::execute_phase(Phase *phase, bool last_phase, map *output_textures, set *generated_mipmaps) +void EffectChain::execute_phase(Phase *phase, bool last_phase, + set *bound_attribute_indices, + map *output_textures, + set *generated_mipmaps) { GLuint fbo = 0; @@ -1816,15 +1948,10 @@ void EffectChain::execute_phase(Phase *phase, bool last_phase, mapcreate_2d_texture(GL_RGBA16F, phase->output_width, phase->output_height); + GLuint tex_num = resource_pool->create_2d_texture(intermediate_format, phase->output_width, phase->output_height); output_textures->insert(make_pair(phase, tex_num)); } - const GLuint glsl_program_num = phase->glsl_program_num; - check_error(); - glUseProgram(glsl_program_num); - check_error(); - // Set up RTT inputs for this phase. for (unsigned sampler = 0; sampler < phase->inputs.size(); ++sampler) { glActiveTexture(GL_TEXTURE0 + sampler); @@ -1848,12 +1975,15 @@ void EffectChain::execute_phase(Phase *phase, bool last_phase, mapoutput_width, phase->output_height); } + GLuint instance_program_num = resource_pool->use_glsl_program(phase->glsl_program_num); + check_error(); + // Give the required parameters to all the effects. unsigned sampler_num = phase->inputs.size(); for (unsigned i = 0; i < phase->effects.size(); ++i) { Node *node = phase->effects[i]; unsigned old_sampler_num = sampler_num; - node->effect->set_gl_state(glsl_program_num, phase->effect_ids[node], &sampler_num); + node->effect->set_gl_state(instance_program_num, phase->effect_ids[node], &sampler_num); check_error(); if (node->effect->is_single_texture()) { @@ -1868,17 +1998,41 @@ void EffectChain::execute_phase(Phase *phase, bool last_phase, map::iterator attr_it = bound_attribute_indices->begin(); + attr_it != bound_attribute_indices->end(); ) { + if (phase->attribute_indexes.count(*attr_it) == 0) { + glDisableVertexAttribArray(*attr_it); + check_error(); + bound_attribute_indices->erase(attr_it++); + } else { + ++attr_it; + } + } - glUseProgram(0); - check_error(); + // Set up the new attributes, if needed. + for (set::iterator attr_it = phase->attribute_indexes.begin(); + attr_it != phase->attribute_indexes.end(); + ++attr_it) { + if (bound_attribute_indices->count(*attr_it) == 0) { + glEnableVertexAttribArray(*attr_it); + check_error(); + glVertexAttribPointer(*attr_it, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); + check_error(); + bound_attribute_indices->insert(*attr_it); + } + } + glDrawArrays(GL_TRIANGLES, 0, 3); + check_error(); + for (unsigned i = 0; i < phase->effects.size(); ++i) { Node *node = phase->effects[i]; node->effect->clear_gl_state(); } + resource_pool->unuse_glsl_program(instance_program_num); + if (!last_phase) { resource_pool->release_fbo(fbo); }