v0.49 "You Wanna Come Visit?!...Yeah, Let's Go!"

This is the first release for the new lexpr implementation, which instead of jitasm, uses a modern JIT library -- LLVM.

There are three downloads available:

1. akarin-legacy-amd64-v0.49.zip and akarin-legacy-x86-v0.49.zip are building of the legacy implementation (compared to last release v0.35, just a small bugfix)
2. the real meat of this release is the akarin-lexpr-v0.49.zip. The LLVM based implementation only supports x64. It should support all enhancements of the legacy version and thanks to LLVM, you can use much more sophisticated expressions. For an example, try muvsfunc.fast_mandelbrot(iterations=1000) after patching this line to use core.akarin.Expr instead of core.std.Expr (the stock std.Expr implementation won't even be able to run iterations=5)

Build script not written yet. Pull requests welcome.

tl;dr Download akarin-lexpr-v0.49.zip if you're unsure.

LLVM-based expr implementation reaches feature parity with `akarin.Expr`!

The new LLVM-based implementation finally reaches feature parity with akarin.Expr.

In fact, it also introduces a few small enhancements:

1. floor: you can use -1 * floor -1 * to implement ceil.
2. pi: to access the pi constant, use 1 exp to access e.

Happy alpha testing!

trunc and round support

Release binaries are built by https://github.com/AkarinVS/vapoursynth-plugin/actions/runs/879203011.

This release introduces trunc and round support.

• The trunc and round operators that truncates/rounds to integers.

cosine support

Release binaries are built by https://github.com/AkarinVS/vapoursynth-plugin/actions/runs/878601664.

This release brings experimental support for the cos operator:

• The cos operator. The implementation is reasonable accurate for input magnitude up to 1e5 (absolute error up to 2e-6). Do not pass input whose magnitude is larger than 2e5.

fmod support

Release binaries are built by https://github.com/AkarinVS/vapoursynth-plugin/actions/runs/879060342.

This release brings experimental support for the fmod (%) operator:

• The % binary operator, which implements C fmodf, e.g. trunc can be implemented as dup 1.0 % -.

Experimental std.Expr replacement with LLVM backend

This prerelease is a preview of a new WIP std.Expr replacement akarin.Expr (no sin/cos/N/X/Y extensions yet)
that uses LLVM 10 as JIT backend.

Comparing to the native core.std.Expr implementation, it might be slower for small/trivial inputs but faster on
more complicated expressions.

For example, while core.std.Expr has trouble with even iterations=5 on https://github.com/WolframRhodium/muvsfunc/blob/c72143dc0151a9a82f96f2f8356d08d5ff7d84b8/Collections/muvsfunc_misc.py#L570, this WIP release can handle iterations=10000 within 1 minutes (that is a 1.6MB expression string.)

The simple example expression x y - abs 4 > x y * x x * ? in vapoursynth/vapoursynth#539 (comment), this release is 10% faster even though it only uses 4-way SIMD (AVX) but core.std.Expr uses 8-way SIMD (AVX2), thanks to LLVM's optimization engine.

This is binary-only preview release. The code is still in flux and it's very hard to build. But I do intend to publish the source soon.

sine support

Release binaries are built by https://github.com/AkarinVS/vapoursynth-plugin/actions/runs/868584555.

This release brings experimental support for the sin operator (vapoursynth/vapoursynth#541):

• The sin operator. The implementation is reasonable accurate for input magnitude up to 1e5 (absolute error up to 2e-6). Do not pass input whose magnitude is larger than 2e5.

This is far from perfect, as I'm not exploiting fma as one should (owing to the fact that I have to pick a different set of minimax approximation coefficients to make better use of the precision gain provided by fma. Intel's cpu should do automatic micro op fusion to take advantage of fma function units given the current code structure, so rewriting the current code into fma won't gain much except complicating the code flow in ExprCompiler128, as we can't assume fma is always available there.)

The first release

The first release. Binaries are built by https://github.com/AkarinVS/vapoursynth-plugin/actions/runs/847861917.

Expr

akarin.Expr(clip[] clips, string[] expr[, int format])

This works just like std.Expr (esp. with the same SIMD JIT support on x86 hosts), with the following additions:

• use x.PlaneStatsAverage to load the PlaneStatsAverage frame property of the current frame in the given clip x.
  • Any scalar numerical frame properties can be used;
  • If the property does not exist for a frame, the value will be NaN, which will be clamped to the maximum value.
• use the N operator to load the current frame number;
• use the X and Y operators to load the current column / row (aka mt_lutspa);