X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=README;h=bc6a5a87a58e80c0ab4821888cfa6643d5f2d2e4;hp=485fd341b1bcb2fc00a23d8d94dbe438094ecead;hb=90ac46cdc5845432df13385f946c63b5496c685e;hpb=9c6e299e39c5ce057739da823620c06e8f4230f3 diff --git a/README b/README index 485fd34..bc6a5a8 100644 --- a/README +++ b/README @@ -9,7 +9,7 @@ Movit is the Modern Video Toolkit, notwithstanding that anything that's called “modern” usually isn't, and it's really not a toolkit. Movit aims to be a _high-quality_, _high-performance_, _open-source_ -library for video filters. It is currently in alpha stage. +library for video filters. TL;DR, please give me download link and system demands @@ -20,14 +20,11 @@ OK, you need * A C++98 compiler. GCC will do. (I haven't tried Windows, but it works fine on Linux and OS X, and Movit is not very POSIX-bound.) * GNU Make. -* A GPU capable of running GLSL fragment shaders, - process floating-point textures, and a few other things. If your machine - is less than five years old _and you have the appropriate drivers_ - (don't complain to me if it doesn't work with Nouveau, please), - you're home free. -* The [Eigen 3] and [Google Test] libraries. (The library itself - depends only on the former, but you probably want to run the unit tests.) -* The [GLEW] library, for dealing with OpenGL extensions on various +* A GPU capable of running OpenGL 3.0 or newer. GLES3 (for mobile devices) + will also work. +* The [Eigen 3], [FFTW3] and [Google Test] libraries. (The library itself + does not depend on the latter, but you probably want to run the unit tests.) +* The [epoxy] library, for dealing with OpenGL extensions on various platforms. Movit has been tested with Intel GPUs with the Mesa drivers @@ -40,13 +37,14 @@ for performance estimates. Still TL;DR, please give me the list of filters =============================================== -Blur, diffusion, glow, lift/gamma/gain (color correction), mirror, -mix (add two inputs), overlay (the Porter-Duff “atop” operation), -scale (bilinear and Lanczos), sharpen (both by unsharp mask and by -Wiener filters), saturation (or desaturation), vignette, and white balance. +Blur, diffusion, FFT-based convolution, glow, lift/gamma/gain (color +correction), mirror, mix (add two inputs), luma mix (use a map to wipe between +two inputs), overlay (the Porter-Duff “over” operation), scale (bilinear and +Lanczos), sharpen (both by unsharp mask and by Wiener filters), saturation +(or desaturation), vignette, white balance, and a deinterlacer (YADIF). Yes, that's a short list. But they all look great, are fast and don't give -you any nasty surprises. (I'd love to include denoise, deinterlace and +you any nasty surprises. (I'd love to include denoise and framerate up-/downconversion to the list, but doing them well are all research-grade problems, and Movit is currently not there.) @@ -54,15 +52,17 @@ all research-grade problems, and Movit is currently not there.) TL;DR, but I am interested in a programming example instead =========================================================== -Assuming you have an OpenGL context already set up: +Assuming you have an OpenGL context already set up (either a classic OpenGL +context, a GL 3.x forward-compatible or core context, or a GLES3 context): + using namespace movit; EffectChain chain(1280, 720); ImageFormat inout_format; inout_format.color_space = COLORSPACE_sRGB; inout_format.gamma_curve = GAMMA_sRGB; - FlatInput *input = knew FlatInput(inout_format, FORMAT_BGRA, GL_UNSIGNED_BYTE, 1280, 720)); + FlatInput *input = new FlatInput(inout_format, FORMAT_BGRA_POSTMULTIPLIED_ALPHA, GL_UNSIGNED_BYTE, 1280, 720)); chain.add_input(input); Effect *saturation_effect = chain.add_effect(new SaturationEffect()); @@ -72,7 +72,7 @@ Assuming you have an OpenGL context already set up: const float gain[] = { 0.8f, 1.0f, 1.0f }; lift_gamma_gain_effect->set_vec3("gain", &gain); - chain.add_output(inout_format); + chain.add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED); chain.finalize(); for ( ;; ) { @@ -89,16 +89,17 @@ OK, I can read a bit. What do you mean by “modern”? Backwards compatibility is fine and all, but sometimes we can do better by observing that the world has moved on. In particular: -* It's 2012, so people want to edit HD video. -* It's 2012, so everybody has a GPU. -* It's 2012, so everybody has a working C++ compiler. +* It's 2017, so people want to edit HD video. +* It's 2017, so everybody has a GPU. +* It's 2017, so everybody has a working C++ compiler. (Even Microsoft fixed theirs around 2003!) -While from a programming standpoint I'd love to say that it's 2012 +While from a programming standpoint I'd love to say that it's 2016 and interlacing does no longer exist, but that's not true (and interlacing, hated as it might be, is actually a useful and underrated technique for -bandwidth reduction in broadcast video). Movit will eventually provide -limited support for working with interlaced video, but currently does not. +bandwidth reduction in broadcast video). Movit may eventually provide +limited support for working with interlaced video; it has a deinterlacer, +but cannot currently process video in interlaced form. What do you mean by “high-performance”? @@ -123,9 +124,9 @@ decoding. Exactly what speeds you can expect is of course highly dependent on your GPU and the exact filter chain you are running. As a rule of thumb, you can run a reasonable filter chain (a lift/gamma/gain operation, -a bit of diffusion, maybe a vignette) at 720p in around 30 fps on a two-year-old +a bit of diffusion, maybe a vignette) at 720p in around 30 fps on a four-year-old Intel laptop. If you have a somewhat newer Intel card, you can do 1080p -video without much problems. And on a mid-range nVidia card of today +video without much problems. And on a low-range nVidia card of today (GTX 550 Ti), you can probably process 4K movies directly. @@ -154,9 +155,10 @@ instead of on input? And I can promise you that once we move to more wide-gamut color spaces, like the one in Rec. 2020 (used for UHDTV), the difference will be anything but subtle. As of [why working in linear light matters](http://www.4p8.com/eric.brasseur/gamma.html), -others have explained it better than I can; note also -that this makes Movit future-proof when the world moves towards 10- -and 12-bit color precision. The extra power from the GPU makes all of this +others have explained it better than I can; note also that this makes Movit +future-proof when the world moves towards 10- and 12-bit color precision +(although the latter requires Movit to change from 16-bit to 32-bit floating +point, it is a simple switch). The extra power from the GPU makes all of this simple, so do we not need to make too many concessions for the sake of speed. Movit does not currently do ICC profiles or advanced gamut mapping;