GIF support removed

CHANGELOG.md

@@ -1,10 +1,18 @@
+# Unreleased
+
+## Removed features
+
+* GIF support was officially removed, as it was not working in the new renderer released in 0.8
+
+
 # 0.8
 
 ## New features
 
 * New PDF renderer. Nelsie now produce smaller slides faster when raster images are used
 * Rendering slides & image preprocessing in parallel
 
+
 # 0.7
 
 ## Fixes

docs/guide/images.md

@@ -1,7 +1,7 @@
 # Images
 
 Images are put into the slides by calling `.image()` on a box. It creates a new box with an image.
-Nelsie supports the following formats: SVG, PNG, JPEG, GIF and OpenRaster.
+Nelsie supports the following formats: SVG, PNG, JPEG, and OpenRaster.
 
 ```nelsie
 @deck.slide()
@@ -53,7 +53,7 @@ def my_slide(slide):
 ## Image and steps
 
 Formats that supports layers (SVG and OpenRaster) may control revealing a part of image
-in steps by naming layers. JPEG, PNG, and GIF image does not have any impact on steps.
+in steps by naming layers. JPEG, and PNG image does not have any impact on steps.
 
 If a layer has a name that ends with `**EXPR` where `EXPR` is an expression allowed in box's `show` argument, except for last/next/last+/next+ keywords. Keywords are not allowed in an image step definitions.
 Example: A layer with name "My layer **2-4" will be shown only steps 2, 3, 4.
@@ -99,4 +99,4 @@ def image_demo(slide):
 
     # The first image will be shown at step 3
     slide.image("./imgs/stepped_logo.ora", shift_steps=2)
-```
+```

src/model/image.rs

@@ -46,7 +46,6 @@ pub(crate) struct OraImageData {
 #[derive(Debug)]
 pub(crate) enum LoadedImageData {
     Png(Arc<Vec<u8>>),
-    Gif(Arc<Vec<u8>>),
     Jpeg(Arc<Vec<u8>>),
     Svg(SvgImageData),
     Ora(OraImageData),
@@ -63,7 +62,7 @@ pub(crate) struct LoadedImage {
 impl LoadedImage {
     pub fn n_steps(&self) -> Step {
         match &self.data {
-            LoadedImageData::Png(_) | LoadedImageData::Gif(_) | LoadedImageData::Jpeg(_) => 1,
+            LoadedImageData::Png(_) | LoadedImageData::Jpeg(_) => 1,
             LoadedImageData::Svg(data) => data.n_steps,
             LoadedImageData::Ora(data) => data.n_steps,
         }
@@ -95,14 +94,11 @@ impl ImageManager {
 }
 
 fn load_raster_image(raw_data: Vec<u8>) -> Option<LoadedImage> {
-    let size = imagesize::blob_size(&raw_data).ok()?;
-    let image_type = imagesize::image_type(&raw_data);
-    let data_arc = Arc::new(raw_data);
-    let data = match image_type {
-        Ok(imagesize::ImageType::Png) => LoadedImageData::Png(data_arc),
-        Ok(imagesize::ImageType::Jpeg) => LoadedImageData::Jpeg(data_arc),
-        Ok(imagesize::ImageType::Gif) => LoadedImageData::Gif(data_arc),
-        _ => unreachable!(), // This is safe, otherwise it should already fail in blob_size
+    let size = blob_size(&raw_data).ok()?;
+    let data = match imagesize::image_type(&raw_data) {
+        Ok(imagesize::ImageType::Png) => LoadedImageData::Png(Arc::new(raw_data)),
+        Ok(imagesize::ImageType::Jpeg) => LoadedImageData::Jpeg(Arc::new(raw_data)),
+        _ => return None,
     };
     Some(LoadedImage {
         image_id: 0,

src/render/canvas.rs

@@ -6,7 +6,6 @@ use std::sync::Arc;
 pub(crate) enum CanvasItem {
     SvgChunk(String),
     PngImage(Rectangle, Arc<Vec<u8>>),
-    GifImage(Rectangle, Arc<Vec<u8>>),
     JpegImage(Rectangle, Arc<Vec<u8>>),
     SvgImage(Rectangle, String, f32, f32),
 }

src/render/canvas_pdf.rs

@@ -63,7 +63,6 @@ impl Canvas {
                         *cache.get(&ByAddress(data)).unwrap(),
                     ));
                 }
-                CanvasItem::GifImage(_, _) => {}
                 CanvasItem::JpegImage(rect, data) => {
                     close_xml(&mut xml_writer, &mut elements)?;
                     elements.push(PdfPageElement::GlobalRef(

src/render/canvas_svg.rs

@@ -23,9 +23,6 @@ impl Canvas {
                 CanvasItem::PngImage(rect, data) => {
                     write_raster_image_to_svg(&rect, "png", &data, &mut writer)
                 }
-                CanvasItem::GifImage(rect, data) => {
-                    write_raster_image_to_svg(&rect, "gif", &data, &mut writer)
-                }
                 CanvasItem::JpegImage(rect, data) => {
                     write_raster_image_to_svg(&rect, "jpeg", &data, &mut writer)
                 }

src/render/image.rs

@@ -113,7 +113,6 @@ pub(crate) fn render_image_to_canvas(
     match &image.loaded_image.data {
         LoadedImageData::Png(data) => canvas.add(CanvasItem::PngImage(rect, data.clone())),
         LoadedImageData::Jpeg(data) => canvas.add(CanvasItem::JpegImage(rect, data.clone())),
-        LoadedImageData::Gif(data) => canvas.add(CanvasItem::GifImage(rect, data.clone())),
         LoadedImageData::Svg(svg) => canvas.add(CanvasItem::SvgImage(
             rect,
             prepare_svg_tree_for_step(step, image, svg),

src/render/pagebuilder.rs

@@ -292,7 +292,7 @@ pub fn collect_image_cache(
             LoadedImageData::Png(_) | LoadedImageData::Jpeg(_) | LoadedImageData::Ora(_) => {
                 Some(img.0)
             }
-            LoadedImageData::Gif(_) | LoadedImageData::Svg(_) => None,
+            LoadedImageData::Svg(_) => None,
         })
         .collect_vec();
     image_vec.sort_unstable_by_key(|i| i.image_id);
@@ -303,9 +303,6 @@ pub fn collect_image_cache(
                 cache.insert(ByAddress(data.clone()), pdf_builder.ref_bump());
                 pdf_builder.ref_bump(); // Reserve ID for transparency layer
             }
-            LoadedImageData::Gif(_) => {
-                unreachable!()
-            }
             LoadedImageData::Jpeg(data) => {
                 cache.insert(ByAddress(data.clone()), pdf_builder.ref_bump());
             }
@@ -336,9 +333,6 @@ pub fn precompute_image_cache(cache: &PdfImageCache, images: &[Arc<LoadedImage>]
                     Some(pdf_writer::Ref::new(id.get() + 1)),
                 )]
             }
-            LoadedImageData::Gif(_) => {
-                todo!()
-            }
             LoadedImageData::Jpeg(data) => {
                 let id = cache.get(&ByAddress(data.clone())).unwrap();
                 vec![image_to_pdf_chunk(