X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=471d603079ef201d0d41e2e32c193c8899fbd867;hp=519cb2c6b9ea1c5816ead123b05260904519f96e;hb=a6dcad2af7fa40a69b9e4881437cc1dde931c8eb;hpb=b564238fa1293c01c77bcabe7b2de267f146ab24 diff --git a/effect_chain.cpp b/effect_chain.cpp index 519cb2c..471d603 100644 --- a/effect_chain.cpp +++ b/effect_chain.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include "alpha_division_effect.h" #include "alpha_multiplication_effect.h" @@ -19,13 +20,16 @@ #include "dither_effect.h" #include "effect.h" #include "effect_chain.h" +#include "effect_util.h" #include "gamma_compression_effect.h" #include "gamma_expansion_effect.h" #include "init.h" #include "input.h" #include "resource_pool.h" #include "util.h" +#include "ycbcr_conversion_effect.h" +using namespace Eigen; using namespace std; namespace movit { @@ -74,6 +78,20 @@ void EffectChain::add_output(const ImageFormat &format, OutputAlphaFormat alpha_ assert(!finalized); output_format = format; output_alpha_format = alpha_format; + output_color_type = OUTPUT_COLOR_RGB; +} + +void EffectChain::add_ycbcr_output(const ImageFormat &format, OutputAlphaFormat alpha_format, + const YCbCrFormat &ycbcr_format) +{ + assert(!finalized); + output_format = format; + output_alpha_format = alpha_format; + output_color_type = OUTPUT_COLOR_YCBCR; + output_ycbcr_format = ycbcr_format; + + assert(ycbcr_format.chroma_subsampling_x == 1); + assert(ycbcr_format.chroma_subsampling_y == 1); } Node *EffectChain::add_node(Effect *effect) @@ -229,11 +247,61 @@ string replace_prefix(const string &text, const string &prefix) return output; } +namespace { + +template +void extract_uniform_declarations(const vector > &effect_uniforms, + const string &type_specifier, + const string &effect_id, + vector > *phase_uniforms, + string *glsl_string) +{ + for (unsigned i = 0; i < effect_uniforms.size(); ++i) { + phase_uniforms->push_back(effect_uniforms[i]); + phase_uniforms->back().prefix = effect_id; + + *glsl_string += string("uniform ") + type_specifier + " " + effect_id + + "_" + effect_uniforms[i].name + ";\n"; + } +} + +template +void extract_uniform_array_declarations(const vector > &effect_uniforms, + const string &type_specifier, + const string &effect_id, + vector > *phase_uniforms, + string *glsl_string) +{ + for (unsigned i = 0; i < effect_uniforms.size(); ++i) { + phase_uniforms->push_back(effect_uniforms[i]); + phase_uniforms->back().prefix = effect_id; + + char buf[256]; + snprintf(buf, sizeof(buf), "uniform %s %s_%s[%d];\n", + type_specifier.c_str(), effect_id.c_str(), + effect_uniforms[i].name.c_str(), + int(effect_uniforms[i].num_values)); + *glsl_string += buf; + } +} + +template +void collect_uniform_locations(GLuint glsl_program_num, vector > *phase_uniforms) +{ + for (unsigned i = 0; i < phase_uniforms->size(); ++i) { + Uniform &uniform = (*phase_uniforms)[i]; + uniform.location = get_uniform_location(glsl_program_num, uniform.prefix, uniform.name); + } +} + +} // namespace + void EffectChain::compile_glsl_program(Phase *phase) { - string frag_shader = read_version_dependent_file("header", "frag"); + string frag_shader_header = read_version_dependent_file("header", "frag"); + string frag_shader = ""; - // Create functions for all the texture inputs that we need. + // Create functions and uniforms for all the texture inputs that we need. for (unsigned i = 0; i < phase->inputs.size(); ++i) { Node *input = phase->inputs[i]->output_node; char effect_id[256]; @@ -245,14 +313,27 @@ void EffectChain::compile_glsl_program(Phase *phase) frag_shader += "\treturn tex2D(tex_" + string(effect_id) + ", tc);\n"; frag_shader += "}\n"; frag_shader += "\n"; + + Uniform uniform; + uniform.name = effect_id; + uniform.value = &phase->input_samplers[i]; + uniform.prefix = "tex"; + uniform.num_values = 1; + uniform.location = -1; + phase->uniforms_sampler2d.push_back(uniform); } + // Give each effect in the phase its own ID. for (unsigned i = 0; i < phase->effects.size(); ++i) { Node *node = phase->effects[i]; char effect_id[256]; sprintf(effect_id, "eff%u", i); phase->effect_ids.insert(make_pair(node, effect_id)); + } + for (unsigned i = 0; i < phase->effects.size(); ++i) { + Node *node = phase->effects[i]; + const string effect_id = phase->effect_ids[node]; if (node->incoming_links.size() == 1) { frag_shader += string("#define INPUT ") + phase->effect_ids[node->incoming_links[0]] + "\n"; } else { @@ -265,7 +346,6 @@ void EffectChain::compile_glsl_program(Phase *phase) frag_shader += "\n"; frag_shader += string("#define FUNCNAME ") + effect_id + "\n"; - frag_shader += replace_prefix(node->effect->output_convenience_uniforms(), effect_id); frag_shader += replace_prefix(node->effect->output_fragment_shader(), effect_id); frag_shader += "#undef PREFIX\n"; frag_shader += "#undef FUNCNAME\n"; @@ -283,8 +363,43 @@ void EffectChain::compile_glsl_program(Phase *phase) frag_shader += string("#define INPUT ") + phase->effect_ids[phase->effects.back()] + "\n"; frag_shader.append(read_version_dependent_file("footer", "frag")); + // Collect uniforms from all effects and output them. Note that this needs + // to happen after output_fragment_shader(), even though the uniforms come + // before in the output source, since output_fragment_shader() is allowed + // to register new uniforms (e.g. arrays that are of unknown length until + // finalization time). + // TODO: Make a uniform block for platforms that support it. + string frag_shader_uniforms = ""; + for (unsigned i = 0; i < phase->effects.size(); ++i) { + Node *node = phase->effects[i]; + Effect *effect = node->effect; + const string effect_id = phase->effect_ids[node]; + extract_uniform_declarations(effect->uniforms_sampler2d, "sampler2D", effect_id, &phase->uniforms_sampler2d, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_bool, "bool", effect_id, &phase->uniforms_bool, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_int, "int", effect_id, &phase->uniforms_int, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_float, "float", effect_id, &phase->uniforms_float, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_vec2, "vec2", effect_id, &phase->uniforms_vec2, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_vec3, "vec3", effect_id, &phase->uniforms_vec3, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_vec4, "vec4", effect_id, &phase->uniforms_vec4, &frag_shader_uniforms); + extract_uniform_array_declarations(effect->uniforms_vec2_array, "vec2", effect_id, &phase->uniforms_vec2, &frag_shader_uniforms); + extract_uniform_array_declarations(effect->uniforms_vec4_array, "vec4", effect_id, &phase->uniforms_vec4, &frag_shader_uniforms); + extract_uniform_declarations(effect->uniforms_mat3, "mat3", effect_id, &phase->uniforms_mat3, &frag_shader_uniforms); + } + + frag_shader = frag_shader_header + frag_shader_uniforms + frag_shader; + string vert_shader = read_version_dependent_file("vs", "vert"); phase->glsl_program_num = resource_pool->compile_glsl_program(vert_shader, frag_shader); + + // Collect the resulting location numbers for each uniform. + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_sampler2d); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_bool); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_int); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_float); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec2); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec3); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec4); + collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_mat3); } // Construct GLSL programs, starting at the given effect and following @@ -419,6 +534,9 @@ Phase *EffectChain::construct_phase(Node *output, map *complete sort(phase->inputs.begin(), phase->inputs.end()); phase->inputs.erase(unique(phase->inputs.begin(), phase->inputs.end()), phase->inputs.end()); + // Allocate samplers for each input. + phase->input_samplers.resize(phase->inputs.size()); + // 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); @@ -1363,6 +1481,22 @@ void EffectChain::fix_output_gamma() connect_nodes(output, conversion); } } + +// If the user has requested Y'CbCr output, we need to do this conversion +// _after_ GammaCompressionEffect etc., but before dither (see below). +// This is because Y'CbCr, with the exception of a special optional mode +// in Rec. 2020 (which we currently don't support), is defined to work on +// gamma-encoded data. +void EffectChain::add_ycbcr_conversion_if_needed() +{ + assert(output_color_type == OUTPUT_COLOR_RGB || output_color_type == OUTPUT_COLOR_YCBCR); + if (output_color_type != OUTPUT_COLOR_YCBCR) { + return; + } + Node *output = find_output_node(); + Node *ycbcr = add_node(new YCbCrConversionEffect(output_ycbcr_format)); + connect_nodes(output, ycbcr); +} // If the user has requested dither, add a DitherEffect right at the end // (after GammaCompressionEffect etc.). This needs to be done after everything else, @@ -1445,11 +1579,13 @@ void EffectChain::finalize() fix_internal_gamma_by_asking_inputs(15); fix_internal_gamma_by_inserting_nodes(16); - output_dot("step17-before-dither.dot"); + output_dot("step17-before-ycbcr.dot"); + add_ycbcr_conversion_if_needed(); + output_dot("step18-before-dither.dot"); add_dither_if_needed(); - output_dot("step18-final.dot"); + output_dot("step19-final.dot"); // Construct all needed GLSL programs, starting at the output. // We need to keep track of which effects have already been computed, @@ -1458,7 +1594,7 @@ void EffectChain::finalize() map completed_effects; construct_phase(find_output_node(), &completed_effects); - output_dot("step19-split-to-phases.dot"); + output_dot("step20-split-to-phases.dot"); assert(phases[0]->inputs.empty()); @@ -1612,7 +1748,8 @@ void EffectChain::execute_phase(Phase *phase, bool last_phase, mapinsert(input); } - setup_rtt_sampler(glsl_program_num, sampler, phase->effect_ids[input->output_node], phase->input_needs_mipmaps); + setup_rtt_sampler(sampler, phase->input_needs_mipmaps); + phase->input_samplers[sampler] = sampler; // Bind the sampler to the right uniform. } // And now the output. (Already set up for us if it is the last phase.) @@ -1638,6 +1775,10 @@ void EffectChain::execute_phase(Phase *phase, bool last_phase, mapuniforms_sampler2d.size(); ++i) { + const Uniform &uniform = phase->uniforms_sampler2d[i]; + if (uniform.location != -1) { + glUniform1iv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_bool.size(); ++i) { + const Uniform &uniform = phase->uniforms_bool[i]; + assert(uniform.num_values == 1); + if (uniform.location != -1) { + glUniform1i(uniform.location, *uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_int.size(); ++i) { + const Uniform &uniform = phase->uniforms_int[i]; + if (uniform.location != -1) { + glUniform1iv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_float.size(); ++i) { + const Uniform &uniform = phase->uniforms_float[i]; + if (uniform.location != -1) { + glUniform1fv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_vec2.size(); ++i) { + const Uniform &uniform = phase->uniforms_vec2[i]; + if (uniform.location != -1) { + glUniform2fv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_vec3.size(); ++i) { + const Uniform &uniform = phase->uniforms_vec3[i]; + if (uniform.location != -1) { + glUniform3fv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_vec4.size(); ++i) { + const Uniform &uniform = phase->uniforms_vec4[i]; + if (uniform.location != -1) { + glUniform4fv(uniform.location, uniform.num_values, uniform.value); + } + } + for (size_t i = 0; i < phase->uniforms_mat3.size(); ++i) { + const Uniform &uniform = phase->uniforms_mat3[i]; + assert(uniform.num_values == 1); + if (uniform.location != -1) { + // Convert to float (GLSL has no double matrices). + float matrixf[9]; + for (unsigned y = 0; y < 3; ++y) { + for (unsigned x = 0; x < 3; ++x) { + matrixf[y + x * 3] = (*uniform.value)(y, x); + } + } + glUniformMatrix3fv(uniform.location, 1, GL_FALSE, matrixf); + } + } +} + +void EffectChain::setup_rtt_sampler(int sampler_num, bool use_mipmaps) { glActiveTexture(GL_TEXTURE0 + sampler_num); check_error(); @@ -1691,10 +1894,6 @@ void EffectChain::setup_rtt_sampler(GLuint glsl_program_num, int sampler_num, co check_error(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); check_error(); - - string texture_name = string("tex_") + effect_id; - glUniform1i(glGetUniformLocation(glsl_program_num, texture_name.c_str()), sampler_num); - check_error(); } } // namespace movit