Changes to use DynamicImage type from the new rust image library

components/gfx/display_list/mod.rs

@@ -27,7 +27,7 @@ use libc::uintptr_t;
 use render_task::RenderLayer;
 use script_traits::UntrustedNodeAddress;
 use servo_msg::compositor_msg::LayerId;
-use servo_net::image::base::Image;
+use servo_net::image::base::DynamicImage;
 use servo_util::dlist as servo_dlist;
 use servo_util::geometry::{mod, Au};
 use servo_util::range::Range;
@@ -447,7 +447,7 @@ pub enum TextOrientation {
 #[deriving(Clone)]
 pub struct ImageDisplayItem {
     pub base: BaseDisplayItem,
-    pub image: Arc<Box<Image>>,
+    pub image: Arc<Box<DynamicImage>>,
 
     /// The dimensions to which the image display item should be stretched. If this is smaller than
     /// the bounds of this display item, then the image will be repeated in the appropriate

components/gfx/render_context.rs

@@ -20,7 +20,7 @@ use geom::size::Size2D;
 use libc::size_t;
 use libc::types::common::c99::{uint16_t, uint32_t};
 use png::{RGB8, RGBA8, K8, KA8};
-use servo_net::image::base::Image;
+use servo_net::image::base::DynamicImage;
 use servo_util::geometry::Au;
 use servo_util::opts;
 use servo_util::range::Range;
@@ -109,7 +109,7 @@ impl<'a> RenderContext<'a>  {
         self.draw_target.pop_clip();
     }
 
-    pub fn draw_image(&self, bounds: Rect<Au>, image: Arc<Box<Image>>) {
+    pub fn draw_image(&self, bounds: Rect<Au>, image: Arc<Box<DynamicImage>>) {
         let size = Size2D(image.width as i32, image.height as i32);
         let (pixel_width, pixels, source_format) = match image.pixels {
             RGBA8(ref pixels) => (4, pixels.as_slice(), B8G8R8A8),

components/net/Cargo.toml

@@ -25,3 +25,6 @@ git = "https://github.com/servo/rust-stb-image"
 
 [dependencies.url]
 git = "https://github.com/servo/rust-url"
+
+[dependencies.image]
+git = "https://github.com/PistonDevelopers/image"

components/net/image/base.rs

@@ -3,12 +3,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use std::iter::range_step;
-use stb_image::image as stb_image;
-use png;
+//use stb_image::image as stb_image;
+use servo_image;
+//use png;
 
 // FIXME: Images must not be copied every frame. Instead we should atomically
 // reference count them.
-pub type Image = png::Image;
+pub type DynamicImage = servo_image::DynamicImage;
 
 
 static TEST_IMAGE: &'static [u8] = include_bin!("test.jpeg");
@@ -41,48 +42,19 @@ fn byte_swap_and_premultiply(data: &mut [u8]) {
     }
 }
 
-pub fn load_from_memory(buffer: &[u8]) -> Option<Image> {
+pub fn load_from_memory(buffer: &[u8]) -> Option<DynamicImage> {
     if buffer.len() == 0 {
         return None;
     }
+   else {
+	let result = servo_image::load_from_memory(buffer,servo_image::ImageFormat::JPEG);
+	if (result.is_ok()) {
+  	let v = result.unwrap();
+  	return Some(v);
+	}
+	else  {	
+	return None;
+
+    }}
 
-    if png::is_png(buffer) {
-        match png::load_png_from_memory(buffer) {
-            Ok(mut png_image) => {
-                match png_image.pixels {
-                    png::RGB8(ref mut data) => byte_swap(data.as_mut_slice()),
-                    png::RGBA8(ref mut data) => {
-                        byte_swap_and_premultiply(data.as_mut_slice())
-                    }
-                    _ => {}
-                }
-                Some(png_image)
-            }
-            Err(_err) => None,
-        }
-    } else {
-        // For non-png images, we use stb_image
-        // Can't remember why we do this. Maybe it's what cairo wants
-        static FORCE_DEPTH: uint = 4;
-
-        match stb_image::load_from_memory_with_depth(buffer, FORCE_DEPTH, true) {
-            stb_image::ImageU8(mut image) => {
-                assert!(image.depth == 4);
-                byte_swap(image.data.as_mut_slice());
-                Some(png::Image {
-                    width: image.width as u32,
-                    height: image.height as u32,
-                    pixels: png::RGBA8(image.data)
-                })
-            }
-            stb_image::ImageF32(_image) => {
-                error!("HDR images not implemented");
-                None
-            }
-            stb_image::Error(e) => {
-                error!("stb_image failed: {}", e);
-                None
-            }
-        }
-    }
 }

components/net/image/holder.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use image::base::Image;
+use image::base::DynamicImage;
 use image_cache_task::{ImageReady, ImageNotReady, ImageFailed};
 use local_image_cache::LocalImageCache;
 
@@ -11,6 +11,7 @@ use std::mem;
 use sync::{Arc, Mutex};
 use url::Url;
 
+
 // FIXME: Nasty coupling here This will be a problem if we want to factor out image handling from
 // the network stack. This should probably be factored out into an interface and use dependency
 // injection.
@@ -20,7 +21,7 @@ use url::Url;
 #[deriving(Clone)]
 pub struct ImageHolder<NodeAddress> {
     url: Url,
-    image: Option<Arc<Box<Image>>>,
+    image: Option<Arc<Box<DynamicImage>>>,
     cached_size: Size2D<int>,
     local_image_cache: Arc<Mutex<LocalImageCache<NodeAddress>>>,
 }
@@ -63,19 +64,21 @@ impl<NodeAddress: Send> ImageHolder<NodeAddress> {
     /// Query and update the current image size.
     pub fn get_size(&mut self, node_address: NodeAddress) -> Option<Size2D<int>> {
         debug!("get_size() {}", self.url.serialize());
+
         self.get_image(node_address).map(|img| {
-            self.cached_size = Size2D(img.width as int,
-                                      img.height as int);
+	let (img_width,img_height) = img.dimensions();
+            self.cached_size = Size2D(img_width as int,
+                                      img_height as int);
             self.cached_size.clone()
         })
     }
 
-    pub fn get_image_if_present(&self) -> Option<Arc<Box<Image>>> {
+    pub fn get_image_if_present(&self) -> Option<Arc<Box<DynamicImage>>> {
         debug!("get_image_if_present() {}", self.url.serialize());
         self.image.clone()
     }
 
-    pub fn get_image(&mut self, node_address: NodeAddress) -> Option<Arc<Box<Image>>> {
+    pub fn get_image(&mut self, node_address: NodeAddress) -> Option<Arc<Box<DynamicImage>>> {
         debug!("get_image() {}", self.url.serialize());
 
         // If this is the first time we've called this function, load

components/net/image_cache_task.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use image::base::{Image, load_from_memory};
+use image::base::{DynamicImage, load_from_memory};
 use resource_task;
 use resource_task::{LoadData, ResourceTask};
 
@@ -39,7 +39,7 @@ pub enum Msg {
     StorePrefetchedImageData(Url, Result<Vec<u8>, ()>),
 
     /// Used by the decoder tasks to post decoded images back to the cache
-    StoreImage(Url, Option<Arc<Box<Image>>>),
+    StoreImage(Url, Option<Arc<Box<DynamicImage>>>),
 
     /// For testing
     WaitForStore(Sender<()>),
@@ -50,7 +50,7 @@ pub enum Msg {
 
 #[deriving(Clone)]
 pub enum ImageResponseMsg {
-    ImageReady(Arc<Box<Image>>),
+    ImageReady(Arc<Box<DynamicImage>>),
     ImageNotReady,
     ImageFailed
 }
@@ -78,7 +78,7 @@ impl<E, S: Encoder<E>> Encodable<S, E> for ImageCacheTask {
     }
 }
 
-type DecoderFactory = fn() -> (proc(&[u8]) : 'static -> Option<Image>);
+type DecoderFactory = fn() -> (proc(&[u8]) : 'static -> Option<DynamicImage>);
 
 impl ImageCacheTask {
     pub fn new(resource_task: ResourceTask, task_pool: TaskPool) -> ImageCacheTask {
@@ -152,7 +152,7 @@ enum ImageState {
     Prefetching(AfterPrefetch),
     Prefetched(Vec<u8>),
     Decoding,
-    Decoded(Arc<Box<Image>>),
+    Decoded(Arc<Box<DynamicImage>>),
     Failed
 }
 
@@ -328,7 +328,7 @@ impl ImageCache {
         }
     }
 
-    fn store_image(&mut self, url: Url, image: Option<Arc<Box<Image>>>) {
+    fn store_image(&mut self, url: Url, image: Option<Arc<Box<DynamicImage>>>) {
 
         match self.get_state(&url) {
           Decoding => {

components/net/lib.rs

@@ -19,6 +19,7 @@ extern crate stb_image;
 extern crate sync;
 extern crate time;
 extern crate url;
+extern crate "image" as servo_image;
 
 /// Image handling.
 ///