Allow APNG with reductions disabled (#511)

src/headers.rs

@@ -86,7 +86,9 @@ pub enum StripChunks {
 
 impl StripChunks {
     /// List of chunks that will be kept when using the `Safe` option
-    pub const KEEP_SAFE: [[u8; 4]; 4] = [*b"cICP", *b"iCCP", *b"sRGB", *b"pHYs"];
+    pub const KEEP_SAFE: [[u8; 4]; 7] = [
+        *b"cICP", *b"iCCP", *b"sRGB", *b"pHYs", *b"acTL", *b"fcTL", *b"fdAT",
+    ];
 
     pub(crate) fn keep(&self, name: &[u8; 4]) -> bool {
         match &self {

src/lib.rs

@@ -32,6 +32,7 @@ use crate::png::PngImage;
 use crate::reduction::*;
 use log::{debug, info, trace, warn};
 use rayon::prelude::*;
+use std::borrow::Cow;
 use std::fmt;
 use std::fs::{copy, File, Metadata};
 use std::io::{stdin, stdout, BufWriter, Read, Write};
@@ -388,7 +389,7 @@ impl RawImage {
     /// Create an optimized png from the raw image data using the options provided
     pub fn create_optimized_png(&self, opts: &Options) -> PngResult<Vec<u8>> {
         let deadline = Arc::new(Deadline::new(opts.timeout));
-        let mut png = optimize_raw(self.png.clone(), opts, deadline, None)
+        let mut png = optimize_raw(self.png.clone(), opts, deadline.clone(), None)
             .ok_or_else(|| PngError::new("Failed to optimize input data"))?;
 
         // Process aux chunks
@@ -398,7 +399,7 @@ impl RawImage {
             .filter(|c| opts.strip.keep(&c.name))
             .cloned()
             .collect();
-        postprocess_chunks(&mut png, opts, &self.png.ihdr);
+        postprocess_chunks(&mut png, opts, deadline, &self.png.ihdr);
 
         Ok(png.output())
     }
@@ -564,17 +565,30 @@ fn optimize_png(
     debug!("    IDAT size = {} bytes", idat_original_size);
     debug!("    File size = {} bytes", file_original_size);
 
+    // Check for APNG by presence of acTL chunk
+    let opts = if png.aux_chunks.iter().any(|c| &c.name == b"acTL") {
+        warn!("APNG detected, disabling all reductions");
+        let mut opts = opts.to_owned();
+        opts.interlace = None;
+        opts.bit_depth_reduction = false;
+        opts.color_type_reduction = false;
+        opts.palette_reduction = false;
+        opts.grayscale_reduction = false;
+        Cow::Owned(opts)
+    } else {
+        Cow::Borrowed(opts)
+    };
     let max_size = if opts.force {
         None
     } else {
         Some(png.estimated_output_size())
     };
-    if let Some(new_png) = optimize_raw(raw.clone(), opts, deadline, max_size) {
+    if let Some(new_png) = optimize_raw(raw.clone(), &opts, deadline.clone(), max_size) {
         png.raw = new_png.raw;
         png.idat_data = new_png.idat_data;
     }
 
-    postprocess_chunks(png, opts, &raw.ihdr);
+    postprocess_chunks(png, &opts, deadline, &raw.ihdr);
 
     let output = png.output();
 
@@ -844,7 +858,12 @@ fn report_format(prefix: &str, png: &PngImage) {
 }
 
 /// Perform cleanup of certain chunks from the `PngData` object, after optimization has been completed
-fn postprocess_chunks(png: &mut PngData, opts: &Options, orig_ihdr: &IhdrData) {
+fn postprocess_chunks(
+    png: &mut PngData,
+    opts: &Options,
+    deadline: Arc<Deadline>,
+    orig_ihdr: &IhdrData,
+) {
     if let Some(iccp_idx) = png.aux_chunks.iter().position(|c| &c.name == b"iCCP") {
         // See if we can replace an iCCP chunk with an sRGB chunk
         let may_replace_iccp = opts.strip != StripChunks::None && opts.strip.keep(b"sRGB");
@@ -897,6 +916,38 @@ fn postprocess_chunks(png: &mut PngData, opts: &Options, orig_ihdr: &IhdrData) {
             !invalid
         });
     }
+
+    // Find fdAT chunks and attempt to recompress them
+    // Note if there are multiple fdATs per frame then decompression will fail and nothing will change
+    let mut fdat: Vec<_> = png
+        .aux_chunks
+        .iter_mut()
+        .filter(|c| &c.name == b"fdAT")
+        .collect();
+    if !fdat.is_empty() {
+        let buffer_size = orig_ihdr.raw_data_size();
+        fdat.par_iter_mut()
+            .with_max_len(1)
+            .enumerate()
+            .for_each(|(i, c)| {
+                if deadline.passed() || c.data.len() <= 4 {
+                    return;
+                }
+                if let Ok(mut data) = deflate::inflate(&c.data[4..], buffer_size).and_then(|data| {
+                    let max_size = AtomicMin::new(Some(c.data.len() - 5));
+                    opts.deflate.deflate(&data, &max_size)
+                }) {
+                    debug!(
+                        "Recompressed fdAT #{:<2}: {} ({} bytes decrease)",
+                        i,
+                        c.data.len(),
+                        c.data.len() - 4 - data.len()
+                    );
+                    c.data.truncate(4);
+                    c.data.append(&mut data);
+                }
+            })
+    }
 }
 
 /// Check if an image was already optimized prior to oxipng's operations

src/main.rs

@@ -120,7 +120,7 @@ fn main() {
         )
         .arg(
             Arg::new("strip")
-                .help("Strip metadata objects ['safe', 'all', or comma-separated list]")
+                .help("Strip metadata objects ['safe', 'all', or comma-separated list]\nCAUTION: stripping 'all' will convert APNGs to standard PNGs")
                 .long("strip")
                 .value_name("mode")
                 .conflicts_with("strip-safe"),

src/png/mod.rs

@@ -7,6 +7,7 @@ use crate::interlace::{deinterlace_image, interlace_image, Interlacing};
 use crate::Options;
 use bitvec::bitarr;
 use libdeflater::{CompressionLvl, Compressor};
+use log::warn;
 use rgb::ComponentSlice;
 use rustc_hash::FxHashMap;
 use std::fs::File;
@@ -93,8 +94,16 @@ impl PngData {
         let mut aux_chunks: Vec<Chunk> = Vec::new();
         while let Some(chunk) = parse_next_chunk(byte_data, &mut byte_offset, opts.fix_errors)? {
             match &chunk.name {
-                b"IDAT" => idat_data.extend_from_slice(chunk.data),
-                b"acTL" => return Err(PngError::APNGNotSupported),
+                b"IDAT" => {
+                    if idat_data.is_empty() {
+                        // Keep track of where the first IDAT sits relative to other chunks
+                        aux_chunks.push(Chunk {
+                            name: chunk.name,
+                            data: Vec::new(),
+                        })
+                    }
+                    idat_data.extend_from_slice(chunk.data);
+                }
                 b"IHDR" | b"PLTE" | b"tRNS" => {
                     key_chunks.insert(chunk.name, chunk.data.to_owned());
                 }
@@ -104,6 +113,10 @@ impl PngData {
                             name: chunk.name,
                             data: chunk.data.to_owned(),
                         })
+                    } else if chunk.name == *b"acTL" {
+                        warn!(
+                            "Stripping animation data from APNG - image will become standard PNG"
+                        );
                     }
                 }
             }
@@ -165,9 +178,10 @@ impl PngData {
         ihdr_data.write_all(&[0]).ok(); // Filter method -- 5-way adaptive filtering
         ihdr_data.write_all(&[self.raw.ihdr.interlaced as u8]).ok();
         write_png_block(b"IHDR", &ihdr_data, &mut output);
-        // Ancillary chunks
-        for chunk in self
-            .aux_chunks
+        // Ancillary chunks - split into those that come before IDAT and those that come after
+        let mut aux_split = self.aux_chunks.split(|c| &c.name == b"IDAT");
+        let aux_pre = aux_split.next().unwrap();
+        for chunk in aux_pre
             .iter()
             .filter(|c| !(&c.name == b"bKGD" || &c.name == b"hIST" || &c.name == b"tRNS"))
         {
@@ -202,15 +216,20 @@ impl PngData {
             _ => {}
         }
         // Special ancillary chunks that need to come after PLTE but before IDAT
-        for chunk in self
-            .aux_chunks
+        for chunk in aux_pre
             .iter()
             .filter(|c| &c.name == b"bKGD" || &c.name == b"hIST" || &c.name == b"tRNS")
         {
             write_png_block(&chunk.name, &chunk.data, &mut output);
         }
         // IDAT data
         write_png_block(b"IDAT", &self.idat_data, &mut output);
+        // Ancillary chunks that come after IDAT
+        for aux_post in aux_split {
+            for chunk in aux_post {
+                write_png_block(&chunk.name, &chunk.data, &mut output);
+            }
+        }
         // Stream end
         write_png_block(b"IEND", &[], &mut output);
 

src/rayon.rs

@@ -26,6 +26,12 @@ pub trait IntoParallelRefIterator<'data> {
     fn par_iter(&'data self) -> Self::Iter;
 }
 
+pub trait IntoParallelRefMutIterator<'data> {
+    type Iter: ParallelIterator<Item = Self::Item>;
+    type Item: Send + 'data;
+    fn par_iter_mut(&'data mut self) -> Self::Iter;
+}
+
 impl<I: IntoIterator> IntoParallelIterator for I
 where
     I::Item: Send,
@@ -50,6 +56,18 @@ where
     }
 }
 
+impl<'data, I: 'data + ?Sized> IntoParallelRefMutIterator<'data> for I
+where
+    &'data mut I: IntoParallelIterator,
+{
+    type Iter = <&'data mut I as IntoParallelIterator>::Iter;
+    type Item = <&'data mut I as IntoParallelIterator>::Item;
+
+    fn par_iter_mut(&'data mut self) -> Self::Iter {
+        self.into_par_iter()
+    }
+}
+
 impl<I: Iterator> ParallelIterator for I {}
 
 #[allow(dead_code)]

src/sanity_checks.rs

@@ -1,15 +1,14 @@
-use image::{DynamicImage, GenericImageView, ImageFormat, Pixel};
+use image::{codecs::png::PngDecoder, *};
 use log::{error, warn};
-use std::io::Cursor;
 
 /// Validate that the output png data still matches the original image
 pub fn validate_output(output: &[u8], original_data: &[u8]) -> bool {
-    let (old_png, new_png) = rayon::join(
+    let (old_frames, new_frames) = rayon::join(
         || load_png_image_from_memory(original_data),
         || load_png_image_from_memory(output),
     );
 
-    match (new_png, old_png) {
+    match (new_frames, old_frames) {
         (Err(new_err), _) => {
             error!("Failed to read output image for validation: {}", new_err);
             false
@@ -21,26 +20,40 @@ pub fn validate_output(output: &[u8], original_data: &[u8]) -> bool {
             warn!("Failed to read input image for validation: {}", old_err);
             true
         }
-        (Ok(new_png), Ok(old_png)) => images_equal(&old_png, &new_png),
+        (Ok(new_frames), Ok(old_frames)) if new_frames.len() != old_frames.len() => false,
+        (Ok(new_frames), Ok(old_frames)) => {
+            for (a, b) in old_frames.iter().zip(new_frames) {
+                if !images_equal(&a, &b) {
+                    return false;
+                }
+            }
+            true
+        }
     }
 }
 
-/// Loads a PNG image from memory to a [DynamicImage]
-fn load_png_image_from_memory(png_data: &[u8]) -> Result<DynamicImage, image::ImageError> {
-    let mut reader = image::io::Reader::new(Cursor::new(png_data));
-    reader.set_format(ImageFormat::Png);
-    reader.no_limits();
-    reader.decode()
+/// Loads a PNG image from memory to frames of [RgbaImage]
+fn load_png_image_from_memory(png_data: &[u8]) -> Result<Vec<RgbaImage>, image::ImageError> {
+    let decoder = PngDecoder::new(png_data)?;
+    if decoder.is_apng() {
+        decoder
+            .apng()
+            .into_frames()
+            .map(|f| f.map(|f| f.into_buffer()))
+            .collect()
+    } else {
+        DynamicImage::from_decoder(decoder).map(|i| vec![i.into_rgba8()])
+    }
 }
 
 /// Compares images pixel by pixel for equivalent content
-fn images_equal(old_png: &DynamicImage, new_png: &DynamicImage) -> bool {
+fn images_equal(old_png: &RgbaImage, new_png: &RgbaImage) -> bool {
     let a = old_png.pixels().filter(|x| {
-        let p = x.2.channels();
+        let p = x.channels();
         !(p.len() == 4 && p[3] == 0)
     });
     let b = new_png.pixels().filter(|x| {
-        let p = x.2.channels();
+        let p = x.channels();
         !(p.len() == 4 && p[3] == 0)
     });
     a.eq(b)

tests/lib.rs

@@ -30,7 +30,7 @@ fn optimize_from_memory_apng() {
     in_file.read_to_end(&mut in_file_buf).unwrap();
 
     let result = oxipng::optimize_from_memory(&in_file_buf, &Options::default());
-    assert!(result.is_err());
+    assert!(result.is_ok());
 }
 
 #[test]
@@ -58,9 +58,9 @@ fn optimize_apng() {
     let result = oxipng::optimize(
         &"tests/files/apng_file.png".into(),
         &OutFile::Path(None),
-        &Options::default(),
+        &Options::from_preset(0),
     );
-    assert!(result.is_err());
+    assert!(result.is_ok());
 }
 
 #[test]