Fix build errors in piston-image by updating to 0.10.3

Author: Mark-Simulacrum

piston-image-0.10.3/.gitattributes

@@ -0,0 +1,2 @@
+*.jpg binary -delta
+*.png binary -delta

piston-image-0.10.3/.gitignore

@@ -0,0 +1,22 @@
+.DS_Store
+*~
+*#
+*.o
+*.so
+*.swp
+*.dylib
+*.dSYM
+*.dll
+*.rlib
+*.dummy
+*.exe
+*-test
+/bin/main
+/bin/test-internal
+/bin/test-external
+/doc/
+/target/
+/build/
+/.rust/
+rusti.sh
+Cargo.lock

piston-image-0.10.3/.travis.yml

@@ -0,0 +1,42 @@
+language: rust
+sudo: false
+notifications:
+    irc: "irc.mozilla.org#piston-internals"
+os:
+    - linux
+    - osx
+rust:
+    - stable
+    - beta
+    - nightly
+env:
+    global:
+        - secure: M2MCRtyP5P/Xf2TSqrbz8cs41TQY04mK/5Fi6qgr77OKLNZlDclKiFY8BmQ6f1JhVccoE5gMIFpfPoVUu8wZ0Pe7/X4IyO4vxWawVQfE6f0NYErD9yqiE1KEi/RGKPOQfL5HFUK7ifnXvLwsAMh1ix9XMgaBZfZLQ8KhkxNRXwI=
+    matrix:
+      - FEATURES=''
+      - FEATURES='gif_codec'
+      - FEATURES='jpeg'
+      - FEATURES='png_codec'
+      - FEATURES='ppm'
+      - FEATURES='tga'
+      - FEATURES='tiff'
+      - FEATURES='webp'
+      - FEATURES='hdr'
+script:
+    - if [ -z "$FEATURES" ]; then
+        cargo build -v;
+        if [ "$TRAVIS_RUST_VERSION" = "nightly" ]; then cargo test -v; fi;
+        cargo doc -v;
+      else
+        cargo build -v --no-default-features --features "$FEATURES";
+        if [ "$TRAVIS_RUST_VERSION" = "nightly" ]; then cargo test -v --no-default-features --features "$FEATURES"; fi;
+        cargo doc -v;
+      fi
+after_success: |
+    [ $TRAVIS_BRANCH = master ] &&
+    [ $TRAVIS_PULL_REQUEST = false ] &&
+    cargo doc &&
+    echo '<meta http-equiv=refresh content=0;url=image/index.html>' > target/doc/index.html &&
+    pip install --user ghp-import &&
+    ghp-import -n target/doc &&
+    git push -fq https://${GH_TOKEN}:[email protected]/${TRAVIS_REPO_SLUG}.git gh-pages

piston-image-0.3.11/CHANGES.md renamed to piston-image-0.10.3/CHANGES.md

@@ -1,14 +1,18 @@
-# Rust Image 0.3 Release Notes
+# Rust Image 0.4 Release Notes
 
 Rust image aims to be a pure-Rust implementation of various popular image formats. Accompanying reading/write support, rust image provides basic imaging processing function. See `README.md` for further details.
 
 ## Known issues
  - Interlaced (progressive) or animated images are not well supported.
  - Images with *n* bit/channel (*n ≠ 8*) are not well supported.
- - No support for alpha channel in paletted PNG images.
 
 ## Changes
 
+### Version 0.4
+ - Various improvements.
+ - Additional supported image formats (BMP and ICO).
+ - GIF and PNG codec moved into separate crates.
+ 
 ### Version 0.3
  - Replace `std::old_io` with `std::io`.
 

piston-image-0.3.11/Cargo.toml renamed to piston-image-0.10.3/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "image"
-version = "0.3.11"
+version = "0.10.3"
 license = "MIT"
 description = "Imaging library written in Rust. Provides basic filters and decoders for the most common image formats."
 authors = [
@@ -22,27 +22,42 @@ name = "image"
 path = "./src/lib.rs"
 
 [dependencies]
-byteorder = "0.3.10"
-num = "0.1.25"
-enum_primitive = "0.0.1"
+byteorder = "0.5.1"
+num-iter = "0.1.32"
+num-rational = "0.1.32"
+num-traits = "0.1.32"
+enum_primitive = "0.1.0"
 glob = "0.2.10"
 
 [dependencies.gif]
-version = "0.5"
+version = "0.9"
+optional = true
+
+[dependencies.jpeg-decoder]
+version = "0.1"
 optional = true
 
 [dependencies.png]
-version = "0.3"
+version = "0.5"
 optional = true
 
+[dependencies.scoped_threadpool]
+version = "0.1"
+optional = true
+
+[dev-dependencies]
+num-complex = "0.1.32"
+
 [features]
-default = ["gif_codec", "jpeg", "png_codec", "ppm", "tga", "tiff", "webp", "bmp"]
+default = ["gif_codec", "jpeg", "ico", "png_codec", "ppm", "tga", "tiff", "webp", "bmp", "hdr"]
 
 gif_codec = ["gif"]
-jpeg = []
+ico = ["bmp", "png_codec"]
+jpeg = ["jpeg-decoder"]
 png_codec = ["png"]
 ppm = []
 tga = []
 tiff = []
 webp = []
 bmp = []
+hdr = ["scoped_threadpool"]

piston-image-0.3.11/LICENSE renamed to piston-image-0.10.3/LICENSE

@@ -14,17 +14,17 @@ All image processing functions provided operate on types that implement the ```G
 
 Add the following to the Cargo.toml in your project:
 
-```
+```toml
 [dependencies]
 image = "*"
 ```
 
 and import using ```extern crate```:
 
 ```rust
-    extern crate image;
+extern crate image;
 
-    //Use image::
+//Use image::
 ```
 
 ## 1. Documentation
@@ -38,8 +38,10 @@ http://www.piston.rs/image/image/index.html
 | Format | Decoding | Encoding |
 |---     |---       | --- |
 | PNG    | All supported color types | Same as decoding|
-| JPEG   | Baseline JPEG | Baseline JPEG |
+| JPEG   | Baseline and progressive | Baseline JPEG |
 | GIF    | Yes | Yes |
+| BMP    | Yes | No |
+| ICO    | Yes | Yes |
 | TIFF   | Baseline(no fax and packbits support) + LZW | No |
 | Webp   | Lossy(Luma channel only) | No |
 | PPM    | No | Yes |
@@ -188,38 +190,37 @@ The image format is determined from the path's file extension.
 ```rust
 extern crate image;
 
-use std::old_io::File;
+use std::fs::File;
+use std::path::Path;
 
 use image::GenericImage;
 
 fn main() {
-    //Use the open function to load an image from a PAth.
-    //```open``` returns a dynamic image.
+    // Use the open function to load an image from a Path.
+    // ```open``` returns a dynamic image.
     let img = image::open(&Path::new("test.jpg")).unwrap();
 
-    //The dimensions method returns the images width and height
+    // The dimensions method returns the images width and height
     println!("dimensions {:?}", img.dimensions());
 
-    //The color method returns the image's ColorType
+    // The color method returns the image's ColorType
     println!("{:?}", img.color());
 
     let ref mut fout = File::create(&Path::new("test.png")).unwrap();
 
-    //Write the contents of this image to the Writer in PNG format.
-    let _ = img.save(fout, image::PNG);
+    // Write the contents of this image to the Writer in PNG format.
+    let _ = img.save(fout, image::PNG).unwrap();
 }
 ```
 
 ### 6.2 Generating Fractals
 ```rust
 //!An example of generating julia fractals.
-#![feature(old_path, old_io)]
-
 extern crate num;
 extern crate image;
 
-use std::old_io::File;
-use std::old_path::Path;
+use std::fs::File;
+use std::path::Path;
 
 use num::complex::Complex;
 
@@ -264,7 +265,7 @@ fn main() {
     let ref mut fout = File::create(&Path::new("fractal.png")).unwrap();
 
     // We must indicate the image’s color type and what format to save as
-    image::ImageLuma8(imgbuf).save(fout, image::PNG);
+    let _ = image::ImageLuma8(imgbuf).save(fout, image::PNG);
 }
 ```
 
@@ -278,12 +279,14 @@ If the high level interface is not needed because the image was obtained by othe
 ```rust
 extern crate image;
 
+use std::path::Path;
+
 fn main() {
 
     let buffer: &[u8] = ...; // Generate the image data
 
     // Save the buffer as "image.png"
-    image::save_buffer(&Path::new("image.png"), buffer, 800, 600, image::RGB(8))
+    image::save_buffer(&Path::new("image.png"), buffer, 800, 600, image::RGB(8)).unwrap()
 }
 
 ```

piston-image-0.3.11/README.md renamed to piston-image-0.10.3/README.md

@@ -0,0 +1,80 @@
+#![feature(test)]
+
+extern crate image;
+extern crate test;
+
+use std::{fs, path};
+use std::io::Read;
+use image::ImageFormat;
+
+struct BenchDef<'a> {
+    dir: &'a [&'a str],
+    format: ImageFormat,
+}
+
+const IMAGE_DIR: [&'static str; 3] = [".", "tests", "images"];
+const BMP: BenchDef<'static> = BenchDef {dir: &["bmp", "images"], format: ImageFormat::BMP};
+
+fn bench_load(b: &mut test::Bencher, def: &BenchDef, filename: &str, ) {
+    let mut path: path::PathBuf = IMAGE_DIR.iter().collect();
+    for d in def.dir {
+        path.push(d);
+    }
+    path.push(filename);
+    let mut fin = fs::File::open(path).unwrap();
+    let mut buf = Vec::new();
+    fin.read_to_end(&mut buf).unwrap();
+    b.iter(|| {
+        image::load_from_memory_with_format(&buf, def.format).unwrap();
+    })
+}
+
+#[bench]
+fn bench_load_bmp_1bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "Core_1_Bit.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_4bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "Core_4_Bit.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_8bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "Core_8_Bit.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_16bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "rgb16.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_24bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "rgb24.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_32bit(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "rgb32.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_4rle(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "pal4rle.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_8rle(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "pal8rle.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_16bf(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "rgb16-565.bmp");
+}
+
+#[bench]
+fn bench_load_bmp_32bf(b: &mut test::Bencher) {
+    bench_load(b, &BMP, "rgb32bf.bmp");
+}

piston-image-0.10.3/benches/load.rs

@@ -0,0 +1,52 @@
+//!An example of generating julia fractals.
+extern crate num_complex;
+extern crate image;
+
+use std::fs::File;
+use std::path::Path;
+
+use num_complex::Complex;
+
+fn main() {
+    let max_iterations = 256u16;
+
+    let imgx = 800;
+    let imgy = 800;
+
+    let scalex = 4.0 / imgx as f32;
+    let scaley = 4.0 / imgy as f32;
+
+    // Create a new ImgBuf with width: imgx and height: imgy
+    let mut imgbuf = image::ImageBuffer::new(imgx, imgy);
+
+    // Iterate over the coordiantes and pixels of the image
+    for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {
+        let cy = y as f32 * scaley - 2.0;
+        let cx = x as f32 * scalex - 2.0;
+
+        let mut z = Complex::new(cx, cy);
+        let c = Complex::new(-0.4, 0.6);
+
+        let mut i = 0;
+
+        for t in 0..max_iterations {
+            if z.norm() > 2.0 {
+                break
+            }
+            z = z * z + c;
+            i = t;
+        }
+
+        // Create an 8bit pixel of type Luma and value i
+        // and assign in to the pixel at position (x, y)
+        *pixel = image::Luma([i as u8]);
+
+    }
+
+
+    // Save the image as “fractal.png”
+    let ref mut fout = File::create(&Path::new("fractal.png")).unwrap();
+
+    // We must indicate the image’s color type and what format to save as
+    let _    = image::ImageLuma8(imgbuf).save(fout, image::PNG);
+}