Merge branch 'master' into docs/repology-packaging-status

.github/workflows/oxipng.yml

@@ -49,9 +49,9 @@ jobs:
  - target: i686-pc-windows-msvc
  os: windows-latest
  - target: x86_64-apple-darwin
- os: macos-latest
+ os: macos-12
  - target: aarch64-apple-darwin
- os: macos-latest
+ os: macos-14 # ARM64 runner
 
  env:
  CARGO_BUILD_TARGET: ${{ matrix.target }}
@@ -122,19 +122,11 @@ jobs:
  reporter: github-check
  fail_on_error: true
 
- # There aren't good user-mode ARM64 emulators we can use on x64 macOS hosts.
- # QEMU doesn't have any plans to add such support due to a lack of kernel
- # syscall stability guarantees: https://gitlab.com/qemu-project/qemu/-/issues/1682
  - name: Run tests
- if: matrix.target != 'aarch64-apple-darwin'
  run: |
  cargo nextest run --release --features sanity-checks
  cargo test --doc --release --features sanity-checks
 
- - name: Build tests (ARM64 macOS only)
- if: matrix.target == 'aarch64-apple-darwin'
- run: cargo test --release --features sanity-checks --no-run
-
  - name: Build benchmarks
  run: cargo bench --no-run
 

src/png/scan_lines.rs

@@ -24,20 +24,26 @@ impl<'a> Iterator for ScanLines<'a> {
  type Item = ScanLine<'a>;
  #[inline]
  fn next(&mut self) -> Option<Self::Item> {
- self.iter.next().map(|(len, pass, num_pixels)| {
- let (data, rest) = self.raw_data.split_at(len);
- self.raw_data = rest;
- let (&filter, data) = if self.has_filter {
- data.split_first().unwrap()
- } else {
- (&0, data)
- };
- ScanLine {
- filter,
- data,
- pass,
- num_pixels,
- }
+ let (len, pass, num_pixels) = self.iter.next()?;
+ debug_assert!(self.raw_data.len() >= len);
+ debug_assert!(!self.has_filter || len > 1);
+ // The data length should always be correct here but this check assures
+ // the compiler that it doesn't need to account for a potential panic
+ if self.raw_data.len() < len {
+ return None;
+ }
+ let (data, rest) = self.raw_data.split_at(len);
+ self.raw_data = rest;
+ let (&filter, data) = if self.has_filter {
+ data.split_first().unwrap()
+ } else {
+ (&0, data)
+ };
+ Some(ScanLine {
+ filter,
+ data,
+ pass,
+ num_pixels,
  })
  }
 }

src/reduction/palette.rs

@@ -14,9 +14,8 @@ pub fn reduced_palette(png: &PngImage, optimize_alpha: bool) -> Option<PngImage>
  if png.ihdr.bit_depth != BitDepth::Eight {
  return None;
  }
- let palette = match &png.ihdr.color_type {
- ColorType::Indexed { palette } if palette.len() > 1 => palette,
- _ => return None,
+ let ColorType::Indexed { palette } = &png.ihdr.color_type else {
+ return None;
  };
 
  let mut used = [false; 256];
@@ -43,8 +42,9 @@ pub fn reduced_palette(png: &PngImage, optimize_alpha: bool) -> Option<PngImage>
  let data = if did_change {
  // Reassign data bytes to new indices
  png.data.iter().map(|b| byte_map[*b as usize]).collect()
- } else if condensed.len() < palette.len() {
- // Data is unchanged but palette will be truncated
+ } else if condensed.len() != palette.len() {
+ // Data is unchanged but palette is different size
+ // Note the new palette could potentially be larger if the original had a missing entry
  png.data.clone()
  } else {
  // Nothing has changed
@@ -183,23 +183,36 @@ pub fn sorted_palette_battiato(png: &PngImage) -> Option<PngImage> {
 
 // Find the most popular color on the image edges (the pixels neighboring the filter bytes)
 fn most_popular_edge_color(num_colors: usize, png: &PngImage) -> usize {
- let mut counts = vec![0; num_colors];
+ let mut counts = [0u32; 256];
  for line in png.scan_lines(false) {
- counts[line.data[0] as usize] += 1;
- counts[line.data[line.data.len() - 1] as usize] += 1;
+ if let &[first, .., last] = line.data {
+ counts[first as usize] += 1;
+ counts[last as usize] += 1;
+ }
  }
- counts.iter().enumerate().max_by_key(|(_, &v)| v).unwrap().0
+ counts
+ .iter()
+ .copied()
+ .take(num_colors)
+ .enumerate()
+ .max_by_key(|&(_, v)| v)
+ .unwrap_or_default()
+ .0
 }
 
 // Calculate co-occurences matrix
-fn co_occurrence_matrix(num_colors: usize, png: &PngImage) -> Vec<Vec<usize>> {
- let mut matrix = vec![vec![0; num_colors]; num_colors];
+fn co_occurrence_matrix(num_colors: usize, png: &PngImage) -> Vec<Vec<u32>> {
+ let mut matrix = vec![vec![0u32; num_colors]; num_colors];
  let mut prev: Option<ScanLine> = None;
+ let mut prev_val = None;
  for line in png.scan_lines(false) {
  for i in 0..line.data.len() {
  let val = line.data[i] as usize;
- if i > 0 {
- matrix[line.data[i - 1] as usize][val] += 1;
+ if val > num_colors {
+ continue;
+ }
+ if let Some(prev_val) = prev_val.replace(val) {
+ matrix[prev_val][val] += 1;
  }
  if let Some(prev) = &prev {
  matrix[prev.data[i] as usize][val] += 1;
@@ -211,7 +224,7 @@ fn co_occurrence_matrix(num_colors: usize, png: &PngImage) -> Vec<Vec<usize>> {
 }
 
 // Calculate edge list sorted by weight
-fn weighted_edges(matrix: &[Vec<usize>]) -> Vec<(usize, usize)> {
+fn weighted_edges(matrix: &[Vec<u32>]) -> Vec<(usize, usize)> {
  let mut edges = Vec::new();
  for i in 0..matrix.len() {
  for j in 0..i {

tests/reduction.rs

@@ -1049,6 +1049,43 @@ fn palette_should_be_reduced_with_both() {
  remove_file(output).ok();
 }
 
+#[test]
+fn palette_should_be_reduced_with_missing() {
+ let input = PathBuf::from("tests/files/palette_should_be_reduced_with_missing.png");
+ let (output, opts) = get_opts(&input);
+
+ let png = PngData::new(&input, &opts).unwrap();
+
+ assert_eq!(png.raw.ihdr.color_type.png_header_code(), INDEXED);
+ assert_eq!(png.raw.ihdr.bit_depth, BitDepth::Eight);
+ if let ColorType::Indexed { palette } = &png.raw.ihdr.color_type {
+ assert_eq!(palette.len(), 2);
+ }
+
+ match oxipng::optimize(&InFile::Path(input), &output, &opts) {
+ Ok(_) => (),
+ Err(x) => panic!("{}", x),
+ };
+ let output = output.path().unwrap();
+ assert!(output.exists());
+
+ let png = match PngData::new(output, &opts) {
+ Ok(x) => x,
+ Err(x) => {
+ remove_file(output).ok();
+ panic!("{}", x)
+ }
+ };
+
+ assert_eq!(png.raw.ihdr.color_type.png_header_code(), INDEXED);
+ assert_eq!(png.raw.ihdr.bit_depth, BitDepth::Two);
+ if let ColorType::Indexed { palette } = &png.raw.ihdr.color_type {
+ assert_eq!(palette.len(), 3);
+ }
+
+ remove_file(output).ok();
+}
+
 #[test]
 fn rgba_16_reduce_alpha() {
  test_it_converts(