+
+ // Whether there is a direct correspondence between input and output
+ // texels. Specifically, the effect must not:
+ //
+ // 1. Try to sample in the border (ie., outside the 0.0 to 1.0 area).
+ // 2. Try to sample between texels.
+ // 3. Sample with an x- or y-derivative different from -1 or 1.
+ // (This also means needs_mipmaps() and one_to_one_sampling()
+ // together would make no sense.)
+ //
+ // The most common case for this would be an effect that has an exact
+ // 1:1-correspondence between input and output texels, e.g. SaturationEffect.
+ // However, more creative things, like mirroring/flipping or padding,
+ // would also be allowed.
+ //
+ // The primary gain from setting this is that you can sample directly
+ // from an effect that changes output size (see changes_output_size() below),
+ // without going through a bounce texture. It won't work for effects that
+ // set sets_virtual_output_size(), though.
+ //
+ // Does not make a lot of sense together with needs_texture_bounce().
+ virtual bool one_to_one_sampling() const { return false; }
+
+ // Whether this effect wants to output to a different size than
+ // its input(s) (see inform_input_size(), below). See also
+ // sets_virtual_output_size() below.
+ virtual bool changes_output_size() const { return false; }
+
+ // Whether your get_output_size() function (see below) intends to ever set
+ // virtual_width different from width, or similar for height.
+ // It does not make sense to set this to true if changes_output_size() is false.
+ virtual bool sets_virtual_output_size() const { return changes_output_size(); }
+
+ // Whether this effect is effectively sampling from a a single texture.
+ // If so, it will override needs_texture_bounce(); however, there are also
+ // two demands it needs to fulfill:
+ //
+ // 1. It needs to be an Input, ie. num_inputs() == 0.
+ // 2. It needs to allocate exactly one sampler in set_gl_state(),
+ // and allow dependent effects to change that sampler state.
+ virtual bool is_single_texture() const { return false; }
+
+ // If set, this effect should never be bounced to an output, even if a
+ // dependent effect demands texture bounce.
+ //
+ // Note that setting this can invoke undefined behavior, up to and including crashing,
+ // so you should only use it if you have deep understanding of your entire chain
+ // and Movit's processing of it. The most likely use case is if you have an input
+ // that's cheap to compute but not a single texture (e.g. YCbCrInput), and want
+ // to run a ResampleEffect directly from it. Normally, this would require a bounce,
+ // but it's faster not to. (However, also note that in this case, effective texel
+ // subpixel precision will be too optimistic, since chroma is already subsampled.)
+ //
+ // Has no effect if is_single_texture() is set.
+ virtual bool override_disable_bounce() const { return false; }
+
+ // If changes_output_size() is true, you must implement this to tell
+ // the framework what output size you want. Also, you can set a
+ // virtual width/height, which is the size the next effect (if any)
+ // will _think_ your data is in. This is primarily useful if you are
+ // relying on getting OpenGL's bilinear resizing for free; otherwise,
+ // your virtual_width/virtual_height should be the same as width/height.
+ //
+ // Note that it is explicitly allowed to change width and height
+ // from frame to frame; EffectChain will reallocate textures as needed.
+ virtual void get_output_size(unsigned *width, unsigned *height,
+ unsigned *virtual_width, unsigned *virtual_height) const {
+ assert(false);
+ }
+
+ // Whether this effect uses a compute shader instead of a regular fragment shader.
+ // Compute shaders are more flexible in that they can have multiple outputs
+ // for each invocation and also communicate between instances (by using shared
+ // memory within each group), but are not universally supported. The typical
+ // pattern would be to check movit_compute_shaders_supported and rewrite the
+ // graph to use a compute shader effect instead of a regular effect if it is
+ // available, in order to get better performance. Since compute shaders can reuse
+ // loads (again typically through shared memory), using needs_texture_bounce()
+ // is usually not needed, although it is allowed; the best candidates for compute
+ // shaders are typically those that sample many times from their input
+ // but can reuse those loads across neighboring instances.
+ //
+ // Compute shaders commonly work with unnormalized texture coordinates
+ // (where coordinates are integers [0..W) and [0..H)), whereas the rest
+ // of Movit, including any inputs you may want to sample from, works
+ // with normalized coordinates ([0..1)). Movit gives you uniforms
+ // PREFIX(inv_output_size) and PREFIX(output_texcoord_adjust) that you
+ // can use to transform unnormalized to normalized, as well as a macro
+ // NORMALIZE_TEXTURE_COORDS(vec2) that does it for you.
+ //
+ // Since compute shaders have flexible output, it is difficult to chain other
+ // effects after them in the same phase, and thus, they will always be last.
+ // (This limitation may be lifted for the special case of one-to-one effects
+ // in the future.) Furthermore, they cannot write to the framebuffer, just to
+ // textures, so Movit may have to insert an extra phase just to do the output
+ // from a texture to the screen in some cases. However, this is transparent
+ // to both the effect and the user.
+ virtual bool is_compute_shader() const { return false; }
+
+ // For a compute shader (see the previous member function), what dimensions
+ // it should be invoked over. Called every frame, before uniforms are set
+ // (so you are allowed to update uniforms based from this call).
+ virtual void get_compute_dimensions(unsigned output_width, unsigned output_height,
+ unsigned *x, unsigned *y, unsigned *z) const {
+ *x = output_width;
+ *y = output_height;
+ *z = 1;