X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.h;h=6cd689d7c38f0b8386deb007d88ad1449a0f18cf;hp=c38f34749cb89ff2a68fe67b61a62abcc5364983;hb=d4f00f9f47a0efaefabaf1efa1a0e214eeecca67;hpb=ff9e68a3f5abb179bd7bf9fb84df48327f148583 diff --git a/effect_chain.h b/effect_chain.h index c38f347..6cd689d 100644 --- a/effect_chain.h +++ b/effect_chain.h @@ -1,15 +1,50 @@ -#ifndef _EFFECT_CHAIN_H -#define _EFFECT_CHAIN_H 1 - +#ifndef _MOVIT_EFFECT_CHAIN_H +#define _MOVIT_EFFECT_CHAIN_H 1 + +// An EffectChain is the largest basic entity in Movit; it contains everything +// needed to connects a series of effects, from inputs to outputs, and render +// them. Generally you set up your effect chain once and then call its render +// functions once per frame; setting one up can be relatively expensive, +// but rendering is fast. +// +// Threading considerations: EffectChain is “thread-compatible”; you can use +// different EffectChains in multiple threads at the same time (assuming the +// threads do not use the same OpenGL context, but this is a good idea anyway), +// but you may not use one EffectChain from multiple threads simultaneously. +// You _are_ allowed to use one EffectChain from multiple threads as long as +// you only use it from one at a time (possibly by doing your own locking), +// but if so, the threads' contexts need to be set up to share resources, since +// the EffectChain holds textures and other OpenGL objects that are tied to the +// context. + +#include +#include +#include #include +#include #include -#include "effect.h" #include "image_format.h" -#include "input.h" -class EffectChain; -class Phase; +class Effect; +class Input; +struct Phase; +class ResourcePool; + +// 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_FORMAT_PREMULTIPLIED, + OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED, +}; // A node in the graph; basically an effect and some associated information. class Node { @@ -22,9 +57,6 @@ public: 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. @@ -42,13 +74,14 @@ private: // 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; + GLuint glsl_program_num; // Owned by the resource_pool. bool input_needs_mipmaps; // Inputs are only inputs from other phases (ie., those that come from RTT); @@ -56,12 +89,22 @@ struct Phase { std::vector inputs; std::vector effects; // In order. - unsigned output_width, output_height; + unsigned output_width, output_height, virtual_output_width, virtual_output_height; + + // Identifier used to create unique variables in GLSL. + // Unique per-phase to increase cacheability of compiled shaders. + std::map effect_ids; }; class EffectChain { public: - EffectChain(float aspect_nom, float aspect_denom); // E.g., 16.0f, 9.0f for 16:9. + // Aspect: e.g. 16.0f, 9.0f for 16:9. + // resource_pool is a pointer to a ResourcePool with which to share shaders + // and other resources (see resource_pool.h). If NULL (the default), + // will create its own that is not shared with anything else. Does not take + // ownership of the passed-in ResourcePool, but will naturally take ownership + // of its own internal one if created. + EffectChain(float aspect_nom, float aspect_denom, ResourcePool *resource_pool = NULL); ~EffectChain(); // User API: @@ -89,7 +132,7 @@ public: } Effect *add_effect(Effect *effect, const std::vector &inputs); - void add_output(const ImageFormat &format); + 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. @@ -132,9 +175,10 @@ public: void insert_node_between(Node *sender, Node *middle, Node *receiver); 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); + // Make sure the output rectangle is at least large enough to hold + // the given input rectangle in both dimensions, and is of the + // current aspect ratio (aspect_nom/aspect_denom). + void size_rectangle_to_fit(unsigned width, unsigned height, unsigned *output_width, unsigned *output_height); // Compute the input sizes for all inputs for all effects in a given phase, // and inform the effects about the results. @@ -159,14 +203,30 @@ private: // 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_nodes_topologically(); - void topological_sort_visit_node(Node *node, std::set *visited_nodes, std::vector *sorted_list); + 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(); @@ -174,6 +234,10 @@ private: 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); @@ -182,19 +246,20 @@ private: 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; - unsigned bytes_per_pixel, num_dither_bits; + unsigned num_dither_bits; bool finalized; + + ResourcePool *resource_pool; + bool owns_resource_pool; }; -#endif // !defined(_EFFECT_CHAIN_H) +#endif // !defined(_MOVIT_EFFECT_CHAIN_H)