Name some threads.

Subsample chroma on the GPU instead of the CPU.

Faster, and also gets the subsampling right. The shaders come from Nageru,
but the support code is heavily tweaked to be more like flow.h.

Change from operating point 3 to 2 (more laptop-friendly debugging).

Do deinterleaving on the GPU (subsampling still remains).

Do the interpolation in Y'CbCr instead of RGBA; saves some conversions back and forth. Subsampling is stil done on the CPU (to be fixed).

Fix so that make clean removes all objects.

Give the VideoStream thread a name.

Make VideoStream capable of using the shared JPEG cache, saving lots of CPU.

Release flow textures when we are done with them.

Make the output actually follow the input in an interpolated fashion.

Read timebase from the input video.

Fix some flickering due to YCbCr interpretation.

Encode JPEGs from the interpolated frames.

Start hacking in support for interpolated frames in the main application.

Fix an issue where interpolation would not work, since something (Qt?) turned off depth writing.

Editorial changes.

Split out the flow code from the example driver.

Make disabling variational refinement somewhat more efficient.

OP2 minus variational refinement is now sub-millisecond for
1024x436 forward flow on my Haswell laptop. (Full OP2 forward+backward
with interpolation is easily realtime.)

Parametrize patch size and number of iterations.

Start parametrizing the operating points for DIS.

Move flow classes into a header file; first step on the way to making it accessible.

Move stream generation into a new class VideoStream, which will also soon deal with the GPU.

Actually send the MJPEG frames on to the HTTP stream.

Import a bunch of http/mux code from Nageru.

av_register_all() is deprecated, so do not call it anymore (no replacement needed).

Support rendering forward and backward flow in parallel.

~15% faster flow computation on GTX 950; the lower resolutions are so
inherently low-parallel, so we get backward flow on those levels
essentially for free. Should be even more important on larger GPUs.

16-bit depth should be plenty.

Use a renderbuffer instead of a depth texture; potentially faster.

Rename “Total” to something more descriptive.

Fix a warning in motion_search.frag.

Fix patch placement. Again.

Add a warmup option to get somewhat more consistent timings.

Fix a bug where the first black pass of SOR would read junk data.

Rename du_dv_tex to diff_flow_tex, for consistency.

Update the SOR comment about twinned buffering.

Fix an outdated comment.

Microoptimization in the SOR fragment shader.

Split the equation texture in two, which speeds up SOR by ~30%.

Fix a NaN issue on Intel.

Pack the gradients and image together into a single 32-bit texture; seems to help ~1.5 ms for flow on NVIDIA.

Remove some redundant glUseProgram() calls.

Remove an unused uniform.

Properly release the flow texture; saves 1 ms (!) on FBO creation.

Compute diffusivity instead of smoothness, which saves a flow-size texture; shaves about 0.2 ms off 720p flow on GTX 950.

Remove some dead code.

Microoptimization in splat.vert.

Share VAOs between all the passes. Much less code, less rebinding overhead.

Fix an issue where we would lose >1 ms for computing flow on NVIDIA, due to lack of fast clears.

Make PersistentFBOSet handle depth.

Remove the rather pointless enable_if tests for now. And move to C++14.

Fix a GLSL syntax error that tripped up NVIDIA.

Disable dither; we don't need it.

When timing a level, print the resolution.

Make a new flag --detailed-timing for microsecond measurements and more.

Move GPUTimers into its own file.

Remove an unused uniform.

Use the same PBO readback system for interpolated images as flows.

Speed up hole filling by ~10%.

Implement hole filling.

Put depth in 0..1; evidently even fp32 depth is clamped in the ARB version.

Start working on interpolation code.

Do RGB -> grayscale conversion on the GPU.

Split texture pooling out from DISComputeFlow into its own class.

Hide the OpenGL window; it is rather annoying.

Remove a TODO.

Making the penalizer smaller (as one should if adjusting it towards
a smaller range, as there's effectively I² numerator and I denominator)
does not seem to have much effect; actually, increasing it to 0.01
seems to give better results on alley-2, but that's the “wrong way”.

Stop leaking texture views (and by extension, textures).

Small code cleanup.

Use textureSize() instead of sending in uniforms manually. Same result, less code, less error-prone.

Remove a TODO; setting up equations is not where our time goes.

Halve the number of motion search iterations, to eight.

The DIS code claims this is allowed after they changed their Sobel code;
for us, seemingly SOR was the breaking point. EPE is hardly moving
(<1% for most Sintel tests I've run), but speed goes up markedly.

Finally get SOR working.

The trick here was something I'd considered for a long time,
namely red-black SOR so that we update only half the values
every iteration. The implementation is annoyingly inefficient,
but convergence is so much better that it's worth it (a few
percent EPE improvement).

Fix a mixup in the variational refinement text.

Close off a TODO.

Rework patch placement. Finally inches our EPE just below the reference code, it seems.

Tweak the default variational refinement weights (optimized on alley_2).

Give the variational refinement terms slightly less mysterious names.

Fix a done TODO (gamma is for E_G, not E_S, and we multiply in the alpha in the smoothness).

Sample gradient as zero outside the image, instead of repeating them. Helps dramatically on edge patches. 20% EPE improvement on alley_2.

Small syntactic tweak.

Fix the patch out-of-bounds check in motion search (it was all broken).

Fix a problem with visualizing flow that goes exactly left.

Use asynchronous readback when doing many flows. Speeds up 50-frame jobs by about 30%; PNG reading is now the dominant cost (60% or so).

Fix some uniforms not getting through to the motion search vertex shader.

Add a debugging flag to disable/ignore variational refinement.

Change the discard condition for motion search.

Fix a typo.

Make motion search happen mostly in pixels; a bit less code that way.

Print EPE on stdout, since it is not an error.

Make flow writing a bit faster.

Print out the first flow pair, too.

Add a --disable-timing flag (less spew, less GPU waiting).

Add support for computing many flows sequentially (reduces startup overhead).

Refactor the flow writing.

Reuse textures between flow invocations.

Make a wrapper class for all the flow logic.

Refactor FBO creation. A step on the way to persistent FBOs and temporary textures.

Small cleanup.

Make the eval tool capable of taking the average over a series of flow files.

Make it possible to set alpha/delta/gamma on the command line, for grid searches.

Add in the relative weighting of the variational refinement terms.