Release Movit 1.6.1.

Fix a typo.

Loosen up some restrictions on strong one-to-one-effects.

In particular, this allows strong one-to-one-effects with multiple
inputs; this was forbidden by the comment, but not enforced anywhere,
and MixEffect was inadvertedly put as strong one-to-one. This actually
triggered at least three distinct bugs (thus three new tests).

Mark a already-done TODO as fixed.

Release Movit 1.6.0.

Typo fixes.

Remove a FIXME which turned out to not be so important after all.

We've run with many more GPUs than just those three now.

2018 README updates.

Break phases when a node needs both to supply mipmaps and _not_ supply mipmaps.

In most cases, this means that we can keep a local copy that supplies
mipmaps and an RTT input that doesn't, or the other way around.

This is not a complete solution, since it doesn't take into account
the case where _both_ inputs will be RTT, but it's good enough for now.

Also requires us to distinguish between links between nodes in the same phase
and in different phases, or we'd get GLSL compile errors as we had both the
local and the RTT input being called e.g. “in0”.

Add explicit support for requesting no mipmaps.

This is significantly less hackish than having the few effects
that don't want mipmaps having to request texture bounce and
fiddling with the sampling parameters themselves.

API change, although only for writing custom effects.

Refactor calculate_scaling_weights() so that it is possible to get weights without bilinear optimization.

Microoptimization in calculate_scaling_weights.

Doesn't actually influence the benchmarks much, but is useful to get 100%
equivalence with the coming compute shader.

Fix some small whitespace errors in SingleResamplePassEffect.

In ResampleEffect, use std::unique_ptr instead of managing ownership ourselves.

Move the functionality for updating the support texture using glTexImage2D or glTexSubImage2D into a separate class.

Another benchmarking data set fix.

Make sure we do not send infinities to benchmarking textures.

Loosen up a bound in ResampleEffectTest a bit.

Add output size as a uniform to compute shaders, as an integer; not just the inverse value as a float.

Reduce the amount of duplication between overloads in test_util.h, by using a few more C++11 features.

Change the resampling tests to fp16 (arguably more useful).

Remove an unused parameter in EffectChainTester.

Fix the uniform name for the compute shader output. (It would always be 0 by accident anyway, but it is nice to have it cleaner.)

When a shader fails compilation, add some line numbers.

Run init_lanczos_table using std::call_once, now that we have C++11.

Add a benchmark for calculate_scaling_weights().

Add some benchmarks for ResampleEffect.

Add missing test shader.

Update .gitignore.

Fix some warnings.

Make it easier to turn on debug for the EffectChain test without having it be turned off again.

Fix resizing compute shaders when used with postprocessing effects.

Support top-left origin for compute shaders.

Minor improvement to a test name.

Fix a bug where the wrong effect would be asked for compute shaders dimensions.

Support chaining certain effects after compute shaders.

This rests on the notion of “strong one-to-one” that's very similar
to the older “one-to-one“ concept, yet a bit stricter (in particular,
PaddingEffect is not strong one-to-one).

Small fix in EffectChainTester constructor.

Use C++11 override everywhere it is appropriate.

Fix a typo in ResizeEffect. Found by virtual → override transition.

Fix some Clang warnings.

Remove the unused fields from ResampleEffect; if we make any changes here, it will have to be later.

Fix another set of test breakages on NVIDIA.

This was broken by c6ee050546b6940ae19a74f92bdcc8d2b1f56d22,
which stopped modifying destination textures' minification modes.

Unbreak FBO caching in unit tests.

EffectChain::render_to_textures() ended up reusing FBOs in a way that
was not compatible with how the tester managed textures; this broke nearly all
unit tests on NVIDIA.

Install compute shaders on make install.

Manage intermediate textures a bit more efficiently.

By holding on to them only for as long as we need to, we'll save some
peak texture RAM, and _might_ in some situations get a bit less cache
trashing.

Support sqrt-transformed intermediates with compute shaders.

Move compute shader functions from the header to the footer; easier to unify with how the fragment shaders work.

Move the compute shader tests into effect_chain_test, as we will have hybrid tests soon.

Support other output formats than GL_RGBA16F; was easier than originally feared.

Do some more cleanups in anticipation of more flexible compute shader outputs.

Includes reverting back to last_phase instead of render_to_texture.

Support rendering compute shaders straight to textures (skipping the dummy phase).

There are lots of limitations currently (only one destination,
only GL_RGBA16F), but it's a good start. Curiously enough,
it doesn't really help anything on the deinterlacing benchmark
for my Haswell, but NVIDIA sees ~15% improvement.

Fix an issue where -std=gnu++11 would become the only flag.

Add a texture barrier after dispatching each compute shader.

This is maybe a bit heavy-handed (there are cases where shaders could
run in parallel), but it's by far the simplest thing to do, since we
have zero control over what happens to the textures we use when they
are handed back to the resource pool.

Add some asserts to EffectChain::execute_phase, so that we do not inadvertedly insert new output textures with number 0.

Invert the meaning of the last_phase boolean to execute_phase().

This is because we can soon have last phases that do not render to FBOs
(those that come out of compute shaders).

Use glGetTexImage() instead of glReadPixels() for reading back test data.

Generally cleaner, and also paves the way for when we have FBO-less
rendering from compute shaders.

Better error messages when skipping compute shader benchmarks.

Implement a compute shdaer version of DeinterlaceEffect.

This is currently a loss for grayscale (probably due to the extra
rgba16f bounce), but a win of about ~30% on BGRA on my Haswell.
NVIDIA doesn't care much either way.

There are some performance mysteries remaining, but it's a good start.

Reduce the clutter in instantiating benchmarks a little bit.

Add a helper class to easier test fragment and compute shader versions of the same effect alongside each other.

Fix compute shader outputs on NVIDIA.

Bump compute shader header to #version 150.

NVIDIA requires this for the layout qualifier, and it's probably right.
Note that this required moving the unit tests to a core context,
due to Mesa's demands.

Drop support for SDL1, which is no longer maintained.

Use auto and range-based for loops a few places where it aids clarity.

More renaming of .compute -> .comp.

Fix an issue where matrices would not get printed out on test failure.

Add a benchmark for DeinterlaceTest without the spatial interlacing check.

Rename .compute to .comp, to be in line with the Khronos reference compiler.

Make BGRA deinterlacing benchmark premultiplied, so that we do not use forever just in bouncing.

Parametrize BM_DeinterlaceEffect so that we have both grayscale and BGRA.

Fix deletion of compute shaders.

Fix some missing NULL -> nullptr.

Revert "Remove C++11 dependency from ResampleEffect."

Add back unique_ptr, now that we have C++11.

This reverts commit 8e9f58fec54a4c879035b214fd7411f6ff7b3a32.

Use double right angle brackets for nested templates everywhere, now that we have C++11.

Use nullptr everywhere, now that we have C++11.

Add support for microbenchmarks.

This depends on Google's microbenchmark library (latest git version,
at least as soon as they pull in the pkg-config file), but it is
not mandatory.

Note that this makes Movit depend on C++11.

Add support for compute shaders.

This is currently pretty raw, and there are no effect using it yet,
but it's a useful first step for getting the infrastructure in place.

There's no need to #undef PREFIX, since we do the token pasting ourselves.

Fix some invalid code in DeinterlaceTest; GCC 7 would optimize it into simply an infinite loop.

Some refactoring in ResourcePool.

Add the GPLv2 license text.

fix compile error: "error: variable-sized object ‘red_data’ may not be initialized"

Support negative values for lift in LiftGammaGainEffect.

Patch by Jean-Baptiste Mardelle <jb@kdenlive.org> (except the test,
which is by myself). Based on work from Dušan Hanuš <hanus@pixelhouse.cz>.

Fix a typo.

Release Movit 1.5.3.

Add a notice to render_to_screen() that it might be suboptimal.

Fix a leak if ResampleEffect is destroyed before being put on a chain.

FFTConvolutionEffect remembered this, but ResampleEffect did not.
Patch by Dan Dennedy.

Fix fp16_test compilation _without_ f16c-enabled compilation flags.

Reported by Arthur Huillet.

Fix fp16_test compilation with f16c-enabled compilation flags.

Remove C++11 dependency from ResampleEffect.

We really ought to allow C++11 in Movit soon, but 1.5.2 is not the right release.

Reported by Etienne d'Hautefeuille.

Fix a double-unlock.

Release Movit 1.5.2.

Add some room for future expansion in ResampleEffect, since I have something that I would like them for and we are breaking the ABI anyway.

Cache VAOs between runs.

NVIDIA's drivers (at least the Linux drivers) seem to have a bug
where, if you call glVertexAttribPointer() in one thread together
with some specific activity in another thread (at least another
glVertexAttribPointer() will do, but I've also seen it during
glXSwapBuffers()), it will try to free a non-malloced pointer,
crashing everything. This happens very rarely, but often enough
that it's a real problem for Nageru.

We solve it by simply pre-creating all needed VAOs ahead-of-time
and caching them, which makes us call glVertexAttribPointer()
a _lot_ less often (basically never, instead of several times
per frame). This might actually be a bit slower than the old code
(I haven't tested), but at least it works around the driver bug.

ABI break, unfortunately, but no API break.

Fix Makefile after fp16 removal.

Inline the fp16 conversion routines. Helps 18% on ResampleEffect::calculate_texture.

Inline combine_two_samples (and remove an obsolete assert). Helps 13–14% on ResampleEffect::calculate_texture.

Some microoptimizations in combine_two_samples(). Saves about 4% in ResampleEffect::calculate_weights.

Remove some unneeded conversions from ResampleEffect. Speeds up texture generation by ~8%.