Move image/svg handling into `iced_graphics`

The `TextureStore` trait is implemented by the atlas, and can also be
implemented in the glow renderer or in a software renderer.

The API here may be improved in the future, but API stability is
presumably not a huge issue since these types will only be used by
renderer backends.

2 files changed, 419 insertions, 0 deletions

diff --git a/graphics/src/image/raster.rs b/graphics/src/image/raster.rs
new file mode 100644
index 00000000..f9672dd5
--- /dev/null
+++ b/graphics/src/image/raster.rs
@@ -0,0 +1,236 @@
+//! Raster image loading and caching
+
+use iced_native::image;
+use std::collections::{HashMap, HashSet};
+
+use bitflags::bitflags;
+
+use super::{TextureStore, TextureStoreEntry};
+
+/// Entry in cache corresponding to an image handle
+#[derive(Debug)]
+pub enum Memory<T: TextureStore> {
+    /// Image data on host
+    Host(::image_rs::ImageBuffer<::image_rs::Rgba<u8>, Vec<u8>>),
+    /// Texture store entry
+    Device(T::Entry),
+    /// Image not found
+    NotFound,
+    /// Invalid image data
+    Invalid,
+}
+
+impl<T: TextureStore> Memory<T> {
+    /// Width and height of image
+    pub fn dimensions(&self) -> (u32, u32) {
+        match self {
+            Memory::Host(image) => image.dimensions(),
+            Memory::Device(entry) => entry.size(),
+            Memory::NotFound => (1, 1),
+            Memory::Invalid => (1, 1),
+        }
+    }
+}
+
+/// Caches image raster data
+#[derive(Debug)]
+pub struct Cache<T: TextureStore> {
+    map: HashMap<u64, Memory<T>>,
+    hits: HashSet<u64>,
+}
+
+impl<T: TextureStore> Cache<T> {
+    /// Load image
+    pub fn load(&mut self, handle: &image::Handle) -> &mut Memory<T> {
+        if self.contains(handle) {
+            return self.get(handle).unwrap();
+        }
+
+        let memory = match handle.data() {
+            image::Data::Path(path) => {
+                if let Ok(image) = image_rs::open(path) {
+                    let operation = std::fs::File::open(path)
+                        .ok()
+                        .map(std::io::BufReader::new)
+                        .and_then(|mut reader| {
+                            Operation::from_exif(&mut reader).ok()
+                        })
+                        .unwrap_or_else(Operation::empty);
+
+                    Memory::Host(operation.perform(image.to_rgba8()))
+                } else {
+                    Memory::NotFound
+                }
+            }
+            image::Data::Bytes(bytes) => {
+                if let Ok(image) = image_rs::load_from_memory(bytes) {
+                    let operation =
+                        Operation::from_exif(&mut std::io::Cursor::new(bytes))
+                            .ok()
+                            .unwrap_or_else(Operation::empty);
+
+                    Memory::Host(operation.perform(image.to_rgba8()))
+                } else {
+                    Memory::Invalid
+                }
+            }
+            image::Data::Pixels {
+                width,
+                height,
+                pixels,
+            } => {
+                if let Some(image) = image_rs::ImageBuffer::from_vec(
+                    *width,
+                    *height,
+                    pixels.to_vec(),
+                ) {
+                    Memory::Host(image)
+                } else {
+                    Memory::Invalid
+                }
+            }
+        };
+
+        self.insert(handle, memory);
+        self.get(handle).unwrap()
+    }
+
+    /// Load image and upload raster data
+    pub fn upload(
+        &mut self,
+        handle: &image::Handle,
+        state: &mut T::State<'_>,
+        store: &mut T,
+    ) -> Option<&T::Entry> {
+        let memory = self.load(handle);
+
+        if let Memory::Host(image) = memory {
+            let (width, height) = image.dimensions();
+
+            let entry = store.upload(width, height, image, state)?;
+
+            *memory = Memory::Device(entry);
+        }
+
+        if let Memory::Device(allocation) = memory {
+            Some(allocation)
+        } else {
+            None
+        }
+    }
+
+    /// Trim cache misses from cache
+    pub fn trim(&mut self, store: &mut T, state: &mut T::State<'_>) {
+        let hits = &self.hits;
+
+        self.map.retain(|k, memory| {
+            let retain = hits.contains(k);
+
+            if !retain {
+                if let Memory::Device(entry) = memory {
+                    store.remove(entry, state);
+                }
+            }
+
+            retain
+        });
+
+        self.hits.clear();
+    }
+
+    fn get(&mut self, handle: &image::Handle) -> Option<&mut Memory<T>> {
+        let _ = self.hits.insert(handle.id());
+
+        self.map.get_mut(&handle.id())
+    }
+
+    fn insert(&mut self, handle: &image::Handle, memory: Memory<T>) {
+        let _ = self.map.insert(handle.id(), memory);
+    }
+
+    fn contains(&self, handle: &image::Handle) -> bool {
+        self.map.contains_key(&handle.id())
+    }
+}
+
+impl<T: TextureStore> Default for Cache<T> {
+    fn default() -> Self {
+        Self {
+            map: HashMap::new(),
+            hits: HashSet::new(),
+        }
+    }
+}
+
+bitflags! {
+    struct Operation: u8 {
+        const FLIP_HORIZONTALLY = 0b001;
+        const ROTATE_180 = 0b010;
+        const FLIP_DIAGONALLY = 0b100;
+    }
+}
+
+impl Operation {
+    // Meaning of the returned value is described e.g. at:
+    // https://magnushoff.com/articles/jpeg-orientation/
+    fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
+    where
+        R: std::io::BufRead + std::io::Seek,
+    {
+        let exif = exif::Reader::new().read_from_container(reader)?;
+
+        Ok(exif
+            .get_field(exif::Tag::Orientation, exif::In::PRIMARY)
+            .and_then(|field| field.value.get_uint(0))
+            .and_then(|value| u8::try_from(value).ok())
+            .and_then(|value| Self::from_bits(value.saturating_sub(1)))
+            .unwrap_or_else(Self::empty))
+    }
+
+    fn perform<P>(
+        self,
+        image: image_rs::ImageBuffer<P, Vec<P::Subpixel>>,
+    ) -> image_rs::ImageBuffer<P, Vec<P::Subpixel>>
+    where
+        P: image_rs::Pixel + 'static,
+    {
+        use image_rs::imageops;
+
+        let mut image = if self.contains(Self::FLIP_DIAGONALLY) {
+            flip_diagonally(image)
+        } else {
+            image
+        };
+
+        if self.contains(Self::ROTATE_180) {
+            imageops::rotate180_in_place(&mut image);
+        }
+
+        if self.contains(Self::FLIP_HORIZONTALLY) {
+            imageops::flip_horizontal_in_place(&mut image);
+        }
+
+        image
+    }
+}
+
+fn flip_diagonally<I>(
+    image: I,
+) -> image_rs::ImageBuffer<I::Pixel, Vec<<I::Pixel as image_rs::Pixel>::Subpixel>>
+where
+    I: image_rs::GenericImage,
+    I::Pixel: 'static,
+{
+    let (width, height) = image.dimensions();
+    let mut out = image_rs::ImageBuffer::new(height, width);
+
+    for x in 0..width {
+        for y in 0..height {
+            let p = image.get_pixel(x, y);
+
+            out.put_pixel(y, x, p);
+        }
+    }
+
+    out
+}
diff --git a/graphics/src/image/vector.rs b/graphics/src/image/vector.rs
new file mode 100644
index 00000000..0062e2ce
--- /dev/null
+++ b/graphics/src/image/vector.rs
@@ -0,0 +1,183 @@
+//! Vector image loading and caching
+
+use iced_native::svg;
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+
+use super::TextureStore;
+
+/// Entry in cache corresponding to an svg handle
+pub enum Svg {
+    /// Parsed svg
+    Loaded(usvg::Tree),
+    /// Svg not found or failed to parse
+    NotFound,
+}
+
+impl Svg {
+    /// Viewport width and height
+    pub fn viewport_dimensions(&self) -> (u32, u32) {
+        match self {
+            Svg::Loaded(tree) => {
+                let size = tree.svg_node().size;
+
+                (size.width() as u32, size.height() as u32)
+            }
+            Svg::NotFound => (1, 1),
+        }
+    }
+}
+
+/// Caches svg vector and raster data
+#[derive(Debug)]
+pub struct Cache<T: TextureStore> {
+    svgs: HashMap<u64, Svg>,
+    rasterized: HashMap<(u64, u32, u32), T::Entry>,
+    svg_hits: HashSet<u64>,
+    rasterized_hits: HashSet<(u64, u32, u32)>,
+}
+
+impl<T: TextureStore> Cache<T> {
+    /// Load svg
+    pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
+        if self.svgs.contains_key(&handle.id()) {
+            return self.svgs.get(&handle.id()).unwrap();
+        }
+
+        let svg = match handle.data() {
+            svg::Data::Path(path) => {
+                let tree = fs::read_to_string(path).ok().and_then(|contents| {
+                    usvg::Tree::from_str(
+                        &contents,
+                        &usvg::Options::default().to_ref(),
+                    )
+                    .ok()
+                });
+
+                tree.map(Svg::Loaded).unwrap_or(Svg::NotFound)
+            }
+            svg::Data::Bytes(bytes) => {
+                match usvg::Tree::from_data(
+                    bytes,
+                    &usvg::Options::default().to_ref(),
+                ) {
+                    Ok(tree) => Svg::Loaded(tree),
+                    Err(_) => Svg::NotFound,
+                }
+            }
+        };
+
+        let _ = self.svgs.insert(handle.id(), svg);
+        self.svgs.get(&handle.id()).unwrap()
+    }
+
+    /// Load svg and upload raster data
+    pub fn upload(
+        &mut self,
+        handle: &svg::Handle,
+        [width, height]: [f32; 2],
+        scale: f32,
+        state: &mut T::State<'_>,
+        texture_store: &mut T,
+    ) -> Option<&T::Entry> {
+        let id = handle.id();
+
+        let (width, height) = (
+            (scale * width).ceil() as u32,
+            (scale * height).ceil() as u32,
+        );
+
+        // TODO: Optimize!
+        // We currently rerasterize the SVG when its size changes. This is slow
+        // as heck. A GPU rasterizer like `pathfinder` may perform better.
+        // It would be cool to be able to smooth resize the `svg` example.
+        if self.rasterized.contains_key(&(id, width, height)) {
+            let _ = self.svg_hits.insert(id);
+            let _ = self.rasterized_hits.insert((id, width, height));
+
+            return self.rasterized.get(&(id, width, height));
+        }
+
+        match self.load(handle) {
+            Svg::Loaded(tree) => {
+                if width == 0 || height == 0 {
+                    return None;
+                }
+
+                // TODO: Optimize!
+                // We currently rerasterize the SVG when its size changes. This is slow
+                // as heck. A GPU rasterizer like `pathfinder` may perform better.
+                // It would be cool to be able to smooth resize the `svg` example.
+                let mut img = tiny_skia::Pixmap::new(width, height)?;
+
+                resvg::render(
+                    tree,
+                    if width > height {
+                        usvg::FitTo::Width(width)
+                    } else {
+                        usvg::FitTo::Height(height)
+                    },
+                    img.as_mut(),
+                )?;
+
+                let mut rgba = img.take();
+                rgba.chunks_exact_mut(4).for_each(|rgba| rgba.swap(0, 2));
+
+                let allocation = texture_store.upload(
+                    width,
+                    height,
+                    bytemuck::cast_slice(rgba.as_slice()),
+                    state,
+                )?;
+                log::debug!("allocating {} {}x{}", id, width, height);
+
+                let _ = self.svg_hits.insert(id);
+                let _ = self.rasterized_hits.insert((id, width, height));
+                let _ = self.rasterized.insert((id, width, height), allocation);
+
+                self.rasterized.get(&(id, width, height))
+            }
+            Svg::NotFound => None,
+        }
+    }
+
+    /// Load svg and upload raster data
+    pub fn trim(&mut self, texture_store: &mut T, state: &mut T::State<'_>) {
+        let svg_hits = &self.svg_hits;
+        let rasterized_hits = &self.rasterized_hits;
+
+        self.svgs.retain(|k, _| svg_hits.contains(k));
+        self.rasterized.retain(|k, entry| {
+            let retain = rasterized_hits.contains(k);
+
+            if !retain {
+                texture_store.remove(entry, state);
+            }
+
+            retain
+        });
+        self.svg_hits.clear();
+        self.rasterized_hits.clear();
+    }
+}
+
+impl<T: TextureStore> Default for Cache<T> {
+    fn default() -> Self {
+        Self {
+            svgs: HashMap::new(),
+            rasterized: HashMap::new(),
+            svg_hits: HashSet::new(),
+            rasterized_hits: HashSet::new(),
+        }
+    }
+}
+
+impl std::fmt::Debug for Svg {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Svg::Loaded(_) => write!(f, "Svg::Loaded"),
+            Svg::NotFound => write!(f, "Svg::NotFound"),
+        }
+    }
+}