| 1 |
#![feature(slice_split_once)] |
| 2 |
|
| 3 |
use fax::{VecWriter, decoder, decoder::pels, BitWriter, Bits, Color}; |
| 4 |
use std::io::Write; |
| 5 |
use std::fs::{self, File}; |
| 6 |
|
| 7 |
fn main() { |
| 8 |
let mut args = std::env::args().skip(1); |
| 9 |
let input: String = args.next().unwrap(); |
| 10 |
let reference = args.next().unwrap(); |
| 11 |
|
| 12 |
let ref_data = std::fs::read(&reference).unwrap(); |
| 13 |
let (header1, data) = ref_data.split_once(|&b| b == b'\n').unwrap(); |
| 14 |
assert_eq!(header1, b"P4"); |
| 15 |
let (header2, ref_image) = data.split_once(|&b| b == b'\n').unwrap(); |
| 16 |
let header2 = std::str::from_utf8(header2).unwrap(); |
| 17 |
dbg!(header2); |
| 18 |
let (w, h) = header2.split_once(" ").unwrap(); |
| 19 |
let width: u16 = w.parse().unwrap(); |
| 20 |
let h: u16 = h.parse().unwrap(); |
| 21 |
|
| 22 |
let mut ref_lines = ref_image.chunks_exact((width as usize + 7) / 8); |
| 23 |
|
| 24 |
let data; |
| 25 |
let inverted; |
| 26 |
if input.ends_with(".tiff") { |
| 27 |
use tiff::{decoder::Decoder, tags::Tag}; |
| 28 |
let tiff = std::fs::read(&input).unwrap(); |
| 29 |
let reader = std::io::Cursor::new(tiff.as_slice()); |
| 30 |
let mut decoder = Decoder::new(reader).unwrap(); |
| 31 |
let (w, h) = decoder.chunk_dimensions(); |
| 32 |
let mut buf = vec![0; w as usize * h as usize]; |
| 33 |
let strip_offset = decoder.get_tag(Tag::StripOffsets).unwrap().into_u32().unwrap() as usize; |
| 34 |
let strip_bytes = decoder.get_tag(Tag::StripByteCounts).unwrap().into_u32().unwrap() as usize; |
| 35 |
|
| 36 |
let interpr = decoder.get_tag(Tag::PhotometricInterpretation).unwrap().into_u16().unwrap(); |
| 37 |
|
| 38 |
data = tiff[strip_offset .. strip_offset + strip_bytes].to_vec(); |
| 39 |
inverted = interpr != 0; |
| 40 |
} else { |
| 41 |
data = fs::read(&input).unwrap(); |
| 42 |
inverted = false; |
| 43 |
} |
| 44 |
let mut height = 0; |
| 45 |
let (black, white) = match inverted { |
| 46 |
false => (Bits { data: 1, len: 1 }, Bits { data: 0, len: 1 }), |
| 47 |
true => (Bits { data: 0, len: 1 }, Bits { data: 1, len: 1 }) |
| 48 |
}; |
| 49 |
decoder::decode_g4(data.iter().cloned(), width, None, |transitions| { |
| 50 |
let mut writer = VecWriter::new(); |
| 51 |
for c in pels(transitions, width) { |
| 52 |
let bit = match c { |
| 53 |
Color::Black => black, |
| 54 |
Color::White => white, |
| 55 |
}; |
| 56 |
writer.write(bit); |
| 57 |
} |
| 58 |
writer.pad(); |
| 59 |
let data = writer.finish(); |
| 60 |
let ref_line = ref_lines.next().unwrap(); |
| 61 |
println!("{height:3} dec: {}", Line(&data)); |
| 62 |
if ref_line != data { |
| 63 |
println!(" ref: {}", Line(ref_line)); |
| 64 |
'a: for (byte, (&r, &v)) in ref_line.iter().zip(data.iter()).enumerate() { |
| 65 |
if r != v { |
| 66 |
for i in (0 .. 8).rev() { |
| 67 |
if r & (1 << i) != v & (1 << i) { |
| 68 |
println!("mismatch at pos {}", (8 * byte) + 7-i); |
| 69 |
break 'a; |
| 70 |
} |
| 71 |
} |
| 72 |
} |
| 73 |
} |
| 74 |
panic!("decode error"); |
| 75 |
} |
| 76 |
height += 1; |
| 77 |
}); |
| 78 |
} |
| 79 |
|
| 80 |
struct Line<'a>(&'a [u8]); |
| 81 |
impl<'a> std::fmt::Display for Line<'a> { |
| 82 |
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| 83 |
let codes = [' ', '▐', '▌', '█']; |
| 84 |
for b in self.0.iter().flat_map(|b| [b >> 6, (b >> 4) & 3, (b >>2) & 3, b & 3]) { |
| 85 |
write!(f, "{}", codes[b as usize])?; |
| 86 |
} |
| 87 |
Ok(()) |
| 88 |
} |
| 89 |
} |