X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.h;h=f0138a99d48bd5a6783f6357229f37fa3d5b03d7;hp=9d389d53f3d25dee54bfcc130653bc8fc5d6416c;hb=c8ddccde29b5dd2c207cc67fa8af2707904557d8;hpb=416abbec4dbde5ce6b05ada2b2977b18a6718190 diff --git a/effect_chain.h b/effect_chain.h index 9d389d5..f0138a9 100644 --- a/effect_chain.h +++ b/effect_chain.h @@ -8,9 +8,77 @@ #include "image_format.h" #include "input.h" +class EffectChain; +class Phase; + +// For internal use within Node. +enum AlphaType { + ALPHA_INVALID = -1, + ALPHA_BLANK, + ALPHA_PREMULTIPLIED, + ALPHA_POSTMULTIPLIED, +}; + +// Whether you want pre- or postmultiplied alpha in the output +// (see effect.h for a discussion of pre- versus postmultiplied alpha). +enum OutputAlphaFormat { + OUTPUT_ALPHA_PREMULTIPLIED, + OUTPUT_ALPHA_POSTMULTIPLIED, +}; + +// A node in the graph; basically an effect and some associated information. +class Node { +public: + Effect *effect; + bool disabled; + + // Edges in the graph (forward and backward). + std::vector outgoing_links; + std::vector incoming_links; + +private: + // Identifier used to create unique variables in GLSL. + std::string effect_id; + + // Logical size of the output of this effect, ie. the resolution + // you would get if you sampled it as a texture. If it is undefined + // (since the inputs differ in resolution), it will be 0x0. + // If both this and output_texture_{width,height} are set, + // they will be equal. + unsigned output_width, output_height; + + // If output goes to RTT (otherwise, none of these are set). + // The Phase pointer is a but ugly; we should probably fix so + // that Phase takes other phases as inputs, instead of Node. + GLuint output_texture; + unsigned output_texture_width, output_texture_height; + Phase *phase; + + // Used during the building of the effect chain. + Colorspace output_color_space; + GammaCurve output_gamma_curve; + AlphaType output_alpha_type; + + friend class EffectChain; +}; + +// A rendering phase; a single GLSL program rendering a single quad. +struct Phase { + GLint glsl_program_num, vertex_shader, fragment_shader; + bool input_needs_mipmaps; + + // Inputs are only inputs from other phases (ie., those that come from RTT); + // input textures are not counted here. + std::vector inputs; + + std::vector effects; // In order. + unsigned output_width, output_height; +}; + class EffectChain { public: - EffectChain(unsigned width, unsigned height); + EffectChain(float aspect_nom, float aspect_denom); // E.g., 16.0f, 9.0f for 16:9. + ~EffectChain(); // User API: // input, effects, output, finalize need to come in that specific order. @@ -37,21 +105,28 @@ public: } Effect *add_effect(Effect *effect, const std::vector &inputs); - // Similar to add_effect, but: - // - // * Does not insert any normalizing effects. - // * Does not ask the effect to insert itself, so it won't work - // with meta-effects. - // - // We should really separate out these two “sides” of Effect in the - // type system soon. - void add_effect_raw(Effect *effect, const std::vector &inputs); + void add_output(const ImageFormat &format, OutputAlphaFormat alpha_format); + + // Set number of output bits, to scale the dither. + // 8 is the right value for most outputs. + // The default, 0, is a special value that means no dither. + void set_dither_bits(unsigned num_bits) + { + this->num_dither_bits = num_bits; + } - void add_output(const ImageFormat &format); void finalize(); + //void render(unsigned char *src, unsigned char *dst); - void render_to_screen(); + void render_to_screen() + { + render_to_fbo(0, 0, 0); + } + + // Render the effect chain to the given FBO. If width=height=0, keeps + // the current viewport. + void render_to_fbo(GLuint fbo, unsigned width, unsigned height); Effect *last_added_effect() { if (nodes.empty()) { @@ -61,56 +136,33 @@ public: } } -private: - struct Phase; - - // A node in the graph; basically an effect and some associated information. - struct Node { - Effect *effect; - - // Identifier used to create unique variables in GLSL. - std::string effect_id; - - // Edges in the graph (forward and backward). - std::vector outgoing_links; - std::vector incoming_links; - - // If output goes to RTT (otherwise, none of these are set). - // The Phsae pointer is a but ugly; we should probably fix so - // that Phase takes other phases as inputs, instead of Node. - GLuint output_texture; - unsigned output_texture_width, output_texture_height; - Phase *phase; - - // Used during the building of the effect chain. - ColorSpace output_color_space; - GammaCurve output_gamma_curve; - }; - - // A rendering phase; a single GLSL program rendering a single quad. - struct Phase { - GLint glsl_program_num; - bool input_needs_mipmaps; + // API for manipulating the graph directly. Intended to be used from + // effects and by EffectChain itself. + // + // Note that for nodes with multiple inputs, the order of calls to + // connect_nodes() will matter. + Node *add_node(Effect *effect); + void connect_nodes(Node *sender, Node *receiver); + void replace_receiver(Node *old_receiver, Node *new_receiver); + void replace_sender(Node *new_sender, Node *receiver); + void insert_node_between(Node *sender, Node *middle, Node *receiver); - // Inputs are only inputs from other phases (ie., those that come from RTT); - // input textures are not counted here. - std::vector inputs; +private: + // Fits a rectangle of the given size to the current aspect ratio + // (aspect_nom/aspect_denom) and returns the new width and height. + unsigned fit_rectangle_to_aspect(unsigned width, unsigned height); - std::vector effects; // In order. - unsigned output_width, output_height; - }; + // Compute the input sizes for all inputs for all effects in a given phase, + // and inform the effects about the results. + void inform_input_sizes(Phase *phase); // Determine the preferred output size of a given phase. // Requires that all input phases (if any) already have output sizes set. void find_output_size(Phase *phase); - void find_all_nonlinear_inputs(Node *effect, - std::vector *nonlinear_inputs, - std::vector *intermediates); - Node *normalize_to_linear_gamma(Node *input); - Node *normalize_to_srgb(Node *input); - - void draw_vertex(float x, float y, const std::vector &inputs); + // Find all inputs eventually feeding into this effect that have + // output gamma different from GAMMA_LINEAR. + void find_all_nonlinear_inputs(Node *effect, std::vector *nonlinear_inputs); // Create a GLSL program computing the given effects in order. Phase *compile_glsl_program(const std::vector &inputs, @@ -120,20 +172,65 @@ private: // that depends on it (whenever possible). void construct_glsl_programs(Node *output); - unsigned width, height; + // Output the current graph to the given file in a Graphviz-compatible format; + // only useful for debugging. + void output_dot(const char *filename); + std::vector get_labels_for_edge(const Node *from, const Node *to); + void output_dot_edge(FILE *fp, + const std::string &from_node_id, + const std::string &to_node_id, + const std::vector &labels); + + // Some of the graph algorithms assume that the nodes array is sorted + // topologically (inputs are always before outputs), but some operations + // (like graph rewriting) can change that. This function restores that order. + void sort_all_nodes_topologically(); + + // Do the actual topological sort. must be a connected, acyclic subgraph; + // links that go to nodes not in the set will be ignored. + std::vector topological_sort(const std::vector &nodes); + + // Utility function used by topological_sort() to do a depth-first search. + // The reason why we store nodes left to visit instead of a more conventional + // list of nodes to visit is that we want to be able to limit ourselves to + // a subgraph instead of all nodes. The set thus serves a dual purpose. + void topological_sort_visit_node(Node *node, std::set *nodes_left_to_visit, std::vector *sorted_list); + + // Used during finalize(). + void find_color_spaces_for_inputs(); + void propagate_alpha(); + void propagate_gamma_and_color_space(); + Node *find_output_node(); + + bool node_needs_colorspace_fix(Node *node); + void fix_internal_color_spaces(); + void fix_output_color_space(); + + bool node_needs_alpha_fix(Node *node); + void fix_internal_alpha(unsigned step); + void fix_output_alpha(); + + bool node_needs_gamma_fix(Node *node); + void fix_internal_gamma_by_asking_inputs(unsigned step); + void fix_internal_gamma_by_inserting_nodes(unsigned step); + void fix_output_gamma(); + void add_dither_if_needed(); + + float aspect_nom, aspect_denom; ImageFormat output_format; + OutputAlphaFormat output_alpha_format; std::vector nodes; std::map node_map; + Effect *dither_effect; std::vector inputs; // Also contained in nodes. GLuint fbo; std::vector phases; - GLenum format, bytes_per_pixel; + unsigned num_dither_bits; bool finalized; }; - #endif // !defined(_EFFECT_CHAIN_H)