-#define GL_GLEXT_PROTOTYPES 1
-
#include <epoxy/gl.h>
#include <assert.h>
#include <math.h>
: 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),
} 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()
if (owns_resource_pool) {
delete resource_pool;
}
+ glDeleteBuffers(1, &vbo);
+ check_error();
}
Input *EffectChain::add_input(Input *input)
}
void EffectChain::add_ycbcr_output(const ImageFormat &format, OutputAlphaFormat alpha_format,
- const YCbCrFormat &ycbcr_format, YCbCrOutputSplitting output_splitting)
+ const YCbCrFormat &ycbcr_format, YCbCrOutputSplitting output_splitting,
+ GLenum output_type)
{
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 == 1);
+ assert(output_ycbcr_format.chroma_subsampling_y == 1);
+ assert(output_ycbcr_type == output_type);
+ } else {
+ output_ycbcr_format = ycbcr_format;
+ output_ycbcr_type = output_type;
+ }
+ 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 == 1);
+ assert(output_ycbcr_format.chroma_subsampling_y == 1);
+
+ 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) {
return GL_TEXTURE0 + node->incoming_links[input_num]->bound_sampler_num;
}
+GLenum EffectChain::has_input_sampler(Node *node, unsigned input_num) const
+{
+ assert(input_num < node->incoming_links.size());
+ return node->incoming_links[input_num]->bound_sampler_num >= 0 &&
+ node->incoming_links[input_num]->bound_sampler_num < 8;
+}
+
void EffectChain::find_all_nonlinear_inputs(Node *node, vector<Node *> *nonlinear_inputs)
{
if (node->output_gamma_curve == GAMMA_LINEAR &&
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";
frag_shader += string("#define INPUT ") + phase->effect_ids[phase->effects.back()] + "\n";
// If we're the last phase, add the right #defines for Y'CbCr multi-output as needed.
- if (phase->output_node->outgoing_links.empty() && output_color_ycbcr) {
- switch (output_ycbcr_splitting) {
+ vector<string> frag_shader_outputs; // In order.
+ 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");
break;
case YCBCR_OUTPUT_SPLIT_Y_AND_CBCR:
frag_shader += "#define YCBCR_OUTPUT_SPLIT_Y_AND_CBCR 1\n";
+ frag_shader_outputs.push_back("Y");
+ frag_shader_outputs.push_back("Chroma");
break;
case YCBCR_OUTPUT_PLANAR:
frag_shader += "#define YCBCR_OUTPUT_PLANAR 1\n";
+ frag_shader_outputs.push_back("Y");
+ frag_shader_outputs.push_back("Cb");
+ frag_shader_outputs.push_back("Cr");
break;
default:
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
// do, too).
frag_shader_header += "#define YCBCR_ALSO_OUTPUT_RGBA 1\n";
+ 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
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_float_array, "float", effect_id, &phase->uniforms_float, &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_vec3_array, "vec3", effect_id, &phase->uniforms_vec3, &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);
}
vert_shader[pos + needle.size() - 1] = '1';
}
- phase->glsl_program_num = resource_pool->compile_glsl_program(vert_shader, frag_shader);
+ 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);
bool start_new_phase = false;
if (node->effect->needs_texture_bounce() &&
- !deps[i]->effect->is_single_texture()) {
+ !deps[i]->effect->is_single_texture() &&
+ !deps[i]->effect->override_disable_bounce()) {
start_new_phase = true;
}
// 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<Phase *> dedup_inputs;
+ set<Phase *> 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());
// 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;
}
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;
// 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, output_ycbcr_type));
+ connect_nodes(output, ycbcr_conversion_effect_node);
}
// If the user has requested dither, add a DitherEffect right at the end
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;
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<GLint> bound_attribute_indices;
set<Phase *> generated_mipmaps;
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.
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);
}
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();
// 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<GLuint>::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;
}
}
}
printf("Total: %5.1f ms\n", total_time_ms);
}
-void EffectChain::execute_phase(Phase *phase, bool last_phase, map<Phase *, GLuint> *output_textures, set<Phase *> *generated_mipmaps)
+void EffectChain::execute_phase(Phase *phase, bool last_phase,
+ set<GLint> *bound_attribute_indices,
+ map<Phase *, GLuint> *output_textures,
+ set<Phase *> *generated_mipmaps)
{
GLuint fbo = 0;
if (!last_phase) {
find_output_size(phase);
- GLuint tex_num = resource_pool->create_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);
glViewport(0, 0, phase->output_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()) {
// from there.
setup_uniforms(phase);
- glDrawArrays(GL_TRIANGLES, 0, 3);
- check_error();
+ // Clean up old attributes if they are no longer needed.
+ for (set<GLint>::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<GLint>::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);
}
projects / movit / blobdiff