image

> If we were to hypothesize a counterfactual world where webp was written in rust You don't have to hypothesize. It's here: https://github.com/image-rs/image/blob/master/src/codecs/web... and it doesn't use unsafe indexing.

FTR there is a WebP decoder implementation in safe Rust in the image crate: https://github.com/image-rs/image It used to be quite incomplete for a long time, but work last year has implemented many webp features. Chromium now has a policy of allowing the use of Rust dependencies, so maybe Chromium could start adopting it?

FTR that decoder does not support colors, so for most uses it is not ready yet: https://github.com/image-rs/image/pull/952

There is a Rust WebP decoder in image-rs [1], presumably independently written from the specification. [1] https://github.com/image-rs/image/tree/master/src/codecs/web...

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. At my startup we use this in a lambda to process user-uploaded images, with great success.

I wonder how these libraries compare to using something like image-rs [0] w/ a custom-exported C FFI extern? I have used that library's PNG decoder/encoder in WASM and it seems simple and small and fast. I think it'd be worthy to include in the next bench round since it's only a bit of glue code away from a "C library" too. 0 - https://github.com/image-rs/image

> Actix-web in used in production at Cloudflare for the image resizing feature. Oh, that's really interesting. I actually used it for exactly the same purpose, but I was a bit disappointed by the image[1] crate for the image-resizing itself: it was several times slower than imagemagick (it was less the case on my decktop, when compiled with `target-cpu=native`, but on my low-end server many SIMD instructions weren't available and auto-vectorized code wasn't that efficient) and the image quality was also way poorer. Did you use that crate for the image processing ? Or imagemagick ? Or something you wrote internally ? [1]: https://github.com/image-rs/image

Most of the time I find that the lib's github's README.md contains the introduction and overview that I want to understand how the library works. Unfortunately it's not in the docs themselves, but I hear that the Rust team is working on improving that. See for instance the "image" crate docs: https://docs.rs/image/0.13.0/image/ A simple API doc, I don't know where to start. But then if I go to the repo I find a nice intro with some example code: https://github.com/PistonDevelopers/image/blob/master/README...

I'm not really sure what the problem is here: having to formally verify a module doesn't seem fundamentally different to formally verify a single function. I mean, sure, it's some more code, but there's still well-defined containment. And, being "allowed" to reason about a whole module (well, usually one just cares about a whole type, but these often match, especially for unsafe code) seems far more useful: one can build far more interesting abstractions. If one was forced to reason about a single function at a time, Vec couldn't exist in a useful way, as every function would have to assume the incoming Vec value could be arbitrarily invalid. In any case, there are many many modules with no `unsafe` code, e.g. std::option has none [1], iron::response has none [2], image::jpeg has none [3] (just some random examples). These are automatical

There's still a bunch of build system issues to be solved before any Rust code can be included in Firefox. You can follow along at https://bugzilla.mozilla.org/show_bug.cgi?id=1135640. Note especially the two bugs listed in the "Blocks" field, which are the first two candidates for components to be rewritten once the build system issues are sorted out. (The second of these would replace the notoriously insecure libstagefright with a Rust alternative.) Piston has a BMP decoder, and my understanding is that it is the one used by Servo. I looked at it briefly and I think its support for the dark corners of the BMP format would be even worse than Firefox's would be before my rewrite. See https://github.com/PistonDevelopers/image/tree/master/src/bm... for the code.

One of the Daala developers here. The official reference Daala codebase is implemented in C89 - this is to ensure the widest possible compatibility with all sorts of weird platforms. In addition, the tooling for assembly and intrinsics are mature. Of course, this is only the reference implementation - once the bitstream is stable, it'd be great to try writing a decoder in Rust. An easier starting point might be audio or image codecs, where speed is not as critical and the formats are well defined. For example, here is a pure Rust image codec library: https://github.com/PistonDevelopers/image

Things are moving fast. I'm not sure what you need specifically, but piston[1,2] is probably what to look at and maybe more specifically image[3] or conrod[4] [1]:http://www.piston.rs [2]:http://www.reddit.com/r/rust/comments/28srso/piston_game_eng... [3]:https://github.com/PistonDevelopers/image [4]:http://blog.piston.rs/2014/08/30/conrod-update/