Merge remote-tracking branch 'origin/master' into version-0.13

Author: 197g

.github/workflows/rust.yml

@@ -17,9 +17,14 @@ jobs:
       with:
         toolchain: ${{ matrix.rust }}
         override: true
+        components: clippy
     - name: build
       run: >
         cargo build --verbose --no-default-features --features "$FEATURES"
+    - name: clippy
+      run: >
+        cargo clippy --verbose --all-targets --no-default-features --features "$FEATURES"
+      if: ${{ matrix.rust == 'stable' }}
     - name: test
       run: >
         cargo test --tests --benches --no-default-features --features "$FEATURES"
@@ -29,7 +34,6 @@ jobs:
   rustfmt:
     runs-on: ubuntu-latest
     continue-on-error: false
-    if: false
     steps:
     - uses: actions/checkout@v2
     - uses: actions-rs/toolchain@v1

Cargo.toml

@@ -43,3 +43,15 @@ required-features = ["std"]
 name = "rgb_frame"
 harness = false
 required-features = ["std", "color_quant"]
+
+[[example]]
+name = "check"
+required-features = ["std"]
+
+[[example]]
+name = "explode"
+required-features = ["std"]
+
+[[example]]
+name = "parallel"
+required-features = ["std"]

benches/decode.rs

@@ -1,17 +1,20 @@
-use criterion::{black_box, BenchmarkId, BenchmarkGroup, Criterion, Throughput, measurement::Measurement};
+use criterion::{
+    black_box, measurement::Measurement, BenchmarkGroup, BenchmarkId, Criterion, Throughput,
+};
 use gif::Decoder;
 
 fn read_image(image: &[u8]) -> Option<Vec<u8>> {
     let decoder = Decoder::new(black_box(image));
     //decoder.set_param(gif::ColorOutput::RGBA);
     let mut reader = decoder.unwrap();
 
-    while reader.next_frame_info().unwrap().is_some() {
+    if reader.next_frame_info().unwrap().is_some() {
         let mut v = vec![0; reader.buffer_size()];
         reader.fill_buffer(&mut v).unwrap();
-        return Some(v);
+        Some(v)
+    } else {
+        None
     }
-    None
 }
 
 fn read_metadata(image: &[u8]) {
@@ -42,38 +45,49 @@ fn main() {
     let mut c = Criterion::default().configure_from_args();
     let mut group = c.benchmark_group("gif");
 
-    run_bench_def(&mut group, BenchDef {
-        data: include_bytes!("note.gif"),
-        id: "note.gif",
-        sample_size: 100,
-    });
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: include_bytes!("note.gif"),
+            id: "note.gif",
+            sample_size: 100,
+        },
+    );
 
-    run_bench_def(&mut group, BenchDef {
-        data: include_bytes!("photo.gif"),
-        id: "photo.gif",
-        sample_size: 20,
-    });
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: include_bytes!("photo.gif"),
+            id: "photo.gif",
+            sample_size: 20,
+        },
+    );
 
-    run_bench_def(&mut group, BenchDef {
-        data: include_bytes!("../tests/samples/sample_1.gif"),
-        id: "sample_1.gif",
-        sample_size: 100,
-    });
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: include_bytes!("../tests/samples/sample_1.gif"),
+            id: "sample_1.gif",
+            sample_size: 100,
+        },
+    );
 
-    run_bench_def(&mut group, BenchDef {
-        data: include_bytes!("../tests/samples/sample_big.gif"),
-        id: "sample_big.gif",
-        sample_size: 20,
-    });
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: include_bytes!("../tests/samples/sample_big.gif"),
+            id: "sample_big.gif",
+            sample_size: 20,
+        },
+    );
 
-    group
-        .bench_with_input(
-            "extract-metadata-note",
-            include_bytes!("note.gif"),
-            |b, input| {
-                b.iter(|| read_metadata(input));
-            }
-        );
+    group.bench_with_input(
+        "extract-metadata-note",
+        include_bytes!("note.gif"),
+        |b, input| {
+            b.iter(|| read_metadata(input));
+        },
+    );
 
     group.finish();
 

benches/rgb_frame.rs

@@ -35,20 +35,18 @@ fn main() {
         group
             .sample_size(50)
             .throughput(Throughput::Bytes(size as u64))
-            .bench_function(path.file_name().unwrap().to_str().unwrap(),
-                |b| {
-                match info.color_type {
-                    png::ColorType::Rgb => b.iter(|| {
-                        Frame::from_rgb_speed(w, h, &mut buf[..size], 30)
-                    }),
-                    png::ColorType::Rgba => b.iter(|| {
-                        Frame::from_rgba_speed(w, h, &mut buf[..size], 30)
-                    }),
+            .bench_function(
+                path.file_name().unwrap().to_str().unwrap(),
+                |b| match info.color_type {
+                    png::ColorType::Rgb => b.iter(|| Frame::from_rgb_speed(w, h, &buf[..size], 30)),
+                    png::ColorType::Rgba => {
+                        b.iter(|| Frame::from_rgba_speed(w, h, &mut buf[..size], 30))
+                    }
                     c => {
                         println!("Image has wrong color type: {c:?}");
                     }
-                }
-            });
+                },
+            );
 
         // actually write the image as a singe frame gif... while MSE can be used
         // for quality check, it might not be as good as visual inspection
@@ -60,7 +58,7 @@ fn main() {
 
         let frame = match info.color_type {
             png::ColorType::Rgb => Frame::from_rgb(w, h, &buf[..size]),
-            png::ColorType::Rgba => Frame::from_rgba(w, h, &buf[..size]),
+            png::ColorType::Rgba => Frame::from_rgba(w, h, &mut buf[..size]),
             _ => continue,
         };
 

clippy.toml

@@ -0,0 +1,2 @@
+# Note: Ensure this matches the value in Cargo.toml and in CI
+msrv = "1.62.0"

examples/check.rs

@@ -1,10 +1,8 @@
 use std::{env, fs, process};
 
 fn main() {
-    let file = env::args().nth(1)
-        .unwrap_or_else(|| explain_usage());
-    let file = fs::File::open(file)
-        .expect("failed to open input file");
+    let file = env::args().nth(1).unwrap_or_else(|| explain_usage());
+    let file = fs::File::open(file).expect("failed to open input file");
     let mut reader = {
         let mut options = gif::DecodeOptions::new();
         options.allow_unknown_blocks(true);
@@ -28,7 +26,10 @@ fn main() {
                  dispose: {:?}\n  \
                  needs_input: {:?}",
             frame.delay,
-            frame.width, frame.height, frame.left, frame.top,
+            frame.width,
+            frame.height,
+            frame.left,
+            frame.top,
             frame.dispose,
             frame.needs_user_input
         );

examples/parallel.rs

@@ -40,17 +40,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let (send, recv) = std::sync::mpsc::channel();
 
-    decoder.into_iter().enumerate().par_bridge().try_for_each(move |(frame_number, frame)| {
-        let mut frame = frame?;
-        FrameDecoder::new(DecodeOptions::new())
-            .decode_lzw_encoded_frame(&mut frame)
-            .unwrap();
-        // frame is now pixels
-        frame.make_lzw_pre_encoded();
-        // frame is now LZW again, re-encoded
-        send.send((frame_number, frame)).unwrap();
-        Ok::<_, gif::DecodingError>(())
-    })?;
+    decoder
+        .into_iter()
+        .enumerate()
+        .par_bridge()
+        .try_for_each(move |(frame_number, frame)| {
+            let mut frame = frame?;
+            FrameDecoder::new(DecodeOptions::new())
+                .decode_lzw_encoded_frame(&mut frame)
+                .unwrap();
+            // frame is now pixels
+            frame.make_lzw_pre_encoded();
+            // frame is now LZW again, re-encoded
+            send.send((frame_number, frame)).unwrap();
+            Ok::<_, gif::DecodingError>(())
+        })?;
 
     // Decoding and encoding can happen in parallel, but writing to the GIF file is sequential
     let mut next_frame_number = 0;
@@ -59,7 +63,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // frames can arrive in any order, since they're processed in parallel,
         // so they have to be stored in a queue
         frames_to_process.push((frame_number, frame));
-        while let Some(index) = frames_to_process.iter().position(|&(num, _)| num == next_frame_number) {
+        while let Some(index) = frames_to_process
+            .iter()
+            .position(|&(num, _)| num == next_frame_number)
+        {
             let frame = frames_to_process.remove(index).1;
             encoder.write_lzw_pre_encoded_frame(&frame)?;
             next_frame_number += 1;
@@ -70,6 +77,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let seconds = start.elapsed().as_millis() as f64 / 1000.;
     let rate = (input_size / 1024 / 1024) as f64 / seconds;
 
-    eprintln!("Finished in {seconds:0.2}s, {rate:0.0}MiB/s {}", if cfg!(debug_assertions) { ". Run with --release for more speed." } else { "" });
+    eprintln!(
+        "Finished in {seconds:0.2}s, {rate:0.0}MiB/s {}",
+        if cfg!(debug_assertions) {
+            ". Run with --release for more speed."
+        } else {
+            ""
+        }
+    );
     Ok(())
 }