Improved PNG reading to support 16-bit images (image-rs#92)

Author: RunDevelopment

tests/encode.rs

@@ -186,10 +186,8 @@ fn encode_dither() {
         Ok(hex)
     }
 
-    let base = util::read_png_u8(&get_sample("base.png")).unwrap().to_f32();
-    let twirl = util::read_png_u8(&get_sample("color-twirl.png"))
-        .unwrap()
-        .to_f32();
+    let base = util::read_png_f32(&get_sample("base.png")).unwrap();
+    let twirl = util::read_png_f32(&get_sample("color-twirl.png")).unwrap();
 
     let ignore = [Format::BC4_SNORM, Format::BC5_UNORM, Format::BC5_SNORM];
 
@@ -250,7 +248,7 @@ fn encode_measure_quality() {
             }
         }
         fn from_file(name: &str) -> Self {
-            let image = util::read_png_u8(&get_sample(name)).unwrap().to_f32();
+            let image = util::read_png_f32(&get_sample(name)).unwrap();
 
             Self {
                 name: name.to_string(),

tests/util/image.rs

@@ -128,6 +128,25 @@ impl Image<u8> {
         )
     }
 }
+impl Image<u16> {
+    pub fn to_u8(&self) -> Image<u8> {
+        Image::new(
+            self.data
+                .iter()
+                .map(|&x| ((x as u32 + 257 / 2) / 257) as u8)
+                .collect(),
+            self.channels,
+            self.size,
+        )
+    }
+    pub fn to_f32(&self) -> Image<f32> {
+        Image::new(
+            self.data.iter().map(|&x| x as f32 / 65535.0).collect(),
+            self.channels,
+            self.size,
+        )
+    }
+}
 
 pub trait WithPrecision {
     const PRECISION: Precision;

tests/util/mod.rs

@@ -312,30 +312,53 @@ pub fn to_png_compatible_channels(channels: Channels) -> (Channels, png::ColorTy
     }
 }
 
-pub fn read_png_u8(png_path: &Path) -> Result<Image<u8>, Box<dyn std::error::Error>> {
+pub fn read_png_u16(png_path: &Path) -> Result<Image<u16>, Box<dyn std::error::Error>> {
     let png_decoder = png::Decoder::new(File::open(png_path)?);
     let mut png_reader = png_decoder.read_info()?;
     let (color, bits) = png_reader.output_color_type();
 
-    if bits != png::BitDepth::Eight {
-        return Err("Output PNG is not 8-bit, which shouldn't happen.".into());
-    }
     let channels = match color {
         png::ColorType::Grayscale => Channels::Grayscale,
         png::ColorType::Rgb => Channels::Rgb,
         png::ColorType::Rgba => Channels::Rgba,
         _ => return Err("Unsupported PNG color type".into()),
     };
 
-    let mut png_image_data = vec![0; png_reader.output_buffer_size()];
-    png_reader.next_frame(&mut png_image_data)?;
-    png_reader.finish()?;
+    match bits {
+        png::BitDepth::Sixteen => {
+            let mut png_image_data: Vec<u16> = vec![0; png_reader.output_buffer_size() / 2];
+            png_reader.next_frame(cast_slice_mut(&mut png_image_data))?;
+            png_reader.finish()?;
+
+            png_image_data.iter_mut().for_each(|v| *v = v.to_be());
 
-    Ok(Image::new(
-        png_image_data,
-        channels,
-        Size::new(png_reader.info().width, png_reader.info().height),
-    ))
+            Ok(Image::new(
+                png_image_data,
+                channels,
+                Size::new(png_reader.info().width, png_reader.info().height),
+            ))
+        }
+        png::BitDepth::Eight => {
+            let mut png_image_data = vec![0; png_reader.output_buffer_size()];
+            png_reader.next_frame(&mut png_image_data)?;
+            png_reader.finish()?;
+
+            let image_u8 = Image::new(
+                png_image_data,
+                channels,
+                Size::new(png_reader.info().width, png_reader.info().height),
+            );
+
+            Ok(image_u8.to_u16())
+        }
+        _ => Err("Output PNG is not 8/16-bit, which shouldn't happen.".into()),
+    }
+}
+pub fn read_png_u8(png_path: &Path) -> Result<Image<u8>, Box<dyn std::error::Error>> {
+    Ok(read_png_u16(png_path)?.to_u8())
+}
+pub fn read_png_f32(png_path: &Path) -> Result<Image<f32>, Box<dyn std::error::Error>> {
+    Ok(read_png_u16(png_path)?.to_f32())
 }
 
 pub fn write_simple_dds_header(