image VS rav1e

There's also a CLI to convert between formats. It uses the crate image.

exr is a is a 100% Rust and 100% safe code library for reading and writing OpenEXR images. It is used by the popular image crate to read and write OpenEXR.

We're currently looking for contributors to add support for zune-jpeg to the image crate. The image maintainers are open to it, but don't have the capacity to do it themselves. You can find more details here.

It uses https://github.com/1Password/arboard and https://github.com/image-rs/image under the hood. I haven't tested deeply but I assume it should handle many formats out of the box.

You can use the image crate.

As for image processing, I'd start on crates.io and search for "image processing" and skim through to find the most downloaded crates -- image seems to be the most popular, with over 7 million downloads, so I'd check if that has what you want, and if not photon-rs seemed relatively mature with perhaps more features (albeit far less commonly used)

Glad it worked out for you—it seemed like the features are there for basic image conversion, but try to do something a little more sophisticated and you run into some severe design limits. Here is the kind of underlying problem I’m talking about:

https://github.com/image-rs/image/issues/1523

Side note the image-rs crate in the Rust ecosystem has no external dependencies and can encode and decode animated gifs and a variety of other image formats, 100% rust https://github.com/image-rs/image

I believe that photon uses image internally which only provides the ability to overlay another image. The crate imageproc extends image and adds the draw_text method.

And for image resizing I used the "image" crate: https://crates.io/crates/image. Note that while in development mode resizing an image takes a long time (several seconds for me), but in production mode it is lightning fast. I spent some time trying to figure this out :D

It's getting there.. Initial steps for FFmepg: https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=8444 rav1e: https://github.com/xiph/rav1e/pull/3000

I doubt much will be done on such an exotic feature any time soon. Progress has been slow on rav1e, it's missing a lot of features, and only supports tile threading.

rav1e is quite well maintained, the fix for the lint was merged days after the ilog PR merged. But the 0.5.1 release of rav1e was one year ago, in December 2021, while the ilog rename was end of August 2022. There hadn't been a release though of rav1e until end of November 2022, which was also a semver incompatible one. Users had only 2-ish months of time to get to the new rav1e version without experiencing breakage.

The rav1e encoder for AV1 has more assembly in it than Rust, which also doesn't bode well for memory-safe video codec implementations. But this might change once Rust provides portable and memory-safe explicit SIMD.

Obviously not super important, but would be super cool to see AV1 encode/decode support added. There's a great rust library for this too : https://github.com/xiph/rav1e

A good encoder will look deeper to improve, and deeper, a bit more deeper, DEEPER

You may look dav1d and rav1e for examples.

There should be some major rav1e improvements in the not-so-distant future that should benefit high fidelity encoding very nicely (https://github.com/xiph/rav1e/pull/2921). And I hope someday someone gets 10/12 bit tune butteraugli working in aomenc, should provide a massive efficiency boost in pretty much all scenarios.